function adcs_dissector(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3,data2)

if data2 == 32  then
      require("adcs_dissector")
      adcs_dissector_32(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)

elseif data2 == 31 then
      require("adcs_dissector")
      adcs_dissector_31(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)  
elseif data2 == 30 then
      require("adcs_dissector")
      adcs_dissector_30(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)  
elseif data2 == 29 then
      require("adcs_dissector")
      adcs_dissector_29(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 28 then
      require("adcs_dissector")
      adcs_dissector_28(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)  
elseif data2 == 27 then
      require("adcs_dissector")
      adcs_dissector_27(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3) 
elseif data2 == 26 then
      require("adcs_dissector")
      adcs_dissector_26(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3) 
elseif data2 == 25 then
      require("adcs_dissector")
      adcs_dissector_25(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3) 
elseif data2 == 24 then
      require("adcs_dissector")
      adcs_dissector_24(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 23 then
      require("adcs_dissector")
      adcs_dissector_23(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 22 then
      require("adcs_dissector")
      adcs_dissector_22(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 21 then
      require("adcs_dissector")
      adcs_dissector_21(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 20 then
      require("adcs_dissector")
      adcs_dissector_20(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 19 then
      require("adcs_dissector")
      adcs_dissector_19(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 18  then
      require("adcs_dissector")
      adcs_dissector_18(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 17  then
      require("adcs_dissector")
      adcs_dissector_17(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 16  then
      require("adcs_dissector")
      adcs_dissector_16(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
     
elseif data2 == 15 then
      require("adcs_dissector")
      adcs_dissector_15(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 14 then
      require("adcs_dissector")
      adcs_dissector_14(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
--elseif data2 == 13 then
  --    require("adcs_dissector")
   --   adcs_dissector_13(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 12 then
      require("adcs_dissector")
      adcs_dissector_12(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)
elseif data2 == 11 then
      require("adcs_dissector")
      adcs_dissector_11(buffer, pinfo, tree, TC_TM_PROTOCOL, offset, tm_len,data3)


else

end
end
------------------------------------------------------------------------------------------------------------------------------
function adcs_dissector_32(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)
    -- Define ProtoFields for each field in the structure
    local f_op_status = ProtoField.uint8("OperationData.op_status", "Operation Status", base.DEC)
    local f_epoch_time = ProtoField.uint32("OperationData.epoch_time", "Epoch Time", base.DEC)
    local f_eci_x_velocity = ProtoField.int16("OperationData.eci_x_velocity", "ECI Referenced X Velocity", base.DEC)
    local f_eci_y_velocity = ProtoField.int16("OperationData.eci_y_velocity", "ECI Referenced Y Velocity", base.DEC)
    local f_eci_z_velocity = ProtoField.int16("OperationData.eci_z_velocity", "ECI Referenced Z Velocity", base.DEC)

    -- Add the fields to the protocol
    HM_TM_dissector.fields = {
        f_op_status, f_epoch_time, f_eci_x_velocity, f_eci_y_velocity, f_eci_z_velocity
    }
for i = 1, data3 do
    -- Add the operation data subtree
    local subtree = tree:add(HM_TM_PROTOCOL, buffer(), "adcs_qid_32")

    -- dissect operation status (1 byte, UINT)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes, UINT)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect ECI X velocity (2 bytes, INT)
    local eci_x_velocity = buffer(offset, 2):le_int()
    subtree:add(f_eci_x_velocity, eci_x_velocity)
    offset = offset + 2

    -- dissect ECI Y velocity (2 bytes, INT)
    local eci_y_velocity = buffer(offset, 2):le_int()
    subtree:add(f_eci_y_velocity, eci_y_velocity)
    offset = offset + 2

    -- dissect ECI Z velocity (2 bytes, INT)
    local eci_z_velocity = buffer(offset, 2):le_int()
    subtree:add(f_eci_z_velocity, eci_z_velocity)
    offset = offset + 2
end
end
--------------------------------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the Nadir Sensor Data





function adcs_dissector_18(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)


-- Define ProtoFields for the Nadir Sensor Data structure
local f_op_status = ProtoField.uint8("NadirSensorData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("NadirSensorData.epoch_time", "Epoch Time", base.DES)
local f_x_angle = ProtoField.int16("NadirSensorData.x_angle", "Nadir Sensor Raw X Angle", base.DEC)
local f_y_angle = ProtoField.int16("NadirSensorData.y_angle", "Nadir Sensor Raw Y Angle", base.DEC)

-- Define the ProtoFields for the ENUM values (Capture Status and Detection Result)
local f_capture_status = ProtoField.uint8("NadirSensorData.capture_status", "Nadir Sensor Capture Status", base.HEX)
local f_detection_result = ProtoField.uint8("NadirSensorData.detection_result", "Nadir Sensor Detection Result", base.HEX)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_angle, f_y_angle, f_capture_status, f_detection_result
}
    -- Add the Nadir Sensor data as a subtree
for i = 1, data3 do
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adc_qid_18")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect nadir sensor raw X angle (2 bytes)
    local x_angle = buffer(offset, 2):le_int()
    subtree:add(f_x_angle, x_angle)
    offset = offset + 2

    -- dissect nadir sensor raw Y angle (2 bytes)
    local y_angle = buffer(offset, 2):le_int()
    subtree:add(f_y_angle, y_angle)
    offset = offset + 2

    -- dissect nadir sensor capture status (1 byte - ENUM)
    local capture_status = buffer(offset, 1):le_uint()
    subtree:add(f_capture_status, capture_status)
    offset = offset + 1

    -- dissect nadir sensor detection result (1 byte - ENUM)
    local detection_result = buffer(offset, 1):le_uint()
    subtree:add(f_detection_result, detection_result)
    offset = offset + 1
end
end
-------------------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the Nadir Vector Data
function adcs_dissector_16(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)


-- Define ProtoFields for the Nadir Vector Data structure
local f_op_status = ProtoField.uint8("NadirVectorData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("NadirVectorData.epoch_time", "Epoch Time", base.DES)
local f_x_nadir = ProtoField.uint16("NadirVectorData.x_nadir", "X axis Nadir Vector (formatted)", base.DEC)
local f_y_nadir = ProtoField.uint16("NadirVectorData.y_nadir", "Y axis Nadir Vector (formatted)", base.DEC)
local f_z_nadir = ProtoField.uint16("NadirVectorData.z_nadir", "Z axis Nadir Vector (formatted)", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_nadir, f_y_nadir, f_z_nadir
}

for i = 1, data3 do

    -- Add the Nadir Vector data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_16")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect X axis Nadir vector (2 bytes)
    local x_nadir = buffer(offset, 2):le_uint()
    subtree:add(f_x_nadir, x_nadir)  -- Apply the scaling factor (RAWVAL * 0.001)
    offset = offset + 2

    -- dissect Y axis Nadir vector (2 bytes)
    local y_nadir = buffer(offset, 2):le_uint()
    subtree:add(f_y_nadir, y_nadir)  -- Apply the scaling factor (RAWVAL * 0.001)
    offset = offset + 2

    -- dissect Z axis Nadir vector (2 bytes)
    local z_nadir = buffer(offset, 2):le_uint()
    subtree:add(f_z_nadir, z_nadir )  -- Apply the scaling factor (RAWVAL * 0.001)
    offset = offset + 2
end
end
---------------------------------------------------------------------------------------------


-- Define the dissector function for the Magnetic Field Vector Data
function adcs_dissector_15(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the Magnetic Field Vector Data structure
local f_op_status = ProtoField.uint8("MagneticFieldVectorData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("MagneticFieldVectorData.epoch_time", "Epoch Time", base.DES)
local f_x_mag = ProtoField.int16("MagneticFieldVectorData.x_mag", "X axis Magnetic Field Vector (formatted)", base.DEC)
local f_y_mag = ProtoField.int16("MagneticFieldVectorData.y_mag", "Y axis Magnetic Field Vector (formatted)", base.DEC)
local f_z_mag = ProtoField.int16("MagneticFieldVectorData.z_mag", "Z axis Magnetic Field Vector (formatted)", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_mag, f_y_mag, f_z_mag
}
for i = 1, data3 do
    -- Add the Magnetic Field Vector data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_15")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect X axis magnetic field vector (2 bytes)
    local x_mag = buffer(offset, 2):le_int()
    subtree:add(f_x_mag, x_mag )  -- Apply the scaling factor (RAWVAL * 0.01)
    offset = offset + 2

    -- dissect Y axis magnetic field vector (2 bytes)
    local y_mag = buffer(offset, 2):le_int()
    subtree:add(f_y_mag, y_mag )  -- Apply the scaling factor (RAWVAL * 0.01)
    offset = offset + 2

    -- dissect Z axis magnetic field vector (2 bytes)
    local z_mag = buffer(offset, 2):le_int()
    subtree:add(f_z_mag, z_mag )  -- Apply the scaling factor (RAWVAL * 0.01)
    offset = offset + 2
end
end
----------------------------------------------------------------------------------------------------------------
function adcs_dissector_31(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)
    -- Define ProtoFields for each field in the structure
    local f_op_status = ProtoField.uint8("OperationCoordinates.op_status", "Operation Status", base.DEC)
    local f_epoch_time = ProtoField.uint32("OperationCoordinates.epoch_time", "Epoch Time", base.DEC)
    local f_eci_x_coord = ProtoField.int16("OperationCoordinates.eci_x_coord", "ECI Referenced X Coordinate", base.DEC)
    local f_eci_y_coord = ProtoField.int16("OperationCoordinates.eci_y_coord", "ECI Referenced Y Coordinate", base.DEC)
    local f_eci_z_coord = ProtoField.int16("OperationCoordinates.eci_z_coord", "ECI Referenced Z Coordinate", base.DEC)

    -- Add the fields to the protocol
    HM_TM_dissector.fields = {
        f_op_status, f_epoch_time, f_eci_x_coord, f_eci_y_coord, f_eci_z_coord
    }
	for i = 1, data3 do
    -- Add the operation data coordinates subtree
    local subtree = tree:add(HM_TM_PROTOCOL, buffer(), "adcs_qid_31")

    -- dissect operation status (1 byte, UINT)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes, UINT)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect ECI X coordinate (2 bytes, INT)
    local eci_x_coord = buffer(offset, 2):le_int()
    subtree:add(f_eci_x_coord, eci_x_coord)
    offset = offset + 2

    -- dissect ECI Y coordinate (2 bytes, INT)
    local eci_y_coord = buffer(offset, 2):le_int()
    subtree:add(f_eci_y_coord, eci_y_coord)
    offset = offset + 2

    -- dissect ECI Z coordinate (2 bytes, INT)
    local eci_z_coord = buffer(offset, 2):le_int()
    subtree:add(f_eci_z_coord, eci_z_coord)
    offset = offset + 2
end
end
-------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure
function adcs_dissector_30(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)


-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_x_coord = ProtoField.int16("PowerSystemData.x_coord", "ECEF X Coordinate", base.DEC)
local f_y_coord = ProtoField.int16("PowerSystemData.y_coord", "ECEF Y Coordinate", base.DEC)
local f_z_coord = ProtoField.int16("PowerSystemData.z_coord", "ECEF Z Coordinate", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_x_coord, f_y_coord, f_z_coord
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_30")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect ECEF X coordinate (2 bytes)
        local x_coord = buffer(offset, 2):le_int()
        subtree:add(f_x_coord, x_coord)
        offset = offset + 2

        -- dissect ECEF Y coordinate (2 bytes)
        local y_coord = buffer(offset, 2):le_int()
        subtree:add(f_y_coord, y_coord)
        offset = offset + 2

        -- dissect ECEF Z coordinate (2 bytes)
        local z_coord = buffer(offset, 2):le_int()
        subtree:add(f_z_coord, z_coord)
        offset = offset + 2
    end
end
----------------------------------------------------------------------------------------------------------------------------------



-- Define the dissector function for the new structure
function adcs_dissector_29(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_roll_angle = ProtoField.int16("PowerSystemData.roll_angle", "Commanded Roll Angle (degrees)", base.DEC)
local f_pitch_angle = ProtoField.int16("PowerSystemData.pitch_angle", "Commanded Pitch Angle (degrees)", base.DEC)
local f_yaw_angle = ProtoField.int16("PowerSystemData.yaw_angle", "Commanded Yaw Angle (degrees)", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_roll_angle, f_pitch_angle, f_yaw_angle
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
   for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_29")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect commanded roll angle (2 bytes)
        local roll_angle_raw = buffer(offset, 2):le_int()
        local roll_angle = roll_angle_raw * 0.01  -- Apply scaling factor
        subtree:add(f_roll_angle, roll_angle)
        offset = offset + 2

        -- dissect commanded pitch angle (2 bytes)
        local pitch_angle_raw = buffer(offset, 2):le_int()
        local pitch_angle = pitch_angle_raw * 0.01  -- Apply scaling factor
        subtree:add(f_pitch_angle, pitch_angle)
        offset = offset + 2

        -- dissect commanded yaw angle (2 bytes)
        local yaw_angle_raw = buffer(offset, 2):le_int()
        local yaw_angle = yaw_angle_raw * 0.01  -- Apply scaling factor
        subtree:add(f_yaw_angle, yaw_angle)
        offset = offset + 2
   end 
end
----------------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure

function adcs_dissector_28(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)


-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_innovation_x = ProtoField.int16("PowerSystemData.innovation_x", "Innovation Vector X", base.DEC)
local f_innovation_y = ProtoField.int16("PowerSystemData.innovation_y", "Innovation Vector Y", base.DEC)
local f_innovation_z = ProtoField.int16("PowerSystemData.innovation_z", "Innovation Vector Z", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_innovation_x, f_innovation_y, f_innovation_z
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_28")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect innovation vector X (2 bytes)
        local innovation_x_raw = buffer(offset, 2):le_int()
        local innovation_x = innovation_x_raw * 0.001  -- Apply scaling factor
        subtree:add(f_innovation_x, innovation_x)
        offset = offset + 2

        -- dissect innovation vector Y (2 bytes)
        local innovation_y_raw = buffer(offset, 2):le_int()
        local innovation_y = innovation_y_raw * 0.001  -- Apply scaling factor
        subtree:add(f_innovation_y, innovation_y)
        offset = offset + 2

        -- dissect innovation vector Z (2 bytes)
        local innovation_z_raw = buffer(offset, 2):le_int()
        local innovation_z = innovation_z_raw * 0.001  -- Apply scaling factor
        subtree:add(f_innovation_z, innovation_z)
        offset = offset + 2
end    
end
---------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure
function adcs_dissector_27(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_x_gyro_bias = ProtoField.int16("PowerSystemData.x_gyro_bias", "Estimated X-Gyro Bias", base.DEC)
local f_y_gyro_bias = ProtoField.int16("PowerSystemData.y_gyro_bias", "Estimated Y-Gyro Bias", base.DEC)
local f_z_gyro_bias = ProtoField.int16("PowerSystemData.z_gyro_bias", "Estimated Z-Gyro Bias", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_x_gyro_bias, f_y_gyro_bias, f_z_gyro_bias
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_27")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect estimated x-gyro bias (2 bytes)
        local x_gyro_bias_raw = buffer(offset, 2):le_int()
        local x_gyro_bias = x_gyro_bias_raw * 0.001  -- Apply scaling factor
        subtree:add(f_x_gyro_bias, x_gyro_bias)
        offset = offset + 2

        -- dissect estimated y-gyro bias (2 bytes)
        local y_gyro_bias_raw = buffer(offset, 2):le_int()
        local y_gyro_bias = y_gyro_bias_raw * 0.001  -- Apply scaling factor
        subtree:add(f_y_gyro_bias, y_gyro_bias)
        offset = offset + 2

        -- dissect estimated z-gyro bias (2 bytes)
        local z_gyro_bias_raw = buffer(offset, 2):le_int()
        local z_gyro_bias = z_gyro_bias_raw * 0.001  -- Apply scaling factor
        subtree:add(f_z_gyro_bias, z_gyro_bias)
        offset = offset + 2
    end
end
----------------------------------------------------------------------------------------------------------------------

-- Define the dissector function for the new structure
function adcs_dissector_26(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_q1_error = ProtoField.int16("PowerSystemData.q1_error", "Quaternion Error - Q1", base.DEC)
local f_q2_error = ProtoField.int16("PowerSystemData.q2_error", "Quaternion Error - Q2", base.DEC)
local f_q3_error = ProtoField.int16("PowerSystemData.q3_error", "Quaternion Error - Q3", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_q1_error, f_q2_error, f_q3_error
}


    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_26")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect quaternion error Q1 (2 bytes)
        local q1_error_raw = buffer(offset, 2):le_int()
        local q1_error = q1_error_raw * 0.01  -- Apply scaling factor
        subtree:add(f_q1_error, q1_error)
        offset = offset + 2

        -- dissect quaternion error Q2 (2 bytes)
        local q2_error_raw = buffer(offset, 2):le_int()
        local q2_error = q2_error_raw * 0.01  -- Apply scaling factor
        subtree:add(f_q2_error, q2_error)
        offset = offset + 2

        -- dissect quaternion error Q3 (2 bytes)
        local q3_error_raw = buffer(offset, 2):le_int()
        local q3_error = q3_error_raw * 0.01  -- Apply scaling factor
        subtree:add(f_q3_error, q3_error)
        offset = offset + 2
    end
end
-----------------------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure
function adcs_dissector_25(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_x_magnetic_field = ProtoField.int16("PowerSystemData.x_magnetic_field", "X axis Modelled Magnetic Field Vector", base.DEC)
local f_y_magnetic_field = ProtoField.int16("PowerSystemData.y_magnetic_field", "Y axis Modelled Magnetic Field Vector", base.DEC)
local f_z_magnetic_field = ProtoField.int16("PowerSystemData.z_magnetic_field", "Z axis Modelled Magnetic Field Vector", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_x_magnetic_field, f_y_magnetic_field, f_z_magnetic_field
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_25")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect x-axis magnetic field vector (2 bytes)
        local x_magnetic_field_raw = buffer(offset, 2):le_int()
        local x_magnetic_field = x_magnetic_field_raw   -- Apply scaling factor
        subtree:add(f_x_magnetic_field, x_magnetic_field)
        offset = offset + 2

        -- dissect y-axis magnetic field vector (2 bytes)
        local y_magnetic_field_raw = buffer(offset, 2):le_int()
        local y_magnetic_field = y_magnetic_field_raw  -- Apply scaling factor
        subtree:add(f_y_magnetic_field, y_magnetic_field)
        offset = offset + 2

        -- dissect z-axis magnetic field vector (2 bytes)
        local z_magnetic_field_raw = buffer(offset, 2):le_int()
        local z_magnetic_field = z_magnetic_field_raw  -- Apply scaling factor
        subtree:add(f_z_magnetic_field, z_magnetic_field)
        offset = offset + 2
    end
end
---------------------------------------------------------------------------------------------------------------------

-- Define the dissector function for the new structure
function adcs_dissector_24(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("PowerSystemData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("PowerSystemData.epoch_time", "Epoch Time", base.DES)
local f_geo_longitude = ProtoField.int16("PowerSystemData.geo_longitude", "Geocentric Longitude", base.DEC)
local f_geo_latitude = ProtoField.int16("PowerSystemData.geo_latitude", "Geocentric Latitude", base.DEC)
local f_geo_altitude = ProtoField.int16("PowerSystemData.geo_altitude", "Geocentric Altitude", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = { 
    f_op_status, f_epoch_time, f_geo_longitude, f_geo_latitude, f_geo_altitude
}


    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_24")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect geocentric longitude (2 bytes)
        local geo_longitude_raw = buffer(offset, 2):le_int()
        local geo_longitude = geo_longitude_raw * 0.01  -- Apply scaling factor
        subtree:add(f_geo_longitude, geo_longitude)
        offset = offset + 2

        -- dissect geocentric latitude (2 bytes)
        local geo_latitude_raw = buffer(offset, 2):le_int()
        local geo_latitude = geo_latitude_raw * 0.01  -- Apply scaling factor
        subtree:add(f_geo_latitude, geo_latitude)
        offset = offset + 2

        -- dissect geocentric altitude (2 bytes)
        local geo_altitude_raw = buffer(offset, 2):le_int()
        local geo_altitude = geo_altitude_raw * 0.1  -- Apply scaling factor
        subtree:add(f_geo_altitude, geo_altitude)
        offset = offset + 2
    end
end
----------------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure
function adcs_dissector_23(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("StarTrackerData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("StarTrackerData.epoch_time", "Epoch Time", base.DES)
local f_num_stars_detected = ProtoField.uint8("StarTrackerData.num_stars_detected", "Number of Stars Detected", base.DES)
local f_star_image_noise = ProtoField.uint8("StarTrackerData.star_image_noise", "Star Image Noise", base.DES)
local f_invalid_star = ProtoField.uint8("StarTrackerData.invalid_star", "Invalid Star", base.DES)
local f_num_stars_identified = ProtoField.uint8("StarTrackerData.num_stars_identified", "Number of Stars Identified", base.DES)
local f_ident_mode = ProtoField.uint8("StarTrackerData.ident_mode", "Identification Mode", base.ENUM)
local f_image_dark_value = ProtoField.uint8("StarTrackerData.image_dark_value", "Image Dark Value", base.DES)
local f_flags = ProtoField.uint8("StarTrackerData.flags", "Flags", base.HEX)

-- Define ProtoFields for star confidence and magnitudes
local f_star_conf_1 = ProtoField.uint8("StarTrackerData.star_conf_1", "Star 1 Confidence", base.PERCENT)
local f_star_conf_2 = ProtoField.uint8("StarTrackerData.star_conf_2", "Star 2 Confidence", base.PERCENT)
local f_star_conf_3 = ProtoField.uint8("StarTrackerData.star_conf_3", "Star 3 Confidence", base.PERCENT)

local f_instrument_mag_1 = ProtoField.uint16("StarTrackerData.instrument_mag_1", "Instrument Magnitude Star 1", base.DEC)
local f_instrument_mag_2 = ProtoField.uint16("StarTrackerData.instrument_mag_2", "Instrument Magnitude Star 2", base.DEC)
local f_instrument_mag_3 = ProtoField.uint16("StarTrackerData.instrument_mag_3", "Instrument Magnitude Star 3", base.DEC)
local f_instrument_mag_4 = ProtoField.uint16("StarTrackerData.instrument_mag_4", "Instrument Magnitude Star 4", base.DEC)

-- Define ProtoFields for capture, detection, identification
local f_capture = ProtoField.uint16("StarTrackerData.capture", "Capture", base.DEC)
local f_detection = ProtoField.uint16("StarTrackerData.detection", "Detection", base.DEC)
local f_identification = ProtoField.uint16("StarTrackerData.identification", "Identification", base.DEC)

-- Define ProtoFields for the estimated rates (X and Y axes)
local f_est_rate_x = ProtoField.int16("StarTrackerData.est_rate_x", "Estimated Rate X-axis", base.DEC)
local f_est_rate_y = ProtoField.int16("StarTrackerData.est_rate_y", "Estimated Rate Y-axis", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_num_stars_detected, f_star_image_noise, f_invalid_star, 
    f_num_stars_identified, f_ident_mode, f_image_dark_value, f_flags, 
    f_star_conf_1, f_star_conf_2, f_star_conf_3,
    f_instrument_mag_1, f_instrument_mag_2, f_instrument_mag_3, f_instrument_mag_4,
    f_capture, f_detection, f_identification, f_est_rate_x, f_est_rate_y
}

    -- Loop through the data (data3 could represent the number of iterations or packets to dissect)
    for i = 1, data3 do
        -- Add the new structure data as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_23")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect number of stars detected (1 byte)
        local num_stars_detected = buffer(offset, 1):le_uint()
        subtree:add(f_num_stars_detected, num_stars_detected)
        offset = offset + 1

        -- dissect star image noise (1 byte)
        local star_image_noise = buffer(offset, 1):le_uint()
        subtree:add(f_star_image_noise, star_image_noise)
        offset = offset + 1

        -- dissect invalid star (1 byte)
        local invalid_star = buffer(offset, 1):le_uint()
        subtree:add(f_invalid_star, invalid_star)
        offset = offset + 1

        -- dissect number of stars identified (1 byte)
        local num_stars_identified = buffer(offset, 1):le_uint()
        subtree:add(f_num_stars_identified, num_stars_identified)
        offset = offset + 1

        -- dissect identification mode (1 byte, enum)
        local ident_mode = buffer(offset, 1):le_uint()
        subtree:add(f_ident_mode, ident_mode)
        offset = offset + 1

        -- dissect image dark value (1 byte)
        local image_dark_value = buffer(offset, 1):le_uint()
        subtree:add(f_image_dark_value, image_dark_value)
        offset = offset + 1

        -- dissect flags (8 flags, 1 byte)
        local flags = buffer(offset, 1):le_uint()
        subtree:add(f_flags, flags)
        offset = offset + 1

        -- dissect star confidences (1 byte each)
        local star_conf_1 = buffer(offset, 1):le_uint()
        subtree:add(f_star_conf_1, star_conf_1)
        offset = offset + 1
        local star_conf_2 = buffer(offset, 1):le_uint()
        subtree:add(f_star_conf_2, star_conf_2)
        offset = offset + 1
        local star_conf_3 = buffer(offset, 1):le_uint()
        subtree:add(f_star_conf_3, star_conf_3)
        offset = offset + 1

        -- dissect instrument magnitudes (2 bytes each)
        local instrument_mag_1 = buffer(offset, 2):le_uint()
        subtree:add(f_instrument_mag_1, instrument_mag_1)
        offset = offset + 2
        local instrument_mag_2 = buffer(offset, 2):le_uint()
        subtree:add(f_instrument_mag_2, instrument_mag_2)
        offset = offset + 2
        local instrument_mag_3 = buffer(offset, 2):le_uint()
        subtree:add(f_instrument_mag_3, instrument_mag_3)
        offset = offset + 2
        local instrument_mag_4 = buffer(offset, 2):le_uint()
        subtree:add(f_instrument_mag_4, instrument_mag_4)
        offset = offset + 2

        -- dissect capture, detection, and identification (2 bytes each)
        local capture = buffer(offset, 2):le_uint()
        subtree:add(f_capture, capture)
        offset = offset + 2
        local detection = buffer(offset, 2):le_uint()
        subtree:add(f_detection, detection)
        offset = offset + 2
        local identification = buffer(offset, 2):le_uint()
        subtree:add(f_identification, identification)
        offset = offset + 2

        -- dissect estimated rate X-axis (2 bytes)
        local est_rate_x_raw = buffer(offset, 2):le_int()
        local est_rate_x = est_rate_x_raw  -- Apply scaling factor
        subtree:add(f_est_rate_x, est_rate_x)
        offset = offset + 2

        -- dissect estimated rate Y-axis (2 bytes)
        local est_rate_y_raw = buffer(offset, 2):le_int()
        local est_rate_y = est_rate_y_raw   -- Apply scaling factor
        subtree:add(f_est_rate_y, est_rate_y)
        offset = offset + 2
    end
end
-------------------------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the new structure
function adcs_dissector_22(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("StarTrackerData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("StarTrackerData.epoch_time", "Epoch Time", base.DES)
local f_css_ad_values = ProtoField.uint8("StarTrackerData.css_ad_value_","CSS A/D Value ", base.HEX)
-- Define the ProtoField for the array of CSS A/D values (10 values of 1 byte each)


-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_css_ad_values
}

for i = 1, data3 do

    -- Add the new structure data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_22")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect CSS A/D values (array of 10 1-byte values)
    for i = 1, 10 do
        local css_ad_value = buffer(offset, 1):le_uint()
        subtree:add(f_css_ad_values, css_ad_value)
        offset = offset + 1
    end
end
end
------------------------------------------------------------------------------------------------------------------------------------------


-- Define the dissector function for the Magnetorquer data
function adcs_dissector_21(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)
-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("MagnetorquerData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("MagnetorquerData.epoch_time", "Epoch Time", base.DES)
local f_x_magnetorquer_time = ProtoField.int16("MagnetorquerData.x_magnetorquer_time", "X Magnetorquer Commanded On-time (10ms)", base.DEC)
local f_y_magnetorquer_time = ProtoField.int16("MagnetorquerData.y_magnetorquer_time", "Y Magnetorquer Commanded On-time (10ms)", base.DEC)
local f_z_magnetorquer_time = ProtoField.int16("MagnetorquerData.z_magnetorquer_time", "Z Magnetorquer Commanded On-time (10ms)", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_magnetorquer_time, f_y_magnetorquer_time, f_z_magnetorquer_time
}

for i = 1, data3 do
    -- Add the new structure data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_21")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect X Magnetorquer Commanded on-time (2 bytes)
    local x_magnetorquer_time = buffer(offset, 2):le_int()
    subtree:add(f_x_magnetorquer_time, x_magnetorquer_time)
    offset = offset + 2

    -- dissect Y Magnetorquer Commanded on-time (2 bytes)
    local y_magnetorquer_time = buffer(offset, 2):le_int()
    subtree:add(f_y_magnetorquer_time, y_magnetorquer_time)
    offset = offset + 2

    -- dissect Z Magnetorquer Commanded on-time (2 bytes)
    local z_magnetorquer_time = buffer(offset, 2):le_int()
    subtree:add(f_z_magnetorquer_time, z_magnetorquer_time)
    offset = offset + 2
end
end
-----------------------------------------------------------------------------------------

-- Define the dissector function for the Reaction Wheel data
function adcs_dissector_20(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("ReactionWheelData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("ReactionWheelData.epoch_time", "Epoch Time", base.DES)
local f_num_reaction_wheels = ProtoField.uint8("ReactionWheelData.num_reaction_wheels", "Number of Reaction Wheels", base.DES)
local f_wheel_speed = ProtoField.uint16("ReactionWheelData.wheel_speed_", "Measured Wheel Speed ", base.DEC)
-- Define the ProtoField for the array of Measured Wheel Speeds (N = 3, each 2 bytes)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_num_reaction_wheels, f_wheel_speed
}

for i = 1, data3 do
    -- Add the new structure data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_20")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect number of reaction wheels (1 byte)
    local num_reaction_wheels = buffer(offset, 1):le_uint()
    subtree:add(f_num_reaction_wheels, num_reaction_wheels)
    offset = offset + 1

    -- dissect wheel speeds (array of N * 2 bytes, with N = 3)
    for i = 1, num_reaction_wheels do
        local wheel_speed = buffer(offset, 2):le_uint()
        subtree:add(f_wheel_speed, wheel_speed)
        offset = offset + 2
    end
end
end
-----------------------------------------------------------------------------------------------------------



-- Define the dissector function for the Reaction Wheel Commanded Speed data
function adcs_dissector_19(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the new structure fields
local f_op_status = ProtoField.uint8("ReactionWheelData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("ReactionWheelData.epoch_time", "Epoch Time", base.DES)
local f_num_reaction_wheels = ProtoField.uint8("ReactionWheelData.num_reaction_wheels", "Number of Reaction Wheels", base.DES)
f_wheel_speed_cmd = ProtoField.uint16("ReactionWheelData.wheel_speed_cmd_","Commanded Wheel Speed ", base.DEC)

-- Define the ProtoField for the array of Commanded Wheel Speeds (N = 3, each 2 bytes)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_num_reaction_wheels,f_wheel_speed_cmd
}

for i = 1, data3 do

    -- Add the new structure data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_19")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect number of reaction wheels (1 byte)
    local num_reaction_wheels = buffer(offset, 1):le_uint()
    subtree:add(f_num_reaction_wheels, num_reaction_wheels)
    offset = offset + 1

    -- dissect commanded wheel speeds (array of N * 2 bytes, with N = 3)
    for i = 1, 3 do 				-- value 3 is fixed in structure
        local wheel_speed_cmd = buffer(offset, 2):le_uint()
        subtree:add(f_wheel_speed_cmd, wheel_speed_cmd)
        offset = offset + 2
    end
end
end
-----------------------------------------------------------------------------------------------------------------

-- Define the dissector function for the FSS Data
function adcs_dissector_17(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the FSS Data structure
local f_op_status = ProtoField.uint8("FSSData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("FSSData.epoch_time", "Epoch Time", base.DES)
local f_x_angle = ProtoField.int16("FSSData.x_angle", "FSS Raw X Angle", base.DEC)
local f_y_angle = ProtoField.int16("FSSData.y_angle", "FSS Raw Y Angle", base.DEC)
local f_capture_status = ProtoField.uint8("FSSData.capture_status", "FSS Capture Status", base.HEX)
local f_detection_result = ProtoField.uint8("FSSData.detection_result", "FSS Detection Result", base.HEX)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_angle, f_y_angle, f_capture_status, f_detection_result
}
for i = 1, data3 do
    -- Add the FSS data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_17")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect FSS raw X angle (2 bytes)
    local x_angle = buffer(offset, 2):le_int16()
    subtree:add(f_x_angle, x_angle)
    offset = offset + 2

    -- dissect FSS raw Y angle (2 bytes)
    local y_angle = buffer(offset, 2):le_int()
    subtree:add(f_y_angle, y_angle)
    offset = offset + 2

    -- dissect FSS capture status (1 byte, enum)
    local capture_status = buffer(offset, 1):le_uint()
    subtree:add(f_capture_status, capture_status)
    offset = offset + 1

    -- dissect FSS detection result (1 byte, enum)
    local detection_result = buffer(offset, 1):le_uint()
    subtree:add(f_detection_result, detection_result)
    offset = offset + 1
end
end
--------------------------------------------------------------------------------------------------------

-- Define the dissector function for the Fine Estimated Angular Rates Data
function adcs_dissector_14(buffer, pinfo, tree, HM_TM_dissector, offset, len,data3)

-- Define ProtoFields for the Fine Estimated Angular Rates structure
local f_op_status = ProtoField.uint8("AngularRateData.op_status", "Operation Status", base.DES)
local f_epoch_time = ProtoField.uint32("AngularRateData.epoch_time", "Epoch Time", base.DES)
local f_x_angular_rate = ProtoField.int16("AngularRateData.x_angular_rate", "Fine Estimated X Angular Rate", base.DEC)
local f_y_angular_rate = ProtoField.int16("AngularRateData.y_angular_rate", "Fine Estimated Y Angular Rate", base.DEC)
local f_z_angular_rate = ProtoField.int16("AngularRateData.z_angular_rate", "Fine Estimated Z Angular Rate", base.DEC)

-- Add the fields to the protocol
HM_TM_dissector.fields = {
    f_op_status, f_epoch_time, f_x_angular_rate, f_y_angular_rate, f_z_angular_rate
}

for i = 1, data3 do
    -- Add the Fine Estimated Angular Rates data as a subtree
    local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_14")

    -- dissect operation status (1 byte)
    local op_status = buffer(offset, 1):le_uint()
    subtree:add(f_op_status, op_status)
    offset = offset + 1

    -- dissect epoch time (4 bytes)
    local epoch_time = buffer(offset, 4):le_uint()
    subtree:add(f_epoch_time, epoch_time)
    offset = offset + 4

    -- dissect Fine Estimated X Angular Rate (2 bytes, formatted value = RAWVAL*0.001)
    local x_angular_rate = buffer(offset, 2):le_int()
    subtree:add(f_x_angular_rate, x_angular_rate)
    offset = offset + 2

    -- dissect Fine Estimated Y Angular Rate (2 bytes, formatted value = RAWVAL*0.001)
    local y_angular_rate = buffer(offset, 2):le_int()
    subtree:add(f_y_angular_rate, y_angular_rate)
    offset = offset + 2

    -- dissect Fine Estimated Z Angular Rate (2 bytes, formatted value = RAWVAL*0.001)
    local z_angular_rate = buffer(offset, 2):le_int()
    subtree:add(f_z_angular_rate, z_angular_rate)
    offset = offset + 2
end
end
-----------------------------------------------------------------------------------------------------------

-- Define the dissector function for the Rate Sensor Temperature Data
function adcs_dissector_12(buffer, pinfo, tree, HM_TM_dissector, offset, len, data3)

    -- Define ProtoFields for the structure (adjust names as per your needs)
    local f_op_status = ProtoField.uint8("RateSensorData.op_status", "Operation Status", base.HEX)
    local f_epoch_time = ProtoField.uint32("RateSensorData.epoch_time", "Epoch Time", base.DEC)
    local f_x_rate_temp = ProtoField.int16("RateSensorData.x_rate_temp", "X Rate Sensor Temperature", base.DEC)
    local f_y_rate_temp = ProtoField.int16("RateSensorData.y_rate_temp", "Y Rate Sensor Temperature", base.DEC)
    local f_z_rate_temp = ProtoField.int16("RateSensorData.z_rate_temp", "Z Rate Sensor Temperature", base.DEC)

    -- Add the fields to the protocol
    HM_TM_dissector.fields = {
        f_op_status, f_epoch_time, f_x_rate_temp, f_y_rate_temp, f_z_rate_temp
    }

    -- Loop to process multiple data3 (if needed, as per your structure)
    for i = 1, data3 do
        -- Add the data structure as a subtree
        local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "adcs_qid_12")

        -- dissect operation status (1 byte)
        local op_status = buffer(offset, 1):le_uint()
        subtree:add(f_op_status, op_status)
        offset = offset + 1

        -- dissect epoch time (4 bytes)
        local epoch_time = buffer(offset, 4):le_uint()
        subtree:add(f_epoch_time, epoch_time)
        offset = offset + 4

        -- dissect X Rate Sensor Temperature (2 bytes, formatted value = RAWVAL)
        local x_rate_temp = buffer(offset, 2):le_int()
        subtree:add(f_x_rate_temp, x_rate_temp)
        offset = offset + 2

        -- dissect Y Rate Sensor Temperature (2 bytes, formatted value = RAWVAL)
        local y_rate_temp = buffer(offset, 2):le_int()
        subtree:add(f_y_rate_temp, y_rate_temp)
        offset = offset + 2

        -- dissect Z Rate Sensor Temperature (2 bytes, formatted value = RAWVAL)
        local z_rate_temp = buffer(offset, 2):le_int()
        subtree:add(f_z_rate_temp, z_rate_temp)
        offset = offset + 2
    end
end
--------------------------------------------------------------------------------------------------------------------