Beispiel #1
0
  def decode(self,decoded_msg):
    df = bin2dec(decoded_msg[:5])
    # Sanity check DF value
    if df not in [0, 4, 5, 11, 16, 17, 19, 20, 21, 22, 24]:
      return

    # Detect extended messages
    extended = False
    if LENGTH * 2 == len(decoded_msg):
      extended = True

    # Verify parity
    if self.check_parity and 0 != get_parity(decoded_msg, extended):
        return

    if "csv" == self.output_type:
      ca = bin2dec(decoded_msg[5:8])
      tc = bin2dec(decoded_msg[32:37])
      icao = bin2dec(decoded_msg[8:32])
      callsign = None
      speed = -1
      heading = -1
      position = None
      odd_even = -1
      if df in [11, 17]:
        if tc >= 1 and tc <= 4:
          callsign = get_callsign(decoded_msg)
        elif tc >= 9 and tc <= 18:
          odd_even = decoded_msg[53]

          if icao not in planes:
            planes[icao] = {}
          if 1 == odd_even:
            planes[icao]["odd"] = get_position_data(decoded_msg)
          else:
            planes[icao]["even"] = get_position_data(decoded_msg)
          if "odd" in planes[icao] and "even" in planes[icao]:
            position = get_position(planes[icao]["even"][0],
                                    planes[icao]["odd"][0],
                                    planes[icao]["even"][1],
                                    planes[icao]["odd"][1],
                                    odd_even)
        elif tc == 19:
          speed_heading = get_speed_heading(decoded_msg)
          speed = speed_heading[0]
          heading = speed_heading[1]

      self.tx_msgq.insert_tail(gr.message_from_string("%X,%s,%s,%s,%s,%s,%s,%s,%s\n" % \
       (icao,
        callsign if callsign else "",
        int(speed) if speed != -1 else "",
        int(heading) if heading != -1 else "",
        "%.02f,%.02f" % (position[0], position[1]) if position else "",
        odd_even if odd_even != -1 else "",
        df if df != -1 else "",
        ca if ca != -1 else "",
        tc if tc != -1 else "")))

    elif "hex" == self.output_type:
      self.tx_msgq.insert_tail(gr.message_from_string("*%X;\n" % bin2dec(decoded_msg)))
Beispiel #2
0
  def work(self, input_items, output_items):
    nread = self.nitems_read(0)

    in0 = input_items[0]
    in0_len = len(in0)

    # Look for preamble tag
    for tag in self.get_tags_in_window(0, 0, in0_len, pmt.intern("adsb_preamble")):
      offset_start = tag.offset - nread
      offset_end = tag.offset - nread + LENGTH * 2 * 2

      if offset_end > in0_len: # Need to wait for buffer to fill before processing
        return 0

      # Try extended length message decoding first
      bin = in0[offset_start:offset_end]
      decoded_msg = self.decode(bin, LENGTH * 2)
      if LENGTH * 2 == len(decoded_msg):
        self.tx_msgq.insert_tail(gr.message_from_string(decoded_msg))
        continue

      # Failed decoding of extended message - try standard length
      bin = bin[0:LENGTH * 2]
      decoded_msg = self.decode(bin, LENGTH)
      if LENGTH == len(decoded_msg):
        self.tx_msgq.insert_tail(gr.message_from_string(decoded_msg, LENGTH))
        continue

    return in0_len
Beispiel #3
0
    def send_pkt2(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
        
            #print '[TxPath] Data Requested'
            pkt = scsf_packet_utils.make_packet(payload,
                                           self._samples_per_symbol,
                                           2,
                                           self._access_code,
                                           self._pad_for_usrp,
                                           1)

            msg = gr.message_from_string(pkt)

        scsf_msg = gr.message_from_string(struct.pack('!b', 0))
        self.scsf_encoder.msgq().insert_tail(scsf_msg)
        scsf_msg = gr.message_from_string(struct.pack('!b', 0))
        self.scsf_encoder.msgq().insert_tail(scsf_msg)
                
        self._pkt_input_scsf.msgq().insert_tail(msg)
 def test_301(self):
     src = gr.message_source(gr.sizeof_char)
     dst = gr.vector_sink_b()
     self.fg.connect(src, dst)
     src.msgq().insert_tail(gr.message_from_string('01234'))
     src.msgq().insert_tail(gr.message_from_string('5'))
     src.msgq().insert_tail(gr.message_from_string(''))
     src.msgq().insert_tail(gr.message_from_string('6789'))
     src.msgq().insert_tail(gr.message(1))                  # send EOF
     self.fg.run()
     self.assertEquals(tuple(map(ord, '0123456789')), dst.data())
Beispiel #5
0
    def test_301(self):
        # Use itemsize, limit constructor
        src = blocks.message_source(gr.sizeof_char)
        dst = gr.vector_sink_b()
	tb = gr.top_block()
        tb.connect(src, dst)
        src.msgq().insert_tail(gr.message_from_string('01234'))
        src.msgq().insert_tail(gr.message_from_string('5'))
        src.msgq().insert_tail(gr.message_from_string(''))
        src.msgq().insert_tail(gr.message_from_string('6789'))
        src.msgq().insert_tail(gr.message(1))                  # send EOF
        tb.run()
        self.assertEquals(tuple(map(ord, '0123456789')), dst.data())
Beispiel #6
0
 def test_301(self):
     # Use itemsize, limit constructor
     src = blocks.message_source(gr.sizeof_char)
     dst = gr.vector_sink_b()
     tb = gr.top_block()
     tb.connect(src, dst)
     src.msgq().insert_tail(gr.message_from_string('01234'))
     src.msgq().insert_tail(gr.message_from_string('5'))
     src.msgq().insert_tail(gr.message_from_string(''))
     src.msgq().insert_tail(gr.message_from_string('6789'))
     src.msgq().insert_tail(gr.message(1))  # send EOF
     tb.run()
     self.assertEquals(tuple(map(ord, '0123456789')), dst.data())
    def __init__(self, code_index, code_size=31, DataRate_Kbps=850, Nburst=32, Ncpb=16, MeanPRF_KHz=15600, Nsync=64, deltaL=16, Nsdf=8, bypass_conv_enc=0, isRangingPacket=0, msgq_limit=2):
        """
	Hierarchical block for the IEEE 802.15.4a UWB modulation.

        Packets to be sent are enqueued by calling send_pkt.
        The output is the complex modulated signal at baseband.

	@param fg: flow graph
	@type fg: flow graph
        @param msgq_limit: maximum number of messages in message queue
        @type msgq_limit: int
        @param pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples
        @param bypass_conv_enc: bypass the convolutional encoding (1) or not (0)[default]
        @type bypass_conv_enc: int
        
        """
        gr.hier_block2.__init__(self, "ieee804154a_uwb_mod_pkt",
				gr.io_signature(0, 0, 0),                    # Input signature
				gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
				        
        # setting parameters
        self.code_index = code_index
        self.code_size = code_size
        self.DataRate_Kbps = DataRate_Kbps
        self.Nburst = Nburst
        self.Ncpb = Ncpb
        self.MeanPRF_KHz = MeanPRF_KHz
        self.Nsync = Nsync
        self.deltaL = deltaL
        self.Nsdf = Nsdf
        self.bypass_conv_enc = bypass_conv_enc
        self.isRangingPacket = bypass_conv_enc
        
        ############ THE SYNCH PATH
        # synchronization header
        self.synch_seq = ieee802_15_4a.msg_formatter.set_synch(self.code_size, self.code_index, self.Nsync, self.deltaL, self.Nsdf)
        self.synch_msg = gr.message_from_string(self.synch_seq)
        self._synch_input = blocks.message_source(gr.sizeof_char, msgq_limit)
        
        ############ THE MAIN PATH
        # accepts messages from the outside world
        self._pkt_input = blocks.message_source(gr.sizeof_char, msgq_limit)
        
        # convolutional encoding
        self._convolutional_encoder = ieee802_15_4a.conv_encoder (self.bypass_conv_enc);
        
        # BPSK BPM modulator
        self._modulator = ieee802_15_4a.bpsk_bpm_modulator(self.code_index, self.Nburst, self.Ncpb)
        
        # connect the blocks
        self.connect(self._pkt_input, self._convolutional_encoder, self._modulator)
        
        # THE CONNECTION BETWEEN THE PATHS
        self.delay = blocks.delay (gr.sizeof_char, len(self.synch_seq))
        self.sum2 = blocks.or_bb(1);
        
        self.connect (self._synch_input, (self.sum2, 0))
        self.connect (self._modulator, self.delay)
        self.connect (self.delay, (self.sum2, 1))
        self.connect (self.sum2, self)
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1)              # tell self._pkt_input we're not sending any more packets
        else: 
            info = ofdm_packet_utils.get_info(payload, self._regime, self._symbol_time)
            N_cbps            = info["N_cbps"]
            N_bpsc            = info["N_bpsc"]
            N_rate            = info["rate"]
            N_sym             = info["N_sym"]

            (pkt,Length) = ofdm_packet_utils.ieee802_11_make(payload,self._regime, self._symbol_time)
            #print ofdm_packet_utils.asciistr_to_bin(pkt)
            #print "Length ", Length
            (pkt_scrambled,Length) = ofdm_packet_utils.scrambler(pkt,Length)
            #print ofdm_packet_utils.asciistr_to_bin(pkt_scrambled)
            #print "Length after scrambling ", Length			
            pkt_coded = ofdm_packet_utils.conv_encoder(pkt_scrambled, Length, self._regime, N_cbps, N_bpsc, N_sym, N_rate)
            #print ofdm_packet_utils.asciistr_to_bin(pkt_coded)	
            pkt_interleaved = ofdm_packet_utils.interleaver(pkt_coded , self._regime, N_cbps, N_bpsc)
            #print ofdm_packet_utils.asciistr_to_bin(pkt_interleaved)
            msg = gr.message_from_string(pkt_interleaved) 
            
        #if self._pkt_input.msgq().full_p():
        #    print "Queue full, are u sure you want to insert stuff in it?"
        #if self._pkt_input.msgq().empty_p():
        #    print "Queue empty, feel free to insert stuff in it!"
        self._pkt_input.msgq().insert_tail(msg)
Beispiel #9
0
 def send_pkt(self, payload='', eof=False):
     if eof:
         msg = gr.message(
             1)  # tell self._pkt_input we're not sending any more packets
     else:
         msg = gr.message_from_string(payload)
     self.pkt_input.msgq().insert_tail(msg)
Beispiel #10
0
    def no_test_001_pad(self):
        s = "abcd"
        x = self.make_waveform(s)
        m = self.tobytes(x)
        msg = gr.message_from_string(m)
        Ntx = 2
        msg.set_arg1(Ntx)
        msg.set_arg2(len(x)/Ntx)

        pad = rf.pad()
        dst = gr.vector_sink_c()

        pad.inputQ().insert_tail(msg)
        pad.shutdown()  # schedules shutdown

        self.tb.connect (pad, dst)
        pad.set_npost(3)
        self.tb.run()
        result_data = dst.data ()
        
        block_size = pad.block_size()
        # prepad:(1+npre)*Ntx, postpad:(1+npost)*Ntx
        pre_pad = int(1+pad.npre())*Ntx*block_size
        post_pad = int(1+pad.npost())*Ntx*block_size
        pad_size = pre_pad + post_pad - len(x)%block_size
        self.assertComplexTuplesAlmostEqual (tuple(x), \
                   result_data[pre_pad:pre_pad+len(x)], len(x)+1 )
        self.assertEqual(len(result_data), len(x)+pad_size )
        self.assertEqual(phy.phyglobal.ctrlQ().count(), 1)
Beispiel #11
0
 def send_packet(self, num=1): # NOTE: we keep this to allow discontinuous operation
   """ send a packet of options.size symbols from the datafile """
   msgq = self.msg.msgq()
   payload = [0] * self.size
   payload[0] = 1
   payload = array.array('B', payload) * num
   msgq.insert_tail(gr.message_from_string(payload.tostring()))
Beispiel #12
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            pkt = packet_utils.make_packet(payload,
                                           self._modulator.samples_per_symbol(),
                                           self._modulator.bits_per_symbol(),
                                           self._access_code,
                                           self._pad_for_usrp,
                                           self._whitener_offset,
                                           True,
                                           self.coder)
            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
            if self._use_whitener_offset is True:
                self._whitener_offset = (self._whitener_offset + 1) % 16
                
        self._pkt_input.msgq().insert_tail(msg)
 def send_pkt(self, payload='', eof=False):
     print self.msgq.count()
     if eof:
         msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
     else:
         msg = gr.message_from_string(payload)
     self.msgq.insert_tail(msg)
Beispiel #14
0
 def get_temp_from_sensor(self):
     self._serial.write(chr(TEMPSENSOR_ADDR))
     temp_val = map(ord, self._serial.read(2))
     temp_string = str(temp_val[0]) + str(temp_val[1])
     arr = numpy.array(float(temp_string) / 10.0, numpy.float32)
     print "Read Temperature from Sensor: %s" % (arr)
     return gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, 1)
Beispiel #15
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(
                1)  # tell self._pkt_input we're not sending any more packets
        else:
            info = ofdm_packet_utils.get_info(payload, self._regime,
                                              self._symbol_time)
            N_cbps = info["N_cbps"]
            N_bpsc = info["N_bpsc"]
            N_rate = info["rate"]
            N_sym = info["N_sym"]

            (pkt, Length) = ofdm_packet_utils.ftw_make(payload, self._regime,
                                                       self._symbol_time)
            (pkt_scrambled, Length) = ofdm_packet_utils.scrambler(pkt, Length)
            #            print
            #            print conv_packed_binary_string_to_1_0_string(pkt_scrambled)
            pkt_coded = ofdm_packet_utils.conv_encoder(pkt_scrambled, Length,
                                                       self._regime, N_cbps,
                                                       N_bpsc, N_sym, N_rate)
            #            print
            #            print conv_packed_binary_string_to_1_0_string(pkt_coded)
            pkt_interleaved = ofdm_packet_utils.interleaver(
                pkt_coded, self._regime, N_cbps, N_bpsc)
            #            print
            #            print conv_packed_binary_string_to_1_0_string(pkt_interleaved)
            msg = gr.message_from_string(pkt_interleaved)

        self._pkt_input.msgq().insert_tail(msg)
    def send_pkt(self, mac_msg, eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1)             # tell self._pkt_input we're not sending any more packets
            
        else: 
            info = mac_msg["INFO"]              # this dictionary vector contains tx information that will be used during the encoding process                     
	    N_cbps            = info["N_cbps"]     # Upload the number of Coded bits per OFDM Symbol
	    N_bpsc            = info["N_bpsc"]     # Upload the number of Coded bits per sub-carrier
            N_rate            = info["rate"]   # Upload the data rate code
	    N_sym             = info["N_sym"]      # Upload the OFDM Symbols' number
        
        # MODIFIED FROM ORIGINAL
        # It is necessary to update the payload and length field on every packet transmitted 
            (pkt,Length) = mac_msg["MPDU"], mac_msg["LENGTH"] 

            
            #print"Txtime in microseconds:",info["txtime"]
            #print"Length of MPDU in bytes = ", info["packet_len"]
            #print"Number of DATA OFDM symbols = ", info["N_sym"]    
            #print"Number of padding bits = ", info["N_pad"]

         
        # Encoding operations
	    (pkt_scrambled,Length) = ofdm_packet_utils.scrambler(pkt,Length)
	    pkt_coded = ofdm_packet_utils.conv_encoder(pkt_scrambled, Length, self._regime, N_cbps, N_bpsc, N_sym, N_rate)
	    pkt_interleaved = ofdm_packet_utils.interleaver(pkt_coded , self._regime, N_cbps, N_bpsc)
	    msg = gr.message_from_string(pkt_interleaved)
        self._pkt_input.msgq().insert_tail(msg)
Beispiel #17
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            if self._adaptive_coding_enabled:
                pkt = digital_ll.ofdm_packet_util.make_packet(payload, 1, 1,
                                                    self._pad_for_usrp, self._use_coding, self._variable_coding_block_length, True, 
                                                    self._rfcenterfreq, self._bandwidth, self._logging,
                                                    whitening=True,
                                                    percent_bw_occupied=self._percent_bw_occupied)
            else:
                pkt = digital_ll.ofdm_packet_util.make_packet(payload, 1, 1,
                                                    self._pad_for_usrp, self._use_coding, self._coding_block_length, False,
                                                    self._rfcenterfreq, self._bandwidth, self._logging,
                                                    whitening=True,
                                                    percent_bw_occupied=self._percent_bw_occupied)
            
            
            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
        self._pkt_input.msgq().insert_tail(msg)
Beispiel #18
0
def bar(mpif):
    time.sleep(5.0)
    sys.stderr.write("bar running ...\n")
    """
    ## packet 1
    MCS = 5
    data = "helloworld"*10
    v = hydra.mimo.txvector()
    v.set_length(len(data) )
    v.set_power(8000.0)
    v.set_rate(MCS)
    h = v.to_string()
    s = h+data
    mpif.tx.inputQ().insert_tail(gr.message_from_string(s, hydra.mpif.TXDATA) )
    ## packets 2 to L
    L = 100
    #for k in range(L):
    """
    k = 0
    m_monitor = hydra.mimo.mac_monitor()
    while 1:
        k = (k + 1) % 1000
        time.sleep(1.0)
        MCS = k % RATE_LIMIT
        # data = "helloworld"*(k%10+10)           # create data to send
        data = "helloworld" * 10  # create data to send
        # create 802.11 data packet
        macdata = hydra.mimo.mimo_mac.ieee80211_data(data)
        v = hydra.mimo.txvector()
        v.set_length(len(macdata))
        v.set_power(8000.0)
        v.set_rate(MCS)
        h = v.to_string()
        s = h + macdata
        mpif.tx.inputQ().insert_tail(gr.message_from_string(s, hydra.mpif.TXDATA))
Beispiel #19
0
 def send_pkt(self, payload='', eof=False):
     if eof:
         msg = gr.message(1)
     else:
         pkt = ofdm_packet_utils.make_packet(payload, 1, 1, False, whiten=False)
         msg = gr.message_from_string(pkt)
     self.ofdm_mapper.msgq().insert_tail(msg)
    def send_pkt(self, seqNr, addressInfo, payload='', eof=False):
        """
        Send the payload.

        @param seqNr: sequence number of packet
        @type seqNr: byte
        @param addressInfo: address information for packet
        @type addressInfo: string
        @param payload: data to send
        @type payload: string
        """

        if eof:
            msg = gr.message(1) # tell self.pkt_input we're not sending any more packets
        else:
            FCF = make_FCF()

            pkt = make_ieee802_15_4_packet(FCF,
                                           seqNr,
                                           addressInfo,
                                           payload,
                                           self.pad_for_usrp)
            print "pkt =", packet_utils.string_to_hex_list(pkt), len(pkt)
            msg = gr.message_from_string(pkt)
        self.pkt_input.msgq().insert_tail(msg)
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        
        fqueue = open('./queuepkt', 'a')
        
        
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            #print "original_payload =", string_to_hex_list(payload)
            pkt = ofdm_packet_utils.make_packet(payload, 1, 1, self._pad_for_usrp, whitening=True)
            
            msg = gr.message_from_string(pkt)
            
            print>>  fqueue, "%.2f \t len(pkt): %d \t pkt_in_queue_before_insert %d" % (time.clock(), len(pkt), self._pkt_input.msgq().count())
            
            if 0:
		print "len(pkt)=", len(pkt)
		print "pkt =", ofdm_packet_utils.string_to_hex_list(pkt)
            
        self._pkt_input.msgq().insert_tail(msg)
Beispiel #22
0
    def _handler_ser(self, samples):
        num = len(samples) / 2
        arr = numpy.zeros(num, numpy.float32)
        for i in range(num):
            old_err = self._err_array[self._err_index]
            # record error
            ref = samples[i * 2]
            res = samples[i * 2 + 1]
            if ref == res:
                self._err_array[self._err_index] = 0
            else:
                self._err_array[self._err_index] = 1
                # update number of errors
            self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err
            # increment index
            self._err_index = (self._err_index + 1) % self._max_samples
            self._num_samps = min(self._num_samps + 1, self._max_samples)
            # write sample
            arr[i] = float(self._num_errs) / float(self._num_samps)
            # write message
        msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num)
        self._msgq_source.insert_tail(msg)

        # change value of ser_ which is geted by external programs
        self.ser_ = arr[num - 1]
Beispiel #23
0
    def send_pkt(self, payload=None, eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            print("Done sending pkts")
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            pkt = packet_utils2.make_packet(payload,
                                           self._modulator.samples_per_symbol(),
                                           self._modulator.bits_per_symbol(),
                                           self._access_code,
                                           self._pad_for_usrp,
                                           self._whitener_offset)
            print "pkt_utils returned ", pkt
            
            if self._use_whitener_offset is True:
                self._whitener_offset = (self._whitener_offset + 1) % 16

            if pkt:
                print("SENDING PACKET\n");
                msg = gr.message_from_string(pkt)
                print("msg set")
                self._pkt_input.msgq().insert_tail(msg) #else do nothing
                print("msg added to msgq")
Beispiel #24
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self.pkt_input we're not sending any more packets
        else:
            sync = chr(0xff) * 16
            start_frame_delim = chr(0xa0) + chr(0xf3)
            preamble = sync + start_frame_delim

            signal = chr(0x0A) # 0x0A = 1 Mpbs, 0x14 = 2 Mbps
            service = chr(0x00) # 802.11 Original Spec
            length = chr(((len(payload) + 4)<< 3) & 0xff) + \
                     chr(((len(payload) + 4)>> 5) & 0xff)

            plcp_header = signal + service + length
            
            plcp_crc = bbn.crc16(plcp_header)
            plcp_header += chr(plcp_crc & 0xff) + chr(plcp_crc >> 8)

            payload_crc = bbn.crc32_le(payload)
            payload_crc_str = chr((payload_crc >> 0) & 0xff) + \
                              chr((payload_crc >> 8) & 0xff) + \
                              chr((payload_crc >> 16) & 0xff) + \
                              chr((payload_crc >> 24) & 0xff)
            msg = gr.message_from_string(preamble + plcp_header +
                                         payload + payload_crc_str +\
                                         chr(0)*7);

        self.pkt_input.msgq().insert_tail(msg)
Beispiel #25
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1)              # tell self._pkt_input we're not sending any more packets
        else: 
            info = ofdm_packet_utils.get_info(payload, self._regime, self._symbol_time)
	    N_cbps            = info["N_cbps"]
	    N_bpsc            = info["N_bpsc"]
            N_rate            = info["rate"]
	    N_sym             = info["N_sym"]

	    (pkt,Length) = ofdm_packet_utils.ftw_make(payload,self._regime, self._symbol_time)
	    (pkt_scrambled,Length) = ofdm_packet_utils.scrambler(pkt,Length)	
#            print
#            print conv_packed_binary_string_to_1_0_string(pkt_scrambled)	
	    pkt_coded = ofdm_packet_utils.conv_encoder(pkt_scrambled, Length, self._regime, N_cbps, N_bpsc, N_sym, N_rate)
#            print
#            print conv_packed_binary_string_to_1_0_string(pkt_coded)
	    pkt_interleaved = ofdm_packet_utils.interleaver(pkt_coded , self._regime, N_cbps, N_bpsc)
#            print
#            print conv_packed_binary_string_to_1_0_string(pkt_interleaved)
	    msg = gr.message_from_string(pkt_interleaved) 

        self._pkt_input.msgq().insert_tail(msg)
	def get_temperature(self):
		self._SBHS.write(chr(TEMPERATURE))
		temp_val = map(ord, self._SBHS.read(2)) #reads in hexadecimal
		temp_string = str(temp_val[0]) + str(temp_val[1])	
		arr = numpy.array(float(temp_string)/10.0, numpy.float32)
		print "Temperature Read: %s" %(arr)
		return gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, 1)
Beispiel #27
0
 def send_pkt(self, payload='',eof=False):
     if eof:
         msg = gr.message(1)
     else:
         msg = gr.message_from_string(payload)
     # send message twice
     for i in range(2):
         self._pkt_source.msgq().insert_tail(msg)
Beispiel #28
0
 def send_pkt(self, payload='', eof=False):
     if eof:
         msg = gr.message(1)
     else:
         msg = gr.message_from_string(payload)
     # send message twice
     for i in range(2):
         self._pkt_source.msgq().insert_tail(msg)
Beispiel #29
0
    def rx_callback(ok, payload):
        global n_rcvd, n_right
        n_rcvd += 1
        if ok:
            n_right += 1
            tb.audio_tx.msgq().insert_tail(gr.message_from_string(payload))

        print "ok = %r  n_rcvd = %4d  n_right = %4d" % (ok, n_rcvd, n_right)
Beispiel #30
0
    def rx_callback(ok, payload):
        global n_rcvd, n_right
        n_rcvd += 1
        if ok:
            n_right += 1
	    tb.audio_tx.msgq().insert_tail(gr.message_from_string(payload))
        
        print "ok = %r  n_rcvd = %4d  n_right = %4d" % (
            ok, n_rcvd, n_right)
Beispiel #31
0
	def push(self, item):
		"""!
		Push an item into the back of the queue.
		@param item the item
		"""
		if self._vlen == 1: item = [item]
		arr = numpy.array(item, self._numpy)
		msg = gr.message_from_string(arr.tostring(), 0, self._item_size, self._vlen)
		self._msgq.insert_tail(msg)
Beispiel #32
0
	def push(self, item):
		"""!
		Push an item into the back of the queue.
		@param item the item
		"""
		if self._vlen == 1: item = [item]
		arr = numpy.array(item, self._numpy)
		msg = gr.message_from_string(arr.tostring(), 0, self._item_size, self._vlen)
		self._msgq.insert_tail(msg)
Beispiel #33
0
def bar(tx):
	time.sleep(1)
	print "bar running"
	pkt = "helloworld"
	print pkt
	msg = gr.message_from_string(pkt)
	print msg
	msg = tx.msgq().insert_tail(msg)
	print "insert"
Beispiel #34
0
	def run(self):
		"""
		Infinite polling loop.
		"""
		while True:
			time.sleep(1.0/self._probe_rate)
			arr = numpy.array(self._probe_callback(), numpy.float32)
			msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, 1)
			self._msgq.insert_tail(msg)
 def send_samples(self, payload='', time=None):
     msg = gr.message_from_string(payload)
     if time is not None:
         secs = long(time)
         frac_secs = time - long(time)
         msg.set_timestamp(secs, frac_secs)
     else:
         #print "[TRANSMIT_PATH] WARNING: no timestamp!"
         pass
     self.tx.msgq().insert_tail(msg)
    def generate_time_diff(self):
        pc_time = time.time()
        usrp_time = self.u.get_time_now().get_real_secs()
        tdiff = pc_time - usrp_time
        print tdiff
        time_diff = struct.pack('!d', tdiff)

        msg = gr.message_from_string(time_diff)

        return msg
 def generate_time_diff(self):
     pc_time = time.time()
     usrp_time = self.u.get_time_now().get_real_secs()
     tdiff = pc_time - usrp_time
     print tdiff
     time_diff = struct.pack('!d', tdiff)
     
     msg = gr.message_from_string(time_diff)
     
     return msg
Beispiel #38
0
 def send_pkt(payload='', eof=False, timeValid=False, timestamp=0):
     if eof:
         msg = gr.message(1)
     else:
         msg = gr.message_from_string(payload)
         if timeValid:
             secs = long(timestamp)
             frac_secs = timestamp - long(timestamp)
             msg.set_timestamp(secs, frac_secs)
     return tb.txpath.msgq().insert_tail(msg)
Beispiel #39
0
 def send_pkt(payload='', timestamp=None, eof=False):
     if eof:
         msg = gr.message(1)
     else:
         msg = gr.message_from_string(payload)
         if timestamp is not None:
             secs = long(timestamp)
             frac_secs = timestamp - long(timestamp)
             msg.set_timestamp(secs, frac_secs)
     return tb.txpath.msgq().insert_tail(msg)
Beispiel #40
0
    def send_pkt(self, payload):
        """
		Wrap the payload in a packet and push onto the message queue.
		@param payload string, data to send
		"""
        packet = packet_utils.make_packet(payload, self._samples_per_symbol,
                                          self._bits_per_symbol,
                                          self._access_code,
                                          self._pad_for_usrp)
        msg = gr.message_from_string(packet)
        self._msgq_out.insert_tail(msg)
Beispiel #41
0
 def fill_queue(self, txDataList):
     message_str = ""
     for bit in txDataList:
         if bit == 1:
             message_str += b'\x01'
         elif bit == 0:
             message_str += b'\x00'
         else:
             print "Error passing data to flowgraph. Exiting..."
             exit(1)
         self.source_queue.handle(gr.message_from_string(message_str))
         message_str = ""
Beispiel #42
0
    def send_pkt(self, payload):
        """
		Wrap the payload in a packet and push onto the message queue.

		Args:
			payload: string, data to send
		"""
        packet = cc1111_packet_utils.make_packet(
            payload, self._samples_per_symbol, self._bits_per_symbol,
            self._preamble, self._access_code, self._pad_for_usrp,
            self._do_whitening, self._add_crc)
        msg = gr.message_from_string(packet)
        self._msgq_out.insert_tail(msg)
Beispiel #43
0
 def _handler_ber(self, samples):
     num = len(samples)/2
     arr = numpy.zeros(num, numpy.float32)
     for i in range(num):
         old_err = self._err_array[self._err_index]
         #record error
         self._err_array[self._err_index] = _1s_counts[samples[i*2] ^ samples[i*2 + 1]]
         self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err
         #increment index
         self._err_index = (self._err_index + 1)%self._max_samples
         self._num_samps = min(self._num_samps + 1, self._max_samples)
         #write sample
         arr[i] = float(self._num_errs)/float(self._num_samps*self._bits_per_symbol)
     #write message
     msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num)
     self._msgq_source.insert_tail(msg)
Beispiel #44
0
 def test_1(self):
     data = ('hello', 'you', 'there')
     tx_msgq = gr.msg_queue()
     rx_msgq = gr.msg_queue()
     for d in data:
         tx_msgq.insert_tail(gr.message_from_string(d))
     tb = gr.top_block()
     src = gr.message_source(gr.sizeof_char, tx_msgq, "packet_length")
     snk = gr.message_sink(gr.sizeof_char, rx_msgq, False, "packet_length")
     tb.connect(src, snk)
     tb.start()
     time.sleep(1)
     tb.stop()
     for d in data:
         msg = rx_msgq.delete_head()
         contents = msg.to_string()
         self.assertEqual(d, contents)
Beispiel #45
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        Args:
            payload: data to send (string)
        """
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            pkt = ofdm_packet_utils.make_packet(payload, 1, 1,
                                                self._pad_for_usrp,
                                                whitening=True)

            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
        self._pkt_input.msgq().insert_tail(msg)
Beispiel #46
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(
                1)  # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            if self._adaptive_coding_enabled:
                pkt = digital_ll.ofdm_packet_util.make_packet(
                    payload,
                    1,
                    1,
                    self._pad_for_usrp,
                    self._use_coding,
                    self._variable_coding_block_length,
                    True,
                    self._rfcenterfreq,
                    self._bandwidth,
                    self._logging,
                    whitening=True,
                    percent_bw_occupied=self._percent_bw_occupied)
            else:
                pkt = digital_ll.ofdm_packet_util.make_packet(
                    payload,
                    1,
                    1,
                    self._pad_for_usrp,
                    self._use_coding,
                    self._coding_block_length,
                    False,
                    self._rfcenterfreq,
                    self._bandwidth,
                    self._logging,
                    whitening=True,
                    percent_bw_occupied=self._percent_bw_occupied)

            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
        self._pkt_input.msgq().insert_tail(msg)
    def get_mlat_positions(self):
        msg = None
        try:
            msg = self._sock.recv(1024)
        except socket.error:
            pass
        if msg:
            for line in msg.splitlines(True):
                if line.endswith("\n"):
                    if self._remnant:
                        line = self._remnant + line
                        self._remnant = None
                    self._queue.insert_tail(gr.message_from_string(line))

                else:
                    if self._remnant is not None:
                        raise Exception("Malformed data: " + line)
                    else:
                        self._remnant = line
Beispiel #48
0
    def enqueue_signal(self, id, signal):
        if not self.src_id_valid(id):
            raise RuntimeError, "Src ID invalid"

        if not self.src_ready(id):
            return False

        if self.is_const[id]:
            raise RuntimeError, "Can't enqueue signal in constant source"

        try:
            signal = numpy.array(signal, dtype=numpy.float32)
            msg = gr.message_from_string(signal.tostring())
            self.sources[id].msgq().insert_tail(msg)
            self.lengths[id] = len(signal)
            return True
        except Exception, ex:
            print repr(ex)
            raise RuntimeError, "FAILED to enqueue signal?"
Beispiel #49
0
    def send_pkt(self, payload='', eof=False, time_flag=False, time=0):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            pkt = ofdm_packet_utils.make_packet(payload, 1, 1,
                                                self._pad_for_usrp,
                                                whitening=True)
            
            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
            if time_flag:
                msg.set_timestamp(long(time), time-long(time))
        self._pkt_input.msgq().insert_tail(msg)
    def send_tinyos_pkt_add_crc(self, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """

        print "GR: ieee802_15_4_pkt: ########## SDR sending a TinyOS packet ###########"

        if eof:
            msg = gr.message(
                1)  # tell self.pkt_input we're not sending any more packets
        else:
            pkt = make_tinyos_packet_add_crc(payload, self.pad_for_usrp)
            print "GR: ieee802_15_4_pkt: pkt =", packet_utils.string_to_hex_list(
                pkt), len(pkt)
            msg = gr.message_from_string(pkt)
        self.pkt_input.msgq().insert_tail(msg)

        print "GR: ieee802_15_4_pkt: ########## SDR inserted packet in message Queue ###########"
Beispiel #51
0
 def _handler_ser(self, samples):
     num = len(samples)/2
     arr = numpy.zeros(num, numpy.float32)
     for i in range(num):
         old_err = self._err_array[self._err_index]
         #record error
         ref = samples[i*2]
         res = samples[i*2 + 1]
         if ref == res:
             self._err_array[self._err_index] = 0
         else:
             self._err_array[self._err_index] = 1
         #update number of errors
         self._num_errs = self._num_errs + self._err_array[self._err_index] - old_err
         #increment index
         self._err_index = (self._err_index + 1)%self._max_samples
         self._num_samps = min(self._num_samps + 1, self._max_samples)
         #write sample
         arr[i] = float(self._num_errs)/float(self._num_samps)
     #write message
     msg = gr.message_from_string(arr.tostring(), 0, gr.sizeof_float, num)
     self._msgq_source.insert_tail(msg)
Beispiel #52
0
    def send_pkt(self, payload='', eof=False):
        """
        Send the payload.

        Args:
            payload: data to send (string)
        """
        if eof:
            msg = gr.message(
                1)  # tell self._pkt_input we're not sending any more packets
        else:
            # print "original_payload =", string_to_hex_list(payload)
            pkt = packet_utils.make_packet(
                payload, self._modulator.samples_per_symbol(),
                self._modulator.bits_per_symbol(), self._preamble,
                self._access_code, self._pad_for_usrp, self._whitener_offset)
            #print "pkt =", string_to_hex_list(pkt)
            msg = gr.message_from_string(pkt)
            if self._use_whitener_offset is True:
                self._whitener_offset = (self._whitener_offset + 1) % 16

        self._pkt_input.msgq().insert_tail(msg)
Beispiel #53
0
    def send_pkt(self, seqNr, addressInfo, payload='', eof=False):
        """
        Send the payload.

        @param seqNr: sequence number of packet
        @type seqNr: byte
        @param addressInfo: address information for packet
        @type addressInfo: string
        @param payload: data to send
        @type payload: string
        """

        if eof:
            msg = gr.message(
                1)  # tell self.pkt_input we're not sending any more packets
        else:
            FCF = make_FCF()

            pkt = make_ieee802_15_4_packet(FCF, seqNr, addressInfo, payload,
                                           self.pad_for_usrp)
            print "pkt =", packet_utils.string_to_hex_list(pkt), len(pkt)
            msg = gr.message_from_string(pkt)
        self.pkt_input.msgq().insert_tail(msg)
Beispiel #54
0
    def fill_queue_vector(self, bb_list, hop_select_list):

        # baseband and select values must be the same
        if len(bb_list) != len(hop_select_list):
            print "Fatal Error: hop select list must be same length as baseband list"
            exit(1)
        # create a vector entry of the bb bits and corresponding enables
        #vector_sample = numpy.array([b'\x00', 0, 0, 0])
        vector_sample = [b'\x00', b'\x00', b'\x00', b'\x00']
        # now we make a u8 vector out of this
        #vector_pmt = pmt.make_u8vector(4, b'\x00')

        for i in xrange(len(bb_list)):
            # assign first vector element to bb value
            vector_sample[0] = b'\x01' if bb_list[i] == 1 else b'\x00'
            if hop_select_list[i] == 0:
                vector_sample[1] = b'\x01'
                vector_sample[2] = b'\x00'
                vector_sample[3] = b'\x00'
            elif hop_select_list[i] == 1:
                vector_sample[1] = b'\x00'
                vector_sample[2] = b'\x01'
                vector_sample[3] = b'\x00'
            elif hop_select_list[i] == 2:
                vector_sample[1] = b'\x00'
                vector_sample[2] = b'\x00'
                vector_sample[3] = b'\x01'
            else:
                print "Fatal Error: hop select out of range; must be 0-2"
                exit(1)

            #vector_pmt = pmt.to_pmt(vector_sample)
            vector_str = ""
            for uchar in vector_sample:
                vector_str += uchar
            message = gr.message_from_string(vector_str)
            self.source_queue_v.insert_tail(message)
    def send_pkt(self, am_group, module_src, module_dst, dst_addr, src_addr, msg_type, payload='', eof=False):
        """
        Send the payload.

        @param payload: data to send
        @type payload: string
        """
        if eof:
            msg = gr.message(1) # tell self.pkt_input we're not sending any more packets
        else:
            #print "original_payload =", string_to_hex_list(payload)
            pkt = make_sos_packet(am_group,
                                  module_src,
                                  module_dst,
                                  dst_addr,
                                  src_addr,
                                  msg_type,
                                  payload,
                                  self.cc1k_mod.spb,
                                  self._access_code,
                                  self.pad_for_usrp)
            #print "pkt =", str(map(hex, map(ord, pkt)))
            msg = gr.message_from_string(pkt)
        self.pkt_input.msgq().insert_tail(msg)
Beispiel #56
0
 def recv_pkt(self, ok, payload):
     msg = gr.message_from_string(payload, 0, self._item_size_out,
                                  len(payload) / self._item_size_out)
     if ok: self._msgq_out.insert_tail(msg)