Пример #1
0
    def test_003_basic_tail(self):

        self.dut = pdu_utils.pdu_preamble([], [1, 0, 1, 0], 1, 0, False)
        self.connectUp()

        input_data = [1, 1, 0, 0, 1, 1, 0, 0]
        input_dict = pmt.dict_add(pmt.make_dict(), pmt.intern("KEY"), pmt.intern("VALUE"))
        input_pdu = pmt.cons(input_dict, pmt.init_u8vector(len(input_data), input_data))

        expected_data = [1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0]
        expected_dict = pmt.dict_add(pmt.make_dict(), pmt.intern("KEY"), pmt.intern("VALUE"))
        expected_pdu = pmt.cons(expected_dict, pmt.init_f32vector(len(expected_data), expected_data))

        self.tb.start()
        time.sleep(.001)
        self.emitter.emit(input_pdu)
        time.sleep(.01)
        self.tb.stop()
        self.tb.wait()

        self.assertEqual(1, self.debug.num_messages())

        print("test_003_basic_tail:")
        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))
Пример #2
0
    def test_001_basic_nrz_test(self):
        emitter = pdu_utils.message_emitter()
        preamble = pdu_utils.pdu_preamble([0, 1, 0, 1], [], 2, 3, True)
        debug = blocks.message_debug()
        self.tb.msg_connect((emitter, 'msg'), (preamble, 'pdu_in'))
        self.tb.msg_connect((preamble, 'pdu_out'), (debug, 'store'))

        input_data = pmt.init_u8vector(8, [1, 0, 1, 1, 0, 0, 1, 0])
        input_dict = pmt.dict_add(pmt.make_dict(), pmt.intern("KEY"),
                                  pmt.intern("VALUE"))
        expected_data = pmt.init_f32vector((8 + 4 + 0) * 2 + 3 * 2, [
            0, 0, 0, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1,
            -1, -1, -1, 1, 1, -1, -1, 0, 0, 0
        ])
        self.tb.start()
        time.sleep(.001)
        emitter.emit(pmt.intern("MALFORMED PDU"))
        time.sleep(.001)
        emitter.emit(pmt.cons(input_dict, input_data))
        time.sleep(.01)
        self.tb.stop()
        self.tb.wait()
        output_data = pmt.cdr(debug.get_message(0))

        self.assertEquals(1, debug.num_messages())
        self.assertTrue((pmt.f32vector_elements(expected_data) ==
                         pmt.f32vector_elements(output_data)))
Пример #3
0
 def setUp(self):
     self.tb = gr.top_block()
     self.emitter = pdu_utils.message_emitter()
     self.emitter2 = pdu_utils.message_emitter()
     self.pre = pdu_utils.pdu_preamble([], [], 8, 20, True)
     self.gmsk = pdu_utils.pdu_gmsk_fc(0.5, firdes.gaussian(1, 4, 0.35, 9))
     self.debug = blocks.message_debug()
     self.tb.msg_connect((self.emitter, 'msg'), (self.pre, 'pdu_in'))
     self.tb.msg_connect((self.emitter2, 'msg'), (self.gmsk, 'pdu_in'))
     self.tb.msg_connect((self.pre, 'pdu_out'), (self.gmsk, 'pdu_in'))
     self.tb.msg_connect((self.gmsk, 'pdu_out'), (self.debug, 'store'))