def test_005_match_error0b(self):
self.dut = pdu_utils.pdu_align('10101010', 1, 0, pdu_utils.ALIGN_DROP)
self.connectUp()
in_data = [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1]
expected_data = [1, 1, 1, 1, 1, 1, 1, 1]
in_pdu = pmt.cons(pmt.make_dict(),
pmt.init_u8vector(len(in_data), in_data))
expected_pdu = pmt.cons(
pmt.make_dict(),
pmt.init_u8vector(len(expected_data), expected_data))
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
self.assertEqual(1, self.debug.num_messages())
print("\nEXPECTED: " + repr(pmt.car(expected_pdu)))
print("GOT: " + repr(pmt.car(self.debug.get_message(0))))
print("\nEXPECTED: " +
repr(pmt.u8vector_elements(pmt.cdr(expected_pdu))))
print("GOT: " +
repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))))
self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_endian(self):
self.emitter = pdu_utils.message_emitter()
#self.endi = pdu_utils.pdu_binary_tools(pdu_utils.pdu_binary_tools.ENDIAN_SWAP8)
self.endi = pdu_utils.pdu_binary_tools(4)
self.debug = blocks.message_debug()
self.tb.msg_connect((self.emitter, 'msg'), (self.endi, 'pdu_in'))
self.tb.msg_connect((self.endi, 'pdu_out'), (self.debug, 'store'))
i_vec = pmt.init_u8vector(
16, [1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0])
e_vec = pmt.init_u8vector(
16, [1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1])
in_pdu = pmt.cons(pmt.make_dict(), i_vec)
e_pdu = pmt.cons(pmt.make_dict(), e_vec)
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
print("test endian_swap8:")
print("pdu expected: " + repr(pmt.car(e_pdu)))
print("pdu got: " + repr(pmt.car(self.debug.get_message(0))))
print("data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu))))
print("data got: " +
repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))))
print()
self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
if pmt.length(msg) > self.mtu:
print "[ERROR] Received frame is too long (%d bytes). Cannot exceed %d bytes." % (
pmt.length(msg), self.mtu)
return
#print pmt.u8vector_elements(msg)[0:2]
#length = struct.unpack('h', pmt.u8vector_elements(msg)[0:2])
length_bytes = pmt.u8vector_elements(msg)[0:2]
length = length_bytes[0] << 8 | length_bytes[1]
#print length, pmt.length(msg)
if length == 0: # caught a Filler packet, drop it
return
buff = list()
buff.extend(pmt.u8vector_elements(msg)[2:2 + length])
#print buff
# TODO: Check for pad byte if there are any
#print pmt.length(buff)
buff = array.array('B', buff)
if debug:
print "Received a packet of length %d bytes" % length
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def test_pdu_add_meta(self):
tb = gr.top_block()
dbg = blocks.message_debug()
meta = pmt.make_dict()
meta = pmt.dict_add(meta, pmt.intern('k1'), pmt.intern('v1'))
meta = pmt.dict_add(meta, pmt.intern('k2'), pmt.intern('v2'))
add_meta = pdu_add_meta(meta)
pdu = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(10, 0))
tb.msg_connect((add_meta, 'out'), (dbg, 'store'))
add_meta.to_basic_block()._post(pmt.intern('in'), pdu)
add_meta.to_basic_block()._post(
pmt.intern('system'), pmt.cons(pmt.intern('done'),
pmt.from_long(1)))
tb.start()
tb.wait()
pdu_out = dbg.get_message(0)
meta_out = pmt.car(pdu_out)
self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k1')),
'Test key k1 not in output PDU metadata')
self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k2')),
'Test key k1 not in output PDU metadata')
self.assertEqual(pmt.u8vector_elements(pmt.cdr(pdu_out)),
pmt.u8vector_elements(pmt.cdr(pdu)),
'Output PDU data does not match input PDU data')
def test_001_t(self):
data = [ord('t'), ord('e'), ord('s'), ord('t')]
msg = pmt.list1(
pmt.list2(pmt.string_to_symbol("msg_clear"),
pmt.init_u8vector(len(data), data)))
filename_key = "secret.key"
nacl.generate_key(filename_key)
strobe = blocks.message_strobe(msg, 100)
encrypt_secret = nacl.encrypt_secret(filename_key)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encrypt_secret, "Msg clear")
self.tb.msg_connect(encrypt_secret, "Msg encrypted", debug, "store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_stored = debug.get_message(0)
nonce = pmt.nth(0, msg_stored)
msg_encrypted = pmt.nth(1, msg_stored)
print pmt.symbol_to_string(pmt.nth(0, nonce)), pmt.u8vector_elements(
pmt.nth(1, nonce))
print pmt.symbol_to_string(pmt.nth(
0,
msg_encrypted)), pmt.u8vector_elements(pmt.nth(1, msg_encrypted))
def test_from_pam(self):
self.emitter = pdu_utils.message_emitter()
#self.flip = pdu_utils.pdu_binary_tools(pdu_utils.pdu_binary_tools.FROM_PAM)
self.flip = pdu_utils.pdu_binary_tools(2)
self.debug = blocks.message_debug()
self.tb.msg_connect((self.emitter, 'msg'), (self.flip, 'pdu_in'))
self.tb.msg_connect((self.flip, 'pdu_out'), (self.debug, 'store'))
i_vec = pmt.init_f32vector(6, [1, -1, -1, 1, -1, 1])
e_vec = pmt.init_u8vector(6, [1, 0, 0, 1, 0, 1])
in_pdu = pmt.cons(pmt.make_dict(), i_vec)
e_pdu = pmt.cons(pmt.make_dict(), e_vec)
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
print("test from_pam:")
print("pdu expected: " + repr(pmt.car(e_pdu)))
print("pdu got: " + repr(pmt.car(self.debug.get_message(0))))
print("data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu))))
print("data got: " +
repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))))
print()
self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_longer(self):
self.emitter = pdu_utils.message_emitter()
self.down = pdu_utils.pdu_downsample(2, 1)
self.debug = blocks.message_debug()
self.tb.msg_connect((self.emitter, 'msg'), (self.down, 'pdu_in'))
self.tb.msg_connect((self.down, 'pdu_out'), (self.debug, 'store'))
i_vec = pmt.init_u8vector(7, [0, 1, 2, 3, 4, 5, 6])
e_vec = pmt.init_u8vector(3, [1, 3, 5])
in_pdu = pmt.cons(pmt.make_dict(), i_vec)
e_pdu = pmt.cons(pmt.make_dict(), e_vec)
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
print "test long:"
print "pdu expected: " + repr(pmt.car(e_pdu))
print "pdu got: " + repr(pmt.car(self.debug.get_message(0)))
print "data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu)))
print "data got: " + repr(
pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0))))
print
self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_longer(self):
self.down = pdu_utils.pdu_downsample(2, 1)
self.connectUp()
i_vec = pmt.init_u8vector(7, [0, 1, 2, 3, 4, 5, 6])
e_vec = pmt.init_u8vector(3, [1, 3, 5])
in_pdu = pmt.cons(pmt.make_dict(), i_vec)
e_pdu = pmt.cons(pmt.make_dict(), e_vec)
self.tb.start()
time.sleep(.001)
self.emitter.emit(in_pdu)
time.sleep(.01)
self.tb.stop()
self.tb.wait()
print("test long:")
print("pdu expected: " + repr(pmt.car(e_pdu)))
print("pdu got: " + repr(pmt.car(self.debug.get_message(0))))
print("data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu))))
print("data got: " +
repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))))
print
self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
data = [0xAA] * self.preamble_bytes
data += [(self.sync >> 8) & 0xFF, self.sync & 0xFF]
payload = [len(pmt.u8vector_elements(msg)) & 0xFF]
payload += list(pmt.u8vector_elements(msg))
data += payload
if (self.has_crc):
crc = self.crc(payload)
data.append((crc >> 8) & 0xff)
data.append(crc & 0xff)
data.append(0x00)
data.append(0x00)
data.append(0x00)
data.append(0x00)
buff = array.array(
'B', numpy.unpackbits(numpy.array(data, dtype=numpy.uint8)))
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def test_001_t (self):
data = [ord('t'),ord('e'),ord('s'),ord('t')]
msg = pmt.list1(pmt.list2(pmt.string_to_symbol("msg_clear"),pmt.init_u8vector(len(data),data)))
filename_sk = "secret.key"
filename_pk = "public.key"
nacl.generate_keypair(filename_sk,filename_pk)
strobe = blocks.message_strobe(msg, 100)
encrypt_public = nacl.encrypt_public(filename_pk,filename_sk)
debug = blocks.message_debug()
self.tb.msg_connect(strobe,"strobe",encrypt_public,"Msg clear")
self.tb.msg_connect(encrypt_public,"Msg encrypted",debug,"store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_stored = debug.get_message(0)
nonce = pmt.nth(0,msg_stored)
msg_encrypted = pmt.nth(1,msg_stored)
print pmt.symbol_to_string(pmt.nth(0,nonce)), pmt.u8vector_elements(pmt.nth(1,nonce))
print pmt.symbol_to_string(pmt.nth(0,msg_encrypted)), pmt.u8vector_elements(pmt.nth(1,msg_encrypted))
def app_in(self, msg): # Generate messages
global d_msg_len, d_mac_id, d_seq_nr, d_msg
if self.debug:
print "******************************** \nGenerating messages ...\n******************************** "
print ""
print "MAC:app_in: got something:", msg
data = msg
if (pmt.is_pair(msg)):
data = pmt.cdr(msg)
#if self.debug: print "mac.py:app_in: pmt_is_pair \n"
elif (pmt.is_eof_object(msg)):
if self.debug: print "MAC: exiting"
return
elif (pmt.is_blob(msg)):
data = pmt.cdr(msg)
if self.debug: print "data is blob"
else:
if self.debug: print "MAC: unknown input"
return
if pmt.is_u8vector(data):
"data is u8vector"
data_elements = pmt.u8vector_elements(data)
if self.debug:
print "Data from Application Layer: ", data_elements, "\n"
print "Data length :", len(data_elements), "\n"
d_msg = []
if pmt.is_symbol(data):
dataString = pmt.symbol_to_string(data)
if self.debug:
print "len(pmt.symbol_to_string(data)): ", len(
dataString), "pmt.symbol_to_string(data): ", dataString
generate_mac(data, len(dataString), self.debug, d_mac_id, d_seq_nr,
self.no_self_loop)
else:
generate_mac(data, pmt.length(data), self.debug, d_mac_id,
d_seq_nr, self.no_self_loop)
generatedMacPayload = pmt.make_u8vector(len(d_msg), 0)
for i in range(len(d_msg)):
#if (pmt.is_vector(data)):
#print "d_msg[",i,"]: ", d_msg[i], " ; type: ", type(d_msg[i])
# pmt.vector_set(generatedMacPayload, i, pmt.to_pmt(d_msg[i]))
pmt.u8vector_set(generatedMacPayload, i, d_msg[i])
#else: pmt.u8vector_set(generatedMacPayload, i, d_msg[i])
self.message_port_pub(pmt.intern("pdu out"),
pmt.cons(pmt.PMT_NIL, generatedMacPayload))
print
print "**********************************"
print
if self.debug:
print "Data Published to physical Layer: ", pmt.u8vector_elements(
generatedMacPayload), "\n"
def test_packet_format_async_counter(self):
bps = 2
ac = packet_utils.default_access_code
hdr_format = digital.header_format_counter(ac, 0, 2)
formatter = digital.protocol_formatter_async(hdr_format)
snk_hdr = blocks.message_debug()
snk_pld = blocks.message_debug()
self.tb.msg_connect(formatter, 'header', snk_hdr, 'store')
self.tb.msg_connect(formatter, 'payload', snk_pld, 'store')
send_str = "Hello World" + 1000 * "xxx"
send_pmt = pmt.make_u8vector(len(send_str), ord(' '))
for i in range(len(send_str)):
pmt.u8vector_set(send_pmt, i, ord(send_str[i]))
msg = pmt.cons(pmt.PMT_NIL, send_pmt)
port = pmt.intern("in")
formatter.to_basic_block()._post(port, msg)
self.tb.start()
while (snk_hdr.num_messages() < 1) or (snk_pld.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_hdr_pmt = pmt.cdr(snk_hdr.get_message(0))
result_pld_pmt = pmt.cdr(snk_pld.get_message(0))
result_hdr = pmt.u8vector_elements(result_hdr_pmt)
result_pld = pmt.u8vector_elements(result_pld_pmt)
header = "".join(chr(r) for r in result_hdr)
payload = "".join(chr(r) for r in result_pld)
access_code = packet_utils.conv_1_0_string_to_packed_binary_string(
packet_utils.default_access_code)[0]
rx_access_code = header[0:len(access_code)]
length = len(send_str)
rx_length = struct.unpack_from(b"!H", six.b(header),
len(access_code))[0]
rx_bps = struct.unpack_from(b"!H", six.b(header),
len(access_code) + 4)[0]
rx_counter = struct.unpack_from(b"!H", six.b(header),
len(access_code) + 6)[0]
self.assertEqual(access_code, rx_access_code)
self.assertEqual(length, rx_length)
self.assertEqual(bps, rx_bps)
self.assertEqual(0, rx_counter)
self.assertEqual(length, len(payload))
self.assertEqual(send_str, payload[0:length])
def test_packet_format_async_counter(self):
bps = 2
ac = packet_utils.default_access_code
hdr_format = digital.header_format_counter(ac, 0, 2)
formatter = digital.protocol_formatter_async(hdr_format)
snk_hdr = blocks.message_debug()
snk_pld = blocks.message_debug()
self.tb.msg_connect(formatter, 'header', snk_hdr, 'store')
self.tb.msg_connect(formatter, 'payload', snk_pld, 'store')
send_str = "Hello World" + 1000*"xxx"
send_pmt = pmt.make_u8vector(len(send_str), ord(' '))
for i in range(len(send_str)):
pmt.u8vector_set(send_pmt, i, ord(send_str[i]))
msg = pmt.cons(pmt.PMT_NIL, send_pmt)
port = pmt.intern("in")
formatter.to_basic_block()._post(port, msg)
self.tb.start()
while (snk_hdr.num_messages() < 1) and (snk_pld.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_hdr_pmt = pmt.cdr(snk_hdr.get_message(0))
result_pld_pmt = pmt.cdr(snk_pld.get_message(0))
result_hdr = pmt.u8vector_elements(result_hdr_pmt)
result_pld = pmt.u8vector_elements(result_pld_pmt)
header = "".join([chr(r) for r in result_hdr])
payload = "".join([chr(r) for r in result_pld])
access_code = packet_utils.conv_1_0_string_to_packed_binary_string(packet_utils.default_access_code)[0]
rx_access_code = header[0:len(access_code)]
length = len(send_str)
rx_length = struct.unpack_from("!H", header, len(access_code))[0]
rx_bps = struct.unpack_from("!H", header, len(access_code)+4)[0]
rx_counter = struct.unpack_from("!H", header, len(access_code)+6)[0]
self.assertEqual(access_code, rx_access_code)
self.assertEqual(length, rx_length)
self.assertEqual(bps, rx_bps)
self.assertEqual(0, rx_counter)
self.assertEqual(length, len(payload))
self.assertEqual(send_str, payload[0:length])
def test_ao40_fec_deframer(self):
"""Loads symbols from an AO-73 packet and checks if ao40_fec_deframer produces the expected output and intermediate data (stored in a reference files)"""
test_data = blocks.file_source(gr.sizeof_float, self.symbols_path)
deframer = ao40_fec_deframer()
dbg_sync = blocks.message_debug()
dbg_deinterleave = blocks.message_debug()
dbg_frame = blocks.message_debug()
dbg_viterbi = blocks.message_debug()
self.tb.connect(test_data, deframer)
self.tb.msg_connect((deframer.deframer, 'out'), (dbg_sync, 'store'))
self.tb.msg_connect((deframer.deinterleaver, 'out'),
(dbg_deinterleave, 'store'))
self.tb.msg_connect((deframer.viterbi_decoder, 'out'),
(dbg_viterbi, 'store'))
self.tb.msg_connect((deframer, 'out'), (dbg_frame, 'store'))
self.tb.start()
self.tb.wait()
synced = pmt.f32vector_elements(pmt.cdr(dbg_sync.get_message(0)))
synced_reference = np.fromfile(self.frame_path, dtype='float32')
self.assertFloatTuplesAlmostEqual(
synced, synced_reference,
"synchronizer output doesn't match expected result")
deinterleaved = pmt.f32vector_elements(
pmt.cdr(dbg_deinterleave.get_message(0)))
rows = 80
cols = 65
skip = 65
output_size = 5132
deinterleaved_reference = synced_reference.reshape(
(cols, rows)).transpose().ravel()[skip:][:output_size]
self.assertFloatTuplesAlmostEqual(
deinterleaved, deinterleaved_reference,
"deinterleaver output doesn't match expected result")
post_viterbi = pmt.u8vector_elements(
pmt.cdr(dbg_viterbi.get_message(0)))
post_viterbi_reference = tuple(
np.unpackbits(np.array(self.post_viterbi_reference,
dtype='uint8')))
self.assertEqual(
post_viterbi, post_viterbi_reference,
"Viterbi decoder output doesn't match expected result")
frame = pmt.u8vector_elements(pmt.cdr(dbg_frame.get_message(0)))
self.assertEqual(
frame, self.frame_reference,
"ao40_fec_deframer() final output doesn't match expected frame")
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
try:
header = csp_header.CSP(packet[:4])
except ValueError as e:
if self.verbose:
print e
return
if not self.force and not header.crc:
if self.verbose:
print "CRC not used"
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if len(packet) < 8: # bytes CSP header, 4 bytes CRC-32C
if self.verbose:
print "Malformed CSP packet (too short)"
return
crc = crc32c.crc(packet[:-4] if self.include_header else packet[4:-4])
packet_crc = struct.unpack(">I", packet[-4:])[0]
if crc == packet_crc:
if self.verbose:
print "CRC OK"
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if self.verbose:
print "CRC failed"
self.message_port_pub(pmt.intern('fail'), msg_pmt)
def handle_msg(self, msg):
meta = pmt.car(msg)
data = pmt.cdr(msg)
if not pmt.is_u8vector(data):
raise NameError("Data is no u8 vector")
packet = pmt.u8vector_elements(data)
packet = array.array("B", packet)
# TODO - add ax25 depacket
try:
string, payload, pid, ctrl, src, dest = ax25.printpacket(packet.tostring())
if self.verbose:
print "Packet: ", packet.tostring()
print "Payload: ", payload
print "Payload(hex): ", self.hex_string(array.array("B", payload))
print "PID: %x" % pid
print "CTRL: %x" % ctrl
print "SRC: ", src
print "DEST: ", dest
payload = array.array("B", payload)
# print outstream
self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(payload), payload)))
print "********Deframer: ", time.time()
except:
print ("Bad packet")
return 0
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
self.kiss.extend(pmt.u8vector_elements(msg))
while self.kiss:
c = self.kiss.popleft()
if c == FEND:
if self.pdu and not self.pdu[0] & 0x0f:
msg = array.array('B', self.pdu[1:])
self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(msg), msg)))
self.pdu = list()
elif self.transpose:
if c == TFEND:
self.pdu.append(FEND)
elif c == TFESC:
self.pdu.append(FESC)
self.transpose = False
elif c == FESC:
self.transpose = True
else:
self.pdu.append(c)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = str(bytearray(pmt.u8vector_elements(msg)))
data = None
try:
if self.verbose:
print "Trying to decode as long packet: 250 FEC bytes, 92 data bytes"
(data, bit_corr, byte_corr) = self.ec.decode(packet[1:])
except Exception as ex:
if self.verbose: print(ex)
try:
if self.verbose:
print "Trying to decode as short packet: 128 FEC bytes, 31 data bytes"
(data, bit_corr, byte_corr) = self.ec.decode(packet[1:1 + 128])
except Exception as ex:
if self.verbose: print(ex)
if data:
if self.verbose:
print "FEC decoded OK. Bit errors: {}. Byte errors {}".format(bit_corr,
byte_corr)
data = data[:-2] # strip out HMAC
self.message_port_pub(pmt.intern('out'),
pmt.cons(pmt.PMT_NIL,
pmt.init_u8vector(len(data), bytearray(data))))
def app_rx(self,msg):
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
raise NameError("mac - input not a PDU")
if pmt.is_u8vector(data):
data = pmt.u8vector_elements(data)
else:
raise NameError("Data is not u8 vector")
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
#double check to make sure correct meta data was in pdu
if 'EM_USE_ARQ' in meta_dict.keys() and 'EM_DEST_ADDR' in meta_dict.keys():
#assign tx path depending on whether PMT_BOOL EM_USE_ARQ is true or false
if(meta_dict['EM_USE_ARQ']):
self.queue.put( (data,meta_dict) )
else:
self.tx_no_arq(( data,meta_dict) ,USER_IO_PROTOCOL_ID)
else:
raise NameError("EM_USE_ARQ and/or EM_DEST_ADDR not specified in PDU")
def test_000 (self):
if enable_vw_testing:
return
print "test_000"
payload_sizes = [28, 60, 92, 124, 156, 188, 220]
codeword_sizes = [47, 79, 111, 159, 191, 223 ,255]
enc = nuts.ngham_encoder(self.tsb_key)
dec = nuts.ngham_decoder(verbose=True)
dbg = blocks.message_debug()
self.tb.connect(enc,dec)
self.tb.msg_connect(dec, "out", dbg, "store")
port_in = pmt.intern("in")
print "starting up"
self.tb.start()
i = 0
#for i in range(len(payload_sizes)*0 + 1):
src_data = [x for x in range(payload_sizes[i])]
src_vec = pmt.init_u8vector(len(src_data), src_data)
msg = pmt.cons(pmt.PMT_NIL, src_vec)
print "posting msg"
enc.to_basic_block()._post(port_in, msg)
#while dbg.num_messages() < 1:
#print "waiting..."
time.sleep(1)
self.tb.stop()
self.tb.wait()
result_msg = dbg.get_message(0)
vector = pmt.u8vector_elements(pmt.cdr(result_msg))
print metadata
print vector
def handle_payload_message(self, msg_pmt):
#if not self.log:
# return
meta = pmt.to_python(pmt.car(msg_pmt))
packet_num = meta["packet_num"]
#packet_num = pmt.to_double(pmt.dict_values(meta)[0])
#print 'num = '+str(packet_num)
msg = pmt.cdr(msg_pmt)
msg_data = pmt.u8vector_elements(msg)
self.num_rec_packets += 1
self.sum_snr += self.curr_snr
ok = True
print '[per_logger] got message. Total = ' + str(self.num_rec_packets)
#print list(msg_data)
byte_errors, bit_errors = self.compare_lists(list(msg_data), self.payload)
if bit_errors > 0:
self.num_packet_errors += 1
print '[per_logger] Packet error. Byte errors = ' + str(bit_errors) + " Bit errors = " + str(bit_errors) + " Total = " + str(self.num_packet_errors)
ok = False
self.log_packet(ok, self.curr_snr, byte_errors, bit_errors, packet_num)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = bytes(pmt.u8vector_elements(msg))
if len(packet) != 64:
print('Error: signalling packet length != 64')
return
prbs = np.frombuffer(packet[:-6], dtype = 'uint8')
ber_prbs = np.sum((np.unpackbits(prbs) ^ np.unpackbits(signalling_prbs[6:])).astype('int')) / (prbs.size * 8)
flags = np.unpackbits(np.frombuffer(packet[-6:], dtype = 'uint8')).reshape((-1, 8))
decoded_flags = 1*(np.sum(flags, axis = 1) > 4)
try:
downlink_speed = downlink_speeds[np.packbits(decoded_flags[:3])[0] >> 5]
except IndexError:
print(f'Error: invalid downlink speed {decoded_flags[:3]}')
return
try:
coding = codings[np.packbits(decoded_flags[3:])[0] >> 5]
except IndexError:
print(f'Error: invalid coding {decoded_flags[3:]}')
return
print(f'Signalling packet: BER {ber_prbs:.4f}, rate {downlink_speed} baud, coding {coding}')
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = np.array(pmt.u8vector_elements(msg), dtype='uint8')
# Decode ESEO "line coding"
packet = np.unpackbits(packet)
packet = destuff(packet)
if packet is None:
return
packet = descramble(packet)
packet = nrzi_decode(packet)
packet = reflect_bytes(packet)
# Remove dummy padding
cutbits = packet.size % 8
if cutbits:
packet = packet[:-cutbits]
packet = np.packbits(packet)
packet = bytes(packet)
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.car(msg_pmt), pmt.init_u8vector(len(packet), packet)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print
"[ERROR] Received invalid message type. Expected u8vector"
return
packet = pmt.u8vector_elements(msg)
finalHeader = array.array(
'B',
telemetry.OCFTrailer.build(
dict(control_word_type=self.control_word_type,
clcw_version_number=self.clcw_version_number,
status_field=self.status_field,
cop_in_effect=self.cop_in_effect,
virtual_channel_identification=self.
virtual_channel_identification,
rsvd_spare1=self.rsvd_spare1,
no_rf_avail=self.no_rf_avail,
no_bit_lock=self.no_bit_lock,
lockout=self.lockout,
wait=self.wait,
retransmit=self.retransmit,
farmb_counter=self.farmb_counter,
rsvd_spare2=self.rsvd_spare2,
report_value=self.report_value))).tolist()
finalPacket = numpy.append(packet, finalHeader)
finalPacket = array.array('B', finalPacket[:])
finalPacket = pmt.cons(
pmt.PMT_NIL, pmt.init_u8vector(len(finalPacket), finalPacket))
self.message_port_pub(pmt.intern('out'), finalPacket)
def handler(self, msg):
ba = bitarray.bitarray();
meta = pmt.car(msg);
packed_data = pmt.cdr(msg);
# convert pmt -> int list (of packed bytes)
data = array.array('B', pmt.u8vector_elements(packed_data))
# add header on front
header = struct.pack('hh', 0x1337, 8*len(data));
ba.frombytes(header);
# compute header crc
c2 = binascii.crc32(ba.tobytes());
hcrc = struct.pack('i', c2);
ba.frombytes(hcrc);
# add the data payload
ba.frombytes(data.tostring())
# compute payload crc
c2 = binascii.crc32(ba.tobytes());
pcrc = struct.pack('i', c2);
ba.frombytes(pcrc);
# convert the unpacked bits to a list and back into a pmt u8vector
burst_bits = pmt.init_u8vector(len(ba), ba.tolist());
print "Tx Packet: " + ":".join("{:02x}".format(ord(c)) for c in ba.tobytes()[0:8])
# make the new pdu
pdu = pmt.cons(meta, burst_bits);
# send it on its way
self.message_port_pub(pmt.intern("unpacked_pdus"), pdu);
def test_001_t(self):
data = [ord("a"), ord("b"), ord("c"), ord("d")]
msg = pmt.list1(pmt.list2(pmt.string_to_symbol("msg_clear"), pmt.init_u8vector(len(data), data)))
filename_key = "secret.a"
nacl.generate_key(filename_key)
strobe = blocks.message_strobe(msg, 100)
encrypt_secret = nacl.encrypt_secret(filename_key)
decrypt_secret = nacl.decrypt_secret(filename_key)
debug = blocks.message_debug()
self.tb.msg_connect(strobe, "strobe", encrypt_secret, "Msg clear")
self.tb.msg_connect(encrypt_secret, "Msg encrypted", decrypt_secret, "Msg encrypted")
self.tb.msg_connect(decrypt_secret, "Msg decrypted", debug, "store")
self.tb.start()
sleep(0.15)
self.tb.stop()
self.tb.wait()
# check results
msg_out = debug.get_message(0)
msg_symbol = pmt.symbol_to_string(pmt.nth(0, pmt.nth(0, msg_out)))
msg_decrypted = pmt.u8vector_elements(pmt.nth(1, pmt.nth(0, msg_out)))
print msg_symbol, msg_decrypted
print "msg_clear", data
for k in range(len(data)):
self.assertEqual(data[k], msg_decrypted[k])
def _app_rx(self, msg, arq):
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
#raise NameError("mac - input not a PDU")
print "Message is not a PDU"
return
if pmt.is_u8vector(data):
data = pmt.u8vector_elements(data)
else:
#raise NameError("Data is not u8 vector")
print "Data is not a u8vector"
return
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
if arq:
meta_dict['EM_USE_ARQ'] = True
if (not 'EM_DEST_ADDR'
in meta_dict.keys()) or (meta_dict['EM_DEST_ADDR'] == -1):
meta_dict['EM_DEST_ADDR'] = BROADCAST_ADDR
self.dispatch_app_rx(data, meta_dict)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = bytes(pmt.u8vector_elements(msg))
try:
header = csp_header.CSP(packet[:4])
except ValueError as e:
if self.verbose:
print(e)
return
if not self.force and not header.crc:
if self.verbose:
print("CRC not used")
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if len(packet) < 8: # bytes CSP header, 4 bytes CRC-32C
if self.verbose:
print("Malformed CSP packet (too short)")
return
crc = crc32c.crc(
packet[:-4] if self.include_header else packet[4:-4])
packet_crc = struct.unpack(">I", packet[-4:])[0]
if crc == packet_crc:
if self.verbose:
print("CRC OK")
self.message_port_pub(pmt.intern('ok'), msg_pmt)
else:
if self.verbose:
print("CRC failed")
self.message_port_pub(pmt.intern('fail'), msg_pmt)
def radio_rx(self, msg):
# message structure is a meta data-data?
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
if self.debug_stderr:
# log the error
sys.stderr.write("in radio_rx(): message is not a PDU\n")
return
# data is a vector of unsigned chars?
if pmt.is_u8vector(data):
data = pmt.u8vector_elements(data)
else:
if self.debug_stderr:
# log the error
sys.stderr.write("in radio_rx(): data is not a u8vector\n")
return
# convert meta data dictionary from PMT to Python type
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
# Get exclusive access
with self.lock:
self._radio_rx(data, meta_dict)
def test_encoder_decoder(self):
"""Connects a PDU to KISS and KISS to PDU and sends PDUs through"""
pdu2kiss = pdu_to_kiss(include_timestamp=True)
kiss2pdu = kiss_to_pdu()
pdu2tag = blocks.pdu_to_tagged_stream(byte_t)
dbg = blocks.message_debug()
self.tb.connect(pdu2tag, kiss2pdu)
self.tb.msg_connect((pdu2kiss, 'out'), (pdu2tag, 'pdus'))
self.tb.msg_connect((kiss2pdu, 'out'), (dbg, 'store'))
test_size = 150
test_number_frames = 7
test_data = [
np.random.randint(0, 256, test_size, dtype='uint8')
for _ in range(test_number_frames)
]
for td in test_data:
test_frame = pmt.cons(pmt.PMT_NIL,
pmt.init_u8vector(test_size, td))
pdu2kiss.to_basic_block()._post(pmt.intern('in'), test_frame)
pdu2kiss.to_basic_block()._post(
pmt.intern('system'), pmt.cons(pmt.intern('done'),
pmt.from_long(1)))
self.tb.start()
self.tb.wait()
for j, td in enumerate(test_data):
result_data = pmt.u8vector_elements(pmt.cdr(dbg.get_message(j)))
np.testing.assert_equal(
td, result_data,
'KISS to PDU output does not match expected frame')
def packetise(self, msg):
data = pmt.cdr(msg)
meta = pmt.car(msg)
if not pmt.is_u8vector(data):
#raise NameError("Data is no u8 vector")
return "Message data is not u8vector"
buf = pmt.u8vector_elements(data)
buf_str = "".join(map(chr, buf))
# FIXME: Max: 4096-header-crc
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
pkt = ""
pkt += self.preamble
pkt += packet_utils.make_packet(
buf_str,
0, #self._samples_per_symbol,
0, #self._bits_per_symbol,
#preamble=<default>
access_code=self.access_code,
pad_for_usrp=False, #pad_for_usrp,
whitener_offset=self.whitener_offset,
whitening=self.whiten)
pkt += self.postamble
pkt = map(ord, list(pkt))
if self.rotate_whitener_offset:
self.whitener_offset = (self.whitener_offset + 1) % 16
meta = pmt.to_pmt(meta_dict)
data = pmt.init_u8vector(len(pkt), pkt)
self.message_port_pub(pmt.intern('out'), pmt.cons(meta, data))
'''
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = bytearray(pmt.u8vector_elements(msg))
size = len(packet) - 6
try:
header = telemetry.PrimaryHeader.parse(packet[:])
if header.ocf_flag == 1:
size -= 4
except:
print("Could not decode telemetry packet")
return
parsed = telemetry.FullPacket.parse(packet[:], size=size)
payload = parsed.payload
#The number 6 is used here, because that's the length of the Primary Header.
#todo: Add a variable for this
while len(payload) != 0:
if len(self.space_packet) < 6:
left = 6 - len(self.space_packet)
self.space_packet.extend(payload[:left])
payload = payload[left:]
if len(self.space_packet) >= 6:
self.length_of_space_packet = space_packet.PrimaryHeader.parse(
bytearray(self.space_packet)).data_length
left = self.length_of_space_packet + 6 - len(self.space_packet)
self.space_packet.extend(payload[:left])
payload = payload[left:]
if 6 + self.length_of_space_packet == len(self.space_packet):
self.sendPacket()
def _app_rx(self, msg, arq):
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
#raise NameError("mac - input not a PDU")
print "Message is not a PDU"
return
if pmt.is_u8vector(data):
data = pmt.u8vector_elements(data)
else:
#raise NameError("Data is not u8 vector")
print "Data is not a u8vector"
return
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
if arq:
meta_dict['EM_USE_ARQ'] = True
if (not 'EM_DEST_ADDR' in meta_dict.keys()) or (meta_dict['EM_DEST_ADDR'] == -1):
meta_dict['EM_DEST_ADDR'] = BROADCAST_ADDR
self.dispatch_app_rx(data, meta_dict)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
try:
header = CSP(packet[:4])
except ValueError as e:
print e
return
# check that message is beacon
if header.destination != 10 or header.dest_port != 30:
print "Not a beacon: destination address {} port {}".format(header.destination,
header.dest_port)
print
return
if len(packet) < 5:
print "Malformed beacon (too short)"
return
beacon_type = packet[4]
payload = packet[4:]
beacon = None
if header.source == 1 and beacon_type == 0 and len(payload) == 140:
beacon = gomx3_beacon.beacon_1_0(payload)
print(beacon if beacon else "Beacon type {} {}".format(header.source, beacon_type))
print
def test_pdu_length_filter(self):
tb = gr.top_block()
dbg = blocks.message_debug()
sizes = [25, 50, 100]
test_data = list(range(np.max(sizes)))
msgs = [test_data[:x] for x in sizes]
pdus = [pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(m), m))
for m in msgs]
length_filter = pdu_length_filter(40, 60)
tb.msg_connect((length_filter, 'out'), (dbg, 'store'))
for pdu in pdus:
length_filter.to_basic_block()._post(pmt.intern('in'), pdu)
length_filter.to_basic_block()._post(
pmt.intern('system'),
pmt.cons(pmt.intern('done'), pmt.from_long(1)))
tb.start()
tb.wait()
self.assertEqual(
dbg.num_messages(), 1,
'Incorrect number of messages passed by PDU Length Filter')
out = pmt.u8vector_elements(pmt.cdr(dbg.get_message(0)))
self.assertEqual(
len(out), 50,
'PDU Length Filter output does not match expected')
def handle_queue(self):
if self.state == self.STATE_IDLE:
if self.app_queue.empty() == False:
self.last_tx_packet = self.app_queue.get()
msg_str = "".join([chr(x) for x in pmt.u8vector_elements(pmt.cdr(self.last_tx_packet))])
self.curr_packet_len = len(msg_str[3:])
self.curr_packet_seq = ord(msg_str[0])
self.last_tx_time = time.time()
print '[stop_and_wait] :: Sending packet. Payload len: '+ str(self.curr_packet_len) +' Queue fill level = ', self.app_queue.qsize()
if self.use_ack:
self.state = self.STATE_WAIT_FOR_ACK
self.num_data_packets_send += 1
self.log_packet("TX", 0, self.curr_packet_len, self.curr_packet_seq, self.last_snr)
self.message_port_pub(pmt.intern('to_phy'), self.last_tx_packet)
elif self.state == self.STATE_WAIT_FOR_ACK:
if (time.time() - self.last_tx_time) > self.ack_timeout:
#retransmit
print '[stop_and_wait] :: ACK timeout. Retransmitting'
self.last_tx_time = time.time()
self.num_ack_timeouts += 1
self.num_data_packets_send += 1
self.log_packet("TX", 0, self.curr_packet_len, self.curr_packet_seq, self.last_snr)
self.message_port_pub(pmt.intern('to_phy'), self.last_tx_packet)
def _app_rx(self, msg):
# verify structure, must be meta-data pair
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
# wrong structure!
if self.debug_stderr:
sys.stderr.write("in _app_rx(): message is not a PDU\n")
# do nothing!
return
# is data a vector of unsigned chars?
if pmt.is_u8vector(data):
# yes! convert to python data type
data = pmt.u8vector_elements(data)
else:
# no!
if self.debug_stderr:
sys.stderr.write("in _app_rx(): data is not a u8vector\n")
# do nothing!
return
# convert meta data to a Python dictionary
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
# send the packet
self.send_pkt_radio(data, meta_dict, self.pkt_cnt)
# increment packet number
self.pkt_cnt = (self.pkt_cnt + 1) % 256
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = pmt.u8vector_elements(msg)
if self.packet_len is not None:
packet = packet[:self.packet_len]
if (self.packet_len is not None and len(packet) < self.packet_len) \
or (self.packet_len is None and len(packet) < 2):
if self.verbose:
print("Packet too short")
return
packet_out = packet[:-2]
msg_out = pmt.cons(pmt.PMT_NIL,
pmt.init_u8vector(len(packet_out), packet_out))
if crc16_arc(packet) == 0:
if self.verbose:
print("CRC OK")
self.message_port_pub(pmt.intern('ok'), msg_out)
else:
if self.verbose:
print("CRC failed")
self.message_port_pub(pmt.intern('fail'), msg_out)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = bytes(pmt.u8vector_elements(msg))
if len(packet) <= 4 + 8:
return
csp = CSP(packet[:4])
packet_number = struct.unpack('<I', packet[-8:-4])[0]
if csp.destination == 6:
print('Packet number', packet_number, '(camera)')
return
# destination 5 is used for telemetry
if csp.destination != 5:
return
data = by701_telemetry.beacon_parse(packet[4:])
if data:
print('Packet number', packet_number, '(telemetry)')
print('--------------------------------------------')
print(data)
print()
else:
print('Could not parse beacon')
print()
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print('[ERROR] Received invalid message type. Expected u8vector')
return
data = list(pmt.u8vector_elements(msg))
crc = hdlc.crc_ccitt(data)
data.append(crc & 0xff)
data.append((crc >> 8) & 0xff)
buff = list(hdlc.flag * self.preamble_bytes)
ones = 0 # number of consecutive ones
for byte in data:
for _ in range(8):
# Transmit byte LSB first
x = byte & 1
buff.append(x)
if x:
ones += 1
else:
ones = 0
if ones == 5:
# Bit-stuff
buff.append(0)
ones = 0
byte >>= 1
buff.extend(hdlc.flag * self.postamble_bytes)
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
header = CSP(packet[:4])
# check that message is beacon
if header.destination != 10 or header.dest_port != 30:
return
beacon_type = packet[4]
payload = packet[4:]
if header.source != 1 or beacon_type != 0 or len(payload) != 140:
return
beacon = gomx3_beacon.beacon_1_0(payload)
print """<Placemark>
<name>{}</name>
<description>Altitude: {}ft Time: {}</description>
<styleUrl>#plane</styleUrl>
<Point><coordinates>{},{}</coordinates></Point>
</Placemark>""".format(hex(beacon.adsb_last_icao), beacon.adsb_last_alt,
beacon.adsb_last_time,
beacon.adsb_last_lon if beacon.adsb_last_lon <= 180 else beacon.adsb_last_lon - 360,
beacon.adsb_last_lat)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = bytearray(pmt.u8vector_elements(msg))
if len(packet) <= 4 + 8:
return
csp = CSP(packet[:4])
# destination 5 is used for telemetry
if csp.destination != 5:
return
data = by701_telemetry.beacon_parse(packet[4:])
if not data or 'latitude' not in data:
return
line = array.array(
'B', '{},{},{}\n'.format(data.longitude, data.latitude,
data.altitude))
self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL,\
pmt.init_u8vector(len(line), line)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
data = list(pmt.u8vector_elements(msg))
crc = hdlc.crc_ccitt(data)
data.append(crc & 0xff)
data.append((crc >> 8) & 0xff)
buff = hdlc.flag * self.preamble_bytes
ones = 0 # number of consecutive ones
for byte in data:
for _ in range(8):
# transmit byte LSB first
x = byte & 1
buff.append(x)
if x:
ones += 1
else:
ones = 0
if ones == 5:
# bit-stuff
buff.append(0)
ones = 0
byte >>= 1
buff.extend(hdlc.flag * self.postamble_bytes)
buff = array.array('B', buff)
self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
# check packet length
# an AX.25 header with 2 addresses, control and PID is 16 bytes
if len(packet) < 16:
self.message_port_pub(pmt.intern('fail'), msg_pmt)
return
if self.direction == 'to':
address = packet[:7]
else:
address = packet[7:14]
callsign = array.array('B', map(lambda c: c >> 1,
address[:6])).tostring().rstrip(' ')
ssid = int((address[6] >> 1) & 0x0f)
if callsign != self.callsign or (self.ssid != None
and ssid != self.ssid):
# incorrect address
self.message_port_pub(pmt.intern('fail'), msg_pmt)
else:
# correct address
self.message_port_pub(pmt.intern('ok'), msg_pmt)
def handle_msg(self, msg_pmt):
"""Process incoming GNU Radio PDU containing a Blocksat Packet
Args:
msg_pmt : the message containing a Blocksat Packet
"""
# Get metadata and information from message
meta = pmt.to_python(pmt.car(msg_pmt))
msg = pmt.cdr(msg_pmt)
# Validate (message should be a vector of u8, i.e. bytes)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type.\n")
return
# Convert incoming packet to a bytes string
raw_pkt = b''.join([chr(x) for x in pmt.u8vector_elements(msg)])
if (self.protocol_version > 1):
# Parse Blocksat Packet
packet = BlocksatPacket(raw_pkt)
# Process the parsed packet
self.handle_pkt(packet)
else:
# Write raw data directly to named pipe
self.blk_pipe.write(raw_pkt)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
buff = list()
buff.append(FEND)
buff.append(numpy.uint8(0))
for x in pmt.u8vector_elements(msg):
if x == FESC:
buff.append(FESC)
buff.append(TFESC)
elif x == FEND:
buff.append(FESC)
buff.append(TFEND)
else:
buff.append(numpy.uint8(x))
buff.append(FEND)
buff = array.array('B', buff)
self.message_port_pub(
pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print("[ERROR] Received invalid message type. Expected u8vector")
return
packet = bytes(pmt.u8vector_elements(msg))
beacon = tlm.parse(packet)
# check that message is beacon
if beacon.csp_header.destination != 10 or beacon.csp_header.destination_port != 30:
return
if beacon.csp_header.source != 1 or beacon.beacon_type != 0:
return
adsb = beacon.beacon.adsb
print("""<Placemark>
<name>{}</name>
<description>Altitude: {}ft Time: {}</description>
<styleUrl>#plane</styleUrl>
<Point><coordinates>{},{}</coordinates></Point>
</Placemark>""".format(hex(adsb.last_icao), adsb.last_alt,
adsb.last_time,
adsb.last_lon if adsb.last_lon <= 180 else adsb.last_lon - 360,
adsb.last_lat))
def handle_msg(self, msg_pmt):
meta = pmt.to_python(pmt.car(msg_pmt))
msg = pmt.cdr(msg_pmt)
#TODO: Fix this ... hack hack hack
bin_str = int("".join(map(lambda x: '1' if x else '0', pmt.u8vector_elements(msg))), 2)
data = struct.pack('xB7xBB', meta['chan'], 0xe9, 0x8a)
data += bytearray.fromhex(hex(bin_str)[2:-1])
self.write_packet(data)
def handle_msg(self, msg):
if(pmt.is_pair(msg)):
blob = pmt.cdr(msg)
s = ""
for i in pmt.u8vector_elements(blob):
s += chr(i)
print "encoder sent:" + s
self.encode_string(s) #"\n\n\n"
def received_msg(self, msg):
meta = pmt.car(msg)
meta_dict = pmt.to_python(meta)
print >> sys.stderr, 'seq no. =', meta_dict['seq_nr']
data = pmt.cdr(msg)
data = pmt.u8vector_elements(data)
print >> sys.stderr, 'received data:\n', data
print >> sys.stderr, '\n'
def rx_from_mac(self, msg):
meta = pmt.car(msg)
meta_dict = pmt.to_python(meta)
print >> sys.stderr, 'seq no. =', meta_dict['seq_nr']
data = pmt.cdr(msg)
print >> sys.stderr, 'received data:\n', pmt.u8vector_elements(data)
print >> sys.stderr, '\n'
self.message_port_pub(pmt.intern('to_tap'), pmt.cons(pmt.PMT_NIL, data))
def radio_rx(self,msg):
try:
meta = pmt.car(msg)
data = pmt.cdr(msg)
except:
raise NameError("mac - input not a PDU")
if pmt.is_u8vector(data):
data = pmt.u8vector_elements(data)
else:
raise NameError("Data is not u8 vector")
incoming_pkt = data #get data
print >> sys.stderr, '@MAC.radio_rx\t\tincoming pkt:', incoming_pkt
if ( len(incoming_pkt) > 5 ): #check for weird header only stuff
if( ( incoming_pkt[PKT_INDEX_DEST] == self.addr or incoming_pkt[PKT_INDEX_DEST] == 255) and not incoming_pkt[PKT_INDEX_SRC] == self.addr): #for us?
#check to see if we must ACK this packet
if(incoming_pkt[PKT_INDEX_CTRL] == ARQ_REQ): #TODO, stuff CTRL and Protocol in one field
self.send_ack(incoming_pkt[PKT_INDEX_SRC],incoming_pkt[PKT_INDEX_CNT]) #Then send ACK then
if not (self.arq_expected_sequence_number == incoming_pkt[PKT_INDEX_CNT]):
self.arq_sequence_error_cnt += 1
self.throw_away = True
print >> sys.stderr, "@MAC.radio_rx\t\tThrow away"
else:
self.throw_away = False
self.arq_expected_sequence_number = ( incoming_pkt[PKT_INDEX_CNT] + 1 ) % 255
else:
if not (self.no_arq_expected_sequence_number == incoming_pkt[PKT_INDEX_CNT]):
self.no_arq_sequence_error_cnt += 1
#print self.no_arq_sequence_error_cnt
#print self.no_arq_sequence_error_cnt,incoming_pkt[PKT_INDEX_CNT],self.no_arq_expected_sequence_number
self.no_arq_expected_sequence_number = ( incoming_pkt[PKT_INDEX_CNT] + 1 ) % 255
incoming_protocol_id = incoming_pkt[PKT_INDEX_PROT_ID]
#check to see if this is an ACK packet
if(incoming_protocol_id == ARQ_PROTOCOL_ID):
if incoming_pkt[5] == self.expected_arq_id:
self.arq_channel_state = ARQ_CHANNEL_IDLE
self.pkt_cnt_arq = ( self.pkt_cnt_arq + 1 ) % 255
print >> sys.stderr, '@MAC.radio_rx\t\tACKED, PKT_ID:', self.expected_arq_id
else:
print >> sys.stderr, '@MAC.radio_rx\t\treceived out of sequence ack',incoming_pkt[5],self.expected_arq_id
#do something with incoming user data
elif(incoming_protocol_id == USER_IO_PROTOCOL_ID):
if not self.throw_away:
data = incoming_pkt
meta_dict = {}
pdu_tuple = (data,meta_dict)
self.output_user_data(pdu_tuple)
self.throw_away = False
else:
print >> sys.stderr, '@MAC.radio_rx\t\tunknown protocol'
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
try:
print(csp_header.CSP(packet[:4]))
except ValueError as e:
print e
def handler(self, msg):
meta = pmt.car(msg);
data_in = pmt.cdr(msg);
data = array.array('B', pmt.u8vector_elements(data_in))
#data = array.array('B', pmt.u8vector_elements(data_in))
pre_data = self.preamble + data;
# print pre_data[:100];
#burst_bits = pmt.to_pmt(pre_data);
burst_bits = pmt.init_u8vector(len(pre_data), pre_data.tolist());
pdu = pmt.cons(meta, burst_bits);
self.message_port_pub(pmt.intern("pdus"), pdu);
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = array.array("B", pmt.u8vector_elements(msg))
header = packet[:4]
header.reverse()
packet = header + packet[4:]
msg_pmt = pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(packet), bytearray(packet)))
self.message_port_pub(pmt.intern('out'), msg_pmt)
def handle_msg(self, msg_pmt):
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "[ERROR] Received invalid message type. Expected u8vector"
return
packet = str(bytearray(pmt.u8vector_elements(msg)))
try:
print(str(beacon.Beacon(packet[4:])))
except ValueError as e:
print e
def handle_message(self, msg_pmt):
meta = pmt.to_python(pmt.car(msg_pmt))
msg = pmt.cdr(msg_pmt)
if not pmt.is_u8vector(msg):
print "ERROR wrong pmt format"
return
msg_str = "".join([chr(x) for x in pmt.u8vector_elements(msg)])
packet = digital.packet_utils.dewhiten(msg_str, 0)
(ok, packet) = digital.crc.check_crc32(packet)
if not ok:
print '#######################################################'
print '################## ERROR: Bad CRC #####################'
print '#######################################################'
return
if ok:
#print 'CRC check OK'
frag_byte = ord(packet[0])
frag_index = frag_byte >> 2
#print 'Fragmentation byte: ', frag_byte
if frag_byte & 0x01 == 1 :
#print "got packet fragment. Index = %d. Last index = %d" % (frag_index, self.last_frag_index)
self.last_frag_index = frag_index
if frag_byte & 0x02 == 0 :
self.wait_for_frag = True
#strip fragmentation control and append payload
self.packet_buffer += packet[1:]
return
else:
#last part of fragmented packet
#print 'got last fragment of packet. Index = ', frag_index
self.wait_for_frag = False
self.packet_buffer += packet[1:]
packet = self.packet_buffer
self.packet_buffer = ''
else:
#packet is not fragmented at all.
#just strip off frag byte and hand it off
packet = packet[1:]
self.wait_for_frag = False
if not self.wait_for_frag:
# Create an empty PMT (contains only spaces):
send_pmt = pmt.make_u8vector(len(packet), ord(' '))
# Copy all characters to the u8vector:
for i in range(len(packet)):
pmt.u8vector_set(send_pmt, i, ord(packet[i]))
# Send the message:
self.message_port_pub(pmt.intern('out'),
pmt.cons(pmt.PMT_NIL, send_pmt))
def tx_handler(self, msg):
self.tx_cnt = self.tx_cnt + 1;
if(len(self.retrans) > 1000):
print "WARNING!!!!!!!!! DISCARDING PACKET BECAUSE RE-TX QUEUE IS TOO LONG!"
return
meta = pmt.car(msg);
data_in = array.array('B', pmt.u8vector_elements(pmt.cdr(msg)))
now = time.time();
self.retrans[self.pkt_idx] = {"time_orig":now,
"time_last":now,
"attempts":0,
"pdu":(meta,data_in)};
self.send_data(self.pkt_idx,(meta,data_in));
self.pkt_idx = self.pkt_idx + 1;
def track(self, msg):
data = pmt.cdr(msg)
meta = pmt.car(msg)
if not pmt.is_u8vector(data):
#raise NameError("Data is no u8 vector")
return "Message data is not u8vector"
buf = pmt.u8vector_elements(data)
meta_dict = pmt.to_python(meta)
if not (type(meta_dict) is dict):
meta_dict = {}
if not 'EM_SRC_ID' in meta_dict:
if self.verbose:
print "[%s<%s>] Packet without source channel ID" % (self.name(), self.unique_id())
return
src_id = meta_dict['EM_SRC_ID']
if len(buf) < 18:
if self.verbose:
print "[%s<%s>] Packet is less than Ethernet minimum" % (self.name(), self.unique_id())
return
mac_dest = buf[0:6]
mac_src = buf[6:12]
mac_dest_str = ":".join(map(lambda x: ("%02X"%(x)), mac_dest))
mac_src_str = ":".join(map(lambda x: ("%02X"%(x)), mac_src))
#if self.verbose:
# print "[%s<%s>] (%02d) %s -> %s" % (self.name(), self.unique_id(), src_id, mac_src_str, mac_dest_str)
with self.lock:
if mac_src_str in self.mac_to_chan_map and self.mac_to_chan_map[mac_src_str] != src_id:
# Same MAC from different source ID
if self.verbose:
print "[%s<%s>] Same MAC %s from different source ID %d (current mapping: %d)" % (self.name(), self.unique_id(), mac_src_str, src_id, self.mac_to_chan_map[mac_src_str])
elif not mac_src_str in self.mac_to_chan_map:
print "[%s<%s>] %s -> %02d" % (self.name(), self.unique_id(), mac_src_str, src_id)
#if src_id in self.chan_to_mac_map and self.chan_to_mac_map[src_id] != mac_src_str:
# # Already have a MAC from a source ID, but now seeing a different MAC
# pass
#self.chan_to_mac_map[src_id] = mac_src_str
self.mac_to_chan_map[mac_src_str] = src_id
