def handle_msg(self, msg_pmt): msg = pmt.cdr(msg_pmt) if not pmt.is_u8vector(msg): print "[ERROR] Received invalid message type. Expected u8vector" return if pmt.length(msg) + 2 > self.mtu: print "[ERROR] Transmitted frame is too long (%d bytes). Cannot exceed %d bytes." % (pmt.length(msg), self.mtu - 2) return #length = struct.pack('h', pmt.length(msg)) #print length, pmt.length(msg) buff = list() #buff.extend([x for x in length]) #buff.extend(pmt.u8vector_elements(msg)) length = pmt.length(msg) buff.append(length >> 8) # MSB buff.append(length & 0xFF) # LSB buff.extend(pmt.u8vector_elements(msg)) pad_length = self.mtu - len(buff) if pad_length: buff.extend([self.pad_byte] * pad_length) if debug: print "Pushing a packet of length %d bytes" % length self.message_port_pub(pmt.intern('out'), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def handle_msg(self, msg_pmt): msg = pmt.cdr(msg_pmt) if not pmt.is_u8vector(msg): print "[ERROR] Received invalid message type. Expected u8vector" return if pmt.length(msg) > self.mtu: print "[ERROR] Received frame is too long (%d bytes). Cannot exceed %d bytes." % ( pmt.length(msg), self.mtu) return #print pmt.u8vector_elements(msg)[0:2] #length = struct.unpack('h', pmt.u8vector_elements(msg)[0:2]) length_bytes = pmt.u8vector_elements(msg)[0:2] length = length_bytes[0] << 8 | length_bytes[1] #print length, pmt.length(msg) if length == 0: # caught a Filler packet, drop it return buff = list() buff.extend(pmt.u8vector_elements(msg)[2:2 + length]) #print buff # TODO: Check for pad byte if there are any #print pmt.length(buff) buff = array.array('B', buff) if debug: print "Received a packet of length %d bytes" % length self.message_port_pub( pmt.intern('out'), pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(len(buff), buff)))
def test_001_t(self): # set up fg test_len = 1024 packet_len = test_len samp_rate = 2000 center_freq = 1e9 velocity = (5, 15, 20) src = radar.signal_generator_cw_c(packet_len, samp_rate, (0, 0), 1) head = blocks.head(8, test_len) sim = radar.static_target_simulator_cc( (10, 10, 10), velocity, (1e12, 1e12, 1e12), (0, 0, 0), (0, ), samp_rate, center_freq, 1, True, False) mult = blocks.multiply_cc() fft = radar.ts_fft_cc(packet_len) cfar = radar.os_cfar_c(samp_rate, 5, 0, 0.78, 10, True) est = radar.estimator_cw(center_freq) res1 = radar.print_results() res2 = radar.print_results() gate = radar.msg_gate(('velocity', 'bla'), (8, 8), (17, 17)) debug1 = blocks.message_debug() debug2 = blocks.message_debug() self.tb.connect(src, head, (mult, 1)) self.tb.connect(head, sim, (mult, 0)) self.tb.connect(mult, fft, cfar) self.tb.msg_connect(cfar, 'Msg out', est, 'Msg in') self.tb.msg_connect(est, 'Msg out', res1, 'Msg in') self.tb.msg_connect(est, 'Msg out', debug1, 'store') self.tb.msg_connect(est, 'Msg out', gate, 'Msg in') self.tb.msg_connect(gate, 'Msg out', debug2, 'store') self.tb.msg_connect(gate, 'Msg out', res2, 'Msg in') self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check data msg1 = debug1.get_message(0) # msg without gate msg2 = debug2.get_message(0) # msg with gate self.assertEqual( "velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth( 1, msg1))))) # check velocity message part (symbol), 1 self.assertEqual( "velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth( 1, msg2))))) # check velocity message part (symbol), 2 self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg1))), 3) # check number of targets without gate self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg2))), 1) # check nubmer of targets with gate self.assertAlmostEqual( 1, velocity[1] / pmt.f32vector_ref(pmt.nth(1, (pmt.nth(1, msg2))), 0), 1) # check velocity value
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 test_001_t(self): # set up fg test_len = 1024 packet_len = test_len samp_rate = 2000 center_freq = 1e9 velocity = (5, 15, 20) src = radar.signal_generator_cw_c(packet_len, samp_rate, (0, 0), 1) head = blocks.head(8, test_len) sim = radar.static_target_simulator_cc( (10, 10, 10), velocity, (1e12, 1e12, 1e12), (0, 0, 0), (0,), samp_rate, center_freq, 1, True, False ) mult = blocks.multiply_cc() fft = radar.ts_fft_cc(packet_len) cfar = radar.os_cfar_c(samp_rate, 5, 0, 0.78, 10, True) est = radar.estimator_cw(center_freq) res1 = radar.print_results() res2 = radar.print_results() gate = radar.msg_gate(("velocity", "bla"), (8, 8), (17, 17)) debug1 = blocks.message_debug() debug2 = blocks.message_debug() self.tb.connect(src, head, (mult, 1)) self.tb.connect(head, sim, (mult, 0)) self.tb.connect(mult, fft, cfar) self.tb.msg_connect(cfar, "Msg out", est, "Msg in") self.tb.msg_connect(est, "Msg out", res1, "Msg in") self.tb.msg_connect(est, "Msg out", debug1, "store") self.tb.msg_connect(est, "Msg out", gate, "Msg in") self.tb.msg_connect(gate, "Msg out", debug2, "store") self.tb.msg_connect(gate, "Msg out", res2, "Msg in") self.tb.start() sleep(0.5) self.tb.stop() self.tb.wait() # check data msg1 = debug1.get_message(0) # msg without gate msg2 = debug2.get_message(0) # msg with gate self.assertEqual( "velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(1, msg1)))) ) # check velocity message part (symbol), 1 self.assertEqual( "velocity", pmt.symbol_to_string(pmt.nth(0, (pmt.nth(1, msg2)))) ) # check velocity message part (symbol), 2 self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg1))), 3) # check number of targets without gate self.assertEqual(pmt.length(pmt.nth(1, pmt.nth(1, msg2))), 1) # check nubmer of targets with gate self.assertAlmostEqual( 1, velocity[1] / pmt.f32vector_ref(pmt.nth(1, (pmt.nth(1, msg2))), 0), 1 ) # check velocity value
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 msg_handler(self, p): length = pmt.length(p) for i in range(0,length): element = pmt.nth(i, p) key = pmt.nth(0, element) value = pmt.nth(1, element) if str(key) == "power": output = pmt.f32vector_elements(value)[0] output = 10 * math.log(output, 10) output = pmt.make_f32vector(1, output) if i==0: outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output)) else: outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output)) output = pmt.nth(1, element) if i==0: outpmt = pmt.list1(pmt.list2(key, output)) else: outpmt = pmt.list_add(outpmt, pmt.list2(key, output)) self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def test_001_t (self): src = analog.sig_source_c(32000, analog.GR_COS_WAVE, 12500, 1) detector = inspector.signal_detector_cvf(32000, 1024, firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.0001) dst1 = blocks.null_sink(gr.sizeof_float*1024) dst2 = blocks.null_sink(gr.sizeof_float*1024) msg_dst = blocks.message_debug() self.tb.connect(src, detector) self.tb.connect((detector, 0), dst1) self.tb.connect((detector, 1), dst2) self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store')) self.tb.start() time.sleep(0.5) self.tb.stop() self.tb.wait() msg = msg_dst.get_message(1) res_vector = numpy.empty([0, 2]) for i in range(pmt.length(msg)): row = pmt.vector_ref(msg, i) res_vector = numpy.vstack((res_vector, numpy.array( [pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)] ))) self.assertAlmostEqual(12500.0, res_vector[0][0], delta=100) self.assertAlmostEqual(0.0, res_vector[0][1], delta=200)
def test_001_t (self): """ Simplest possible test: put in zeros, then header, then payload, trigger signal, try to demux. The return signal from the header parser is faked via _post() Add in some tags for fun. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload trigger_signal = [0,] * len(data_signal) trigger_signal[n_zeros] = 1 # This is dropped: testtag1 = make_tag('tag1', 0, 0) # This goes on output 0, item 0: testtag2 = make_tag('tag2', 23, n_zeros) # This goes on output 0, item 2: testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1) # This goes on output 1, item 3: testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3) data_src = blocks.vector_source_f( data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4) ) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) mock_header_demod = HeaderToMessageBlock( numpy.float32, len(header), [len(payload)] ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you payload_sink = blocks.vector_sink_f() header_sink = blocks.vector_sink_f() self.connect_all_blocks(data_src, trigger_src, hpd, mock_header_demod, payload_sink, header_sink) self.run_tb(payload_sink, len(payload), header_sink, len(header)) self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 2}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 3}, ] self.assertEqual(expected_tags_payload, ptags_payload)
def msg_handler(self, p): length = pmt.length(p) # iterate over all elements for i in range(0, length): element = pmt.nth(i, p) key = pmt.nth(0, element) value = pmt.nth(1, element) initial_phase = None # when we found the phase key if str(key) == "phase" and pmt.length(value) >= 1: # print "length of vector: ", pmt.length(value) value = pmt.f32vector_elements(value)[0] self.last_val = value # save that value initial_phase = value value = value - self.subtract while value < -numpy.pi: value = value + numpy.pi while value > numpy.pi: value = value - numpy.pi initial_phase = pmt.make_f32vector(1, initial_phase) initial_phase = pmt.list2(pmt.string_to_symbol("phase_initial"), initial_phase) outvalue = pmt.make_f32vector(1, value) output = pmt.list2(pmt.string_to_symbol(str(key)), outvalue) else: output = element if i == 0: outpmt = pmt.list1(output) else: outpmt = pmt.list_add(outpmt, output) if initial_phase != None: outpmt = pmt.list_add(outpmt, initial_phase) self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def zmq_msg_payload_to_str(raw_msg): msg = pmt.deserialize_str(raw_msg) cdr = pmt.cdr(msg) packet_len = pmt.length(cdr) cdr_str = pmt.serialize_str(cdr) output_str = cdr_str[-1 * packet_len:] return output_str
def test_001_t_tags(self): """ Like the previous test, but use a trigger tag instead of a trigger signal. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload # Trigger tag trigger_tag = make_tag('detect', True, n_zeros) # This is dropped: testtag1 = make_tag('tag1', 0, 0) # This goes on output 0, item 0: testtag2 = make_tag('tag2', 23, n_zeros) # This goes on output 0, item 2: testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1) # This goes on output 1, item 3: testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3) data_src = blocks.vector_source_f( data_signal, False, tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4) ) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() mock_header_demod = HeaderToMessageBlock( numpy.float32, len(header), [len(payload)] ) self.connect_all_blocks(data_src, None, hpd, mock_header_demod, payload_sink, header_sink) self.run_tb(payload_sink, len(payload), header_sink, len(header)) # Check results self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 2}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 3}, ] self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t_tags (self): """ Like the previous test, but use a trigger tag instead of a trigger signal. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload # Trigger tag trigger_tag = make_tag('detect', True, n_zeros) # This is dropped: testtag1 = make_tag('tag1', 0, 0) # This goes on output 0, item 0: testtag2 = make_tag('tag2', 23, n_zeros) # This goes on output 0, item 2: testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1) # This goes on output 1, item 3: testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3) data_src = blocks.vector_source_f( data_signal, False, tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4) ) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() mock_header_demod = HeaderToMessageBlock( numpy.float32, len(header), [len(payload)] ) self.connect_all_blocks(data_src, None, hpd, mock_header_demod, payload_sink, header_sink) self.run_tb(payload_sink, len(payload), header_sink, len(header)) # Check results self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 2}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 3}, ] self.assertEqual(expected_tags_payload, ptags_payload)
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 map_handler(self, msg): content = pmt.to_python(msg) #type:float length = pmt.length(msg) #list of signals (their freqs and bandwidths) self.freq_list = [] self.bw_list = [] for i in range(0, length): self.freq_list.append(content[i][0]) self.bw_list.append(content[i][1])
def print_msg(self, msg): """ Print the rx'd message. """ meta = pmt.to_python(pmt.car(msg)) vect = pmt.cdr(msg) msg_str = ''.join([ chr(pmt.u8vector_ref(vect, i)) for i in range(pmt.length(vect)) ]).strip() if len(msg_str): print 'Incoming message: ', msg_str print meta
def assert_has_num_subscriptions(self, block, port, number): """assert that the given block has the given number of subscriptions on the given port :param block: a block sptr :param string port: the port name :param number: the number of subscriptions expected """ subs = block.message_subscribers(pmt.intern(port)) self.assertEqual(pmt.length(subs), number)
def map_handler(self, msg): content = pmt.to_python(msg) #type:float length = pmt.length(msg) #update freq/bandwidth information of the signals self.freq_list = [] self.bw_list = [] for i in range(0, length): self.freq_list.append(content[i][0]) self.bw_list.append(content[i][1])
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 zmq_msg_payload_to_bytes(raw_msg): msg = pmt.deserialize_str(raw_msg) cdr = pmt.cdr(msg) packet_len = pmt.length(cdr) cdr_str = pmt.serialize_str(cdr) output_str = cdr_str[-1 * packet_len:] byte_list = list() for i in xrange(len(output_str)): byte_list.append(ord(output_str[i])) return byte_list
def test_003_t (self): """ Like test 1, but twice, plus one fail """ n_zeros = 5 header = (1, 2, 3) header_fail = (-1, -2, -4) # Contents don't really matter payload1 = tuple(range(5, 20)) payload2 = (42,) data_signal = (0,) * n_zeros + header + payload1 trigger_signal = [0,] * len(data_signal) * 2 trigger_signal[n_zeros] = 1 trigger_signal[len(data_signal)] = 1 trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1 tx_signal = data_signal + header_fail + (0,) * n_zeros + header + payload2 + (0,) * 1000 data_src = blocks.vector_source_f(tx_signal, False) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 1) header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload1)) ) while len(payload_sink.data()) < len(payload1): time.sleep(.2) hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.PMT_F ) # This next command is a bit of a showstopper, but there's no condition to check upon # to see if the previous msg handling is finished time.sleep(.7) hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload2)) ) while len(payload_sink.data()) < len(payload1) + len(payload2): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header + header_fail + header) self.assertEqual(payload_sink.data(), payload1 + payload2)
def msg_handler(self, p): if self.filename != "": self.fdout = open(self.filename, "a") length = pmt.length(p) if self.key == "all": #if all keys are printed, they need however be printed once above if self.counter == 0: for i in range(0, length): element = pmt.nth(i, p) current_key = str(pmt.nth(0, element)) self.fdout.write(current_key + ",") self.fdout.write("\n") self.counter=1 #print all for i in range(0, length): element = pmt.nth(i, p) current_key = str(pmt.nth(0, element)) current_value = pmt.nth(1, element) if current_key=="rx_time": number = pmt.to_uint64(pmt.tuple_ref(current_value,0)) + \ pmt.to_double(pmt.tuple_ref(current_value,1)) self.fdout.write(str(number) + ",") else: self.fdout.write(str(pmt.f32vector_elements(current_value)[0]) + ",") else: #print all values that correspond to keys for key in self.key: for i in range(0, length): element = pmt.nth(i, p) current_key = str(pmt.nth(0, element)) current_value = pmt.nth(1, element) if current_key == key: if key=="rx_time": number = pmt.to_uint64(pmt.tuple_ref(current_value,0)) + \ pmt.to_double(pmt.tuple_ref(current_value,1)) self.fdout.write(str(number) + ",") else: self.fdout.write(str(pmt.f32vector_elements(current_value)[0]) + ",") self.fdout.write("\n") self.fdout.close()
def parse_extra_dict(p, info, VERBOSE=False): if(pmt.is_dict(p) is False): sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n") sys.exit(1) items = pmt.dict_items(p) nitems = pmt.length(items) for i in xrange(nitems): item = pmt.nth(i, items) key = pmt.symbol_to_string(pmt.car(item)) val = pmt.cdr(item) info[key] = val if(VERBOSE): print "{0}: {1}".format(key, val) return info
def sched_pdu(self, pdu): sched_time = self.nproduced_val + 10000 # pick a time in the future if sched_time < self.sched_barrier: sched_time = self.sched_barrier print "delaying packet to sched barrier" sched_time = sched_time - sched_time % 1000 # round to nearest slot event_length = pmt.length(pmt.cdr(pdu)) # event_length = pmt.to_long(pmt.dict_ref(pmt.car(pdu), pmt.intern("event_length"), pmt.PMT_NIL)); self.sched_barrier = sched_time + event_length + 1000 print "SCHED_EVENT: time=%d, len=%d " % (sched_time, event_length) pdu = pdulib.pdu_arg_add(pdu, pmt.intern("event_time"), pmt.from_uint64(sched_time)) self.message_port_pub(pmt.intern("sched_pdu"), pdu)
def parse_extra_dict(p, info, VERBOSE=False): if(pmt.is_dict(p) is False): sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n") sys.exit(1) items = pmt.dict_items(p) nitems = pmt.length(items) for i in range(nitems): item = pmt.nth(i, items) key = pmt.symbol_to_string(pmt.car(item)) val = pmt.cdr(item) info[key] = val if(VERBOSE): print("{0}: {1}".format(key, val)) return info
def sched_pdu(self, pdu): sched_time = (self.nproduced_val + 10000) # pick a time in the future if (sched_time < self.sched_barrier): sched_time = self.sched_barrier print "delaying packet to sched barrier" sched_time = sched_time - sched_time % 1000 # round to nearest slot event_length = pmt.length(pmt.cdr(pdu)) #event_length = pmt.to_long(pmt.dict_ref(pmt.car(pdu), pmt.intern("event_length"), pmt.PMT_NIL)); self.sched_barrier = sched_time + event_length + 1000 print "SCHED_EVENT: time=%d, len=%d " % (sched_time, event_length) pdu = pdulib.pdu_arg_add(pdu, pmt.intern("event_time"), pmt.from_uint64(sched_time)) self.message_port_pub(pmt.intern("sched_pdu"), pdu)
def handle_msg(self, msg): d_size_msg = pmt.length(msg) # rx_time, frequency, power, phase time_tuple = pmt.nth(1, pmt.nth(0, msg)) time_s = pmt.to_uint64(pmt.tuple_ref(time_tuple, 0)) time_ms = pmt.to_double(pmt.tuple_ref(time_tuple, 1)) timestamp = time_s + time_ms phase_val_vec = pmt.nth(1, pmt.nth(d_size_msg - 1, msg)) phase_val = pmt.f32vector_elements(phase_val_vec)[0] #plt.scatter(timestamp, phase_val) #plt.pause(0.05) #power_val_vec = pmt.nth(1, pmt.nth(d_size_msg-2, msg)) #power_val = pmt.f32vector_elements(power_val_vec)[0] self.phase = phase_val self.time = timestamp
def main(): src_id = 42 dest_id = 84 frame_num = 4711 checksum = range(16) raw_payload = range(16) payload = get_pdu_payload(raw_payload) print(payload, pmt.length(payload)) meta = get_pdu_header(dest_id, src_id, frame_num) # pl = pmt.u print(meta) print(pmt.dict_keys(meta)) print(pmt.dict_values(meta)) meta = set_pdu_header_checksum(meta, checksum) print(meta) K = "00010203 04050607 08090A0B 0C0D0E0F " K += "10111213 14151617 18191A1B 1C1D1E1F" print(K) vals = hex_string_to_int_list(K) print(get_hex_char_string(vals))
def test_001_t (self): """ Simplest possible test: put in zeros, then header, then payload, trigger signal, try to demux. The return signal from the header parser is faked via _post() """ n_zeros = 100 header = (1, 2, 3) payload = tuple(range(17)) data_signal = (0,) * n_zeros + header + payload trigger_signal = [0,] * len(data_signal) trigger_signal[n_zeros] = 1 data_src = blocks.vector_source_f(data_signal, False) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 1) header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload)) ) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload)
def test_001_t(self): src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 12500, 3) src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 9800, 3) add = blocks.add_cc() detector = inspector.signal_detector_cvf(32000, 4096, firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.001) dst1 = blocks.null_sink(gr.sizeof_float * 4096) msg_dst = blocks.message_debug() # connections self.tb.connect(src1, (add, 0)) self.tb.connect(src2, (add, 1)) self.tb.connect(add, detector) self.tb.connect((detector, 0), dst1) self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store')) self.tb.start() time.sleep(0.5) self.tb.stop() self.tb.wait() # take most recent message msg = msg_dst.get_message(msg_dst.num_messages() - 1) res_vector = numpy.empty([0, 2]) for i in range(pmt.length(msg)): row = pmt.vector_ref(msg, i) res_vector = numpy.vstack( (res_vector, numpy.array( [pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)]))) self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50) self.assertAlmostEqual(0.0, res_vector[0][1], delta=100) self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50) self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def test_001_t (self): src1 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 12500, 3) src2 = analog.sig_source_c(32000, analog.GR_COS_WAVE, 9800, 3) add = blocks.add_cc() detector = inspector.signal_detector_cvf(32000, 4096, firdes.WIN_BLACKMAN_hARRIS, -80, 0.6, False, 0.5, 0.001) dst1 = blocks.null_sink(gr.sizeof_float*4096) msg_dst = blocks.message_debug() #connections self.tb.connect(src1, (add, 0)) self.tb.connect(src2, (add, 1)) self.tb.connect(add, detector) self.tb.connect((detector, 0), dst1) self.tb.msg_connect((detector, 'map_out'), (msg_dst, 'store')) self.tb.start() time.sleep(0.5) self.tb.stop() self.tb.wait() #take most recent message msg = msg_dst.get_message(msg_dst.num_messages()-1) res_vector = numpy.empty([0, 2]) for i in range(pmt.length(msg)): row = pmt.vector_ref(msg, i) res_vector = numpy.vstack((res_vector, numpy.array( [pmt.f32vector_ref(row, 0), pmt.f32vector_ref(row, 1)] ))) self.assertAlmostEqual(9800.0, res_vector[0][0], delta=50) self.assertAlmostEqual(0.0, res_vector[0][1], delta=100) self.assertAlmostEqual(12500.0, res_vector[1][0], delta=50) self.assertAlmostEqual(0.0, res_vector[1][1], delta=100)
def check_file(self, fname, expected, has_header=False, data_type='uint8'): # instantiate objects debug = blocks.message_debug() reader = csv_reader(fname=fname, has_header=has_header, period=10, repeat=False, start_delay=0, data_type=data_type) tb = gr.top_block() tb.msg_connect((reader, 'out'), (debug, 'store')) tb.start() time.sleep(.25) tb.stop() tb.wait() # collect results got = debug.get_message(0) got_car = pmt.car(got) print("got: {}".format(got)) print("expected: {}".format(expected)) # do a manual equal on elements because pmt equal is not the best expected_items = pmt.dict_items(pmt.car(expected)) valid = True for i in range(pmt.length(expected_items)): key = pmt.car(pmt.nth(i, expected_items)) value = pmt.cdr(pmt.nth(i, expected_items)) got_value = pmt.dict_ref(got_car, key, pmt.PMT_NIL) if not pmt.equal(got_value, value): valid = False break return (valid and pmt.equal(pmt.cdr(got), pmt.cdr(expected)))
def test_003_t (self): """ Like test 1, but twice, plus one fail """ ### Tx Data n_zeros = 5 header = (1, 2, 3) header_fail = (-1, -2, -4) # Contents don't really matter payload1 = tuple(range(5, 20)) payload2 = (42,) sampling_rate = 2 data_signal = (0,) * n_zeros + header + payload1 trigger_signal = [0,] * len(data_signal) * 2 trigger_signal[n_zeros] = 1 trigger_signal[len(data_signal)] = 1 trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1 print("Triggers at: {0} {1} {2}".format( n_zeros, len(data_signal), len(data_signal)+len(header_fail)+n_zeros) ) tx_signal = data_signal + \ header_fail + (0,) * n_zeros + \ header + payload2 + (0,) * 1000 # Timing tag: This is preserved and updated: timing_tag = make_tag('rx_time', (0, 0), 0) # Rx freq tags: rx_freq_tag1 = make_tag('rx_freq', 1.0, 0) rx_freq_tag2 = make_tag('rx_freq', 1.5, 29) rx_freq_tag3 = make_tag('rx_freq', 2.0, 30) ### Flow graph data_src = blocks.vector_source_f( tx_signal, False, tags=(timing_tag, rx_freq_tag1, rx_freq_tag2, rx_freq_tag3) ) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( header_len=len(header), items_per_symbol=1, guard_interval=0, length_tag_key="frame_len", trigger_tag_key="detect", output_symbols=False, itemsize=gr.sizeof_float, timing_tag_key='rx_time', samp_rate=sampling_rate, special_tags=('rx_freq',), ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload1)) ) while len(payload_sink.data()) < len(payload1): time.sleep(.2) hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.PMT_F ) # This next command is a bit of a showstopper, but there's no condition to check upon # to see if the previous msg handling is finished time.sleep(.7) hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload2)) ) while len(payload_sink.data()) < len(payload1) + len(payload2): time.sleep(.2) self.tb.stop() self.tb.wait() # Signal description: # 0: 5 zeros # 5: header 1 # 8: payload 1 (length: 15) # 23: header 2 (fail) # 26: 5 zeros # 31: header 3 # 34: payload 2 (length 1) # 35: 1000 zeros self.assertEqual(header_sink.data(), header + header_fail + header) self.assertEqual(payload_sink.data(), payload1 + payload2) tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()] tags_payload = sorted([(x.offset, x.key, x.value) for x in tags_payload]) tags_expected_payload = [ (0, 'frame_len', len(payload1)), (len(payload1), 'frame_len', len(payload2)), ] tags_header = [gr.tag_to_python(x) for x in header_sink.tags()] tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header]) tags_expected_header = [ (0, 'rx_freq', 1.0), (0, 'rx_time', (2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate (len(header), 'rx_freq', 1.0), (len(header), 'rx_time', (11, .5)), # Hard coded time value :(. See above. (2*len(header), 'rx_freq', 2.0), (2*len(header), 'rx_time', (15, .5)), # Hard coded time value :(. See above. ] self.assertEqual(tags_header, tags_expected_header) self.assertEqual(tags_payload, tags_expected_payload)
def test_001_headerpadding_payload_offset (self): """ Like test 1, but with header padding + payload offset. """ n_zeros = 3 header = (1, 2, 3) header_padding = 1 payload_offset = -1 payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload + (0,) * 100 trigger_signal = [0] * len(data_signal) trigger_signal[n_zeros] = 1 # This goes on output 1, item 3 + 1 (for payload offset) testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3) data_src = blocks.vector_source_f( data_signal, False, tags=(testtag4,) ) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, # Items per symbol 0, # Guard interval "frame_len", # TSB tag key "detect", # Trigger tag key False, # No symbols please gr.sizeof_float, # Item size "", # Timing tag key 1.0, # Samp rate (), # No special tags header_padding ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.to_pmt({'frame_len': len(payload), 'payload_offset': payload_offset}) ) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() # Header is now padded: self.assertEqual(header_sink.data(), (0,) + header + (payload[0],)) # Payload is now offset: self.assertEqual( payload_sink.data(), data_signal[n_zeros + len(header) + payload_offset:n_zeros + len(header) + payload_offset + len(payload)] ) ptags_payload = {} for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload[ptag.key] = ptag.offset expected_tags_payload = { 'frame_len': 0, 'payload_offset': 0, 'tag4': 3 - payload_offset, } self.assertEqual(expected_tags_payload, ptags_payload)
def test_003_t(self): """ Like test 1, but twice, plus one fail """ ### Tx Data n_zeros = 5 header = (1, 2, 3) header_fail = (-1, -2, -4) # Contents don't really matter payload1 = tuple(range(5, 20)) payload2 = (42, ) sampling_rate = 2 data_signal = (0, ) * n_zeros + header + payload1 trigger_signal = [ 0, ] * len(data_signal) * 2 trigger_signal[n_zeros] = 1 trigger_signal[len(data_signal)] = 1 trigger_signal[len(data_signal) + len(header_fail) + n_zeros] = 1 tx_signal = data_signal + header_fail + ( 0, ) * n_zeros + header + payload2 + (0, ) * 1000 # Timing tag: This is preserved and updated: timing_tag = gr.tag_t() timing_tag.offset = 0 timing_tag.key = pmt.string_to_symbol('rx_time') timing_tag.value = pmt.to_pmt((0, 0)) # Rx freq tags: rx_freq_tag1 = gr.tag_t() rx_freq_tag1.offset = 0 rx_freq_tag1.key = pmt.string_to_symbol('rx_freq') rx_freq_tag1.value = pmt.from_double(1.0) rx_freq_tag2 = gr.tag_t() rx_freq_tag2.offset = 29 rx_freq_tag2.key = pmt.string_to_symbol('rx_freq') rx_freq_tag2.value = pmt.from_double(1.5) rx_freq_tag3 = gr.tag_t() rx_freq_tag3.offset = 30 rx_freq_tag3.key = pmt.string_to_symbol('rx_freq') rx_freq_tag3.value = pmt.from_double(2.0) ### Flow graph data_src = blocks.vector_source_f(tx_signal, False, tags=(timing_tag, rx_freq_tag1, rx_freq_tag2, rx_freq_tag3)) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( header_len=len(header), items_per_symbol=1, guard_interval=0, length_tag_key="frame_len", trigger_tag_key="detect", output_symbols=False, itemsize=gr.sizeof_float, timing_tag_key='rx_time', samp_rate=sampling_rate, special_tags=('rx_freq', ), ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.from_long(len(payload1))) while len(payload_sink.data()) < len(payload1): time.sleep(.2) hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.PMT_F) # This next command is a bit of a showstopper, but there's no condition to check upon # to see if the previous msg handling is finished time.sleep(.7) hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.from_long(len(payload2))) while len(payload_sink.data()) < len(payload1) + len(payload2): time.sleep(.2) self.tb.stop() self.tb.wait() # Signal description: # 0: 5 zeros # 5: header 1 # 8: payload 1 (length: 15) # 23: header 2 (fail) # 26: 5 zeros # 31: header 3 # 34: payload 2 (length 1) # 35: 1000 zeros self.assertEqual(header_sink.data(), header + header_fail + header) self.assertEqual(payload_sink.data(), payload1 + payload2) tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()] tags_payload = sorted([(x.offset, x.key, x.value) for x in tags_payload]) tags_expected_payload = [ (0, 'frame_len', len(payload1)), (len(payload1), 'frame_len', len(payload2)), ] tags_header = [gr.tag_to_python(x) for x in header_sink.tags()] tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header]) tags_expected_header = [ (0, 'rx_freq', 1.0), (0, 'rx_time', (2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate (len(header), 'rx_freq', 1.0), (len(header), 'rx_time', (11, .5)), # Hard coded time value :(. See above. (2 * len(header), 'rx_freq', 2.0), (2 * len(header), 'rx_time', (15, .5)), # Hard coded time value :(. See above. ] self.assertEqual(tags_header, tags_expected_header) self.assertEqual(tags_payload, tags_expected_payload)
def test_001_t(self): """ Simplest possible test: put in zeros, then header, then payload, trigger signal, try to demux. The return signal from the header parser is faked via _post() Add in some tags for fun. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0, ) * n_zeros + header + payload trigger_signal = [ 0, ] * len(data_signal) trigger_signal[n_zeros] = 1 # This is dropped: testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) # This goes on output 0, item 0: testtag2 = gr.tag_t() testtag2.offset = n_zeros testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(23) # This goes on output 0, item 2: testtag3 = gr.tag_t() testtag3.offset = n_zeros + len(header) - 1 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(42) # This goes on output 1, item 3: testtag4 = gr.tag_t() testtag4.offset = n_zeros + len(header) + 3 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(314) data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4)) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux(len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.from_long(len(payload))) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ { 'key': 'tag2', 'offset': 0 }, { 'key': 'tag3', 'offset': 2 }, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ { 'key': 'frame_len', 'offset': 0 }, { 'key': 'tag4', 'offset': 3 }, ] self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t_tags (self): """ Like the previous test, but use a trigger tag instead of a trigger signal. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload # Trigger tag trigger_tag = gr.tag_t() trigger_tag.offset = n_zeros trigger_tag.key = pmt.string_to_symbol('detect') trigger_tag.value = pmt.PMT_T # This is dropped: testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) # This goes on output 0, item 0: testtag2 = gr.tag_t() testtag2.offset = n_zeros testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(23) # This goes on output 0, item 2: testtag3 = gr.tag_t() testtag3.offset = n_zeros + len(header) - 1 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(42) # This goes on output 1, item 3: testtag4 = gr.tag_t() testtag4.offset = n_zeros + len(header) + 3 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(314) data_src = blocks.vector_source_f( data_signal, False, tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4) ) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload)) ) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 2}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 3}, ] self.assertEqual(expected_tags_payload, ptags_payload)
def test_002_symbols(self): """ Same as before, but operate on symbols """ n_zeros = 1 items_per_symbol = 3 gi = 1 n_symbols = 4 header = (1, 2, 3) payload = (1, 2, 3) data_signal = (0, ) * n_zeros + (0, ) + header + ( (0, ) + payload) * n_symbols trigger_signal = [ 0, ] * len(data_signal) trigger_signal[n_zeros] = 1 # This is dropped: testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) # This goes on output 0, item 0 (from the GI) testtag2 = gr.tag_t() testtag2.offset = n_zeros testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(23) # This goes on output 0, item 0 (middle of the header symbol) testtag3 = gr.tag_t() testtag3.offset = n_zeros + gi + 1 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(42) # This goes on output 1, item 1 (middle of the first payload symbol) testtag4 = gr.tag_t() testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(314) data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4)) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header) / items_per_symbol, # Header length (in symbols) items_per_symbol, # Items per symbols gi, # Items per guard time "frame_len", # Frame length tag key "detect", # Trigger tag key True, # Output symbols (not items) gr.sizeof_float # Bytes per item ) self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you header_sink = blocks.vector_sink_f(items_per_symbol) payload_sink = blocks.vector_sink_f(items_per_symbol) self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post(pmt.intern('header_data'), pmt.from_long(n_symbols)) while len(payload_sink.data()) < len(payload) * n_symbols: time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload * n_symbols) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ { 'key': 'tag2', 'offset': 0 }, { 'key': 'tag3', 'offset': 0 }, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ { 'key': 'frame_len', 'offset': 0 }, { 'key': 'tag4', 'offset': 1 }, ] self.assertEqual(expected_tags_payload, ptags_payload)
def __init__(self, buf, len, debug, d_mac_id, d_seq_nr, no_self_loop): self.debug = debug self.buf = buf self.len = len self.d_seq_nr = d_seq_nr self.d_mac_id = d_mac_id self.no_self_loop = no_self_loop if self.no_self_loop: #Insert an id here to check for self routing. This makes the packet non standard. d_msg.insert(0, self.d_mac_id) d_msg.insert(1, 11 + self.len + 2) #FCF d_msg.insert(2,0x41) d_msg.insert(3,0x88) #seq nr d_msg.insert(4,++self.d_seq_nr) #addr info d_msg.insert(5,0xcd) d_msg.insert(6,0xab) d_msg.insert(7,0xff) d_msg.insert(8,0xff) d_msg.insert(9,0x40) d_msg.insert(10,0xe8) #Copy the data here. if (pmt.is_vector(buf)): for i in range(pmt.length(buf)): d_msg.insert(10+i,pmt.to_long(pmt.vector_ref(buf,i))) elif (pmt.is_uniform_vector(buf)): d_msg.extend(pmt.u8vector_elements(buf)) else: bufString = pmt.symbol_to_string(buf) #print "pmt.symbol_to_string(buf): ", bufString #print "pmt.length(buf): ", pmt.length(buf) bytes = map(ord,bufString) #print "map(ord,buf): ", bytes d_msg.extend(bytes) #Compute the CRC over the whole packet (excluding the CRC bytes themselves) crc = crc16(d_msg, self.len + 11) #if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc() #CRC goes on the end. d_msg.insert(11+ self.len, crc.get_crc() & 0xFF) d_msg.insert(12+ self.len, crc.get_crc() >> 8) d_msg_len = 11 + self.len + 2 print print if self.debug: print "d_msg: ", d_msg print print else: #Preamble length + CRC length ( CRC at the end) d_msg.insert(0, 10 + self.len + 2) #FCF d_msg.insert(1,0x41) d_msg.insert(2,0x88) #seq nr d_msg.insert(3,++self.d_seq_nr) #addr info d_msg.insert(4,0xcd) d_msg.insert(5,0xab) d_msg.insert(6,0xff) d_msg.insert(7,0xff) d_msg.insert(8,0x40) d_msg.insert(9,0xe8) #Copy the data here. d_msg.extend(pmt.u8vector_elements(buf)) #Compute the CRC over the whole packet (excluding the CRC bytes themselves) crc = crc16(d_msg, self.len + 10) if self.debug: print "#### CRC at Transmission: #### ", crc.get_crc() d_msg.insert(10 + self.len, crc.get_crc() & 0xFF) d_msg.insert(11 + self.len, crc.get_crc() >> 8) d_msg_len = 10 + self.len + 2 # Preamble + Data + CRC if self.debug: print " msg len ", d_msg_len, " len ", self.len, "\n"
def msg_handler(self, p): verbose = False length = pmt.length(p) if verbose: print "PMT contrains " + str(length) + " key/value pairs" for i in range(0,length): element = pmt.nth(i, p) key = pmt.nth(0, element) value = pmt.nth(1, element) if verbose: print "Key of " + str(i) + "th element: " + str(key) print "Value of " + str(i) + "th element: " + str(value) print found = False for j in range(0, len(self.n)): if str(key) == self.kk[j]: found = True if verbose: print "found the key " + str(key) #rotate the values, the latest one disappears self.prev_values[j] = numpy.roll(self.prev_values[j], -1) #set the vector accordingly self.prev_values[j][-1] = pmt.f32vector_elements(value)[0] output = sum(self.prev_values[j])/len(self.prev_values[j]) output = pmt.make_f32vector(1, output) if i==0: outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output)) else: outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output)) output = pmt.nth(1, element) if i==0: outpmt = pmt.list1(pmt.list2(key, output)) else: outpmt = pmt.list_add(outpmt, pmt.list2(key, output)) if verbose: print #iterate over all keys for i in range(0, len(self.kk)): minimum = self.prev_values[i][0] maximum = self.prev_values[i][0] #iterate over all saved values for j in range(0, self.n[i]): if self.prev_values[i][j] < minimum: minimum = self.prev_values[i][j] if self.prev_values[i][j] > maximum: maximum = self.prev_values[i][j] #print out a min, diff, max for every key difference = maximum-minimum outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("min"), pmt.make_f32vector(1, minimum))) outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("max"), pmt.make_f32vector(1, maximum))) outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("diff"), pmt.make_f32vector(1, difference))) self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def test_004_long_burst(self): # This test processes a single burst that exceeds the maximum burst size that will be truncated # data min_data_size = 32 * 1024 # arbitrary constant in tagged_burst_to_pdu_impl.h src_data = (1, ) * min_data_size * 8 new_burst_offset = 64 new_burst_dict = pmt.make_dict() new_burst_dict = pmt.dict_add(new_burst_dict, fhss_utils.PMTCONSTSTR__burst_id(), pmt.from_uint64(505)) new_burst_dict = pmt.dict_add( new_burst_dict, fhss_utils.PMTCONSTSTR__relative_frequency(), pmt.from_float(1e6 / 30.72e6)) # in [-1.0,1.0], not Hz new_burst_dict = pmt.dict_add( new_burst_dict, fhss_utils.PMTCONSTSTR__center_frequency(), pmt.from_float(915e6)) # of the whole signal, not the burst new_burst_dict = pmt.dict_add(new_burst_dict, fhss_utils.PMTCONSTSTR__magnitude(), pmt.from_float(40)) new_burst_dict = pmt.dict_add(new_burst_dict, fhss_utils.PMTCONSTSTR__sample_rate(), pmt.from_float(30.72e6)) new_burst_dict = pmt.dict_add(new_burst_dict, fhss_utils.PMTCONSTSTR__noise_density(), pmt.from_float(-100)) # in dBFS/Hz new_burst_dict = pmt.dict_add(new_burst_dict, fhss_utils.PMTCONSTSTR__bandwidth(), pmt.from_float(0.1e6)) nb_tag = gr.tag_utils.python_to_tag([ new_burst_offset, fhss_utils.PMTCONSTSTR__new_burst(), new_burst_dict, pmt.intern("qa_test") ]) duration = 1024 gone_burst_offset = new_burst_offset + duration gone_burst_dict = pmt.make_dict() gone_burst_dict = pmt.dict_add(gone_burst_dict, fhss_utils.PMTCONSTSTR__burst_id(), pmt.from_uint64(505)) gb_tag = gr.tag_utils.python_to_tag([ gone_burst_offset, fhss_utils.PMTCONSTSTR__gone_burst(), gone_burst_dict, pmt.intern("qa_test") ]) # blocks src = blocks.vector_source_c(src_data, False, 1, [nb_tag, gb_tag]) #src.set_min_output_buffer(min_data_size*2) # not necessary, block calls set_output_multiple debug = blocks.message_debug() dec = 16 taps = [1] min_time = 1e-6 max_time = 10e-6 nthreads = 3 samp_rate = 30.72e6 rel_span = 1 rel_samp_rate = 1 rel_cf = 0 dut = fhss_utils.tagged_burst_to_pdu(dec, taps, min_time, max_time, rel_cf, rel_span, rel_samp_rate, samp_rate, nthreads) self.tb.connect(src, dut) self.tb.msg_connect((dut, 'cpdus'), (debug, 'store')) #self.tb.run() # blocking, vector_source will end flowgraph self.tb.start() time.sleep(0.1) self.tb.stop() time.sleep(0.1) self.tb.wait() time.sleep(0.1) print("test long burst:") #print(f"how many msg? {debug.num_messages()}") self.assertEqual(debug.num_messages(), 1) #print(f"received: {pmt.car(debug.get_message(0))}") #print(f"received: {pmt.cdr(debug.get_message(0))}") #print(f"received len: {pmt.length(pmt.cdr(debug.get_message(0)))}") rcv_meta = pmt.car(debug.get_message(0)) # we expect a duration equal to `max_time` and a vector of length that corrseponds to `max_time` samples self.assertAlmostEqual( pmt.to_double( pmt.dict_ref(rcv_meta, pmt.intern("duration"), pmt.PMT_NIL)), max_time, 6) self.assertEqual(pmt.length(pmt.cdr(debug.get_message(0))), (max_time * samp_rate) // dec) self.assertEqual( pmt.to_uint64( pmt.dict_ref(rcv_meta, pmt.intern("burst_id"), pmt.PMT_NIL)), 505)
def test_002_symbols (self): """ Same as before, but operate on symbols """ n_zeros = 1 items_per_symbol = 3 gi = 1 n_symbols = 4 header = (1, 2, 3) payload = (1, 2, 3) data_signal = (0,) * n_zeros + (0,) + header + ((0,) + payload) * n_symbols trigger_signal = [0,] * len(data_signal) trigger_signal[n_zeros] = 1 # This is dropped: testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) # This goes on output 0, item 0 (from the GI) testtag2 = gr.tag_t() testtag2.offset = n_zeros testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(23) # This goes on output 0, item 0 (middle of the header symbol) testtag3 = gr.tag_t() testtag3.offset = n_zeros + gi + 1 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(42) # This goes on output 1, item 1 (middle of the first payload symbol) testtag4 = gr.tag_t() testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(314) data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4)) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header) / items_per_symbol, # Header length (in symbols) items_per_symbol, # Items per symbols gi, # Items per guard time "frame_len", # Frame length tag key "detect", # Trigger tag key True, # Output symbols (not items) gr.sizeof_float # Bytes per item ) self.assertEqual(pmt.length(hpd.message_ports_in()), 1) header_sink = blocks.vector_sink_f(items_per_symbol) payload_sink = blocks.vector_sink_f(items_per_symbol) self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(n_symbols) ) while len(payload_sink.data()) < len(payload) * n_symbols: time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload * n_symbols) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 0}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 1}, ] self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t (self): """ Simplest possible test: put in zeros, then header, then payload, trigger signal, try to demux. The return signal from the header parser is faked via _post() Add in some tags for fun. """ n_zeros = 1 header = (1, 2, 3) payload = tuple(range(5, 20)) data_signal = (0,) * n_zeros + header + payload trigger_signal = [0,] * len(data_signal) trigger_signal[n_zeros] = 1 # This is dropped: testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) # This goes on output 0, item 0: testtag2 = gr.tag_t() testtag2.offset = n_zeros testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(23) # This goes on output 0, item 2: testtag3 = gr.tag_t() testtag3.offset = n_zeros + len(header) - 1 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(42) # This goes on output 1, item 3: testtag4 = gr.tag_t() testtag4.offset = n_zeros + len(header) + 3 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(314) data_src = blocks.vector_source_f(data_signal, False, tags=(testtag1, testtag2, testtag3, testtag4)) trigger_src = blocks.vector_source_b(trigger_signal, False) hpd = digital.header_payload_demux( len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float ) self.assertEqual(pmt.length(hpd.message_ports_in()), 1) header_sink = blocks.vector_sink_f() payload_sink = blocks.vector_sink_f() self.tb.connect(data_src, (hpd, 0)) self.tb.connect(trigger_src, (hpd, 1)) self.tb.connect((hpd, 0), header_sink) self.tb.connect((hpd, 1), payload_sink) self.tb.start() time.sleep(.2) # Need this, otherwise, the next message is ignored hpd.to_basic_block()._post( pmt.intern('header_data'), pmt.from_long(len(payload)) ) while len(payload_sink.data()) < len(payload): time.sleep(.2) self.tb.stop() self.tb.wait() self.assertEqual(header_sink.data(), header) self.assertEqual(payload_sink.data(), payload) ptags_header = [] for tag in header_sink.tags(): ptag = gr.tag_to_python(tag) ptags_header.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_header = [ {'key': 'tag2', 'offset': 0}, {'key': 'tag3', 'offset': 2}, ] self.assertEqual(expected_tags_header, ptags_header) ptags_payload = [] for tag in payload_sink.tags(): ptag = gr.tag_to_python(tag) ptags_payload.append({'key': ptag.key, 'offset': ptag.offset}) expected_tags_payload = [ {'key': 'frame_len', 'offset': 0}, {'key': 'tag4', 'offset': 3}, ] self.assertEqual(expected_tags_payload, ptags_payload)
rc = sock.bind(_ADDR) #%% flanks = pmt.make_f32vector(2, 0.0) pmt.f32vector_set(flanks, 0, np.radians(15)) pmt.f32vector_set(flanks, 1, np.radians(70)) c = pmt.cons(pmt.to_pmt("doa"), flanks) #%% sock.recv() #%% sock.send(pmt.serialize_str(c)) # %% De acá para arriba anda key0 = pmt.intern("doa") val0 = pmt.from_long(123) val1 = pmt.from_long(234) val_list = pmt.list2(val0, val1) pmt.length(val_list) # %% a = pmt.make_dict() # %% a = pmt.dict_add(a, key0, val_list) print(pmt.cdr(a)) # %% pmt.set_car(a, key0) pmt.set_cdr(a, val_list) # %% print(pmt.cons(pmt.to_pmt("doa"), val_list)) # %% print( pmt.cons(pmt.to_pmt("doa"), pmt.list2(pmt.from_long(123), pmt.from_long(234)))) # %%