Exemple #1
0
def read_single_header(handle):
    nread = handle.tell()
    header_str = handle.read(parse_file_metadata.HEADER_LENGTH)
    if len(header_str) == 0:
        sys.stderr.write("Empty Header, quitting.\n")
        sys.exit(1)
    # Convert from string to PMT (should be a dictionary)
    try:
        header = pmt.deserialize_str(header_str)
    except RuntimeError:
        sys.stderr.write(
            "Could not deserialize header: invalid or \
                corrupt data file.\n"
        )
        sys.exit(1)
    info = parse_file_metadata.parse_header(header, False)
    extras_str = handle.read(info["extra_len"])
    try:
        extras_hdr = pmt.deserialize_str(extras_str)
    except RuntimeError:
        sys.stderr.write("Could not deserialize extras\n")
        sys.exit(1)
    nread += parse_file_metadata.HEADER_LENGTH + info["extra_len"]
    handle.seek(nread, 0)
    return header, extras_hdr, handle
Exemple #2
0
def parse_gnuradio_header(header_file, verbose=False):
    headers = []
    index = 0
    rx_time = datetime.timedelta(seconds=0)
    with open(header_file, "rb") as handle:
        file_length = os.path.getsize(header_file)
        while True:
            if file_length - handle.tell() < parse_file_metadata.HEADER_LENGTH:
                break

            header_str = handle.read(parse_file_metadata.HEADER_LENGTH)

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

            info = parse_file_metadata.parse_header(header, verbose)

            if info["nbytes"] == 0:
                break

            if info["extra_len"] > 0:
                extra_str = handle.read(info["extra_len"])
                if len(extra_str) == 0:
                    break

                try:
                    extra = pmt.deserialize_str(extra_str)
                except RuntimeError:
                    break

                parse_file_metadata.parse_extra_dict(extra, info, verbose)

            if len(headers) > 0:
                last_rx_time = headers[-1]["rx_time"]
                samples_delta = headers[-1]["nitems"] / headers[-1]["rx_rate"]
                samples_delta = datetime.timedelta(seconds=samples_delta)
                info["rx_time"] = last_rx_time + samples_delta

                info["index"] = index
                index = index + info["nitems"]
            else:
                info["rx_time"] = datetime.timedelta(seconds=0.0)
                info["index"] = 0
                index = info["nitems"]

            headers.append(info)

    return headers
Exemple #3
0
    def parse_metadata(self, filepath):
        head_file = filepath+".hdr"
        hlen = parse_file_metadata.HEADER_LENGTH

        headers = []
        extra_tags = []

        overs = []

        if not os.path.isfile(head_file):
            return {'total power':{}}, []

        with open(head_file,'rb') as fd:
            for h_str in iter(partial(fd.read, hlen), ''):
                h_pmt = pmt.deserialize_str(h_str)
                h_parsed=parse_file_metadata.parse_header(h_pmt,False)
                headers.append(h_parsed)
                if(h_parsed["extra_len"] > 0):
            
                    extra_str = fd.read(h_parsed["extra_len"])
                    if(len(extra_str) == 0):
                        break
                    extra = pmt.deserialize_str(extra_str)
                    e_parsed = parse_file_metadata.parse_extra_dict(extra, h_parsed, False)
                    extra_tags.append(e_parsed)

        # Load the extra data into the tagging system for the LightCurve.
        tags = pd.DataFrame({'total power':[{} for _ in xrange(self.data_len)]})
        nums_done = 0 
        segment_start_time = headers[0]['rx_time']
        segments = 1
        for i  in xrange(len(extra_tags)):
            j = int(nums_done + extra_tags[i]['nitems'])
            if not extra_tags[i]['rx_time'] == segment_start_time:

                should = segment_start_time + j/extra_tags[i]['rx_rate']

                miss_sec = extra_tags[i]['rx_time']-should

                overs.append({'new_seg':j, 'new_time':extra_tags[i]['rx_time']})

                segment_start_time = extra_tags[i]['rx_time']
                segments += 1
            j = int(nums_done + extra_tags[i]['nitems'])
            tags['total power'][j] = extra_tags[i]
            nums_done += extra_tags[i]['nitems']
        new = self.import_tags(extra_tags, 'total power')
            
        return {'total power': headers[0]}, overs
Exemple #4
0
 def test14(self):
     const = self.MAXINT32 - 1
     x_pmt = pmt.from_long(const)
     s = pmt.serialize_str(x_pmt)
     deser = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(x_pmt, deser))
     self.assertEqual(const,pmt.to_long(deser))
Exemple #5
0
 def test17(self):
     const = self.MININT32 + 1
     x_pmt = pmt.from_long(const)
     s = pmt.serialize_str(x_pmt)
     deser = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(x_pmt, deser))
     x_long = pmt.to_long(deser)
     self.assertEqual(const, x_long)
Exemple #6
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
Exemple #7
0
 def watcher(self):
     self.keep_running = True
     while self.keep_running:
         # poll for calls
         socks = dict(self.poller_rep.poll(10))
         if socks.get(self.rep_socket) == zmq.POLLIN:
             # receive call
             msg = self.rep_socket.recv()
             (id_str, args) = pmt.to_python(pmt.deserialize_str(msg))
             print("[RPC] request:", id_str, ", args:", args)
             reply = self.callback(id_str, args)
             self.rep_socket.send(pmt.serialize_str(pmt.to_pmt(reply)))
Exemple #8
0
 def test19(self):
     max_key = pmt.intern("MAX")
     _max = pmt.from_long(self.MAXINT32)
     min_key = pmt.intern("MIN")
     _min = pmt.from_long(self.MININT32)
     d = pmt.make_dict()
     d = pmt.dict_add(d, max_key, _max)
     d = pmt.dict_add(d, min_key, _min)
     s = pmt.serialize_str(d)
     deser = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(d, deser))
     p_dict = pmt.to_python(deser)
     self.assertEqual(self.MAXINT32, p_dict["MAX"])
     self.assertEqual(self.MININT32, p_dict["MIN"])
Exemple #9
0
def background_thread():
    # Establish ZMQ context and socket
    context = zmq.Context()
    socket = context.socket(zmq.SUB)
    socket.setsockopt(zmq.SUBSCRIBE, "")
    socket.connect("tcp://0.0.0.0:%d" % (ZMQ_PORT))

    while True:
        # Receive decoded ADS-B message from the decoder over ZMQ
        pdu_bin = socket.recv()
        pdu = pmt.deserialize_str(pdu_bin)
        plane = pmt.to_python(pmt.car(pdu))

        socketio.emit("updatePlane", plane)
        time.sleep(0.010)
Exemple #10
0
    def work(self, queue, listener_address, label):
        self.q = queue
        self.label = label
        self.listener_address = listener_address
        
        self.logger.log("init: " + self.label)
        
        context = zmq.Context()
        socket = context.socket(zmq.SUB)
        socket.setsockopt(zmq.SUBSCRIBE, '')
        socket.connect(listener_address)
        
        while True:
            # Important improvement opportunity 1: The zmq socket that are transmitting to the collector
            # is sending data as json (send_json), but here the data is being received as normal string.
            # This is getenrating some inconsistency and the code should be reviewed in future.
            
            # Important improvement opportunity 2: The information transported by zmq between applications
            # may use linux socket instead of tcp socket.
             
            k = socket.recv()
            if self.from_gnuradio == True:
                # this part of code seams to be consuming alot of processing, needs verification
                try:
                    p = pmt.deserialize_str(k)
                except Exception:
                    p = None
                    self.logger.log('Error: problem deserializing message')

                if p is not None:
                    python_numpy_array = pmt.pmt_to_python.pmt_to_python(p)
                    tosend = str(python_numpy_array[0])
                    msg = (self.label, tosend)
                    with self.thread_lock:
                        self.q.put(msg)
                        
            else:
                tosend = k
                msg = (self.label, tosend)
                with self.thread_lock:
                    self.q.put(msg)
            
            sleep(0.01) # test
Exemple #11
0
 def test10(self):
     v = pmt.init_s32vector(3, [11, -22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
Exemple #12
0
 def test07(self):
     v = pmt.init_u16vector(3, [11, 22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
 def forward(self):
     data, addr = self.input_sock.recvfrom(4096)
     print "Received Something", pmt.deserialize_str(data)
     self.output_sock.sendto(data, (self.dest_addr, self.dest_port))
    def watcher(self, reception_complete):
        poll = dict(self.poller.poll(100))
        for i in self.interfaces:
            if not reception_complete[i[0]]:
                # i = (socket, data_type, callback_func)
                if poll.get(i[1]) == zmq.POLLIN:
                    print "receiving data"
                    # receive data
                    msg_packed = i[1].recv()
                    # use numpy to unpack header and data
                    header_magic = numpy.fromstring(msg_packed[:2], numpy.dtype('uint16'))
                    #print "header_magic",header_magic
                    if header_magic != 0x5FF0:
                        raise ValueError('Error: gr-zmq header magic does not match!')
                    header_version = numpy.fromstring(msg_packed[2:3], numpy.dtype('uint8'))
                    #print "header_version",header_version
                    if header_version != 1:
                        raise ValueError('Error: gr-zmq header version too high!')
                    offset_out = numpy.fromstring(msg_packed[3:11], numpy.dtype('uint64'))
                    #print "offset_out",offset_out
                    rcv_ntags = numpy.fromstring(msg_packed[11:19], numpy.dtype('uint64'))

                    if rcv_ntags == 3:
                        # extract all the tags
                        offset = numpy.fromstring(msg_packed[19:27], numpy.dtype('uint64'))
                        #print "offset", offset
                        key = str(pmt.deserialize_str(msg_packed[27:37]))
                        #print "key",key
                        value = pmt.to_python(pmt.deserialize_str(msg_packed[37:60]))
                        value = value[0] + value[1]
                        #print "value", value
                        srcid = str(pmt.deserialize_str(msg_packed[60:82]))
                        #print "srcid",srcid
                        #print "in probe_manager:"
                        key_2 = str(pmt.deserialize_str(msg_packed[90:100]))
                        #print "key_2",key_2
                        value_2 = pmt.to_python(pmt.deserialize_str(msg_packed[100:109]))
                        #print "value_2", value_2
                        srcid_2 = str(pmt.deserialize_str(msg_packed[109:131]))
                        #print "srcid_2",srcid_2

                        key_3 = str(pmt.deserialize_str(msg_packed[139:149]))
                        #print "key_3",key_3
                        value_3 = pmt.to_python(pmt.deserialize_str(msg_packed[149:158]))
                        #print "value_3", value_3
                        srcid_3 = str(pmt.deserialize_str(msg_packed[158:180]))
                        #print "srcid_3",srcid_3

                        # Reverse engineering (brute force)
                        #for n in range(39,39+1*64):
                        #for m in range(145,1):
                        #    for n in range(160,180):
                        #        try:
                        #            key = pmt.deserialize_str(msg_packed[m:n])
                        #            print "value_3",key
                        #            print m,n
                        #        except:
                        #            pass

                        samples = numpy.fromstring(msg_packed[180:], numpy.dtype(i[3]))
                        tags = {key:value,key_2:value_2,key_3:value_3}
                    else:
                        samples = numpy.fromstring(msg_packed[19:], numpy.dtype(i[3]))
                        tags = None
                        #print "\n!!!!!!fatal error in rx ",i[0],"!!!!!!"
                        print "rcv_ntags",rcv_ntags
                        print len(samples)
                        #print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"

                    # invoke callback function
                    i[4](samples, tags)
Exemple #15
0
 def test12(self):
     v = pmt.init_c64vector(3, [11 + -101j, -22 + 202j, 33 + -303j])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
Exemple #16
0
 def test11(self):
     v = pmt.init_c32vector(3, [11 + -101j, -22 + 202j, 33 + -303j])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
     self.assertEqual(pmt.uniform_vector_itemsize(v), 8)
Exemple #17
0
 def test16(self):
     const = self.MININT32
     x_pmt = pmt.from_long(const)
     s = pmt.serialize_str(x_pmt)
     deser = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(x_pmt, deser))
Exemple #18
0
 def test03(self):
     v = pmt.init_f32vector(3, [11, -22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
     self.assertEqual(pmt.uniform_vector_itemsize(v), 4)
Exemple #19
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(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)
Exemple #20
0
 def test07(self):
     v = pmt.init_u16vector(3, [11, 22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
    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)
Exemple #22
0
 def test12(self):
     v = pmt.init_c64vector(3, [11 + -101j, -22 + 202j, 33 + -303j])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
Exemple #23
0
 def test03(self):
     v = pmt.init_f32vector(3, [11, -22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
     self.assertEqual(pmt.uniform_vector_itemsize(v), 4)
Exemple #24
0
 def test11(self):
     v = pmt.init_c32vector(3, [11 + -101j, -22 + 202j, 33 + -303j])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
     self.assertEqual(pmt.uniform_vector_itemsize(v), 8)
Exemple #25
0
 def test10(self):
     v = pmt.init_s32vector(3, [11, -22, 33])
     s = pmt.serialize_str(v)
     d = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(v, d))
Exemple #26
0
    parser = argparse.ArgumentParser()
    parser.add_argument("--server", "-s", default="127.0.0.1", help="remote server")
    parser.add_argument("--port", "-p", default=6000, type=int, help="remote port")
    args = parser.parse_args()

    # Socket to talk to server
    context = zmq.Context()
    socket = context.socket(zmq.SUB)

    print "Collecting updates from radio server at {} port {}...".format(args.server, args.port)
    socket.connect("tcp://{}:{}".format(args.server, args.port))

    socket.setsockopt(zmq.SUBSCRIBE, "")
    data = RBDSData()
    try:
        while True:
            gnr_message_pmt = pmt.deserialize_str(socket.recv())
            if pmt.is_tuple(gnr_message_pmt):
                msg_type = pmt.to_long(pmt.tuple_ref(gnr_message_pmt, 0))
                msg = pmt.symbol_to_string(pmt.tuple_ref(gnr_message_pmt, 1))
                data.update(msg_type, msg)
                print ansi_erase_display(2) + repr(data) + ansi_move_to(1, 1)
            else:
                print "Encountered Data I Did Not Understand"

    except KeyboardInterrupt:
        print ansi_erase_display(2) + ansi_move_to(1, 1) + "Shutdown requested...exiting"
    except Exception:
        traceback.print_exc(file=sys.stdout)
    sys.exit(0)
Exemple #27
0
 def test16(self):
     const = self.MININT32
     x_pmt = pmt.from_long(const)
     s = pmt.serialize_str(x_pmt)
     deser = pmt.deserialize_str(s)
     self.assertTrue(pmt.equal(x_pmt, deser))
    except EOFError:
        pass

    tb.stop()
    tb.wait()

fileToWrite = open("signal.txt", 'w')
fileToRead = open("meta_signal.bin", "rb")

posInFile = 0
while(True):
    header_str = fileToRead.read(parse_file_metadata.HEADER_LENGTH)
    if(len(header_str) == 0):
        break
    try:
        header = pmt.deserialize_str(header_str)
    except RuntimeError:
        sys.stderr.write("Could not deserialize header: invalid or corrupt data file.\n")
        sys.exit(1)

    info = parse_file_metadata.parse_header(header, False)
    
    if(info["extra_len"] > 0):
        extra_str = fileToRead.read(info["extra_len"])
        if(len(extra_str) == 0):
            break
        
        try:
            extra = pmt.deserialize_str(extra_str)
        except RuntimeError:
            sys.stderr.write("Could not deserialize extras: invalid or corrupt data file.\n")
Exemple #29
0
                        help='remote port')
    args = parser.parse_args()

    # Socket to talk to server
    context = zmq.Context()
    socket = context.socket(zmq.SUB)

    print 'Collecting updates from radio server at {} port {}...'.format(
        args.server, args.port)
    socket.connect('tcp://{}:{}'.format(args.server, args.port))

    socket.setsockopt(zmq.SUBSCRIBE, '')
    data = RBDSData()
    try:
        while True:
            gnr_message_pmt = pmt.deserialize_str(socket.recv())
            if pmt.is_tuple(gnr_message_pmt):
                msg_type = pmt.to_long(pmt.tuple_ref(gnr_message_pmt, 0))
                msg = pmt.symbol_to_string(pmt.tuple_ref(gnr_message_pmt, 1))
                data.update(msg_type, msg)
                print ansi_erase_display(2) + repr(data) + ansi_move_to(1, 1)
            else:
                print 'Encountered Data I Did Not Understand'

    except KeyboardInterrupt:
        print ansi_erase_display(2) + ansi_move_to(
            1, 1) + "Shutdown requested...exiting"
    except Exception:
        traceback.print_exc(file=sys.stdout)
    sys.exit(0)