adcs_dissector

Dissector/adcs_dissector.lua

@@ -0,0 +1,1157 @@
+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
+--------------------------------------------------------------------------------------------------------------------

Dissector/hm_dissector.lua

@@ -71,6 +71,9 @@ TC_TM_PROTOCOL.fields = { f_sub_mod_id, f_Queue_id, f_num_of_instance, f_Health_
      if submodule_id == 0  then
      	require("eps_dissector")
       	dissect_power_system_data(buffer, pinfo, subtree1, TC_TM_PROTOCOL, offset, tm_len, num_of_instance)
+     elseif submodule_id == 1 then
+	require("adcs_dissector")
+	adcs_dissector(buffer, pinfo, subtree1, TC_TM_PROTOCOL, offset, tm_len,num_of_instance,queue_id)
      elseif submodule_id == 3  then
         require("uhf_dissector")
       UHF_DISSECTOR(buffer, pinfo, subtree1, TC_TM_PROTOCOL, offset, tm_len, num_of_instance)