def test_004_invert_passb(self): self.dut = pdu_utils.pdu_range_filter(pmt.intern("start_time"), 1, 5, True) self.connectUp() in_data = [0, 0, 0, 0, 0, 0] i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("start_time"), pmt.from_double(6.0)) in_pdu = pmt.cons(i_meta, pmt.init_u8vector(len(in_data), in_data)) expected_data = [0, 0, 0, 0, 0, 0] e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("start_time"), pmt.from_double(6.0)) expected_pdu = pmt.cons( e_meta, pmt.init_u8vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertEqual(1, self.debug.num_messages()) self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_001_t (self): in_data = [0, 1, 0, 0, 1, 0, 1, 1] print ("in_data = ", in_data) expected_data = [(1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (0.9999558329582214-0.009149551391601562j), (0.9986380934715271-0.05212688446044922j), (0.9845290780067444-0.17521238327026367j), (0.9109043478965759-0.4126133918762207j), (0.6968833208084106-0.717181921005249j), (0.31042835116386414-0.950594425201416j), (-0.17273569107055664-0.9849666953086853j), (-0.6225566864013672-0.7825717926025391j), (-0.914273738861084-0.4051017761230469j), (-0.999992847442627-0.003090381622314453j), (-0.9691651463508606+0.24640250205993652j), (-0.968771755695343+0.24795293807983398j), (-0.9999971389770508+0.0017070770263671875j), (-0.9174799919128418-0.39777708053588867j), (-0.6312775611877441-0.7755542993545532j), (-0.18532180786132812-0.9826757907867432j), (0.2910269498825073-0.9567151069641113j), (0.6513003706932068-0.7588169574737549j), (0.81996750831604-0.5724067687988281j), (0.8208843469619751-0.5710964202880859j), (0.6549332737922668-0.7556841373443604j), (0.2986666262149811-0.9543551206588745j), (-0.17431020736694336-0.9846884608268738j), (-0.6225566864013672-0.7825717926025391j), (-0.9215338230133057-0.3883037567138672j), (-0.994880199432373+0.10103797912597656j), (-0.8246530294418335+0.5656423568725586j), (-0.4525153636932373+0.8917537331581116j), (0.030410051345825195+0.9995390772819519j), (0.5058896541595459+0.8625954985618591j), (0.8575133085250854+0.5144641399383545j), (0.9991825222969055+0.040370840579271317j), (0.9041904211044312-0.42713212966918945j), (0.6559781432151794-0.7547774314880371j), (0.44701042771339417-0.8945262432098389j), (0.44557973742485046-0.8952407836914062j), (0.6523504257202148-0.7579166889190674j), (0.9007443785667419-0.43434762954711914j), (0.9995729923248291+0.029183024540543556j), (0.8648265600204468+0.5020678639411926j), (0.533815860748291+0.8455996513366699j), (0.14855670928955078+0.9889022707939148j), (-0.1027672290802002+0.99470454454422j), (-0.10435843467712402+0.9945414066314697j), (0.14381003379821777+0.9896029233932495j), (0.5270366668701172+0.8498398065567017j), (0.8591512441635132+0.5117172598838806j), (0.9991825222969055+0.040370840579271317j), (0.9041904211044312-0.42713212966918945j), (0.6559781432151794-0.7547774314880371j), (0.44701042771339417-0.8945262432098389j), (0.44557973742485046-0.8952407836914062j), (0.6523504257202148-0.7579166889190674j), (0.9007443785667419-0.43434762954711914j), (0.9995729923248291+0.029183024540543556j), (0.8648265600204468+0.5020678639411926j), (0.5182530879974365+0.8552265167236328j), (0.04479217529296875+0.9989947080612183j), (-0.4396350383758545+0.8981758952140808j), (-0.8164236545562744+0.5774505138397217j), (-0.9933251738548279+0.11534643173217773j), (-0.9270230531692505-0.3749988079071045j), (-0.6337566375732422-0.773532509803772j), (-0.18532228469848633-0.9826757311820984j), (0.29976776242256165-0.954010009765625j), (0.6899716258049011-0.7238376140594482j), (0.9075756072998047-0.41988372802734375j), (0.9833885431289673-0.18150663375854492j), (0.9983774423599243-0.05691719055175781j), (0.9999259114265442-0.012347698211669922j), (0.9999974370002747-0.0015993118286132812j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j), (1.000002384185791+7.219194575469601e-09j)] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_pdu = pmt.cons(pmt.make_dict(), pmt.init_c32vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) # handle non-pair input self.emitter2.emit(pmt.intern("MALFORMED PDU")) time.sleep(.001) # handle malformed pair self.emitter2.emit(pmt.cons(pmt.intern("NON-PDU"), pmt.intern("PAIR"))) time.sleep(.001) # handle incorrect PDU self.emitter2.emit(in_pdu) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() out_data = pmt.c32vector_elements(pmt.cdr(self.debug.get_message(0))) self.assertComplexTuplesAlmostEqual(out_data, expected_data, 6)
def test_002_pass_empty (self): emitter = pdu_utils.message_emitter() split = pdu_utils.pdu_split(True) d1 = blocks.message_debug() d2 = blocks.message_debug() self.tb.msg_connect((emitter, 'msg'), (split, 'pdu_in')) self.tb.msg_connect((split, 'dict'), (d1, 'store')) self.tb.msg_connect((split, 'data'), (d2, 'store')) in_meta1 = pmt.dict_add(pmt.make_dict(), pmt.intern('num'), pmt.from_long(4)) in_meta2 = pmt.dict_add(pmt.make_dict(), pmt.intern('n'), pmt.from_long(99)) in_pdu = pmt.cons(in_meta1, pmt.init_u8vector(6, range(6))) self.tb.start() time.sleep(.001) emitter.emit(pmt.intern("MALFORMED PDU")) time.sleep(.001) emitter.emit(pmt.cons(pmt.PMT_NIL, pmt.init_u8vector(2, range(2)))) time.sleep(.001) emitter.emit(pmt.cons(in_meta2, pmt.init_u8vector(0, []))) time.sleep(.001) emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(d1.get_message(0), pmt.PMT_NIL)) self.assertTrue(pmt.equal(d1.get_message(1), in_meta2)) self.assertTrue(pmt.equal(d1.get_message(2), in_meta1)) self.assertTrue(pmt.equal(d2.get_message(0), pmt.init_u8vector(2, range(2)))) self.assertTrue(pmt.equal(d2.get_message(1), pmt.init_u8vector(0, []))) self.assertTrue(pmt.equal(d2.get_message(2), pmt.init_u8vector(6, range(6))))
def test_002_larger(self): self.ht.set_length(32) in_data = [ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1 ] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_head = [ 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] e_head_pdu = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_head), expected_head)) expected_tail = [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1 ] e_tail_pdu = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_tail), expected_tail)) self.tb.start() time.sleep(.001) self.emitter.emit(pmt.intern("MALFORMED PDU")) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.d_head.get_message(0), e_head_pdu)) self.assertTrue(pmt.equal(self.d_tail.get_message(0), e_tail_pdu))
def test_float(self): self.down = pdu_utils.pdu_downsample(3, 0) self.connectUp() i_vec = pmt.init_f32vector(9, [0, 1, 2, 3.3, 4, 5, 6, 7, 8]) e_vec = pmt.init_f32vector(3, [0, 3.3, 6]) in_pdu = pmt.cons(pmt.make_dict(), i_vec) e_pdu = pmt.cons(pmt.make_dict(), e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() print("test float:") print("pdu expected: " + repr(pmt.car(e_pdu))) print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) print("data expected: " + repr(pmt.f32vector_elements(pmt.cdr(e_pdu)))) print("data got: " + repr(pmt.f32vector_elements(pmt.cdr(self.debug.get_message(0))))) print self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_008_match_leading_zeros (self): ''' Leading zeros at the beginning of the alignment sequence previously caused invalid alignments due to not checking to ensure that the entire alignment sequence was checked before emitting the message For an alignment sequence of: '00000000'*3 + '10110111' a message was kicked out with the following contents '00000000'*3 + '10110111' + ... if the first 8 bits of a sequence were within the threshold of the last 8 bits of the alignment sequence, which has a 1 in 256 chance of occuring statistically anyway. ''' preamble = '00000000' * 3 + '10110111' self.dut = pdu_utils.pdu_align(preamble, 0, 0, pdu_utils.ALIGN_EMPTY) self.connectUp() in_data = [int(a) for a in ('10110111' + '00000000' * 3 + '10110111' + '10100101')] expected_data = [1, 0, 1, 0, 0, 1, 0, 1] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_longer (self): self.emitter = pdu_utils.message_emitter() self.down = pdu_utils.pdu_downsample(2,1) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.down, 'pdu_in')) self.tb.msg_connect((self.down, 'pdu_out'), (self.debug, 'store')) i_vec = pmt.init_u8vector(7, [0,1,2,3,4,5,6]) e_vec = pmt.init_u8vector(3, [1,3,5]) in_pdu = pmt.cons(pmt.make_dict(), i_vec) e_pdu = pmt.cons(pmt.make_dict(), e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() print("test long:") print("pdu expected: " + repr(pmt.car(e_pdu))) print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) print("data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu)))) print("data got: " + repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0))))) print self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_005_fff_down(self): self.dut = pdu_utils.pdu_pfb_resamp_fff([1], 1, 0.5) self.connectUp() in_data = [1, 1, 0, 0] * 4 in_pdu = pmt.cons(pmt.make_dict(), pmt.init_f32vector(len(in_data), in_data)) expected_data = [1, 0] * 4 expected_pdu = pmt.cons(pmt.make_dict(), pmt.init_f32vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertEqual(1, self.debug.num_messages()) print("test_005_fff_down:") print("pdu expected: " + repr(pmt.car(expected_pdu))) print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) print("data expected: " + repr(pmt.to_python(pmt.cdr(expected_pdu)))) print("data got: " + repr(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) print self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_005_match_error0b(self): self.dut = pdu_utils.pdu_align('10101010', 1, 0, pdu_utils.ALIGN_DROP) self.connectUp() in_data = [1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1] expected_data = [1, 1, 1, 1, 1, 1, 1, 1] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_pdu = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() self.assertEqual(1, self.debug.num_messages()) print("\nEXPECTED: " + repr(pmt.car(expected_pdu))) print("GOT: " + repr(pmt.car(self.debug.get_message(0)))) print("\nEXPECTED: " + repr(pmt.u8vector_elements(pmt.cdr(expected_pdu)))) print("GOT: " + repr(pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0))))) self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_007_match_errors2(self): ''' Ensure specification of the number of errors in an alignment sequence is properly checked ''' self.dut = pdu_utils.pdu_align('10101010', 2, 0, pdu_utils.ALIGN_EMPTY) self.connectUp() in_data = [1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1] expected_data = [0, 1, 0, 1, 0, 1, 0, 1] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_pdu = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu))
def test_endian(self): self.emitter = pdu_utils.message_emitter() #self.endi = pdu_utils.pdu_binary_tools(pdu_utils.pdu_binary_tools.ENDIAN_SWAP8) self.endi = pdu_utils.pdu_binary_tools(4) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.endi, 'pdu_in')) self.tb.msg_connect((self.endi, 'pdu_out'), (self.debug, 'store')) i_vec = pmt.init_u8vector( 16, [1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0]) e_vec = pmt.init_u8vector( 16, [1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1]) in_pdu = pmt.cons(pmt.make_dict(), i_vec) e_pdu = pmt.cons(pmt.make_dict(), e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() print "test endian_swap8:" print "pdu expected: " + repr(pmt.car(e_pdu)) print "pdu got: " + repr(pmt.car(self.debug.get_message(0))) print "data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu))) print "data got: " + repr( pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))) print self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_004_n512_s32(self): self.upsample.set_n(512) self.upsample.set_repeat(True) in_data = [99, 44] expected_data = [ 99, ] * 512 + [ 44, ] * 512 in_pdu = pmt.cons(pmt.make_dict(), pmt.init_s32vector(len(in_data), in_data)) expected_pdu = pmt.cons( pmt.make_dict(), pmt.init_s32vector(len(expected_data), expected_data)) self.tb.start() time.sleep(.001) self.emitter.emit(pmt.intern("MALFORMED PDU")) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.05) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu)) self.assertTrue(pmt.equal(self.debug.get_message(1), expected_pdu))
def test_001_n4_u8(self): in_data = [0, 1, 2, 4, 8, 16, 32] expected_data1 = [ 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 8, 0, 0, 0, 16, 0, 0, 0, 32, 0, 0, 0 ] expected_data2 = [ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 16, 16, 16, 16, 32, 32, 32, 32 ] in_pdu = pmt.cons(pmt.make_dict(), pmt.init_u8vector(len(in_data), in_data)) expected_pdu1 = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_data1), expected_data1)) expected_pdu2 = pmt.cons( pmt.make_dict(), pmt.init_u8vector(len(expected_data2), expected_data2)) self.tb.start() time.sleep(.001) self.emitter.emit(pmt.intern("MALFORMED PDU")) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.001) self.upsample.set_repeat(True) time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.05) self.tb.stop() self.tb.wait() self.assertTrue(pmt.equal(self.debug.get_message(0), expected_pdu1)) self.assertTrue(pmt.equal(self.debug.get_message(1), expected_pdu2))
def test_simple (self): self.emitter = pdu_utils.message_emitter() self.ctm2 = pdu_utils.pdu_complex_to_mag2() self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.ctm2, 'cpdus')) self.tb.msg_connect((self.ctm2, 'fpdus'), (self.debug, 'store')) # gnuradio uses single-precision floats by default i_vec = pmt.init_c32vector(3, [3+4j, 1+0j, 0+1j]) e_vec = pmt.init_f32vector(3, [25, 1, 1]) in_pdu = pmt.cons(pmt.make_dict(), i_vec) e_pdu = pmt.cons(pmt.make_dict(), e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() print("test ctm2:") print("pdu expected: " + repr(pmt.car(e_pdu))) print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) print("data expected: " + repr(pmt.to_python(pmt.cdr(e_pdu)))) print("data got: " + repr(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) print self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def msg_handler_frame(self, msg_in): ## print('-------------------- msg_handler_frame --------------------') ## print(msg_in) symbols = pmt.to_python( pmt.dict_ref(msg_in, pmt.intern('symbols'), pmt.PMT_NIL)) soft_dec = pmt.to_python( pmt.dict_ref(msg_in, pmt.intern('soft_dec'), pmt.PMT_NIL)) symb, constellation_idx, do_continue, save_soft_dec = self._obj.get_next_frame( symbols) if do_continue and len(soft_dec) != 0: d = self._obj.decode_soft_dec(soft_dec) msg_out = pmt.make_dict() msg_out = pmt.dict_add(msg_out, pmt.intern('packet_len'), pmt.to_pmt(len(d))) d = np.array(d, dtype=np.float32) d[abs(d) == np.Inf] = 0 vv = pmt.to_pmt(d) msg = pmt.cons(msg_out, vv) self.message_port_pub(self._port_soft_dec, msg) ## TODO: publish the bits if success ##print('symb=', symb, symb['symb'], symb['scramble']) msg_out = pmt.make_dict() msg_out = pmt.dict_add(msg_out, pmt.intern('symb'), pmt.to_pmt(symb['symb'])) msg_out = pmt.dict_add(msg_out, pmt.intern('scramble'), pmt.to_pmt(symb['scramble'])) msg_out = pmt.dict_add(msg_out, pmt.intern('constellation_idx'), pmt.to_pmt(constellation_idx)) msg_out = pmt.dict_add(msg_out, pmt.intern('do_continue'), pmt.to_pmt(np.bool(do_continue))) msg_out = pmt.dict_add(msg_out, pmt.intern('save_soft_dec'), pmt.to_pmt(np.bool(save_soft_dec))) ## print(msg_out) self.message_port_pub(self._port_frame_info, msg_out)
def test_from_pam(self): self.emitter = pdu_utils.message_emitter() #self.flip = pdu_utils.pdu_binary_tools(pdu_utils.pdu_binary_tools.FROM_PAM) self.flip = pdu_utils.pdu_binary_tools(2) self.debug = blocks.message_debug() self.tb.msg_connect((self.emitter, 'msg'), (self.flip, 'pdu_in')) self.tb.msg_connect((self.flip, 'pdu_out'), (self.debug, 'store')) i_vec = pmt.init_f32vector(6, [1, -1, -1, 1, -1, 1]) e_vec = pmt.init_u8vector(6, [1, 0, 0, 1, 0, 1]) in_pdu = pmt.cons(pmt.make_dict(), i_vec) e_pdu = pmt.cons(pmt.make_dict(), e_vec) self.tb.start() time.sleep(.001) self.emitter.emit(in_pdu) time.sleep(.01) self.tb.stop() self.tb.wait() print "test from_pam:" print "pdu expected: " + repr(pmt.car(e_pdu)) print "pdu got: " + repr(pmt.car(self.debug.get_message(0))) print "data expected: " + repr(pmt.u8vector_elements(pmt.cdr(e_pdu))) print "data got: " + repr( pmt.u8vector_elements(pmt.cdr(self.debug.get_message(0)))) print self.assertTrue(pmt.equal(self.debug.get_message(0), e_pdu))
def test_006_f32(self): ''' float input data, complicated input, decimation, and filtering ''' taps = [ -0.1, -0.2, -0.3, 0., 0.8, 1.4, 0.7, -1.9, -4.5, -3.8, 2.9, 14.4, 25.5, 30.1, 30.1, 25.5, 14.4, 2.9, -3.8, -4.5, -1.9, 0.7, 1.4, 0.8, 0., -0.3, -0.2, -0.1 ] print(len(taps)) self.dut = pdu_utils.pdu_fir_filter(4, taps) self.connectUp() i_data = [ 0., 0.25, 0.48, 0.68, 0.84, 0.95, 1., 0.98, 0.91, 0.78, 0.6, 0.38, 0.14, -0.11, -0.35, -0.57, -0.76, -0.89, -0.98, -1., -0.96, -0.86, -0.71, -0.51, -0.28, -0.03, 0.22, 0.45, 0.66, 0.82, 0.94, 0.99, 0.99, 0.92, 0.8, 0.62, 0.41, 0.17, -0.08, -0.32, -0.54, -0.73, -0.88, -0.97, -1., -0.97, -0.88, -0.73, -0.54, -0.31, -0.07, 0.18, 0.42, 0.63, 0.8, 0.93, 0.99, 0.99, 0.93, 0.82, 0.65, 0.44, 0.21, -0.04, -0.29, -0.52, -0.71, -0.86, -0.96, -1., -0.98, -0.89 ] i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_double(40e3)) i_meta = pmt.dict_add(i_meta, pmt.intern("start_time"), pmt.from_double(65.4321)) in_pdu = pmt.cons(i_meta, pmt.init_f32vector(len(i_data), i_data)) e_data = [ 8.344998, 95.737, 121.949005, 33.454994, -85.351006, -126.05898, -50.684998, 71.381004, 127.386, 66.26399, -55.451004, -126.658005, -81.652, 38.550003, 123.046005, 94.08399, -19.649996, -123.254005 ] e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_double(10e3)) e_meta = pmt.dict_add(e_meta, pmt.intern("start_time"), pmt.from_double(65.432050)) e_pdu = pmt.cons(e_meta, pmt.init_f32vector(len(e_data), e_data)) self.tb.start() time.sleep(.01) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() #print("test_005:") #print("pdu expected: " + repr(pmt.car(e_pdu))) #print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) #print("data expected: " + repr(pmt.to_python(pmt.cdr(e_pdu)))) #print("data got: " + repr(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) #print self.assertTrue(pmt.equal(pmt.car(self.debug.get_message(0)), e_meta)) v_diff = np.abs( pmt.f32vector_elements(pmt.cdr(self.debug.get_message(0))) - np.array(e_data)) / e_data print("Maximum error is", np.max(v_diff)) self.assertTrue(np.max(v_diff) < 0.0001)
def test_005_c32(self): ''' complex input data, no decimation, even number of taps ''' self.dut = pdu_utils.pdu_fir_filter(1, [.2] * 6) self.connectUp() i_data = [ 1, ] * 10 i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_double(100.0)) i_meta = pmt.dict_add(i_meta, pmt.intern("start_time"), pmt.from_double(9.9)) in_pdu = pmt.cons(i_meta, pmt.init_c32vector(len(i_data), i_data)) e_data = [ .6, .8, 1, ] + [ 1.2, ] * 5 + [1, .8, .6] e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"), pmt.from_double(100.0)) e_meta = pmt.dict_add(e_meta, pmt.intern("start_time"), pmt.from_double(9.895)) e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data)) self.tb.start() time.sleep(.01) self.emitter.emit(in_pdu) time.sleep(.1) self.tb.stop() self.tb.wait() #print("test_005:") #print("pdu expected: " + repr(pmt.car(e_pdu))) #print("pdu got: " + repr(pmt.car(self.debug.get_message(0)))) #print("data expected: " + repr(pmt.to_python(pmt.cdr(e_pdu)))) #print("data got: " + repr(pmt.to_python(pmt.cdr(self.debug.get_message(0))))) #print self.assertTrue(pmt.equal(pmt.car(self.debug.get_message(0)), e_meta)) v_diff = np.abs( pmt.c32vector_elements(pmt.cdr(self.debug.get_message(0))) - np.array(e_data)) / np.abs(e_data) print("Maximum error is", np.max(v_diff)) self.assertTrue(np.max(v_diff) < 0.00001)
def set_value(self, value, conversion = pmt.from_double ): """ When the set_value(value) method is called, sends a message containing a PMT dict {key, value} """ pmt_val = conversion(value) pmt_dict = pmt.make_dict() pmt_dict = pmt.dict_add(pmt_dict, self._key, pmt_val) self.message_port_pub(self._out_port, pmt_dict)
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 pdu_arg_add(pdu, k, v): meta = pmt.car(pdu); data = pmt.cdr(pdu); if(pmt.is_null(meta)): meta = pmt.make_dict(); assert(pmt.is_dict(meta)); meta = pmt.dict_add(meta, k, v); return pmt.cons(meta,data);
def work(self, input_items, output_items): tensordata = [] input_i = [] shapev = np.array(input_items[0]).shape for item in range(shapev[0]): inp = np.array(input_items[0][item]) if self.dtype == np.complex64: # complex data must be split into real # and imaginary floats for the ANN tensordata.append(np.array([[inp.real,inp.imag]])) elif self.dtype == np.float32: if np.mean(inp) == 0.0: return len(input_items[0]) ## Normalise data inp = (inp - np.mean(inp)) / np.std(inp) ## Reshape data as specified if not self.reshape == (): floats = np.reshape(inp,self.reshape) else: floats = inp tensordata.append(np.array([floats])) ne = [] for v in tensordata: try: #print("In: ",self.inp,"Out : ",self.out) #print("Inp ",v) outp = self.sess.run(self.out, feed_dict={self.inp: [v]})[0] #print("OUTP ",outp) ne.append(outp) except tf.errors.InvalidArgumentError: print("Invalid size of input vector to TensorFlow model") quit() pmtv = pmt.make_dict() for outp in ne: pmtv = pmt.make_tuple(pmt.to_pmt(("signal",self.signum)),pmt.to_pmt((self.classes[np.argmax(outp)],outp[np.argmax(outp)].item()))) self.message_port_pub(pmt.intern("classification"), pmtv) return len(input_items[0])
def test19(self): max_key = pmt.intern("MAX") _max = pmt.from_long(self.MAXINT32) min_key = pmt.intern("MIN") _min = pmt.from_long(self.MININT32) d = pmt.make_dict() d = pmt.dict_add(d, max_key, _max) d = pmt.dict_add(d, min_key, _min) s = pmt.serialize_str(d) deser = pmt.deserialize_str(s) self.assertTrue(pmt.equal(d, deser)) p_dict = pmt.to_python(deser) self.assertEqual(self.MAXINT32, p_dict["MAX"]) self.assertEqual(self.MININT32, p_dict["MIN"])
def nmea_parser_core(self, nmea_str): fixobj = pynmea2.parse(nmea_str) nmea_id = fixobj.sentence_type if nmea_id not in ['GGA', 'GLL', 'RMC', 'VTG']: raise AttributeError("Unparsed Sentence") D = pmt.make_dict() D = PMT_ADD(D, PSTR("id"), PSTR(nmea_id)) D = PMT_ADD(D, PSTR("protocol"), PSTR('nmea')) D = PMT_ADD(D, PSTR("host_time"), PSTR(str(self.host_time))) try: self.valid = fixobj.is_valid D = PMT_ADD(D, PSTR("valid"), pmt.from_bool(self.valid)) except AttributeError: pass # not all sentences carry validity try: D = PMT_ADD(D, PSTR("latitude"), PDBL(fixobj.latitude)) D = PMT_ADD(D, PSTR("longitude"), PDBL(fixobj.longitude)) except AttributeError: pass try: if fixobj.altitude is not None: D = PMT_ADD(D, PSTR("altitude"), PDBL(fixobj.altitude)) except AttributeError: pass try: D = PMT_ADD(D, PSTR("track"), PDBL(fixobj.true_track)) except AttributeError: pass try: if fixobj.spd_over_grnd_kmph is not None: D = PMT_ADD(D, PSTR("speed"), PDBL(fixobj.spd_over_grnd_kmph)) except AttributeError: pass try: self.nmea_time = dt.combine(fixobj.datestamp, fixobj.timestamp) D = PMT_ADD(D, PSTR("gps_time"), PSTR(str(self.nmea_time))) except AttributeError: pass # Send the message if D: self.message_port_pub(pmt.intern('gps_msg'), pmt.cons(D, pmt.PMT_NIL))
def run(self): while True: self.pcap = PcapReader(self.f) self.lasttime = 0; for p in self.pcap: if(not (self.lasttime == 0)): diff = (p.time - self.lasttime) time.sleep(diff*self.time_scale); self.lasttime = p.time if(self.done): return v = pmt.to_pmt(numpy.fromstring(str(p), dtype=numpy.uint8)) meta = pmt.make_dict(); self.message_port_pub(pmt.intern("pdus"), pmt.cons(meta, v));
def gpsd_parser_core(self, gpsd_str): G = json.loads(gpsd_str) if 'TPV' not in G['class']: return D = pmt.make_dict() D = PMT_ADD(D, PSTR("id"), PSTR(str(G['tag']))) D = PMT_ADD(D, PSTR("protocol"), PSTR('gpsd')) D = PMT_ADD(D, PSTR("host_time"), PSTR(str(self.host_time))) D = PMT_ADD(D, PSTR("gps_time"), PSTR(str(G['time']))) D = PMT_ADD(D, PSTR("longitude"), PDBL(G['lon'])) D = PMT_ADD(D, PSTR("latitude"), PDBL(G['lat'])) D = PMT_ADD(D, PSTR("altitude"), PDBL(G['alt'])) D = PMT_ADD(D, PSTR("speed"), PDBL(G['speed'])) D = PMT_ADD(D, PSTR("track"), PDBL(G['track'])) self.message_port_pub(pmt.intern('gps_msg'), pmt.cons(D, pmt.PMT_NIL))
def test_001_t (self): # set up fg msg_meta = pmt.make_dict() msg_meta = pmt.dict_add(msg_meta, pmt.to_pmt("freq"), pmt.to_pmt("val")) vec1 = [0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00]; msg_vector = pmt.init_u8vector(len(vec1), vec1) msg = pmt.cons(msg_meta, msg_vector) src = blocks.message_strobe(msg, 10) dut = capture_tools.bit_sniffer(fade_out=500, hexadecimal=True) self.tb.msg_connect((src, "strobe"), (dut, "packets")) self.tb.start () time.sleep(5) vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00]; msg_vector = pmt.init_u8vector(len(vec1), vec1) msg = pmt.cons(msg_meta, msg_vector) src.set_msg(msg); time.sleep(5) vec1 = [0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x01]; msg_vector = pmt.init_u8vector(len(vec1), vec1) msg = pmt.cons(msg_meta, msg_vector) src.set_msg(msg); time.sleep(5) self.tb.stop()
def rx_handler(self, msg): meta = pmt.car(msg); data_in = array.array('B', pmt.u8vector_elements(pmt.cdr(msg))) data_list = data_in.tolist(); if data_list[0:8] == self.operations["data"]: self.rx_cnt = self.rx_cnt + 1; seq = struct.unpack("<i", self.pack_bits(data_list[8:8+32]))[0]; #print "rx sequence: %d"%(seq); # send ACK bak self.send_ack(seq); # pass along sequence number for fun if(pmt.is_null(meta)): meta = pmt.make_dict(); meta = pmt.dict_add(meta, pmt.intern("arq_seq"), pmt.from_long(seq)); if(self.rx_record.has_key(seq)): print "duplicate recieve data pkt seq! %d"%(seq) return; self.rx_record[seq] = time.time(); # send payload to next layer data_upper = data_list[8+32:]; self.message_port_pub(pmt.intern("rx_out"), pmt.cons(meta,pmt.init_u8vector(len(data_upper),data_upper))); return; if data_list[0:8] == self.operations["ack"]: self.ack_rx_cnt = self.ack_rx_cnt + 1; # set pkt ack'd locally seq = struct.unpack("<i", self.pack_bits(data_list[8:8+32]))[0]; print "got pkt ack (%d)"%(seq) self.ack(seq); return; # fall through fail print "got invalid ARQ header, discarding!"
def test01(self): a = pmt.intern("a") b = pmt.from_double(123765) d1 = pmt.make_dict() d2 = pmt.dict_add(d1, a, b) print d2
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.scroll = scroll = False self.samp_rate = samp_rate = 32000 self.offset = offset = 0 self.hex_output = hex_output = False self.bits_per_word = bits_per_word = 8 self.binary_output = binary_output = True self.ascii_output = ascii_output = False ################################################## # Blocks ################################################## _scroll_check_box = Qt.QCheckBox("scroll") self._scroll_choices = {True: True, False: False} self._scroll_choices_inv = dict((v,k) for k,v in self._scroll_choices.iteritems()) self._scroll_callback = lambda i: Qt.QMetaObject.invokeMethod(_scroll_check_box, "setChecked", Qt.Q_ARG("bool", self._scroll_choices_inv[i])) self._scroll_callback(self.scroll) _scroll_check_box.stateChanged.connect(lambda i: self.set_scroll(self._scroll_choices[bool(i)])) self.top_layout.addWidget(_scroll_check_box) self._offset_range = Range(0, 7, 1, 0, 200) self._offset_win = RangeWidget(self._offset_range, self.set_offset, "offset", "counter_slider", int) self.top_layout.addWidget(self._offset_win) _hex_output_check_box = Qt.QCheckBox("hex_output") self._hex_output_choices = {True: True, False: False} self._hex_output_choices_inv = dict((v,k) for k,v in self._hex_output_choices.iteritems()) self._hex_output_callback = lambda i: Qt.QMetaObject.invokeMethod(_hex_output_check_box, "setChecked", Qt.Q_ARG("bool", self._hex_output_choices_inv[i])) self._hex_output_callback(self.hex_output) _hex_output_check_box.stateChanged.connect(lambda i: self.set_hex_output(self._hex_output_choices[bool(i)])) self.top_layout.addWidget(_hex_output_check_box) self._bits_per_word_range = Range(2, 8, 1, 8, 200) self._bits_per_word_win = RangeWidget(self._bits_per_word_range, self.set_bits_per_word, "bits_per_word", "counter_slider", int) self.top_layout.addWidget(self._bits_per_word_win) _binary_output_check_box = Qt.QCheckBox("binary_output") self._binary_output_choices = {True: True, False: False} self._binary_output_choices_inv = dict((v,k) for k,v in self._binary_output_choices.iteritems()) self._binary_output_callback = lambda i: Qt.QMetaObject.invokeMethod(_binary_output_check_box, "setChecked", Qt.Q_ARG("bool", self._binary_output_choices_inv[i])) self._binary_output_callback(self.binary_output) _binary_output_check_box.stateChanged.connect(lambda i: self.set_binary_output(self._binary_output_choices[bool(i)])) self.top_layout.addWidget(_binary_output_check_box) _ascii_output_check_box = Qt.QCheckBox("ascii_output") self._ascii_output_choices = {True: True, False: False} self._ascii_output_choices_inv = dict((v,k) for k,v in self._ascii_output_choices.iteritems()) self._ascii_output_callback = lambda i: Qt.QMetaObject.invokeMethod(_ascii_output_check_box, "setChecked", Qt.Q_ARG("bool", self._ascii_output_choices_inv[i])) self._ascii_output_callback(self.ascii_output) _ascii_output_check_box.stateChanged.connect(lambda i: self.set_ascii_output(self._ascii_output_choices[bool(i)])) self.top_layout.addWidget(_ascii_output_check_box) self.capture_tools_bit_sniffer_0 = capture_tools.bit_sniffer(200, hex_output, offset, bits_per_word, False, False, ascii_output, binary_output, 0, scroll) msg_meta = pmt.make_dict() msg_meta = pmt.dict_add(msg_meta, pmt.to_pmt("freq"), pmt.to_pmt("val")) vec1 = [0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00]; msg_vector = pmt.init_u8vector(len(vec1), vec1) msg = pmt.cons(msg_meta, msg_vector) self.blocks_message_strobe_0 = blocks.message_strobe(msg, 10) ################################################## # Connections ################################################## self.msg_connect((self.blocks_message_strobe_0, 'strobe'), (self.capture_tools_bit_sniffer_0, 'packets'))
def make_header(options, filename): extras_present = False if options.freq is not None: extras_present = True # Open the file and make the header hdr_filename = filename + '.hdr' hdr_file = open(hdr_filename, 'wb') header = pmt.make_dict() # Fill in header vals # TODO - Read this from blocks.METADATA_VERSION ver_val = pmt.from_long(long(0)) rate_val = pmt.from_double(options.sample_rate) time_val = pmt.make_tuple(pmt.from_uint64(options.time_sec), pmt.from_double(options.time_fsec)) ft_to_sz = parse_file_metadata.ftype_to_size # Map shortname to properties enum_type = SNAME_TO_ENUM[options.format] type_props = SNAME_DEFS[enum_type] size_val = pmt.from_long(type_props[0]) cplx_val = pmt.from_bool(type_props[1]) type_val = pmt.from_long(type_props[2]) fmt = type_props[2] file_samp_len = long(options.length) seg_size = long(options.seg_size) bytes_val = pmt.from_uint64(long(seg_size*ft_to_sz[fmt])) # Set header vals header = pmt.dict_add(header, pmt.intern("version"), ver_val) header = pmt.dict_add(header, pmt.intern("size"), size_val) header = pmt.dict_add(header, pmt.intern("type"), type_val) header = pmt.dict_add(header, pmt.intern("cplx"), cplx_val) header = pmt.dict_add(header, pmt.intern("rx_time"), time_val) header = pmt.dict_add(header, pmt.intern("rx_rate"), rate_val) header = pmt.dict_add(header, pmt.intern("bytes"), bytes_val) if extras_present: freq_key = pmt.intern("rx_freq") freq_val = pmt.from_double(options.freq) extras = pmt.make_dict() extras = pmt.dict_add(extras, freq_key, freq_val) extras_str = pmt.serialize_str(extras) start_val = pmt.from_uint64(blocks.METADATA_HEADER_SIZE + len(extras_str)) else: start_val = pmt.from_uint64(blocks.METADATA_HEADER_SIZE) header = pmt.dict_add(header, pmt.intern("strt"), start_val) num_segments = file_samp_len/seg_size if options.verbose: print "Wrote %d headers to: %s (Version %d)" % (num_segments+1, hdr_filename,pmt.to_long(ver_val)) for x in range(0,num_segments,1): # Serialize and write out file if extras_present: header_str = pmt.serialize_str(header) + extras_str else: header_str = pmt.serialize_str(header) hdr_file.write(header_str) # Update header based on sample rate and segment size header = update_timestamp(header,seg_size) # Last header is special b/c file size is probably not mult. of seg_size header = pmt.dict_delete(header,pmt.intern("bytes")) bytes_remaining = ft_to_sz[fmt]*(file_samp_len - num_segments*long(seg_size)) bytes_val = pmt.from_uint64(bytes_remaining) header = pmt.dict_add(header,pmt.intern("bytes"),bytes_val) # Serialize and write out file if extras_present: header_str = pmt.serialize_str(header) + extras_str else: header_str = pmt.serialize_str(header) hdr_file.write(header_str) hdr_file.close()
def post_message(self): msg_dict = pmt.make_dict() msg_dict = pmt.dict_add(msg_dict, pmt.intern("scenario_number"), pmt.from_long(long(self.scenario))) msg_dict = pmt.dict_add(msg_dict, pmt.intern("scenario_channels"), pmt.to_pmt([bool(c) for c in self.chan_occupied])) msg_dict = pmt.dict_add(msg_dict, pmt.intern("scenario_tau"), pmt.from_long(long(self.scenario_send_window[self.scenario]))) self.message_port_pub(pmt.intern("scenario"), msg_dict)
def test_001(self): N = 1000 outfile = "test_out.dat" detached = False samp_rate = 200000 key = pmt.intern("samp_rate") val = pmt.from_double(samp_rate) extras = pmt.make_dict() extras = pmt.dict_add(extras, key, val) extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) src = blocks.vector_source_c(data) fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile, samp_rate, 1, blocks.GR_FILE_FLOAT, True, 1000000, extras_str, detached) fsnk.set_unbuffered(True) self.tb.connect(src, fsnk) self.tb.run() fsnk.close() handle = open(outfile, "rb") header_str = handle.read(parse_file_metadata.HEADER_LENGTH) if(len(header_str) == 0): self.assertFalse() try: header = pmt.deserialize_str(header_str) except RuntimeError: self.assertFalse() info = parse_file_metadata.parse_header(header, False) extra_str = handle.read(info["extra_len"]) self.assertEqual(len(extra_str) > 0, True) handle.close() try: extra = pmt.deserialize_str(extra_str) except RuntimeError: self.assertFalse() extra_info = parse_file_metadata.parse_extra_dict(extra, info, False) self.assertEqual(info['rx_rate'], samp_rate) self.assertEqual(pmt.to_double(extra_info['samp_rate']), samp_rate) # Test file metadata source src.rewind() fsrc = blocks.file_meta_source(outfile, False) vsnk = blocks.vector_sink_c() tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA") ssnk = blocks.vector_sink_c() self.tb.disconnect(src, fsnk) self.tb.connect(fsrc, vsnk) self.tb.connect(fsrc, tsnk) self.tb.connect(src, ssnk) self.tb.run() fsrc.close() # Test to make sure tags with 'samp_rate' and 'rx_rate' keys # were generated and received correctly. tags = tsnk.current_tags() for t in tags: if(pmt.eq(t.key, pmt.intern("samp_rate"))): self.assertEqual(pmt.to_double(t.value), samp_rate) elif(pmt.eq(t.key, pmt.intern("rx_rate"))): self.assertEqual(pmt.to_double(t.value), samp_rate) # Test that the data portion was extracted and received correctly. self.assertComplexTuplesAlmostEqual(vsnk.data(), ssnk.data(), 5) os.remove(outfile)