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 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