def test_space_packet_decoder_segmented():
"""
Test the decoder with a list of packets
"""
random_data = os.urandom(MAX_BYTES_PER_PACKET + 1) # one more byte than space packet can handle
expected_space_packet_0 = SpacePacket(
ccsds_version=0,
packet_type=SpacePacketType.TELECOMMAND,
apid=TEST_APID_VAL,
seq_flags=SpacePacketSequenceFlags.SEGMENT_FIRST,
packet_seq_count=0,
data=random_data[0:MAX_BYTES_PER_PACKET],
sec_hdr_flag=False
)
expected_space_packet_1 = SpacePacket(
ccsds_version=0,
packet_type=SpacePacketType.TELECOMMAND,
apid=TEST_APID_VAL,
seq_flags=SpacePacketSequenceFlags.SEGMENT_LAST,
packet_seq_count=1,
data=bytes(random_data[MAX_BYTES_PER_PACKET:]),
sec_hdr_flag=False
)
space_packet_list = [expected_space_packet_0, expected_space_packet_1]
decoder = SpacePacketProtocolDecoder(apid=TEST_APID_VAL)
user_data = decoder.decode(space_packet_list)
assert(user_data == random_data)
def test_encoder_decoder_compatibility():
"""
Decoder should be able to decode the list of space packets from encoder
"""
spp_encoder = SpacePacketProtocolEncoder(
packet_type=SpacePacketType.TELECOMMAND,
apid=TEST_APID_VAL
)
spp_decoder = SpacePacketProtocolDecoder(apid=TEST_APID_VAL)
random_data = os.urandom(MAX_BYTES_PER_PACKET * 10 + 77)
encoded_packet_list = spp_encoder.encode_packets(random_data)
decoded_data = spp_decoder.decode(encoded_packet_list)
assert(decoded_data == random_data)
class CCSDS_Decoder():
def __init__(self,
apid=APID,
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID,
start_sequnce=START_SEQUENCE,
tail_sequence=TAIL_SEQUENCE):
# start and tail sequence must be the same as the cltu encoder
self.cltu_decoder = CLTUDecoder(start_sequence=START_SEQUENCE,
tail_sequence=TAIL_SEQUENCE)
# spacecraft, virtual channel and map ID must be the same as the tc datalink encoder
self.tc_datalink_decoder = TCDataLinkProtocolDecoder(
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID)
# APID must be the same as spp encoder
self.spp_decoder = SpacePacketProtocolDecoder(apid=APID)
def decode_data(self, data):
recovered_tcc_datalink_list = self.cltu_decoder.decode_to_tc_datalink_packets(
data) # recover tc
# datalink
recovered_spp_list = self.tc_datalink_decoder.decode_to_spp_packets(
recovered_tcc_datalink_list) # recovere
# space packets
ret = self.spp_decoder.decode(
recovered_spp_list) # recover original data
return ret
def setup_encoder_decoder():
# setup space packet, tc datalink and tc channel encoder/decoder
spp_encoder = SpacePacketProtocolEncoder(
packet_type=SpacePacketType.TELECOMMAND, apid=TEST_APID_VAL)
tc_datalink_encoder = TCDataLinkProtocolEncoder(
control_command_flag=ControlCommandFlag.CONTROL,
spacecraft_id=TEST_SPACECRAFT_ID,
virtual_channel_id=TEST_VIRTUAL_CHANNEL_ID,
map_id=TEST_MAP_ID)
cltu_encoder = CLTUEncoder(start_sequence=TEST_START_SEQUENCE,
tail_sequence=TEST_END_SEQUENCE)
cltu_decoder = CLTUDecoder(start_sequence=TEST_START_SEQUENCE,
tail_sequence=TEST_END_SEQUENCE)
tc_datalink_decoder = TCDataLinkProtocolDecoder(
spacecraft_id=TEST_SPACECRAFT_ID,
virtual_channel_id=TEST_VIRTUAL_CHANNEL_ID,
map_id=TEST_MAP_ID)
spp_decoder = SpacePacketProtocolDecoder(apid=TEST_APID_VAL)
return [
spp_encoder, tc_datalink_encoder, cltu_encoder, cltu_decoder,
tc_datalink_decoder, spp_decoder
]
def solve_challenge(data):
cltu_decoder = CLTUDecoder(
start_sequence=START_SEQUENCE,
tail_sequence=TAIL_SEQUENCE
)
tc_datalink_decoder = TCDataLinkProtocolDecoder(
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID
)
spp_decoder = SpacePacketProtocolDecoder(apid=APID)
recovered_tcc_datalink_list = cltu_decoder.decode_to_tc_datalink_packets(data)
recovered_spp_list = tc_datalink_decoder.decode_to_spp_packets(recovered_tcc_datalink_list)
ret = spp_decoder.decode(recovered_spp_list)
return ret
def __init__(self,
apid=APID,
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID,
start_sequnce=START_SEQUENCE,
tail_sequence=TAIL_SEQUENCE):
# start and tail sequence must be the same as the cltu encoder
self.cltu_decoder = CLTUDecoder(start_sequence=START_SEQUENCE,
tail_sequence=TAIL_SEQUENCE)
# spacecraft, virtual channel and map ID must be the same as the tc datalink encoder
self.tc_datalink_decoder = TCDataLinkProtocolDecoder(
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID)
# APID must be the same as spp encoder
self.spp_decoder = SpacePacketProtocolDecoder(apid=APID)
def test_space_packet_decoder_unsegmented():
"""
Test the decoder on ONE space packet
"""
expected_data = b'\xde\xad\xbe\xef'
space_packet = SpacePacket(
ccsds_version=0,
packet_type=SpacePacketType.TELECOMMAND,
apid=TEST_APID_VAL,
seq_flags=SpacePacketSequenceFlags.UNSEGMENTED,
packet_seq_count=17,
data=expected_data,
sec_hdr_flag=False
)
decoder = SpacePacketProtocolDecoder(apid=TEST_APID_VAL)
user_data = decoder.decode([space_packet])
assert (user_data == expected_data)
def solve_challenge(data):
tm_decoder = TMDecoder()
tc_datalink_decoder = TCDataLinkProtocolDecoder(
spacecraft_id=SPACECRAFT_ID,
virtual_channel_id=VIRTUAL_CHANNEL_ID,
map_id=MAP_ID)
spp_decoder = SpacePacketProtocolDecoder(apid=APID)
recovered_tcc_datalink_list = tm_decoder.decode_to_tc_datalink_packets(
data)
recovered_spp_list = tc_datalink_decoder.decode_to_spp_packets(
recovered_tcc_datalink_list)
msg_song = spp_decoder.decode(recovered_spp_list)
with open(LYRIC_FILE, 'r') as fh:
song = fh.read()
msg = msg_song[int(len(song) / 2):int(-len(song) / 2)]
res = gzip.decompress(msg)
return res
"""
The challenge is generated up to this point, the folllowing code is to recover the file once the bytestream is
recovered
"""
# start and tail sequence must be the same as the cltu encoder
cltu_decoder = CLTUDecoder(start_sequence=b'\xde\xad',
tail_sequence=b'\xbe\xef')
# spacecraft, virtual channel and map ID must be the same as the tc datalink encoder
tc_datalink_decoder = TCDataLinkProtocolDecoder(spacecraft_id=80,
virtual_channel_id=33,
map_id=20)
# APID must be the same as spp encoder
spp_decoder = SpacePacketProtocolDecoder(apid=1337)
with open(TEST_OUTPUT_BINARY_FILE, 'rb') as f:
recovered_bytes = f.read()
recovered_tcc_datalink_list = cltu_decoder.decode_to_tc_datalink_packets(
cltu_bytes) # recover tc datalink
new_recovered_tcc_datalink_list = [None] * len(recovered_tcc_datalink_list)
# recover order of the mixed up datalink list
for p in recovered_tcc_datalink_list:
new_recovered_tcc_datalink_list[p.frame_seq_num] = p
# recover space packets
recovered_spp_list = tc_datalink_decoder.decode_to_spp_packets(
new_recovered_tcc_datalink_list)
recovered_data = spp_decoder.decode(
recovered_spp_list) # recover original data