exo_sw_dissectors/Dissector/Tc_Tm_Protocols1.lua

-- Define the protocol
TC_TM_PROTOCOL = Proto("tm_tc", "TM_TC")

local f_sof1 = ProtoField.uint8("TC_TM_PROTOCOL.sof1", "SOF1", base.HEX)
local f_sof2 = ProtoField.uint8("TC_TM_PROTOCOL.sof2", "SOF2", base.HEX)
local f_tm_ctrl = ProtoField.uint8("TC_TM_PROTOCOL.tm_ctrl", "TM Ctrl", base.HEX)
local f_GS_Id = ProtoField.uint8("TC_TM_PROTOCOL.GS_Id", "GS Id", base.HEX)
local f_timestamp = ProtoField.uint32("TC_TM_PROTOCOL.timestamp", "Timestamp", base.DEC)
local f_sequence_no = ProtoField.uint16("TC_TM_PROTOCOL.sequence_no", "Sequence No", base.DEC)
local f_sat_id = ProtoField.uint16("TC_TM_PROTOCOL.sat_id", "SAT Id", base.DEC)
local f_qos = ProtoField.uint8("TC_TM_PROTOCOL.qos", "QoS", base.DEC)
local f_sa_id = ProtoField.uint16("TC_TM_PROTOCOL.sa_id", "SA Id", base.DEC)
local f_da_id = ProtoField.uint16("TC_TM_PROTOCOL.da_id", "DA Id", base.DEC)
local f_rm_id = ProtoField.uint8("TC_TM_PROTOCOL.rm_id", "RM Id", base.DEC)
local f_tm_id = ProtoField.uint16("TC_TM_PROTOCOL.tm_id", "TM Id", base.DEC)
local f_co_id = ProtoField.uint16("TC_TM_PROTOCOL.co_id", "Co Id", base.DEC)
local f_tm_len = ProtoField.uint16("TC_TM_PROTOCOL.tm_len", "TM Len", base.DEC)
local f_tm_data = ProtoField.uint8("TC_TM_PROTOCOL.tm_data", "TM Data", base.DEC)
local f_ext_header_len = ProtoField.uint8("TC_TM_PROTOCOL.ext_header_len", "Ext Header Len", base.DEC)
local f_ext_header_data = ProtoField.uint8("TC_TM_PROTOCOL.ext_header_data", "Ext Header Data", base.DEC)
local f_crc = ProtoField.uint8("TC_TM_PROTOCOL.crc", "CRC", base.DEC)
local f_c_mac = ProtoField.uint8("TC_TM_PROTOCOL.c_mac", "C MAC", base.DEC)
local f_eof1 = ProtoField.uint8("TC_TM_PROTOCOL.eof1", "EOF1", base.HEX)
local f_tc_id = ProtoField.uint16("TC_TM_PROTOCOL.tc_id", "TC Id", base.DEC)
local f_tc_len = ProtoField.uint16("TC_TM_PROTOCOL.tc_len", "TC Len", base.DEC)
local f_tc_data = ProtoField.uint32("TC_TM_PROTOCOL.tc_data", "TC Data", base.DEC)

-- Add the fields to the protocol
TC_TM_PROTOCOL.fields = {
    f_sof1, f_sof2, f_tm_ctrl,f_GS_Id, f_timestamp, f_sequence_no, f_sat_id,
    f_qos, f_sa_id, f_da_id, f_rm_id, f_tm_id, f_co_id, f_tm_len, f_tm_data,
    f_ext_header_len, f_ext_header_data, f_crc, f_c_mac, f_eof1,f_tc_id ,f_tc_len ,f_tc_data 
}

------------------------------------------------------------------------------------------------------------------------------------
function TC_dissector(buffer, pinfo, tree)
--Set the protocol coloumn name in wireshark
   local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "TELECOMMAND")
    
    -- Dissect SOF1 and SOF2
    subtree:add(f_sof1 , buffer(4, 1))
    subtree:add(f_sof2, buffer(5, 1))
    
    -- Dissect TC Control byte (TC_Ctrl)
    local offset = 6
    local tc_ctrl = buffer(offset, 1):le_uint()  -- Get the value of TC Ctrl byte
    subtree:add(f_tm_ctrl , tc_ctrl)
    offset = offset + 1
    
    -- Dissect Timestamp (4 bytes)
    if buffer:len() >= offset + 4 then
        local timestamp = buffer(offset, 4):le_uint()
        subtree:add(f_timestamp, timestamp)
        offset = offset + 4
    else
        subtree:add(f_timestamp, "Invalid data (timestamp)")
    end
    
    -- Dissect Sequence No (2 bytes)
    if buffer:len() >= offset + 2 then
        local sequence = buffer(offset, 2):le_uint()
        subtree:add(f_sequence_no, sequence)
        offset = offset + 2
    else
       subtree:add(f_sequence_no, "Invalid data (sequence number)")
    end
    
    -- Dissect SAT_Id (1 byte)
    if buffer:len() >= offset + 1 then
        local sat_id = buffer(offset, 1):uint()  -- Get SAT Id (1st byte)
            --offset = offset + 1
            
            if bit.band(sat_id, 0x80) == 0x80 then     --if 7th bit is set and 
                if buffer:len() >= offset + 1 then
                    local second = buffer(offset, 2):le_uint()
                    
                    if bit.band(second, 0x8000) == 0x0000 then    --and 15th bit is set then unset 15th bit 
                    sat_id = buffer(offset, 2):le_uint()
                    sat_id = bit.band(sat_id, 0xFF7F)
                    offset = offset + 1
                    
                    else
                    sat_id = buffer(offset, 2):le_uint()
                    sat_id = bit.band(sat_id, 0x7FFF)  -- and 15th bit is unset then unset the 7th bit
                    offset = offset + 1
                    end
                end
            end
            subtree:add(f_sat_id, sat_id)
            offset = offset + 1
    end
    
    -- Dissect GS_Id (1 byte)
    if buffer:len() >= offset + 1 then
        local gs_id = buffer(offset, 1):uint()  -- Get SAT Id (1st byte)
            --offset = offset + 1
            
            if bit.band(gs_id, 0x80) == 0x80 then
                if buffer:len() >= offset + 1 then
                    local second = buffer(offset, 2):le_uint()
                    
                    if bit.band(second, 0x8000) == 0x0000 then
                    gs_id = buffer(offset, 2):le_uint()
                    gs_id = bit.band(gs_id, 0xFF7F)
                    offset = offset + 1
                    
                    else
                    gs_id = buffer(offset, 2):le_uint()
                    gs_id = bit.band(gs_id, 0x7FFF)
                    offset = offset + 1
                    end
                end
            end
            subtree:add(f_GS_Id, gs_id)
            offset = offset + 1
    end
    
    -- Dissect QoS (1 byte)
    if buffer:len() >= offset + 1 then
        subtree:add(f_qos, buffer(offset, 1))
        offset = offset + 1
    end
    
    -- Dissect SA_Id (Source Application ID) and DA_Id (Destination Application ID)
    if buffer:len() >= offset + 1 then
        local sa_id = buffer(offset, 1):uint()  -- Get source Application Id (1st byte)
            --offset = offset + 1
            
            if bit.band(sa_id, 0x80) == 0x80 then
                if buffer:len() >= offset + 1 then
                   local second = buffer(offset, 2):le_uint()
                    
                    if bit.band(second, 0x8000) == 0x0000 then
                    sa_id = buffer(offset, 2):le_uint()
                    sa_id = bit.band(sa_id, 0xFF7F)
                    offset = offset + 1
                    
                    else
                    sa_id = buffer(offset, 2):le_uint()
                    sa_id = bit.band(sa_id, 0x7FFF)
                    offset = offset + 1
                    end
                end
            end
            subtree:add(f_sa_id, sa_id)
            offset = offset + 1
     end
        
        if buffer:len() >= offset + 1 then
            --subtree:add(f_DA_Id, buffer(offset, 1))
            local da_id = buffer(offset, 1):le_uint()  -- Get Destination Application Id (1st byte)
            --offset = offset + 1
            
            if bit.band(da_id, 0x80) == 0x80 then
                if buffer:len() >= offset + 1 then
                        
 		local second = buffer(offset, 2):le_uint()
                    
                    if bit.band(second, 0x8000) == 0x0000 then
                    da_id = buffer(offset, 2):le_uint()
                    da_id = bit.band(da_id, 0xFF7F)
                    offset = offset + 1
                    
                    else
                    da_id = buffer(offset, 2):le_uint()
                    da_id = bit.band(da_id, 0x7FFF)
                    offset = offset + 1
                    end
                end
            end
            subtree:add(f_da_id, da_id)
            offset = offset + 1
        end
    
    -- Dissect RM_Id (1 byte)
    if buffer:len() >= offset + 1 then
        subtree:add(f_rm_id, buffer(offset, 1))
        offset = offset + 1
    end
    
    -- Dissect TC_Id (2 bytes)
   -- Dissect TC_Id (2 bytes)
	local info_display
   if buffer:len() >= offset + 2 then  -- Ensure enough data is available to read 2 bytes
    local tc_id = buffer(offset, 1):le_uint()  -- Read 1 byte for tc_id

    -- Check if the 7th bit (0x80) is set in tc_id
    if bit.band(tc_id, 0x80) == 0x80 then
        if buffer:len() >= offset + 2 then  -- Ensure enough data for the next 2 bytes
           
                    
 		local second = buffer(offset, 2):le_uint()
                    
                    if bit.band(second, 0x8000) == 0x0000 then
                    tc_id = buffer(offset, 2):le_uint()
                    tc_id = bit.band(tc_id, 0xFF7F)
                    offset = offset + 1
                    
                    else
                    tc_id = buffer(offset, 2):le_uint()
                    tc_id = bit.band(tc_id, 0x7FFF)
                    offset = offset + 1
                    end
        end
    end

    -- Add tc_id to the subtree (display in dissection tree)
    subtree:add(f_tc_id, tc_id)
	 info_display= {buffer(11, 2):le_uint(),buffer(7, 4):le_uint() ,tc_id} --- for info display in wireshark

    -- Move the offset forward by 1 (since we initially read 1 byte)
    offset = offset + 1
end


    -- Dissect TC_Len (2 bytes)
    local tc_len = 0  -- Declare tc_len as a local variable here
    if buffer:len() >= offset + 2 then
        tc_len = buffer(offset, 2):le_uint()
        subtree:add(f_tc_len, tc_len)
        offset = offset + 2
    end
    
    -- Dissect TC_Data (variable length)
	local subtree2 = subtree:add(TC_TM_PROTOCOL, buffer(), "TC_DATA")
    if buffer:len() >= offset + tc_len then
    if  tc_len == 0 then
        subtree2:add("TC DATA : NIL")
    else
	  for i=1,tc_len do
        	subtree2:add(f_tc_data, buffer(offset, 1))
        	offset = offset + 1
    end   
		end
	end
    

    -- Check if we can dissect Ext_Header_Len
    if bit.band(tc_ctrl, 0x80) == 0x80 and buffer:len() >= offset + 1 then
        subtree:add(f_ext_header_len, buffer(offset, 1))
        local ext_header_len = buffer(offset, 1):uint()
        offset = offset + 1

        if buffer:len() >= offset + ext_header_len then
	    for i=1,ext_header_len do
            	subtree:add(f_ext_header_data, buffer(offset, 1))
            	offset = offset + 1
		end
        end
   end
    
    -- Dissect CRC (1 byte)
    if buffer:len() >= offset + 1 then
        subtree:add(f_crc, buffer(offset, 1))
        offset = offset + 1
    end
    
    -- Dissect C-MAC/H-MAC (if TC Ctrl bit 4 is set)
    if bit.band(tc_ctrl, 0x10) == 0x10 and buffer:len() >= offset + 32 then
	for i=1,32 do
        	subtree:add(f_c_mac, buffer(offset, 1))
        	offset = offset + 1
	end
    end
    
    -- Dissect EOF (1 byte)
    if buffer:len() >= offset + 1 then
        subtree:add(f_eof1, buffer(offset, 1))
    end

	pinfo.cols.info ="seq_no=" ..info_display[1] .." TS=" ..info_display[2].." TC_ID="..info_display[3]  -- for info display in wireshark
end

-----------------------------------------------------------------------------------------------------------------------------------
function TM_dissector(buffer, pinfo, tree)  -- OBC to GS

	local subtree = tree:add(TC_TM_PROTOCOL, buffer(), "TELEMETRIC")
    -- Set the protocol column name in Wireshark
    

    -- Ensure the buffer is large enough to contain the entire structure (40 bytes)
   -- if buffer:len() < 40 then
     --   return -- Not enough data to dissect
    --end

    -- Extract the fields in order as defined in the structure
    subtree:add(f_sof1, buffer(4, 1):uint())  -- SOF1 in HEX
    subtree:add(f_sof2, buffer(5, 1):uint())  -- SOF2 in HEX
    subtree:add(f_tm_ctrl, buffer(6, 1):le_uint())  -- TM Ctrl in HEX
    subtree:add(f_timestamp, buffer(7, 4):le_uint())
   
    subtree:add(f_sequence_no, buffer(11, 2):le_uint())  -- Sequence No in HEX
    
       
-- My logic for SAT Id
    local magic = buffer(13, 1):le_uint()

    local add=13
    if bit.band(magic, 0x80) == 0 then
        subtree:add(f_sat_id, buffer(add, 1):le_uint())  -- SAT Id in HEX
	add=add+1
    else
	
	magic=buffer(add, 2):le_uint()
	local dummy=magic & 0x8000    --to check 7th byte is 1
	if dummy == 0 then
		magic = magic & 0xff7f -- if 15th bit is 0 set 7th bit 0
	else 
		magic = magic & 0x7fff -- if 15 bit is 1 set 15th bit to 0
	end
        subtree:add(f_sat_id, magic)  -- SAT Id in HEX
	add=add+2
	
    end

    -- QoS in HEX
    subtree:add(f_qos, buffer(add, 1):le_uint())
    add=add+1

    -- My logic for SA Id
    magic = buffer(add, 1):le_uint()
    if bit.band(magic, 0x80) == 0 then
        subtree:add(f_sa_id, buffer(add, 1):le_uint())  -- SA Id in HEX
	add=add+1
    else
	magic=buffer(add, 2):le_uint()
	local dummy=magic & 0x8000
	if dummy == 0 then
		magic = magic & 0xff7f
	else 
		magic = magic & 0x7fff
	end 
        subtree:add(f_sa_id,magic)  -- SA Id in HEX
	add=add+2
    end

    -- My logic for DA Id
    magic = buffer(add, 1):uint()
    if bit.band(magic, 0x80) == 0 then
        subtree:add(f_da_id, buffer(add, 1):le_uint())  -- DA Id in HEX
	add=add+1
    else
	magic=buffer(add, 2):le_uint()
	local dummy=magic & 0x8000
	if dummy == 0 then
		magic = magic & 0xff7f
	else 
		magic = magic & 0x7fff
	end
        subtree:add(f_da_id, magic)  -- DA Id in HEX
	add=add+2
    end

    -- RM Id in HEX
    subtree:add(f_rm_id, buffer(add, 1):le_uint())
    add=add+1

    -- My logic for TM Id
    local info_display    -- for display in wireshark
    magic = buffer(add, 1):uint()
    if bit.band(magic, 0x80) == 0 then
        subtree:add(f_tm_id, buffer(add, 1):le_uint())  -- TM Id in HEX
	 info_display= {buffer(11, 2):le_uint(),buffer(7, 4):le_uint() ,buffer(add, 1):le_uint()} --- for info display in wireshark
	add=add+1
    else
	magic=buffer(add, 2):le_uint()
	local dummy=magic & 0x8000
	if dummy == 0 then
		magic = magic & 0xff7f
	else 
		magic = magic & 0x7fff
	end
        subtree:add(f_tm_id, magic)  -- TM Id in HEX
	info_display= {buffer(11, 2):le_uint(),buffer(7, 4):le_uint() ,magic} --- for info display in wireshark
	add=add+2
    end

    -- Co Id in HEX
    subtree:add(f_co_id, buffer(add, 2):le_uint())
    add=add+2
    -- TM Len in HEX
    magic = buffer(add, 2):le_uint()
    subtree:add(f_tm_len, buffer(add, 2):le_uint())
    add=add+2

    --  logic for TM Data
	local subtree2 = subtree:add(TC_TM_PROTOCOL, buffer(), "TM_DATA")
    for i=0,magic-1 do
	subtree2:add(f_tm_data, buffer(add, 1):le_uint())
	add=add+1
    end
      
    -- Ext Header Len in HEX
    magic = buffer(6, 1):le_uint()  -- to check tm control
    if bit.band(magic, 0x80) == 0x80   then
    	magic=  buffer(add, 1):uint()
    	subtree:add(f_ext_header_len, buffer(add, 1):uint())
    	add=add+1

    --  logic for Ext Header Data
    	for i=0,magic-1 do
	subtree:add(f_ext_header_data, buffer(add, 1):uint())  -- Ext Header Data in HEX
	add=add+1
	end
    end
    -- CRC in HEX
    subtree:add(f_crc, buffer(add, 1):le_uint())
	add=add+1

    -- C MAC in HEX
	magic = buffer(6, 1):le_uint() -- tm control
    if bit.band(magic, 0x10) == 0x10   then
	for i=1,32 do
    		subtree:add(f_c_mac, buffer(add, 1):uint())
		add=add+1    
 	end   
    end
    -- EOF1 in HEX
    subtree:add(f_eof1, buffer(add, 1):uint())

	 
	pinfo.cols.info ="seq_no=" ..info_display[1] .." TS=" ..info_display[2].." TM_ID="..info_display[3]  -- for info display in wireshark

    -- Check if the buffer contains enough data for the expected total length
   --if buffer:len() < 38 + buffer(21, 2):uint() then
     --   subtree:add_expert_info(PI_MALFORMED, PI_WARN, "Incomplete data")
    --end
end
-- Register the dissector for udp port 


-------------------------------------------------------------------------------------------------------------------------------
-- Dissector function
function TC_TM_PROTOCOL.dissector(buffer, pinfo, tree)
	-- Register protocol in preferences (add this part)
	--my_udp_protocol:register_preference()

    pinfo.cols.protocol = "TM_TC"

    -- Create a subtree for this protocol
    --local subtree = tree:add(my_udp_protocol, buffer(), "TE")

	local direction = buffer(6, 1):uint()  -- taking tM or tc control byte
 
    if direction & 0x40 == 0x40 then      -- if 6th bit is set then it is TM   
	    pinfo.cols.protocol = "TELEMETRY"
	    TM_dissector(buffer, pinfo, tree)  -- OBC to GS
         
    else
	    pinfo.cols.protocol = "TELECOMMAND"
      	    TC_dissector(buffer, pinfo, tree)   -- GS to OBC
   
    end
end
------------------------------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------


local udp_port = 6779
local udp_table = DissectorTable.get("udp.port")


-- Get the TCP dissector table and add our custom dissector to the table for the port

udp_table:add(udp_port, TC_TM_PROTOCOL)