コード例 #1
0
ファイル: qa_ber_bf.py プロジェクト: LUMERIIX/cs436-gnuradio
    def test_002(self):
        # Cause 8 bit errors out of 8*N bits
        # using test mode

        mode = True
        N = 1000
        data0 = numpy.random.randint(0, 256, N).tolist()
        data1 = copy.deepcopy(data0)
        data1[0] ^= 0xFF

        src0 = blocks.vector_source_b(data0)
        src1 = blocks.vector_source_b(data1)
        op = fec.ber_bf(mode, 1, -2.0)
        dst = blocks.vector_sink_f()

        self.tb.connect(src0, (op, 0))
        self.tb.connect(src1, (op, 1))
        self.tb.connect(op, dst)
        self.tb.run()

        data = dst.data()
        expected_result = [
            numpy.log10(8.0 / (8.0 * N)),
        ]

        self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
コード例 #2
0
ファイル: qa_ber_bf.py プロジェクト: deactivated/gnuradio
    def test_003(self):
        # Cause a 8 bit errors out of 8*N bits
        # using test mode
        # Exit if BER < -2.0

        mode = True
        N = 1000
        data0 = numpy.random.randint(0, 256, N).tolist()
        data1 = copy.deepcopy(data0)
        data1[0] ^= 0xFF

        src0 = blocks.vector_source_b(data0)
        src1 = blocks.vector_source_b(data1)
        op = fec.ber_bf(mode, 10, -2.0)
        dst = blocks.vector_sink_f()

        self.tb.connect(src0, (op, 0))
        self.tb.connect(src1, (op, 1))
        self.tb.connect(op, dst)
        self.tb.run()

        data = dst.data()
        expected_result = [-2.0]

        print data
        print expected_result

        self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
コード例 #3
0
 def test_027a_internally_unconnected_input(self):
     tb = gr.top_block()
     hb = gr.hier_block2("block",
                         gr.io_signature(1, 1, 1),
                         gr.io_signature(1, 1, 1))
     hsrc = blocks.vector_source_b([1,])
     hb.connect(hsrc, hb) # wire output internally
     src = blocks.vector_source_b([1, ])
     dst = blocks.vector_sink_b()
     tb.connect(src, hb, dst) # hb's input is not connected internally
     self.assertRaises(RuntimeError,
                       lambda: tb.run())
コード例 #4
0
    def test_1(self):
        datas = (
            0, 1, 2,  5, 6,     10,          14, 15, 16,
            3, 4,     7, 8, 9,  11, 12, 13,  17
        )
        expected = tuple(range(18))

        tagname = "packet_length"
        len_tags_0 = (
            make_len_tag(0, tagname, 3),
            make_len_tag(3, tagname, 2),
            make_len_tag(5, tagname, 1),
            make_len_tag(6, tagname, 3)
        )
        len_tags_1 = (
            make_len_tag(0, tagname, 2),
            make_len_tag(2, tagname, 3),
            make_len_tag(5, tagname, 3),
            make_len_tag(8, tagname, 1)
        )
        test_tag_0 = gr.tag_t()
        test_tag_0.key = pmt.string_to_symbol('spam')
        test_tag_0.offset = 4 # On the second '1'
        test_tag_0.value = pmt.to_pmt(42)
        test_tag_1 = gr.tag_t()
        test_tag_1.key = pmt.string_to_symbol('eggs')
        test_tag_1.offset = 3 # On the first '3' of the 2nd stream
        test_tag_1.value = pmt.to_pmt(23)

        src0 = blocks.vector_source_b(datas[0:9], False, 1, len_tags_0 + (test_tag_0,))
        src1 = blocks.vector_source_b(datas[9:],  False, 1, len_tags_1 + (test_tag_1,))
        tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, tagname)
        snk = blocks.vector_sink_b()
        self.tb.connect(src0, (tagged_stream_mux, 0))
        self.tb.connect(src1, (tagged_stream_mux, 1))
        self.tb.connect(tagged_stream_mux, snk)
        self.tb.run()

        self.assertEqual(expected, snk.data())

        tags = [gr.tag_to_python(x) for x in snk.tags()]
        tags = sorted([(x.offset, x.key, x.value) for x in tags])
        tags_expected = [
                (0, 'packet_length', 5),
                (5, 'packet_length', 5),
                (6, 'spam', 42),
                (8, 'eggs', 23),
                (10, 'packet_length', 4),
                (14, 'packet_length', 4)
        ]
        self.assertEqual(tags, tags_expected)
コード例 #5
0
 def test_027a_internally_unconnected_input(self):
     tb = gr.top_block()
     hb = gr.hier_block2("block", gr.io_signature(1, 1, 1),
                         gr.io_signature(1, 1, 1))
     hsrc = blocks.vector_source_b([
         1,
     ])
     hb.connect(hsrc, hb)  # wire output internally
     src = blocks.vector_source_b([
         1,
     ])
     dst = blocks.vector_sink_b()
     tb.connect(src, hb, dst)  # hb's input is not connected internally
     self.assertRaises(RuntimeError, lambda: tb.run())
コード例 #6
0
    def helper(self, v0, v1, fft_length, preamble):
        tb = self.tb
        src0 = blocks.vector_source_c(v0)
        src1 = blocks.vector_source_b(v1)

        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length)

        # print "len(v) = %d" % (len(v))

        op = digital.ofdm_insert_preamble(fft_length, preamble)

        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_length)
        dst0 = blocks.vector_sink_c()
        dst1 = blocks.vector_sink_b()

        tb.connect(src0, s2v, (op, 0))
        tb.connect(src1, (op, 1))
        tb.connect((op, 0), v2s, dst0)
        tb.connect((op, 1), dst1)

        tb.run()
        r0 = dst0.data()
        r0v = []
        for i in range(len(r0) // fft_length):
            r0v.append(r0[i * fft_length:(i + 1) * fft_length])

        r1 = dst1.data()
        self.assertEqual(len(r0v), len(r1))
        return (r1, r0v)
コード例 #7
0
    def helper(self, v0, v1, fft_length, preamble):
        tb = self.tb
        src0 = blocks.vector_source_c(v0)
        src1 = blocks.vector_source_b(v1)
        
        s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length)

        # print "len(v) = %d" % (len(v))

        op = digital.ofdm_insert_preamble(fft_length, preamble)

        v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_length)
        dst0 = blocks.vector_sink_c()
        dst1 = blocks.vector_sink_b()

        tb.connect(src0, s2v, (op, 0))
        tb.connect(src1, (op, 1))
        tb.connect((op, 0), v2s, dst0)
        tb.connect((op, 1), dst1)

        tb.run()
        r0 = dst0.data()
        r0v = []
        for i in range(len(r0)//fft_length):
            r0v.append(r0[i*fft_length:(i+1)*fft_length])
            
        r1 = dst1.data()
        self.assertEqual(len(r0v), len(r1))
        return (r1, r0v)
コード例 #8
0
ファイル: qa_puncture.py プロジェクト: 0x7678/gnuradio-wg-grc
    def test_003(self):
        # Test scenario where we have defined a puncture pattern with
        # more bits than the puncsize with a delay. The python code
        # doesn't account for this when creating self.expected, but
        # this should be equivalent to a puncpat of the correct size.

        self.puncsize = 4
        self.puncpat0 = 0x5555 # too many bits set
        self.puncpat1 = 0x55   # num bits = puncsize
        self.delay = 1

        src = blocks.vector_source_b(self.src_data)
	op0  = fec.puncture_bb(self.puncsize, self.puncpat0, self.delay)
	op1  = fec.puncture_bb(self.puncsize, self.puncpat1, self.delay)
	dst0 = blocks.vector_sink_b()
	dst1 = blocks.vector_sink_b()

	self.tb.connect(src, op0, dst0)
	self.tb.connect(src, op1, dst1)
	self.tb.run()

	dst_data0 = list(dst0.data())
        for i in xrange(len(dst_data0)):
            dst_data0[i] = int(dst_data0[i])

	dst_data1 = list(dst1.data())
        for i in xrange(len(dst_data1)):
            dst_data1[i] = int(dst_data1[i])

        self.assertEqual(dst_data1, dst_data0)
コード例 #9
0
    def test_004(self):
        # Test normal operation of the depuncture block without
        # specifying the fill symbol (defaults to 127).

        self.puncsize = 8
        self.puncpat = 0xEF
        self.delay = 0
        self.sym = 127
        self.puncholes = 1

        self.depuncture_setup()

        src = blocks.vector_source_b(self.src_data)
	op  = fec.depuncture_bb(self.puncsize, self.puncpat,
                                self.delay)
	dst = blocks.vector_sink_b()

	self.tb.connect(src, op, dst)
	self.tb.run()

	dst_data = list(dst.data())
        for i in xrange(len(dst_data)):
            dst_data[i] = int(dst_data[i])

        self.assertEqual(self.expected, dst_data)
コード例 #10
0
    def test_002(self):
        # Test scenario where we have defined a puncture pattern with
        # more bits than the puncsize.

        self.puncsize = 4
        self.puncpat = 0x5555
        self.delay = 0
        self.sym = 0
        self.puncholes = 2

        self.depuncture_setup()

        src = blocks.vector_source_b(self.src_data)
	op  = fec.depuncture_bb(self.puncsize, self.puncpat,
                                self.delay, self.sym)
	dst = blocks.vector_sink_b()

	self.tb.connect(src, op, dst)
	self.tb.run()

	dst_data = list(dst.data())
        for i in xrange(len(dst_data)):
            dst_data[i] = int(dst_data[i])

        self.assertEqual(self.expected, dst_data)
コード例 #11
0
 def test_003_12bits_formatter_object (self):
     # 3 PDUs: |           |     |         |
     data   = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
     tagname = "packet_len"
     tag1 = gr.tag_t()
     tag1.offset = 0
     tag1.key = pmt.string_to_symbol(tagname)
     tag1.value = pmt.from_long(4)
     tag2 = gr.tag_t()
     tag2.offset = 4
     tag2.key = pmt.string_to_symbol(tagname)
     tag2.value = pmt.from_long(2)
     tag3 = gr.tag_t()
     tag3.offset = 6
     tag3.key = pmt.string_to_symbol(tagname)
     tag3.value = pmt.from_long(4)
     src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
     formatter_object = digital.packet_header_default(12, tagname)
     header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, header, sink)
     self.tb.run()
     expected_data = (
         0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
     )
     self.assertEqual(sink.data(), expected_data)
コード例 #12
0
 def test_002_32bits (self):
     # 3 PDUs: |           |     |         |
     data   = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
     tagname = "packet_len"
     tag1 = gr.tag_t()
     tag1.offset = 0
     tag1.key = pmt.string_to_symbol(tagname)
     tag1.value = pmt.from_long(4)
     tag2 = gr.tag_t()
     tag2.offset = 4
     tag2.key = pmt.string_to_symbol(tagname)
     tag2.value = pmt.from_long(2)
     tag3 = gr.tag_t()
     tag3.offset = 6
     tag3.key = pmt.string_to_symbol(tagname)
     tag3.value = pmt.from_long(4)
     src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
     header = digital.packet_headergenerator_bb(32, tagname)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, header, sink)
     self.tb.run()
     expected_data = (
         #   | Number of symbols                  | Packet number                                  | Parity
             0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  1, 0, 0, 0,
             0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
             0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0
     )
     self.assertEqual(sink.data(), expected_data)
コード例 #13
0
    def test_002(self):

        code = tuple(string_to_1_0_list(default_access_code))
        access_code = to_1_0_string(code)
        header = tuple(
            2 * [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0])  # len=2
        pad = (0, ) * 100
        src_data = code + header + (0, 1, 0, 0, 1, 0, 0, 0) + (0, 1, 0, 0, 1,
                                                               0, 0, 1) + pad
        expected_data = 'HI'

        rcvd_pktq = gr.msg_queue()

        src = blocks.vector_source_b(src_data)
        correlator = digital.correlate_access_code_bb(access_code, 0)
        framer_sink = digital.framer_sink_1(rcvd_pktq)
        vsnk = blocks.vector_sink_b()

        self.tb.connect(src, correlator, framer_sink)
        self.tb.connect(correlator, vsnk)
        self.tb.run()

        result_data = rcvd_pktq.delete_head()
        result_data = result_data.to_string()
        self.assertEqual(expected_data, result_data)
コード例 #14
0
    def test_regen2(self):
        tb = self.tb

        data = 200*[0,]
        data[9] = 1
        data[99] = 1

        expected_result = 200*[0,]
        expected_result[9]   = 1
        expected_result[19]  = 1
        expected_result[29]  = 1
        expected_result[39]  = 1

        expected_result[99]  = 1
        expected_result[109]  = 1
        expected_result[119]  = 1
        expected_result[129]  = 1

        src = blocks.vector_source_b(data, False)
        regen = blocks.regenerate_bb(10, 3)
        dst = blocks.vector_sink_b()

        tb.connect(src, regen)
        tb.connect(regen, dst)
        tb.run ()

        dst_data = dst.data()

        self.assertEqual(tuple(expected_result), dst_data)
コード例 #15
0
 def test_001_t (self):
     """
     First header: Packet length 4, packet num 0
     Second header: Packet 2, packet num 1
     Third header: Invalid (parity bit does not check) (would be len 4, num 2)
     """
     encoded_headers = (
         #   | Number of bytes                    | Packet number                                  | Parity
             0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  1, 0, 0, 0,
             0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0,
             0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,  0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  1, 0, 0, 0
     )
     packet_len_tagname = "packet_len"
     random_tag = gr.tag_t()
     random_tag.offset = 5
     random_tag.key = pmt.string_to_symbol("foo")
     random_tag.value = pmt.from_long(42)
     src = blocks.vector_source_b(encoded_headers, tags=(random_tag,))
     parser = digital.packet_headerparser_b(32, packet_len_tagname)
     sink = blocks.message_debug()
     self.tb.connect(src, parser)
     self.tb.msg_connect(parser, "header_data", sink, "store")
     self.tb.start()
     time.sleep(1)
     self.tb.stop()
     self.tb.wait()
     self.assertEqual(sink.num_messages(), 3)
     msg1 = pmt.to_python(sink.get_message(0))
     msg2 = pmt.to_python(sink.get_message(1))
     msg3 = pmt.to_python(sink.get_message(2))
     self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0, 'foo': 42})
     self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1})
     self.assertEqual(msg3, False)
コード例 #16
0
 def __init__(self, constellation, differential, data_length=None, src_data=None, freq_offset=True):
     """
     Args:
         constellation: a constellation object
         differential: whether differential encoding is used
         data_length: the number of bits of data to use
         src_data: a list of the bits to use
         freq_offset: whether to use a frequency offset in the channel
     """
     super(rec_test_tb, self).__init__()
     # Transmission Blocks
     if src_data is None:
         self.src_data = tuple([rndm.randint(0, 1) for i in range(0, data_length)])
     else:
         self.src_data = src_data
     packer = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
     src = blocks.vector_source_b(self.src_data)
     mod = generic_mod(constellation, differential=differential)
     # Channel
     if freq_offset:
         channel = channel_model(NOISE_VOLTAGE, FREQUENCY_OFFSET, TIMING_OFFSET)
     else:
         channel = channel_model(NOISE_VOLTAGE, 0, TIMING_OFFSET)
     # Receiver Blocks
     if freq_offset:
         demod = generic_demod(constellation, differential=differential, freq_bw=FREQ_BW, phase_bw=PHASE_BW)
     else:
         demod = generic_demod(constellation, differential=differential, freq_bw=0, phase_bw=0)
     self.dst = blocks.vector_sink_b()
     self.connect(src, packer, mod, channel, demod, self.dst)
コード例 #17
0
 def test_004_8bits_formatter_ofdm (self):
     occupied_carriers = ((1, 2, 3, 5, 6, 7),)
     # 3 PDUs: |           |     |         |
     data   = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
     tagname = "packet_len"
     tag1 = gr.tag_t()
     tag1.offset = 0
     tag1.key = pmt.string_to_symbol(tagname)
     tag1.value = pmt.from_long(4)
     tag2 = gr.tag_t()
     tag2.offset = 4
     tag2.key = pmt.string_to_symbol(tagname)
     tag2.value = pmt.from_long(2)
     tag3 = gr.tag_t()
     tag3.offset = 6
     tag3.key = pmt.string_to_symbol(tagname)
     tag3.value = pmt.from_long(4)
     src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
     formatter_object = digital.packet_header_ofdm(occupied_carriers, 1, tagname)
     self.assertEqual(formatter_object.header_len(), 6)
     self.assertEqual(pmt.symbol_to_string(formatter_object.len_tag_key()), tagname)
     header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, header, sink)
     self.tb.run()
     expected_data = (
         0, 0, 1, 0, 0, 0,
         0, 1, 0, 0, 0, 0,
         0, 0, 1, 0, 0, 0
     )
     self.assertEqual(sink.data(), expected_data)
コード例 #18
0
    def test_002(self):
        # Test scenario where we have defined a puncture pattern with
        # more bits than the puncsize.

        self.puncsize = 4
        self.puncpat = 0x5555
        self.delay = 0
        self.sym = 0
        self.puncholes = 2

        self.depuncture_setup()

        src = blocks.vector_source_b(self.src_data)
        op = fec.depuncture_bb(self.puncsize, self.puncpat, self.delay,
                               self.sym)
        dst = blocks.vector_sink_b()

        self.tb.connect(src, op, dst)
        self.tb.run()

        dst_data = list(dst.data())
        for i in xrange(len(dst_data)):
            dst_data[i] = int(dst_data[i])

        self.assertEqual(self.expected, dst_data)
コード例 #19
0
    def test_003(self):
        # Test scenario where we have defined a puncture pattern with
        # more bits than the puncsize with a delay. The python code
        # doesn't account for this when creating self.expected, but
        # this should be equivalent to a puncpat of the correct size.

        self.puncsize = 4
        self.puncpat0 = 0x5555  # too many bits set
        self.puncpat1 = 0x55  # num bits = puncsize
        self.delay = 1
        self.sym = 0

        src = blocks.vector_source_b(self.src_data)
        op0 = fec.depuncture_bb(self.puncsize, self.puncpat0, self.delay,
                                self.sym)
        op1 = fec.depuncture_bb(self.puncsize, self.puncpat1, self.delay,
                                self.sym)
        dst0 = blocks.vector_sink_b()
        dst1 = blocks.vector_sink_b()

        self.tb.connect(src, op0, dst0)
        self.tb.connect(src, op1, dst1)
        self.tb.run()

        dst_data0 = list(dst0.data())
        for i in xrange(len(dst_data0)):
            dst_data0[i] = int(dst_data0[i])

        dst_data1 = list(dst1.data())
        for i in xrange(len(dst_data1)):
            dst_data1[i] = int(dst_data1[i])

        self.assertEqual(dst_data1, dst_data0)
コード例 #20
0
 def test_004_ofdm_packets (self):
     """
     Send several bursts using ofdm_tx, see if the number of detects is correct.
     Burst lengths and content are random.
     """
     n_bursts = 42
     fft_len = 64
     cp_len = 16
     # Here, coarse freq offset is allowed
     max_freq_offset = 2*numpy.pi/fft_len * 4
     freq_offset = ((2 * random.random()) - 1) * max_freq_offset
     tx_signal = []
     packets = []
     tagname = "packet_length"
     min_packet_length = 10
     max_packet_length = 50
     sync_sequence = [random.randint(0, 1)*2-1 for x in range(fft_len/2)]
     for i in xrange(n_bursts):
         packet_length = random.randint(min_packet_length,
                                        max_packet_length+1)
         packet = [random.randint(0, 255) for i in range(packet_length)]
         packets.append(packet)
     data, tags = tagged_streams.packets_to_vectors(packets, tagname, vlen=1)
     total_length = len(data)
     src = blocks.vector_source_b(data, False, 1, tags)
     mod = ofdm_tx(packet_length_tag_key=tagname)
     sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len)
     sink_freq   = blocks.vector_sink_f()
     sink_detect = blocks.vector_sink_b()
     noise_level = 0.005
     channel = channels.channel_model(noise_level, freq_offset / 2 / numpy.pi)
     self.tb.connect(src, mod, channel, sync, sink_freq)
     self.tb.connect((sync, 1), sink_detect)
     self.tb.run()
     self.assertEqual(numpy.sum(sink_detect.data()), n_bursts)
コード例 #21
0
 def test_003_12bits_formatter_object(self):
     # 3 PDUs: |           |     |         |
     data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
     tagname = "packet_len"
     tag1 = gr.tag_t()
     tag1.offset = 0
     tag1.key = pmt.string_to_symbol(tagname)
     tag1.value = pmt.from_long(4)
     tag2 = gr.tag_t()
     tag2.offset = 4
     tag2.key = pmt.string_to_symbol(tagname)
     tag2.value = pmt.from_long(2)
     tag3 = gr.tag_t()
     tag3.offset = 6
     tag3.key = pmt.string_to_symbol(tagname)
     tag3.value = pmt.from_long(4)
     src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
     formatter_object = digital.packet_header_default(12, tagname)
     header = digital.packet_headergenerator_bb(
         formatter_object.formatter(), tagname)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, header, sink)
     self.tb.run()
     expected_data = (0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
     self.assertEqual(sink.data(), expected_data)
コード例 #22
0
 def test_004_8bits_formatter_ofdm(self):
     occupied_carriers = ((1, 2, 3, 5, 6, 7), )
     # 3 PDUs: |           |     |         |
     data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
     tagname = "packet_len"
     tag1 = gr.tag_t()
     tag1.offset = 0
     tag1.key = pmt.string_to_symbol(tagname)
     tag1.value = pmt.from_long(4)
     tag2 = gr.tag_t()
     tag2.offset = 4
     tag2.key = pmt.string_to_symbol(tagname)
     tag2.value = pmt.from_long(2)
     tag3 = gr.tag_t()
     tag3.offset = 6
     tag3.key = pmt.string_to_symbol(tagname)
     tag3.value = pmt.from_long(4)
     src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
     formatter_object = digital.packet_header_ofdm(occupied_carriers, 1,
                                                   tagname)
     self.assertEqual(formatter_object.header_len(), 6)
     self.assertEqual(pmt.symbol_to_string(formatter_object.len_tag_key()),
                      tagname)
     header = digital.packet_headergenerator_bb(
         formatter_object.formatter(), tagname)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, header, sink)
     self.tb.run()
     expected_data = (0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0)
     self.assertEqual(sink.data(), expected_data)
コード例 #23
0
    def test_00(self):
        expected_result = (
            0x00, 0x11, 0x22, 0x33,
            0x44, 0x55, 0x66, 0x77,
            0x88, 0x99, 0xaa, 0xbb,
            0xcc, 0xdd, 0xee, 0xff)

        # Filter taps to expand the data to oversample by 8
        # Just using a RRC for some basic filter shape
        taps = filter.firdes.root_raised_cosine(8, 8, 1.0, 0.5, 21)
        
        src = blocks.vector_source_b(expected_result)
        frame = digital.simple_framer(4)
        unpack = blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST)
        expand = filter.interp_fir_filter_fff(8, taps)
        b2f = blocks.char_to_float()
        mult2 = blocks.multiply_const_ff(2)
        sub1 = blocks.add_const_ff(-1)
        op = digital.simple_correlator(4)
        dst = blocks.vector_sink_b()
        self.tb.connect(src, frame, unpack, b2f, mult2, sub1, expand)
        self.tb.connect(expand, op, dst)
        self.tb.run()
        result_data = dst.data()

        self.assertEqual(expected_result, result_data)
コード例 #24
0
 def __init__(self, data, len_tag_key):
     gr.top_block.__init__(self, "ofdm_tx")
     tx_data, tags = tagged_streams.packets_to_vectors((data,), len_tag_key)
     src = blocks.vector_source_b(data, False, 1, tags)
     self.tx = ofdm_tx(packet_length_tag_key=len_tag_key, debug_log=LOG_DEBUG_INFO)
     self.sink = blocks.vector_sink_c()
     self.connect(src, self.tx, self.sink)
コード例 #25
0
 def test_300(self):
     input_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
     src = blocks.vector_source_b(input_data)
     dst = blocks.vector_sink_b()
     tb = gr.top_block()
     tb.connect(src, dst)
     tb.run()
     self.assertEquals(input_data, dst.data())
コード例 #26
0
ファイル: qa_message.py プロジェクト: Gabotero/GNURadioNext
    def test_300(self):
        input_data = (0,1,2,3,4,5,6,7,8,9)
        src = blocks.vector_source_b(input_data)
        dst = blocks.vector_sink_b()
	tb = gr.top_block()
        tb.connect(src, dst)
        tb.run()
        self.assertEquals(input_data, dst.data())
コード例 #27
0
 def test_char_to_short(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (256, 512, 768, 1024, 1280)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_short()
     dst = blocks.vector_sink_s()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
コード例 #28
0
 def test_char_to_float_scale(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (0.5, 1.0, 1.5, 2.0, 2.5)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_float(scale=2.0)
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
コード例 #29
0
 def test_char_to_float_identity(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_float()
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
コード例 #30
0
ファイル: qa_scrambler.py プロジェクト: Gabotero/GNURadioNext
 def test_scrambler_descrambler(self):
     src_data = (1,)*1000
     src = blocks.vector_source_b(src_data, False)
     scrambler = digital.scrambler_bb(0x8a, 0x7F, 7)     # CCSDS 7-bit scrambler
     descrambler = digital.descrambler_bb(0x8a, 0x7F, 7)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, scrambler, descrambler, dst)
     self.tb.run()
     self.assertEqual(tuple(src_data[:-8]), dst.data()[8:]) # skip garbage during synchronization
コード例 #31
0
ファイル: qa_scrambler.py プロジェクト: Gabotero/GNURadioNext
 def test_additive_scrambler_reset(self):
     src_data = (1,)*1000
     src = blocks.vector_source_b(src_data, False)
     scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100)
     descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, scrambler, descrambler, dst)
     self.tb.run()
     self.assertEqual(src_data, dst.data())
コード例 #32
0
 def test_char_to_short(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (256, 512, 768, 1024, 1280)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_short()
     dst = blocks.vector_sink_s()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_data, dst.data())
コード例 #33
0
 def test_char_to_float_scale(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (0.5, 1.0, 1.5, 2.0, 2.5)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_float(scale=2.0)
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
コード例 #34
0
 def test_001(self):
     src_data =              (1,0,1,1,0,1,1,0)
     expected_results =      (1,0,1,1,0,1,1,0)
     src = blocks.vector_source_b(src_data,False)
     op = blocks.pack_k_bits_bb(1)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(expected_results, dst.data())
コード例 #35
0
 def help_bb (self, src_data, exp_data, op):
     for s in zip (range (len (src_data)), src_data):
         src = blocks.vector_source_b (s[1])
         self.tb.connect (src, (op, s[0]))
     dst = blocks.vector_sink_b ()
     self.tb.connect (op, dst)
     self.tb.run ()
     result_data = dst.data ()
     self.assertEqual (exp_data, result_data)
コード例 #36
0
 def test_and_const_bb (self):
     src_data =        (1,  2, 3,  0x50,   0x11)
     expected_result = (0,  2, 2,  0x00,   0x00)
     src = blocks.vector_source_b(src_data)
     op = blocks.and_const_bb (0xAA)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_result)
コード例 #37
0
 def test_and_const_bb(self):
     src_data = (1, 2, 3, 0x50, 0x11)
     expected_result = (0, 2, 2, 0x00, 0x00)
     src = blocks.vector_source_b(src_data)
     op = blocks.and_const_bb(0xAA)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_result)
コード例 #38
0
 def help_bb(self, src_data, exp_data, op):
     for s in zip(range(len(src_data)), src_data):
         src = blocks.vector_source_b(s[1])
         self.tb.connect(src, (op, s[0]))
     dst = blocks.vector_sink_b()
     self.tb.connect(op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertEqual(exp_data, result_data)
コード例 #39
0
 def test_char_to_float_identity(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     src = blocks.vector_source_b(src_data)
     op = blocks.char_to_float()
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
コード例 #40
0
 def test_003(self):
     src_data = expected_results = map(lambda x: random.randint(0,3), range(10));
     src = blocks.vector_source_b( src_data );
     pack = blocks.pack_k_bits_bb(2);
     unpack = blocks.unpack_k_bits_bb(2);
     snk = blocks.vector_sink_b();
     self.tb.connect(src,unpack,pack,snk);
     self.tb.run()
     self.assertEqual(list(expected_results), list(snk.data()));
コード例 #41
0
 def test_029_singleton_disconnect(self):
     tb = gr.top_block()
     src = blocks.vector_source_b([1, ])
     dst = blocks.vector_sink_b()
     tb.connect(src, dst)
     tb.disconnect(src)   # Singleton disconnect
     tb.connect(src, dst)
     tb.run()
     self.assertEquals(dst.data(), (1,))
コード例 #42
0
    def test_002(self):
        src_data = [1, 1, 1, 1]
        expected_data = 1
        src = blocks.vector_source_b(src_data)
        op = digital.probe_density_b(0.01)
        self.tb.connect(src, op)
        self.tb.run()

        result_data = op.density()
        self.assertEqual(expected_data, result_data)
コード例 #43
0
 def test_001(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_data = (5, 10)
     src = blocks.vector_source_b(src_data)
     op = blocks.keep_one_in_n(gr.sizeof_char, 5)
     dst = blocks.vector_sink_b()
     print "HERE"
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_data)
コード例 #44
0
 def test_001(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_data = (5, 10)
     src = blocks.vector_source_b(src_data);
     op = blocks.keep_one_in_n(gr.sizeof_char, 5)
     dst = blocks.vector_sink_b()
     print "HERE"
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_data)
コード例 #45
0
ファイル: qa_copy.py プロジェクト: asif125/gnuradio
 def test_copy(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     src = blocks.vector_source_b(src_data)
     op = blocks.copy(gr.sizeof_char)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     dst_data = dst.data()
     self.assertEqual(expected_result, dst_data)
コード例 #46
0
ファイル: qa_copy.py プロジェクト: mfischer/gnuradio
 def test_copy(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     src = blocks.vector_source_b(src_data)
     op = blocks.copy(gr.sizeof_char)
     dst = blocks.vector_sink_b()
     self.tb.connect(src, op, dst)
     self.tb.run()
     dst_data = dst.data()
     self.assertEqual(expected_result, dst_data)
コード例 #47
0
    def test_003(self):
        src_data = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
        expected_data = 0.95243
        src = blocks.vector_source_b(src_data)
        op = digital.probe_density_b(0.01)
        self.tb.connect(src, op)
        self.tb.run()

        result_data = op.density()
        print result_data
        self.assertAlmostEqual(expected_data, result_data, 5)
コード例 #48
0
    def helper(self, symbols):
        src_data = [0, 1, 2, 3, 0, 1, 2, 3]
        expected_data = map(lambda x: symbols[x], src_data)
        src = blocks.vector_source_b(src_data)
        op = digital.map_bb(symbols)
        dst = blocks.vector_sink_b()
        self.tb.connect(src, op, dst)
        self.tb.run()

        result_data = list(dst.data())
        self.assertEqual(expected_data, result_data)
コード例 #49
0
 def test_029_singleton_disconnect(self):
     tb = gr.top_block()
     src = blocks.vector_source_b([
         1,
     ])
     dst = blocks.vector_sink_b()
     tb.connect(src, dst)
     tb.disconnect(src)  # Singleton disconnect
     tb.connect(src, dst)
     tb.run()
     self.assertEquals(dst.data(), (1, ))
コード例 #50
0
 def test_002_three(self):
     """ 8 -> 3 """
     src_data = (0b11111101, 0b11111111, 0b11111111)
     expected_data = (0b101, ) + (0b111, ) * 7
     k = 8
     l = 3
     src = blocks.vector_source_b(src_data, False, 1)
     repack = blocks.repack_bits_bb(k, l)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, repack, sink)
     self.tb.run()
     self.assertEqual(sink.data(), expected_data)
コード例 #51
0
    def test_006(self):
        src_data = (0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0)
        expected_results = (0x82, 0x5a)
        src = blocks.vector_source_b(src_data, False)
        op = blocks.unpacked_to_packed_bb(1, gr.GR_LSB_FIRST)
        dst = blocks.vector_sink_b()

        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        self.assertEqual(expected_results, dst.data())
コード例 #52
0
    def test_004(self):
        src_data = (0x11, )
        expected_results = (0, 4)
        src = blocks.vector_source_b(src_data, False)
        op = blocks.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST)
        dst = blocks.vector_sink_b()

        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        self.assertEqual(expected_results, dst.data())
コード例 #53
0
 def test_001_tx (self):
     """ Just make sure the Tx works in general """
     len_tag_key = 'frame_len'
     n_bytes = 52
     n_samples_expected = (numpy.ceil(1.0 * (n_bytes + 4) / 6) + 3) * 80
     test_data = [random.randint(0, 255) for x in range(n_bytes)]
     tx_data, tags = tagged_streams.packets_to_vectors((test_data,), len_tag_key)
     src = blocks.vector_source_b(test_data, False, 1, tags)
     tx = ofdm_tx(packet_length_tag_key=len_tag_key)
     tx_fg = ofdm_tx_fg(test_data, len_tag_key)
     tx_fg.run()
     self.assertEqual(len(tx_fg.get_tx_samples()), n_samples_expected)
コード例 #54
0
 def test_001_simple(self):
     """ Very simple test, 2 bits -> 1 """
     src_data = (0b11, 0b01, 0b10)
     expected_data = (0b1, 0b1, 0b1, 0b0, 0b0, 0b1)
     k = 2
     l = 1
     src = blocks.vector_source_b(src_data, False, 1)
     repack = blocks.repack_bits_bb(k, l)
     sink = blocks.vector_sink_b()
     self.tb.connect(src, repack, sink)
     self.tb.run()
     self.assertEqual(sink.data(), expected_data)