def pdu_in(self, msg): # consume messages global d_mac_id if self.debug: print "****************************** \nConsuming messages...\n******************************** " data = 0 if(pmt.is_eof_object(msg)): self.message_port_pub(pmt.intern('pdu out'), pmt.PMT_EOF) return elif(pmt.is_pair(msg)): #if self.debug: print "pmt_is_pair" data = pmt.cdr(msg) elif(pmt.is_bool(msg)): if self.debug: print "mac.py:pdu in: got a busy notification" return data_len = pmt.length(data) if self.debug: print "" print "Data received from pdusical Layer: ", pmt.u8vector_elements(data) print "" if (data_len < 13): if self.debug: print "MAC: frame too short. Dropping! \n" return else: if self.no_self_loop: # Compare to our own "mac ID" and reject if we are self routing packets. macId = pmt.u8vector_elements(data)[0] if self.debug: print "macId of the packet: ", macId print "our macId: ", d_mac_id print "data_len: ", data_len if (macId != d_mac_id): crc = crc16(pmt.u8vector_elements(data), data_len) if self.debug: print "#### CRC at Reception: #### " , crc.get_crc(), "\n" if (crc.get_crc()): print "MAC: wrong crc. Dropping packet! \n" return macPayload = pmt.make_u8vector(data_len - 13, 0) #Because of the iperf 'E' issue #macPayload = pmt.make_u8vector(data_len - 14, 0) #for i in range(data_len - 14): for i in range(data_len - 13): pmt.u8vector_set(macPayload, i, pmt.u8vector_elements(data)[i+11]) self.message_port_pub(pmt.intern('app out'), pmt.cons(pmt.PMT_NIL, macPayload)) if self.debug: print "Data sent up to Application Layer : ", pmt.u8vector_elements(macPayload), "\n" else: crc = crc16(pmt.u8vector_elements(data), data_len) if self.debug: print "#### CRC at Reception: #### " , crc.get_crc(), "\n" if(crc.get_crc()): if self.debug: print "MAC: wrong crc. Dropping packet! \n" return macPayload = pmt.make_u8vector(data_len - 14, 0) for i in range(data_len - 14): pmt.u8vector_set(macPayload, i, pmt.u8vector_elements(data)[i+10]) self.message_port_pub(pmt.intern('app out'), pmt.cons(pmt.PMT_NIL, macPayload)) if self.debug: print "Data sent up to Application Layer : ", pmt.u8vector_elements(macPayload), "\n"
def make_NPDU(self,msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt #print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) #print "is pair" else: print "Formato desconocido" return # Toma Pmt pair a numpyarray y luego a list data_np = pmt.to_python(blob) #numpy.ndarray apdu = data_np.tolist() #python list Src_Ieee = self.SrcIeeeN # la dir del USRP de 64 bit puede ser cualquiera global Seq_Num Seq_Num[0] = Seq_Num[0] +1 if Seq_Num[0] > 254: Seq_Num[0] = 0 Radio = [0x1E] # Saltos Max del mensaje Src_Add = self.SrcAddN # Puede ser cualquiera Dst_Add = [0xFF,0xFF] # Coordinador 00 00 / #broadcast FF FF FC_N = [0x08,0x10] # Frame Control LSB-MSB NPDU = FC_N + Dst_Add + Src_Add + Radio + Seq_Num + Src_Ieee + apdu # Crea PMT vacio send_pmt = pmt.make_u8vector(len(NPDU), ord(' ')) # Copia Caracteres a u8vector: for i in range(len(NPDU)): pmt.u8vector_set(send_pmt, i, NPDU[i]) # Envia mensaje: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def deframe_APDU(self, msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt # print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) # print "is pair" else: print "Formato desconocido" return data_np = pmt.to_python(blob) # numpy.ndarray data_py = data_np.tolist() # python list # print "Paquete",data_py,data_py.__class__ if data_py[2:4] == [0xFF, 0xFF]: index = 16 else: index = 24 del data_py[:index] # FC(2),Dst_Add(2),Src_Add(2),Radio(1),Sec_N(1),X->Dst_IEEE(8), Src_IEEE(8) # print "DEPACKED-->",data_py # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(" ")) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, send_pmt))
def post_message(self, msg_str): if self.ack == 0: """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do string sanitization: msg_str = filter(lambda x: x in string.printable, msg_str) send_str = "[{}] {}".format(self.prefix, msg_str) count = 0; # prepend AC to sent packet if self.access_code: (packed_access_code, padded) = digital.packet_utils.conv_1_0_string_to_packed_binary_string(self.access_code) print self.access_code print map(ord, packed_access_code) print padded send_str = packed_access_code + send_str #print len(send_str) #print send_str # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) #print ord(send_str[i]) # Send the message: while self.ack != 1: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt)) time.sleep(.06) count = count + 1 if count == 6: print 'Message not received by RX' self.ack = 1 print count #print self.ack self.ack = 0
def deframe_MSJ(self, msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt #print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) #print "is pair" else: print "Formato desconocido" return data_np = pmt.to_python(blob) #numpy.ndarray data_py = data_np.tolist() #python list #print "Paquete",data_py,data_py.__class__ index = 8 del data_py[: index] # FC (1), DesEP(1),Cluster(2),Profile(2),SourEP(1),Counter(1) #print "DEPACKED-->",data_py # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(' ')) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def deframe_MSJ(self, msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt # print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) # print "is pair" else: print "Formato desconocido" return data_np = pmt.to_python(blob) # numpy.ndarray data_py = data_np.tolist() # python list # print "Paquete",data_py,data_py.__class__ index = 8 del data_py[:index] # FC (1), DesEP(1),Cluster(2),Profile(2),SourEP(1),Counter(1) # print "DEPACKED-->",data_py # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(" ")) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, send_pmt))
def test_010_t (self): # PHR prefixer to removal data_in = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(2*self.c.phy_packetsize_bytes,170)) self.src = blocks.message_strobe(data_in,100) self.snk = blocks.message_debug() self.tb.msg_connect(self.src, "strobe", self.fragmentation, "in") self.tb.msg_connect(self.fragmentation, "out", self.phr_prefixer, "in") self.tb.msg_connect(self.phr_prefixer, "out", self.zeropadding, "in") self.tb.connect(self.zeropadding, self.demux) self.tb.connect((self.demux,0), self.codeword_mapper_I, self.interleaver_I, self.preamble_sfd_prefixer_I, (self.qpsk_mapper,0)) self.tb.connect((self.demux,1), self.codeword_mapper_Q, self.interleaver_Q, self.preamble_sfd_prefixer_Q, (self.qpsk_mapper,1)) self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper) self.tb.connect((self.qpsk_demapper,0), self.preamble_sfd_removal_I, self.deinterleaver_I, self.codeword_demapper_I, (self.mux,0)) self.tb.connect((self.qpsk_demapper,1), self.preamble_sfd_removal_Q, self.deinterleaver_Q, self.codeword_demapper_Q, (self.mux,1)) self.tb.connect(self.mux, self.zeropadding_removal) self.tb.msg_connect(self.zeropadding_removal, "out", self.phr_removal, "in") self.tb.msg_connect(self.phr_removal, "out", self.snk, "store") self.tb.start() time.sleep(0.3) self.tb.stop() msg_out1 = self.snk.get_message(0) msg_out2 = self.snk.get_message(1) data_out1 = pmt.to_python(msg_out1)[1] data_out2 = pmt.to_python(msg_out2)[1] ref = pmt.to_python(data_in)[1] self.assertTrue((data_out1==ref[:len(data_out1)]).all() and (data_out2==ref[:len(data_out2)]).all())
def __init__(self): gr.top_block.__init__(self, "Strobe") ################################################## # Blocks ################################################## self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu( blocks.byte_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream( blocks.byte_t, "packet_len") self.blocks_message_strobe_0_0 = blocks.message_strobe( pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(64, 0)), 750) self.blocks_message_strobe_0 = blocks.message_strobe( pmt.intern("TEST"), 1000) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_copy_0 = blocks.copy(gr.sizeof_char * 1) self.blocks_copy_0.set_enabled(True) ################################################## # Connections ################################################## self.connect((self.blocks_copy_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_copy_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_message_debug_0, "print") self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print_pdu")
def _byteList_to_pmtvector(self, byteList): length = len(byteList) vector = pmt.make_u8vector(length, 0) byteIterator = iter(range(length)) for byte in byteIterator: pmt.u8vector_set(vector, byte, byteList[byte]) return vector
def get_pmt_from_data_str(self, msg_str): send_pmt = pmt.make_u8vector(len(msg_str), ord(' ')) for i in range(len(msg_str)): pmt.u8vector_set(send_pmt, i, ord(msg_str[i])) send_pmt = pmt.cons(pmt.PMT_NIL, send_pmt) return send_pmt
def post_message(self, msg): """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do sanitization msg = filter(lambda x: x in string.printable, msg) send_msg = "[{}] {}".format(self.prefix, msg) # Prepend AC to send packet if self.access_code: (packet_access_code, padded ) = digital.packet_utils.conv_1_0_string_to_packed_binary_string( self.access_code) print self.access_code print map(ord, packet_access_code) print padded send_msg = packet_access_code + send_msg # Create an empty PMT send_pmt = pmt.make_u8vector(len(send_msg), ord(' ')) # Copy all characters to the vetor for i in range(len(send_msg)): pmt.u8vector_set(send_pmt, i, ord(send_msg[i])) # Send message self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def send_packet(self, data, max_tu, fft_len, data_precision): fft_data = np.fromstring(data, np.float32) if data_precision: #fft_data = fft_data.astype(np.float16, copy=False) fragments = int(math.ceil(fft_len * 4 / float(max_tu))) else: fft_data = fft_data.astype(np.int8, copy=False) fragments = int(math.ceil(fft_len / float(max_tu))) data = fft_data.tostring() j = 0 for i in range(fragments): n_frags = struct.pack('!B', fragments) #1 byte for number of fragments frag_id = struct.pack('!B', i) #1 byte for fragment number frag = data[j:j + max_tu] if i == fragments - 1: frag = data[j:] frame = n_frags + frag_id + frag #construct frame data_pmt = pmt.make_u8vector(len(frame), ord(' ')) # Copy all characters to the u8vector: for i in range(len(frame)): pmt.u8vector_set(data_pmt, i, ord(frame[i])) self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, data_pmt)) j += max_tu
def vector_from_str(value_str): send_pmt = pmt.make_u8vector(len(value_str), ord(' ')) for i in range(len(value_str)): pmt.u8vector_set(send_pmt, i, ord(value_str[i])) return send_pmt
def post_message(self, msg_str): """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do string sanitization: #msg_str = filter(lambda x: x in string.printable, msg_str) #send_str = "[{}] {}".format(self.prefix, msg_str) send_str = msg_str # prepend AC to sent packet if self.access_code: (packed_access_code, padded) = digital.packet_utils.conv_1_0_string_to_packed_binary_string(self.access_code) print self.access_code print map(ord, packed_access_code) print padded send_str = packed_access_code + send_str if self.AESkey: send_str = self.crypter.encrypt(send_str) #print len(send_str) # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def post_message(self, msg_str): """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do string sanitization: #msg_str = filter(lambda x: x in string.printable, msg_str) #send_str = "[{}] {}".format(self.prefix, msg_str) send_str = msg_str # prepend AC to sent packet if self.access_code: (packed_access_code, padded ) = digital.packet_utils.conv_1_0_string_to_packed_binary_string( self.access_code) print self.access_code print map(ord, packed_access_code) print padded send_str = packed_access_code + send_str if self.AESkey: send_str = self.crypter.encrypt(send_str) #print len(send_str) # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
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 deframe_APDU(self, msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt #print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) #print "is pair" else: print "Formato desconocido" return data_np = pmt.to_python(blob) #numpy.ndarray data_py = data_np.tolist() #python list #print "Paquete",data_py,data_py.__class__ if data_py[2:4] == [0xFF, 0xFF]: index = 16 else: index = 24 del data_py[: index] # FC(2),Dst_Add(2),Src_Add(2),Radio(1),Sec_N(1),X->Dst_IEEE(8), Src_IEEE(8) #print "DEPACKED-->",data_py # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(' ')) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def make_MPDU(self, msg_pmt): if pmt.is_blob(msg_pmt): blob = msg_pmt # print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) # print "is pair" else: print "Formato desconocido" return # Toma Pmt pair a numpyarray y luego a list data_np = pmt.to_python(blob) # numpy.ndarray npdu = data_np.tolist() # python list Src_Add = self.SrcAddM # Dir 16 bit id de la red Dst_Add = [0xFF, 0xFF] # Coordinador 00 00 / #broadcast FF FF Pan_Id = self.PanId # PanID que estabece el coordinador LSB -MSB global Seq_M Seq_M[0] = Seq_M[0] + 1 if Seq_M[0] > 254: Seq_M[0] = 0 FC_M = [0x41, 0x88] # Frame control Mac LSB-MSB to_fcs = FC_M + Seq_M + Pan_Id + Dst_Add + Src_Add + npdu s_to_fcs = struct.pack("B" * len(to_fcs), *to_fcs) # Convierte List a String a = self.crc16(s_to_fcs) # Calcula FCS FCS = [a & 0xFF, (a >> 8) & 0xFF] MPDU = FC_M + Seq_M + Pan_Id + Dst_Add + Src_Add + npdu + FCS send_pmt = pmt.make_u8vector(len(MPDU), ord(" ")) # Crea PMT vacio for i in range(len(MPDU)): pmt.u8vector_set(send_pmt, i, MPDU[i]) # Copia Caracteres a u8vector: # Envia mensaje: self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, send_pmt))
def post_message(self, msg_str, meta=None): if self.prefix is not None: send_str = "[{}] {}".format(self.prefix, msg_str) else: send_str = msg_str # prepend AC to sent packet if self.access_code: (packed_access_code, padded ) = digital.packet_utils.conv_1_0_string_to_packed_binary_string( self.access_code) print self.access_code print map(ord, packed_access_code) print padded send_str = packed_access_code + send_str # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) # Send the message: if meta is not None: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.to_pmt(meta), send_pmt)) else: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def str_to_pdu(meta, msg): vector = map(ord, msg) data = pmt.make_u8vector(len(vector), 0) for k in range(0, len(vector)): pmt.u8vector_set(data, k, vector[k]) pdu = pmt.cons(pmt.make_dict(), data) return pdu
def post(self, message_str): """ Post a message for tx """ vect = pmt.make_u8vector(max(len(message_str), self.min_tx_len), ord(' ')) for i in range(len(message_str)): pmt.u8vector_set(vect, i, ord(message_str[i])) meta = pmt.PMT_NIL msg = pmt.cons(meta, vect) self.blocks_pdu_to_tagged_stream_0.to_basic_block()._post(self.pdu_port, msg)
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_000(self): # Just run some data through and make sure it doesn't puke. src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = pdu.pdu_to_tagged_stream(gr.types.byte_t) snk3 = pdu.tagged_stream_to_pdu(gr.types.byte_t) snk2 = blocks.vector_sink_b() snk = blocks.tag_debug(1, "test") snk.set_display(False) dbg = blocks.message_debug() # Test that the right number of ports exist. pi = snk3.message_ports_in() po = snk3.message_ports_out() # system port is defined automatically self.assertEqual(pmt.length(pi), 1) self.assertEqual(pmt.length(po), 1) self.tb.connect(src, snk) self.tb.connect(src, snk2) self.tb.connect(src, snk3) self.tb.msg_connect(snk3, "pdus", dbg, "store") # make our reference and message pmts port = pmt.intern("pdus") msg = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message src.to_basic_block()._post(port, msg) src.to_basic_block()._post( pmt.intern("system"), pmt.cons(pmt.intern("done"), pmt.from_long(1))) self.tb.start() self.tb.wait() # Get the vector of data from the vector sink result_data = snk2.data() # Get the vector of data from the message sink # Convert the message PMT as a pair into its vector result_msg = dbg.get_message(0) msg_vec = pmt.cdr(result_msg) # pmt.print(msg_vec) # Convert the PMT vector into a Python list msg_data = [] for i in range(16): msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16 * [ 0xFF, ] self.assertEqual(actual_data, list(result_data)) self.assertEqual(actual_data, msg_data)
def generate_ack_packet_pdu(self, seq_num): packet_str = chr(seq_num) packet_str += chr(self.PACKET_TYPE_ACK) packet_str += 'aaa' send_pmt = pmt.make_u8vector(len(packet_str), ord(' ')) for i in range(len(packet_str)): pmt.u8vector_set(send_pmt, i, ord(packet_str[i])) return pmt.cons(pmt.PMT_NIL, send_pmt)
def _packetToPDU(self): self.message_port_pub(pmt.intern('rmsg'), pmt.intern('paring packet')) if (len(self._packet)%self._size == 0): numberOfBytes = int(round(len(self._packet)/self._size)) stream = pmt.make_u8vector(numberOfBytes,0) for by in range(numberOfBytes): element = int(self._packet[by*self._size:(by+1)*self._size],2) pmt.u8vector_set(stream, by, element) pdu = pmt.cons(pmt.make_dict(),stream) self.message_port_pub(pmt.intern('rmsg'),pmt.intern('sending pdu')) self.message_port_pub(pmt.intern("PDUout"), pdu)
def test_000(self): # Just run some data through and make sure it doesn't puke. src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = blocks.pdu_to_tagged_stream(blocks.byte_t) snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t) snk2 = blocks.vector_sink_b() snk = blocks.tag_debug(1, "test") snk.set_display(False) dbg = blocks.message_debug() # Test that the right number of ports exist. pi = snk3.message_ports_in() po = snk3.message_ports_out() self.assertEqual(pmt.length(pi), 0) self.assertEqual(pmt.length(po), 1) self.tb.connect(src, snk) self.tb.connect(src, snk2) self.tb.connect(src, snk3) self.tb.msg_connect(snk3, "pdus", dbg, "store") self.tb.start() # make our reference and message pmts port = pmt.intern("pdus") msg = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF)) # post the message src.to_basic_block()._post(port, msg) # eww, what's that smell? while dbg.num_messages() < 1: time.sleep(0.1) self.tb.stop() self.tb.wait() # Get the vector of data from the vector sink result_data = snk2.data() # Get the vector of data from the message sink # Convert the message PMT as a pair into its vector result_msg = dbg.get_message(0) msg_vec = pmt.cdr(result_msg) #pmt.print(msg_vec) # Convert the PMT vector into a Python list msg_data = [] for i in xrange(16): msg_data.append(pmt.u8vector_ref(msg_vec, i)) actual_data = 16*[0xFF,] self.assertEqual(actual_data, list(result_data)) self.assertEqual(actual_data, msg_data)
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 deframe_NPDU(self, msg_pmt): global pack_err global pack_tot global PER # veficcación del formato PMT if pmt.is_blob(msg_pmt): blob = msg_pmt #print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) #print "is pair" else: print "Formato desconocido" return data_len = pmt.blob_length(blob) if (data_len < 11): print "MAC: muy corta!" pack_err = pack_err + 1.0 return data_np = pmt.to_python(blob) #numpy.ndarray data_py = data_np.tolist() #python list #print "Paquete",data_py,data_py.__class__ #print "Dir Gateway",self.SrcAddR," Dir Nodo",data_py[7:9] if len(set(self.SrcAddR).intersection( data_py)) < 2: #Validación TX de la misma dirección # Valodacion FCS y cuenta PER rec_FCS = [data_py[-2], data_py[-1]] #FCS recibido del data_py[-2], data_py[-1] #quita FCS s_to_fcs = struct.pack('B' * len(data_py), *data_py) # Convierte List a String a = self.crc16(s_to_fcs) #Calcula FCS FCS = [a & 0xFF, (a >> 8) & 0xFF] if FCS == rec_FCS: # paquete correcto index = 9 del data_py[: index] # FC(2),Sec_N(1),PanID(2),Dst_Add(2),Src_Add(2) # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(' ')) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt)) else: pack_err = pack_err + 1.0 pack_tot = pack_tot + 1.0 PER = pack_err / pack_tot * 100.0 print ",", pack_tot, ",", pack_err, ",", PER, "%"
def send_string_message(self, msg_str): """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do string sanitization: msg_str = filter(lambda x: x in string.printable, msg_str) send_str = "[{}] {}".format(self.prefix, msg_str) # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def post_message(self, msg_str): send_str = (lowFreqMessage(1, 0, 0, 0, 0, 4, BitArray("0b10000000"), BitArray("0b10000000"), 0, 0, 0, 0, BROADCAST_ADDRESS, msg_str).bin) 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])) while 1: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.make_dict(), send_pmt)) time.sleep(self.msg_per)
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 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 deframe_NPDU(self,msg_pmt): global pack_err global pack_tot global PER # veficcación del formato PMT if pmt.is_blob(msg_pmt): blob = msg_pmt #print "is blob" elif pmt.is_pair(msg_pmt): blob = pmt.cdr(msg_pmt) #print "is pair" else: print "Formato desconocido" return data_len = pmt.blob_length(blob) if(data_len < 11): print "MAC: muy corta!" pack_err = pack_err+1.0 return; data_np = pmt.to_python(blob) #numpy.ndarray data_py = data_np.tolist() #python list #print "Paquete",data_py,data_py.__class__ #print "Dir Gateway",self.SrcAddR," Dir Nodo",data_py[7:9] if len(set(self.SrcAddR).intersection(data_py)) < 2 : #Validación TX de la misma dirección # Valodacion FCS y cuenta PER rec_FCS = [data_py[-2],data_py[-1]] #FCS recibido del data_py[-2],data_py[-1] #quita FCS s_to_fcs = struct.pack('B'*len(data_py), *data_py) # Convierte List a String a = self.crc16(s_to_fcs) #Calcula FCS FCS= [a & 0xFF,(a>>8)&0xFF] if FCS == rec_FCS: # paquete correcto index = 9 del data_py[:index] # FC(2),Sec_N(1),PanID(2),Dst_Add(2),Src_Add(2) # Crea un PMT vacio: send_pmt = pmt.make_u8vector(len(data_py), ord(' ')) # Copy all characters to the u8vector: for i in range(len(data_py)): pmt.u8vector_set(send_pmt, i, data_py[i]) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt)) else: pack_err = pack_err+1.0 pack_tot = pack_tot +1.0 PER =pack_err/pack_tot*100.0 print ",",pack_tot,",",pack_err,",",PER,"%"
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)]) num_mtus = (len(msg_str) // self.max_mtu_size) if len(msg_str) % self.max_mtu_size != 0: num_mtus = num_mtus + 1 #Fragment packet? mtu_index_start = 0 mtu_index_end = 0 last = False frag = False frag_index = 0 if num_mtus > 1: frag = True; for i in range(num_mtus): if (len(msg_str) - mtu_index_start) > self.max_mtu_size: mtu_index_end = mtu_index_start + self.max_mtu_size else: mtu_index_end = len(msg_str) last = True fragment_str = msg_str[mtu_index_start:mtu_index_end] packet = self.build_packet(fragment_str, frag, last, i) mtu_index_start += self.max_mtu_size # 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 msg_to_pdu(msg_str, debug=False): '''Inserts string message into a PDU. @param msg: a string to insert as content of the PDU. @param debug: print additional information, default False. @return: a PDU, a pair (metadata, content) in PMT data types; metadata is None. ''' # create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(msg_str), ord(' ')) # copy all characters to the u8vector: for i in range(len(msg_str)): pmt.u8vector_set(send_pmt, i, ord(msg_str[i])) if debug: mutex_prt('[PMT message]') mutex_prt(send_pmt) pdu = pmt.cons(pmt.PMT_NIL, send_pmt) return pdu
def test_packet_format_async_default(self): ac = packet_utils.default_access_code hdr_format = digital.header_format_default(ac, 0) 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 = b"Hello World" send_pmt = pmt.make_u8vector(len(send_str), 0) for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, 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 = bytes(result_hdr) payload = bytes(result_pld) access_code = packet_utils.default_access_code_binary rx_access_code = header[0:len(access_code)] length = len(send_str) rx_length = struct.unpack_from(b"!H", header, len(access_code))[0] self.assertEqual(access_code, rx_access_code) self.assertEqual(length, rx_length) self.assertEqual(length, len(payload)) self.assertEqual(send_str, payload[0:length])
def test_010_t(self): # PHR prefixer to removal data_in = pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(2 * self.c.phy_packetsize_bytes, 170)) self.src = blocks.message_strobe(data_in, 100) self.snk = blocks.message_debug() self.tb.msg_connect(self.src, "strobe", self.fragmentation, "in") self.tb.msg_connect(self.fragmentation, "out", self.phr_prefixer, "in") self.tb.msg_connect(self.phr_prefixer, "out", self.zeropadding, "in") self.tb.connect(self.zeropadding, self.demux) self.tb.connect((self.demux, 0), self.codeword_mapper_I, self.interleaver_I, self.preamble_sfd_prefixer_I, (self.qpsk_mapper, 0)) self.tb.connect((self.demux, 1), self.codeword_mapper_Q, self.interleaver_Q, self.preamble_sfd_prefixer_Q, (self.qpsk_mapper, 1)) self.tb.connect(self.qpsk_mapper, self.dqpsk_mapper, self.dqcsk_mapper, self.dqcsk_demapper, self.dqpsk_demapper, self.qpsk_demapper) self.tb.connect((self.qpsk_demapper, 0), self.preamble_sfd_removal_I, self.deinterleaver_I, self.codeword_demapper_I, (self.mux, 0)) self.tb.connect((self.qpsk_demapper, 1), self.preamble_sfd_removal_Q, self.deinterleaver_Q, self.codeword_demapper_Q, (self.mux, 1)) self.tb.connect(self.mux, self.zeropadding_removal) self.tb.msg_connect(self.zeropadding_removal, "out", self.phr_removal, "in") self.tb.msg_connect(self.phr_removal, "out", self.snk, "store") self.tb.start() time.sleep(0.3) self.tb.stop() msg_out1 = self.snk.get_message(0) msg_out2 = self.snk.get_message(1) data_out1 = pmt.to_python(msg_out1)[1] data_out2 = pmt.to_python(msg_out2)[1] ref = pmt.to_python(data_in)[1] self.assertTrue((data_out1 == ref[:len(data_out1)]).all() and (data_out2 == ref[:len(data_out2)]).all())
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Blocks ################################################## self.crypto_sym_ciph_desc_0 = crypto.sym_ciph_desc( "aes-256-ofb", False, ()) self.crypto_sym_enc_0 = crypto.sym_enc(self.crypto_sym_ciph_desc_0) self.crypto_sym_dec_0 = crypto.sym_dec(self.crypto_sym_ciph_desc_0) self.blocks_message_strobe_0_0 = blocks.message_strobe( pmt.make_u8vector(16, 65), 500) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'), (self.crypto_sym_enc_0, 'pdus')) self.msg_connect((self.crypto_sym_dec_0, 'pdus'), (self.blocks_message_debug_0, 'print')) self.msg_connect((self.crypto_sym_enc_0, 'pdus'), (self.crypto_sym_dec_0, 'pdus'))
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 5000000 ################################################## # Blocks ################################################## self.pir_set_timestamp_2_cm_0 = pir.set_timestamp_2_cm() self.blocks_message_strobe_0 = blocks.message_strobe( pmt.cons(pmt.make_dict(), pmt.make_u8vector(4, 1)), 3000) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.blocks_message_debug_0, 'print_pdu')) self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.pir_set_timestamp_2_cm_0, 'in'))
def nordictap_handler(self, msg): # PMT to byte string data = pmt.to_python(msg).tostring() # Unpack the header values = struct.unpack('BBBBBBBB', data[0:8]) channel = values[0] data_rate = values[1] address_length = values[2] payload_length = values[3] sequence_number = values[4] no_ack = values[5] crc_length = values[6] # Parse the address, payload, and crc address = data[7:7 + address_length] payload = data[7 + address_length:7 + address_length + payload_length] crc = data[7 + address_length + payload_length:7 + address_length + payload_length + crc_length] # ACK if needed if payload_length > 0 and no_ack == 0: # Print the channel, sequence number, address and payload print "ACK'd Packet: ", print 'CH=' + str(2400 + channel), print 'SEQ=' + str(sequence_number), print 'ADDR=' + ':'.join('%02X' % ord(b) for b in address), print 'PLD=' + ':'.join('%02X' % ord(b) for b in payload), print 'CRC=' + ':'.join('%02X' % ord(b) for b in crc) # Build an ACK nordictap = [0] + [4, 2, 5, 0, sequence_number, 0, 2] for c in address: nordictap.append(ord(c)) # Transmit an ACK vec = pmt.make_u8vector(len(nordictap), 0) for x in range(len(nordictap)): pmt.u8vector_set(vec, x, nordictap[x]) self.message_port_pub(pmt.intern("nordictap_out"), vec)
def post_message(self, meta, msg_str): if self.prefix is not None: send_str = "[{}] {}".format(self.prefix, msg_str) else: send_str = msg_str # prepend AC to sent packet if self.access_code: (packed_access_code, padded) = digital.packet_utils.conv_1_0_string_to_packed_binary_string(self.access_code) print self.access_code print map(ord, packed_access_code) print padded send_str = packed_access_code + send_str # Create an empty PMT (contains only spaces): send_pmt = pmt.make_u8vector(len(send_str), ord(' ')) # Copy all characters to the u8vector: for i in range(len(send_str)): pmt.u8vector_set(send_pmt, i, ord(send_str[i])) # Send the message: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.to_pmt(meta), send_pmt))
def work(self, input_items, output_items): for i in input_items[0]: #print i if i == 0: i = 1 else: i = 0 if i == 0: self.nz += 1 if self.nz == 2: if self.rev_varicodes.has_key(self.curr): c = self.rev_varicodes[self.curr] self.out_string += c sys.stdout.write(c) if c == "\n": print "sent pdu" payload = pmt.make_u8vector(len(self.out_string), 0) j = 0 for a in self.out_string: pmt.u8vector_set(payload, j, ord(a)) j += 1 self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, payload)) self.out_string = "" self.nz = 0 self.curr = "" sys.stdout.flush() elif i == 1: if self.nz == 1 and self.curr != "": self.curr += "0" self.curr += "1" self.nz = 0 return len(input_items[0])
def make_APDU(self,msg_pmt): # Toma Pmt Symbol a String y luego a list msg_pmt = pmt.symbol_to_string(msg_pmt) msg = [ord(c) for c in msg_pmt] global count_app count_app[0] = count_app[0] +1 if count_app[0] > 254: count_app[0] = 0 Src_EP = [0xE8] # Source endpoint Profile = [0x05,0xC1] # Profile ID LSB-MSB Cluster = [0x11,0x00] # Cluster ID LSB-MSB Dst_EP = [0xE8] # Destination endpoint FC_A = [0x08] # Frame Control APP APDU = FC_A + Dst_EP + Cluster + Profile + Src_EP + count_app + msg # Crea PMT vacio send_pmt = pmt.make_u8vector(len(APDU), ord(' ')) # Copia Caracteres a u8vector: for i in range(len(APDU)): pmt.u8vector_set(send_pmt, i, APDU[i]) # Envia mensaje: self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def handle_app_message(self, msg_pmt): with self.thread_lock: packets_str = self.fragment_packet(msg_pmt) for packet_str in packets_str: packet_str_total = chr(self.tx_seq_num) if self.tx_seq_num < 255: self.tx_seq_num = self.tx_seq_num + 1 else: self.tx_seq_num = 0 packet_str_total += chr(self.PACKET_TYPE_DATA) packet_str_total += packet_str send_pmt = pmt.make_u8vector(len(packet_str_total), ord(' ')) for i in range(len(packet_str_total)): pmt.u8vector_set(send_pmt, i, ord(packet_str_total[i])) send_pmt = pmt.cons(pmt.PMT_NIL, send_pmt) self.app_queue.put(send_pmt) self.handle_queue()
def process_fragment(self, packet_str): frag_byte = ord(packet_str[0]) frag_index = frag_byte >> 2 if frag_byte & 0x01 == 1 : self.last_frag_index = frag_index if frag_byte & 0x02 == 0 : self.wait_for_frag = True self.packet_buffer += packet_str[1:] return else: self.wait_for_frag = False self.packet_buffer += packet_str[1:] packet_str = self.packet_buffer self.packet_buffer = '' else: packet_str = packet_str[1:] self.wait_for_frag = False if not self.wait_for_frag: send_pmt = pmt.make_u8vector(len(packet_str), ord(' ')) for i in range(len(packet_str)): pmt.u8vector_set(send_pmt, i, ord(packet_str[i])) self.message_port_pub(pmt.intern('to_app'), pmt.cons(pmt.PMT_NIL, send_pmt))
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Blocks ################################################## self.crypto_sym_ciph_desc_0 = crypto.sym_ciph_desc("aes-256-ofb", False, ()) self.crypto_sym_enc_0 = crypto.sym_enc(self.crypto_sym_ciph_desc_0) self.crypto_sym_dec_0 = crypto.sym_dec(self.crypto_sym_ciph_desc_0) self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.make_u8vector(16,65), 500) self.blocks_message_debug_0 = blocks.message_debug() ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0_0, 'strobe'), (self.crypto_sym_enc_0, 'pdus')) self.msg_connect((self.crypto_sym_dec_0, 'pdus'), (self.blocks_message_debug_0, 'print')) self.msg_connect((self.crypto_sym_enc_0, 'pdus'), (self.crypto_sym_dec_0, 'pdus'))
def post_message(self, msg): """ Take a string, remove all non-printable characters, prepend the prefix and post to the next block. """ # Do sanitization msg = filter(lambda x: x in string.printable, msg) send_msg = "[{}] {}".format(self.prefix, msg) # Prepend AC to send packet if self.access_code: (packet_access_code, padded) = digital.packet_utils.conv_1_0_string_to_packed_binary_string(self.access_code) print self.access_code print map(ord, packet_access_code) print padded send_msg = packet_access_code + send_msg # Create an empty PMT send_pmt = pmt.make_u8vector(len(send_msg), ord(' ')) # Copy all characters to the vetor for i in range(len(send_msg)): pmt.u8vector_set(send_pmt, i, ord(send_msg[i])) # Send message self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, send_pmt))
def __init__(self): gr.top_block.__init__(self, "Ofdm Tx") Qt.QWidget.__init__(self) self.setWindowTitle("Ofdm Tx") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "ofdm_tx") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 1e6 self.packet_len = packet_len = 100 self.len_tag_key = len_tag_key = "packet_len" self.gain = gain = 60 self.fft_len = fft_len = 128 ################################################## # Blocks ################################################## self._gain_layout = Qt.QVBoxLayout() self._gain_tool_bar = Qt.QToolBar(self) self._gain_layout.addWidget(self._gain_tool_bar) self._gain_tool_bar.addWidget(Qt.QLabel("gain"+": ")) class qwt_counter_pyslot(Qwt.QwtCounter): def __init__(self, parent=None): Qwt.QwtCounter.__init__(self, parent) @pyqtSlot('double') def setValue(self, value): super(Qwt.QwtCounter, self).setValue(value) self._gain_counter = qwt_counter_pyslot() self._gain_counter.setRange(0, 90, 1) self._gain_counter.setNumButtons(2) self._gain_counter.setValue(self.gain) self._gain_tool_bar.addWidget(self._gain_counter) self._gain_counter.valueChanged.connect(self.set_gain) self._gain_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot) self._gain_slider.setRange(0, 90, 1) self._gain_slider.setValue(self.gain) self._gain_slider.setMinimumWidth(200) self._gain_slider.valueChanged.connect(self.set_gain) self._gain_layout.addWidget(self._gain_slider) self.top_layout.addLayout(self._gain_layout) self.uhd_usrp_sink_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_subdev_spec("A:A", 0) self.uhd_usrp_sink_0.set_samp_rate(samp_rate) self.uhd_usrp_sink_0.set_center_freq(400e6, 0) self.uhd_usrp_sink_0.set_gain(gain, 0) self.rational_resampler_xxx_0 = filter.rational_resampler_ccc( interpolation=2, decimation=1, taps=None, fractional_bw=None, ) self.fosdem_burst_marker_0 = fosdem.burst_marker(gr.sizeof_gr_complex, len_tag_key, 0) self.digital_ofdm_tx_0 = digital.ofdm_tx( fft_len=fft_len, cp_len=fft_len/4, packet_length_tag_key=len_tag_key, bps_header=1, bps_payload=2, rolloff=0, debug_log=False, scramble_bits=True ) self.blocks_tagged_stream_multiply_length_0 = blocks.tagged_stream_multiply_length(gr.sizeof_gr_complex*1, len_tag_key, 2) self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((0.05, )) self.blocks_message_strobe_0 = blocks.message_strobe(pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(packet_len, 0xAA)), 1000) ################################################## # Connections ################################################## self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_tagged_stream_multiply_length_0, 0)) self.connect((self.digital_ofdm_tx_0, 0), (self.rational_resampler_xxx_0, 0)) self.connect((self.rational_resampler_xxx_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.digital_ofdm_tx_0, 0)) self.connect((self.blocks_tagged_stream_multiply_length_0, 0), (self.fosdem_burst_marker_0, 0)) self.connect((self.fosdem_burst_marker_0, 0), (self.uhd_usrp_sink_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus")
def set_packet_len(self, packet_len): self.packet_len = packet_len self.blocks_message_strobe_0.set_msg(pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(self.packet_len, 0xAA)))
def __init__(self): gr.top_block.__init__(self, "Strobe") ################################################## # Blocks ################################################## self.blocks_tagged_stream_to_pdu_0 = blocks.tagged_stream_to_pdu(blocks.byte_t, "packet_len") self.blocks_pdu_to_tagged_stream_0 = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len") self.blocks_message_strobe_0_0 = blocks.message_strobe(pmt.cons( pmt.PMT_NIL, pmt.make_u8vector(64,0) ), 750) self.blocks_message_strobe_0 = blocks.message_strobe(pmt.intern("TEST"), 1000) self.blocks_message_debug_0 = blocks.message_debug() self.blocks_copy_0 = blocks.copy(gr.sizeof_char*1) self.blocks_copy_0.set_enabled(True) ################################################## # Connections ################################################## self.connect((self.blocks_copy_0, 0), (self.blocks_tagged_stream_to_pdu_0, 0)) self.connect((self.blocks_pdu_to_tagged_stream_0, 0), (self.blocks_copy_0, 0)) ################################################## # Asynch Message Connections ################################################## self.msg_connect(self.blocks_message_strobe_0, "strobe", self.blocks_message_debug_0, "print") self.msg_connect(self.blocks_message_strobe_0_0, "strobe", self.blocks_pdu_to_tagged_stream_0, "pdus") self.msg_connect(self.blocks_tagged_stream_to_pdu_0, "pdus", self.blocks_message_debug_0, "print_pdu")