def post_req(environ, start_response, postdata): global my_input_q, my_output_q, my_recv_q, my_port resp_msg = [] try: data = json.loads(postdata) except: sys.stderr.write('post_req: error processing input: %s:\n' % (postdata)) traceback.print_exc(limit=None, file=sys.stderr) sys.stderr.write('*** end traceback ***\n') for d in data: if d['command'].startswith('config-') or d['command'].startswith('rx-'): resp = do_request(d) if resp: resp_msg.append(resp) continue if d['command'].startswith('settings-'): msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) else: msg = gr.message().make_from_string(str(d['command']), -2, d['data'], 0) if my_output_q.full_p(): my_output_q.delete_head_nowait() # ignores result if not my_output_q.full_p(): my_output_q.insert_tail(msg) time.sleep(0.2) while not my_recv_q.empty_p(): msg = my_recv_q.delete_head() if msg.type() == -4: resp_msg.append(json.loads(msg.to_string())) status = '200 OK' content_type = 'application/json' output = json.dumps(resp_msg) return status, content_type, output
def process_qmsg(self, msg): # Handle UI requests RX_COMMANDS = 'skip lockout hold whitelist reload'.split() if msg is None: return True s = msg.to_string() if type(s) is not str and isinstance(s, bytes): # should only get here if python3 s = s.decode() if s == 'quit': return True elif s == 'update': # UI initiated update request self.ui_last_update = time.time() self.ui_freq_update() if self.trunking is None or self.trunk_rx is None: return False js = self.trunk_rx.to_json() # extract data from trunking module msg = gr.message().make_from_string(js, -4, 0, 0) self.ui_in_q.insert_tail(msg) # send info back to UI self.ui_plot_update() elif s == 'toggle_plot': if not self.get_interactive(): sys.stderr.write( "%s Cannot start plots for non-realtime (replay) sessions\n" % log_ts.get()) return plot_type = int(msg.arg1()) msgq_id = int(msg.arg2()) self.find_channel(msgq_id).toggle_plot(plot_type) elif s == 'adj_tune': freq = msg.arg1() msgq_id = int(msg.arg2()) self.find_channel(msgq_id).adj_tune(freq) elif s == 'set_debug': dbglvl = int(msg.arg1()) self.set_debug(dbglvl) elif s == 'get_config': if self.terminal is not None and self.terminal_config is not None: self.terminal_config['json_type'] = "terminal_config" js = json.dumps(self.terminal_config) msg = gr.message().make_from_string(js, -4, 0, 0) self.ui_in_q.insert_tail(msg) # send configuration back to UI pass else: return False elif s == 'dump_tgids': self.trunk_rx.dump_tgids() elif s == 'watchdog': if self.ui_last_update > 0 and ( time.time() > (self.ui_last_update + self.ui_timeout)): self.ui_last_update = 0 sys.stderr.write("%s UI Timeout\n" % log_ts.get()) for chan in self.channels: chan.close_plots() elif s in RX_COMMANDS: if self.trunking is not None and self.trunk_rx is not None: self.trunk_rx.ui_command(s, msg.arg1(), msg.arg2()) return False
def body_200(self): self.msgq.insert_tail(gr.message(0)) self.assertEquals(1, self.msgq.count()) self.msgq.insert_tail(gr.message(1)) self.assertEquals(2, self.msgq.count()) msg0 = self.msgq.delete_head() self.assertEquals(0, msg0.type()) msg1 = self.msgq.delete_head() self.assertEquals(1, msg1.type()) self.assertEquals(0, self.msgq.count())
def process_terminal_events(self): # return true signifies end of main event loop if curses.is_term_resized(self.maxy, self.maxx) is True: self.resize_curses() _ORD_S = ord('s') _ORD_L = ord('l') _ORD_H = ord('h') COMMANDS = {_ORD_S: 'skip', _ORD_L: 'lockout', _ORD_H: 'hold'} c = self.stdscr.getch() if c == ord('u') or self.do_auto_update(): msg = gr.message().make_from_string('update', -2, 0, 0) self.output_q.insert_tail(msg) if c in COMMANDS.keys(): msg = gr.message().make_from_string(COMMANDS[c], -2, 0, 0) self.output_q.insert_tail(msg) elif c == ord('q'): return True elif c == ord('t'): if self.current_nac: msg = gr.message().make_from_string('add_default_config', -2, int(self.current_nac), 0) self.output_q.insert_tail(msg) elif c == ord('f'): self.prompt.addstr(0, 0, 'Frequency') self.prompt.refresh() self.text_win.clear() response = self.textpad.edit() self.prompt.clear() self.prompt.refresh() self.text_win.clear() self.text_win.refresh() try: freq = float(response) if freq < 10000: freq *= 1000000.0 except: freq = None if freq: msg = gr.message().make_from_string('set_freq', -2, freq, 0) self.output_q.insert_tail(msg) elif c == ord(','): msg = gr.message().make_from_string('adj_tune', -2, -100, 0) self.output_q.insert_tail(msg) elif c == ord('.'): msg = gr.message().make_from_string('adj_tune', -2, 100, 0) self.output_q.insert_tail(msg) elif c == ord('<'): msg = gr.message().make_from_string('adj_tune', -2, -1200, 0) self.output_q.insert_tail(msg) elif c == ord('>'): msg = gr.message().make_from_string('adj_tune', -2, 1200, 0) self.output_q.insert_tail(msg) elif (c >= ord('1')) and (c <= ord('4')): msg = gr.message().make_from_string('toggle_plot', -2, (c - ord('0')), 0) self.output_q.insert_tail(msg) elif c == ord('x'): assert 1 == 0 return False
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)
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")
def error_tracking(self): UPDATE_TIME = 3 if self.last_error_update + UPDATE_TIME > time.time() \ or self.last_change_freq_at + UPDATE_TIME > time.time(): return self.last_error_update = time.time() band = self.demod.get_error_band() freq_error = self.demod.get_freq_error() if band: self.error_band += band self.freq_correction += freq_error * 0.15 self.freq_correction = int(self.freq_correction) if self.freq_correction > 600: self.freq_correction -= 1200 self.error_band += 1 elif self.freq_correction < -600: self.freq_correction += 1200 self.error_band -= 1 self.tuning_error = int(self.error_band * 1200 + self.freq_correction) e = 0 if self.last_change_freq > 0: e = (self.tuning_error*1e6) / float(self.last_change_freq) if self.options.verbosity >= 10: sys.stderr.write('frequency_tracking\t%d\t%d\t%d\t%d\t%f\n' % (freq_error, self.error_band, self.tuning_error, self.freq_correction, e)) if self.input_q.full_p(): return d = {'time': time.time(), 'json_type': 'freq_error_tracking', 'name': 'rx.py', 'device': self.options.args, 'freq_error': freq_error, 'band': band, 'error_band': self.error_band, 'tuning_error': self.tuning_error, 'freq_correction': self.freq_correction} js = json.dumps(d) msg = gr.message().make_from_string(js, -4, 0, 0) self.input_q.insert_tail(msg) if self.options.verbosity > 0: sys.stderr.write('%f error tracking: %s\n' % (time.time(), js))
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)
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)
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)
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 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)
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)
def __init__(self, options, input_q, output_q, init_config=None, **kwds): threading.Thread.__init__ (self, **kwds) self.setDaemon(1) self.keep_running = True self.rx_options = None self.input_q = input_q self.output_q = output_q self.verbosity = options.verbosity self.zmq_context = zmq.Context() self.zmq_port = options.zmq_port self.zmq_sub = self.zmq_context.socket(zmq.SUB) self.zmq_sub.connect('tcp://localhost:%d' % self.zmq_port) self.zmq_sub.setsockopt_string(zmq.SUBSCRIBE, '') self.zmq_pub = self.zmq_context.socket(zmq.PUB) self.zmq_pub.sndhwm = 5 self.zmq_pub.bind('tcp://*:%d' % (self.zmq_port+1)) self.start() self.subproc = None self.msg = None self.q_watcher = queue_watcher(self.input_q, self.process_msg) if init_config: d = {'command': 'rx-start', 'data': init_config} msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) self.input_q.insert_tail(msg)
def freq_update(self): params = self.last_freq_params params['json_type'] = 'change_freq' params['fine_tune'] = self.options.fine_tune js = json.dumps(params) msg = gr.message().make_from_string(js, -4, 0, 0) self.input_q.insert_tail(msg)
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 post_req(environ, start_response, postdata): global my_input_q, my_output_q, my_recv_q, my_port valid_req = False try: data = json.loads(postdata) for d in data: msg = gr.message().make_from_string(str(d['command']), -2, d['data'], 0) my_output_q.insert_tail(msg) valid_req = True time.sleep(0.2) except: sys.stderr.write('post_req: error processing input: %s:\n' % (postdata)) resp_msg = [] while not my_recv_q.empty_p(): msg = my_recv_q.delete_head() if msg.type() == -4: resp_msg.append(json.loads(msg.to_string())) if not valid_req: resp_msg = [] status = '200 OK' content_type = 'application/json' output = json.dumps(resp_msg) return status, content_type, output
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 do_request(d): global my_backend if d['command'].startswith('rx-'): msg = gr.message().make_from_string(json.dumps(d), -2, 0, 0) if not my_backend.input_q.full_p(): my_backend.input_q.insert_tail(msg) return None elif d['command'] == 'config-load': if '[TSV]' in d['data']: return tsv_config(d['data']) filename = '%s%s.json' % (CFG_DIR, d['data']) if not os.access(filename, os.R_OK): return None js_msg = json.loads(open(filename).read()) return {'json_type':'config_data', 'data': js_msg} elif d['command'] == 'config-list': files = glob.glob('%s*.json' % CFG_DIR) files = [x.replace('.json', '') for x in files] files = [x.replace(CFG_DIR, '') for x in files] if d['data'] == 'tsv': tsvfiles = glob.glob('%s*.tsv' % TSV_DIR) tsvfiles = [x for x in tsvfiles if valid_tsv(x)] tsvfiles = [x.replace('.tsv', '[TSV]') for x in tsvfiles] tsvfiles = [x.replace(TSV_DIR, '') for x in tsvfiles] files += tsvfiles return {'json_type':'config_list', 'data': files} elif d['command'] == 'config-save': name = d['data']['name'] if '..' in name or '.json' in name or '/' in name: return None filename = '%s%s.json' % (CFG_DIR, d['data']['name']) open(filename, 'w').write(json.dumps(d['data']['value'], indent=4, separators=[',',':'], sort_keys=True)) return None
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 process_qmsg(self, msg): # return true = end top block RX_COMMANDS = 'skip lockout hold' s = msg.to_string() if s == 'quit': return True elif s == 'update': self.freq_update() if self.trunk_rx is None: return False ## possible race cond - just ignore js = self.trunk_rx.to_json() msg = gr.message().make_from_string(js, -4, 0, 0) self.input_q.insert_tail(msg) self.process_ajax() elif s == 'set_freq': freq = msg.arg1() self.last_freq_params['freq'] = freq self.set_freq(freq) elif s == 'adj_tune': freq = msg.arg1() self.adj_tune(freq) elif s == 'toggle_plot': plot_type = msg.arg1() self.toggle_plot(plot_type) elif s == 'dump_tgids': self.trunk_rx.dump_tgids() elif s == 'add_default_config': nac = msg.arg1() self.trunk_rx.add_default_config(int(nac)) elif s in RX_COMMANDS: self.rx_q.insert_tail(msg) return False
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, 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_event(self, d): ## called from trunking module to send json msgs / updates to client if d is not None: self.sql_db.event(d) if d and not self.input_q.full_p(): msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) self.input_q.insert_tail(msg) self.process_update()
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 meta_update(meta_q, tgid=None, tag=None): if meta_q is None: return d = {'json_type': 'meta_update'} d['tgid'] = tgid d['tag'] = tag msg = gr.message().make_from_string(json.dumps(d), -2, time.time(), 0) meta_q.insert_tail(msg)
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)
def stop(self): print "Stopping..." self.keep_running = False msg = gr.message() # Empty message to signal end self.msgq.insert_tail(msg) self.stop_event.wait() self.server.shutdown() print "Stopped"
def do_error_tracking(self): if not self.track_errors: return for chan in self.channels: d = chan.error_tracking(self.last_change_freq) if d is not None and not self.input_q.full_p(): msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) self.input_q.insert_tail(msg)
def meta_update(self, tgid, tag): if self.meta_server is None: return d = {'json_type': 'meta_update'} d['tgid'] = tgid d['tag'] = tag msg = gr.message().make_from_string(json.dumps(d), -2, time.time(), 0) self.meta_q.insert_tail(msg)
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)
def stop(self): try: for i in range(1, len(self.sources)): if not self.is_const[i]: self.sources[i].msgq().flush() self.sources[i].msgq().insert_tail(gr.message(1)) except Exception, ex: print repr(ex)
def stop(self): try: for i in range( 1, len( self.sources ) ): if not self.is_const[i]: self.sources[i].msgq().flush() self.sources[i].msgq().insert_tail( gr.message(1) ) except Exception, ex: print repr(ex)
def freq_update(self): if self.input_q.full_p(): return params = self.last_freq_params params['json_type'] = 'change_freq' params['current_time'] = time.time() js = json.dumps(params) msg = gr.message().make_from_string(js, -4, 0, 0) self.input_q.insert_tail(msg)
def run(self): while self.keep_running: js = self.zmq_sub.recv() if not self.keep_running: break js = ensure_str(js) msg = gr.message().make_from_string(js, -4, 0, 0) if not self.output_q.full_p(): self.output_q.insert_tail(msg)
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)
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)
def process_ajax(self): if not self.options.terminal_type.startswith('http:'): return filenames = [sink.gnuplot.filename for sink in self.plot_sinks if sink.gnuplot.filename] error = None if self.options.demod_type == 'cqpsk': error = self.demod.get_freq_error() d = {'json_type': 'rx_update', 'error': error, 'fine_tune': self.options.fine_tune, 'files': filenames} msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) self.input_q.insert_tail(msg)
def meta_update(self, tgid, tag): if self.meta_server is None: return if tgid is None: metadata = "[idle]" else: metadata = "[" + str(tgid) + "] " + tag msg = gr.message().make_from_string(metadata, -2, 0, 0) self.meta_q.insert_tail(msg)
def send_command(self, command, arg1=0, arg2=0): if self.sock: js = json.dumps({'command': command, 'arg1': arg1, 'arg2': arg2}) if sys.version[0] > '2': if type(js) is str: js = js.encode() self.sock.send(js) else: msg = gr.message().make_from_string(command, -2, arg1, arg2) self.output_q.insert_tail(msg)
def send_pkt(self, payload='', eof=False): pad_for_usrp = True 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, 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)
def run(self): while self.keep_running: js = self.zmq_sub.recv() if not self.keep_running: break d = json.loads(js) msg = gr.message().make_from_string(str(d['command']), d['msgtype'], d['data'], 0) if self.output_q.full_p(): self.output_q.delete_head() if not self.output_q.full_p(): self.output_q.insert_tail(msg)
def send_command(self, command, arg1=0, arg2=0): if self.sock: self.sock.send( json.dumps({ 'command': command, 'arg1': arg1, 'arg2': arg2 })) else: msg = gr.message().make_from_string(command, -2, arg1, arg2) self.output_q.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())
def run(self): while self.keep_running: try: js, addr = self.sock.recvfrom(2048) msg = gr.message().make_from_string(js, -4, 0, 0) self.input_q.insert_tail(msg) except socket.timeout: pass except: raise if not self.terminal.keep_running: self.keep_running = False
def run(self): while self.keep_running: data, addr = self.sock.recvfrom(2048) data = json.loads(data) if data['command'] == 'quit': self.keepalive_until = 0 continue msg = gr.message().make_from_string(str(data['command']), -2, data['data'], 0) self.output_q.insert_tail(msg) self.remote_ip = addr[0] self.remote_port = addr[1] self.keepalive_until = time.time() + KEEPALIVE_TIME
def ui_plot_update(self): if self.terminal_type is None or self.terminal_type != "http": return filenames = [] for chan in self.channels: for sink in chan.sinks: if chan.sinks[sink][0].gnuplot.filename is not None: filenames.append(chan.sinks[sink][0].gnuplot.filename) d = {'json_type': 'rx_update', 'files': filenames} msg = gr.message().make_from_string(json.dumps(d), -4, 0, 0) self.ui_in_q.insert_tail(msg)
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 send_pkt(self, payload='', eof=False): """ Send the payload. @param payload: data to sendsys.path.append('/usr/local/lib/python2.6/dist-packages/ofdmnew/') @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 = digital.ofdm_packet_utils.make_packet(payload, 1, 1, self._pad_for_usrp, whitening=True) #print "ofdm send_pkt working" #print "pkt =", string_to_hex_list(pkt) msg = gr.message_from_string(pkt) self._pkt_input.msgq().insert_tail(msg)
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)) tx_msgq.insert_tail(gr.message(1)) # send EOF tb = gr.top_block() src = blocks.message_source(gr.sizeof_char, tx_msgq, "packet_length") snk = blocks.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)
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 = ofdm_packet_utils.make_packet(payload, 1, 1, self._pad_for_usrp, whitening=False)#cyjadd original is True #print "pkt =", string_to_hex_list(pkt) msg = gr.message_from_string(pkt) self._pkt_input.msgq().insert_tail(msg)
def main(): global CentreFreq,DataRate,RepeatTime datarate = int(raw_input("Enter datarate with which we want to transmit ")) centrefreq = int(raw_input("Enter centre frequency with which we want to transmit ")) packts= int(raw_input("Enter no. of packets to transmit ")) CentreFreq=centrefreq DataRate=datarate RepeatTime=AudioRate/DataRate print RepeatTime fg = fsk_graph() fg.start() # start flow graph' try: i=0 while i<=packts: #message = raw_input("Enter a message to transmit (Ctrl-D to exit): ") message=str(i) msg64 = base64.standard_b64encode(message) print "Encoding message= %s to base64= %s" % (message,msg64) print i i=i + 1 payload = clock_sync+sync+encode_6b_8b(msg64)+stop_sync pkt = struct.pack('%iB' % (len(payload)),*payload) msg = gr.message_from_string(pkt) fg.src.msgq().insert_tail(msg) Tx_Dur=((((((len(msg64)-1.0)/4.0)*4.0)+16.0)*8.0)/DataRate) print Tx_Dur time.sleep(Tx_Dur) except EOFError: print "\nExiting." fg.src.msgq().insert_tail(gr.message(1)) fg.wait()
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 ###########"
def send_pkt(self, payload, _type=0, eof=False): """ Send the payload. @param payload: data to send @type payload: string """ print "send_pkt: type: ", _type, " eof: ", eof if eof: msg = gr.message(1) # tell self._pkt_input we're not sending any more packets elif (_type == 0): ############# print "original_payload =", string_to_hex_list(payload) #pkt = ofdm_packet_utils.make_packet(payload, 1, self._bits_per_symbol, self._fec_n, self._fec_k, self._pad_for_usrp, whitening=True) msg = gr.message_from_string(payload) if _type == 0: print "source: send_pkt" self._pkt_input.msgq().insert_tail(msg) # for source! (msg needs to be modulated in mapper) else: print "fwd: send_pkt" self._pkt_input.msgq().insert_tail(payload) # for forwarder! (payload is already modulated)
def start_call(self, group_id, chan, radio_id=None): if self._sys_id < 0: return False call_found = False new_history = list() for h in self._call_history: if time.time() < h[3] + self._TIMEOUT: new_history.append(h) if [group_id, chan, radio_id] == h[:3]: h[3] = time.time() call_found = True self._call_history = new_history if call_found: return False self._call_history.append([group_id, chan, radio_id, time.time()]) msg = message().make_from_string( "%d %d %d %d" % (self._sys_id, chan, group_id, (radio_id) if radio_id is not None else (-1)) ) msg.set_type(0) self._queue.insert_tail(msg) return True
def send_pkt(self, payload='', timetag=None, 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: # Digital Only Packet # TODO pkt = packet_utils.make_packet(payload,self._samples_per_symbol,2,self._access_code,self._pad_for_usrp) msg = gr.message_from_string(pkt) if timetag != None: timetag_int = int(math.floor(timetag)) timetag_frac = timetag - float(timetag_int) samples = len(pkt)*8*self._samples_per_symbol #print '[TransmitPath] Digital Packet Length =',len(pkt) #print '[TransmitPath] Digital Packet Sample Length=',samples #self.timetag_inserter.put_timestamp(int(timetag_int), samples) #self.delay.set_delay (timetag_frac, samples) else: samples = len(pkt)*8*self._samples_per_symbol #print '[TransmitPath] Digital Packet Length =',len(pkt) #print '[TransmitPath] Digital Packet Sample Length=',samples self._pkt_input.msgq().insert_tail( msg )
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: msg = ieee802_15_4a.make_from_string_Bb(payload, self.Nsync, self.DataRate_Kbps, self.MeanPRF_KHz, self.isRangingPacket) # insert the synch header self._synch_input.msgq().insert_tail(self.synch_msg) # insert the tail to complete the transmission sizepayload = len(msg.to_string()) * self.Nburst * self.Ncpb; t = struct.pack ('B', 0) tail = gr.message_from_string(t * sizepayload) self._synch_input.msgq().insert_tail(tail) # insert the payload 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 """ 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, coder=self.coder) # AYBABTUS: Accumulate N packets here, interleave, and post them all onto the msgq #print "pkt =", string_to_hex_list(pkt) msg = gr.message_from_string(pkt) self._pkt_input.msgq().insert_tail(msg)