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)
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)
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())
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)
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())
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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())
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())
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())
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())
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())
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
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())
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())
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)
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)
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)
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)
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()));
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,))
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)
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)
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)
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)
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)
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)
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, ))
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)
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())
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())
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)
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)