def make_packet(payload, samples_per_symbol, bits_per_symbol,
access_code=default_access_code, pad_for_usrp=True,
whitener_offset=0, whitening=True, coder=None):
"""
Build a packet, given access code, payload, and whitener offset
@param payload: packet payload, len [0, 4096]
@param samples_per_symbol: samples per symbol (needed for padding calculation)
@type samples_per_symbol: int
@param bits_per_symbol: (needed for padding calculation)
@type bits_per_symbol: int
@param access_code: string of ascii 0's and 1's
@param whitener_offset offset into whitener string to use [0-16)
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
if not whitener_offset >=0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)
(packed_access_code, padded) = conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble, ignore) = conv_1_0_string_to_packed_binary_string(preamble)
payload_with_crc = crc.gen_and_append_crc32(payload)
if coder is not None:
payload_with_crc = encode_rs(coder, payload_with_crc)
#print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
L = len(payload_with_crc)
MAXLEN = len(random_mask_tuple)
if L > MAXLEN:
raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
if whitening:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
whiten(payload_with_crc, whitener_offset), '\x55'))
else:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
(payload_with_crc), '\x55'))
if pad_for_usrp:
pkt = pkt + (_npadding_bytes(len(pkt), int(samples_per_symbol), bits_per_symbol) * '\x55')
#print "make_packet: len(pkt) =", len(pkt)
return pkt
def make_packet(payload, samples_per_symbol, bits_per_symbol,
pad_for_usrp=True, whitener_offset=0, whitening=True, coder=None):
"""
Build a packet, given access code, payload, and whitener offset
@param payload: packet payload, len [0, 4096]
@param samples_per_symbol: samples per symbol (needed for padding calculation)
@type samples_per_symbol: int
@param bits_per_symbol: (needed for padding calculation)
@type bits_per_symbol: int
@param whitener_offset offset into whitener string to use [0-16)
@param whitening: Turn whitener on or off
@type whitening: bool
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not whitener_offset >=0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)
payload_with_crc = crc.gen_and_append_crc32(payload)
#print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
if coder is not None:
payload_with_crc = encode_rs(coder, payload_with_crc)
L = len(payload_with_crc)
MAXLEN = len(random_mask_tuple)
if L > MAXLEN:
raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
pkt_hd = make_header(L, whitener_offset)
pkt_dt = ''.join((payload_with_crc, '\x55'))
packet_length = len(pkt_hd) + len(pkt_dt)
if pad_for_usrp:
usrp_packing = _npadding_bytes(packet_length, samples_per_symbol, bits_per_symbol) * '\x55'
pkt_dt = pkt_dt + usrp_packing
if(whitening):
pkt = pkt_hd + whiten(pkt_dt, whitener_offset)
else:
pkt = pkt_hd + pkt_dt
#print "make_packet: len(pkt) =", len(pkt)
return pkt
def make_packet(payload, samples_per_symbol, bits_per_symbol,
preamble=default_preamble, access_code=default_access_code,
pad_for_usrp=True, whitener_offset=0, whitening=True,
calc_crc=True, repeat=1, interleave=None, debug=False):
"""
Build a packet, given access code, payload, and whitener offset
Args:
payload: packet payload, len [0, 4096]
samples_per_symbol: samples per symbol (needed for padding calculation) (int)
bits_per_symbol: (needed for padding calculation) (int)
preamble: string of ascii 0's and 1's
access_code: string of ascii 0's and 1's
pad_for_usrp: If true, packets are padded such that they end up a multiple of 128 samples(512 bytes)
whitener_offset: offset into whitener string to use [0-16)
whitening: Whether to turn on data whitening(scrambling) (boolean)
calc_crc: Whether to calculate CRC32 or not (boolean)
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not is_1_0_string(preamble):
raise ValueError, "preamble must be a string containing only 0's and 1's (%r)" % (preamble,)
if not is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
if not whitener_offset >=0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)
(packed_access_code, padded) = conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble, ignore) = conv_1_0_string_to_packed_binary_string(preamble)
if(calc_crc):
payload_with_crc = crc.gen_and_append_crc32(payload)
else:
payload_with_crc = payload
if repeat > 1:
payload_with_crc = fec.repeat_encode(payload_with_crc, repeat)
if interleave == 1:
payload_with_crc = fec.interleave(payload_with_crc, repeat)
elif interleave == 2:
payload_with_crc = fec.shuffle_encode(payload_with_crc)
L = len(payload_with_crc)
if debug:
print ""
print "length =", L
print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
print "payload_with_crc =", string_to_hex_list(payload_with_crc)
print ""
MAXLEN = len(random_mask_tuple)
if L > MAXLEN:
raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
if whitening:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
whiten(payload_with_crc, whitener_offset), '\x55'))
else:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
(payload_with_crc), '\x55'))
if pad_for_usrp:
pkt = pkt + (_npadding_bytes(len(pkt), int(samples_per_symbol), bits_per_symbol) * '\x55')
#print "make_packet: len(pkt) =", len(pkt)
return pkt
def make_packet(payload, samples_per_symbol, bits_per_symbol,
options, access_code=default_access_code, pad_for_usrp=True,
use_coding=False, #added on 09/20/12
logging=-1,
whitener_offset=0, whitening=True):
"""
Build a packet, given access code, payload, and whitener offset
@param payload: packet payload, len [0, 4096]
@param samples_per_symbol: samples per symbol (needed for padding calculation)
@type samples_per_symbol: int
@param bits_per_symbol: (needed for padding calculation)
@type bits_per_symbol: int
@param access_code: string of ascii 0's and 1's
@param whitener_offset offset into whitener string to use [0-16)
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
if not whitener_offset >=0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)
(packed_access_code, padded) = conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble, ignore) = conv_1_0_string_to_packed_binary_string(preamble)
#print "Length of payload is %d" % len(payload)
payload_with_crc = crc.gen_and_append_crc32(payload)
#print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
#use_coding section copied from Thomas' ofdm_packet_util.py
#added by Tri on 09/20/2012
if use_coding:
#print "use_coding is activated on tx"
#Use coding and interleaving
#Apply Reed-Solomon Code
N = 8
K = 4
rs_encoder = Codec(N,K)
payload_with_crc_and_rs = ''
for n in range(0, len(payload_with_crc), K):
payload_with_crc_and_rs = payload_with_crc_and_rs + rs_encoder.encode(payload_with_crc[n:n+K])
#Interleave the RS symbols to put distance between the symbols under the same RS code
payload_with_crc_and_rs_interleaved = ''
for n in range(0, N, 1):
payload_with_crc_and_rs_interleaved = payload_with_crc_and_rs_interleaved + payload_with_crc_and_rs[n:len(payload_with_crc_and_rs):N]
else:
# Skip coding and interleaving (although the variable name kind of indicates otherwise)
payload_with_crc_and_rs_interleaved = payload_with_crc
L = len(payload_with_crc_and_rs_interleaved)
MAXLEN = len(random_mask_tuple)
#print "coded payload length is %d" % L
#print "MAXLEN is %d" % MAXLEN
if L > MAXLEN:
raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
if whitening:
hd = make_header(L, whitener_offset)
whitened_payload, success=whiten(payload_with_crc_and_rs_interleaved, whitener_offset)
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
whitened_payload, packed_preamble))
else:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
(payload_with_crc_and_rs_interleaved), packed_preamble))
if pad_for_usrp:
# print out number of padded bytes to make sure not to waste too much padded data
#print "Preamble length is %d" % len(packed_preamble)
#print "Access code length is %d" % len(packed_access_code)
#print "Header length is %d" % len(hd)
#print "Payload with crc length is %d" % len(payload_with_crc)
#print "Payload with crc and RS length is %d" % len(payload_with_crc_and_rs_interleaved)
#print "Packet length before padding is %d" % len(pkt)
Nbytes_to_pad = _npadding_bytes(len(pkt), int(samples_per_symbol), bits_per_symbol)
#print "Number of bytes padded to each packet is %d" % Nbytes_to_pad
pkt = pkt + (Nbytes_to_pad * '\x55')
print "Number of bytes padded to packet for USRP is %d" % Nbytes_to_pad
print "Total packet length is %d bytes" % len(pkt)
#print "make_packet: len(pkt) =", len(pkt)
return pkt
def make_packet(payload, samples_per_symbol, bits_per_symbol,
access_code=default_access_code, pad_for_usrp=True,
whitener_offset=0, whitening=True):
"""
Build a packet, given access code, payload, and whitener offset
@param payload: packet payload, len [0, 4096]
@param samples_per_symbol: samples per symbol (needed for padding calculation)
@type samples_per_symbol: int
@param bits_per_symbol: (needed for padding calculation)
@type bits_per_symbol: int
@param access_code: string of ascii 0's and 1's
@param whitener_offset offset into whitener string to use [0-16)
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (access_code,)
if not whitener_offset >=0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)
(packed_access_code, padded) = conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble, ignore) = conv_1_0_string_to_packed_binary_string(preamble)
payload_with_crc = crc.gen_and_append_crc32(payload)
#print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
########################
# Error control code here
nb = len(payload_with_crc)
cl = Encoder.cat_codelength(nb)
#print nb, cl
codedpayload = payload_with_crc + payload_with_crc[0:cl-nb]
Encoder.cat_encode(codedpayload,nb)
ccnb = len(codedpayload);
#print "Input to CC Enc has length ", ccnb
cccl = ccEncoder.cc3_codelength(ccnb,RSLEN)
#cccodedpayload = codedpayload + codedpayload[0: cccl-ccnb]
cccodedpayload = codedpayload + ('x' * (cccl-ccnb))
ccEncoder.cc3_encode(cccodedpayload, ccnb, RSLEN)
######################
# uncoded
#L = len(payload_with_crc)
# Xu: When coded with RS + CC
L = len(cccodedpayload)
MAXLEN = len(random_mask_tuple)
# Commented by Xu, 2014-2-9
#if L > MAXLEN:
# raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN,)
# Xu: Never whitening
'''
if whitening:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
whiten(payload_with_crc, whitener_offset), '\x55'))
else:
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
(payload_with_crc), '\x55'))
'''
# coded
pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),
(cccodedpayload), '\x55'))
if pad_for_usrp:
pkt = pkt + (_npadding_bytes(len(pkt), int(samples_per_symbol), bits_per_symbol) * '\x55')
#print "make_packet: len(pkt) =", len(pkt)
return pkt
def run(self):
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'spectrum_watcher_thread_started\n')
min_delay = 0.001 #min delay for CSMA implementation
previous_spectrum_constraint_hz = []
print 'master spectrum watch thread started'
time.sleep(1)
while self.keep_running:
if self.state == 'ofdm': #triggers sync mode if we're in ofdm mode...
time.sleep(self.sensing_settings['period_sense']
) #start timer for sensing
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-' + 'sensing_triggered_watcher\n')
for a in range(
3
): #trigger slave to go to sync mode - this way slave mutes TX
self.ofdm_channel_available(min_delay)
if self.w_crc == 1:
frame = make_packet(
'sync mode', self.ofdm_settings['ofdm_packet_len'],
'B')
self.payload_src.send_pkt_s(frame)
else:
frame = crc.gen_and_append_crc32(
make_packet(
'sync mode',
self.ofdm_settings['ofdm_packet_len'] - 4,
'B'))
#crc32 adds 4 bytes
self.payload_src.send_pkt_s(frame)
#self.payload_src.send_pkt_s(make_packet('sync mode', self.ofdm_settings['ofdm_packet_len'], 'B'))
time.sleep(0.2)
print 'sending order to slave: switch to sync mode'
self.idle_callback(
) #switch MASTER to idle mode - we can only conduct spectrum sensing if the slave is already out of OFDM mode
if self.hardware_type == 'usrp':
spectrum_constraint_hz = spectrum_scan(
self.sensing_settings['ofdm_band_start'],
self.sensing_settings['ofdm_band_finish'],
self.sensing_settings['channel_rate'],
self.sensing_settings['srch_bw'],
self.sensing_settings['n_fft'], self.rf_source,
self.sense_rxpath, self.sensing_settings['method'],
self.sensing_settings['ed_threshold'],
self.sensing_settings['time_sense'] * 4,
False) #True - plots results
else: #test purposes w/ TCP/UDP
spectrum_constraint_hz = []
#spectrum_constraint_hz = [_rand_bad_freqs[randrange(5)]] #force some spectrum constraint...
#if there is any change in spectrum analysis:
if previous_spectrum_constraint_hz != spectrum_constraint_hz:
previous_spectrum_constraint_hz = spectrum_constraint_hz
self.generate_sync_data(
spectrum_constraint_hz
) #generate sync data based on spectrum_constraint_hz
self.log_file.write(
'Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'occupied_carriers-' +
str(len(self.sync_data['occupied_carriers'][0])))
#chage the state to post_ofdm_pre_sync and update sync data and ofdm data!
if self.update_sync_data_callback:
self.update_sync_data_callback(self.sync_data)
#if there is NO change in spectrum analysis:
else:
#chage the state to post_ofdm_pre_sync and update sync data and ofdm data!
if self.update_sync_data_callback:
self.update_sync_data_callback(self.sync_data)
#if we are not in OFDM mode, there is no need to trigger anything
else:
time.sleep(.1)
def slave_main_loop(self):
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'main_loop_started\n')
min_delay = 1e-6 # seconds
forced_delay = 1e-6
_ofdm_n_txd = 0
self.pre_sync()
#1st sync...
print 'waiting for 1st sync'
self.sync_nOK = True
while self.sync_nOK:
time.sleep(0.5)
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'1st_sync_end(ok/Nok)\n')
#rebuild sync data
temp = ''
for data in self.slave_raw_sync_data:
temp += data
slave_ack = True
try:
self.sync_data = ast.literal_eval(temp)
#make sure MASTER received ack...
except: #catch any error that might occour
slave_ack = False
print 'error while recovering sync data'
print 'going to sync again'
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'bad_1st_sync_data\n')
self.state = 'sync' #jump to post_sync_pre_ofdm and then ofdm loop
slave_ack = self.check_sync_words(
slave_ack) # check if sync words are correct
if slave_ack:
for i in range(3):
self.sync_channel_available(min_delay)
self.sync_txpath.send_pkt_s(
make_sync_packet('ACK',
self.sync_settings['sync_packet_len'],
'D', i))
time.sleep(0.2)
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-' + 'sent_ack_to_master\n')
self.update_ofdm_settings()
print 'end 1st sync, going to post_sync_pre_ofdm'
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'1st_sync_ok\n')
self.state = 'post_sync_pre_ofdm'
self.start_slave_timeout_unlock_thread()
self._slave_timeout_unlock.state = self.state
while 1: #slave loop
if self.state == 'ofdm':
payload = None
signal.signal(
signal.SIGALRM,
self.signal_handler) #initiate os.read execution monitor
signal.alarm(2) #set trigger time to 1s
try:
payload = os.read(self.tun_fd, self.data_to_load)
if not payload:
self.payload_src.send_pkt_s(eof=True)
break
except Exception:
print 'TIMEOUT'
finally:
signal.alarm(0) # disable alarm
if payload != None:
print "Tx: len(payload) = %4d" % (len(payload), )
self.ofdm_channel_available(min_delay,
forced_delay) #CSMA - back off
if self.w_crc == 1:
frame = make_packet(
payload, self.ofdm_settings['ofdm_packet_len'],
'C')
self.payload_src.send_pkt_s(frame)
else:
frame = crc.gen_and_append_crc32(
make_packet(
payload,
self.ofdm_settings['ofdm_packet_len'] - 4,
'C'))
#crc32 adds 4 bytes
self.payload_src.send_pkt_s(frame)
_ofdm_n_txd += 1
self._slave_timeout_unlock.state = self.state
else:
if self.state == 'sync':
print 'state:', self.state
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-' + 'state=sync\n')
self.sync_nOK = True
while self.sync_nOK:
time.sleep(0.5)
#rebuild sync data
temp = ''
for data in self.slave_raw_sync_data:
temp += data
slave_ack = True
try: #try to recover sync data
self.sync_data = ast.literal_eval(temp)
except: #catch any error that might occour
slave_ack = False
print 'error while recovering sync data'
print 'going to sync again'
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-' + 'bad_sync_data\n')
self.state = 'sync' #jump to post_sync_pre_ofdm and then ofdm loop
self._slave_timeout_unlock.state = self.state
slave_ack = self.check_sync_words(
slave_ack) # check if sync words are correct
if slave_ack:
#make sure MASTER received ack...
for i in range(3):
self.sync_channel_available(min_delay)
self.sync_txpath.send_pkt_s(
make_sync_packet('ACK', 512, 'D', i))
time.sleep(0.2)
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-' +
'told_master_ack(sync)\n')
self.update_ofdm_settings()
print 'going to post_sync_pre_ofdm'
self.state = 'post_sync_pre_ofdm' #jump to post_sync_pre_ofdm and then ofdm loop
if self.state == 'post_sync_pre_ofdm': #allways before ofdm
print 'state:', self.state
#sync off ofdm on
self.pre_ofdm()
print 'going to ofdm!'
self.state = 'ofdm'
self._slave_timeout_unlock.state = self.state
if self.state == 'post_ofdm_pre_sync': #only the watcher can call this one... turn off ofdm flowgraph
print 'state:', self.state
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-total_ofdm_txd_packets-' +
str(_ofdm_n_txd) + '\n')
# ofdm off sync on
self.pre_sync()
print 'going to sync...'
self.state = 'sync'
self._slave_timeout_unlock.state = self.state
if self.state == 'stop':
print 'state:', self.state
print self.sync_data
sys.exit(0)
if self.state == 'idle':
print 'state', self.state
time.sleep(.001)
'''
def master_main_loop(self):
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'main_loop_started\n')
min_delay = 1e-6 # seconds
forced_delay = 1e-6
_ofdm_n_txd = 0
#1ST Sensing
if self.hardware_type == 'usrp': #because it could be a 'net' source (tcp / udp)
self.rf_source.set_samp_rate(self.ofdm_settings['ofdm_samp_rate'])
self.rf_source.set_center_freq(
uhd.tune_request(self.ofdm_settings['ofdm_fc'],
self.ofdm_settings['ofdm_dc_offset']))
self.rf_source.set_antenna(_sense_rx_ant, 0)
#noise estimate
offset = 0
noise_band = 20000
n_time = 1
self.estimate_noise_level(
noise_band, n_time,
offset) #----> receice FG must be / will be stopped!!!
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'noise_estimate:' +
str(self.sensing_settings['ed_threshold']) +
'\n')
print self.sensing_settings['ed_threshold']
self.sense_rxpath = spectrum_probe(
self.sensing_settings['time_sense'],
self.ofdm_settings['ofdm_samp_rate'])
self.tb.connect(self.rf_source, self.sense_rxpath)
self.tb.start() #start
time.sleep(0.5)
else:
self.sense_rxpath = blocks.null_sink(gr.sizeof_gr_complex * 1)
if self.hardware_type == 'usrp':
#Compute the spectrum constraint based on the spectrum
spectrum_constraint_hz = spectrum_scan(
self.sensing_settings['ofdm_band_start'],
self.sensing_settings['ofdm_band_finish'],
self.sensing_settings['channel_rate'],
self.sensing_settings['srch_bw'],
self.sensing_settings['n_fft'], self.rf_source,
self.sense_rxpath, self.sensing_settings['method'],
self.sensing_settings['ed_threshold'],
self.sensing_settings['time_sense'] * 4,
True) # 0.1 -> wait time before get samples, True = show plot
else:
spectrum_constraint_hz = []
#self.safe_quit()
#plots.show()
#sys.exit(0)
#spectrum_constraint_hz = [_rand_bad_freqs[randrange(5)]] #force some spectrum constraint...
#spectrum_constraint_hz = []
self.generate_sync_data(
spectrum_constraint_hz
) #generate sync data based on spectrum_constraint_hz
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'occupied_carriers-' +
str(len(self.sync_data['occupied_carriers'][0])) +
'\n')
#end initial sense -> set tb flowgraph for sync
self.pre_sync()
#sync data --> occupied_carriers pilot_carriers pilot_symbols sync_word1 sync_word2 ofdm_fc ofdm_samp_rate ofdm_packet_len payload_mod
#slice sync data in sync data packets
temp = chunks_of_word(str(self.sync_data),
self.sync_settings['sync_packet_len'] - 10)
sync_data_s = [''] * self.sink_len
#fill sync packets w/ sync data --> the number of packets must be larger than the number of sync data slices...
sync_data_s[:len(temp)] = temp
print 'sd', len(str(self.sync_data))
print 'sync data avail', self.sync_settings[
'sync_packet_len'] * self.sink_len
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'sync_data_len-' + str(len(str(self.sync_data))) +
'-sync_data_space_available-' +
str(self.sync_settings['sync_packet_len'] *
self.sink_len) + '\n')
self.sync_nOK = True #self.sync_nOK = False
self.sync_slave(sync_data_s, min_delay)
print 'going to post_sync_pre_ofdm'
self.log_file.write('Time-' + time.strftime("%H%M%S") + '-Evnt-' +
'1st_sync_ok\n')
self.state = 'post_sync_pre_ofdm' #jump to post_sync_pre_ofdm and then ofdm loop
#Start spectrum watch thread
self.start_master_watch_thread(
) #update thread value: self._spectrum_watcher.value = new_value
self._master_spectrum_watcher.state = self.state
while 1: # master loop
if self.state == 'ofdm':
payload = None
signal.signal(
signal.SIGALRM,
self.signal_handler) #initiate os.read execution monitor
signal.alarm(2) #set trigger time to 1s
try:
payload = os.read(self.tun_fd, self.data_to_load)
if not payload:
self.payload_src.send_pkt_s(eof=True)
break
except Exception:
print 'TIMEOUT'
finally:
signal.alarm(0) # disable alarm
if payload != None:
print "Tx: len(payload) = %4d" % (len(payload), )
self.ofdm_channel_available(min_delay,
forced_delay) #CSMA - back off
if self.w_crc == 1:
frame = make_packet(
payload, self.ofdm_settings['ofdm_packet_len'],
'A')
self.payload_src.send_pkt_s(frame)
else:
frame = crc.gen_and_append_crc32(
make_packet(
payload,
self.ofdm_settings['ofdm_packet_len'] - 4,
'A'))
#crc32 adds 4 bytes
self.payload_src.send_pkt_s(frame)
_ofdm_n_txd += 1
self._master_spectrum_watcher.state = self.state
else:
if self.state == 'sync':
print 'state:', self.state
temp = chunks_of_word(
str(self.sync_data),
self.sync_settings['sync_packet_len'] -
10) #header adds 10 bytes
sync_data_s = [''] * self.sink_len
sync_data_s[:len(temp)] = temp
self.sync_slave(sync_data_s, min_delay)
print 'sync done'
print 'going to post_sync_pre_ofdm'
self.state = 'post_sync_pre_ofdm'
self._master_spectrum_watcher.state = self.state
if self.state == 'post_sync_pre_ofdm': #allways before ofdm
print 'state:', self.state
#sync off ofdm on
self.pre_ofdm()
#update master_watch_thread
self.update_master_spectrum_watcher()
print 'going to ofdm!'
self.state = 'ofdm'
self._master_spectrum_watcher.state = self.state
if self.state == 'post_ofdm_pre_sync': #only the watcher can call this one... turn off ofdm flowgraph
print 'state:', self.state
self.log_file.write('Time-' + time.strftime("%H%M%S") +
'-Evnt-total_ofdm_txd_packets-' +
str(_ofdm_n_txd) + '\n')
# ofdm off sync on
self.pre_sync()
print 'going to sync...'
self.state = 'sync'
self._master_spectrum_watcher.state = self.state
if self.state == 'stop':
print 'state:', self.state
print 'exiting...'
sys.exit(0)
if self.state == 'idle':
print 'state', self.state
time.sleep(.001)
'''
def make_packet(
payload,
samples_per_symbol,
bits_per_symbol,
options,
access_code=default_access_code,
pad_for_usrp=True,
use_coding=False, #added on 09/20/12
logging=-1,
whitener_offset=0,
whitening=True):
"""
Build a packet, given access code, payload, and whitener offset
@param payload: packet payload, len [0, 4096]
@param samples_per_symbol: samples per symbol (needed for padding calculation)
@type samples_per_symbol: int
@param bits_per_symbol: (needed for padding calculation)
@type bits_per_symbol: int
@param access_code: string of ascii 0's and 1's
@param whitener_offset offset into whitener string to use [0-16)
Packet will have access code at the beginning, followed by length, payload
and finally CRC-32.
"""
if not is_1_0_string(access_code):
raise ValueError, "access_code must be a string containing only 0's and 1's (%r)" % (
access_code, )
if not whitener_offset >= 0 and whitener_offset < 16:
raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (
whitener_offset, )
(packed_access_code,
padded) = conv_1_0_string_to_packed_binary_string(access_code)
(packed_preamble,
ignore) = conv_1_0_string_to_packed_binary_string(preamble)
#print "Length of payload is %d" % len(payload)
payload_with_crc = crc.gen_and_append_crc32(payload)
#print "outbound crc =", string_to_hex_list(payload_with_crc[-4:])
#use_coding section copied from Thomas' ofdm_packet_util.py
#added by Tri on 09/20/2012
if use_coding:
#print "use_coding is activated on tx"
#Use coding and interleaving
#Apply Reed-Solomon Code
N = 8
K = 4
rs_encoder = Codec(N, K)
payload_with_crc_and_rs = ''
for n in range(0, len(payload_with_crc), K):
payload_with_crc_and_rs = payload_with_crc_and_rs + rs_encoder.encode(
payload_with_crc[n:n + K])
#Interleave the RS symbols to put distance between the symbols under the same RS code
payload_with_crc_and_rs_interleaved = ''
for n in range(0, N, 1):
payload_with_crc_and_rs_interleaved = payload_with_crc_and_rs_interleaved + payload_with_crc_and_rs[
n:len(payload_with_crc_and_rs):N]
else:
# Skip coding and interleaving (although the variable name kind of indicates otherwise)
payload_with_crc_and_rs_interleaved = payload_with_crc
L = len(payload_with_crc_and_rs_interleaved)
MAXLEN = len(random_mask_tuple)
#print "coded payload length is %d" % L
#print "MAXLEN is %d" % MAXLEN
if L > MAXLEN:
raise ValueError, "len(payload) must be in [0, %d]" % (MAXLEN, )
if whitening:
hd = make_header(L, whitener_offset)
whitened_payload, success = whiten(payload_with_crc_and_rs_interleaved,
whitener_offset)
pkt = ''.join(
(packed_preamble, packed_access_code,
make_header(L,
whitener_offset), whitened_payload, packed_preamble))
else:
pkt = ''.join((packed_preamble, packed_access_code,
make_header(L, whitener_offset),
(payload_with_crc_and_rs_interleaved), packed_preamble))
if pad_for_usrp:
# print out number of padded bytes to make sure not to waste too much padded data
#print "Preamble length is %d" % len(packed_preamble)
#print "Access code length is %d" % len(packed_access_code)
#print "Header length is %d" % len(hd)
#print "Payload with crc length is %d" % len(payload_with_crc)
#print "Payload with crc and RS length is %d" % len(payload_with_crc_and_rs_interleaved)
#print "Packet length before padding is %d" % len(pkt)
Nbytes_to_pad = _npadding_bytes(len(pkt), int(samples_per_symbol),
bits_per_symbol)
#print "Number of bytes padded to each packet is %d" % Nbytes_to_pad
pkt = pkt + (Nbytes_to_pad * '\x55')
print "Number of bytes padded to packet for USRP is %d" % Nbytes_to_pad
print "Total packet length is %d bytes" % len(pkt)
#print "make_packet: len(pkt) =", len(pkt)
return pkt
