Example #1
0
    def test_002_update(self):
        start_time = 0.1
        self.duration = 125000
        self.src = blocks.vector_source_c(list(range(self.duration)), False, 1, [])
        self.throttle = blocks.throttle(gr.sizeof_gr_complex * 1, 250000)
        self.utag = timing_utils.add_usrp_tags_c(1090e6, 250000, 0, start_time)
        self.tag_dbg = blocks.tag_debug(gr.sizeof_gr_complex * 1, '', "")

        self.tb.connect((self.src, 0), (self.throttle, 0))
        self.tb.connect((self.throttle, 0), (self.utag, 0))
        self.tb.connect((self.utag, 0), (self.tag_dbg, 0))

        self.tb.start()
        time.sleep(.01)
        #print("Dumping tags")
        for t in self.tag_dbg.current_tags():
            #print( 'Tag:' , t.key, ' ', t.value )
            if pmt.eq(t.key, pmt.intern("rx_freq")):
                self.assertAlmostEqual(1090e6, pmt.to_double(t.value))
            if pmt.eq(t.key, pmt.intern("rx_rate")):
                self.assertAlmostEqual(250000, pmt.to_double(t.value))

        self.utag.update_tags(self.makeDict(freq=1091e6, rate=260000, epoch_int=0, epoch_frac=start_time + .3))
        time.sleep(.01)
        #print("Dumping tags")
        for t in self.tag_dbg.current_tags():
            #print( 'Tag:' , t.key, ' ', t.value )
            if pmt.eq(t.key, pmt.intern("rx_freq")):
                self.assertAlmostEqual(1091e6, pmt.to_double(t.value))
            if pmt.eq(t.key, pmt.intern("rx_rate")):
                self.assertAlmostEqual(260000, pmt.to_double(t.value))

        time.sleep(.1)
        self.tb.stop()
Example #2
0
    def test_tag_propagation(self):
        N = 10 # Block length
        stream_sizes = [1,2,3]

        expected_result     = N*(stream_sizes[0]*[1,]
                                 +stream_sizes[1]*[2,]
                                 +stream_sizes[2]*[3,])
        # check the data
        (result, tags) = self.help_stream_tag_propagation(N, stream_sizes)
        self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)

        # check the tags
        expected_tag_offsets_src1 = [sum(stream_sizes)*i for i in range(N)]
        expected_tag_offsets_src2 = [stream_sizes[0]
                                     +sum(stream_sizes)*i for i in range(N)]
        expected_tag_offsets_src3 = [stream_sizes[0]+stream_sizes[1]
                                     +sum(stream_sizes)*i for i in range(N)]
        tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
        tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
        tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]

        for i in range(len(expected_tag_offsets_src1)):
            self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
        for i in range(len(expected_tag_offsets_src2)):
            self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
        for i in range(len(expected_tag_offsets_src3)):
            self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)
Example #3
0
    def test_tag_propagation(self):
        N = 10 # Block length
        stream_sizes = [1,2,3]

        expected_result     = N*(stream_sizes[0]*[1,]
                                 +stream_sizes[1]*[2,]
                                 +stream_sizes[2]*[3,])
        # check the data
        (result, tags) = self.help_stream_tag_propagation(N, stream_sizes)
        self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)

        # check the tags
        expected_tag_offsets_src1 = [sum(stream_sizes)*i for i in range(N)]
        expected_tag_offsets_src2 = [stream_sizes[0]
                                     +sum(stream_sizes)*i for i in range(N)]
        expected_tag_offsets_src3 = [stream_sizes[0]+stream_sizes[1]
                                     +sum(stream_sizes)*i for i in range(N)]
        tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
        tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
        tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]

        for i in range(len(expected_tag_offsets_src1)):
            self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
        for i in range(len(expected_tag_offsets_src2)):
            self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
        for i in range(len(expected_tag_offsets_src3)):
            self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)
    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()
Example #5
0
    def msg_handler_QOBJ_in(self, msg):
        print("in msg_handler_QOBJ_in")
        self.lock()
        qubit_id_PMT = pmt.dict_ref(
            msg,
            pmt.from_float(
                quantum_qubit_param_type.quantum_qubit_param_type.ID),
            pmt.PMT_NIL)
        if (pmt.eq(qubit_id_PMT, pmt.PMT_NIL)):
            return
        qubit_id = pmt.to_float(qubit_id_PMT)
        print("quantum_qubit_param_type.qubit_id=" + str(qubit_id))
        if (this._qubit_id != qubit_id):
            return

        qubit_angle_PMT = pmt.dict_ref(
            msg,
            pmt.from_float(
                quantum_qubit_param_type.quantum_qubit_param_type.ANGLE),
            pmt.PMT_NIL)
        if (pmt.eq(qubit_angle_PMT, pmt.PMT_NIL)):
            return
        qubit_angle = pmt.to_float(qubit_angle_PMT)
        print("quantum_qubit_param_type.qubit_angle=" + str(qubit_angle))

        qubit_pole_PMT = pmt.dict_ref(
            msg,
            pmt.from_float(
                quantum_qubit_param_type.quantum_qubit_param_type.POLE),
            pmt.PMT_NIL)
        if (pmt.eq(qubit_pole_PMT, pmt.PMT_NIL)):
            return
        qubit_pole = pmt.to_float(qubit_pole_PMT)
        print("quantum_qubit_param_type.qubit_pole=" + str(qubit_pole))

        e_ops = [sigmax(), sigmay(), sigmaz()]
        if (qubit_pole == 1.0):
            Z = sigmaz()
        else:
            Z = -sigmaz()

        if (qubit_angle == 0.0):
            Q = Z
        elif (qubit_angle > 0.0):
            Q = sigmax() * self.angle_converter(qubit_angle)
            Q = Q + Z
        elif ():
            Q = sigmax() * self.angle_converter(-qubit_angle)
            Q = Q + (-Z)

#        self._block_view.clear()
        self._block_view.add_vectors(expect(Q.unit(), e_ops))
        self._block_view.make_sphere()
        self._block_view.show()
Example #6
0
    def test_tag_propagation(self):
        N = 10 # Block length
        stream_sizes = [1,2,3]

        expected_result0 = N*(stream_sizes[0]*[1,])
        expected_result1 = N*(stream_sizes[1]*[2,])
        expected_result2 = N*(stream_sizes[2]*[3,])

        # check the data
        (result0, result1, result2) = self.help_stream_tag_propagation(N, stream_sizes)
        self.assertFloatTuplesAlmostEqual(expected_result0, result0.data(), places=6)
        self.assertFloatTuplesAlmostEqual(expected_result1, result1.data(), places=6)
        self.assertFloatTuplesAlmostEqual(expected_result2, result2.data(), places=6)

        # check the tags - result0
        tags = result0.tags()
        expected_tag_offsets_src1 = list(range(0,stream_sizes[0]*N,stream_sizes[0]))
        expected_tag_offsets_src2 = list(range(0,stream_sizes[0]*N,stream_sizes[0]))
        expected_tag_offsets_src3 = list(range(0,stream_sizes[0]*N,stream_sizes[0]))
        tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
        tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
        tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]
        for i in range(len(expected_tag_offsets_src1)):
            self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
        for i in range(len(expected_tag_offsets_src2)):
            self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
        for i in range(len(expected_tag_offsets_src3)):
            self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)

        # check the tags - result1
        tags = result1.tags()
        expected_tag_offsets_src1 = list(range(0,stream_sizes[1]*N,stream_sizes[0]))
        expected_tag_offsets_src2 = list(range(1,stream_sizes[1]*N,stream_sizes[1]))
        expected_tag_offsets_src3 = list()
        tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
        tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
        tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]
        for i in range(len(expected_tag_offsets_src1)):
            self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
        for i in range(len(expected_tag_offsets_src2)):
            self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
        for i in range(len(expected_tag_offsets_src3)):
            self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)

        # check the tags - result2
        tags = result2.tags()
        expected_tag_offsets_src1 = list(range(0,stream_sizes[2]*N,stream_sizes[0]))
        expected_tag_offsets_src2 = list(range(1,stream_sizes[2]*N,stream_sizes[2]))
        expected_tag_offsets_src3 = list(range(0,stream_sizes[2]*N,stream_sizes[2]))
        tags_src1 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src1'))]
        tags_src2 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src2'))]
        tags_src3 = [tag for tag in tags if pmt.eq(tag.key, pmt.intern('src3'))]
        for i in range(len(expected_tag_offsets_src1)):
            self.assertTrue(expected_tag_offsets_src1[i] == tags_src1[i].offset)
        for i in range(len(expected_tag_offsets_src2)):
            self.assertTrue(expected_tag_offsets_src2[i] == tags_src2[i].offset)
        for i in range(len(expected_tag_offsets_src3)):
            self.assertTrue(expected_tag_offsets_src3[i] == tags_src3[i].offset)
 def tag_handler(self, ninput_items):
     nread = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, nread, nread + ninput_items)
     key_0 = pmt.intern("corr_start")
     key_1 = pmt.intern("freq_est")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key_0, tags[i].key)):
                 offset = tags[i].offset
                 self.delay = offset % self.sps
                 self.corr_start_detected = True
             if (pmt.eq(key_1, tags[i].key)):
                 self.freq_off = -float(pmt.to_double(tags[i].value))
    def test_003_every (self):
        self.tb = gr.top_block ()
        self.rate = 99999999999
        self.interval = 1
        self.duration = 4321

        self.src = blocks.vector_source_c(list(range(self.duration)), False, 1, [])
        self.utag = timing_utils.add_usrp_tags_c(1090e6, self.rate, 0, .98765)
        self.tags = timing_utils.tag_uhd_offset_c(self.rate, self.interval)
        self.tag_dbg = blocks.tag_debug(gr.sizeof_gr_complex*1, "", "");
        self.tag_dbg.set_display(False)
        self.tb.connect((self.src, 0), (self.utag, 0))
        self.tb.connect((self.utag, 0), (self.tags, 0))
        self.tb.connect((self.tags, 0), (self.tag_dbg, 0))
        e_n_tags = int(ceil(1.0*self.duration / self.interval)) + 3

        self.tb.run ()

        tags = self.tag_dbg.current_tags()
        tprev = None
        for t in tags:
            if pmt.eq(t.key, pmt.intern("rx_time_offset")):
                self.assertAlmostEqual(self.rate, pmt.to_double(pmt.tuple_ref(t.value, 3)),-4)
                self.assertEqual(t.offset, pmt.to_uint64(pmt.tuple_ref(t.value, 2)))
                self.assertTrue((pmt.to_uint64(pmt.tuple_ref(t.value, 2)) / (1.0*self.interval)).is_integer())
                if tprev is not None:
                    tcur = pmt.to_uint64(pmt.tuple_ref(t.value, 0)) + pmt.to_double(pmt.tuple_ref(t.value, 1))
                    self.assertAlmostEqual(tcur-tprev, 1.0*self.interval / self.rate)
                    tprev = tcur
                else:
                    tprev = pmt.to_uint64(pmt.tuple_ref(t.value, 0)) + pmt.to_double(pmt.tuple_ref(t.value, 1))
        self.assertEqual(self.tag_dbg.num_tags(), e_n_tags)
        self.tb = None
 def tag_propagation(self, ninput_items):
     self.set_tag_propagation_policy(0)
     nread = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, nread, nread + ninput_items)
     key_1 = pmt.intern("packet_len")
     key_2 = pmt.intern("pdu_len")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key_1, tags[i].key)):
                 offset = int(tags[i].offset / self.factor)
                 value = pmt.from_long(int(pmt.to_long(tags[i].value)))
                 self.add_item_tag(0, offset, key_1, value)
             if (pmt.eq(key_2, tags[i].key)):
                 offset = int(tags[i].offset / self.factor)
                 value = pmt.from_long(int(pmt.to_long(tags[i].value)))
                 self.add_item_tag(0, offset, key_2, value)
    def test_002_tags(self): 
        start_time = 0.1
        self.duration = 125000
        tnow = time.time()
        
        src_tag = gr.tag_utils.python_to_tag([0, pmt.intern("wall_clock_time"), pmt.from_double(tnow - 10000), pmt.intern("test_002_tags")])
        self.src = blocks.vector_source_c(list(range(self.duration)), False, 1, [src_tag])
        self.throttle = blocks.throttle(gr.sizeof_gr_complex*1, 250000)
        self.dut = timing_utils.system_time_diff_c(True, True, False)
        self.tag_dbg = blocks.tag_debug(gr.sizeof_gr_complex*1, '', "");
        
        self.tb.connect((self.src, 0), (self.throttle, 0))
        self.tb.connect((self.throttle, 0), (self.dut, 0))
        self.tb.connect((self.dut, 0), (self.tag_dbg, 0))
        
        self.tb.start()
        time.sleep(.01)
        
        tags = self.tag_dbg.current_tags();
        print("Dumping tags")
        for t in tags:
            print( 'Tag:' , t.key, ' ', t.value )
            if pmt.eq(t.key, pmt.intern("wall_clock_time")):
                time_tag = t;
        
        if time_tag:
            self.assertAlmostEqual( tnow, pmt.to_double(time_tag.value), delta=60 )
        else:
            self.assertTrue( False )

        time.sleep(.1)
        self.tb.stop()
Example #11
0
    def test_002_1tag(self):
        '''
        Tests a stream with a single tag
        '''

        src_tag = gr.tag_utils.python_to_tag([
            0,
            pmt.intern("sam"),
            pmt.from_double(10000),
            pmt.intern("test_002_1tag")
        ])

        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        src = blocks.vector_source_i(src_data, False, 1, [src_tag])
        dut = sandia_utils.sandia_tag_debug(gr.sizeof_int, "tag QA")
        self.tb.connect(src, dut)

        self.tb.run()

        self.assertEqual(1, dut.num_tags())

        tag0 = dut.get_tag(0)

        self.assertTrue(pmt.eq(tag0.key, pmt.intern("sam")))
        self.assertAlmostEqual(10000, pmt.to_double(tag0.value))
 def tag_handler(self, n_input_items):
     n_read = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, n_read, n_read + n_input_items)
     key = pmt.intern("packet_len")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key, tags[i].key)):
                 self.PN9 = np.ones((9, ), dtype=int)
Example #13
0
    def test_003_tags(self):
        '''
        Tests a stream that has multiple tags inside it
        '''
        src_tag1 = gr.tag_utils.python_to_tag([
            0,
            pmt.intern("sam"),
            pmt.from_double(10000),
            pmt.intern("test_003_tags")
        ])
        src_tag2 = gr.tag_utils.python_to_tag([
            1,
            pmt.intern("peter"),
            pmt.from_double(1000),
            pmt.intern("test_003_tags")
        ])
        src_tag3 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("jacob"),
            pmt.from_double(100),
            pmt.intern("test_003_tags")
        ])

        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        src = blocks.vector_source_i(src_data, False, 1,
                                     [src_tag1, src_tag2, src_tag3])
        dut = sandia_utils.sandia_tag_debug(gr.sizeof_int, "tag QA")
        self.tb.connect(src, dut)

        self.tb.run()

        self.assertEqual(3, dut.num_tags())

        tag0 = dut.get_tag(0)
        tag1 = dut.get_tag(1)
        tag2 = dut.get_tag(2)

        self.assertTrue(pmt.eq(tag0.key, pmt.intern("sam")))
        self.assertAlmostEqual(10000, pmt.to_double(tag0.value))

        self.assertTrue(pmt.eq(tag1.key, pmt.intern("peter")))
        self.assertAlmostEqual(1000, pmt.to_double(tag1.value))

        self.assertTrue(pmt.eq(tag2.key, pmt.intern("jacob")))
        self.assertAlmostEqual(100, pmt.to_double(tag2.value))
Example #14
0
    def test_003_snr(self):
        nframes = 30
        timeslots = 5
        subcarriers = 1024
        active_subcarriers = 936
        overlap = 2
        cp_len = subcarriers // 2
        ramp_len = cp_len // 2
        active_ratio = subcarriers / active_subcarriers

        subcarrier_map = get_subcarrier_map(subcarriers, active_subcarriers,
                                            dc_free=True)
        preambles = mapped_preamble(self.seed, self.filtertype, self.filteralpha,
                                    active_subcarriers, subcarriers,
                                    subcarrier_map, overlap, cp_len, ramp_len)

        core_preamble = preambles[1]

        sigenergy = calculate_energy(core_preamble)

        data = np.copy(core_preamble)
        snrs = np.arange(3, 3 * nframes, 3, dtype=np.float)
        snrs_lin = 10. ** (snrs / 10.)
        expected_snrs_lin = np.concatenate(((np.inf,), snrs_lin))

        for i, snr_lin in enumerate(snrs_lin):
            nscale = calculate_noise_scale(
                snr_lin, sigenergy, active_ratio, core_preamble.size)
            noise = get_noise_vector(core_preamble.size, nscale)

            d = core_preamble + noise
            data = np.concatenate((data, d))

        dut = gfdm.channel_estimator_cc(
            timeslots, subcarriers, active_subcarriers, True, 1, core_preamble)
        src = blocks.vector_source_c(data)
        snk = blocks.vector_sink_c()
        self.tb.connect(src, dut, snk)
        self.tb.run()

        res = np.array(snk.data())
        self.assertEqual(res.size, nframes * timeslots * subcarriers)

        tags = snk.tags()
        snr_tags = [t for t in tags if pmt.eq(t.key, pmt.mp("snr_lin"))]

        for i, t in enumerate(snr_tags):
            self.assertEqual(t.offset, i * timeslots * subcarriers)
            res_lin = pmt.to_float(t.value)
            res_db = 10. * np.log10(res_lin)
            ref_db = 10. * np.log10(expected_snrs_lin[i])
            # print(f"Reference: {ref_db:6.3f}dB\t{res_db:6.3f}dB")

            if np.isfinite(ref_db):
                self.assertTrue(np.abs(res_db - ref_db) < 1.)
 def wait_for_tag(self, in0):
     nread = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, nread, nread + self.n_input_items)
     key = pmt.intern("corr_start")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key, tags[i].key)):
                 self.offset = tags[i].offset
                 self.num = 1
     else:
         self.num = 0
Example #16
0
def extract_pdu_header(header):
    d = pmt.to_long(pmt.dict_ref(header, pmt.intern('dest_id'), pmt.PMT_NIL))
    s = pmt.to_long(pmt.dict_ref(header, pmt.intern('src_id'), pmt.PMT_NIL))
    f = pmt.to_long(pmt.dict_ref(header, pmt.intern('frame_num'), pmt.PMT_NIL))
    c = pmt.dict_ref(header, pmt.intern('checksum'), pmt.PMT_NIL)
    if pmt.is_u8vector(c):
        c = pmt_u8vector_to_ndarray(c)
    elif pmt.eq(c, pmt.PMT_T):
        c = True
    else:
        c = False
    return d, s, f, c
Example #17
0
 def recalc_msg(self, msg):
     if pmt.is_pair(msg):
         key = pmt.car(msg)
         val = pmt.cdr(msg)
         if pmt.eq(key, pmt.intern("recalc")):
             if pmt.is_integer(val):
                 if pmt.to_long(val) == 10:
                     global start
                     start = 0
                 if pmt.to_long(val) == 20:
                     global start
                     start = 1
Example #18
0
 def recalc_msg(self, msg):
     if pmt.is_pair(msg):
         key = pmt.car(msg)
         val = pmt.cdr(msg)
         if pmt.eq(key, pmt.intern("recalc")):
             if pmt.is_integer(val):
                 if pmt.to_long(val) == 10:
                     global file_written
                     file_written = 1
                 if pmt.to_long(val) == 20:
                     global file_written
                     file_written = 0
                     print "hello"
Example #19
0
 def handle_msg(self, msg):
     msgs = pmt.cdr(msg)
     msg_str = "".join([chr(x) for x in pmt.u8vector_elements(msgs)])
     print msg_str
     print self.message
     self.message = msg
     self.message_port_pub(pmt.intern('message_stream out'), self.message)
     if pmt.eq(self.message, msg):
         print "No change"
         pass
     else:
         print "Changed"
         self.message = msg
 def set_signal_number_msg(self, msg):
     if pmt.is_pair(msg):
         key = pmt.car(msg)
         val = pmt.cdr(msg)
         if pmt.eq(key, pmt.string_to_symbol("signal_number_msg")):
             if pmt.is_integer(val):
                 self.n = pmt.to_long(val)
             else:
                 print("DoA Esprit: Not an integer")
         else:
             print("DoA Esprit: Key not 'signal_number_msg'")
     else:
         print("DoA Esprit: Not a tuple")
Example #21
0
 def tag_handler(self, ninput_items):
     self.set_tag_propagation_policy(0)
     nread = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, nread, nread + ninput_items)
     key = pmt.intern("phr_start")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key, tags[i].key)):
                 offset = tags[i].offset
                 self.delay = offset % self.sps
                 offset = int(offset / self.sps)
                 value = pmt.from_double(int(pmt.to_double(tags[i].value)))
                 self.add_item_tag(0, offset, key, value)
 def tag_handler(self, ninput_items):
     self.set_tag_propagation_policy(0)
     nread = self.nitems_read(0)  #number of items read on port 0
     tags = self.get_tags_in_range(0, nread, nread + ninput_items)
     key_1 = pmt.intern("corr_start")
     key_2 = pmt.intern("phr_start")
     key_3 = pmt.intern("freq_est")
     key_4 = pmt.intern("SFD_start")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key_1, tags[i].key)):
                 offset = tags[i].offset
                 value = pmt.from_double(float(pmt.to_double(
                     tags[i].value)))
                 self.add_item_tag(0, offset, key_1, value)
             if (pmt.eq(key_2, tags[i].key)):
                 offset = int(tags[i].offset / self.sps)
                 value = pmt.from_double(float(pmt.to_double(
                     tags[i].value)))
                 self.add_item_tag(0, offset, key_2, value)
             if (pmt.eq(key_3, tags[i].key)):
                 self.freq_off = 0  #-float(pmt.to_double(tags[i].value))
             if (pmt.eq(key_4, tags[i].key)):
                 self.delay = tags[i].offset % self.sps
 def wait_tags(self, in0, out):
     n_read = self.nitems_read(0) #Number of items read on port 0
     tags = self.get_tags_in_range(0, n_read, n_read+self.n_input_items)
     key = pmt.intern("pdu_len")
     if tags:
         for i in range(len(tags)):
             if (pmt.eq(key, tags[i].key)):
                 self.offset_rel = tags[i].offset - n_read 
                 self.pdu_len = pmt.to_long(tags[i].value) * 8
                 self.add_item_tag(0, self.offset_tag, key,  pmt.from_long(self.pdu_len))
                 self.offset_tag = self.offset_tag + self.pdu_len
                 self.num = 1
                 break
         self.consume(0,self.offset_rel)
     else:
         self.num = 0
Example #24
0
    def handle_msg(self, msg_pmt):
        srcId = pmt.dict_ref(pmt.car(msg_pmt), pmt.intern('SNET SrcId'),
                             pmt.PMT_NIL)
        if pmt.eq(srcId, pmt.PMT_NIL):
            return
        sat = pmt.to_long(srcId) >> 1

        if sat == 0:
            satellite = 'SNET-A'
        elif sat == 1:
            satellite = 'SNET-B'
        elif sat == 2:
            satellite = 'SNET-C'
        elif sat == 3:
            satellite = 'SNET-D'
        else:
            return

        self.message_port_pub(pmt.intern(satellite), msg_pmt)
Example #25
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)

        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, detached)
        fsnk.set_unbuffered(True)

        self.tb.connect(src, fsnk)
        self.tb.run()
        fsnk.close()

        handle = open(outfile, "rb")
        header_str = handle.read(blocks.parse_file_metadata.HEADER_LENGTH)
        if(len(header_str) == 0):
            self.assertFalse()

        try:
            header = pmt.deserialize_str(header_str)
        except RuntimeError:
            self.assertFalse()

        info = blocks.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 = blocks.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)
    def msg_handler_analyzed_data_in_circuit(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")
            self._qubit_circuit.add_gate("RX",
                                         targets=qubit_id,
                                         arg_value=pi,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.Y):
            print("in msg_handler_analyzed_data_in Y gate")
            self._qubit_circuit.add_gate("RY",
                                         targets=qubit_id,
                                         arg_value=pi,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.Z):
            print("in msg_handler_analyzed_data_in Z gate")
            self._qubit_circuit.add_gate("RZ",
                                         targets=qubit_id,
                                         arg_value=pi,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.H):
            print("in msg_handler_analyzed_data_in H gate")
            self._qubit_circuit.add_gate("hadamard_transform",
                                         targets=qubit_id,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.S):
            print("in msg_handler_analyzed_data_in S gate")
            self._qubit_circuit.add_gate("RZ",
                                         targets=qubit_id,
                                         arg_value=pi / 2,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.T):
            print("in msg_handler_analyzed_data_in T gate")
            self._qubit_circuit.add_gate("RZ",
                                         targets=qubit_id,
                                         arg_value=pi / 4,
                                         index=this._qcircuit_index_cnt)

        elif (gate_type == quantum_gate_type.quantum_gate_type.INIT):
            print("in msg_handler_analyzed_data_in INIT gate")
            pass

        elif (gate_type == quantum_gate_type.quantum_gate_type.CNOT):
            print("in msg_handler_analyzed_data_in CNOT gate")
            self._qubit_circuit.add_gate("CNOT", controls=[0], targets=[1])

        elif (gate_type == quantum_gate_type.quantum_gate_type.JUNC):
            print("in msg_handler_analyzed_data_in JUNC gate")
            pass

        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()
Example #27
0
    def test_interned_string_constants(self):

        assert (pmt.eq(timing_utils.PMTCONSTSTR__time(), pmt.intern('time')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__trig(), pmt.intern('trig')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__set(), pmt.intern('set')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__disarm(),
                       pmt.intern('disarm')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__rx_time(),
                       pmt.intern('rx_time')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__rx_rate(),
                       pmt.intern('rx_rate')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__rx_freq(),
                       pmt.intern('rx_freq')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__rx_sample(),
                       pmt.intern('rx_sample')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__freq(), pmt.intern('freq')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__wall_clock_time(),
                       pmt.intern('wall_clock_time')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__pdu_out(),
                       pmt.intern('pdu_out')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__pdu_in(),
                       pmt.intern('pdu_in')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__trigger_time(),
                       pmt.intern('trigger_time')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__trigger_sample(),
                       pmt.intern('trigger_sample')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__trigger_now(),
                       pmt.intern('trigger_now')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__late_delta(),
                       pmt.intern('late_delta')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__command(),
                       pmt.intern('command')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__set_freq(),
                       pmt.intern('set_freq')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__in(), pmt.intern('in')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__dsp_freq(),
                       pmt.intern('dsp_freq')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__START(), pmt.intern('START')))
        assert (pmt.eq(timing_utils.PMTCONSTSTR__END(), pmt.intern('END')))
Example #28
0
 def test_interned_string_constants(self):
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__pdu_in(), pmt.intern("pdu_in")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__msg(), pmt.intern("msg")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__in(), pmt.intern("in")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__out(), pmt.intern("out")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__pdu_in(), pmt.intern("pdu_in")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__pdu_out(),
                    pmt.intern("pdu_out")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__cpdus(), pmt.intern("cpdus")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__fpdus(), pmt.intern("fpdus")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__burst_time(),
                    pmt.intern("burst_time")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__start_time(),
                    pmt.intern("start_time")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__start_time_offset(),
                    pmt.intern("start_time_offset")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__rx_time(),
                    pmt.intern("rx_time")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__tx_time(),
                    pmt.intern("tx_time")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__uhd_time_tuple(),
                    pmt.intern("uhd_time_tuple")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__dict(), pmt.intern("dict")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__data(), pmt.intern("data")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__emit(), pmt.intern("emit")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__head(), pmt.intern("head")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__tail(), pmt.intern("tail")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__ctrl(), pmt.intern("ctrl")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__conf(), pmt.intern("conf")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__val(), pmt.intern("val")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__key(), pmt.intern("key")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_val(),
                    pmt.intern("set_val")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_key(),
                    pmt.intern("set_key")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__bursts(), pmt.intern("bursts")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__detects(),
                    pmt.intern("detects")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__debug(), pmt.intern("debug")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__zeroX(), pmt.intern("zeroX")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__window(), pmt.intern("window")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__burst_id(),
                    pmt.intern("burst_id")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__burst_index(),
                    pmt.intern("burst_index")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__eob_offset(),
                    pmt.intern("eob_offset")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__eob_alignment(),
                    pmt.intern("eob_alignment")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__sample_rate(),
                    pmt.intern("sample_rate")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__symbol_rate(),
                    pmt.intern("symbol_rate")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__tx_sob(), pmt.intern("tx_sob")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__tx_eob(), pmt.intern("tx_eob")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__pdu_num(),
                    pmt.intern("pdu_num")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__time_type(),
                    pmt.intern("time_type")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__wall_clock_time(),
                    pmt.intern("wall_clock_time")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__duration(),
                    pmt.intern("duration")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_trigger_tag(),
                    pmt.intern("set_trigger_tag")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_arming_tag(),
                    pmt.intern("set_arming_tag")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_tx_limit(),
                    pmt.intern("set_tx_limit")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_delays(),
                    pmt.intern("set_delays")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_message(),
                    pmt.intern("set_message")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_holdoff(),
                    pmt.intern("set_holdoff")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__set_armed(),
                    pmt.intern("set_armed")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__trigger_now(),
                    pmt.intern("trigger_now")))
     assert (pmt.eq(pdu_utils.PMTCONSTSTR__system(), pmt.intern("system")))
Example #29
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)
Example #30
0
    def test_009_dual_tags_nostore(self):
        '''
        This test has 2 sources each with tags 
        '''
        src_tag1 = gr.tag_utils.python_to_tag([
            0,
            pmt.intern("sam"),
            pmt.from_double(10000),
            pmt.intern("test_003_tags")
        ])
        src_tag2 = gr.tag_utils.python_to_tag([
            1,
            pmt.intern("peter"),
            pmt.from_double(1000),
            pmt.intern("test_003_tags")
        ])
        src_tag3 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("jacob"),
            pmt.from_double(100),
            pmt.intern("test_003_tags")
        ])
        src_tag4 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("chip"),
            pmt.from_double(10),
            pmt.intern("test_003_tags")
        ])
        src_tag5 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("josh"),
            pmt.from_double(1),
            pmt.intern("test_003_tags")
        ])

        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        src1 = blocks.vector_source_i(src_data, False, 1,
                                      [src_tag1, src_tag2, src_tag3])
        src2 = blocks.vector_source_i(src_data, False, 1, [src_tag4, src_tag5])
        dut = sandia_utils.sandia_tag_debug(gr.sizeof_int, "tag QA", "", False)
        self.tb.connect(src1, (dut, 0))
        self.tb.connect(src2, (dut, 1))

        self.tb.run()

        self.assertEqual(5, dut.num_tags())

        tag0 = dut.get_tag(0)
        tag1 = dut.get_tag(1)
        tag2 = dut.get_tag(2)
        tag3 = dut.get_tag(3)
        tag4 = dut.get_tag(4)

        self.assertTrue(pmt.eq(tag0.key, pmt.intern("sam")))
        self.assertAlmostEqual(10000, pmt.to_double(tag0.value))

        self.assertTrue(pmt.eq(tag1.key, pmt.intern("peter")))
        self.assertAlmostEqual(1000, pmt.to_double(tag1.value))

        self.assertTrue(pmt.eq(tag2.key, pmt.intern("jacob")))
        self.assertAlmostEqual(100, pmt.to_double(tag2.value))

        self.assertTrue(pmt.eq(tag3.key, pmt.intern("chip")))
        self.assertAlmostEqual(10, pmt.to_double(tag3.value))

        self.assertTrue(pmt.eq(tag4.key, pmt.intern("josh")))
        self.assertAlmostEqual(1, pmt.to_double(tag4.value))

        self.tb.stop()
        self.tb.wait()
Example #31
0
    def test_005_multiWork(self):
        '''
        This test is testing multiple calls to the sandia_tag_debug::work function 
        to ensure tags are all being saved. 
        '''
        src_tag1 = gr.tag_utils.python_to_tag([
            0,
            pmt.intern("sam"),
            pmt.from_double(10000),
            pmt.intern("test_003_tags")
        ])
        src_tag2 = gr.tag_utils.python_to_tag([
            1,
            pmt.intern("peter"),
            pmt.from_double(1000),
            pmt.intern("test_003_tags")
        ])
        src_tag3 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("jacob"),
            pmt.from_double(100),
            pmt.intern("test_003_tags")
        ])
        src_tag4 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("chip"),
            pmt.from_double(10),
            pmt.intern("test_003_tags")
        ])
        src_tag5 = gr.tag_utils.python_to_tag([
            2,
            pmt.intern("josh"),
            pmt.from_double(1),
            pmt.intern("test_003_tags")
        ])

        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        src = blocks.vector_source_i(src_data, False, 1,
                                     [src_tag1, src_tag2, src_tag3])
        dut = sandia_utils.sandia_tag_debug(gr.sizeof_int, "tag QA")
        self.tb.connect(src, dut)

        #Run one of the TB
        self.tb.run()

        self.assertEqual(3, dut.num_tags())

        tag0 = dut.get_tag(0)
        tag1 = dut.get_tag(1)
        tag2 = dut.get_tag(2)

        self.assertTrue(pmt.eq(tag0.key, pmt.intern("sam")))
        self.assertAlmostEqual(10000, pmt.to_double(tag0.value))

        self.assertTrue(pmt.eq(tag1.key, pmt.intern("peter")))
        self.assertAlmostEqual(1000, pmt.to_double(tag1.value))

        self.assertTrue(pmt.eq(tag2.key, pmt.intern("jacob")))
        self.assertAlmostEqual(100, pmt.to_double(tag2.value))

        self.tb.stop()
        self.tb.wait()

        #Run two of the TB
        src.set_data(src_data, [src_tag4, src_tag5])
        self.tb.run()

        self.assertEqual(5, dut.num_tags())

        tag3 = dut.get_tag(3)
        tag4 = dut.get_tag(4)

        self.assertTrue(pmt.eq(tag0.key, pmt.intern("sam")))
        self.assertAlmostEqual(10000, pmt.to_double(tag0.value))

        self.assertTrue(pmt.eq(tag1.key, pmt.intern("peter")))
        self.assertAlmostEqual(1000, pmt.to_double(tag1.value))

        self.assertTrue(pmt.eq(tag2.key, pmt.intern("jacob")))
        self.assertAlmostEqual(100, pmt.to_double(tag2.value))

        self.assertTrue(pmt.eq(tag3.key, pmt.intern("chip")))
        self.assertAlmostEqual(10, pmt.to_double(tag3.value))

        self.assertTrue(pmt.eq(tag4.key, pmt.intern("josh")))
        self.assertAlmostEqual(1, pmt.to_double(tag4.value))

        self.tb.stop()
        self.tb.wait()
Example #32
0
 def test_interned_string_constants(self):
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__in(), pmt.intern("in")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__out(), pmt.intern("out")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__center_frequency(),
                    pmt.intern("center_frequency")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__relative_frequency(),
                    pmt.intern("relative_frequency")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__sample_rate(),
                    pmt.intern("sample_rate")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__bandwidth(),
                    pmt.intern("bandwidth")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__pwr_db(), pmt.intern("pwr_db")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__snr_db(), pmt.intern("snr_db")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__debug(), pmt.intern("debug")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__rx_freq(),
                    pmt.intern("rx_freq")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__burst_id(),
                    pmt.intern("burst_id")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__magnitude(),
                    pmt.intern("magnitude")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__noise_density(),
                    pmt.intern("noise_density")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__new_burst(),
                    pmt.intern("new_burst")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__gone_burst(),
                    pmt.intern("gone_burst")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__rx_time(),
                    pmt.intern("rx_time")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__start_time(),
                    pmt.intern("start_time")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__duration(),
                    pmt.intern("duration")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__cpdus(), pmt.intern("cpdus")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__start_offset(),
                    pmt.intern("start_offset")))
     assert (pmt.eq(fhss_utils.PMTCONSTSTR__end_offset(),
                    pmt.intern("end_offset")))