def make_packet(payload, samples_per_symbol, bits_per_symbol,
preamble, access_code,
pad_for_usrp=True, do_whitening=False, add_crc=False):
"""
Build a packet
Args:
payload: packet payload, len [0, 4096]
samples_per_symbol: samples per symbol (needed for padding calculation) (int)
bits_per_symbol: (needed for padding calculation) (int)
preamble: (eg: 10101010...)
access_code: the sync word
pad_for_usrp:
do_whitening: ccxxxx whitening version
add_crc: add CRC16 (2 bytes) checksum
Packet will have access code at the beginning, followed by length (1 byte), payload
and finally CRC-16.
"""
if not packet_utils.is_1_0_string(preamble):
raise ValueError, "preamble must be a string containing only 0's and 1's (%r)" % (preamble,)
if not packet_utils.is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
(packed_access_code, padded) = packet_utils.conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble, ignore) = packet_utils.conv_1_0_string_to_packed_binary_string(preamble)
# len
payload_length = len(payload)
# header (1 byte)
pkt_hd = make_header(payload_length)
# data
pkt_dt = payload
# final message
final_message = ''.join((pkt_hd, pkt_dt))
# CRC ?
if add_crc:
crc = crc16(final_message)
#print "crc: %02x %02x" % (ord(crc[0:1]), ord(crc[1:2]))
final_message = ''.join((final_message, crc))
# Whitening ?
pkt = ''
if do_whitening:
pkt = ''.join((packed_preamble, packed_access_code, whiten(final_message), '\x55'))
else:
pkt = ''.join((packed_preamble, packed_access_code, final_message, '\x55'))
# Padding ?
if pad_for_usrp:
usrp_packing = packet_utils._npadding_bytes(len(pkt), samples_per_symbol, bits_per_symbol) * '\x55'
pkt = pkt + usrp_packing
return pkt
def repeat_decode(payload, repeat):
bits = []
for p in [payload[i:i + repeat] for i in range(0, len(payload), repeat)]:
bitstring = conv_packed_binary_string_to_1_0_string(p)
for bit in range(8):
positions = [i+bit for i in range(0, len(bitstring), 8)]
repeated_bits = map(lambda pos: int(bitstring[pos]), positions)
bits += [str(int(round(sum(repeated_bits) / float(repeat))))]
return conv_1_0_string_to_packed_binary_string(''.join(bits))[0]
def test_packet_format_async_counter(self):
bps = 2
ac = packet_utils.default_access_code
hdr_format = digital.header_format_counter(ac, 0, 2)
formatter = digital.protocol_formatter_async(hdr_format)
snk_hdr = blocks.message_debug()
snk_pld = blocks.message_debug()
self.tb.msg_connect(formatter, 'header', snk_hdr, 'store')
self.tb.msg_connect(formatter, 'payload', snk_pld, 'store')
send_str = "Hello World" + 1000 * "xxx"
send_pmt = pmt.make_u8vector(len(send_str), ord(' '))
for i in range(len(send_str)):
pmt.u8vector_set(send_pmt, i, ord(send_str[i]))
msg = pmt.cons(pmt.PMT_NIL, send_pmt)
port = pmt.intern("in")
formatter.to_basic_block()._post(port, msg)
self.tb.start()
while (snk_hdr.num_messages() < 1) or (snk_pld.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_hdr_pmt = pmt.cdr(snk_hdr.get_message(0))
result_pld_pmt = pmt.cdr(snk_pld.get_message(0))
result_hdr = pmt.u8vector_elements(result_hdr_pmt)
result_pld = pmt.u8vector_elements(result_pld_pmt)
header = "".join(chr(r) for r in result_hdr)
payload = "".join(chr(r) for r in result_pld)
access_code = packet_utils.conv_1_0_string_to_packed_binary_string(
packet_utils.default_access_code)[0]
rx_access_code = header[0:len(access_code)]
length = len(send_str)
rx_length = struct.unpack_from(b"!H", six.b(header),
len(access_code))[0]
rx_bps = struct.unpack_from(b"!H", six.b(header),
len(access_code) + 4)[0]
rx_counter = struct.unpack_from(b"!H", six.b(header),
len(access_code) + 6)[0]
self.assertEqual(access_code, rx_access_code)
self.assertEqual(length, rx_length)
self.assertEqual(bps, rx_bps)
self.assertEqual(0, rx_counter)
self.assertEqual(length, len(payload))
self.assertEqual(send_str, payload[0:length])
def test_packet_format_async_counter(self):
bps = 2
ac = packet_utils.default_access_code
hdr_format = digital.header_format_counter(ac, 0, 2)
formatter = digital.protocol_formatter_async(hdr_format)
snk_hdr = blocks.message_debug()
snk_pld = blocks.message_debug()
self.tb.msg_connect(formatter, 'header', snk_hdr, 'store')
self.tb.msg_connect(formatter, 'payload', snk_pld, 'store')
send_str = "Hello World" + 1000*"xxx"
send_pmt = pmt.make_u8vector(len(send_str), ord(' '))
for i in range(len(send_str)):
pmt.u8vector_set(send_pmt, i, ord(send_str[i]))
msg = pmt.cons(pmt.PMT_NIL, send_pmt)
port = pmt.intern("in")
formatter.to_basic_block()._post(port, msg)
self.tb.start()
while (snk_hdr.num_messages() < 1) and (snk_pld.num_messages() < 1):
time.sleep(0.1)
self.tb.stop()
self.tb.wait()
result_hdr_pmt = pmt.cdr(snk_hdr.get_message(0))
result_pld_pmt = pmt.cdr(snk_pld.get_message(0))
result_hdr = pmt.u8vector_elements(result_hdr_pmt)
result_pld = pmt.u8vector_elements(result_pld_pmt)
header = "".join([chr(r) for r in result_hdr])
payload = "".join([chr(r) for r in result_pld])
access_code = packet_utils.conv_1_0_string_to_packed_binary_string(packet_utils.default_access_code)[0]
rx_access_code = header[0:len(access_code)]
length = len(send_str)
rx_length = struct.unpack_from("!H", header, len(access_code))[0]
rx_bps = struct.unpack_from("!H", header, len(access_code)+4)[0]
rx_counter = struct.unpack_from("!H", header, len(access_code)+6)[0]
self.assertEqual(access_code, rx_access_code)
self.assertEqual(length, rx_length)
self.assertEqual(bps, rx_bps)
self.assertEqual(0, rx_counter)
self.assertEqual(length, len(payload))
self.assertEqual(send_str, payload[0:length])