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 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)
