コード例 #1
0
    def test_pdu_add_meta(self):
        tb = gr.top_block()
        dbg = blocks.message_debug()
        meta = pmt.make_dict()
        meta = pmt.dict_add(meta, pmt.intern('k1'), pmt.intern('v1'))
        meta = pmt.dict_add(meta, pmt.intern('k2'), pmt.intern('v2'))
        add_meta = pdu_add_meta(meta)

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

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

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

        tb.start()
        tb.wait()

        pdu_out = dbg.get_message(0)
        meta_out = pmt.car(pdu_out)
        self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k1')),
                        'Test key k1 not in output PDU metadata')
        self.assertTrue(pmt.dict_has_key(meta_out, pmt.intern('k2')),
                        'Test key k1 not in output PDU metadata')
        self.assertEqual(pmt.u8vector_elements(pmt.cdr(pdu_out)),
                         pmt.u8vector_elements(pmt.cdr(pdu)),
                         'Output PDU data does not match input PDU data')
コード例 #2
0
ファイル: qa_packet_format.py プロジェクト: vowstar/gnuradio
    def test_packet_parse_default(self):
        ac = packet_utils.default_access_code
        length = '0000000000000001'

        hdr_format_1bps = digital.header_format_default(ac, 0)
        hdr_format_4bps = digital.header_format_default(ac, 0, 4)

        ac_bits = [int(x) & 1 for x in ac]
        length_bits = [int(x) & 1 for x in length]
        header_bits = ac_bits + length_bits + length_bits

        src_hdr = blocks.vector_source_b(header_bits)

        parser_1bps = digital.protocol_parser_b(hdr_format_1bps)
        parser_4bps = digital.protocol_parser_b(hdr_format_4bps)

        snk_hdr_1bps = blocks.message_debug()
        snk_hdr_4bps = blocks.message_debug()

        self.tb.connect(src_hdr, parser_1bps)
        self.tb.connect(src_hdr, parser_4bps)

        self.tb.msg_connect(parser_1bps, 'info', snk_hdr_1bps, 'store')
        self.tb.msg_connect(parser_4bps, 'info', snk_hdr_4bps, 'store')

        self.tb.start()
        while (snk_hdr_1bps.num_messages() <
               1) or (snk_hdr_4bps.num_messages() < 1):
            time.sleep(0.1)
        self.tb.stop()
        self.tb.wait()

        result_1bps = snk_hdr_1bps.get_message(0)
        result_4bps = snk_hdr_4bps.get_message(0)

        self.assertTrue(
            pmt.dict_has_key(result_1bps, pmt.intern('payload symbols')))
        self.assertEqual(
            pmt.to_long(
                pmt.dict_ref(result_1bps, pmt.intern('payload symbols'),
                             pmt.PMT_F)), 8)

        self.assertTrue(
            pmt.dict_has_key(result_4bps, pmt.intern('payload symbols')))
        self.assertEqual(
            pmt.to_long(
                pmt.dict_ref(result_4bps, pmt.intern('payload symbols'),
                             pmt.PMT_F)), 2)
コード例 #3
0
 def handle_msg(self, msg):
     if pmt.dict_has_key(msg, pmt.intern(self.len_tag_key)):
         packet_len = pmt.to_python(msg)[self.len_tag_key]
         msg = pmt.dict_delete(msg, pmt.intern(self.len_tag_key))
         msg = pmt.dict_add(msg, pmt.intern(self.len_tag_key), pmt.from_long(packet_len * 8))
         
     self.message_port_pub(self.msg_buf_out, msg)
コード例 #4
0
    def test_packet_parse_default(self):
        ac = packet_utils.default_access_code
        length = '0000000000000001'

        hdr_format_1bps = digital.header_format_default(ac, 0)
        hdr_format_4bps = digital.header_format_default(ac, 0, 4)

        ac_bits = [int(x) & 1 for x in ac]
        length_bits = [int(x) & 1 for x in length]
        header_bits = ac_bits + length_bits + length_bits

        src_hdr = blocks.vector_source_b(header_bits)

        parser_1bps = digital.protocol_parser_b(hdr_format_1bps)
        parser_4bps = digital.protocol_parser_b(hdr_format_4bps)

        snk_hdr_1bps = blocks.message_debug()
        snk_hdr_4bps = blocks.message_debug()

        self.tb.connect(src_hdr, parser_1bps)
        self.tb.connect(src_hdr, parser_4bps)

        self.tb.msg_connect(parser_1bps, 'info', snk_hdr_1bps, 'store')
        self.tb.msg_connect(parser_4bps, 'info', snk_hdr_4bps, 'store')

        self.tb.start()
        while (snk_hdr_1bps.num_messages() < 1) and (snk_hdr_4bps.num_messages() < 1):
            time.sleep(0.1)
        self.tb.stop()
        self.tb.wait()

        result_1bps = snk_hdr_1bps.get_message(0)
        result_4bps = snk_hdr_4bps.get_message(0)

        self.assertTrue(pmt.dict_has_key(
            result_1bps, pmt.intern('payload symbols')))
        self.assertEqual(pmt.to_long(pmt.dict_ref(
            result_1bps, pmt.intern('payload symbols'), pmt.PMT_F)), 8)

        self.assertTrue(pmt.dict_has_key(
            result_4bps, pmt.intern('payload symbols')))
        self.assertEqual(pmt.to_long(pmt.dict_ref(
            result_4bps, pmt.intern('payload symbols'), pmt.PMT_F)), 2)
コード例 #5
0
ファイル: mkheader.py プロジェクト: mjp5578/recipes
def update_timestamp(hdr, seg_size):
    if pmt.dict_has_key(hdr, pmt.string_to_symbol("rx_time")):
        r = pmt.dict_ref(hdr, pmt.string_to_symbol("rx_time"), pmt.PMT_NIL)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
    else:
        sys.stderr.write("Could not find key 'time': \
                invalid or corrupt data file.\n")
        sys.exit(1)
    new_hdr = pmt.dict_delete(hdr, pmt.intern("rx_time"))
    if pmt.dict_has_key(hdr, pmt.intern("rx_rate")):
        r = pmt.dict_ref(hdr, pmt.intern("rx_rate"), pmt.PMT_NIL)
        rate = pmt.to_double(r)
        new_t = t + float(seg_size) / rate
        new_secs = long(new_t)
        new_fracs = new_t - new_secs
        time_val = pmt.make_tuple(pmt.from_uint64(new_secs),
                                  pmt.from_double(new_fracs))
        new_hdr = pmt.dict_add(new_hdr, pmt.intern("rx_time"), time_val)
        return new_hdr
コード例 #6
0
ファイル: mkheader.py プロジェクト: garverp/recipes
def update_timestamp(hdr,seg_size):
    if pmt.dict_has_key(hdr, pmt.string_to_symbol("rx_time")):
        r = pmt.dict_ref(hdr, pmt.string_to_symbol("rx_time"), pmt.PMT_NIL)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
    else:
        sys.stderr.write("Could not find key 'time': \
                invalid or corrupt data file.\n")
        sys.exit(1)
    new_hdr = pmt.dict_delete(hdr, pmt.intern("rx_time"))
    if pmt.dict_has_key(hdr, pmt.intern("rx_rate")):
        r = pmt.dict_ref(hdr, pmt.intern("rx_rate"), pmt.PMT_NIL)
        rate = pmt.to_double(r)
        new_t = t + float(seg_size)/rate
        new_secs = long(new_t)
        new_fracs = new_t - new_secs
        time_val = pmt.make_tuple(pmt.from_uint64(new_secs),
                             pmt.from_double(new_fracs))
        new_hdr = pmt.dict_add(new_hdr, pmt.intern("rx_time"), time_val)
        return new_hdr
コード例 #7
0
    def test_001_basic_io(self):
        self.tb.start()
        # provide two non PDU inputs and one PDU input
        self.add_sys_time.to_basic_block()._post(
            pmt.intern("pdu"), pmt.intern("BAD PDU"))
        self.add_sys_time.to_basic_block()._post(pmt.intern("pdu"),
                                                 pmt.cons(pmt.from_long(4), pmt.PMT_NIL))
        self.add_sys_time.to_basic_block()._post(pmt.intern("pdu"),
                                                 pmt.cons(pmt.make_dict(), pmt.init_f32vector(1, [0.0])))
        self.waitFor(lambda: self.debug.num_messages() >=
                     1, timeout=1.0, poll_interval=0.01)
        self.tb.stop()
        self.tb.wait()

        # make sure we got one message and it has a systime key
        self.assertEqual(1, self.debug.num_messages())
        self.assertTrue(pmt.dict_has_key(
            pmt.car(self.debug.get_message(0)), pmt.intern('systime')))
コード例 #8
0
def parse_header(p, VERBOSE=False):
    dump = pmt.PMT_NIL

    info = dict()

    if (pmt.is_dict(p) is False):
        sys.stderr.write(
            "Header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    # GET FILE FORMAT VERSION NUMBER
    if (pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
        version = pmt.to_long(r)
        if (VERBOSE):
            print("Version Number: {0}".format(version))
    else:
        sys.stderr.write(
            "Could not find key 'version': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SAMPLE RATE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
        samp_rate = pmt.to_double(r)
        info["rx_rate"] = samp_rate
        if (VERBOSE):
            print("Sample Rate: {0:.2f} sps".format(samp_rate))
    else:
        sys.stderr.write(
            "Could not find key 'sr': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT TIME STAMP
    if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
        info["rx_time"] = t
        if (VERBOSE):
            print("Seconds: {0:.6f}".format(t))
    else:
        sys.stderr.write(
            "Could not find key 'time': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT ITEM SIZE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
        dsize = pmt.to_long(r)
        info["size"] = dsize
        if (VERBOSE):
            print("Item size: {0}".format(dsize))
    else:
        sys.stderr.write(
            "Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT DATA TYPE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
        dtype = pmt.to_long(r)
        stype = ftype_to_string[dtype]
        info["type"] = stype
        if (VERBOSE):
            print("Data Type: {0} ({1})".format(stype, dtype))
    else:
        sys.stderr.write(
            "Could not find key 'type': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT COMPLEX
    if (pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
        cplx = pmt.to_bool(r)
        info["cplx"] = cplx
        if (VERBOSE):
            print("Complex? {0}".format(cplx))
    else:
        sys.stderr.write(
            "Could not find key 'cplx': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT WHERE CURRENT SEGMENT STARTS
    if (pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
        seg_start = pmt.to_uint64(r)
        info["hdr_len"] = seg_start
        info["extra_len"] = seg_start - HEADER_LENGTH
        info["has_extra"] = info["extra_len"] > 0
        if (VERBOSE):
            print("Header Length: {0} bytes".format(info["hdr_len"]))
            print("Extra Length:  {0}".format((info["extra_len"])))
            print("Extra Header?  {0}".format(info["has_extra"]))
    else:
        sys.stderr.write(
            "Could not find key 'strt': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SIZE OF DATA
    if (pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
        nbytes = pmt.to_uint64(r)

        nitems = nbytes / dsize
        info["nitems"] = nitems
        info["nbytes"] = nbytes

        if (VERBOSE):
            print("Size of Data: {0} bytes".format(nbytes))
            print("              {0} items".format(nitems))
    else:
        sys.stderr.write(
            "Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    return info
コード例 #9
0
ファイル: console.py プロジェクト: otilrac/gr-dect2-1
 def handle_msg(self, msg):
     if(pmt.dict_has_key( msg, pmt.to_pmt("log_msg"))):        
         log_msg = pmt.dict_ref( msg, pmt.to_pmt("log_msg"), pmt.PMT_NIL)
         self.console_msg = pmt.to_python(log_msg)
         self.emit(QtCore.SIGNAL("console_update"))
コード例 #10
0
def parse_header(p, VERBOSE=False):
    dump = pmt.PMT_NIL

    info = dict()

    if(pmt.is_dict(p) is False):
        sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    # GET FILE FORMAT VERSION NUMBER
    if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
        version = pmt.to_long(r)
        if(VERBOSE):
            print("Version Number: {0}".format(version))
    else:
        sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SAMPLE RATE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
        samp_rate = pmt.to_double(r)
        info["rx_rate"] = samp_rate
        if(VERBOSE):
            print("Sample Rate: {0:.2f} sps".format(samp_rate))
    else:
        sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT TIME STAMP
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
        info["rx_time"] = t
        if(VERBOSE):
            print("Seconds: {0:.6f}".format(t))
    else:
        sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT ITEM SIZE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
        dsize = pmt.to_long(r)
        info["size"] = dsize
        if(VERBOSE):
            print("Item size: {0}".format(dsize))
    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT DATA TYPE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
        dtype = pmt.to_long(r)
        stype = ftype_to_string[dtype]
        info["type"] = stype
        if(VERBOSE):
            print("Data Type: {0} ({1})".format(stype, dtype))
    else:
        sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT COMPLEX
    if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
        cplx = pmt.to_bool(r)
        info["cplx"] = cplx
        if(VERBOSE):
            print("Complex? {0}".format(cplx))
    else:
        sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT WHERE CURRENT SEGMENT STARTS
    if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
        seg_start = pmt.to_uint64(r)
        info["hdr_len"] = seg_start
        info["extra_len"] = seg_start - HEADER_LENGTH
        info["has_extra"] = info["extra_len"] > 0
        if(VERBOSE):
            print("Header Length: {0} bytes".format(info["hdr_len"]))
            print("Extra Length:  {0}".format((info["extra_len"])))
            print("Extra Header?  {0}".format(info["has_extra"]))
    else:
        sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SIZE OF DATA
    if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
        nbytes = pmt.to_uint64(r)

        nitems = nbytes / dsize
        info["nitems"] = nitems
        info["nbytes"] = nbytes

        if(VERBOSE):
            print("Size of Data: {0} bytes".format(nbytes))
            print("              {0} items".format(nitems))
    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    return info
コード例 #11
0
def parse_header(p, VERBOSE=False):
    dump = pmt.PMT_NIL

    info = dict()

    if (pmt.is_dict(p) is False):
        sys.stderr.write(
            "Header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    # GET FILE FORMAT VERSION NUMBER
    if (pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
        version = pmt.to_long(r)
        if (VERBOSE):
            print "Version Number: {0}".format(version)
    else:
        sys.stderr.write(
            "Could not find key 'version': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SAMPLE RATE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
        samp_rate = pmt.to_double(r)
        info["rx_rate"] = samp_rate
        if (VERBOSE):
            print "Sample Rate: " + eng_notation.num_to_str(samp_rate) + "SPS"

    else:
        sys.stderr.write(
            "Could not find key 'sr': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT TIME STAMP
    if (pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
        info["rx_time"] = t
        if (VERBOSE):
            time = datetime.fromtimestamp(t).strftime('%m/%d/%Y %H:%M:%S')
            print "Timestamp (Unix Epoch): " + time
            print "Integer Seconds: " + repr(secs)
            print "Fractional Seconds: " + repr(fracs)
            #print "Linux Epoch: {0:.6f}".format(t) + " Seconds"

    else:
        sys.stderr.write(
            "Could not find key 'time': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT ITEM SIZE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
        dsize = pmt.to_long(r)
        info["size"] = dsize
        if (VERBOSE):
            print "Item Size: " + eng_notation.num_to_str(dsize) + " Bytes"
    else:
        sys.stderr.write(
            "Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT DATA TYPE
    if (pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
        dtype = pmt.to_long(r)
        stype = ftype_to_string[dtype]
        info["type"] = stype
        if (VERBOSE):
            print "Data Type: {0} ({1})".format(stype, dtype)
    else:
        sys.stderr.write(
            "Could not find key 'type': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT COMPLEX
    if (pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
        #global cplx
        cplx = pmt.to_bool(r)
        info["cplx"] = cplx
        if (VERBOSE):
            print "Complex? {0}".format(cplx)
        global vecchk
        global tsize
#print cplx
#print dtype
#print dsize
    if (cplx == False):
        if (dtype == 0):
            tsize = 1
        elif (dtype == 1):
            tsize = 4
        elif (dtype == 2):
            tsize = 4
        elif (dtype == 3):
            tsize = 4
        elif (dtype == 5):
            tsize = 4
        elif (dtype == 6):
            tsize = 8
        else:
            tsize = 64
        #print tsize
        vecchk = dsize / tsize
        #print vecchk
        if (vecchk > 1):
            print "The data is a vector containing {0} elements.".format(
                vecchk)
        else:
            print "The data is not a vector."
    '''else:
        sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
        sys.exit(1)
		'''
    # EXTRACT WHERE CURRENT SEGMENT STARTS
    if (pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
        seg_start = pmt.to_uint64(r)
        info["hdr_len"] = seg_start
        info["extra_len"] = seg_start - HEADER_LENGTH
        info["has_extra"] = info["extra_len"] > 0
        if (VERBOSE):
            print "Header Length: {0} bytes".format(info["hdr_len"])
            print "Extra Length:  {0}".format((info["extra_len"]))
            print "Extra Header?  {0}".format(info["has_extra"])
    else:
        sys.stderr.write(
            "Could not find key 'strt': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SIZE OF DATA
    if (pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
        nbytes = pmt.to_uint64(r)

        nitems = nbytes / dsize
        info["nitems"] = nitems
        info["nbytes"] = nbytes
        #info["types"] = types
        if (VERBOSE):
            #print "Size of Data: {0:2.1e} bytes".format(nbytes)
            print "Segment Size (bytes): " + eng_notation.num_to_str(nbytes)
            #print "              {0:2.1e} items".format(nitems)
            print "Segment Size (items): " + eng_notation.num_to_str(nitems)

    else:
        sys.stderr.write(
            "Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    return info
コード例 #12
0
ファイル: console.py プロジェクト: pavelyazev/gr-dect2
 def handle_msg(self, msg):
     if pmt.dict_has_key(msg, pmt.to_pmt("log_msg")):
         log_msg = pmt.dict_ref(msg, pmt.to_pmt("log_msg"), pmt.PMT_NIL)
         self.console_msg = pmt.to_python(log_msg)
         self.emit(QtCore.SIGNAL("console_update"))
コード例 #13
0
def parse_header(p, VERBOSE=False):
    dump = pmt.PMT_NIL

    info = dict()

    if(pmt.is_dict(p) is False):
        sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    # GET FILE FORMAT VERSION NUMBER
    if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
        version = pmt.to_long(r)
        if(VERBOSE):
            print "Version Number: {0}".format(version)
    else:
        sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SAMPLE RATE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
        samp_rate = pmt.to_double(r)
        info["rx_rate"] = samp_rate
        if(VERBOSE):
            print "Sample Rate: " + eng_notation.num_to_str(samp_rate) + "SPS"

    else:
        sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT TIME STAMP
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
        info["rx_time"] = t
        if(VERBOSE):
            time = datetime.fromtimestamp(t).strftime('%m/%d/%Y %H:%M:%S')
            print "Timestamp (Unix Epoch): " + time
	    print "Integer Seconds: " + repr(secs)
	    print "Fractional Seconds: " + repr(fracs)
            #print "Linux Epoch: {0:.6f}".format(t) + " Seconds"
	    
    else:
        sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT ITEM SIZE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
        dsize = pmt.to_long(r)
        info["size"] = dsize
        if(VERBOSE):
            print "Item Size: " + eng_notation.num_to_str(dsize) + " Bytes"
    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT DATA TYPE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
        dtype = pmt.to_long(r)
        stype = ftype_to_string[dtype]
        info["type"] = stype
        if(VERBOSE):
            print "Data Type: {0} ({1})".format(stype, dtype)
    else:
        sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT COMPLEX
    if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
        #global cplx 
	cplx = pmt.to_bool(r)
        info["cplx"] = cplx
        if(VERBOSE):
            print "Complex? {0}".format(cplx)
	global vecchk
	global tsize
	#print cplx
	#print dtype
	#print dsize
    if(cplx==False):
		if(dtype==0):
			tsize=1
		elif(dtype==1):
			tsize=4
		elif(dtype==2):
			tsize=4
		elif(dtype==3):
			tsize=4
		elif(dtype==5):
			tsize=4
		elif(dtype==6):
			tsize=8
		else:
			tsize=64
		#print tsize
		vecchk = dsize/tsize
		#print vecchk
    		if(vecchk>1):
			print "The data is a vector containing {0} elements.".format(vecchk)
    		else:
			print "The data is not a vector."
    '''else:
        sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
        sys.exit(1)
		'''
    # EXTRACT WHERE CURRENT SEGMENT STARTS
    if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
        seg_start = pmt.to_uint64(r)
        info["hdr_len"] = seg_start
        info["extra_len"] = seg_start - HEADER_LENGTH
        info["has_extra"] = info["extra_len"] > 0
        if(VERBOSE):
            print "Header Length: {0} bytes".format(info["hdr_len"])
            print "Extra Length:  {0}".format((info["extra_len"]))
            print "Extra Header?  {0}".format(info["has_extra"])
    else:
        sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SIZE OF DATA
    if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
        nbytes = pmt.to_uint64(r)

        nitems = nbytes/dsize
        info["nitems"] = nitems
        info["nbytes"] = nbytes
	#info["types"] = types
        if(VERBOSE):
            #print "Size of Data: {0:2.1e} bytes".format(nbytes)
            print "Segment Size (bytes): " + eng_notation.num_to_str(nbytes) 
            #print "              {0:2.1e} items".format(nitems)
            print "Segment Size (items): " + eng_notation.num_to_str(nitems)

    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    return info