Add dissector for comms (TM - 855, 857, 800, 819, 823, 398, 411, 413, 461, 463, 464, 468, 474, 475, 412)

Dissector/tm_comms_beacon_tx.lua

@@ -0,0 +1,391 @@
+
+function tm_comms_beacon_tx(buffer, pinfo, tree, comms_beacon_tx, offset)
+
+
+-- Define the fields for the protocol based on the structure
+local f_bcon_msg = ProtoField.string("comms_beacon_tx.bcon_msg", "Bcon Msg")
+local f_utc_tim = ProtoField.uint32("comms_beacon_tx.utc_tim", "UTC Time", base.DEC)
+local f_utc_gps_tim_sts = ProtoField.uint8("comms_beacon_tx.utc_gps_tim_sts", "UTC GPS Time Status", base.DEC)
+local f_latitude = ProtoField.float("comms_beacon_tx.latitude", "Latitude", base.DEC)
+local f_longitude = ProtoField.float("comms_beacon_tx.longitude", "Longitude", base.DEC)
+local f_altitude = ProtoField.float("comms_beacon_tx.altitude", "Altitude", base.DEC)
+local f_x_pos = ProtoField.double("comms_beacon_tx.x_pos", "X Position", base.DEC)
+local f_y_pos = ProtoField.double("comms_beacon_tx.y_pos", "Y Position", base.DEC)
+local f_z_pos = ProtoField.double("comms_beacon_tx.z_pos", "Z Position", base.DEC)
+local f_x_vel = ProtoField.double("comms_beacon_tx.x_vel", "X Velocity", base.DEC)
+local f_y_vel = ProtoField.double("comms_beacon_tx.y_vel", "Y Velocity", base.DEC)
+local f_z_vel = ProtoField.double("comms_beacon_tx.z_vel", "Z Velocity", base.DEC)
+local f_fsm_state = ProtoField.uint8("comms_beacon_tx.fsm_state", "FSM State", base.DEC)
+local f_num_resets = ProtoField.uint8("comms_beacon_tx.num_resets", "Number of Resets", base.DEC)
+local f_zio_err = ProtoField.uint16("comms_beacon_tx.zio_err", "ZIO Error", base.DEC)
+local f_sys_err = ProtoField.uint8("comms_beacon_tx.sys_err", "System Error", base.DEC)
+local f_obc_volt_sensor = ProtoField.uint8("comms_beacon_tx.obc_volt_sensor", "OBC Volt Sensor", base.DEC)
+local f_ps_volt_sensor = ProtoField.uint8("comms_beacon_tx.ps_volt_sensor", "PS Volt Sensor", base.DEC)
+local f_temp_obc = ProtoField.uint8("comms_beacon_tx.temp_obc", "OBC Temperature", base.DEC)
+local f_temp_ps = ProtoField.uint8("comms_beacon_tx.temp_ps", "PS Temperature", base.DEC)
+local f_temp_es = ProtoField.uint8("comms_beacon_tx.temp_es", "ES Temperature", base.DEC)
+local f_temp_gps = ProtoField.uint8("comms_beacon_tx.temp_gps", "GPS Temperature", base.DEC)
+local f_totl_btry_volt = ProtoField.uint8("comms_beacon_tx.totl_btry_volt", "Total Battery Voltage", base.DEC)
+local f_totl_panel_pwr = ProtoField.uint8("comms_beacon_tx.totl_panel_pwr", "Total Panel Power", base.DEC)
+local f_chnl_sts = ProtoField.uint16("comms_beacon_tx.chnl_sts", "Channel Status", base.DEC)
+local f_overcrnt_err_flg_byte1 = ProtoField.uint8("comms_beacon_tx.overcrnt_err_flg_byte1", "Overcurrent Error Flag Byte1", base.DEC)
+local f_overcrnt_err_flg_byte2 = ProtoField.uint16("comms_beacon_tx.overcrnt_err_flg_byte2", "Overcurrent Error Flag Byte2", base.DEC)
+local f_fsm_state_mode = ProtoField.uint8("comms_beacon_tx.fsm_state_mode", "FSM State Mode", base.DEC)
+local f_sns_actr_pwr_sts = ProtoField.uint16("comms_beacon_tx.sns_actr_pwr_sts", "Sensor Actuator Power Status", base.DEC)
+local f_actrs_run_sts = ProtoField.uint8("comms_beacon_tx.actrs_run_sts", "Actuators Run Status", base.DEC)
+
+local f_sdr_fsm_st = ProtoField.uint8("comms_beacon_tx.sdr_fsm_st", "SDR FSM State", base.DEC)
+local f_rssi0 = ProtoField.uint8("comms_beacon_tx.rssi0", "RSSI0", base.DEC)
+local f_rssi1 = ProtoField.uint8("comms_beacon_tx.rssi1", "RSSI1", base.DEC)
+local f_rx_err_cnt = ProtoField.uint32("comms_beacon_tx.rx_err_cnt", "RX Error Count", base.DEC)
+local f_tx_frm_cnt = ProtoField.uint32("comms_beacon_tx.tx_frm_cnt", "TX Frame Count", base.DEC)
+local f_rx_freq = ProtoField.uint32("comms_beacon_tx.rx_freq", "RX Frequency", base.DEC)
+local f_symb_freq = ProtoField.uint16("comms_beacon_tx.symb_freq", "Symbol Frequency", base.DEC)
+local f_mod = ProtoField.uint16("comms_beacon_tx.mod", "Modulation", base.DEC)
+local f_roll_off = ProtoField.uint16("comms_beacon_tx.roll_off", "Roll Off", base.DEC)
+local f_rand_enb = ProtoField.uint16("comms_beacon_tx.rand_enb", "Random Enable", base.DEC)
+local f_cc_enb = ProtoField.uint16("comms_beacon_tx.cc_enb", "CC Enable", base.DEC)
+local f_ors_enb = ProtoField.uint16("comms_beacon_tx.ors_enb", "ORS Enable", base.DEC)
+local f_crc_enb = ProtoField.uint16("comms_beacon_tx.crc_enb", "CRC Enable", base.DEC)
+local f_dc_filter_enb = ProtoField.uint16("comms_beacon_tx.dc_filter_enb", "DC Filter Enable", base.DEC)
+local f_manchester_coding_en = ProtoField.uint16("comms_beacon_tx.manchester_coding_en", "Manchester Coding Enable", base.DEC)
+
+-- Add the fields to the protocol
+comms_beacon_tx.fields = {
+    f_bcon_msg, f_utc_tim, f_utc_gps_tim_sts, f_latitude, f_longitude, f_altitude,
+    f_x_pos, f_y_pos, f_z_pos, f_x_vel, f_y_vel, f_z_vel, f_fsm_state, f_num_resets, 
+    f_zio_err, f_sys_err, f_obc_volt_sensor, f_ps_volt_sensor, f_temp_obc, f_temp_ps, 
+    f_temp_es, f_temp_gps, f_totl_btry_volt, f_totl_panel_pwr, f_chnl_sts, 
+    f_overcrnt_err_flg_byte1, f_overcrnt_err_flg_byte2, f_fsm_state_mode, f_sns_actr_pwr_sts, 
+    f_actrs_run_sts, f_sdr_fsm_st, f_rssi0, f_rssi1, f_rx_err_cnt, f_tx_frm_cnt, 
+    f_rx_freq, f_symb_freq, f_mod, f_roll_off, f_rand_enb, f_cc_enb, f_ors_enb, 
+    f_crc_enb, f_dc_filter_enb, f_manchester_coding_en
+}
+local subtree = tree:add(comms_beacon_tx, buffer(), "TM COMMS BEACON TX")
+
+-- dissect bcon_msg
+
+local bcon_msg = buffer(offset, 18):string()
+subtree:add(f_bcon_msg, bcon_msg)
+offset = offset + 18
+
+
+-- dissect utc_tim
+local utc_tim = buffer(offset, 4):le_uint()
+subtree:add(f_utc_tim, utc_tim)
+offset = offset + 4
+
+-- dissect utc_gps_tim_sts
+local utc_gps_tim_sts = buffer(offset, 1):le_uint()
+subtree:add(f_utc_gps_tim_sts, utc_gps_tim_sts)
+offset = offset + 1
+
+-- dissect latitude
+local latitude = buffer(offset, 4):le_float()
+subtree:add(f_latitude, latitude)
+offset = offset + 4
+
+-- dissect longitude
+local longitude = buffer(offset, 4):le_float()
+subtree:add(f_longitude, longitude)
+offset = offset + 4
+
+-- dissect altitude
+local altitude = buffer(offset, 4):le_float()
+subtree:add(f_altitude, altitude)
+offset = offset + 4
+
+-- dissect x_pos
+	local high = buffer(offset, 4):le_uint()  -- First 4 bytes
+	local low = buffer(offset + 4, 4):le_uint() -- Next 4 bytes
+
+	-- Combine and unpack as a double (64-bit floating-point number)
+	local x_pos = string.unpack("d", string.pack("<II", low, high))	
+	subtree:add(f_x_pos, x_pos)
+	offset = offset + 8
+	
+	--local x_pos = buffer(offset, 8):le_uint()
+	--subtree:add(f_x_pos, x_pos)
+	--offset = offset + 8
+
+-- dissect y_pos
+local high_y_pos = buffer(offset, 4):le_uint()  -- First 4 bytes for y_pos
+local low_y_pos = buffer(offset + 4, 4):le_uint() -- Next 4 bytes for y_pos
+local y_pos = string.unpack("d", string.pack("<II", low_y_pos, high_y_pos))
+subtree:add(f_y_pos, y_pos)
+offset = offset + 8
+
+-- dissect z_pos
+local high_z_pos = buffer(offset, 4):le_uint()  -- First 4 bytes for z_pos
+local low_z_pos = buffer(offset + 4, 4):le_uint() -- Next 4 bytes for z_pos
+local z_pos = string.unpack("d", string.pack("<II", low_z_pos, high_z_pos))
+subtree:add(f_z_pos, z_pos)
+offset = offset + 8
+
+-- dissect x_vel
+local high_x_vel = buffer(offset, 4):le_uint()  -- First 4 bytes for x_vel
+local low_x_vel = buffer(offset + 4, 4):le_uint() -- Next 4 bytes for x_vel
+local x_vel = string.unpack("d", string.pack("<II", low_x_vel, high_x_vel))
+subtree:add(f_x_vel, x_vel)
+offset = offset + 8
+
+-- dissect y_vel
+local high_y_vel = buffer(offset, 4):le_uint()  -- First 4 bytes for y_vel
+local low_y_vel = buffer(offset + 4, 4):le_uint() -- Next 4 bytes for y_vel
+local y_vel = string.unpack("d", string.pack("<II", low_y_vel, high_y_vel))
+subtree:add(f_y_vel, y_vel)
+offset = offset + 8
+
+-- dissect z_vel
+local high_z_vel = buffer(offset, 4):le_uint()  -- First 4 bytes for z_vel
+local low_z_vel = buffer(offset + 4, 4):le_uint() -- Next 4 bytes for z_vel
+local z_vel = string.unpack("d", string.pack("<II", low_z_vel, high_z_vel))
+subtree:add(f_z_vel, z_vel)
+offset = offset + 8
+
+-- dissect fsm_state
+local fsm_state = buffer(offset, 1):le_uint()
+subtree:add(f_fsm_state, fsm_state)
+offset = offset + 1
+
+-- dissect num_resets
+local num_resets = buffer(offset, 1):le_uint()
+subtree:add(f_num_resets, num_resets)
+offset = offset + 1
+
+-- dissect zio_err
+local zio_err = buffer(offset, 2):le_uint()
+subtree:add(f_zio_err, zio_err)
+offset = offset + 2
+
+-- dissect sys_err
+local sys_err = buffer(offset, 1):le_uint()
+subtree:add(f_sys_err, sys_err)
+offset = offset + 1
+
+-- dissect obc_volt_sensor
+local obc_volt_sensor = buffer(offset, 1):le_uint()
+subtree:add(f_obc_volt_sensor, obc_volt_sensor)
+offset = offset + 1
+
+-- dissect ps_volt_sensor
+local ps_volt_sensor = buffer(offset, 1):le_uint()
+subtree:add(f_ps_volt_sensor, ps_volt_sensor)
+offset = offset + 1
+
+-- dissect temp_obc
+local temp_obc = buffer(offset, 1):le_uint()
+subtree:add(f_temp_obc, temp_obc)
+offset = offset + 1
+
+-- dissect temp_ps
+local temp_ps = buffer(offset, 1):le_uint()
+subtree:add(f_temp_ps, temp_ps)
+offset = offset + 1
+
+-- dissect temp_es
+local temp_es = buffer(offset, 1):le_uint()
+subtree:add(f_temp_es, temp_es)
+offset = offset + 1
+
+-- dissect temp_gps
+local temp_gps = buffer(offset, 1):le_uint()
+subtree:add(f_temp_gps, temp_gps)
+offset = offset + 1
+
+-- dissect totl_btry_volt
+local totl_btry_volt = buffer(offset, 1):le_uint()
+subtree:add(f_totl_btry_volt, totl_btry_volt)
+offset = offset + 1
+
+-- dissect totl_panel_pwr
+local totl_panel_pwr = buffer(offset, 1):le_uint()
+subtree:add(f_totl_panel_pwr, totl_panel_pwr)
+offset = offset + 1
+
+-- dissect chnl_sts
+local chnl_sts = buffer(offset, 2):le_uint()
+subtree:add(f_chnl_sts, chnl_sts)
+offset = offset + 2
+
+-- dissect overcrnt_err_flg_byte1
+local overcrnt_err_flg_byte1 = buffer(offset, 1):le_uint()
+subtree:add(f_overcrnt_err_flg_byte1, overcrnt_err_flg_byte1)
+offset = offset + 1
+
+-- dissect overcrnt_err_flg_byte2
+local overcrnt_err_flg_byte2 = buffer(offset, 2):le_uint()
+subtree:add(f_overcrnt_err_flg_byte2, overcrnt_err_flg_byte2)
+offset = offset + 2
+
+-- dissect fsm_state_mode
+local fsm_state_mode = buffer(offset, 1):le_uint()
+subtree:add(f_fsm_state_mode, fsm_state_mode)
+offset = offset + 1
+
+-- dissect sns_actr_pwr_sts
+local sns_actr_pwr_sts = buffer(offset, 2):le_uint()
+subtree:add(f_sns_actr_pwr_sts, sns_actr_pwr_sts)
+offset = offset + 2
+
+-- dissect actrs_run_sts
+local actrs_run_sts = buffer(offset, 1):le_uint()
+subtree:add(f_actrs_run_sts, actrs_run_sts)
+offset = offset + 1
+
+-- dissect sdr_fsm_st
+local byte = buffer(offset, 1):le_uint()  -- Read the full byte (8 bits)
+--local sdr_fsm_st = (byte >> 4) & 0x0F
+local sdr_fsm_st = byte  & 0x0F
+subtree:add(f_sdr_fsm_st, sdr_fsm_st)  ------------------------------------bit logic
+--offset = offset + 1
+
+-- dissect rssi0
+byte = buffer(offset, 1):le_uint() 
+local rssi0 = (byte >> 4) & 0x03
+subtree:add(f_rssi0, rssi0)
+--offset = offset + 1
+
+-- dissect rssi1
+byte = buffer(offset, 1):le_uint()
+local rssi1 = (byte >> 6) &0x03
+subtree:add(f_rssi1, rssi1)
+offset = offset + 1
+-------------------------------------------one byte
+
+-- dissect rx_err_cnt
+local rx_err_cnt = buffer(offset, 4):le_uint()
+subtree:add(f_rx_err_cnt, rx_err_cnt)
+offset = offset + 4
+
+-- dissect tx_frm_cnt
+local tx_frm_cnt = buffer(offset, 4):le_uint()
+subtree:add(f_tx_frm_cnt, tx_frm_cnt)
+offset = offset + 4
+
+-- dissect rx_freq
+local rx_freq = buffer(offset, 4):le_uint()
+subtree:add(f_rx_freq, rx_freq)
+offset = offset + 4
+
+-- dissect symb_freq
+local symb_freq = buffer(offset, 1):le_uint()
+subtree:add(f_symb_freq, symb_freq)
+offset = offset + 1
+-------------------------------------------------------
+-- dissect mod
+byte = buffer(offset, 1):le_uint()
+local mod = byte & 0x03
+subtree:add(f_mod, mod)
+--offset = offset + 2
+
+-- dissect roll_off
+byte = buffer(offset, 1):le_uint()
+local roll_off = (byte >> 2) & 0x03
+subtree:add(f_roll_off, roll_off)
+--offset = offset + 2
+
+-- dissect rand_enb
+byte = buffer(offset, 1):le_uint()
+local rand_enb = (byte >> 4) & 0x03
+subtree:add(f_rand_enb, rand_enb)
+--offset = offset + 2
+
+-- dissect cc_enb
+byte = buffer(offset, 1):le_uint()
+local cc_enb = (byte >> 6) &0x01
+subtree:add(f_cc_enb, cc_enb)
+--offset = offset + 2
+
+-- dissect ors_enb
+byte = buffer(offset, 1):le_uint()
+local ors_enb = (byte >> 7) & 0x01
+subtree:add(f_ors_enb, ors_enb)
+offset = offset + 1
+------------------------------------------------------------
+-- dissect sdr_fsm_st
+byte = buffer(offset, 1):le_uint()
+local x = byte  & 0x0F
+subtree:add(f_sdr_fsm_st, x)
+
+-- dissect rssi0
+byte = buffer(offset, 1):le_uint()
+local rssi0 = (byte >> 4) & 0x03
+subtree:add(f_rssi0, rssi0)
+--offset = offset + 1
+
+-- dissect rssi1
+byte = buffer(offset, 1):le_uint()
+local rssi1 = (byte >> 6) & 0x03
+subtree:add(f_rssi1, rssi1)
+offset = offset + 1
+-----------------------------------------------------1byte
+
+-- dissect rx_err_cnt
+local rx_err_cnt = buffer(offset, 4):le_uint()
+subtree:add(f_rx_err_cnt, rx_err_cnt)
+offset = offset + 4
+
+-- dissect tx_frm_cnt
+local tx_frm_cnt = buffer(offset, 4):le_uint()
+subtree:add(f_tx_frm_cnt, tx_frm_cnt)
+offset = offset + 4
+
+-- dissect rx_freq
+local rx_freq = buffer(offset, 4):le_uint()
+subtree:add(f_rx_freq, rx_freq)
+offset = offset + 4
+---------------------------------------------------------------
+-- dissect symb_freq
+byte = buffer(offset, 1):le_uint()
+local symb_freq = byte & 0x0f
+subtree:add(f_symb_freq, symb_freq)
+--offset = offset + 2
+
+-- dissect mod
+byte = buffer(offset, 1):le_uint()
+local mod = (byte >> 4) & 0x01
+subtree:add(f_mod, mod)
+--offset = offset + 2
+
+-- dissect roll_off
+byte = buffer(offset, 1):le_uint()
+local roll_off = (byte >> 5) & 0x01
+subtree:add(f_roll_off, roll_off)
+--offset = offset + 2
+
+-- dissect crc_enb
+byte = buffer(offset, 1):le_uint()
+local crc_enb = (byte >> 6) &0x03
+subtree:add(f_crc_enb, crc_enb)
+offset = offset + 1
+--------------------------------------------------------------------
+
+-- dissect dc_filter_enb
+byte = buffer(offset, 1):le_uint()
+--byte = 0x2c
+local dc_filter_enb = byte & 0x03
+subtree:add(f_dc_filter_enb, dc_filter_enb)
+--offset = offset + 2
+
+byte = buffer(offset, 1):le_uint()
+--byte = 0x2c
+local cc_enb = (byte >> 2) & 0x03 
+subtree:add(f_cc_enb, cc_enb)
+--offset = offset + 2
+
+-- dissect rand_enb (2 bits)
+byte = buffer(offset, 1):le_uint()
+--byte = 0x2c
+local rand_enb = (byte >> 4) & 0x03 
+subtree:add(f_rand_enb, rand_enb)
+--offset = offset + 2
+
+-- dissect manchester_coding_en
+byte = buffer(offset, 1):le_uint()
+--byte = 0x2c
+local manchester_coding_en = (byte >>6) & 0x03
+subtree:add(f_manchester_coding_en, manchester_coding_en)
+--offset = offset + 2
+
+end

Dissector/tm_comms_uhf_dbg_cb.lua

@@ -0,0 +1,60 @@
+function tm_comms_uhf_dbg_cb(buffer, pinfo, tree, comms_uhf_dbg_cb, offset)
+    -- Define ProtoFields
+    local f_state = ProtoField.uint8("comms_uhf_dbg_cb.state", "UHF FSM State", base.DEC)
+    local f_uhf_sch_gs_cont = ProtoField.uint8("comms_uhf_dbg_cb.uhf_sch_gs_cont", "UHF Scheduler Ground Contact Status", base.DEC)
+    local f_uhf_gs_cont_valid = ProtoField.uint8("comms_uhf_dbg_cb.uhf_gs_cont_valid", "UHF Ground Contact Valid", base.DEC)
+
+    local f_uhf_uart_cmd_rx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_uart_cmd_rx_cnt", "UHF UART Command RX Count", base.DEC)
+    local f_uhf_uart_cmd_tx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_uart_cmd_tx_cnt", "UHF UART Command TX Count", base.DEC)
+    local f_uhf_uart_data_rx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_uart_data_rx_cnt", "UHF UART Data RX Count", base.DEC)
+    local f_uhf_uart_data_tx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_uart_data_tx_cnt", "UHF UART Data TX Count", base.DEC)
+
+    local f_uhf_tm_tx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_tm_tx_cnt", "UHF TM TX Count to CSP", base.DEC)
+    local f_uhf_tc_rx_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_tc_rx_cnt", "UHF TC RX Count from CSP", base.DEC)
+    local f_uhf_tm_tx_fail_cnt = ProtoField.uint32("comms_uhf_dbg_cb.uhf_tm_tx_fail_cnt", "UHF TM TX Fail Count in CSP", base.DEC)
+
+    -- Register the fields in the protocol
+    comms_uhf_dbg_cb.fields = {
+        f_state, f_uhf_sch_gs_cont, f_uhf_gs_cont_valid,
+        f_uhf_uart_cmd_rx_cnt, f_uhf_uart_cmd_tx_cnt, f_uhf_uart_data_rx_cnt, f_uhf_uart_data_tx_cnt,
+        f_uhf_tm_tx_cnt, f_uhf_tc_rx_cnt, f_uhf_tm_tx_fail_cnt
+    }
+
+    -- Create a subtree for the structure
+    local subtree = tree:add(comms_uhf_dbg_cb, buffer(), "TM COMMS UHF GET DBG CB INFO")
+
+    -- Parse each field
+    subtree:add(f_state, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    subtree:add(f_uhf_sch_gs_cont, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    subtree:add(f_uhf_gs_cont_valid, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Padding (if necessary)
+    --offset = offset + 1
+
+    subtree:add_le(f_uhf_uart_cmd_rx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_uart_cmd_tx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_uart_data_rx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_uart_data_tx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_tm_tx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_tc_rx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_uhf_tm_tx_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+end

Dissector/tm_comms_uhf_get_tm_info.lua

@@ -0,0 +1,131 @@
+function tm_comms_uhf_get_tm_info(buffer, pinfo, tree, comms_uhf_tm_info, offset)
+    -- Define ProtoFields for the structure
+    local f_adc_cnt = ProtoField.uint8("comms_uhf_tm_info.adc_cnt", "ADC Count", base.DEC)
+    local f_uptime = ProtoField.uint32("comms_uhf_tm_info.uptime", "Device Uptime", base.DEC)
+    local f_uart0_rx_count = ProtoField.uint32("comms_uhf_tm_info.uart0_rx_count", "UART0 RX Count", base.DEC)
+    local f_uart1_rx_count = ProtoField.uint32("comms_uhf_tm_info.uart1_rx_count", "UART1 RX Count", base.DEC)
+    local f_rx_mode = ProtoField.uint8("comms_uhf_tm_info.rx_mode", "RX Mode", base.DEC)
+    local f_tx_mode = ProtoField.uint8("comms_uhf_tm_info.tx_mode", "TX Mode", base.DEC)
+    local f_adc = ProtoField.int16("comms_uhf_tm_info.adc", "ADC Channel Stat", base.DEC)
+    local f_last_rssi = ProtoField.int8("comms_uhf_tm_info.last_rssi", "Last RSSI", base.DEC)
+    local f_last_lqi = ProtoField.uint8("comms_uhf_tm_info.last_lqi", "Last LQI", base.DEC)
+    local f_last_freqest = ProtoField.int8("comms_uhf_tm_info.last_freqest", "Last Frequency Estimation", base.DEC)
+    local f_pkt_sent = ProtoField.uint32("comms_uhf_tm_info.pkt_sent", "Packets Sent", base.DEC)
+    local f_cs_count = ProtoField.uint32("comms_uhf_tm_info.cs_count", "CS Count", base.DEC)
+    local f_pkt_good = ProtoField.uint32("comms_uhf_tm_info.pkt_good", "Packets Good", base.DEC)
+    local f_pkt_rejected_checksum = ProtoField.uint32("comms_uhf_tm_info.pkt_rejected_checksum", "Packets Rejected (Checksum)", base.DEC)
+    local f_pkt_rejected_reserved = ProtoField.uint32("comms_uhf_tm_info.pkt_rejected_reserved", "Packets Rejected (Reserved)", base.DEC)
+    local f_pkt_rejected_other = ProtoField.uint32("comms_uhf_tm_info.pkt_rejected_other", "Packets Rejected (Other)", base.DEC)
+    local f_reserved0 = ProtoField.uint32("comms_uhf_tm_info.reserved0", "Reserved 1", base.DEC)
+    local f_data_tx_cnt = ProtoField.uint32("comms_uhf_tm_info.data_tx_cnt", "Data uart tx cnt", base.DEC)
+    local f_data_rx_cnt = ProtoField.uint32("comms_uhf_tm_info.data_rx_cnt","Data uart rx cnt", base.DEC)
+
+    -- Add fields to the protocol
+    comms_uhf_tm_info.fields = { 
+        f_adc_cnt,
+        f_uptime,
+        f_uart0_rx_count,
+        f_uart1_rx_count,
+        f_rx_mode,
+        f_tx_mode,
+        f_adc,
+        f_last_rssi,
+        f_last_lqi,
+        f_last_freqest,
+        f_pkt_sent,
+        f_cs_count,
+        f_pkt_good,
+        f_pkt_rejected_checksum,
+        f_pkt_rejected_reserved,
+        f_pkt_rejected_other,
+        f_reserved0,
+        f_data_tx_cnt,
+        f_data_rx_cnt
+    }
+
+    -- Add a subtree for the structure
+    local subtree = tree:add(comms_uhf_tm_info, buffer(), "TM COMMS UHF GET TM INFO")
+
+    -- Dissect each field
+    -- ADC Count (1 byte)
+    --local adc_cnt = buffer(offset, 1):le_uint()
+    --subtree:add(f_adc_cnt, buffer(offset, 1)):set_text(string.format("ADC Count: %d", adc_cnt))
+    --offset = offset + 1
+
+    -- Device Uptime (4 bytes)
+    subtree:add_le(f_uptime, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- UART0 RX Count (4 bytes)
+    subtree:add_le(f_uart0_rx_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- UART1 RX Count (4 bytes)
+    subtree:add_le(f_uart1_rx_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- RX Mode (1 byte)
+    subtree:add(f_rx_mode, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- TX Mode (1 byte)
+    subtree:add(f_tx_mode, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- ADC Channel Stat (10 * 2 bytes)
+    --local adc_subtree = subtree:add(buffer(offset, adc_cnt * 2), "ADC Channel Stats")
+    for i = 0, 10 - 1 do
+        local adc_value = buffer(offset, 2):le_int()
+        subtree:add(f_adc, buffer(offset, 2)):set_text(string.format("ADC[%d]: %d", i + 1, adc_value))
+        offset = offset + 2
+    end
+
+    -- Last RSSI (1 byte)
+    subtree:add(f_last_rssi, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Last LQI (1 byte)
+    subtree:add(f_last_lqi, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Last Frequency Estimation (1 byte)
+    subtree:add(f_last_freqest, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Packets Sent (4 bytes)
+    subtree:add_le(f_pkt_sent, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- CS Count (4 bytes)
+    subtree:add_le(f_cs_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Good (4 bytes)
+    subtree:add_le(f_pkt_good, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Checksum) (4 bytes)
+    subtree:add_le(f_pkt_rejected_checksum, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Reserved) (4 bytes)
+    subtree:add_le(f_pkt_rejected_reserved, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Other) (4 bytes)
+    subtree:add_le(f_pkt_rejected_other, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Reserved 0 (4 bytes)
+    --subtree:add_le(f_reserved0, buffer(offset, 1):le_uint())
+    --offset = offset + 1
+
+    -- Custom 0 (4 bytes)
+    subtree:add_le(f_data_tx_cnt, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Custom 1 (4 bytes)
+    subtree:add_le(f_data_rx_cnt, buffer(offset, 1))
+    offset = offset + 1
+
+end

Dissector/tm_comms_uhf_get_tm_store.lua

@@ -0,0 +1,140 @@
+function tm_comms_uhf_get_tm_store(buffer, pinfo, tree, comms_uhf_tm_store, offset)
+    -- Define ProtoFields for the structure
+    local f_timestamp = ProtoField.uint64("comms_uhf_tm_store.timestamp", "Timestamp", base.DEC)
+    local f_adc_cnt = ProtoField.uint8("comms_uhf_tm_store.adc_cnt", "ADC Count", base.DEC)
+    local f_uptime = ProtoField.uint32("comms_uhf_tm_store.uptime", "Device Uptime", base.DEC)
+    local f_uart0_rx_count = ProtoField.uint32("comms_uhf_tm_store.uart0_rx_count", "UART0 RX Count", base.DEC)
+    local f_uart1_rx_count = ProtoField.uint32("comms_uhf_tm_store.uart1_rx_count", "UART1 RX Count", base.DEC)
+    local f_rx_mode = ProtoField.uint8("comms_uhf_tm_store.rx_mode", "RX Mode", base.DEC)
+    local f_tx_mode = ProtoField.uint8("comms_uhf_tm_store.tx_mode", "TX Mode", base.DEC)
+    local f_adc = ProtoField.int16("comms_uhf_tm_store.adc", "ADC Channel Stat", base.DEC)
+    local f_last_rssi = ProtoField.int8("comms_uhf_tm_store.last_rssi", "Last RSSI", base.DEC)
+    local f_last_lqi = ProtoField.uint8("comms_uhf_tm_store.last_lqi", "Last LQI", base.DEC)
+    local f_last_freqest = ProtoField.int8("comms_uhf_tm_store.last_freqest", "Last Frequency Estimation", base.DEC)
+    local f_pkt_sent = ProtoField.uint32("comms_uhf_tm_store.pkt_sent", "Packets Sent", base.DEC)
+    local f_cs_count = ProtoField.uint32("comms_uhf_tm_store.cs_count", "CS Count", base.DEC)
+    local f_pkt_good = ProtoField.uint32("comms_uhf_tm_store.pkt_good", "Packets Good", base.DEC)
+    local f_pkt_rejected_checksum = ProtoField.uint32("comms_uhf_tm_store.pkt_rejected_checksum", "Packets Rejected (Checksum)", base.DEC)
+    local f_pkt_rejected_reserved = ProtoField.uint32("comms_uhf_tm_store.pkt_rejected_reserved", "Packets Rejected (Reserved)", base.DEC)
+    local f_pkt_rejected_other = ProtoField.uint32("comms_uhf_tm_store.pkt_rejected_other", "Packets Rejected (Other)", base.DEC)
+    local f_reserved0 = ProtoField.uint32("comms_uhf_tm_store.reserved0", "Reserved 1", base.DEC)
+    local f_data_tx_cnt = ProtoField.uint32("comms_uhf_tm_store.data_tx_cnt", "Data uart tx cnt", base.DEC)
+    local f_data_rx_cnt = ProtoField.uint32("comms_uhf_tm_store.data_rx_cnt","Data uart rx cnt", base.DEC)
+
+    -- Add fields to the protocol
+    comms_uhf_tm_store.fields = { 
+        f_timestamp,
+        f_adc_cnt,
+        f_uptime,
+        f_uart0_rx_count,
+        f_uart1_rx_count,
+        f_rx_mode,
+        f_tx_mode,
+        f_adc,
+        f_last_rssi,
+        f_last_lqi,
+        f_last_freqest,
+        f_pkt_sent,
+        f_cs_count,
+        f_pkt_good,
+        f_pkt_rejected_checksum,
+        f_pkt_rejected_reserved,
+        f_pkt_rejected_other,
+        f_reserved0,
+        f_data_tx_cnt,
+        f_data_rx_cnt
+    }
+
+    -- Add a subtree for the structure
+    local subtree = tree:add(comms_uhf_tm_store, buffer(), "TM COMMS UHF GET TM STORE")
+
+    -- Dissect each field
+    -- ADC Count (1 byte)
+    local adc_cnt = buffer(offset, 1):le_uint()
+    subtree:add(f_adc_cnt, buffer(offset, 1)):set_text(string.format("ADC Count: %d", adc_cnt))
+    offset = offset + 1
+    
+    for i = 0, adc_cnt - 1 do
+    local subtree1 = subtree:add(comms_uhf_tm_store, buffer(), "INSTANCE"..i)
+    -- Timestamp
+    subtree1:add(f_timestamp, buffer(offset, 8):le_uint64())
+    offset = offset + 8
+
+    -- Device Uptime (4 bytes)
+    subtree1:add_le(f_uptime, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- UART0 RX Count (4 bytes)
+    subtree1:add_le(f_uart0_rx_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- UART1 RX Count (4 bytes)
+    subtree1:add_le(f_uart1_rx_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- RX Mode (1 byte)
+    subtree1:add(f_rx_mode, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- TX Mode (1 byte)
+    subtree1:add(f_tx_mode, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- ADC Channel Stat (10 * 2 bytes)
+    --local adc_subtree = subtree:add(buffer(offset, adc_cnt * 2), "ADC Channel Stats")
+    for i = 0, 10 - 1 do
+        local adc_value = buffer(offset, 2):le_int()
+        subtree1:add(f_adc, buffer(offset, 2)):set_text(string.format("ADC[%d]: %d", i + 1, adc_value))
+        offset = offset + 2
+    end
+
+    -- Last RSSI (1 byte)
+    subtree1:add(f_last_rssi, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Last LQI (1 byte)
+    subtree1:add(f_last_lqi, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Last Frequency Estimation (1 byte)
+    subtree1:add(f_last_freqest, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Packets Sent (4 bytes)
+    subtree1:add_le(f_pkt_sent, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- CS Count (4 bytes)
+    subtree1:add_le(f_cs_count, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Good (4 bytes)
+    subtree1:add_le(f_pkt_good, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Checksum) (4 bytes)
+    subtree1:add_le(f_pkt_rejected_checksum, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Reserved) (4 bytes)
+    subtree1:add_le(f_pkt_rejected_reserved, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Packets Rejected (Other) (4 bytes)
+    subtree1:add_le(f_pkt_rejected_other, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    --Reserved 0 (4 bytes)
+    subtree1:add_le(f_reserved0, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    -- Custom 0 (4 bytes)
+    subtree1:add_le(f_data_tx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    -- Custom 1 (4 bytes)
+    subtree1:add_le(f_data_rx_cnt, buffer(offset, 4))
+    offset = offset + 4
+    end
+
+end

Dissector/tm_get_comms_tm_info.lua

@@ -0,0 +1,106 @@
+--tm id - 398
+function tm_get_comms_tm_info(buffer, pinfo, tree, comms_tm_prop, offset)
+    -- Define ProtoFields for the structure
+    local f_temp_psu = ProtoField.int16("comms_tm_prop.temp_psu", "Temperature PSU", base.DEC)
+    local f_temp_mcu = ProtoField.int16("comms_tm_prop.temp_mcu", "Temperature MCU", base.DEC)
+    local f_temp_fpga = ProtoField.int16("comms_tm_prop.temp_fpga", "Temperature FPGA", base.DEC)
+    local f_temp_xcvr = ProtoField.int16("comms_tm_prop.temp_xcvr", "Temperature Transceiver", base.DEC)
+    local f_temp_lna = ProtoField.int16("comms_tm_prop.temp_lna", "Temperature LNA", base.DEC)
+    local f_temp_pa = ProtoField.int16("comms_tm_prop.temp_pa", "Temperature PA", base.DEC)
+    local f_volt_vin = ProtoField.uint16("comms_tm_prop.volt_vin", "Voltage Input (Vin)", base.DEC)
+    local f_volt_3v3 = ProtoField.uint16("comms_tm_prop.volt_3v3", "Voltage 3.3V Rail", base.DEC)
+    local f_volt_1v8 = ProtoField.uint16("comms_tm_prop.volt_1v8", "Voltage 1.8V Rail", base.DEC)
+    local f_volt_1v0 = ProtoField.uint16("comms_tm_prop.volt_1v0", "Voltage 1.0V Rail", base.DEC)
+    local f_volt_pa = ProtoField.uint16("comms_tm_prop.volt_pa", "Voltage PA", base.DEC)
+    local f_cur_vin = ProtoField.int16("comms_tm_prop.cur_vin", "Current Input (Vin)", base.DEC)
+    local f_cur_3v3 = ProtoField.int16("comms_tm_prop.cur_3v3", "Current 3.3V Rail", base.DEC)
+    local f_cur_1v8 = ProtoField.int16("comms_tm_prop.cur_1v8", "Current 1.8V Rail", base.DEC)
+    local f_cur_1v0 = ProtoField.int16("comms_tm_prop.cur_1v0", "Current 1.0V Rail", base.DEC)
+    local f_cur_pa = ProtoField.int16("comms_tm_prop.cur_pa", "Current PA", base.DEC)
+    local f_power_vin = ProtoField.uint16("comms_tm_prop.power_vin", "Power Input (Vin)", base.DEC)
+    local f_power_3v3 = ProtoField.uint16("comms_tm_prop.power_3v3", "Power 3.3V Rail", base.DEC)
+    local f_power_1v8 = ProtoField.uint16("comms_tm_prop.power_1v8", "Power 1.8V Rail", base.DEC)
+    local f_power_1v0 = ProtoField.uint16("comms_tm_prop.power_1v0", "Power 1.0V Rail", base.DEC)
+    local f_power_pa = ProtoField.uint16("comms_tm_prop.power_pa", "Power PA", base.DEC)
+    local f_rsvd = ProtoField.uint16("comms_tm_prop.rsvd", "Reserved", base.DEC)
+
+    -- Add fields to the protocol
+    comms_tm_prop.fields = {
+        f_temp_psu, f_temp_mcu, f_temp_fpga, f_temp_xcvr, f_temp_lna, f_temp_pa,
+        f_volt_vin, f_volt_3v3, f_volt_1v8, f_volt_1v0, f_volt_pa,
+        f_cur_vin, f_cur_3v3, f_cur_1v8, f_cur_1v0, f_cur_pa,
+        f_power_vin, f_power_3v3, f_power_1v8, f_power_1v0, f_power_pa,
+        f_rsvd
+    }
+
+    -- Add a subtree for the structure
+    local subtree = tree:add(comms_tm_prop, buffer(), "TM GET COMMS TM INFO")
+
+    -- Dissect each field
+    subtree:add_le(f_temp_psu, buffer(offset, 2)):set_text(string.format("Temperature PSU: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_temp_mcu, buffer(offset, 2)):set_text(string.format("Temperature MCU: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_temp_fpga, buffer(offset, 2)):set_text(string.format("Temperature FPGA: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_temp_xcvr, buffer(offset, 2)):set_text(string.format("Temperature Transceiver: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_temp_lna, buffer(offset, 2)):set_text(string.format("Temperature LNA: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_temp_pa, buffer(offset, 2)):set_text(string.format("Temperature PA: %d °C", buffer(offset, 2):le_int()))
+    offset = offset + 2
+
+    subtree:add_le(f_volt_vin, buffer(offset, 2)):set_text(string.format("Voltage Vint: %.6f V", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_volt_3v3, buffer(offset, 2)):set_text(string.format("Voltage vaux: %.6f V", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_volt_1v8, buffer(offset, 2)):set_text(string.format("Voltage vbram: %.6f V", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_volt_1v0, buffer(offset, 2)):set_text(string.format("Voltage vpint: %.6f V", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_volt_pa, buffer(offset, 2)):set_text(string.format("Voltage vpaux: %.6f V", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_cur_vin, buffer(offset, 2)):set_text(string.format("Current Vin: %.6f A", buffer(offset, 2):le_int() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_cur_3v3, buffer(offset, 2)):set_text(string.format("Current 3.3V: %.6f A", buffer(offset, 2):le_int() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_cur_1v8, buffer(offset, 2)):set_text(string.format("Current 1.8V: %.6f A", buffer(offset, 2):le_int() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_cur_1v0, buffer(offset, 2)):set_text(string.format("Current 1.0V: %.6f A", buffer(offset, 2):le_int() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_cur_pa, buffer(offset, 2)):set_text(string.format("Current PA: %.6f A", buffer(offset, 2):le_int() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_power_vin, buffer(offset, 2)):set_text(string.format("Power Vin: %.6f W", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_power_3v3, buffer(offset, 2)):set_text(string.format("Power 3.3V: %.6f W", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_power_1v8, buffer(offset, 2)):set_text(string.format("Power 1.8V: %.6f W", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_power_1v0, buffer(offset, 2)):set_text(string.format("Power 1.0V: %.6f W", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_power_pa, buffer(offset, 2)):set_text(string.format("Power PA: %.6f W", buffer(offset, 2):le_uint() / 100))
+    offset = offset + 2
+
+    subtree:add_le(f_rsvd, buffer(offset, 2)):set_text(string.format("Reserved : %.6f", buffer(offset, 2):le_uint() / 100) )
+    offset = offset + 2
+
+end

Dissector/tm_get_sband_dbg_cb.lua

@@ -0,0 +1,100 @@
+function tm_get_sband_dbg_cb(buffer, pinfo, tree, sband_dbg_cb, offset)
+    -- Define ProtoFields
+    local f_state = ProtoField.uint8("sband_dbg_cb.state", "State", base.DEC)
+    local f_sch_gs_cont = ProtoField.uint8("sband_dbg_cb.sband_sch_gs_cont", "Scheduler Ground Station Contact", base.DEC)
+    local f_gs_cont_valid = ProtoField.uint8("sband_dbg_cb.sband_gs_cont_valid", "Ground Station Contact Valid", base.DEC)
+
+    local f_udp_rx_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_rx_cnt", "UDP RX Count", base.DEC)
+    local f_udp_tx_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_cnt", "UDP TX Count", base.DEC)
+    local f_udp_rx_less_len_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_rx_less_len_cnt", "UDP RX Less Length Count", base.DEC)
+    local f_udp_tx_send_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_send_fail_cnt", "UDP TX Send Fail Count", base.DEC)
+    local f_udp_tx_pkt_drop_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_pkt_drop_cnt", "UDP TX Packet Drop Count", base.DEC)
+    local f_udp_tx_len_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_len_fail_cnt", "UDP TX Length Fail Count", base.DEC)
+    local f_udp_tx_crc_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_crc_fail_cnt", "UDP TX CRC Fail Count", base.DEC)
+    local f_udp_tx_busy_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_busy_fail_cnt", "UDP TX Busy Fail Count", base.DEC)
+    local f_udp_tx_fifo_full_cnt = ProtoField.uint32("sband_dbg_cb.sband_udp_tx_fifo_full_cnt", "UDP TX FIFO Full Count", base.DEC)
+
+    local f_tcp_read_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_tcp_read_fail_cnt", "TCP Read Fail Count", base.DEC)
+    local f_tcp_conn_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_tcp_conn_fail_cnt", "TCP Connection Fail Count", base.DEC)
+    local f_tcp_write_fail_cnt = ProtoField.uint32("sband_dbg_cb.sband_tcp_write_fail_cnt", "TCP Write Fail Count", base.DEC)
+    local f_tcp_read_busy_cnt = ProtoField.uint32("sband_dbg_cb.sband_tcp_read_busy_cnt", "TCP Read Busy Count", base.DEC)
+
+    local f_rx_swt_cnt = ProtoField.uint32("sband_dbg_cb.sband_rx_swt_cnt", "RX Switch Count", base.DEC)
+
+    -- Register the fields in the protocol
+    sband_dbg_cb.fields = {
+        f_state,
+        f_sch_gs_cont,
+        f_gs_cont_valid,
+        f_udp_rx_cnt,
+        f_udp_tx_cnt,
+        f_udp_rx_less_len_cnt,
+        f_udp_tx_send_fail_cnt,
+        f_udp_tx_pkt_drop_cnt,
+        f_udp_tx_len_fail_cnt,
+        f_udp_tx_crc_fail_cnt,
+        f_udp_tx_busy_fail_cnt,
+        f_udp_tx_fifo_full_cnt,
+        f_tcp_read_fail_cnt,
+        f_tcp_conn_fail_cnt,
+        f_tcp_write_fail_cnt,
+        f_tcp_read_busy_cnt,
+        f_rx_swt_cnt
+    }
+
+    -- Create a subtree for the structure
+    local subtree = tree:add(sband_dbg_cb, buffer(), "TM SBAND GET DBG CB INFO")
+
+    -- Dissect the fields
+    subtree:add_le(f_state, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    subtree:add_le(f_sch_gs_cont, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    subtree:add_le(f_gs_cont_valid, buffer(offset, 1):le_uint())
+    offset = offset + 1
+
+    subtree:add_le(f_udp_rx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_rx_less_len_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_send_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_pkt_drop_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_len_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_crc_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_busy_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_udp_tx_fifo_full_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_tcp_read_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_tcp_conn_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_tcp_write_fail_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_tcp_read_busy_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+    subtree:add_le(f_rx_swt_cnt, buffer(offset, 4):le_uint())
+    offset = offset + 4
+
+end

Dissector/tm_get_sband_tx_rx_on_ts.lua

@@ -0,0 +1,61 @@
+function tm_get_sband_tx_rx_on_ts(buffer, pinfo, tree, sband_tx_rx_sts_timestamp, offset)
+    -- Define ProtoFields for s_sband_rx_sts_timestamp
+    local f_rx0_sts = ProtoField.uint8("sband_rx_sts_timestamp.rx0_sts", "Rx0 Status", base.DEC)
+    local f_rx1_sts = ProtoField.uint8("sband_rx_sts_timestamp.rx1_sts", "Rx1 Status", base.DEC)
+    local f_timestamp_rx = ProtoField.uint64("sband_rx_sts_timestamp.timestamp", "Timestamp", base.DEC)
+
+    -- Define ProtoFields for s_sband_tx_sts_timestamp
+    local f_tx_sts = ProtoField.uint8("sband_tx_sts_timestamp.tx_sts", "Tx Status", base.DEC)
+    local f_timestamp_tx = ProtoField.uint64("sband_tx_sts_timestamp.timestamp", "Timestamp", base.DEC)
+
+    -- Define ProtoFields for s_sband_tx_rx_sts_timestamp
+    local f_tx_index = ProtoField.uint16("sband_tx_rx_sts_timestamp.tx_index", "Tx Index", base.DEC)
+    local f_rx_index = ProtoField.uint16("sband_tx_rx_sts_timestamp.rx_index", "Rx Index", base.DEC)
+    
+    -- Register the fields in the protocol
+    sband_tx_rx_sts_timestamp.fields = {
+        f_tx_index, f_rx_index, 
+        f_tx_sts, f_timestamp_tx, 
+        f_rx0_sts, f_rx1_sts, f_timestamp_rx
+    }
+
+    -- Create the subtree for `sband_tx_rx_sts_timestamp`
+    local subtree = tree:add(sband_tx_rx_sts_timestamp, buffer(), "TM SBAND TX RX STS TIMESTAMP")
+
+    -- Parse the `tx_index` and `rx_index`
+    
+    subtree:add(f_tx_index, buffer(offset, 2):le_uint())
+    offset = offset + 2
+    subtree:add(f_rx_index, buffer(offset, 2):le_uint())
+    offset = offset + 2
+
+    -- Parse the `tx_ts` array (50 entries of `s_sband_tx_sts_timestamp`)
+    for i = 0, 49 do
+        local tx_subtree = subtree:add(buffer(offset), "TX Info Index" .. i)
+
+        -- Parse `tx_sts` (1 byte)
+        tx_subtree:add(f_tx_sts, buffer(offset, 1):le_uint())
+        offset = offset + 1
+
+        -- Parse `timestamp` (8 bytes)
+        tx_subtree:add(f_timestamp_tx, buffer(offset, 8):le_uint64())
+        offset = offset + 8
+    end
+
+    -- Parse the `rx_ts` array (50 entries of `s_sband_rx_sts_timestamp`)
+    for i = 0, 49 do
+        local rx_subtree = subtree:add(buffer(offset), "RX Info Index" .. i)
+
+        -- Parse `rx0_sts` (1 byte)
+        rx_subtree:add(f_rx0_sts, buffer(offset, 1):le_uint())
+        offset = offset + 1
+
+        -- Parse `rx1_sts` (1 byte)
+        rx_subtree:add(f_rx1_sts, buffer(offset, 1):le_uint())
+        offset = offset + 1
+
+        -- Parse `timestamp` (8 bytes)
+        rx_subtree:add(f_timestamp_rx, buffer(offset, 8):le_uint64())
+        offset = offset + 8
+    end
+end

Dissector/tm_get_sband_version.lua

@@ -0,0 +1,64 @@
+function tm_get_sband_version(buffer, pinfo, tree, sband_version, offset)
+    -- Define ProtoFields
+    local f_file_cnt = ProtoField.uint8("sband_version.file_cnt", "File Count", base.DEC)
+    local f_file_name_cnt = ProtoField.uint8("sband_version.file_name_cnt", "File Name Count", base.DEC)
+    local f_seconds = ProtoField.uint8("sband_version.seconds", "Seconds", base.DEC)
+    local f_minutes = ProtoField.uint8("sband_version.minutes", "Minutes", base.DEC)
+    local f_hours = ProtoField.uint8("sband_version.hours", "Hours", base.DEC)
+    local f_year = ProtoField.uint16("sband_version.year", "Year", base.DEC)
+    local f_months = ProtoField.uint8("sband_version.months", "Months", base.DEC)
+    local f_day = ProtoField.uint8("sband_version.day", "Day", base.DEC)
+    local f_file_name = ProtoField.bytes("sband_version.file_name", "File Name")
+    local f_start_adr = ProtoField.uint32("sband_version.start_adr", "Start Address", base.HEX)
+    local f_len = ProtoField.uint32("sband_version.len", "Length", base.DEC)
+    local f_flags = ProtoField.uint8("sband_version.flags", "Flags", base.HEX)
+
+    -- Register the fields in the protocol
+    sband_version.fields = {
+        f_file_cnt, f_file_name_cnt,
+        f_seconds, f_minutes, f_hours, f_year, f_months, f_day,
+        f_file_name, f_start_adr, f_len, f_flags
+    }
+
+    -- Create the subtree for `version_date_struct`
+    local subtree = tree:add(sband_version, buffer(), "TM GET SBAND VERSION")
+
+    -- Parse `file_cnt`
+    local cnt = buffer(offset, 1):le_uint()
+    subtree:add(f_file_cnt, buffer(offset, 1))
+    offset = offset + 1
+
+    -- Parse `file_name_cnt`
+    --subtree:add(f_file_name_cnt, buffer(offset, 1))
+    --offset = offset + 1
+
+    -- Parse `VERSION_DATE_STRUCT`
+    for i = 0 , cnt - 1 do
+    local version_subtree = subtree:add(buffer(offset), "VERSION_DATE_STRUCT")
+
+    -- Parse the packed date/time fields (32 bits)
+    local date_time_value = buffer(offset, 4):le_uint()
+    version_subtree:add(f_seconds, (date_time_value & 0x3F)) -- 6 bits
+    version_subtree:add(f_minutes, ((date_time_value >> 6) & 0x3F)) -- 6 bits
+    version_subtree:add(f_hours, ((date_time_value >> 12) & 0x1F)) -- 5 bits
+    version_subtree:add(f_year, ((date_time_value >> 17) & 0x3F)) -- 6 bits
+    version_subtree:add(f_months, ((date_time_value >> 23) & 0x0F)) -- 4 bits
+    version_subtree:add(f_day, ((date_time_value >> 27) & 0x1F)) -- 5 bits
+    offset = offset + 4
+
+    -- Parse `FileName` (4 bytes)
+    version_subtree:add(f_file_name, buffer(offset, 4))
+    offset = offset + 4
+
+    -- Parse `start_adr` (32 bits)
+    version_subtree:add_le(f_start_adr, buffer(offset, 4))
+    offset = offset + 4
+
+    -- Parse the packed `len` and `Flags` fields (32 bits)
+    local len_flags_value = buffer(offset, 4):le_uint()
+    version_subtree:add(f_len, (len_flags_value & 0x0FFFFFFF)) -- 28 bits
+    version_subtree:add(f_flags, ((len_flags_value >> 28) & 0x0F)) -- 4 bits
+    offset = offset + 4
+    end
+
+end

Dissector/tm_get_sdr_rssi_cfg.lua

@@ -0,0 +1,61 @@
+function tm_get_sdr_rssi_cfg(buffer, pinfo, tree, sdr_rssi_cfg, offset)
+    -- Define ProtoFields for the structure
+    local f_valid_rssi_cnt = ProtoField.uint8("sdr_rssi_cfg.valid_rssi_cnt", "Valid RSSI Count", base.DEC)
+    local f_inv_rssi_cnt = ProtoField.uint8("sdr_rssi_cfg.inv_rssi_cnt", "Invalid RSSI Count", base.DEC)
+    local f_rssi_min = ProtoField.float("sdr_rssi_cfg.rssi_min", "RSSI Min", base.DEC)
+    local f_rssi_typ = ProtoField.float("sdr_rssi_cfg.rssi_typ", "RSSI Typ", base.DEC)
+    local f_rssi_prd_tmr = ProtoField.uint32("sdr_rssi_cfg.rssi_prd_tmr", "RSSI Period Timer", base.DEC)
+    local f_short_rx_on_tmr = ProtoField.uint32("sdr_rssi_cfg.short_rx_on_tmr", "Short RX On Timer", base.DEC)
+    local f_long_rx_on_tmr = ProtoField.uint32("sdr_rssi_cfg.long_rx_on_tmr", "Long RX On Timer", base.DEC)
+
+    -- Add fields to the protocol
+    sdr_rssi_cfg.fields = { 
+        f_valid_rssi_cnt,
+        f_inv_rssi_cnt,
+        f_rssi_min,
+        f_rssi_typ,
+        f_rssi_prd_tmr,
+        f_short_rx_on_tmr,
+        f_long_rx_on_tmr
+    }
+
+    -- Add a subtree for the structure
+    local subtree = tree:add(sdr_rssi_cfg, buffer(), "TM GET SDR RX RSSI CNFG")
+
+    -- Dissect each field
+    -- Valid RSSI Count (1 byte)
+    local valid_rssi_cnt = buffer(offset, 1):uint()
+    subtree:add(f_valid_rssi_cnt, buffer(offset, 1)):set_text(string.format("Valid RSSI Count: %d", valid_rssi_cnt))
+    offset = offset + 1
+
+    -- Invalid RSSI Count (1 byte)
+    local inv_rssi_cnt = buffer(offset, 1):uint()
+    subtree:add(f_inv_rssi_cnt, buffer(offset, 1)):set_text(string.format("Invalid RSSI Count: %d", inv_rssi_cnt))
+    offset = offset + 1
+
+    -- RSSI Min (4 bytes, float)
+    local rssi_min = buffer(offset, 4):le_float()
+    subtree:add(f_rssi_min, buffer(offset, 4)):set_text(string.format("RSSI Min: %.6f", rssi_min))
+    offset = offset + 4
+
+    -- RSSI Typ (4 bytes, float)
+    local rssi_typ = buffer(offset, 4):le_float()
+    subtree:add(f_rssi_typ, buffer(offset, 4)):set_text(string.format("RSSI Typ: %.6f", rssi_typ))
+    offset = offset + 4
+
+    -- RSSI Period Timer (4 bytes, uint32)
+    local rssi_prd_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_rssi_prd_tmr, buffer(offset, 4)):set_text(string.format("RSSI Period Timer: %d", rssi_prd_tmr))
+    offset = offset + 4
+
+    -- Short RX On Timer (4 bytes, uint32)
+    local short_rx_on_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_short_rx_on_tmr, buffer(offset, 4)):set_text(string.format("Short RX On Timer: %d", short_rx_on_tmr))
+    offset = offset + 4
+
+    -- Long RX On Timer (4 bytes, uint32)
+    local long_rx_on_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_long_rx_on_tmr, buffer(offset, 4)):set_text(string.format("Long RX On Timer: %d", long_rx_on_tmr))
+    offset = offset + 4
+
+end

Dissector/tm_get_sdr_tmr_cfg.lua

@@ -0,0 +1,61 @@
+function tm_get_sdr_tmr_cfg(buffer, pinfo, tree, sdr_tmr_cfg, offset)
+    -- Define ProtoFields for the structure
+    local f_beacon_enb_tmr = ProtoField.uint32("sdr_tmr_cfg.beacon_enb_tmr", "Beacon Enable Timer", base.DEC)
+    local f_beacon_prd_tmr = ProtoField.uint32("sdr_tmr_cfg.beacon_prd_tmr", "Beacon Period Timer", base.DEC)
+    local f_beacon_rep_tmr = ProtoField.uint32("sdr_tmr_cfg.beacon_rep_tmr", "Beacon Repetition Timer", base.DEC)
+    local f_tx_data_rep_cnt = ProtoField.uint32("sdr_tmr_cfg.tx_data_rep_cnt", "TX Data Repetition Count", base.DEC)
+    local f_sdr_tm_tx_tmr = ProtoField.uint32("sdr_tmr_cfg.sdr_tm_tx_tmr", "SDR TM TX Timer", base.DEC)
+    local f_sdr_tx_on_tmr = ProtoField.uint32("sdr_tmr_cfg.sdr_tx_on_tmr", "SDR TX On Timer", base.DEC)
+    local f_sdr_rx_on_tmr = ProtoField.uint32("sdr_tmr_cfg.sdr_rx_on_tmr", "SDR RX On Timer", base.DEC)
+    local f_sdr_tm_read_tmr = ProtoField.uint32("sdr_tmr_cfg.sdr_tm_read_tmr", "SDR TM Read Timer", base.DEC)
+
+    -- Add fields to the protocol
+    sdr_tmr_cfg.fields = { 
+        f_beacon_enb_tmr,
+        f_beacon_prd_tmr,
+        f_beacon_rep_tmr,
+        f_tx_data_rep_cnt,
+        f_sdr_tm_tx_tmr,
+        f_sdr_tx_on_tmr,
+        f_sdr_rx_on_tmr,
+        f_sdr_tm_read_tmr
+    }
+
+    -- Add a subtree for the structure
+    local subtree = tree:add(sdr_tmr_cfg, buffer(), "TM GET SDR TMR CNFG")
+
+    -- Dissect each field (4 bytes each)
+    local beacon_enb_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_beacon_enb_tmr, buffer(offset, 4)):set_text(string.format("Beacon Enable Timer: %d", beacon_enb_tmr))
+    offset = offset + 4
+
+    local beacon_prd_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_beacon_prd_tmr, buffer(offset, 4)):set_text(string.format("Beacon Period Timer: %d", beacon_prd_tmr))
+    offset = offset + 4
+
+    local beacon_rep_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_beacon_rep_tmr, buffer(offset, 4)):set_text(string.format("Beacon Repetition Timer: %d", beacon_rep_tmr))
+    offset = offset + 4
+
+    local tx_data_rep_cnt = buffer(offset, 4):le_uint()
+    subtree:add(f_tx_data_rep_cnt, buffer(offset, 4)):set_text(string.format("TX Data Repetition Count: %d", tx_data_rep_cnt))
+    offset = offset + 4
+
+    local sdr_tm_tx_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_sdr_tm_tx_tmr, buffer(offset, 4)):set_text(string.format("SDR TM TX Timer: %d", sdr_tm_tx_tmr))
+    offset = offset + 4
+
+    local sdr_tx_on_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_sdr_tx_on_tmr, buffer(offset, 4)):set_text(string.format("SDR TX On Timer: %d", sdr_tx_on_tmr))
+    offset = offset + 4
+
+    local sdr_rx_on_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_sdr_rx_on_tmr, buffer(offset, 4)):set_text(string.format("SDR RX On Timer: %d", sdr_rx_on_tmr))
+    offset = offset + 4
+
+    local sdr_tm_read_tmr = buffer(offset, 4):le_uint()
+    subtree:add(f_sdr_tm_read_tmr, buffer(offset, 4)):set_text(string.format("SDR TM Read Timer: %d", sdr_tm_read_tmr))
+    offset = offset + 4
+
+    return offset
+end

Dissector/tm_sband_get_device_conf.lua

@@ -0,0 +1,452 @@
+-- Define the protocol
+function tm_sband_get_device_conf(buffer, pinfo, tree, tm_sband_get_device_conf, offset)
+
+-- Define ProtoFields with three arguments
+local f_rfe_rx0_on = ProtoField.uint32("tm_sband_get_device_conf.RfeRx0On", "RFE RX0 On", base.HEX)
+local f_rfe_tx0_on = ProtoField.uint32("tm_sband_get_device_conf.RfeTx0On", "RFE TX0 On", base.HEX)
+local f_rfe_pa0_on = ProtoField.uint32("tm_sband_get_device_conf.RfePa0On", "RFE PA0 On", base.HEX)
+local f_rfe_rx_tx0 = ProtoField.uint32("tm_sband_get_device_conf.RfeRxTx0", "RFE RX TX0", base.HEX)
+local f_rfe_rx1_on = ProtoField.uint32("tm_sband_get_device_conf.RfeRx1On", "RFE RX1 On", base.HEX)
+local f_rfe_tx1_on = ProtoField.uint32("tm_sband_get_device_conf.RfeTx1On", "RFE TX1 On", base.HEX)
+local f_rfe_pa1_on = ProtoField.uint32("tm_sband_get_device_conf.RfePa1On", "RFE PA1 On", base.HEX)
+local f_rfe_rx_tx1 = ProtoField.uint32("tm_sband_get_device_conf.RfeRxTx1", "RFE RX TX1", base.HEX)
+local f_rfe_out_en = ProtoField.uint32("tm_sband_get_device_conf.RfeOutEn", "RFE Out Enable", base.HEX)
+local f_rfe_gpio0 = ProtoField.uint32("tm_sband_get_device_conf.RfeGpio0", "RFE GPIO0", base.HEX)
+local f_rfe_loop_det = ProtoField.uint32("tm_sband_get_device_conf.RfeLoopDet", "RFE Loop Detect", base.HEX)
+local f_rfe_lo_mux = ProtoField.uint32("tm_sband_get_device_conf.RfeLoMux", "RFE LO Mux", base.HEX)
+local f_rfe_pow_on = ProtoField.uint32("tm_sband_get_device_conf.RfePowOn", "RFE Power On", base.HEX)
+local f_rfe_da = ProtoField.uint32("tm_sband_get_device_conf.RfeDA", "RFE DA", base.HEX)
+local f_rfe_cl = ProtoField.uint32("tm_sband_get_device_conf.RfeCL", "RFE CL", base.HEX)
+local f_rfe_en_ad5304 = ProtoField.uint32("tm_sband_get_device_conf.RfeEnAD5304", "RFE Enable AD5304", base.HEX)
+local f_rfe_en_synth = ProtoField.uint32("tm_sband_get_device_conf.RfeEnSynth", "RFE Enable Synthesizer", base.HEX)
+local f_rfe_en3 = ProtoField.uint32("tm_sband_get_device_conf.RfeEn3", "RFE Enable 3", base.HEX)
+local f_rfe_en4 = ProtoField.uint32("tm_sband_get_device_conf.RfeEn4", "RFE Enable 4", base.HEX)
+local f_rfe_en5 = ProtoField.uint32("tm_sband_get_device_conf.RfeEn5", "RFE Enable 5", base.HEX)
+local f_rfe_7v0_en = ProtoField.uint32("tm_sband_get_device_conf.Rfe7V0En", "RFE 7V0 Enable", base.HEX)
+local f_rfe_rsv_uint32 = ProtoField.uint32("tm_sband_get_device_conf.RfeRsvuint32", "Reserved Bits", base.HEX)
+
+local f_rxmix_ch0 = ProtoField.int32("tm_sband_get_device_conf.rxmix_ch0", "receive DownConversionFrequency channel 0", base.DEC)
+local f_rxmix_ch1 = ProtoField.int32("tm_sband_get_device_conf.rxmix_ch1", "receive DownConversionFrequency channel 1", base.DEC)
+
+local f_txmix_ch0 = ProtoField.int32("tm_sband_get_device_conf.txmix_ch0", "transmit UpConversionFrequency channel 0", base.DEC)
+local f_txmix_ch1 = ProtoField.int32("tm_sband_get_device_conf.txmix_ch1", "transmit UpConversionFrequency channel 1", base.DEC)
+
+local f_rxfreq_ch0 = ProtoField.int32("tm_sband_get_device_conf.rxfreq_ch0", "receive Frequency Channel0 :", base.DEC)
+local f_rxfreq_ch1 = ProtoField.int32("tm_sband_get_device_conf.rxfreq_ch1", "receive Frequency Channel1 :", base.DEC)
+
+local f_txfreq_ch0 = ProtoField.int32("tm_sband_get_device_conf.txfreq_ch0", "transmit Frequency Channel0 :", base.DEC)
+local f_txfreq_ch1 = ProtoField.int32("tm_sband_get_device_conf.txfreq_ch1", "transmit Frequency Channel1 :", base.DEC)
+
+local f_rxlow_ch0 = ProtoField.int32("tm_sband_get_device_conf.rxlow_ch0", "Rcv lowest  possible frequency Channel0 : ", base.DEC)
+local f_rxlow_ch1 = ProtoField.int32("tm_sband_get_device_conf.rxlow_ch1", "Rcv lowest  possible frequency Channel1 :", base.DEC)
+
+local f_rxhigh_ch0 = ProtoField.int32("tm_sband_get_device_conf.rxhigh_ch0", "Rcv highest  possible frequency Channel0 : ", base.DEC)
+local f_rxhigh_ch1 = ProtoField.int32("tm_sband_get_device_conf.rxhigh_ch1", "Rcv highest  possible frequency Channel0 : ", base.DEC)
+
+local f_txlow_ch0 = ProtoField.int32("tm_sband_get_device_conf.txlow_ch0", "Xmt lowest  possible frequency Channel0 : ", base.DEC)
+local f_txlow_ch1 = ProtoField.int32("tm_sband_get_device_conf.txlow_ch1", "Xmt lowest  possible frequency Channel1 : ", base.DEC)
+
+local f_txhigh_ch0 = ProtoField.int32("tm_sband_get_device_conf.txhigh_ch0", "Xmt highest  possible frequency Channel0 : ", base.DEC)
+local f_txhigh_ch1 = ProtoField.int32("tm_sband_get_device_conf.txhigh_ch1", "Xmt highest  possible frequency Channel1 : ", base.DEC)
+
+local f_2rx2tx = ProtoField.uint32("tm_sband_get_device_conf._2rx2tx", "Flag for use 2Rx2Tx mode : ", base.DEC)  -- 1 bit
+local f_txlevel_0 = ProtoField.uint32("tm_sband_get_device_conf.txlevel_0", "Tx Level for XmtChannel 0 ", base.DEC)  -- 11 bits
+local f_txlevel_1 = ProtoField.uint32("tm_sband_get_device_conf.txlevel_1", "Tx Level for XmtChannel 1 ", base.DEC)  -- 11 bits
+local f_refclk = ProtoField.uint32("tm_sband_get_device_conf.refclk", "AD9361 reference clock in MHz : ", base.DEC)  -- 8 bits
+local f_reserve = ProtoField.uint32("tm_sband_get_device_conf.reserve", "Reserve", base.DEC)  -- 1 bit
+
+local f_modulat_0 = ProtoField.uint32("tm_sband_get_device_conf.modulat_0", "Xmt Modulation Channel_0 :", base.DEC)  -- 3 bits
+local f_mode_0 = ProtoField.uint32("tm_sband_get_device_conf.mode_0", "Xmt Mode Channel_0:", base.DEC)         -- 4 bits
+local f_fec_0 = ProtoField.uint32("tm_sband_get_device_conf.fec_0", "Fec 0", base.DEC)           -- 3 bits
+local f_chen_0 = ProtoField.uint32("tm_sband_get_device_conf.chen_0", "ChEn 0", base.DEC)        -- 1 bit
+local f_prnd_0 = ProtoField.uint32("tm_sband_get_device_conf.prnd_0", "PRnd 0", base.DEC)        -- 1 bit
+local f_asmstart_0 = ProtoField.uint32("tm_sband_get_device_conf.asmstart_0", "ASMStart 0", base.DEC) -- 1 bit
+local f_offsetmod_0 = ProtoField.uint32("tm_sband_get_device_conf.offsetmod_0", "OffsetMod 0", base.DEC) -- 1 bit
+local f_ch1_diff_ch2 = ProtoField.uint32("tm_sband_get_device_conf.ch1_diff_ch2", "Ch1_diff_Ch2", base.DEC) -- 1 bit
+local f_chswitchon_0 = ProtoField.uint32("tm_sband_get_device_conf.chswitchon_0", "ChSwitchOn 0", base.DEC) -- 1 bit
+
+local f_modulat_1 = ProtoField.uint32("tm_sband_get_device_conf.modulat_1", "Modulat 1", base.DEC) -- 3 bits
+local f_mode_1 = ProtoField.uint32("tm_sband_get_device_conf.mode_1", "Mode 1", base.DEC)         -- 4 bits
+local f_fec_1 = ProtoField.uint32("tm_sband_get_device_conf.fec_1", "Fec 1", base.DEC)           -- 3 bits
+local f_chen_1 = ProtoField.uint32("tm_sband_get_device_conf.chen_1", "ChEn 1", base.DEC)        -- 1 bit
+local f_prnd_1 = ProtoField.uint32("tm_sband_get_device_conf.prnd_1", "PRnd 1", base.DEC)        -- 1 bit
+local f_asmstart_1 = ProtoField.uint32("tm_sband_get_device_conf.asmstart_1", "ASMStart 1", base.DEC) -- 1 bit
+local f_offsetmod_1 = ProtoField.uint32("tm_sband_get_device_conf.offsetmod_1", "OffsetMod 1", base.DEC) -- 1 bit
+local f_chswitchon_1 = ProtoField.uint32("tm_sband_get_device_conf.chswitchon_1", "ChSwitchOn 1", base.DEC) -- 1 bit
+
+local f_offsetmodnormaly = ProtoField.uint32("tm_sband_get_device_conf.offsetmodnormaly", "OffsetModNormaly", base.DEC) -- 1 bit
+
+local f_atttxgain_0 = ProtoField.uint32("tm_sband_get_device_conf.atttxgain_0", "AttTxGain 0", base.DEC) -- 10 bits
+local f_atttxgain_1 = ProtoField.uint32("tm_sband_get_device_conf.atttxgain_1", "AttTxGain 1", base.DEC) -- 10 bits
+local f_trfrmsz = ProtoField.uint32("tm_sband_get_device_conf.trfrmsz", "TrFrmSz", base.DEC)             -- 12 bits
+
+local f_phioffset16 = ProtoField.int32("tm_sband_get_device_conf.phioffset16", "PhiOffset16", base.DEC) -- 5 bits
+local f_y16 = ProtoField.uint32("tm_sband_get_device_conf.y16", "Y16", base.DEC)                       -- 13 bits
+local f_txsampfact = ProtoField.uint32("tm_sband_get_device_conf.txsampfact", "TxSampFact", base.DEC)  -- 10 bits
+local f_rsmode = ProtoField.uint32("tm_sband_get_device_conf.rsmode", "RsMode", base.DEC)              -- 4 bits
+
+local f_rxgainmax = ProtoField.uint32("tm_sband_get_device_conf.rxgainmax", "RxGainMax", base.HEX)   -- 8 bits
+local f_chen = ProtoField.uint32("tm_sband_get_device_conf.chen", "ChEn", base.HEX)                  -- 1 bit
+local f_modulat = ProtoField.uint32("tm_sband_get_device_conf.modulat", "Modulat", base.HEX)           -- 3 bits
+local f_msbfirst = ProtoField.uint32("tm_sband_get_device_conf.msbfirst", "MsbFirst", base.HEX)        -- 1 bit
+local f_fec = ProtoField.uint32("tm_sband_get_device_conf.fec", "Fec", base.HEX)                      -- 3 bits
+local f_prnd = ProtoField.uint32("tm_sband_get_device_conf.prnd", "PRnd", base.HEX)                    -- 1 bit
+local f_bchdec = ProtoField.uint32("tm_sband_get_device_conf.bchdec", "BchDec", base.HEX)              -- 1 bit
+local f_accbcherr = ProtoField.uint32("tm_sband_get_device_conf.accbcherr", "AccBchErr", base.HEX)      -- 1 bit
+local f_bchcountmode = ProtoField.uint32("tm_sband_get_device_conf.bchcountmode", "BchCountMode", base.HEX) -- 1 bit
+local f_pwroff = ProtoField.uint32("tm_sband_get_device_conf.pwroff", "PwrOff", base.DEC)              -- 6 bits
+local f_rcvcalib = ProtoField.int32("tm_sband_get_device_conf.rcvcalib", "RcvCalib", base.DEC)         -- 6 bits
+
+local f_xmtsymbfreq = ProtoField.uint32("tm_sband_get_device_conf.xmtsymbfreq", "XmtSymbFreq", base.DEC) -- 16 bits
+local f_rcvsymbfreq = ProtoField.uint32("tm_sband_get_device_conf.rcvsymbfreq", "RcvSymbFreq", base.DEC) -- 16 bits
+
+local f_rcvmode = ProtoField.uint32("tm_sband_get_device_conf.rcvmode", "RcvMode", base.HEX)       -- 4 bits
+local f_rcvchannel = ProtoField.uint32("tm_sband_get_device_conf.rcvchannel", "RcvChannel", base.HEX) -- 2 bits
+local f_chnswitchon_0 = ProtoField.uint32("tm_sband_get_device_conf.chnswitchon_0", "ChSwitchOn_0", base.HEX) -- 1 bit
+local f_chnswitchon_1 = ProtoField.uint32("tm_sband_get_device_conf.chnswitchon_1", "ChSwitchOn_1", base.HEX) -- 1 bit
+local f_dropsample = ProtoField.uint32("tm_sband_get_device_conf.dropsample", "DropSample", base.DEC)   -- 12 bits
+local f_dtminus = ProtoField.uint32("tm_sband_get_device_conf.dtminus", "dT_minus", base.HEX)          -- 1 bit
+local f_dtplus = ProtoField.uint32("tm_sband_get_device_conf.dtplus", "dT_plus", base.HEX)            -- 1 bit
+local f_reserve1 = ProtoField.uint32("tm_sband_get_device_conf.reserve1", "Reserve", base.HEX)           -- 10 bits
+
+-- Register fields with the protocol
+tm_sband_get_device_conf.fields = {
+    f_rfe_rx0_on, f_rfe_tx0_on, f_rfe_pa0_on, f_rfe_rx1_on, f_rfe_tx1_on, f_rfe_pa1_on,
+    f_rfe_rx_tx1, f_rfe_out_en, f_rfe_gpio0, f_rfe_loop_det, f_rfe_lo_mux, f_rfe_pow_on,
+    f_rfe_da, f_rfe_cl, f_rfe_en_ad5304, f_rfe_en_synth, f_rfe_en3, f_rfe_en4, f_rfe_en5,
+    f_rfe_7v0_en, f_rfe_rsv_uint32, f_rfe_rx_tx0, f_rxmix_ch0, f_rxmix_ch1,f_txmix_ch0, 
+    f_txmix_ch1, f_rxfreq_ch0, f_rxfreq_ch1, f_txfreq_ch0, f_txfreq_ch1, f_rxlow_ch0, f_rxlow_ch1,
+    f_rxhigh_ch0, f_rxhigh_ch1, f_txlow_ch0, f_txlow_ch1, f_txhigh_ch0, f_txhigh_ch1, 
+    f_2rx2tx, f_txlevel_0, f_txlevel_1, f_refclk, f_reserve, f_modulat_0, f_mode_0, f_fec_0,
+     f_chen_0, f_prnd_0, f_asmstart_0, f_offsetmod_0, f_ch1_diff_ch2, f_chswitchon_0,
+    f_modulat_1, f_mode_1, f_fec_1, f_chen_1, f_prnd_1, f_asmstart_1, f_offsetmod_1, f_chswitchon_1,
+    f_offsetmodnormaly, f_atttxgain_0, f_atttxgain_1, f_trfrmsz, f_phioffset16, f_y16, f_txsampfact, f_rsmode,
+    f_rxgainmax, f_chen, f_modulat, f_msbfirst, f_fec, f_prnd, f_bchdec, f_accbcherr, 
+                      f_bchcountmode, f_pwroff, f_rcvcalib, f_xmtsymbfreq, f_rcvsymbfreq, 
+    f_rcvmode, f_rcvchannel, f_chnswitchon_0, f_chnswitchon_1, f_dropsample, f_dtminus, f_dtplus, f_reserve1
+}
+
+
+    -- Create a subtree for the protocol
+    local subtree = tree:add(tm_sband_get_device_conf, buffer(), "TM SBAND Get Device Configuration")
+    --offset = offset + 8
+
+    -- Parse and add fields to the subtree
+    local data = buffer(offset, 4):le_uint()
+    local value = (data & 1)
+    subtree:add(f_rfe_rx0_on, value)
+    
+    value = (data >> 1) & 1
+    subtree:add(f_rfe_tx0_on, value)
+    
+    value = (data >> 2) & 1
+    subtree:add(f_rfe_pa0_on, data)
+    
+    value = (data >> 3) & 1
+    subtree:add(f_rfe_rx_tx0, data)
+    
+    value = (data >> 4) & 1
+    subtree:add(f_rfe_rx1_on, data)
+    
+    value = (data >> 5) & 1
+    subtree:add(f_rfe_tx1_on, data)
+    
+    value = (data >> 6) & 1
+    subtree:add(f_rfe_pa1_on, data)
+    
+    value = (data >> 7) & 1
+    subtree:add(f_rfe_rx_tx1, data)
+    
+    value = (data >> 8) & 1
+    subtree:add(f_rfe_out_en, data)
+    
+    value = (data >> 9) & 1
+    subtree:add(f_rfe_gpio0, data)
+    
+    value = (data >> 10) & 1
+    subtree:add(f_rfe_loop_det, data)
+    
+    value = (data >> 11) & 1
+    subtree:add(f_rfe_lo_mux, data)
+    
+    value = (data >> 12) & 1
+    subtree:add(f_rfe_pow_on, data)
+    
+    value = (data >> 13) & 1
+    subtree:add(f_rfe_da, data)
+    
+    value = (data >> 14) & 1
+    subtree:add(f_rfe_cl, data)
+    
+    value = (data >> 15) & 1
+    subtree:add(f_rfe_en_ad5304, data)
+    
+    value = (data >> 16) & 1
+    subtree:add(f_rfe_en_synth, data)
+    
+    value = (data >> 17) & 1
+    subtree:add(f_rfe_en3, data)
+    
+    value = (data >> 18) & 1
+    subtree:add(f_rfe_en4, data)
+    
+    value = (data >> 19) & 1
+    subtree:add(f_rfe_en5, data)
+    
+    value = (data >> 20) & 1
+    subtree:add(f_rfe_7v0_en, data)
+    
+    value = (data >> 21) & 0xfff3
+    subtree:add(f_rfe_rsv_uint32, data)
+    
+    
+    offset = offset + 4
+    
+    subtree:add(f_rxmix_ch0, buffer(offset, 4):le_uint())  -- First 4 bytes for RxMix Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_rxmix_ch1, buffer(offset, 4):le_uint())  -- Next 4 bytes for RxMix Channel 1
+    offset = offset + 4
+
+    subtree:add(f_txmix_ch0, buffer(offset, 4):le_uint())  -- Next 4 bytes for TxMix Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_txmix_ch1, buffer(offset, 4):le_uint()) -- Next 4 bytes for TxMix Channel 1
+    offset = offset + 4
+
+    subtree:add(f_rxfreq_ch0, buffer(offset, 4):le_uint()) -- Next 4 bytes for RxFreq Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_rxfreq_ch1, buffer(offset, 4):le_uint()) -- Next 4 bytes for RxFreq Channel 1
+    offset = offset + 4
+    
+    subtree:add(f_txfreq_ch0, buffer(offset, 4):le_uint()) -- Next 4 bytes for TxFreq Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_txfreq_ch1, buffer(offset, 4):le_uint()) -- Next 4 bytes for TxFreq Channel 1
+    offset = offset + 4
+    
+    subtree:add(f_rxlow_ch0, buffer(offset, 4):le_uint())   -- First 4 bytes for RxLow Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_rxlow_ch1, buffer(offset, 4):le_uint())   -- Next 4 bytes for RxLow Channel 1
+    offset = offset + 4
+
+    subtree:add(f_rxhigh_ch0, buffer(offset, 4):le_uint())  -- Next 4 bytes for RxHigh Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_rxhigh_ch1, buffer(offset, 4):le_uint()) -- Next 4 bytes for RxHigh Channel 1
+    offset = offset + 4
+
+    subtree:add(f_txlow_ch0, buffer(offset, 4):le_uint())  -- Next 4 bytes for TxLow Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_txlow_ch1, buffer(offset, 4):le_uint())  -- Next 4 bytes for TxLow Channel 1
+    offset = offset + 4
+
+    subtree:add(f_txhigh_ch0, buffer(offset, 4):le_uint()) -- Next 4 bytes for TxHigh Channel 0
+    offset = offset + 4
+    
+    subtree:add(f_txhigh_ch1, buffer(offset, 4):le_uint()) -- Next 4 bytes for TxHigh Channel 1
+    offset = offset + 4
+    
+    local data = buffer(offset , 4):le_uint()
+    local value = data & 1
+     subtree:add(f_2rx2tx, value)  -- 2Rx2Tx (bit 31)
+     
+     value = (data >> 1) & 0xff3
+    subtree:add(f_txlevel_0, value)  -- TxLevel 0 (bits 20-30)
+    
+    value = (data >> 12) & 0xff3
+    subtree:add(f_txlevel_1, value)     -- TxLevel 1 (bits 10-20)
+    
+    value = (data >> 23) & 0xff
+    subtree:add(f_refclk, value)         -- RefClk (bits 2-9)
+    
+    value = (data >> 31) & 1
+    subtree:add(f_reserve, value)         -- Reserve (bit 0)
+    
+    offset = offset + 4
+    
+    data = buffer(offset, 2):le_uint()
+    value = data & 0x7
+    subtree:add(f_modulat_0, value)  -- 3 bits
+    
+    value = (data >> 3) & 0xf
+    subtree:add(f_mode_0, value)    -- 4 bits
+    
+    value = (data >> 7) & 0x7
+    subtree:add(f_fec_0, value)    -- 3 bits
+    
+    value = (data >> 10) & 1
+    subtree:add(f_chen_0, value)   -- 1 bit
+    
+    value = (data >> 11) & 1
+    subtree:add(f_prnd_0, value)   -- 1 bit
+    
+    value = (data >> 12) & 1
+    subtree:add(f_asmstart_0, value) -- 1 bit
+    
+    value = (data >> 13) & 1
+    subtree:add(f_offsetmod_0, value) -- 1 bit
+    
+    value = (data >> 14) & 1
+    subtree:add(f_ch1_diff_ch2, value) -- 1 bit
+    
+    value = (data >> 15) & 1
+    subtree:add(f_chswitchon_0, value) -- 1 bit
+    
+    offset = offset + 2
+    
+    data = buffer(offset , 2):le_uint()
+    value = data  & 7
+    subtree:add(f_modulat_1, value) -- 3 bits
+    
+    value = (data >> 3) & 0xf
+    subtree:add(f_mode_1, value)   -- 4 bits
+    
+    value = (data >> 7) & 0x7
+    subtree:add(f_fec_1, value)   -- 3 bits
+    
+    value = (data >> 10) & 0x1
+    subtree:add(f_chen_1, value)  -- 1 bit
+    
+    value = (data >> 11) & 0x1
+    subtree:add(f_prnd_1, value)  -- 1 bit
+    
+    value = (data >> 12) & 0x1
+    subtree:add(f_asmstart_1, value) -- 1 bit
+    
+    value = (data >> 13) & 0x1
+    subtree:add(f_offsetmod_1, value) -- 1 bit
+    
+    value = (data >> 14) & 0x1
+    subtree:add(f_chswitchon_1, value) -- 1 bit
+  
+    value = (data >> 15) & 0x1
+    subtree:add(f_offsetmodnormaly, value) -- 1 bit
+    offset = offset + 2
+    
+    
+    data = buffer(offset , 4):le_uint()
+    value = data & 0x000003ff
+    subtree:add(f_atttxgain_0, value) -- AttTxGain_0 (bits 22–31)
+    
+    value = (data >> 10) & 0x000003ff
+    subtree:add(f_atttxgain_1, value) -- AttTxGain_1 (bits 12–21)
+    
+    value = (data >> 20) & 0x00000fff
+    subtree:add(f_trfrmsz, value)                  -- TrFrmSz (bits 0–11)
+    
+    offset = offset + 4
+    
+    data = buffer(offset, 4):le_uint()
+    value = data &  0x1f
+    subtree:add(f_phioffset16, value) -- PhiOffset16 (bits 27–31)
+    
+    value = (data >> 5) & 0x1fff
+    subtree:add(f_y16, value)        -- Y16 (bits 14–26)
+    
+    value = (data >> 18) & 0x3ff
+    subtree:add(f_txsampfact, value)  -- TxSampFact (bits 2–11)
+    
+    value = (data >> 28) & 0xf
+    subtree:add(f_rsmode, value)        -- RsMode (bits 0–3)
+    offset = offset + 4
+    
+    data = buffer(offset , 2):le_uint()
+    value = data & 0xff
+    subtree:add(f_rxgainmax, value)
+
+    -- Add ChEn (bit 23)
+    value = (data >> 8) & 1
+    subtree:add(f_chen, value)
+
+    -- Add Modulat (bits 20–22)
+    value = (data >> 9) & 0x7
+    subtree:add(f_modulat, value)
+
+    -- Add MsbFirst (bit 19)
+    value = (data >> 12) & 0x1
+    subtree:add(f_msbfirst, value)
+
+    -- Add Fec (bits 16–18)
+    value = (data >> 13) & 0x7
+    subtree:add(f_fec, value)
+    
+    offset = offset + 2
+    
+    data = buffer(offset , 2):le_uint()
+    value = data & 0x1
+    -- Add PRnd (bit 15)
+    subtree:add(f_prnd, value)
+
+    -- Add BchDec (bit 14)
+    value = (data >> 1) & 0x1
+    subtree:add(f_bchdec, value)
+
+    -- Add AccBchErr (bit 13)
+     value = (data >> 2) & 0x1
+    subtree:add(f_accbcherr, value)
+
+    -- Add BchCountMode (bit 12)
+     value = (data >> 3) & 0x1
+    subtree:add(f_bchcountmode, value)
+
+    -- Add PwrOff (bits 6–11)
+     value = (data >> 4) & 0x003f
+    subtree:add(f_pwroff, value)
+
+    -- Add RcvCalib (bits 0–5)
+     value = (data >> 10) & 0x003f
+    subtree:add(f_rcvcalib, value)
+    
+    offset = offset + 2
+    
+    data = buffer(offset , 4):le_uint()
+    subtree:add("data : %d", data)
+    value = data & 0x0000ffff
+     subtree:add(f_xmtsymbfreq, value)
+
+    -- Add RcvSymbFreq (bits 0–15)
+     value = (data >> 16)  & 0xffff
+    subtree:add(f_rcvsymbfreq, value)
+    
+    offset = offset + 4
+    
+    data = buffer(offset ,4):le_uint()
+    value = data & 0xf
+     subtree:add(f_rcvmode, value)
+
+    -- Add RcvChannel (bits 26–27)
+    value = (data >> 4) & 0x3
+    subtree:add(f_rcvchannel, value)
+
+    -- Add ChSwitchOn_0 (bit 25)
+    value = (data >> 6) & 0x1
+    subtree:add(f_chnswitchon_0, value)
+
+    -- Add ChSwitchOn_1 (bit 24)
+    value = (data >> 7) & 0x1
+    subtree:add(f_chnswitchon_1, value)
+
+    -- Add DropSample (bits 12–23)
+    value = (data >> 8) & 0xfff
+    subtree:add(f_dropsample, value)
+
+    -- Add dT_minus (bit 7)
+    value = (data >> 20) & 0x1
+    subtree:add(f_dtminus, value)
+
+    -- Add dT_plus (bit 6)
+    value = (data >> 21) & 0x1
+    subtree:add(f_dtplus, value)
+
+    -- Add Reserve (bits 0–9)
+    value = (data >> 22) & 0x3ff
+    subtree:add(f_reserve, value)
+    offset = offset + 4
+    
+    
+
+end

Dissector/tm_sband_get_feature_select.lua

@@ -0,0 +1,114 @@
+function tm_sband_get_feature_select(buffer, pinfo, tree, sband_get_feature_select, offset)
+    -- Define ProtoFields
+    local f_crc16 = ProtoField.uint16("sband_get_feature_select.Crc16", "Crc16", base.HEX)
+    local f_reserve_0 = ProtoField.uint16("sband_get_feature_select.Reserve_0", "Reserve_0", base.HEX)
+    local f_more_xmt_mod = ProtoField.uint8("sband_get_feature_select.MoreXmtMod", "MoreXmtMod", base.DEC)
+    local f_xmt_offset_mod = ProtoField.uint8("sband_get_feature_select.XmtOffsetMod", "XmtOffsetMod", base.DEC)
+    local f_rs_mode = ProtoField.uint8("sband_get_feature_select.RsMode", "RsMode", base.DEC)
+
+    local f_xmt_ch0_en = ProtoField.uint8("sband_get_feature_select.XmtCh0_En", "XmtCh0_En", base.DEC)
+    local f_xmt_ch1_en = ProtoField.uint8("sband_get_feature_select.XmtCh1_En", "XmtCh1_En", base.DEC)
+    local f_rcv_ch0_en = ProtoField.uint8("sband_get_feature_select.RcvCh0_En", "RcvCh0_En", base.DEC)
+    local f_rcv_ch1_en = ProtoField.uint8("sband_get_feature_select.RcvCh1_En", "RcvCh1_En", base.DEC)
+    local f_rcv_ch0_gain_max = ProtoField.uint8("sband_get_feature_select.RcvCh0_GainMax", "RcvCh0_GainMax", base.DEC)
+    local f_rcv_ch1_gain_max = ProtoField.uint8("sband_get_feature_select.RcvCh1_GainMax", "RcvCh1_GainMax", base.DEC)
+    local f_disable_xmt_symb_freq_change = ProtoField.uint8("sband_get_feature_select.DisableXmtSymbFreqChange", "DisableXmtSymbFreqChange", base.DEC)
+    local f_disable_rcv_symb_freq_change = ProtoField.uint8("sband_get_feature_select.DisableRcvSymbFreqChange", "DisableRcvSymbFreqChange", base.DEC)
+    local f_disable_xmt_up_sampling = ProtoField.uint8("sband_get_feature_select.DisableXmtUpSampling", "DisableXmtUpSampling", base.DEC)
+
+    local f_reserve_1 = ProtoField.uint32("sband_get_feature_select.Reserve_1", "Reserve_1", base.HEX)
+
+    local f_xmt_symb_freq = ProtoField.uint16("sband_get_feature_select.XmtSymbFreq", "XmtSymbFreq", base.HEX)
+    local f_rcv_symb_freq = ProtoField.uint16("sband_get_feature_select.RcvSymbFreq", "RcvSymbFreq", base.HEX)
+
+    local f_reserve_3 = ProtoField.uint32("sband_get_feature_select.Reserve_3", "Reserve_3", base.HEX)
+
+    -- Register the fields in the protocol
+    sband_get_feature_select.fields = {
+        f_crc16, f_reserve_0, f_more_xmt_mod, f_xmt_offset_mod, f_rs_mode,
+        f_xmt_ch0_en, f_xmt_ch1_en, f_rcv_ch0_en, f_rcv_ch1_en, f_rcv_ch0_gain_max, 
+        f_rcv_ch1_gain_max, f_disable_xmt_symb_freq_change, f_disable_rcv_symb_freq_change, 
+        f_disable_xmt_up_sampling, f_reserve_1, f_xmt_symb_freq, f_rcv_symb_freq, f_reserve_3
+    }
+
+    -- Create the subtree for tm_sband_get_feature_select
+    local subtree = tree:add(sband_get_feature_select, buffer(), "TM SBAND GET FEATURE SELECT")
+
+    -- Parse the 16-bit `Crc16`
+    subtree:add(f_crc16, buffer(offset, 2))
+    offset = offset + 2
+
+    -- Parse the 10-bit `Reserve_0`
+    local value
+    local data = buffer(offset, 2):le_uint()
+    value = data & 0x3ff
+    subtree:add(f_reserve_0, value)
+
+    -- Parse `MoreXmtMod` (1 bit)
+    value = (data >> 10) & 1
+    subtree:add(f_more_xmt_mod,value)
+
+
+    -- Parse `XmtOffsetMod` (1 bit)
+    value = (data >> 11) & 1
+    subtree:add(f_xmt_offset_mod, value)
+
+    -- Parse `RsMode` (4 bits)
+    value = (data >> 12) & 0xf000
+    subtree:add(f_rs_mode, value)
+    offset = offset + 2
+    
+    data = buffer(offset , 4):le_uint()
+    value = data & 1
+    subtree:add(f_xmt_ch0_en, value)
+    
+
+    -- Parse `XmtCh1_En` (1 bit)
+    value = (data >> 1) & 1
+    subtree:add(f_xmt_ch1_en, value)
+
+    -- Parse `RcvCh0_En` (1 bit)
+    value = (data >> 2) & 1
+    subtree:add(f_rcv_ch0_en, value )
+
+    -- Parse `RcvCh1_En` (1 bit)
+    value = (data >> 3) & 1
+    subtree:add(f_rcv_ch1_en, value)
+
+    -- Parse `RcvCh0_GainMax` (1 bit)
+    value = (data >> 4) & 1
+    subtree:add(f_rcv_ch0_gain_max, value)
+
+    -- Parse `RcvCh1_GainMax` (1 bit)
+    value = (data >> 5) & 1
+    subtree:add(f_rcv_ch1_gain_max, value)
+
+    -- Parse `DisableXmtSymbFreqChange` (1 bit)
+    value = (data >> 6) & 1
+    subtree:add(f_disable_xmt_symb_freq_change, value)
+
+    -- Parse `DisableRcvSymbFreqChange` (1 bit)
+    value = (data >> 7) & 1
+    subtree:add(f_disable_rcv_symb_freq_change, value)
+
+    -- Parse `DisableXmtUpSampling` (1 bit)
+    value = (data >> 8) & 1
+    subtree:add(f_disable_xmt_up_sampling, value)
+
+    -- Parse `Reserve_1` (23 bits)
+    value = (data >> 9) & 0x03ffffff
+    subtree:add(f_reserve_1, value)
+    offset = offset + 4
+
+    -- Parse `XmtSymbFreq` (16 bits)
+    subtree:add(f_xmt_symb_freq, buffer(offset, 2):le_uint())
+    offset = offset + 2
+
+    -- Parse `RcvSymbFreq` (16 bits)
+    subtree:add(f_rcv_symb_freq, buffer(offset, 2):le_uint())
+    offset = offset + 2
+
+    -- Parse `Reserve_3` (32 bits)
+    subtree:add(f_reserve_3, buffer(offset, 4):le_uint())
+    offset = offset + 4
+end

Dissector/tm_sband_get_product_key.lua

@@ -0,0 +1,27 @@
+function tm_sband_get_product_key(buffer, pinfo, tree, sband_product_key, offset)
+    -- Define ProtoFields
+    local f_previous_product_key = ProtoField.uint32("sband_product_key.previous_product_key", "Previous Product Key", base.HEX)
+    local f_current_product_key = ProtoField.uint32("sband_product_key.current_product_key", "Current Product Key", base.HEX)
+
+    -- Register the fields in the protocol
+    sband_product_key.fields = {
+        f_previous_product_key,
+        f_current_product_key
+    }
+
+    -- Create a subtree for the structure
+    local subtree = tree:add(sband_product_key, buffer(), "Product Key Structure")
+
+    -- Parse previous_product_key array
+    for i = 0, 3 do
+        subtree:add_le(f_previous_product_key, buffer(offset, 4):le_uint()):append_text(string.format(" [Index %d]", i))
+        offset = offset + 4
+    end
+
+    -- Parse current_product_key array
+    for i = 0, 3 do
+        subtree:add_le(f_current_product_key, buffer(offset, 4):le_uint()):append_text(string.format(" [Index %d]", i))
+        offset = offset + 4
+    end
+
+end

Dissector/tm_sband_get_tm_all.lua

@@ -0,0 +1,146 @@
+-- tmid - 412
+-- Your function definition begins here
+function tm_sband_get_tm_all(buffer, pinfo, tree, sband_get_tm_all, offset, instance)
+    -- Define ProtoFields for s_sband_cmn_tm
+    local f_cnt  = ProtoField.uint64("sband_get_tm_all.cnt", "Count", base.DEC)
+    local f_timestamp2 = ProtoField.uint64("sband_get_tm_all.timestamp2", "Timestamp", base.DEC) 
+    local f_temp_mcu = ProtoField.uint32("sband_get_tm_all.temp_mcu", "Temp MCU", base.DEC)
+    local f_temp_fpga = ProtoField.uint32("sband_get_tm_all.temp_fpga", "Temp FPGA", base.DEC)
+    local f_temp_xcvr = ProtoField.uint32("sband_get_tm_all.temp_xcvr", "Temp XCVR", base.DEC)
+    local f_volt_vint = ProtoField.double("sband_get_tm_all.volt_vint", "Volt Vint", base.DEC)
+    local f_volt_vaux = ProtoField.double("sband_get_tm_all.volt_vaux", "Volt Vaux", base.DEC)
+    local f_volt_vbram = ProtoField.double("sband_get_tm_all.volt_vbram", "Volt Vbram", base.DEC)
+    local f_volt_vpint = ProtoField.double("sband_get_tm_all.volt_vpint", "Volt Vpint", base.DEC)
+    local f_volt_vpaux = ProtoField.double("sband_get_tm_all.volt_vpaux", "Volt Vpaux", base.DEC)
+    local f_volt_vpdro = ProtoField.double("sband_get_tm_all.volt_vpdro", "Volt Vpdro", base.DEC)
+    --local f_resv_chnl = ProtoField.uint8("sband_get_tm_all.resv_cgnl", "resvchnl", base.DEC)
+
+    -- Define ProtoFields for s_sband_rx_tm
+    local f_rx_cfg_frames = ProtoField.uint32("sband_get_tm_all.rx_cfg_frames", "RX Config Frames", base.DEC)
+    local f_rx_cfg_detected = ProtoField.uint32("sband_get_tm_all.rx_cfg_detected", "RX Config Detected", base.DEC)
+    local f_rx_cfg_rssi = ProtoField.float("sband_get_tm_all.rx_cfg_rssi", "RX Config RSSI", base.DEC)
+    local f_rx_avg_rssi = ProtoField.float("sband_get_tm_all.rx_avg_rssi", "RX Average RSSI", base.DEC)
+    local f_rx_cfg_freqerr = ProtoField.int32("sband_get_tm_all.rx_cfg_freqerr", "RX Config Frequency Error", base.DEC)
+    local f_rx_cfg_carrier_lock = ProtoField.uint32("sband_get_tm_all.rx_cfg_carrier_lock", "RX Carrier Lock", base.DEC)
+    local f_rx_frame_lock = ProtoField.uint32("sband_get_tm_all.rx_frame_lock", "RX Frame Lock", base.DEC)
+    local f_rx_sir_min = ProtoField.uint32("sband_get_tm_all.rx_sir_min", "RX SIR Min", base.DEC)
+    local f_rx_sir_max = ProtoField.uint32("sband_get_tm_all.rx_sir_max", "RX SIR Max", base.DEC)
+    local f_rx_bch_block_cnt = ProtoField.uint32("sband_get_tm_all.rx_bch_block_cnt", "RX BCH Block Count", base.DEC)
+    local f_rx_bch_err_cnt = ProtoField.uint32("sband_get_tm_all.rx_bch_err_cnt", "RX BCH Error Count", base.DEC)
+
+    -- Define ProtoFields for s_sband_tx_tm
+    local f_tx_cfg_frames = ProtoField.uint32("sband_get_tm_all.tx_cfg_frames", "TX Config Frames", base.DEC)
+    local f_tx_cfg_pwr_rfl = ProtoField.float("sband_get_tm_all.tx_cfg_pwr_rfl", "TX Power RFL", base.DEC)
+
+    -- For the main s_sband_periodic_tm structure
+    --local f_cmn_tm = ProtoField.bytes("sband_get_tm_store.cmn_tm", "Common Time", base.HEX)
+    --local f_rx_tm = ProtoField.bytes("sband_get_tm_store.rx_tm", "RX Time", base.HEX)
+    --local f_tx_tm = ProtoField.bytes("sband_get_tm_store.tx_tm", "TX Time", base.HEX) 
+
+    -- Add all fields to the protocol
+    sband_get_tm_all.fields = {
+        f_timestamp2, f_temp_mcu, f_temp_fpga, f_temp_xcvr, f_volt_vint, f_volt_vaux, f_volt_vbram, f_volt_vpint,
+        f_volt_vpaux, f_volt_vpdro,
+        f_rx_cfg_frames, f_rx_cfg_detected, f_rx_cfg_rssi, f_rx_avg_rssi, f_rx_cfg_freqerr, 
+        f_rx_cfg_carrier_lock, f_rx_frame_lock, f_rx_sir_min, f_rx_sir_max, f_rx_bch_block_cnt, f_rx_bch_err_cnt,
+        f_tx_cfg_frames, f_tx_cfg_pwr_rfl
+    }
+
+
+  local subtree1 = tree:add(sband_get_tm_all, buffer(), "TM SBAND GET TM STORE")
+    
+        subtree1:add(f_temp_mcu, buffer(offset, 4):le_uint())  -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_temp_fpga, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_temp_xcvr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        
+        local data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vint, data ):set_text(string.format("Volt Vint: %.6f ", data))
+        offset = offset + 8
+       
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vaux, data):set_text(string.format("Volt Vaux: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vbram, data ):set_text(string.format("Volt Vbram: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpint, data ):set_text(string.format("Volt Vpint: %.6f ", data))
+        offset = offset + 8
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpaux, data ):set_text(string.format("Volt Vpaux: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpdro, data ):set_text(string.format("Volt Vpdro: %.6f ", data))
+        offset = offset + 8
+       
+
+        -- Dissect the s_sband_rx_tm structure 
+        -- Handle the RX structure
+        print("Recv chnl : 1")
+
+        subtree1:add(f_rx_cfg_frames, buffer(offset, 4):le_uint())  -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_detected, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_rssi, buffer(offset, 4):le_float()):set_text(string.format("Rx Cfg Rssi: %.6f ", buffer(offset, 4):le_float()))  -- 4bytes for float(f32)
+        offset = offset + 4
+        subtree1:add(f_rx_avg_rssi, buffer(offset, 4):le_float()) :set_text(string.format("Rx avg Rssi: %.6f ", buffer(offset, 4):le_float()))-- 4bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_freqerr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_carrier_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_frame_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_min, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_max, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_block_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_err_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        
+        --subtree1:add(f_recv_chnl,2)  -- 4 bytes for uint32
+        
+        print("Recv chnl - 2")
+        subtree1:add(f_rx_cfg_frames, buffer(offset, 4):le_uint())  -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_detected, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_rssi, buffer(offset, 4):le_float()):set_text(string.format("Rx Cfg Rssi: %.6f ", buffer(offset, 4):le_float()))--4 bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_avg_rssi, buffer(offset, 4):le_float()):set_text(string.format("Rx Avg Rssi: %.6f ", buffer(offset, 4):le_float()))-- 4 bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_freqerr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_carrier_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_frame_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_min, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_max, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_block_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_err_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+
+         --Dissect the s_sband_tx_tm structure
+        subtree1:add(f_tx_cfg_frames, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_tx_cfg_pwr_rfl, buffer(offset, 4):le_float()) -- 4 bytes for float (f32)
+        offset = offset + 4
+        
+end  -- This closes the function `sband_dissectors`

Dissector/tm_sband_get_tm_store.lua

@@ -0,0 +1,162 @@
+-- tmid - 413
+-- Your function definition begins here
+function tm_sband_get_tm_store(buffer, pinfo, tree, sband_get_tm_store, offset, instance)
+    -- Define ProtoFields for s_sband_cmn_tm
+    local f_cnt  = ProtoField.uint8("sband_get_tm_store.cnt", "Count", base.DEC)
+    local f_timestamp2 = ProtoField.uint64("sband_get_tm_store.timestamp2", "Timestamp", base.DEC) 
+    local f_temp_mcu = ProtoField.uint32("sband_get_tm_store.temp_mcu", "Temp MCU", base.DEC)
+    local f_temp_fpga = ProtoField.uint32("sband_get_tm_store.temp_fpga", "Temp FPGA", base.DEC)
+    local f_temp_xcvr = ProtoField.uint32("sband_get_tm_store.temp_xcvr", "Temp XCVR", base.DEC)
+    local f_volt_vint = ProtoField.double("sband_get_tm_store.volt_vint", "Volt Vint", base.DEC)
+    local f_volt_vaux = ProtoField.double("sband_get_tm_store.volt_vaux", "Volt Vaux", base.DEC)
+    local f_volt_vbram = ProtoField.double("sband_get_tm_store.volt_vbram", "Volt Vbram", base.DEC)
+    local f_volt_vpint = ProtoField.double("sband_get_tm_store.volt_vpint", "Volt Vpint", base.DEC)
+    local f_volt_vpaux = ProtoField.double("sband_get_tm_store.volt_vpaux", "Volt Vpaux", base.DEC)
+    local f_volt_vpdro = ProtoField.double("sband_get_tm_store.volt_vpdro", "Volt Vpdro", base.DEC)
+    --local f_resv_chnl = ProtoField.uint8("sband_get_tm_store.resv_cgnl", "resvchnl", base.DEC)
+
+    -- Define ProtoFields for s_sband_rx_tm
+    local f_rx_cfg_frames = ProtoField.uint32("sband_get_tm_store.rx_cfg_frames", "RX Config Frames", base.DEC)
+    local f_rx_cfg_detected = ProtoField.uint32("sband_get_tm_store.rx_cfg_detected", "RX Config Detected", base.DEC)
+    local f_rx_cfg_rssi = ProtoField.float("sband_get_tm_store.rx_cfg_rssi", "RX Config RSSI", base.DEC)
+    local f_rx_avg_rssi = ProtoField.float("sband_get_tm_store.rx_avg_rssi", "RX Average RSSI", base.DEC)
+    local f_rx_cfg_freqerr = ProtoField.int32("sband_get_tm_store.rx_cfg_freqerr", "RX Config Frequency Error", base.DEC)
+    local f_rx_cfg_carrier_lock = ProtoField.uint32("sband_get_tm_store.rx_cfg_carrier_lock", "RX Carrier Lock", base.DEC)
+    local f_rx_frame_lock = ProtoField.uint32("sband_get_tm_store.rx_frame_lock", "RX Frame Lock", base.DEC)
+    local f_rx_sir_min = ProtoField.uint32("sband_get_tm_store.rx_sir_min", "RX SIR Min", base.DEC)
+    local f_rx_sir_max = ProtoField.uint32("sband_get_tm_store.rx_sir_max", "RX SIR Max", base.DEC)
+    local f_rx_bch_block_cnt = ProtoField.uint32("sband_get_tm_store.rx_bch_block_cnt", "RX BCH Block Count", base.DEC)
+    local f_rx_bch_err_cnt = ProtoField.uint32("sband_get_tm_store.rx_bch_err_cnt", "RX BCH Error Count", base.DEC)
+
+    -- Define ProtoFields for s_sband_tx_tm
+    local f_tx_cfg_frames = ProtoField.uint32("sband_get_tm_store.tx_cfg_frames", "TX Config Frames", base.DEC)
+    local f_tx_cfg_pwr_rfl = ProtoField.float("sband_get_tm_store.tx_cfg_pwr_rfl", "TX Power RFL", base.DEC)
+
+    -- For the main s_sband_periodic_tm structure
+    --local f_cmn_tm = ProtoField.bytes("sband_get_tm_store.cmn_tm", "Common Time", base.HEX)
+    --local f_rx_tm = ProtoField.bytes("sband_get_tm_store.rx_tm", "RX Time", base.HEX)
+    --local f_tx_tm = ProtoField.bytes("sband_get_tm_store.tx_tm", "TX Time", base.HEX) 
+
+    -- Add all fields to the protocol
+    sband_get_tm_store.fields = {
+        f_timestamp2, f_temp_mcu, f_temp_fpga, f_temp_xcvr, f_volt_vint, f_volt_vaux, f_volt_vbram, f_volt_vpint,
+        f_volt_vpaux, f_volt_vpdro,
+        f_rx_cfg_frames, f_rx_cfg_detected, f_rx_cfg_rssi, f_rx_avg_rssi, f_rx_cfg_freqerr, 
+        f_rx_cfg_carrier_lock, f_rx_frame_lock, f_rx_sir_min, f_rx_sir_max, f_rx_bch_block_cnt, f_rx_bch_err_cnt,
+        f_tx_cfg_frames, f_tx_cfg_pwr_rfl, f_cnt
+    }
+
+
+  local subtree = tree:add(sband_get_tm_store, buffer(), "TM SBAND GET TM STORE")
+    
+    local cnt = buffer(offset, 1):le_uint()
+    subtree:add(f_cnt, buffer(offset, 1):le_uint())
+        offset = offset + 1
+    -- Now the loop for iterating over instances
+    for i = 0, cnt - 1 do
+        local subtree1 = subtree:add(sband_get_tm_store, buffer(), "Instance " ..i)
+
+        -- Offset for the different structs in s_sband_periodic_tm
+        
+        -- Dissect the s_sband_cmn_tm structure
+        subtree1:add(f_timestamp2, buffer(offset, 8):le_uint64())
+        offset = offset + 8 
+        subtree1:add(f_temp_mcu, buffer(offset, 4):le_uint())  -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_temp_fpga, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_temp_xcvr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        
+        local data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vint, data ):set_text(string.format("Volt Vint: %.6f ", data))
+        offset = offset + 8
+       
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vaux, data):set_text(string.format("Volt Vaux: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vbram, data ):set_text(string.format("Volt Vbram: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpint, data ):set_text(string.format("Volt Vpint: %.6f ", data))
+        offset = offset + 8
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpaux, data ):set_text(string.format("Volt Vpaux: %.6f ", data))
+        offset = offset + 8
+        
+        
+        data = buffer(offset, 8):le_float()  -- First 4 bytes for z_vel
+        subtree1:add(f_volt_vpdro, data ):set_text(string.format("Volt Vpdro: %.6f ", data))
+        offset = offset + 8
+       
+
+        -- Dissect the s_sband_rx_tm structure 
+        -- Handle the RX structure
+        print("Recv chnl : 1")
+
+        subtree1:add(f_rx_cfg_frames, buffer(offset, 4):le_uint())  -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_detected, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_rssi, buffer(offset, 4):le_float()):set_text(string.format("Rx Cfg Rssi: %.6f ", buffer(offset, 4):le_float()))  -- 4bytes for float(f32)
+        offset = offset + 4
+        subtree1:add(f_rx_avg_rssi, buffer(offset, 4):le_float())  -- 4 bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_freqerr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_carrier_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_frame_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_min, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_max, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_block_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_err_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        
+        --subtree1:add(f_recv_chnl,2)  -- 4 bytes for uint32
+        
+        print("Recv chnl - 2")
+        subtree1:add(f_rx_cfg_frames, buffer(offset, 4):le_uint())  -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_detected, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_rssi, buffer(offset, 4):le_float())  -- 4 bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_avg_rssi, buffer(offset, 4):le_float())  -- 4 bytes for float (f32)
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_freqerr, buffer(offset, 4):le_uint()) -- 4 bytes for int32
+        offset = offset + 4
+        subtree1:add(f_rx_cfg_carrier_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_frame_lock, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_min, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_sir_max, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_block_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_rx_bch_err_cnt, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+
+         --Dissect the s_sband_tx_tm structure
+        subtree1:add(f_tx_cfg_frames, buffer(offset, 4):le_uint()) -- 4 bytes for uint32
+        offset = offset + 4
+        subtree1:add(f_tx_cfg_pwr_rfl, buffer(offset, 4):le_float()) -- 4 bytes for float (f32)
+        offset = offset + 4
+        
+        
+        
+    end  -- This closes the `for` loop
+
+end  -- This closes the function `sband_dissectors`