Exemplo n.º 1
0
    def test_004_es_source_pdus(self):
        print "test_004_es_source_pdus"       
        msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ), 
                        pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) );
        src = es.source([gr.sizeof_float], 8, 2);
        stb = blocks.message_strobe( msg, 100.0 );
        tb = gr.top_block();
        tb.msg_connect(stb, "strobe", src, "schedule_event");
        th = blocks.throttle(gr.sizeof_float, 1000*100);
        hd = blocks.head(gr.sizeof_float, 1000*100);
        snk = blocks.vector_sink_f();
        tb.connect(src,th,hd,snk);

        # TODO: this can not use run because it is 
        # subject to GNU Radio's shutdown msg block bug
        # for remaining upstream msg blocks ...
        #tb.run();

        # workaround
        tb.start();
        time.sleep(1);
        tb.stop();
        tb.wait();

        self.assertEqual( sum(snk.data())>0, True );
Exemplo n.º 2
0
    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))
Exemplo n.º 3
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()
Exemplo n.º 4
0
    def test_001_t(self):
        # Constants
        tag_key = 'in1_tag'
        tag_value = 0
        tag_offset = 0
        in0_value = 1.0+1.0j
        in1_value = 2.717
        in0_data = (in0_value,)*10
        in1_data = (in1_value,)*10
        sink_data = in0_data

        tag = gr.tag_t()
        tag.key = pmt.to_pmt(tag_key)
        tag.value = pmt.to_pmt(tag_value)
        tag.offset = tag_offset

        # Only tag Input 1 of the share block and see if it transfers
        # to Output 0. Also verify that Input 0 stream is propagated to
        # Output 0.
        in0 = blocks.vector_source_c(in0_data, False, 1)
        in1 = blocks.vector_source_f(in1_data, False, 1, (tag,))
        tag_share = blocks.tag_share(gr.sizeof_gr_complex, gr.sizeof_float)
        sink = blocks.vector_sink_c(1)

        self.tb.connect(in0, (tag_share,0))
        self.tb.connect(in1, (tag_share,1))
        self.tb.connect(tag_share, sink)
        self.tb.run()

        self.assertEqual(len(sink.tags()), 1)
        self.assertEqual(pmt.to_python(sink.tags()[0].key), tag_key)
        self.assertEqual(pmt.to_python(sink.tags()[0].value), tag_value)
        self.assertEqual(sink.tags()[0].offset, tag_offset)
        self.assertEqual(sink.data(), sink_data)
Exemplo n.º 5
0
 def send_response(self, response):
     response_msg = response.strip()
     response = numpy.fromstring(response, dtype=numpy.uint8)
     response = pmt.to_pmt(response)
     response = pmt.cons(pmt.to_pmt(None), response)
     # self.debug_msg('Responding with {}'.format(response_msg))
     self.message_port_pub(pmt.intern('out'), response)
Exemplo n.º 6
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()
Exemplo n.º 7
0
	def to_spec_sense(self, meta, data):
		meta = pmt.to_pmt(meta)
		data = pmt.to_pmt(data)
		pdu = pmt.cons(meta, data) #make the PDU
		#publish PDU to msg port
		self.message_port_pub(pmt.intern('to_spect_sens'),pdu)
		return None
Exemplo n.º 8
0
    def handle_demod_classic(self, pdu):
        t0 = time.time()
        self.demod_packet_cnt += 1
        tag_dict = pmt.car(pdu)
        vec = pmt.to_python(pmt.cdr(pdu))
        _, _, new_echo_s, my_echo_s = self.split_packet_iq(vec)
        bits = util_data.integers_to_bits(self.demod.demodulate(vec),
                                          self.bits_per_symbol)
        spy, hdr, new_echo, _ = self.split_packet_bits(bits)
        # Check spy header to see if packet is corrupt
        if self.spy_length > 0:
            spy_ber = sum(spy != self.spy_master) * 1.0 / self.spy_length
        else:
            spy_ber = 0
        # Interpret header
        if hdr is not None:
            idxpre = hdr[0]
            idxecho = hdr[1]
            valid = hdr[2]
        else:
            valid = False
            idxpre = (1 << 16) - 1
            idxecho = (1 << 16) - 1
            if spy_ber < self.spy_threshold:
                self.logger.debug(
                    "classic demod {} spy passed ({}) but header failed to decode"
                    .format(self.uuid_str, spy_ber))
        if spy_ber > self.spy_threshold:
            # BAD PACKET!
            self.logger.debug(
                "classic demod {} spy ber {} above threshold {}".format(
                    self.uuid_str, spy_ber, self.spy_threshold))
            # Publish to both ports so mod can decide what to do with the bad packet
            #self.message_port_pub(self.port_id_corrupt,
            #                      pmt.cons(pmt.PMT_NIL, pmt.to_pmt(bits.astype(np.int8))))
            self.message_port_pub(
                self.port_id_demod_out,
                pmt.cons(pmt.PMT_NIL, pmt.to_pmt(bits.astype(np.int8))))
        else:
            # Publish good packet
            self.demod_update_cnt += 1
            self.message_port_pub(
                self.port_id_demod_out,
                pmt.cons(pmt.PMT_NIL, pmt.to_pmt(bits.astype(np.int8))))

            try:
                preamble = self.get_preamble_hist(idxecho)[:self.preamble.size]
                ber = sum(preamble != new_echo) * 1.0 / self.preamble.size
                if self.demod_update_cnt % self.log_interval == 0 or self.run_mode == 'freeze':
                    with open("ber_{}.csv".format(self.uuid_str), "a") as f:
                        f.write("{},{}\n".format(self.demod_update_cnt, ber))
            except KeyError as e:
                self.logger.info(
                    "DEBUG::Unable to calculate BER with stored index {}".
                    format(idxecho))
        t1 = time.time()
        self.logger.debug(
            "classic demod {} handled {} bits in {} seconds".format(
                self.uuid_str, bits.size, t1 - t0))
        return bits
Exemplo n.º 9
0
 def send_response(self, response):
     response_msg = response.strip()
     response = numpy.fromstring(response, dtype=numpy.uint8)
     response = pmt.to_pmt(response)
     response = pmt.cons(pmt.to_pmt(None), response)
     # self.debug_msg('Responding with {}'.format(response_msg))
     self.message_port_pub(pmt.intern('out'), response)
Exemplo n.º 10
0
 def publish_to_ports(self, range_rate):
     shifted_downlink = self.downlink_frequency * (1.0 - range_rate / SPEED_OF_LIGHT)
     shifted_uplink = self.uplink_frequency * (1.0 + range_rate / SPEED_OF_LIGHT)
     self.message_port_pub(
         pmt.intern("downlink_shift"), pmt.to_pmt(self.downlink_frequency - shifted_downlink))
     self.message_port_pub(
         pmt.intern("uplink_shift"), pmt.to_pmt(self.uplink_frequency - shifted_uplink))
Exemplo n.º 11
0
    def _parse_payload(self):
        if self.uf_str == 'UF0':
            self.rl = self.payload[8]
            self.aq = self.payload[13]
            self.ds = self.payload[14:22]
            self.ap = self.payload[32:32 + 24]

            if self.verbose:
                #print '\n'
                print '----------------------------------------------------------------------'
                print self.meta
                print len(self.payload), self.payload
                print 'datetime: {:s}'.format(self.meta['datetime'])
                print '     SNR: {:2.2f} dB'.format(self.meta['snr'])
                print '    SYNC: {:d}'.format(self.meta['sync'])
                print '      UF: {:d} {:s}'.format(self.uf,
                                                   UF_STR_LUT[self.uf])
                print '      RL: {:d}'.format(self.rl)
                print '      AQ: {:d}'.format(self.aq)
                print '      DS: 0x{:04x}'.format(self.bin2dec(self.ds))
                print ' bits AP:', self.ap
                print '  hex AP: 0x{:06x}'.format(self.bin2dec(self.ap))

            #Create output pdu and emit
            meta = pmt.to_pmt(self.meta)
            vector = pmt.to_pmt(self.payload)
            pdu = pmt.cons(meta, vector)
            self.message_port_pub(pmt.intern('out'), pdu)
Exemplo n.º 12
0
    def tag_end_preamble(self, freq_shift, fine_freq_shift, time_shift,
            fine_delay, sync_value, sof_idx):
        #Prepare tag
        #This delay estimator has an uncertainty of +/-M (by steps of M/2).
        #So we put the tag M items before the estimated SOF item, to allow
        #A successive block to remove this uncertainty.
        tag_offset = self.nitems_written(0) + time_shift + sof_idx*self.M \
                + self.M//4

        tag1_key = pmt.intern('fine_freq_offset')
        tag1_value = pmt.to_pmt(fine_freq_shift)
        tag2_key = pmt.intern('coarse_freq_offset')
        tag2_value = pmt.to_pmt(freq_shift/self.M)
        tag3_key = pmt.intern('sync_word')
        tag3_value = pmt.to_pmt(sync_value)
        tag4_key = pmt.intern('time_offset')
        tag4_value = pmt.to_pmt(int(time_shift))
        tag5_key = pmt.intern('fine_time_offset')
        tag5_value = pmt.to_pmt(float(fine_delay))

        #Append tags
        self.add_item_tag(0, tag_offset, tag1_key, tag1_value)
        self.add_item_tag(0, tag_offset, tag2_key, tag2_value)
        self.add_item_tag(0, tag_offset, tag3_key, tag3_value)
        self.add_item_tag(0, tag_offset, tag4_key, tag4_value)
        self.add_item_tag(0, tag_offset, tag5_key, tag5_value)
Exemplo n.º 13
0
 def update_file_range(self):
     try:
         (s, l) = self.f_range
         meta = {
             "start": s,
             "len": l,
             "end": s + l,
             "filename": self.filename
         }
         self.F.seek(s * self.itemsize)
         if self.force_complex:
             vec = numpy.fromfile(self.F,
                                  dtype=self.filetype,
                                  count=2 * l,
                                  sep='')
             vec = vec[0::2] + 1j * vec[1::2]
         else:
             vec = numpy.fromfile(self.F,
                                  dtype=self.filetype,
                                  count=l,
                                  sep='')
         vec = numpy.array(vec, dtype="complex64")
         self.message_port_pub(pmt.intern("pdus"),
                               pmt.cons(pmt.to_pmt(meta), pmt.to_pmt(vec)))
     except:
         pass
Exemplo n.º 14
0
 def test_011_tag1 (self):
     # set up fg
     tags = []
     tags.append(gr.tag_utils.python_to_tag((2, pmt.to_pmt("the_key"), pmt.to_pmt("the_value"), pmt.PMT_NIL)))
     tags.append(gr.tag_utils.python_to_tag((3, pmt.to_pmt("hehe"), pmt.to_pmt("the_value"), pmt.PMT_NIL)))
     #tags.append(gr.tag_utils.python_to_tag((4, pmt.to_pmt("end"), pmt.to_pmt("vector_source_c"), pmt.PMT_NIL)))
     self.src = blocks.vector_source_c([1,2,3,4,5], tags=tags)
     self.dst = blocks.vector_sink_c()
     self.repeating = capture_tools.repeat_input_n_times_cc(3, 1000)
     self.repeating.set_tag_propagate_end(False)
     self.repeating.set_tag_add_repeat(False)
     self.tb.connect(self.src, self.repeating, self.dst)
     self.tb.run ()
     tags = self.dst.tags()
     #for t in tags:
     #    print("HER: "+str(t.offset))
     self.assertEqual(self.dst.data() , ((1+0j), (2+0j), (3+0j), (4+0j), (5+0j), (1+0j), (2+0j), (3+0j), (4+0j), (5+0j), (1+0j), (2+0j), (3+0j), (4+0j), (5+0j)))
     self.assertEqual(len(tags), 7)
     self.assertEqual(str(tags[0].key), "the_key")
     self.assertEqual(str(tags[0].value), "the_value")
     self.assertEqual(int(tags[0].offset), 2)
     self.assertEqual(str(tags[2].key), "the_key")
     self.assertEqual(str(tags[2].value), "the_value")
     self.assertEqual(int(tags[2].offset), 7)
     self.assertEqual(str(tags[4].key), "the_key")
     self.assertEqual(str(tags[4].value), "the_value")
     self.assertEqual(int(tags[4].offset), 12)
     self.assertEqual(str(tags[3].key), "hehe")
     self.assertEqual(str(tags[3].value), "the_value")
     self.assertEqual(int(tags[3].offset), 8)
Exemplo n.º 15
0
    def work(self, input_items, output_items):
        """
        Send out packets to be encoded and sent to the transmitter

        :param input_items:
        :param output_items:
        :return:
        """
        out = output_items[0]

        if not self.out_packet:
            return 0
        else:
            packet_len = self.out_packet.size
            out[:packet_len] = self.out_packet
            out[packet_len + 1] = 0

            self.add_item_tag(
                0,  # Port number
                self.nitems_written(0),  # Offset
                pmt.intern(f'Packet start'),
                pmt.to_pmt(self.received_packets))

            self.add_item_tag(
                0,  # Port number
                self.nitems_written(0) + packet_len,  # Offset
                pmt.intern(f'Packet end'),
                pmt.to_pmt(self.received_packets))

            self.received_packets += 1
            self.out_packet = None
            self.status = self.Status.WAITING

            print(f'Pkt source: output of {packet_len} items')
            return packet_len + 1
Exemplo n.º 16
0
    async def process_cmd(self, msg):
        print(f'Received cmd: {msg}')
        cmd = msg[0]

        # Data packet
        if cmd == 0:
            print(f'Sending packet to modulator')
            # TODO: eeeeh not really
            data = self.preamble + msg[1:]

            # print(f"Received {data.hex()}")
            data = numpy.frombuffer(data, dtype=numpy.uint8)

            self.out_packet = data

            self.status = self.Status.SENDING

        # Pass to board interface
        elif cmd == 1:
            print(f'Passing message to board interface')
            message = pmt.cons(pmt.intern('cmd'), pmt.to_pmt(msg[1:].hex()))
            self.message_port_pub(pmt.intern(self.port_out_name), message)

        # Pass rf pkt to board interface
        elif cmd == 2:
            print(f'Passing rf pkt to board interface')
            message = pmt.cons(pmt.intern('rf'), pmt.to_pmt(msg[1:].hex()))
            self.message_port_pub(pmt.intern(self.port_out_name), message)
Exemplo n.º 17
0
    def test_003_trim_from_end(self):
        orig_array = np.array([1.1, 2.2, 3.3, 4.4, 5.5])
        expected_out_array = np.array([1.1, 2.2, 3.3])
        metadata = {'a': 1, 'b': 2}
        in_pmt = pmt.cons(pmt.to_pmt(metadata), pmt.to_pmt(orig_array))
        expected_pmt = pmt.cons(pmt.to_pmt(metadata),
                                pmt.to_pmt(expected_out_array))

        # We just need something connected to the trimmer block for
        # the flowgraph to compile, but we'll post messages to it directly
        src = blocks.message_strobe(pmt.PMT_NIL, 9999999)
        trimmer = pdu_trim_uvector(0, 2)
        snk = blocks.message_debug()

        self.tb.msg_connect((src, 'strobe'), (trimmer, 'in'))
        self.tb.msg_connect((trimmer, 'out'), (snk, 'store'))

        self.tb.start()
        trimmer.to_basic_block()._post(pmt.intern('in'), in_pmt)
        time.sleep(0.1)
        self.tb.stop()
        self.tb.wait()

        # check data
        self.assertEqual(snk.num_messages(), 1)
        self.assertTrue(pmt.equal(snk.get_message(0), expected_pmt))
Exemplo n.º 18
0
    def test_generic_output(self):
        messages = [
            pmt.to_pmt('foo'),
            pmt.to_pmt('bar'),
            pmt.to_pmt({'foo': [1, 2]})
        ]
        for parameters, expected_output in [
            (dict(output=OutputType.RAW), 'foo\nbar\n((foo . #(1 2)))\n'),
            (dict(output=OutputType.PYTHON), "foo\nbar\n{'foo': [1, 2]}\n"),
        ]:
            with self.subTest(parameters=parameters,
                              expected_output=expected_output):
                # sub-tests don't call tearDown / setUp
                self.tearDown()
                self.setUp()
                # given
                self._setup_graph(messages, **parameters)

                # when
                out = io.StringIO()
                with contextlib.redirect_stdout(out):
                    self._run()

                # then
                self.assertEqual(out.getvalue(), expected_output)
    def work(self, input_items, output_items):
        in0 = input_items[0]
        in1 = input_items[1]

        #if we have data to classify:
        if len(in0) >= 1 and len(self.bw_list) > self.sig_no:
            #create the feature vector
            x = [self.bw_list[self.sig_no]]
            x.extend(in0[0])
            x.extend(in1[0])
            x_tmp = []

            x_tmp.append(x)

            #predict!
            a = self.knn.predict(x_tmp)

            #print "Signal #"+ str(self.sig_no)+" :" +a[0]

            #write to the output message port.
            pmt_signal = pmt.to_pmt(("signal", self.sig_no))
            pmt_class = pmt.to_pmt((a[0], 0))
            pmt_tuple = pmt.make_tuple(pmt_signal, pmt_class)

            self.message_port_pub(pmt.intern("classification"), pmt_tuple)

        #consume, finish
        self.consume(0, len(in0))
        self.consume(1, len(in1))
        return len(input_items[0])
Exemplo n.º 20
0
    def tx_work(self, x):

        pygame.init()
        screen = pygame.display.set_mode((640, 480))
        pygame.display.set_caption('Pygame Caption')
        pygame.mouse.set_visible(0)

        done = False
        while not done:
            time.sleep(0.1)
            for event in pygame.event.get():
                if (event.type == KEYUP) or (event.type == KEYDOWN):
                    print event
                    if (event.key == K_ESCAPE and event.type == KEYDOWN):
                        dict2 = {"id": "joystick", "buttons": [1, 0, 0]}
                        #pmt_dict = pmt.to_pmt(dict2)
                        self.message_port_pub(pmt.intern('out'),
                                              pmt.to_pmt(dict2))
                    if (event.key == K_ESCAPE and event.type == KEYUP):
                        dict2 = {"id": "joystick", "buttons": [0, 0, 0]}
                        #pmt_dict = pmt.to_pmt(dict2)
                        self.message_port_pub(pmt.intern('out'),
                                              pmt.to_pmt(dict2))
                        print 'here'
        '''
 def set_takeoff(self, takeoff):
     if (takeoff == 1):
         meta = pmt.to_pmt('takeoff')
         data = pmt.to_pmt(self.altitude)
         msg = pmt.cons(meta, data)
         print('send_zmq')
         self.zmqc.send(pmt.serialize_str(msg))
 def set_land(self, land):
     self.land = land
     meta = pmt.to_pmt('land')
     data = pmt.to_pmt(1)
     msg = pmt.cons(meta, data)
     print('send_zmq')
     self.zmqc.send(pmt.serialize_str(msg))
Exemplo n.º 23
0
    def test_003_2_byte_sync(self):
        orig_array = np.array([1, 0, 1, 0, 1, 0, 1], dtype=np.uint8)
        metadata = {'a': 1, 'b': 2}
        expected_array = np.array([
            1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1
        ],
                                  dtype=np.uint8)
        in_pmt = pmt.cons(pmt.to_pmt(metadata), pmt.to_pmt(orig_array))
        expected_pmt = pmt.cons(pmt.to_pmt(metadata),
                                pmt.to_pmt(expected_array))

        appender = add_sync_pdu(0xf023, 2)
        snk = blocks.message_debug()

        self.tb.msg_connect((appender, 'out'), (snk, 'store'))

        self.tb.start()
        appender.to_basic_block()._post(pmt.intern('in'), in_pmt)
        time.sleep(0.1)
        self.tb.stop()
        self.tb.wait()

        # check data
        self.assertEqual(snk.num_messages(), 1)
        self.assertTrue(pmt.equal(snk.get_message(0), expected_pmt))
Exemplo n.º 24
0
 def vector_handler(self, msg):
     meta = pmt.to_python(pmt.car(msg))
     databuf = pmt.to_python(pmt.cdr(msg))
     data = numpy.frombuffer(databuf, dtype=numpy.uint32)
     print "vector handler"
     print data
     self.data[0] = int(data[0])
     self.data[1] = int(data[1])
     self.data[2] = int(data[2])
     self.data[7] = int(data[7])
     if (data[8] == 1):
         meta = pmt.to_pmt('takeoff')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
     elif (data[8] == 2):
         meta = pmt.to_pmt('land')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
     elif (data[8] == 3):
         meta = pmt.to_pmt('rc_override')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
     elif (data[8] == 4):
         meta = pmt.to_pmt('disarm')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
     elif (data[8] == 5):
         meta = pmt.to_pmt('heartbeat')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
     self.message_port_pub(pmt.intern("Control_OUT"), msg)
Exemplo n.º 25
0
    def tx_work(self,x):
		
		pygame.init()
		screen = pygame.display.set_mode((640, 480))
		pygame.display.set_caption('Pygame Caption')
		pygame.mouse.set_visible(0)
		 
		done = False
		while not done:
		   time.sleep(0.1)
		   for event in pygame.event.get():
			  if (event.type == KEYUP) or (event.type == KEYDOWN):
				 print event
				 if (event.key == K_ESCAPE and event.type == KEYDOWN):
					dict2 = { "id" : "joystick",
					"buttons" : [1,0,0]}
					#pmt_dict = pmt.to_pmt(dict2)
					self.message_port_pub(pmt.intern('out'),pmt.to_pmt(dict2))
				 if (event.key == K_ESCAPE and event.type == KEYUP):
					dict2 = { "id" : "joystick",
					"buttons" : [0,0,0]}
					#pmt_dict = pmt.to_pmt(dict2)
					self.message_port_pub(pmt.intern('out'),pmt.to_pmt(dict2))
					print 'here'

					 
				
		'''
Exemplo n.º 26
0
    def general_work(self, input_items, output_items):

        # this block only works with single input port, so make a convenience var for ch0
        inp = input_items[0]


        # check if we need to look for a header
        if self.nitems_remaining <= 0:

            # make sure there's a whole header plus first payload byte available
            if len(inp) >= self.hdr_len + 1:
                pad_len, frame_len = struct.unpack(self.hdr_fmt, inp[:self.hdr_len])

                packet_len = frame_len - self.hdr_len
                self.nitems_remaining = packet_len - 1


                # add stream tags for payload len and zero pad len
                offset = self.nitems_written(0)

                self.add_item_tag(0, offset,
                                  self.zero_pad_tag_name,
                                  pmt.to_pmt(pad_len))

                self.add_item_tag(0, offset,
                                  self.len_tag_name,
                                  pmt.to_pmt(packet_len))

                # keep track of where we are in the input chain
                self.consume_each(self.hdr_len + 1)
                output_items[0][0] = inp[self.hdr_len]
                return 1
            # if a full header isn't available in inp, return and hope for better
            # luck next iteration
            else:
                return 0

        # this should always be true at this point
        if self.nitems_remaining > 0:

            # figure out how many items we can output
            noutput_items = min(len(inp), len(output_items[0]), self.nitems_remaining)

            output_items[0][:noutput_items] = inp[:noutput_items]

            # consume header and all items we just passed to output and return
            self.consume_each(noutput_items)

            self.nitems_remaining -= noutput_items
            return noutput_items

        else:
            # we should not be able to get here...
            print("Warning, traffic parser is hitting an unexpected state")
            return 0

        # we shouldn't be able to get here either
        print("Warning, traffic parser is hitting another unexpected state")
        return 0
Exemplo n.º 27
0
 def send_msg(self, meta, data):
     # construct pdu and publish to radio port
     # data = pmt.intern(str(data)) #convert from string
     meta = pmt.to_pmt(meta)
     data = pmt.to_pmt(data)
     pdu = pmt.cons(meta, data)  # make the PDU
     # publish PDU to msg port
     self.message_port_pub(pmt.intern("PDU spect_msg"), pdu)
 def set_disarm(self, disarm):
     self.disarm = disarm
     if self.disarm == 1:
         meta = pmt.to_pmt('disarm')
         pmtdata = pmt.to_pmt(self.data)
         msg = pmt.cons(meta, pmtdata)
         print('send_zmq disarm')
         self.zmqc.send(pmt.serialize_str(msg))
Exemplo n.º 29
0
 def update_file_range(self):
     (s, l) = self.f_range
     meta = {"start": s, "len": l, "end": s + l, "filename": self.filename}
     self.F.seek(s * self.itemsize)
     vec = numpy.fromfile(self.F, dtype=self.filetype, count=l, sep='')
     vec = numpy.array(vec, dtype="complex64")
     self.message_port_pub(pmt.intern("pdus"),
                           pmt.cons(pmt.to_pmt(meta), pmt.to_pmt(vec)))
Exemplo n.º 30
0
def make_tag(key, value, offset, srcid=None):
    tag = gr.tag_t()
    tag.key = pmt.string_to_symbol(key)
    tag.value = pmt.to_pmt(value)
    tag.offset = offset
    if srcid is not None:
        tag.srcid = pmt.to_pmt(srcid)
    return tag
Exemplo n.º 31
0
def make_tag(key, value, offset, srcid=None):
    tag = gr.tag_t()
    tag.key = pmt.string_to_symbol(key)
    tag.value = pmt.to_pmt(value)
    tag.offset = offset
    if srcid is not None:
        tag.srcid = pmt.to_pmt(srcid)
    return tag
Exemplo n.º 32
0
 def send_msg(self, meta, data):
     #construct pdu and publish to radio port
     #data = pmt.intern(str(data)) #convert from string
     meta = pmt.to_pmt(meta)
     data = pmt.to_pmt(data)
     pdu = pmt.cons(meta, data)  #make the PDU
     #publish PDU to msg port
     self.message_port_pub(pmt.intern('PDU spect_msg'), pdu)
Exemplo n.º 33
0
    def sync_fsm(self):
        if self.sync_state == 'INIT':
            #select a sub-channel at random from the hop_sequence!!
            #rnd_sync_listen_channel = random.randint(0, sequence_length)
            #how? doesn't have access to xorshift/hop_sequence, which is internal to the FH message strobe block?
            #implement later, currently set to center_freq
            if self.hopset_loaded == 'FALSE':
                try:
                    self.d_py_hop_seq = self.hopset_import(self.d_py_hop_seq)
                    self.hopset_loaded = 'TRUE'
                    print "\n Hopset Loaded \n"
                except:
                    print "ERROR: Failed to load hopset"
            if self.init_tune == 'FALSE':
                init_freq_pmt = pmt.to_pmt(self.d_center_freq)
                self.message_port_pub(pmt.intern('rx_freq_out'), init_freq_pmt)
                self.init_tune = 'TRUE'
                print "Radio Tuned for INIT"
            #publish this pmt to the freq_out port

            #INIT SYNC times out
            if (time.time() - self.last_sync_time) >= self.sync_rx_timeout:
                print "Time elapsed is: ", (time.time() - self.last_sync_time)
                print "Failed to acquire Sync after: %03d. Defaulting to internal time." % (
                    self.sync_rx_timeout)
                #self.send_sync_pkt() needs to broadcast sync on all channels
                #broadcast sync packets to every channel
                #work through the hop_sequence from 0-sequence_length?
                self.sync_state = 'SYNCED'
                self.last_sync_time = time.time()
                print "New Sync Time is: ", self.last_sync_time

        #if sync_state == SYNCED
        if self.sync_state == 'SYNCED' and (
            (time.time() - self.last_sync_time) >= self.sync_tx_interval):
            self.send_sync_pkt()
            self.last_sync_time = time.time()

        if self.sync_state == 'SYNCED' and (
            (time.time() - self.last_sync_time) >= self.sync_rx_timeout):
            print "Changing state to INIT after: ", self.sync_rx_timeout
            self.sync_state = 'INIT'
            self.init_tune = 'FALSE'
            self.last_sync_time = time.time()

        if self.sync_state == 'SYNCED':
            d_time_ms = (datetime.now().minute *
                         60000) + (datetime.now().second *
                                   1000) + (datetime.now().microsecond / 1000)
            d_current_hop = (d_time_ms /
                             self.d_period_ms) % self.d_sequence_length
            #print "Length of Sequence is: ", len(self.d_py_hop_seq)
            #print "Current Hop Index is: ", d_current_hop
            d_current_freq = self.d_py_hop_seq[d_current_hop]
            fh_rx_freq_pmt = pmt.to_pmt(d_current_freq + self.d_center_freq)
            fh_tx_freq_pmt = pmt.to_pmt(d_current_freq)
            self.message_port_pub(pmt.intern('rx_freq_out'), fh_rx_freq_pmt)
            self.message_port_pub(pmt.intern('tx_freq_out'), fh_tx_freq_pmt)
Exemplo n.º 34
0
 def work(self, input_items, output_items):
     output_items[0][:] = input_items[0]
     if self.inject_tag:
         offset = self.nitems_read(0)
         for key, val in self.inject_tag.items():
             self.add_item_tag(0, offset, pmt.to_pmt(key), pmt.to_pmt(val))
         self.injected_offset = offset
         self.inject_tag = None
     return len(output_items[0])
Exemplo n.º 35
0
 def range_received(self, msg):
     (s,l) = pmt.to_python(msg)
     meta = {"start":s, "len":l, "end":s+l, "filename":self.filename}
     self.F.seek(s*self.itemsize)
     vec = numpy.fromfile(self.F, dtype=numpy.complex64, count=l, sep='')
     self.message_port_pub(pmt.intern("pdus"), 
         pmt.cons(
             pmt.to_pmt(meta),
             pmt.to_pmt(vec) ))
Exemplo n.º 36
0
 def update_file_range(self):
     (s,l) = self.f_range
     meta = {"start":s, "len":l, "end":s+l, "filename":self.filename}
     self.F.seek(s*self.itemsize)
     vec = numpy.fromfile(self.F, dtype=self.filetype, count=l, sep='')
     vec = numpy.array(vec, dtype="complex64")
     self.message_port_pub(pmt.intern("pdus"), 
         pmt.cons(
             pmt.to_pmt(meta),
             pmt.to_pmt(vec) ))
Exemplo n.º 37
0
 def test_001_t (self):
     # set up fg
     tag1 = gr.tag_utils.python_to_tag((0, pmt.to_pmt("ramp_up"), pmt.to_pmt("the_value"), pmt.PMT_NIL))
     tag2 = gr.tag_utils.python_to_tag((25, pmt.to_pmt("ramp_down"), pmt.to_pmt("the_value"), pmt.PMT_NIL))
     self.src = blocks.vector_source_c([1+2j,1+2j,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1], tags=[tag1, tag2])
     self.dut = capture_tools.add_rampup_cc(0.4)
     self.dst = blocks.vector_sink_c()
     self.tb.connect(self.src, self.dut, self.dst)
     self.tb.run ()
     print(self.dst.data())
Exemplo n.º 38
0
    def test_1(self):
        datas = (
            0, 1, 2,  5, 6,     10,          14, 15, 16,
            3, 4,     7, 8, 9,  11, 12, 13,  17
        )
        expected = tuple(range(18))

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

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

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

        tags = [gr.tag_to_python(x) for x in snk.tags()]
        tags = sorted([(x.offset, x.key, x.value) for x in tags])
        tags_expected = [
                (0, 'packet_length', 5),
                (5, 'packet_length', 5),
                (6, 'spam', 42),
                (8, 'eggs', 23),
                (10, 'packet_length', 4),
                (14, 'packet_length', 4)
        ]
        self.assertEqual(tags, tags_expected)
Exemplo n.º 39
0
    def work(self, input_items, output_items):

        tensordata = []
        input_i = []
        shapev = np.array(input_items[0]).shape

        for item in range(shapev[0]):

            inp = np.array(input_items[0][item])

            if self.dtype == np.complex64:

                # complex data must be split into real 
                # and imaginary floats for the ANN
                tensordata.append(np.array([[inp.real,inp.imag]]))

            elif self.dtype == np.float32:

                if np.mean(inp) == 0.0:
                    return len(input_items[0])

                ## Normalise data
                inp = (inp - np.mean(inp)) / np.std(inp)

                ## Reshape data as specified
                if not self.reshape == ():
                    floats = np.reshape(inp,self.reshape)
                else:
                    floats = inp

                tensordata.append(np.array([floats]))

        ne = []
        for v in tensordata:
            try:
                #print("In: ",self.inp,"Out : ",self.out)
                #print("Inp ",v)
                outp = self.sess.run(self.out, feed_dict={self.inp: [v]})[0]
                #print("OUTP ",outp)
                ne.append(outp)
            except tf.errors.InvalidArgumentError:
                print("Invalid size of input vector to TensorFlow model")
                quit()

        pmtv = pmt.make_dict()
        for outp in ne:
            pmtv = pmt.make_tuple(pmt.to_pmt(("signal",self.signum)),pmt.to_pmt((self.classes[np.argmax(outp)],outp[np.argmax(outp)].item())))

            self.message_port_pub(pmt.intern("classification"), pmtv)

        return len(input_items[0])
Exemplo n.º 40
0
 def test_001_t (self):
     # set up fg
     tags= []
     tags.append(gr.tag_utils.python_to_tag((2, pmt.to_pmt("add_here"), pmt.to_pmt("the_value"), pmt.PMT_NIL)))
     tags.append(gr.tag_utils.python_to_tag((5, pmt.to_pmt("add_here"), pmt.to_pmt("the_value"), pmt.PMT_NIL)))
     src = blocks.vector_source_c([1,2,3,4,5,6,7,8,9], tags=tags)
     dut = capture_tools.add_at_tag_cc(10,10,0,"add_here")
     dst = blocks.vector_sink_c()
     self.tb.connect(src,dut,dst)
     self.tb.run ()
     print(dst.data())
     print("Tags:")
     for t in dst.tags():
         print(str(t.offset)+": "+str(t.key)+"")
Exemplo n.º 41
0
    def handle_msg(self, msg):
	# save the feedback from-decoder 
	self.feedback.extend(pmt.to_python(msg))
	# encrypted data
	ciphertext = []
        # consumed feedback
        feedback = []
        # consumed plain text
        plaintext = []
        # consume feedback from encoder
	while (min(len(self.feedback),len(self.plain_text)) > 0):
		# consume a feedback item
		f = self.feedback.pop(0)
                feedback.append(f)
		# consume a key bit
		k = self.key_bit.pop(0)
		if f: # positive feedback?
			# get a data bit
			d = self.plain_text.pop(0)
			plaintext.append(d)
			# post encrypted data bit
			ciphertext.append(int(k^d))
	if self.debug: 
           sys.stderr.write("encoder.handle_msg():feedback: " + \
                str(feedback) + "\n")
	if self.debug: 
           sys.stderr.write("encoder.handle_msg():plain text: " + \
                str(plaintext) + \
		" cipher text: " + str(ciphertext) + "\n")
        # post encrypted data
        self.message_port_pub(pmt.intern('ciphertext'),
           pmt.to_pmt(ciphertext))
Exemplo n.º 42
0
    def encode_decode_test(self, payload_str="TEST", whitening=False, encode_crc=False, decode_crc=False):
        preamble = "01010101"
        sync1 = 0x2
        sync2 = 0x3
        sync_length = 2
        payload = [ord(c) for c in payload_str]

        strobe = blocks.message_strobe(pmt.cons(pmt.PMT_NIL, pmt.to_pmt(payload)), 200)
        encoder = cc11xx_encoder.cc11xx_encoder(preamble=[int(preamble, 2)], syncword=[sync1, sync2], whitening=whitening, crc=encode_crc)
        pdu_to_stream = blocks.pdu_to_tagged_stream(blocks.byte_t, "packet_len")
        debug = blocks.message_debug()
        self.tb.msg_connect(strobe, "strobe", encoder, "in")
        self.tb.msg_connect(encoder, "out", pdu_to_stream, "pdus")

        unpack = blocks.packed_to_unpacked_bb(1, 0)

        acc_code_block =  digital.correlate_access_code_tag_bb(preamble, 0, "preamble")
        deframer = cc11xx.cc11xx_deframer_bb(sync1 ,sync2, whitening, decode_crc, sync_length)

        self.tb.connect(pdu_to_stream,unpack)
        self.tb.connect(unpack, acc_code_block)
        self.tb.connect(acc_code_block, deframer)
        self.tb.msg_connect((deframer, 'out'), (debug, 'store'))
        self.tb.start()
        time.sleep(1)
        self.tb.stop()
        #Please get rid of this sleep if you know how!
        time.sleep(0.1)
        self.tb.stop()

        result_data = [i for i in pmt.to_python(pmt.cdr(debug.get_message(0)))]
        self.assertEqual(payload, result_data)
Exemplo n.º 43
0
 def handler(self, pdu):
     meta = pmt.car(pdu)
     vec = pmt.to_python(pmt.cdr(pdu))
     idx = numpy.argmax(numpy.abs(vec) > self.max_item)
     if(not idx == 0):
         vec = vec[0:idx]
     self.message_port_pub(pmt.intern("pdus"), pmt.cons( meta, pmt.to_pmt(vec) ) );
Exemplo n.º 44
0
    def work(self, input_items, output_items):
        in0 = input_items[0]
        for bit in in0:
            if self.pattern_check == self.pattern:
                self.output.append(bit)

                if len(self.output) == self.output.maxlen:
                    output = list(self.output)
                    outs = ''.join(['1' if ch == 1 else '0' for ch in output])
                    pmt_out = (None, outs)
                    self.message_port_pub(pmt.intern('out'), pmt.to_pmt(pmt_out))
                    output = self.format_output(output)

                    if self.stdout:
                        print output

                    if self.fp:
                        try:
                            self.fp.write(output + '\n')
                            self.fp.flush()
                        except IOError as e:
                            print 'Error while writing to file:',
                            print str(e)
                            self.fp.close()
                            self.fp = None

                    self.output.clear()
                    self.pattern_check.clear()
            else:
                self.pattern_check.append(bit)

        return len(input_items[0])
Exemplo n.º 45
0
 def next_vector(self, seed, samp_rate, noise_amp, modulation, delay, samples_to_receive, freq, rx_id):
     timing_tag = gr.tag_t()
     timing_tag.offset = 0
     timing_tag.key = pmt.string_to_symbol('rx_time')
     timing_tag.value = pmt.to_pmt((float(seed), 0.6))
     timing_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1'))
     # Rx freq tags:
     #print "In source emulation (before tag)" 
     #print freq
     rx_freq_tag = gr.tag_t()
     rx_freq_tag.offset = 0
     rx_freq_tag.key = pmt.string_to_symbol('rx_freq')
     rx_freq_tag.value = pmt.from_double(freq)
     rx_freq_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1'))
     # Samp_rate tags:
     rx_rate_tag = gr.tag_t()
     rx_rate_tag.offset = 0
     rx_rate_tag.key = pmt.string_to_symbol('rx_rate')
     rx_rate_tag.value = pmt.from_double(samp_rate)
     rx_rate_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1'))
     pulse_width = 4
     np.random.seed(seed=seed)
     tx_vector = np.reshape(np.matlib.repmat(np.random.randint(0,2,(5*samples_to_receive)/pulse_width)*2-1,pulse_width,1).T,[1,5*samples_to_receive])[0].tolist()
     # delay signal vector -> insert zeros at beginnig; nothing happens if signal has not reached the receiver:
     tx_vector_delayed = np.hstack((np.zeros(delay),tx_vector))
     #tx_vector_delayed = tx_vector_delayed[:600]
     print len(tx_vector_delayed)
     self.vector_source.set_data(tx_vector_delayed,(timing_tag, rx_freq_tag, rx_rate_tag)) 
     self.head.reset()
     self.vector_source.rewind()
Exemplo n.º 46
0
def make_tag(key, value, offset):
    """Create a gr.tag_t() from key, value, offset."""
    tag = gr.tag_t()
    tag.offset = offset
    tag.key = pmt.string_to_symbol(key)
    tag.value = pmt.to_pmt(value)
    return tag
Exemplo n.º 47
0
 def test_preserve_tag_head_pos(self):
     """ Test the 'preserve head position' function.
     This will add a 'special' tag to item 0 on stream 1.
     It should be on item 0 of the output stream. """
     special_tag = gr.tag_t()
     special_tag.key = pmt.string_to_symbol('spam')
     special_tag.offset = 0
     special_tag.value = pmt.to_pmt('eggs')
     len_tag_key = "length"
     packet_len_1 = 5
     packet_len_2 = 3
     mux = blocks.tagged_stream_mux(gr.sizeof_float, len_tag_key, 1)
     sink = blocks.vector_sink_f()
     self.tb.connect(
         blocks.vector_source_f(range(packet_len_1)),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, len_tag_key),
         (mux, 0)
     )
     self.tb.connect(
         blocks.vector_source_f(range(packet_len_2), False, 1, (special_tag,)),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_2, len_tag_key),
         (mux, 1)
     )
     self.tb.connect(mux, sink)
     self.tb.run()
     self.assertEqual(sink.data(), tuple(range(packet_len_1) + range(packet_len_2)))
     tags = [gr.tag_to_python(x) for x in sink.tags()]
     tags = sorted([(x.offset, x.key, x.value) for x in tags])
     tags_expected = [
             (0, 'length', packet_len_1 + packet_len_2),
             (0, 'spam', 'eggs'),
     ]
     self.assertEqual(tags, tags_expected)
Exemplo n.º 48
0
 def send_pkt_radio(self, payload, meta_dict, pkt_cnt):
     # sink in Sink table?
     if self.SINK_ADDR not in self.sinkTable.keys():
         if self.debug_stderr:
             # yes! log the packet
             sys.stderr.write(
                 "%d:in send_pkt_radio(): dropping packet\n" % self.addr)
         # drop the packet
         return
     # yes! get the value paired with the sink key
     aSinkVal = self.sinkTable[self.SINK_ADDR]
     # yes! data packet header structure
     data = [self.DATA_PROTO, self.addr, self.addr, pkt_cnt, aSinkVal.min_dx_to_sink,
             self.SINK_ADDR, aSinkVal.min_dx_to_sink + self.R]
     # add payload
     if payload is None:
         payload = []
     elif isinstance(payload, str):
         payload = map(ord, list(payload))
     elif not isinstance(payload, list):
         payload = list(payload)
     data += payload
     # debug mode enabled?
     if self.debug_stderr:
         # yes! log the packet
         sys.stderr.write(
             "%d:in send_pkt_radio(): sending packet:\n" % self.addr)
         self.print_pkt(data)
     # conversion to PMT PDU (meta data, data)
     pdu = pmt.cons(
         pmt.to_pmt({}),
         pmt.init_u8vector(len(data), data))
     # push to radio msg port
     self.message_port_pub(pmt.intern('to_radio'), pdu)
Exemplo n.º 49
0
	def _to_ofdm_radio(self, pdu_tuple, pkt_cnt, protocol_id, control):
		meta_data = pdu_tuple[1]
		payload = pdu_tuple[0]
		if payload is None:
			payload = []
		elif isinstance(payload, str):
			payload = map(ord, list(payload))
		elif not isinstance(payload, list):
			payload = list(payload)

		dest_addr = meta_data['EM_DEST_ADDR']
		if dest_addr == -1:
			dest_addr = BROADCAST_ADDR
		elif dest_addr < -1 or dest_addr > BROADCAST_ADDR:
			print "Invalid address:", dest_addr
			return
        
		#create header, merge with payload, convert to pmt for message_pub
		data = [pkt_cnt, self.address, dest_addr, protocol_id, control]

		data += payload

		data = pmt.init_u8vector(len(data), data)
		meta = pmt.to_pmt({})

		#construct pdu and publish to radio port
		pdu = pmt.cons(meta, data)
		#publish to msg port
		self.message_port_pub(pmt.intern('to_ofdm_radio'),pdu)
Exemplo n.º 50
0
    def work(self, input_items, output_items):
	# feedback to encoder
	feedback = []
	# read photon angle, previous basis pairs
	for i in range(len(input_items[0])):
		# compares encoder and decoder basis used for previous photon
		if input_items[0][i]==self.sel_basis:
			# append positive feedback
			feedback.append(1)
			# append corresponding biy to key
			self.key_bit.append(self.dec_bit)
		else:
			# append negative feedback
			feedback.append(0)

		# randomly select a basis
        	self.sel_basis=random.randint(0, 1)
		# decode a photon
		if input_items[1][i]==self.basis[self.sel_basis][0]:
			# store a zero
			self.dec_bit = 0
		elif input_items[1][i]==self.basis[self.sel_basis][1]:
			# store a one
			self.dec_bit = 1
		else:
			# store a random value
			self.dec_bit = random.randint(0, 1)
	if self.debug: 
           sys.stderr.write("decoder.work():feedback: " + \
                str(feedback) + "\n")
        # post feedback to encoder
        self.message_port_pub(pmt.intern('feedback'), 
		pmt.to_pmt(feedback)) 
	return len(input_items[0])
Exemplo n.º 51
0
	def set_freqs(self, freq0, freq1, freq2, freq3):
		self.top4[0] = freq0
		self.top4[1] = freq1
		self.top4[2] = freq2
		self.top4[3] = freq3
		self.message_out0.set_msg(pmt.cons( pmt.to_pmt("freq"), pmt.to_pmt(freq0-self.tune_freq) )) #send differencial frequency
		self.message_out1.set_msg(pmt.cons( pmt.to_pmt("freq"), pmt.to_pmt(freq1-self.tune_freq) ))
		self.message_out2.set_msg(pmt.cons( pmt.to_pmt("freq"), pmt.to_pmt(freq2-self.tune_freq) ))
		self.message_out3.set_msg(pmt.cons( pmt.to_pmt("freq"), pmt.to_pmt(freq3-self.tune_freq) ))
Exemplo n.º 52
0
 def work(self, input_items, output_items):
     """Where the magic happens."""
     for _ in range(len(input_items[0]) // self.header_len):
         msg = self.messages[self.msg_count] or False
         self.message_port_pub(pmt.intern('header_data'), pmt.to_pmt(msg))
         self.msg_count += 1
     output_items[0][:] = input_items[0][:]
     return len(input_items[0])
Exemplo n.º 53
0
 def work(self, input_items, output_items):
     for i in range(len(input_items[0]) // self.header_len):
         msg = self.messages[self.msg_count] or False
         #print("Sending message: {0}".format(msg))
         self.message_port_pub(pmt.intern('header_data'), pmt.to_pmt(msg))
         self.msg_count += 1
     output_items[0][:] = input_items[0][:]
     return len(input_items[0])
Exemplo n.º 54
0
 def work(self, input_items, output_items):
     tags = self.get_tags_in_window(0, 0, len(input_items[0]), self.tag)
     tags = sorted(tags, reverse=True)
     for tag in tags:
         rel_offset = tag.offset - self.nitems_read(0)
         if rel_offset + self.burst_length_bits > len(input_items[0]):
             return rel_offset
         else:
             pdu = pmt.cons(
                     pmt.to_pmt({'chan': self.chan_idx}),
                     pmt.to_pmt(input_items[0][rel_offset:rel_offset+self.burst_length_bits])
             )
             self.message_port_pub(
                     pmt.intern('burst'),
                     pdu
             )
     return len(input_items[0])
Exemplo n.º 55
0
 def update_file_range(self):
     try:
         (s,l) = self.f_range
         meta = {"start":s, "len":l, "end":s+l, "filename":self.filename}
         self.F.seek(s*self.itemsize)
         if self.force_complex:
             vec = numpy.fromfile(self.F, dtype=self.filetype, count=2*l, sep='')
             vec = vec[0::2] + 1j*vec[1::2]
         else:
             vec = numpy.fromfile(self.F, dtype=self.filetype, count=l, sep='')
         vec = numpy.array(vec, dtype="complex64")
         self.message_port_pub(pmt.intern("pdus"), 
             pmt.cons(
                 pmt.to_pmt(meta),
                 pmt.to_pmt(vec) ))
     except:
         pass
Exemplo n.º 56
0
 def request(self, id_str, args=None):
     socks = dict(self.poller_req_out.poll(10))
     if socks.get(self.req_socket) == zmq.POLLOUT:
         self.req_socket.send(pmt.serialize_str(pmt.to_pmt((id_str,args))))
     socks = dict(self.poller_req_in.poll(10))
     if socks.get(self.req_socket) == zmq.POLLIN:
         reply = pmt.to_python(pmt.deserialize_str(self.req_socket.recv()))
         print("[RPC] reply:", reply)
         return reply
Exemplo n.º 57
0
    def handler(self, msg):
        ba = bitarray.bitarray();
        meta = pmt.car(msg);
        data = pmt.cdr(msg);
        
        f_vec = pmt.to_pmt(  numpy.array(pmt.to_python(data), dtype="float32") * 2 - 1 )
        pdu = pmt.cons(meta, f_vec);

        # send it on its way
        self.message_port_pub(pmt.intern("fpdus"), pdu);