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 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_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 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")
