예제 #1
0
    def timer_tick(self):

        if (self.has_gps_sensor):
            gps_gpgga = self.uhd_dev.get_mboard_sensor('gps_gpgga').value
            gps_gprmc = self.uhd_dev.get_mboard_sensor('gps_gprmc').value
            gps_time = self.uhd_dev.get_mboard_sensor('gps_time').to_int()
            gps_locked = self.uhd_dev.get_mboard_sensor('gps_locked').to_bool()
            pps_seconds = self.uhd_dev.get_time_last_pps().to_ticks(1.0)
            uhd_time_set = (pps_seconds == gps_time)

            gps_data = pmt.make_dict()
            gps_data = pmt.dict_add(gps_data, pmt.intern('gps_time'),
                                    pmt.to_pmt(gps_time))
            gps_data = pmt.dict_add(gps_data, pmt.intern('gps_locked'),
                                    pmt.to_pmt(gps_locked))
            gps_data = pmt.dict_add(gps_data,
                                    pmt.intern('usrp_time_is_absolute'),
                                    pmt.to_pmt(uhd_time_set))
            gps_data = pmt.dict_add(gps_data, pmt.intern('usrp_time'),
                                    pmt.to_pmt(pps_seconds))
            self.message_port_pub(pmt.intern('gps_data'), gps_data)

            if self.udp_socket:
                # send UDP
                self.udp_socket.sendto("\r\n" + gps_gprmc + "\r\n" + gps_gpgga,
                                       ("127.0.0.1", self.udp_port))

            self.timer = Timer(self.update_rate, self.timer_tick)
            self.timer.start()
예제 #2
0
    def test_002_callbacks (self):
        in_data = [0, 0, 0, 0]
        in_meta = pmt.make_dict()
        expected_meta1 = pmt.dict_add(in_meta, pmt.intern('num'), pmt.from_long(4))
        expected_meta2 = pmt.dict_add(pmt.dict_add(in_meta, pmt.intern('num'), pmt.from_long(4)), pmt.intern('name'), pmt.intern('param1'))
        expected_meta3 = pmt.dict_add(pmt.dict_add(in_meta, pmt.intern('name'), pmt.intern('param1')), pmt.intern('num'), pmt.from_long(1))
        in_pdu = pmt.cons(in_meta, pmt.init_u8vector(len(in_data), in_data))
        expected_pdu1 = pmt.cons(expected_meta1, pmt.init_u8vector(len(in_data), in_data))
        expected_pdu2 = pmt.cons(expected_meta2, pmt.init_u8vector(len(in_data), in_data))
        expected_pdu3 = pmt.cons(expected_meta3, pmt.init_u8vector(len(in_data), in_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.set.set_key(pmt.intern('name'))
        self.set.set_val(pmt.intern('param1'))
        time.sleep(.001)
        self.emitter.emit(self.debug.get_message(0))
        time.sleep(.001)
        self.set.set_kv(pmt.intern('num'), pmt.from_long(1))
        time.sleep(.001)
        self.emitter.emit(self.debug.get_message(1))
        time.sleep(.01)
        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))
        self.assertTrue(pmt.equal(self.debug.get_message(2), expected_pdu3))
예제 #3
0
    def work(self, input_items, output_items):
        inb = input_items[0]
        linb = len(inb)
        gen = self.base.gen_n(linb)

        tags = self.get_tags_in_window(0, 0, linb, pmt.intern("rx_time"))

        if tags:
            tag = tags[-1]
            rx_time = tag.value
            seconds = pmt.to_uint64(pmt.tuple_ref(rx_time, 0))
            fractional_seconds = pmt.to_double(pmt.tuple_ref(rx_time, 1))
            timestamp = seconds + fractional_seconds
            if self.nbits > 0:
                ber = self.nerrs / float(self.nbits)
                #print "NBits: %d \tNErrs: %d \tBER: %.4E, \ttimestamp %f"%(int(self.nbits), int(self.nerrs), ber, timestamp)
                d = pmt.make_dict()
                d = pmt.dict_add(d, pmt.intern('timestamp'),
                                 pmt.from_double(timestamp))
                d = pmt.dict_add(d, pmt.intern('ber'), pmt.from_double(ber))
                self.message_port_pub(self.ber_port_id, d)
                self.nerrs = 0
                self.nbits = 0

        self.nerrs += numpy.sum(numpy.bitwise_xor(inb, gen))
        self.nbits += len(inb)
        # if self.nbits > 0:
        #     print "NBits: %d \tNErrs: %d \tBER: %.4E"%(int(self.nbits), int(self.nerrs), self.nerrs/self.nbits)

        return len(inb)
예제 #4
0
    def __init__(self, cfreq, ant_list, coord_type):
        gr.sync_block.__init__(self,
                               name="trackscan",
                               in_sig=None,
                               out_sig=None)

        self.message_port_register_out(pmt.intern("command"))
        self.message_port_register_in(pmt.intern("msg_in"))
        self.set_msg_handler(pmt.intern('msg_in'), self.handle_msg)

        #set up dictionary of observing info which will be sent through
        #the message port

        obs_key = pmt.intern("obs_type")
        obs_val = pmt.intern("track")

        ant_key = pmt.intern("antennas_list")
        ant_val = pmt.intern(ant_list)

        freq_key = pmt.intern("freq")
        freq_val = pmt.from_double(cfreq)

        coord_key = pmt.intern("coord_type")
        coord_val = pmt.intern(coord_type)

        command = pmt.make_dict()
        command = pmt.dict_add(command, ant_key, ant_val)
        command = pmt.dict_add(command, freq_key, freq_val)
        command = pmt.dict_add(command, obs_key, obs_val)
        command = pmt.dict_add(command, coord_key, coord_val)

        self.command = command
예제 #5
0
    def test_003_normal_passa(self):

        self.dut = pdu_utils.pdu_range_filter(pmt.intern("start_time"), 1, 5,
                                              False)
        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(1.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(1.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))
예제 #6
0
    def test1_cleanup(self):
      '''
      All files should be deleted by the monitor when complete
      '''
      # open a dummy file
      fname = '/tmp/foo.txt'
      if os.path.exists(fname):
        os.remove(fname)
      Path(fname).touch()

      # PMT
      p = pmt.dict_add(pmt.make_dict(),pmt.intern('rx_freq'), pmt.from_double(915e6))
      p = pmt.dict_add(p,pmt.intern('rx_rate'),pmt.from_double(30.72e6))
      p = pmt.dict_add(p,pmt.intern('rx_time'),pmt.make_tuple(
        pmt.from_uint64(0),pmt.from_double(0)))
      p = pmt.dict_add(p,pmt.intern('fname'),pmt.intern(fname))

      # blocks
      emitter = pdu_utils.message_emitter(pmt.PMT_NIL)
      debug = blocks.message_debug()
      monitor = file_monitor(10,'/tmp')

      # connect
      self.tb.msg_connect((emitter,'msg'),(monitor,'pdu'))

      # set up fg - terrible hacky way of doing this until we get
      # pdu utility message emitter working
      self.tb.start()
      emitter.emit(p)
      time.sleep(.05)
      self.tb.stop()
      self.tb.wait()

      # check data
      self.assertTrue(not os.path.exists(fname))
예제 #7
0
파일: acars.py 프로젝트: mmmaaaxxx/SUPACARS
    def parser_output(self, mat_frame, parity_ok=True, crc_ok=True):

        # Reshaping the mat_frame into a simple row vector and convert the vector to a string
        size_mat_frame = mat_frame.shape
        mat_vect = numpy.reshape(mat_frame,
                                 (size_mat_frame[0] * size_mat_frame[1], 1))
        mat_vect = numpy.array(mat_vect)
        mat_vect_str = mat_vect.tostring()

        # Creation of dictionnary with the matrix and the crc_ok & parity_ok boolean
        key_crc = pmt.intern("crc_ok")
        val_crc = pmt.to_pmt(crc_ok)
        key_parity = pmt.intern("parity_ok")
        val_parity = pmt.to_pmt(parity_ok)
        key_mat = pmt.intern("mat_vect_str")
        val_mat = pmt.to_pmt(mat_vect_str)

        dic = pmt.make_dict()
        dic = pmt.dict_add(dic, key_crc, val_crc)
        dic = pmt.dict_add(dic, key_parity, val_parity)
        dic = pmt.dict_add(dic, key_mat, val_mat)

        # Sending the dictionnary to the acarsparser block
        self.message_port_pub(pmt.intern("parser_output"),
                              pmt.cons(pmt.PMT_NIL, dic))
예제 #8
0
    def test_pdu(self):
        cs = starcoder.command_source()
        snk = blocks.message_debug()
        self.tb.msg_connect((cs, 'out'), (snk, 'store'))

        msg = starcoder_pb2.BlockMessage()
        md = msg.pair_value.car.dict_value.entry.add()
        md.key.symbol_value = 'metadata_1'
        md.value.integer_value = -2
        md = msg.pair_value.car.dict_value.entry.add()
        md.key.symbol_value = 'metadata_2'
        md.value.symbol_value = 'val'

        msg.pair_value.cdr.uniform_vector_value.f64_value.value.extend(
            [2.4, -12.3, 21.2])

        pmt_dict = pmt.make_dict()
        pmt_dict = pmt.dict_add(pmt_dict, pmt.intern('metadata_1'),
                                pmt.from_long(-2))
        pmt_dict = pmt.dict_add(pmt_dict, pmt.intern('metadata_2'),
                                pmt.intern('val'))
        expected = pmt.cons(pmt_dict,
                            pmt.init_f64vector(3, [2.4, -12.3, 21.2]))

        self.tb.start()
        cs.push(msg.SerializeToString())
        time.sleep(0.1)
        self.tb.stop()
        self.tb.wait()

        self.assertEqual(snk.num_messages(), 1)
        self.assertTrue(pmt.is_dict(snk.get_message(0)))
        self.assertTrue(pmt.equal(snk.get_message(0), expected))
예제 #9
0
def get_pdu_header(dest_id, src_id, frame_num, checksum=None):
    d = pmt.make_dict()
    d = set_pdu_header_checksum(d, checksum)
    d = pmt.dict_add(d, pmt.intern("frame_num"), pmt.from_long(frame_num))
    d = pmt.dict_add(d, pmt.intern("src_id"), pmt.from_long(src_id))
    d = pmt.dict_add(d, pmt.intern("dest_id"), pmt.from_long(dest_id))
    return d
예제 #10
0
def set_pdu_header_checksum(meta, checksum=None):
    if checksum is None:
        meta = pmt.dict_add(meta, pmt.intern("checksum"), pmt.PMT_NIL)
    else:
        c = ndarray_to_pmt_u8vector(checksum)
        meta = pmt.dict_add(meta, pmt.intern("checksum"), c)
    return meta
예제 #11
0
    def test_002_normal(self):
        tnow = time.time()

        in_data = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
                   1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]
        meta = pmt.dict_add(pmt.make_dict(), pmt.intern(
            'system_time'), pmt.from_double(tnow - 10.0))
        in_pdu = pmt.cons(meta, pmt.init_c32vector(len(in_data), in_data))

        e_data = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1,
                  1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1]
        e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern(
            'system_time'), pmt.from_double(tnow))
        e_meta = pmt.dict_add(e_meta, pmt.intern(
            'sys time delta (ms)'), pmt.from_double(10000.0))
        e_pdu = pmt.cons(e_meta, pmt.init_c32vector(len(e_data), e_data))

        # set up fg
        self.tb.start()
        self.time_delta.to_basic_block()._post(pmt.intern("pdu"), in_pdu)
        self.waitFor(lambda: self.debug.num_messages() ==
                     1, timeout=1.0, poll_interval=0.01)
        self.tb.stop()
        self.tb.wait()

        # check data
        self.assertEqual(1, self.debug.num_messages())
        a_meta = pmt.car(self.debug.get_message(0))
        time_tag = pmt.dict_ref(a_meta, pmt.intern("system_time"), pmt.PMT_NIL)
        delta_tag = pmt.dict_ref(a_meta, pmt.intern(
            "sys time delta (ms)"), pmt.PMT_NIL)
        self.assertAlmostEqual(tnow, pmt.to_double(time_tag), delta=60)
        self.assertAlmostEqual(10000, pmt.to_double(delta_tag), delta=10)
예제 #12
0
    def button_clicked(self):
        # Add metadata elements to PDU
        meta = pmt.make_dict()
        try:
            v_txt = str(self.textinputs[1].text().toUtf8())
            if len(v_txt) > 0:
                meta_dict = ast.literal_eval(v_txt)
                for key, val in meta_dict.items():
                    if type(val) == list or type(val) == tuple:
                        t = pmt.make_vector(len(val), pmt.from_uint64(0))
                        meta = pmt.dict_add(meta, pmt.intern(str(key)),
                                            pmt.to_tuple(t))
                    else:  # Store as uint64
                        if isinstance(val, float):
                            if val.is_integer():
                                meta = pmt.dict_add(meta, pmt.intern(str(key)),
                                                    pmt.from_uint64(int(val)))
                            else:
                                meta = pmt.dict_add(meta, pmt.intern(str(key)),
                                                    pmt.from_double(val))
                        else:
                            meta = pmt.dict_add(meta, pmt.intern(str(key)),
                                                pmt.from_uint64(int(val)))
        except ValueError as err:
            print('PDU Parser Error: ', err)
            pass

        # Generate payload data
        v_txt = str(self.textinputs[0].text())
        vec = self.data_types[str(self.input_types.currentText())](v_txt)

        # Publish message
        self.message_port_pub(
            pmt.intern("pdu_out"),
            pmt.cons(meta, pmt.to_pmt(numpy.array(vec, dtype=numpy.uint8))))
예제 #13
0
    def test_001_three (self):
        in_data1 = [1+1j, 0-1j]
        in_data2 = [1, 0]
        in_data3 = [1j, -1]
        expected_data = in_data1 + in_data2 + in_data3
        dict1 = pmt.dict_add(pmt.make_dict(), pmt.intern("burst_index"), pmt.cons(pmt.from_uint64(1), pmt.from_uint64(3)))
        dict2 = pmt.dict_add(pmt.make_dict(), pmt.intern("burst_index"), pmt.cons(pmt.from_uint64(2), pmt.from_uint64(3)))
        dict3 = pmt.dict_add(pmt.make_dict(), pmt.intern("burst_index"), pmt.cons(pmt.from_uint64(3), pmt.from_uint64(3)))
        in_pdu1 = pmt.cons(dict1, pmt.init_c32vector(len(in_data1), in_data1))
        in_pdu2 = pmt.cons(dict2, pmt.init_c32vector(len(in_data2), in_data2))
        in_pdu3 = pmt.cons(dict3, pmt.init_c32vector(len(in_data3), in_data3))
        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.emitter.emit(pmt.intern("MALFORMED PDU"))
        time.sleep(.001)
        # handle malformed pair
        self.emitter.emit(pmt.cons(pmt.intern("NON-PDU"), pmt.intern("PAIR")))
        time.sleep(.001)
        # handle out of order PDU
        self.emitter.emit(in_pdu3)
        time.sleep(.001)
        self.emitter.emit(in_pdu1)
        time.sleep(.001)
        self.emitter.emit(in_pdu2)
        time.sleep(.001)
        self.emitter.emit(in_pdu3)
        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)
예제 #14
0
    def test_001_c32(self):
        '''
        uint8_t input data, no decimation, no filter
        '''
        self.dut = pdu_utils.pdu_fir_filter(1, [1.0])
        self.connectUp()

        i_data = [1, 0, 0, 0] * 5
        i_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"),
                              pmt.from_float(1000.0))
        in_pdu = pmt.cons(i_meta, pmt.init_c32vector(len(i_data), i_data))

        e_data = [1, 0, 0, 0] * 5
        e_meta = pmt.dict_add(pmt.make_dict(), pmt.intern("sample_rate"),
                              pmt.from_float(1000.0))
        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_001:")
        #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))
예제 #15
0
    def test_pdu_add_meta(self):
        tb = gr.top_block()
        dbg = blocks.message_debug()
        meta = pmt.make_dict()
        meta = pmt.dict_add(meta, pmt.intern('k1'), pmt.intern('v1'))
        meta = pmt.dict_add(meta, pmt.intern('k2'), pmt.intern('v2'))
        add_meta = pdu_add_meta(meta)

        pdu = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(10, 0))

        tb.msg_connect((add_meta, 'out'), (dbg, 'store'))

        add_meta.to_basic_block()._post(pmt.intern('in'), pdu)
        add_meta.to_basic_block()._post(
            pmt.intern('system'), pmt.cons(pmt.intern('done'),
                                           pmt.from_long(1)))

        tb.start()
        tb.wait()

        pdu_out = dbg.get_message(0)
        meta_out = pmt.car(pdu_out)
        self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k1')),
                        'Test key k1 not in output PDU metadata')
        self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k2')),
                        'Test key k1 not in output PDU metadata')
        self.assertEqual(pmt.u8vector_elements(pmt.cdr(pdu_out)),
                         pmt.u8vector_elements(pmt.cdr(pdu)),
                         'Output PDU data does not match input PDU data')
예제 #16
0
def create_frame(config, tag_key):
    symbols = get_random_qpsk(config.timeslots * config.active_subcarriers)
    d_block = modulate_mapped_gfdm_block(
        symbols,
        config.timeslots,
        config.subcarriers,
        config.active_subcarriers,
        2,
        0.2,
        dc_free=True,
    )
    preamble = config.full_preambles[0]
    frame = add_cyclic_starfix(d_block, config.cp_len, config.cs_len)
    frame = np.concatenate((preamble, frame))

    tag = gr.tag_t()
    tag.key = pmt.string_to_symbol(tag_key)
    d = pmt.make_dict()
    d = pmt.dict_add(d, pmt.mp("xcorr_idx"), pmt.from_uint64(42))
    d = pmt.dict_add(d, pmt.mp("xcorr_offset"), pmt.from_uint64(4711))
    d = pmt.dict_add(d, pmt.mp("sc_rot"), pmt.from_complex(1.0 + 0.0j))
    # tag.offset = data.size + cp_len
    tag.srcid = pmt.string_to_symbol("qa")
    tag.value = d
    return frame, symbols, tag
예제 #17
0
    def test_001_split(self):
        emitter = pdu_utils.message_emitter()
        split = pdu_utils.pdu_split()
        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), in_meta2))
        self.assertTrue(pmt.equal(d1.get_message(1), 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(6, range(6))))
 def send_command(self, freq, bw):
     command = pmt.make_dict()
     command = pmt.dict_add(command, pmt.intern("freq"),
                            pmt.from_double(freq))
     command = pmt.dict_add(command, pmt.intern("bandwidth"),
                            pmt.from_double(freq))
     return command
예제 #19
0
    def test_002_uint8_metadata_header(self):
        emitter = pdu_utils.message_emitter()
        writer = csv_writer('/tmp/file.csv', True, '', 'uint8')

        # generate pdu
        metadata = pmt.dict_add(pmt.make_dict(), pmt.intern('a'),
                                pmt.intern('a'))
        metadata = pmt.dict_add(metadata, pmt.intern('b'), pmt.from_long((0)))
        data = pmt.init_u8vector(5, [11, 12, 13, 14, 15])
        pdu = pmt.cons(metadata, data)

        # expected will only have intern strings
        metadata = pmt.dict_add(pmt.make_dict(), pmt.intern('a'),
                                pmt.intern('a'))
        metadata = pmt.dict_add(metadata, pmt.intern('b'), pmt.intern('0'))
        expected = pmt.cons(metadata, data)

        # run
        tb = gr.top_block()
        tb.msg_connect((emitter, 'msg'), (writer, 'in'))
        tb.start()
        emitter.emit(expected)
        time.sleep(.5)
        tb.stop()
        tb.wait()

        # read in csv
        self.assertTrue(
            self.check_file('/tmp/file.csv', expected, has_header=True))
예제 #20
0
    def test_006_basic_nrz(self):

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

        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"))
        input_pdu = pmt.cons(input_dict, input_data)

        expected_data = [1, -1, 1, 1, -1, -1, 1, -1]
        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_006_basic_nrz:")
        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))
예제 #21
0
    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 msg_handler_analyzed_data_in(self, msg):
        print("in msg_handler_analyzed_data_in")
        self.lock()
        gate_params = pmt.vector_ref(msg, 0)
        gate_type_PMT = pmt.dict_ref(
            gate_params,
            pmt.from_float(
                quantum_gate_param_type.quantum_gate_param_type.GATE_TYPE),
            pmt.PMT_NIL)
        if (pmt.eq(gate_type_PMT, pmt.PMT_NIL)):
            return

        gate_type = pmt.to_float(gate_type_PMT)
        print("gate_params.gate_type=" + str(gate_type))

        qubit_id_PMT = pmt.dict_ref(
            gate_params,
            pmt.from_float(
                quantum_gate_param_type.quantum_gate_param_type.QUBIT_ID),
            pmt.PMT_NIL)
        if (pmt.eq(qubit_id_PMT, pmt.PMT_NIL)):
            return
        qubit_id = pmt.to_float(qubit_id_PMT)
        print("gate_params.qubit_id=" + str(qubit_id))

        if (gate_type == quantum_gate_type.quantum_gate_type.X):
            print("in msg_handler_analyzed_data_in X gate")
            #回路を作る
            RO_STATE = self._qubit_stat_map[qubit_id]
            if (float(RO_STATE.angle) == 0.0):
                RO_STATE.angle = 180.0
            else:
                RO_STATE.angle = 0.0
            self._qubit_stat_map[qubit_id] = RO_STATE
        elif (gate_type == quantum_gate_type.quantum_gate_type.RO):
            print("in msg_handler_analyzed_data_in RO")
            #回路を実行する
            RO_STATE = self._qubit_stat_map[qubit_id]
            SIM_msg = pmt.make_dict()
            SIM_msg = pmt.dict_add(
                SIM_msg,
                pmt.from_float(
                    quantum_qubit_param_type.quantum_qubit_param_type.ID),
                pmt.from_float(qubit_id))
            SIM_msg = pmt.dict_add(
                SIM_msg,
                pmt.from_float(
                    quantum_qubit_param_type.quantum_qubit_param_type.ANGLE),
                pmt.from_float(float(RO_STATE.angle)))
            SIM_msg = pmt.dict_add(
                SIM_msg,
                pmt.from_float(
                    quantum_qubit_param_type.quantum_qubit_param_type.STATE),
                pmt.from_float(quantum_qubit_RO_state_type.
                               quantum_qubit_RO_state_type.START))
            self.message_port_pub(pmt.intern('simulated_data'), SIM_msg)
            RO_STATE.state = quantum_qubit_RO_state_type.quantum_qubit_RO_state_type.START
            self._qubit_stat_map[qubit_id] = RO_STATE
        self.unlock()
예제 #23
0
 def _post_phase_inc_cmd(self, new_phase_inc, offset=None):
     """Post phase increment update command to the rotator block"""
     cmd = pmt.make_dict()
     cmd = pmt.dict_add(cmd, pmt.intern("inc"),
                        pmt.from_double(new_phase_inc))
     if (offset is not None):
         cmd = pmt.dict_add(cmd, pmt.intern("offset"),
                            pmt.from_uint64(offset))
     self.rotator_cc.insert_tail(pmt.to_pmt("cmd"), cmd)
예제 #24
0
    def test_001_all_header_fields(self):
        with open('/tmp/file.csv', 'w') as f:
            # write header
            f.write('field0(string), , field1(bool), field2(float),' +
                    'field3(long), field4(uint64), field5(double),' +
                    'field6(complex),field7,field8(time),field9(time_tuple)\n')

            # add some data
            f.write(
                'field0, empty, True, 1.0,1234567890,987654321, 2.5,1+2j,string,1.0,1.0,1,2,3,4,5\n'
            )

        # start reader/
        reader = csv_reader(fname='/tmp/file.csv',
                            has_header=True,
                            period=10,
                            start_delay=0,
                            repeat=False)

        # expected pdu
        metadata = pmt.dict_add(pmt.make_dict(), pmt.intern('field0'),
                                pmt.intern('field0'))
        metadata = pmt.dict_add(metadata, pmt.intern('field1'),
                                pmt.from_bool(True))
        metadata = pmt.dict_add(metadata, pmt.intern('field2'),
                                pmt.from_float(1.0))
        metadata = pmt.dict_add(metadata, pmt.intern('field3'),
                                pmt.from_long(1234567890))
        metadata = pmt.dict_add(metadata, pmt.intern('field4'),
                                pmt.from_uint64(987654321))
        metadata = pmt.dict_add(metadata, pmt.intern('field5'),
                                pmt.from_double(2.5))
        metadata = pmt.dict_add(metadata, pmt.intern('field6'),
                                pmt.from_complex(1.0 + 2j))
        metadata = pmt.dict_add(metadata, pmt.intern('field7'),
                                pmt.intern('string'))
        metadata = pmt.dict_add(
            metadata, pmt.intern('field8'),
            pmt.cons(pmt.from_uint64(1), pmt.from_double(0)))
        metadata = pmt.dict_add(
            metadata, pmt.intern('field9'),
            pmt.make_tuple(pmt.from_uint64(1), pmt.from_double(0)))

        data = pmt.init_u8vector(5, [1, 2, 3, 4, 5])
        expected = pmt.cons(metadata, data)

        # run
        self.tb.msg_connect((reader, 'out'), (self.debug, 'store'))
        self.tb.start()
        time.sleep(.5)
        self.tb.stop()
        self.tb.wait()

        got = self.debug.get_message(0)

        self.assertTrue(pmt.equal(expected, got))
예제 #25
0
    def test_coerce(self):
        samp_rate = 1e6
        freq_offset = -400e3
        center_freq = 911e6

        # blocks
        self.emitter = pdu_utils.message_emitter()
        self.cf = fhss_utils.cf_estimate(fhss_utils.COERCE,
                                         [x * 1e6 for x in range(900, 930)])
        self.debug = blocks.message_debug()

        # connections
        self.tb.msg_connect((self.emitter, 'msg'), (self.cf, 'in'))
        self.tb.msg_connect((self.cf, 'out'), (self.debug, 'store'))

        # data
        in_data = (1 + 0j, ) * 2048
        i_vec = pmt.init_c32vector(len(in_data), in_data)
        out_data = np.exp(1j *
                          np.arange(0,
                                    2 * np.pi *
                                    (freq_offset / samp_rate * len(in_data)),
                                    2 * np.pi * (freq_offset / samp_rate),
                                    dtype=np.complex64))
        e_vec = pmt.init_c32vector(len(out_data), out_data.tolist(
        ))  # pmt doesn't play nice with numpy sometimes, convert to list

        meta = pmt.make_dict()
        meta = pmt.dict_add(meta, pmt.intern("sample_rate"),
                            pmt.from_float(samp_rate))
        meta = pmt.dict_add(meta, pmt.intern("center_frequency"),
                            pmt.from_float(center_freq + freq_offset))
        in_pdu = pmt.cons(meta, i_vec)
        e_pdu = pmt.cons(meta, e_vec)

        # flowgraph
        self.tb.start()
        time.sleep(.001)
        self.emitter.emit(in_pdu)
        time.sleep(.01)
        self.tb.stop()
        self.tb.wait()

        # parse output
        #print "got ", list(pmt.to_python(pmt.cdr(self.debug.get_message(0))))
        #print "got ", self.debug.get_message(0)
        rcv = self.debug.get_message(0)
        rcv_meta = pmt.car(rcv)
        rcv_data = pmt.cdr(rcv)
        rcv_cf = pmt.dict_ref(rcv_meta, pmt.intern("center_frequency"),
                              pmt.PMT_NIL)

        # asserts
        self.assertComplexTuplesAlmostEqual(
            tuple(pmt.c32vector_elements(rcv_data)), tuple(out_data), 2)
        self.assertTrue(pmt.equal(rcv_cf, pmt.from_float(911e6)))
예제 #26
0
 def makeDict(self, **kwargs):
     pmtDict = pmt.make_dict()
     if "freq" in kwargs:
         pmtDict = pmt.dict_add(pmtDict, pmt.intern("rx_freq"), pmt.from_double(kwargs["freq"]))
     if "rate" in kwargs:
         pmtDict = pmt.dict_add(pmtDict, pmt.intern("rx_rate"), pmt.from_double(kwargs["rate"]))
     if "epoch_int" in kwargs and "epoch_frac" in kwargs:
         pmtDict = pmt.dict_add(pmtDict, pmt.intern("rx_time"),
                                pmt.make_tuple(pmt.from_uint64(kwargs["epoch_int"]), pmt.from_double(kwargs["epoch_frac"])))
     return pmtDict
예제 #27
0
    def work(self, input_items, output_items):
        in0 = input_items[0]
        #out = output_items[0]
        for idx in range(in0.shape[0]):
            self.nsamplesread += len(in0[idx, :])
            # continue#return len(input_items[0])
            self.imgnp[self.count, :] += in0[idx, :]
            self.countavg += 1
            if self.countavg == self.avgsize:
                self.countavg = 0
                self.count += 1
            if self.count == self.nrows:
                self.count = 0
                self.dropcount += 1
                if self.dropcount >= self.n_drops:
                    self.dropcount = 0
                    Sxx = spectrogram.normalize_spectrogram(
                        self.imgnp)  #/self.avgsize)
                    if self.cancel_DCoffset:
                        pwr_min = np.min(Sxx)
                        Sxx[:, Sxx.shape[1] / 2] = pwr_min
                    self.imgcv[:, 0:self.vlen, 0] = np.uint8(Sxx * 255)
                    self.imgcv[:, :, 1] = self.imgcv[:, :, 0]
                    self.imgcv[:, :, 2] = self.imgcv[:, :, 0]
                    detected_boxes = self.classifier.classify(self.imgcv)
                    self.last_result = detected_boxes
                    for box in detected_boxes:
                        d = pmt.make_dict()
                        d = pmt.dict_add(d, pmt.intern('tstamp'),
                                         pmt.from_long(self.img_tstamp))
                        for k, v in box.items():
                            if k == 'topleft' or k == 'bottomright':
                                pmt_val = pmt.make_dict()
                                pmt_val = pmt.dict_add(pmt_val,
                                                       pmt.intern('x'),
                                                       pmt.from_long(v['x']))
                                pmt_val = pmt.dict_add(pmt_val,
                                                       pmt.intern('y'),
                                                       pmt.from_long(v['y']))
                            elif k == 'confidence':
                                pmt_val = pmt.from_float(float(v))
                            elif k == 'label':
                                pmt_val = pmt.string_to_symbol(v)
                            else:
                                raise NotImplementedError(
                                    'Did not expect parameter {}'.format(k))
                            d = pmt.dict_add(d, pmt.intern(k), pmt_val)
                        # print 'gonna send:',pmt.write_string(d)
                        self.message_port_pub(pmt.intern('msg_out'), d)
                    # self.message_port_pub(pmt.intern('boxes'), pmt.intern(detected_boxes))
                self.imgnp[:] = 0
                self.img_tstamp += int(self.vlen * self.nrows)

        return len(input_items[0])
예제 #28
0
 def msg_handler_doppler(self, msg_in):
     ## print('-------------------- msg_handler_doppler --------------------')
     iq_samples = pmt.to_python(pmt.cdr(msg_in))
     success, doppler = self._obj.get_doppler(iq_samples)
     msg_out = pmt.make_dict()
     msg_out = pmt.dict_add(msg_out, pmt.intern('success'),
                            pmt.to_pmt(np.bool(success)))
     msg_out = pmt.dict_add(msg_out, pmt.intern('doppler'),
                            pmt.to_pmt(doppler))
     ## print(msg_out)
     self.message_port_pub(self._port_doppler, msg_out)
예제 #29
0
 def send_frame(self, timestamp, center_frequency, confidence):
     msg_meta = pmt.dict_add(pmt.make_dict(), pmt.intern('timestamp'),
                             pmt.from_uint64(timestamp))
     msg_meta = pmt.dict_add(msg_meta, pmt.intern('center_frequency'),
                             pmt.from_float(center_frequency))
     msg_meta = pmt.dict_add(msg_meta, pmt.intern('confidence'),
                             pmt.from_long(confidence))
     msg = pmt.cons(msg_meta, pmt.init_u8vector(2, range(2)))
     if timestamp > self.max_timestamp:
         self.max_timestamp = timestamp
     self.sorter.to_basic_block()._post(pmt.intern("pdus"), msg)
예제 #30
0
 def setUp (self):
     self.tb = gr.top_block ()
     self.emitter = pdu_utils.message_emitter()
     self.emd = pdu_utils.extract_metadata(pmt.intern("test_key"), 1, 0)
     self.debug = blocks.message_debug()
     self.tb.msg_connect((self.emitter, 'msg'), (self.emd, 'dict'))
     self.tb.msg_connect((self.emd, 'msg'), (self.debug, 'store'))
     self.base_dict = pmt.make_dict()
     self.base_dict = pmt.dict_add(self.base_dict, pmt.intern("key1"), pmt.intern("value1"))
     self.base_dict = pmt.dict_add(self.base_dict, pmt.intern("key2"), pmt.intern("value2"))
     self.base_dict = pmt.dict_add(self.base_dict, pmt.intern("uint64_key"), pmt.from_uint64(1234567))
     self.base_dict = pmt.dict_add(self.base_dict, pmt.intern("double_key"), pmt.from_double(1.234567))
예제 #31
0
파일: qa_pmt.py 프로젝트: dl1ksv/gnuradio
 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"])
예제 #32
0
 def handle_msg(self, msg):
     if pmt.dict_has_key(msg, pmt.intern(self.len_tag_key)):
         packet_len = pmt.to_python(msg)[self.len_tag_key]
         msg = pmt.dict_delete(msg, pmt.intern(self.len_tag_key))
         msg = pmt.dict_add(msg, pmt.intern(self.len_tag_key), pmt.from_long(packet_len * 8))
         
     self.message_port_pub(self.msg_buf_out, msg)
예제 #33
0
 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)
예제 #34
0
파일: pdulib.py 프로젝트: icopavan/gr-burst
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);
예제 #35
0
    def handler(self, pdu):
        data = pmt.to_python(pmt.cdr(pdu))
        meta = pmt.car(pdu)
        data = data - numpy.mean(data) # remove DC
        mag_sq = numpy.mean(numpy.real(data*numpy.conj(data))) #compute average Mag Sq
        p = self.k + 10*numpy.log10(mag_sq)
#        print "Power: %f"%(p)
        meta = pmt.dict_add(meta, pmt.intern("power"), pmt.from_float( p ) )

        # done pass vector element for now ...
        self.message_port_pub( pmt.intern("cpdus"), pmt.cons( meta, pmt.PMT_NIL ) );
예제 #36
0
    def handler(self, msg):
        meta = pmt.car(msg);
        samples = pmt.cdr(msg);
        
        x = numpy.array(pmt.c32vector_elements(samples), dtype=numpy.complex64)
        x_2 = numpy.real(x * x.conjugate())
        
        # smoothing filter
        x_2f = numpy.convolve(50*[1], x_2);

        # find max power to compute power thresh
        maxidx = numpy.argmax(x_2f);
        maxpow = x_2f[maxidx];
        thr = maxpow / 16; # 6db down

        # find where we are below thresh
        start_offset = 1000;
        idx = numpy.argmax(x_2f[start_offset:] < thr) + start_offset + 1000;
#        print "below = (%d, %f)"%(idx, x_2f[idx])

        # discard bursts where we dont find an end
        if idx == start_offset:
            print "WARNING: length detect: discarding burst"
            return

        # tack on some metadata
        meta = pmt.dict_add(meta, pmt.intern("est_len"), pmt.from_double(int(idx)));
        meta = pmt.dict_add(meta, pmt.intern("orig_len"), pmt.from_double(len(x)));
        
        # extract the useful signal
        x = x[0:idx];

        # send it on its way
        samples_out = pmt.init_c32vector(len(x), map(lambda i: complex(i), x))
        cpdu = pmt.cons(meta,samples_out)
        self.message_port_pub(pmt.intern("cpdus"), cpdu);
예제 #37
0
 def handler(self,msg):
     meta = pmt.car(msg)
     metapy = pmt.to_python(meta)
     t_start = metapy['start']/self.fs
     t_stop  = metapy['end']  /self.fs
     tag_times = []
     #print [t_start, t_stop]
     #print type(t_start)
     self.pcap = PcapReader(self.f)
     for i,p in enumerate(self.pcap):
         if p.time > t_start:
             if p.time > t_stop:
                 break;
             else:
                 samp_offset = int(self.fs*(p.time-t_start) )
                 k = "packet_id"
                 v = "%d"%(i)
                 tag_times.append( (samp_offset, k, v) )
     tags = pmt.to_pmt(tag_times)       
     meta = pmt.dict_add(meta, pmt.intern("tags"), tags)
     #print "tag times: ", tag_times
     self.message_port_pub(pmt.intern("pdus"), pmt.cons(meta, pmt.cdr(msg)));
예제 #38
0
파일: mkheader.py 프로젝트: garverp/recipes
def update_timestamp(hdr,seg_size):
    if pmt.dict_has_key(hdr, pmt.string_to_symbol("rx_time")):
        r = pmt.dict_ref(hdr, pmt.string_to_symbol("rx_time"), pmt.PMT_NIL)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
    else:
        sys.stderr.write("Could not find key 'time': \
                invalid or corrupt data file.\n")
        sys.exit(1)
    new_hdr = pmt.dict_delete(hdr, pmt.intern("rx_time"))
    if pmt.dict_has_key(hdr, pmt.intern("rx_rate")):
        r = pmt.dict_ref(hdr, pmt.intern("rx_rate"), pmt.PMT_NIL)
        rate = pmt.to_double(r)
        new_t = t + float(seg_size)/rate
        new_secs = long(new_t)
        new_fracs = new_t - new_secs
        time_val = pmt.make_tuple(pmt.from_uint64(new_secs),
                             pmt.from_double(new_fracs))
        new_hdr = pmt.dict_add(new_hdr, pmt.intern("rx_time"), time_val)
        return new_hdr
예제 #39
0
 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()
예제 #40
0
파일: arq.py 프로젝트: icopavan/gr-burst
    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!"
예제 #41
0
 def rx_from_tap(self, msg):
     meta = pmt.car(msg)
     meta = pmt.dict_add(meta, pmt.intern('dst_addr'), pmt.init_u8vector(len(self.dst_addr), self.dst_addr))
     self.message_port_pub(pmt.intern('to_mac'), pmt.cons(meta, pmt.cdr(msg)))
예제 #42
0
    def handler(self, msg):
        # get input
        meta = pmt.car(msg);
        samples = pmt.cdr(msg);
        x = numpy.array(pmt.c32vector_elements(samples), dtype=numpy.complex64)
 
        # upsample and normalize power
        xi = signal.resample(x, len(x)* (self.N / self.T));
        # compute the symbol timing
        xt = numpy.real(xi*xi.conjugate()) * numpy.exp( (-1j*2.0*numpy.pi/self.N) * numpy.linspace(1,len(xi),len(xi)) );
        s = numpy.sum(x);    
        tau = (-self.T/(2*numpy.pi)) * numpy.arctan2(numpy.imag(s), numpy.real(s));
        
        # publish timing metric for debugging
        tm = pmt.init_c32vector(xt.size, map(lambda i: complex(i), xt))
        tm_cpdu = pmt.cons(meta,tm)
        self.message_port_pub(pmt.intern("timing_metric"), tm_cpdu);

        # extract symbols
        offset = round(self.N*tau/self.T);
        fo = (offset + self.N)%self.N;
        sym = xi[fo:-1:self.N];
        
        # normalize power to 1
        sym = sym / numpy.mean(numpy.real(sym * sym.conjugate()));

        # publish timing correct symbols (with frequency offset)
        sm = pmt.init_c32vector(sym.size, map(lambda i: complex(i), sym))
        sm_cpdu = pmt.cons(meta,sm)
        self.message_port_pub(pmt.intern("sym_timed"), sm_cpdu);

        # compute symbol frequency offset (linear phase offset within block)
        x_n = numpy.power(sym[200:1000], self.O);
        phase_ramp = numpy.unwrap(numpy.angle( x_n ));
        f_off_O = numpy.mean(numpy.diff(phase_ramp));
        goodstat = numpy.std(numpy.diff(phase_ramp));
        f_off = f_off_O / self.O;

        # check percentages
        self.nburst = self.nburst + 1;
        if(goodstat < 1.0):
            self.nburst_ok = self.nburst_ok + 1;
        else:
            print "WARNING: feedforward synchronizer discarding burst, goodness metric %f < 1.0 (likely poor timing recovery occurred, the CFO phase ramp looks like garbage)"%(goodstat)
            return
        print "sync: "+str((goodstat, self.nburst, self.nburst_ok, self.nburst_ok*100.0 / self.nburst));       

        # export phase ramp
        pr = pmt.init_f32vector(phase_ramp.size, map(lambda i: float(i), phase_ramp))
        pr_fpdu = pmt.cons(meta,pr)
        self.message_port_pub(pmt.intern("phase_ramp"), pr_fpdu);

        # apply frequency offset correction
        xc = numpy.multiply(sym, numpy.exp(-1j * f_off * numpy.linspace(1,sym.size,sym.size)));
        
        # compute and correct static symbol phase offset
        xcp = numpy.power(xc[400:1000], self.O);

# linear mean
        theta = numpy.mean( numpy.angle( xcp ) ) / self.O + numpy.pi/4;
# weighted mean
#        theta = numpy.sum(numpy.angle(xcp) * numpy.abs(xcp)) / numpy.sum(numpy.abs(xcp));
#        theta = theta / self.O + numpy.pi/4;

        xc = xc * numpy.exp(-1j*theta);

        # show time, frequency and phase estimates
        #print "tau = %f, f_off = %f, theta = %f"%(tau, f_off, theta);

        # add our estimates to the metadata dictionary
        meta = pmt.dict_add(meta, pmt.intern("tau"), pmt.from_double(tau));
        meta = pmt.dict_add(meta, pmt.intern("f_off"), pmt.from_double(f_off));
        meta = pmt.dict_add(meta, pmt.intern("theta"), pmt.from_double(theta));

        # publish freq corrected symbols
        xcm = pmt.init_c32vector(xc.size, map(lambda i: complex(i), xc))
        xcm_cpdu = pmt.cons(meta,xcm)
        self.message_port_pub(pmt.intern("cpdus"), xcm_cpdu);
예제 #43
0
    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 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)
예제 #45
0
파일: fileman.py 프로젝트: garverp/recipes
def propagate_headers(options, args):
    infile = args[0]
    outfile = args[1]
    infile_hdr = infile + ".hdr"
    outfile_hdr = outfile + ".hdr"
    sample_cnt_end = 0
    sample_offset = long(options.start)
    # Open input header
    try:
        handle_in = open(infile_hdr, "rb")
    except IOError:
        sys.stderr.write("Unable to open input file header\n")
        sys.exit(1)
    # Open output header
    try:
        handle_out = open(outfile_hdr, "wb")
    except IOError:
        sys.stderr.write("Unable to open output file header\n")
        sys.exit(1)

    # Read first header separately to get file type
    hdr_in, hdr_extra_in, handle_in = read_single_header(handle_in)
    info_in = parse_file_metadata.parse_header(hdr_in, False)
    sample_cnt_end += info_in["nitems"]
    # Parse file type - ensure support for it
    shortname_intype = find_shortname(info_in["cplx"], info_in["type"], info_in["size"])
    if shortname_intype == SNAME_TO_ENUM["unknown"]:
        sys.stderr.write("Unsupported data type\n")
        sys.exit(1)
    if options.output_type == "unknown":
        shortname_outtype = shortname_intype
    else:
        shortname_outtype = SNAME_TO_ENUM[options.output_type]

    # Calc sample_len from file size if not specified
    if options.nsamples is not None:
        sample_len = long(options.nsamples)
    else:
        sample_len = os.path.getsize(infile) / SNAME_DEFS[shortname_intype][0]
    final_index = sample_offset + sample_len

    # Search input headers until we find the correct one
    while sample_cnt_end <= sample_offset:
        hdr_in, hdr_extra_in, handle_in = read_single_header(handle_in)
        info_in = parse_file_metadata.parse_header(hdr_in, False)
        sample_cnt_end += info_in["nitems"]
    time_in = info_in["rx_time"]
    # Starting sample of current segment
    sample_cnt_start = sample_cnt_end - info_in["nitems"]
    # Interpolate new timestamp
    delta = sample_offset - sample_cnt_start
    new_ts = time_in + delta / info_in["rx_rate"]
    # Calc new segment size (samples)
    if sample_cnt_end > final_index:
        first_seg_len = final_index - sample_offset
    else:
        first_seg_len = sample_cnt_end - sample_offset

    # Write the first output header
    hdr_out = hdr_in
    new_secs = long(new_ts)
    new_fracs = new_ts - new_secs
    time_val = pmt.make_tuple(pmt.from_uint64(new_secs), pmt.from_double(new_fracs))
    size_val = pmt.from_long(SNAME_DEFS[shortname_outtype][0])
    bytes_val = pmt.from_uint64(first_seg_len * SNAME_DEFS[shortname_outtype][0])
    type_val = pmt.from_long(SNAME_DEFS[shortname_outtype][2])
    hdr_out = pmt.dict_add(hdr_out, pmt.intern("rx_time"), time_val)
    hdr_out = pmt.dict_add(hdr_out, pmt.intern("bytes"), bytes_val)
    hdr_out = pmt.dict_add(hdr_out, pmt.intern("type"), type_val)
    hdr_out = pmt.dict_add(hdr_out, pmt.intern("size"), size_val)
    hdr_out_str = pmt.serialize_str(hdr_out) + pmt.serialize_str(hdr_extra_in)
    handle_out.write(hdr_out_str)

    # Continue reading headers, modifying, and writing
    last_seg_len = info_in["nitems"]
    print "sample_cnt_end=%d,final_index=%d" % (sample_cnt_end, final_index)
    # Iterate through remaining headers
    while sample_cnt_end < final_index:
        hdr_in, hdr_extra_in, handle_in = read_single_header(handle_in)
        info_in = parse_file_metadata.parse_header(hdr_in, False)
        nitems = info_in["nitems"]
        sample_cnt_start = sample_cnt_end
        sample_cnt_end += nitems
        hdr_out = hdr_in
        # For last header, adjust segment length accordingly
        if sample_cnt_end > final_index:
            last_seg_len = final_index - sample_cnt_start
        else:
            last_seg_len = nitems
        size_val = pmt.from_long(SNAME_DEFS[shortname_outtype][0])
        bytes_val = pmt.from_uint64(last_seg_len * SNAME_DEFS[shortname_outtype][0])
        type_val = pmt.from_long(SNAME_DEFS[shortname_outtype][2])
        hdr_out = pmt.dict_add(hdr_out, pmt.intern("bytes"), bytes_val)
        hdr_out = pmt.dict_add(hdr_out, pmt.intern("type"), type_val)
        hdr_out = pmt.dict_add(hdr_out, pmt.intern("size"), size_val)
        hdr_out_str = pmt.serialize_str(hdr_out) + pmt.serialize_str(hdr_extra_in)
        handle_out.write(hdr_out_str)

    if options.verbose:
        print "Input File:" + infile
        print "Input Header:" + infile_hdr
        print "Input Type:" + ENUM_TO_SNAME[shortname_intype]
        print "Output File:" + outfile
        print "Output File Length (Samples):%d" % (final_index - sample_offset)
        print "Output Header:" + outfile_hdr
        print "File subsection: [%d,%d]" % (sample_offset, final_index)
        print "Output Type:" + ENUM_TO_SNAME[shortname_outtype]
        print "First Segment Length: %e samples" % first_seg_len
        print "Last Segment Length: %e samples" % last_seg_len
        print "delta=%f,new ts=%f" % (delta, new_ts)

    # Clean up
    handle_in.close()
    handle_out.close()

    # Return header info
    return {
        "infile": infile,
        "intype": shortname_intype,
        "outfile": outfile,
        "outtype": shortname_outtype,
        "sample_offset": sample_offset,
        "sample_len": sample_len,
    }
예제 #46
0
    def handler(self, msg):
        # get input
        meta = pmt.car(msg);
        x = pmt.to_python(pmt.cdr(msg))

        if( self.sps == None and len(self.sps_samps) < 10):
            # compute the cross correlation metric first peak (to find baud rate)
            (clen, ncut) = (500,500)
            e = numpy.zeros(clen*2-1)
            for i in range(1,ncut):
                c = x[i:i+clen]
                d = numpy.correlate(c,c, mode='full')
                e += d

            # upsample to xcorr to interpolate fractional sym rate
            e = e[clen-1:]
            e_upsamp = signal.resample(e, self.upsample_rate*len(e))
            e_upsamp = e_upsamp[:len(e_upsamp)/2]
            #e_upsamp = e_upsamp[0:len(e_upsamp)/2]
            self.message_port_pub(pmt.intern("autocorr"), pmt.cons(meta, pmt.to_pmt(e_upsamp)))
    
            # locate first minimum and next peak (need to see how generalizable this is ... )
            firstmin = numpy.argmin(e_upsamp)
            firstmax = firstmin + numpy.argmax(e_upsamp[firstmin:])

            # determine samples per symbol
            sps = firstmax/self.upsample_rate
            self.sps_samps.append(sps)
            self.sps = numpy.mean(self.sps_samps)
        else:
            sps = self.sps

        meta = pmt.dict_add(meta, pmt.intern("meta"), pmt.from_double(sps));
        print "sps = %f"%(sps)
        
        ovf = []
        ovals = {}
        n_offsets = float(self.n_offsets)
        nsyms = (len(x)/sps)-1
        best = 0
        best_syms = None
        for o in numpy.arange(0,sps,sps/n_offsets):
            syms = signal.resample(x[o:o+nsyms*sps], len(x[o:])*10/(sps))
            syms = syms[0:len(syms)-len(syms)%10]
            syms = syms.reshape( [len(syms)/10, 10] )
            #syms = syms[:,4]
            syms = syms[:,3:7].mean(1)
            dist = numpy.mean(numpy.abs(syms))
            if dist > best:
                best = dist
                best_syms = syms
            ovals[o] = dist
            ovf.append(dist)

        # output timing metric (should look sinusoidal-ish)
        self.message_port_pub(pmt.intern("timing"), pmt.cons(meta, pmt.to_pmt(ovf)))
        best_offset = ovals.keys()[ numpy.argmax(ovals.values()) ]
        meta = pmt.dict_add(meta, pmt.intern("tau"), pmt.from_double(best_offset));

        # publish our recovered symbols
        self.message_port_pub(pmt.intern("pdus"), pmt.cons(meta, pmt.to_pmt(best_syms)))
예제 #47
0
    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)
예제 #48
0
파일: qa_pmt.py 프로젝트: 232675/gnuradio
 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
예제 #49
0
 def __init__(
         self,
         n_bursts, n_channels,
         freq_delta, base_freq, dsp_tuning,
         burst_length, base_time, hop_time,
         post_tuning=False,
         tx_gain=0,
         verbose=False
     ):
     gr.hier_block2.__init__(
         self, "FrequencyHopperSrc",
         gr.io_signature(1, 1, gr.sizeof_gr_complex),
         gr.io_signature(1, 1, gr.sizeof_gr_complex),
     )
     n_samples_total = n_bursts * burst_length
     lowest_frequency = base_freq - numpy.floor(n_channels/2) * freq_delta
     self.hop_sequence = [lowest_frequency + n * freq_delta for n in range(n_channels)]
     numpy.random.shuffle(self.hop_sequence)
     # Repeat that:
     self.hop_sequence = [self.hop_sequence[x % n_channels] for x in range(n_bursts)]
     if verbose:
         print("Hop Frequencies  | Hop Pattern")
         print("=================|================================")
         for f in self.hop_sequence:
             print("{:6.3f} MHz      |  ".format(f/1e6), end='')
             if n_channels < 50:
                 print(" " * int((f - base_freq) / freq_delta) + "#")
             else:
                 print("\n")
         print("=================|================================")
     # There's no real point in setting the gain via tag for this application,
     # but this is an example to show you how to do it.
     gain_tag = gr.tag_t()
     gain_tag.offset = 0
     gain_tag.key = pmt.string_to_symbol('tx_command')
     gain_tag.value = pmt.to_pmt({'gain': tx_gain})
     tag_list = [gain_tag,]
     for i in range(len(self.hop_sequence)):
         time = pmt.cons(
             pmt.from_uint64(int(base_time + i * hop_time+0.01)),
             pmt.from_double((base_time + i * hop_time+0.01) % 1),
         )
         tune_tag = gr.tag_t()
         tune_tag.offset = i * burst_length
         # TODO dsp_tuning should also be able to do post_tuning
         if i > 0 and post_tuning and not dsp_tuning:
             tune_tag.offset -= 1 # Move it to last sample of previous burst
         if dsp_tuning:
             tune_tag.key = pmt.string_to_symbol('tx_command')
             tune_tag.value = pmt.to_pmt({'lo_freq': base_freq, 'dsp_freq': base_freq - self.hop_sequence[i]})
             tune_tag.value = pmt.dict_add(tune_tag.value, pmt.intern("time"),time)
         else:
             tune_tag.key = pmt.string_to_symbol('tx_command')
             tune_tag.value = pmt.to_pmt({'freq': self.hop_sequence[i]})
             tune_tag.value = pmt.dict_add(tune_tag.value, pmt.intern('time'), time)
         tag_list.append(tune_tag)
         length_tag = gr.tag_t()
         length_tag.offset = i * burst_length
         length_tag.key = pmt.string_to_symbol('packet_len')
         length_tag.value = pmt.from_long(burst_length)
         tag_list.append(length_tag)
         time_tag = gr.tag_t()
         time_tag.offset = i * burst_length
         time_tag.key = pmt.string_to_symbol('tx_time')
         time_tag.value = pmt.make_tuple(
                 pmt.car(time),
                 pmt.cdr(time)
         )
         tag_list.append(time_tag)
     tag_source = blocks.vector_source_c((1.0,) * n_samples_total, repeat=False, tags=tag_list)
     mult = blocks.multiply_cc()
     self.connect(self, mult, self)
     self.connect(tag_source, (mult, 1))
예제 #50
0
    def handler(self, msg):
        meta = pmt.car(msg)
        bits = pmt.cdr(msg)

        self.npkt = self.npkt + 1

        # convert pmt -> int list (of bits)
        data = pmt.u8vector_elements(bits)
        ba = bitarray.bitarray(data)
        datab = ba.tobytes()

        #        print map(lambda x: hex(ord(x)), datab[0:4]);
        #        print 'Received Len Bits= ' + str(len(datab)*8)

        #        print "Rx Packet:" + str(data[0:10]);
        #        print "Rx Packet: "+":".join("{:02x}".format(ord(c)) for c in datab[0:8])
        try:
            (prefix, pktlen) = struct.unpack("<hh", datab[0:4])
            pprint.pprint({"prefix": hex(prefix), "pktlen": pktlen, "pktlen_bytes": pktlen / 8})
            if not (prefix == 0x1337):
                print "Deframer: BAD PREFIX!"
                return

            # check header crc
            c2 = binascii.crc32(datab[0:4])
            hcrc = struct.unpack("i", datab[4:8])[0]
            #        print "CRC: " + str((c2,hcrc))
            if not (c2 == hcrc):
                print "Deframer: bad header crc"
                return
            self.npkt_hok = self.npkt_hok + 1

            # make sure we got enough bits for the given header len
            if len(data) < (pktlen / 8 + 8 + 4):
                print "Deframer: not enough bits received for full payload!"
                print "Deframer: pktlen field = %d, received = %d\n" % (pktlen, len(data))
                return

            if not (pktlen % 8 == 0):
                print "Deframer: payload should be a multiple of 8"
                return

            # extract header bytes
            c1 = binascii.crc32(datab[0 : 8 + pktlen / 8])
            payload = datab[8 : 8 + pktlen / 8]
            # print "RX Payload len = %d"%(len(payload))
            # print  ":".join("{:02x}".format(ord(c)) for c in datab)
            #        print payload;
            ex_crc2 = datab[(8 + pktlen / 8) : (8 + pktlen / 8 + 4)]
        except:
            print "Not enough data to read! dropping"
            return
        try:
            c1h = struct.unpack("i", ex_crc2)[0]
            # print "rx payload CRC = %d (%s)"%(c1h, ":".join("{:02x}".format(ord(c)) for c in ex_crc2))
        except:
            print "shortened packet length dropping"
            return
        #        print "CRC2:" + str((c1, c1h));
        if not c1 == c1h:
            print "Failed payload CRC"
            return

        #        print "BURST OK!"
        self.npkt_ok = self.npkt_ok + 1
        pct_ok = 100.0 * self.npkt_ok / self.npkt
        pct_hok = 100.0 * self.npkt_hok / self.npkt
        print "Deframer: Percent ok = %f (%f header)%%" % (pct_ok, pct_hok)

        # send it on its way
        payload = numpy.fromstring(payload, dtype=numpy.uint8)
        v = pmt.to_pmt(payload)
        meta = pmt.dict_add(meta, pmt.intern("timestamp"), pmt.from_double(time.time()))
        meta = pmt.dict_add(meta, pmt.intern("npkt"), pmt.from_long(self.npkt))
        meta = pmt.dict_add(meta, pmt.intern("npkt_hok"), pmt.from_long(self.npkt_hok))
        meta = pmt.dict_add(meta, pmt.intern("npkt_ok"), pmt.from_long(self.npkt_ok))
        meta = pmt.dict_add(meta, pmt.intern("header_pass_rate"), pmt.from_double(pct_hok))
        meta = pmt.dict_add(meta, pmt.intern("payload_pass_rate"), pmt.from_double(pct_ok))
        pdu = pmt.cons(meta, v)
        self.message_port_pub(pmt.intern("pdus"), pdu)
예제 #51
0
파일: mkheader.py 프로젝트: garverp/recipes
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()