def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing": "narrowband"}
logger.info(dict_to_xml(params, section_indent))
# narrowband section start
logger.info("%s<narrowband>", section_indent * '\t')
section_indent += 1
# narrowband section param values
params = {
"tx_amplitude": self._tx_amplitude,
"modulation": self._modulation,
"bitrate": self._bitrate,
"samples_per_symbol": self.samples_per_symbol(),
"differential": self.differential(),
"access_code": self._access_code,
"coding": self._use_coding,
"constellation_points": self._constellation_points,
"excess_bw": self._excess_bw
}
# add optional params if they exist
# check for mod code (currently in psk and qam only)
if "_mod_code" in vars(self.modulator):
params["mod_code"] = self.modulator._mod_code
# check for bt (currently in gmsk and cpm only)
if "_bt" in vars(self.modulator):
params["bt"] = self.modulator._bt
logger.info(dict_to_xml(params, section_indent))
if self._use_coding == True:
# Forward error correction section start
logger.info("%s<forward_error_correction>", section_indent * '\t')
section_indent += 1
# TODO: change the way coding is implemented so a coding module can be
# checked for this information, instead of hard coding it
# Forward error correction section param values
params = {"scheme": "reed_solomon", "code_rate": (4.0 / 8.0)}
logger.info(dict_to_xml(params, section_indent))
# Forward error correction section end
section_indent -= 1
logger.info("%s</forward_error_correction>", section_indent * '\t')
# narrowband section end
section_indent -= 1
logger.info("%s</narrowband>", section_indent * '\t')
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing":"narrowband"}
logger.info(dict_to_xml(params, section_indent))
# narrowband section start
logger.info("%s<narrowband>", section_indent*'\t')
section_indent += 1
# narrowband section param values
params = {"tx_amplitude":self._tx_amplitude,
"modulation":self._modulation,
"bitrate":self._bitrate,
"samples_per_symbol":self.samples_per_symbol(),
"differential":self.differential(),
"access_code":self._access_code,
"coding":self._use_coding,
"constellation_points":self._constellation_points,
"excess_bw":self._excess_bw}
# add optional params if they exist
# check for mod code (currently in psk and qam only)
if "_mod_code" in vars(self.modulator):
params["mod_code"] = self.modulator._mod_code
# check for bt (currently in gmsk and cpm only)
if "_bt" in vars(self.modulator):
params["bt"] = self.modulator._bt
logger.info(dict_to_xml(params, section_indent))
if self._use_coding == True:
# Forward error correction section start
logger.info("%s<forward_error_correction>", section_indent*'\t')
section_indent += 1
# TODO: change the way coding is implemented so a coding module can be
# checked for this information, instead of hard coding it
# Forward error correction section param values
params = {"scheme":"reed_solomon",
"code_rate":(4.0/8.0)}
logger.info(dict_to_xml(params, section_indent))
# Forward error correction section end
section_indent -= 1
logger.info("%s</forward_error_correction>", section_indent*'\t')
# narrowband section end
section_indent -= 1
logger.info("%s</narrowband>", section_indent*'\t')
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# rx front end section start
logger.info("%s<rx_frontend>", section_indent * '\t')
section_indent += 1
# rx front end section param values
params = {
"args": self._args,
"rf_frequency": self._freq,
"rx_gain": self._gain,
"sample_rate": self._rate,
"antenna": self._ant,
"spec": self._spec
}
logger.info(dict_to_xml(params, section_indent))
# rx front end section end
section_indent -= 1
logger.info("%s</rx_frontend>", section_indent * '\t')
def frame_config_to_xml(frame_config_in, indent_level):
fc = deepcopy(frame_config_in)
fc["t0"] = str(fc["t0"])
for k, slot in enumerate(fc["slots"]):
fc["slots"][k] = tuple(slot)
return dict_to_xml(fc, indent_level)
def frame_config_to_xml(frame_config_in, indent_level):
fc = deepcopy(frame_config_in)
fc["t0"] = str(fc["t0"])
for k, slot in enumerate(fc["slots"]):
fc["slots"][k] = tuple(slot)
return dict_to_xml(fc, indent_level)
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level tdma controller params
params = {
"app_in_q_size":self.max_app_in_q_size,
"incoming_q_size":self.max_incoming_q_size,
"mux_name":self.mux_name,
"rx_channelizer_name":self.rx_channelizer_name,
"first_frame_time":self.start_time,
"frame_file":self.frame_file,
}
#logger.info(dict_to_xml(params, section_indent))
logger.info(dict_to_xml(params, section_indent))
# tdma state machine section start
#logger.info("%s<tdma_mac>", section_indent*'\t')
logger.info("%s<tdma_controller>", (section_indent*'\t'))
section_indent += 1
# mac section param values
params = {
"node_source_address":self.mac_config["my_id"],
"base_id":self.mac_config["base_id"],
"node_sink_address_list":self.mac_config["peer_ids"],
"fs":self.mac_config["fs"],
"lead_limit":self.mac_config["lead_limit"],
"pre_guard":self.mac_config["pre_guard"],
"fhss_flag":self.mac_config["fhss_flag"],
}
#logger.info(dict_to_xml(params, section_indent))
logger.info(dict_to_xml(params, section_indent))
self.manage_slots.log_my_settings(section_indent,logger)
# csma section end
section_indent -= 1
#logger.info("%s</tdma_mac>", section_indent*'\t')
logger.info("%s</tdma_controller>", (section_indent*'\t'))
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing":"ofdm"}
logger.info(dict_to_xml(params, section_indent))
# ofdm section start
logger.info("%s<ofdm>", section_indent*'\t')
section_indent += 1
# ofdm section param values
params = {"tx_amplitude":self._tx_amplitude,
"modulation":self.packet_tx._modulation,
"coding":self.packet_tx._use_coding,
"number_of_subcarriers":self.packet_tx._fft_length,
"number_of_active_subcarriers":self.packet_tx._occupied_tones,
"cp_length":self.packet_tx._cp_length}
logger.info(dict_to_xml(params, section_indent))
if self.packet_tx._use_coding == True:
# Forward error correction section start
logger.info("%s<forward_error_correction>", section_indent*'\t')
section_indent += 1
# TODO: change the way coding is implemented so a coding module can be
# checked for this information, instead of hard coding it
# Forward error correction section param values
params = {"scheme":"reed_solomon",
"code_rate":(4.0/8.0)}
logger.info(dict_to_xml(params, section_indent))
# Forward error correction section end
section_indent -= 1
logger.info("%s</forward_error_correction>", section_indent*'\t')
# ofdm section end
section_indent -= 1
logger.info("%s</ofdm>", section_indent*'\t')
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing": "ofdm"}
logger.info(dict_to_xml(params, section_indent))
# ofdm section start
logger.info("%s<ofdm>", section_indent * '\t')
section_indent += 1
# ofdm section param values
params = {
"tx_amplitude": self._tx_amplitude,
"modulation": self.packet_tx._modulation,
"coding": self.packet_tx._use_coding,
"number_of_subcarriers": self.packet_tx._fft_length,
"number_of_active_subcarriers": self.packet_tx._occupied_tones,
"cp_length": self.packet_tx._cp_length
}
logger.info(dict_to_xml(params, section_indent))
if self.packet_tx._use_coding == True:
# Forward error correction section start
logger.info("%s<forward_error_correction>", section_indent * '\t')
section_indent += 1
# TODO: change the way coding is implemented so a coding module can be
# checked for this information, instead of hard coding it
# Forward error correction section param values
params = {"scheme": "reed_solomon", "code_rate": (4.0 / 8.0)}
logger.info(dict_to_xml(params, section_indent))
# Forward error correction section end
section_indent -= 1
logger.info("%s</forward_error_correction>", section_indent * '\t')
# ofdm section end
section_indent -= 1
logger.info("%s</ofdm>", section_indent * '\t')
def log_results(self, indent_level, logger):
section_indent = (indent_level)
logger.info('%s<tx_channelizer>', section_indent*'\t')
params = { "number_digital_channels":self.num_chan,
"channelizer_transition_bandwidth":self.trans_bw,
"channelizer_attenuation_dB":self.att_dB,
"digital_channel_number":self.current_chan }
logger.info(dict_to_xml(params, section_indent+1))
logger.info('%s</tx_channelizer>', section_indent*'\t')
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level mac section param values
params = {"beacon_timeout":self._beacon_timeout,
"min_beacons": self._min_beacons,
"max_beacons": self._max_beacons,
"base_id":self._base_id,
"beacon_error_thresh":self._beacon_error_thresh,
}
logger.info(dict_to_xml(params, section_indent))
def log_tune_command(self, cmd_time, freq, dropped):
params = {
"timestamp":str(cmd_time),
"freq":freq,
"dropped":dropped
}
param_xml = dict_to_xml(params, 1)
tune_log_xml = ("<rf_tune>\n" +
"%s\n" +
"</rf_tune>") % param_xml
self.statelog.info(tune_log_xml)
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level mac section param values
params = {
"beacon_timeout": self._beacon_timeout,
"min_beacons": self._min_beacons,
"max_beacons": self._max_beacons,
"base_id": self._base_id,
"beacon_error_thresh": self._beacon_error_thresh,
}
logger.info(dict_to_xml(params, section_indent))
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# infinite backlog section start
logger.info("%s<infinite>", section_indent*'\t')
section_indent += 1
# infinite backlog section param values
params = {
"node_sink_address_list":self.destination_id_list,
"max_queue_size":self.max_queue_size,
"fill_threshold":self.fill_thresh,
"payload_size":self.payload_size
}
logger.info(dict_to_xml(params, section_indent))
# infinite backlog section end
section_indent -= 1
logger.info("%s</infinite>", section_indent*'\t')
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# infinite backlog section start
logger.info("%s<tunnel>", section_indent*'\t')
section_indent += 1
# tunnel section param values
params = {"tun_device_filename":self.tun_device_filename,
"tun_ifname":self.tun_ifname}
# TODO: Am I missing any interesting parameters?
logger.info(dict_to_xml(params, section_indent))
# infinite backlog section end
section_indent -= 1
logger.info("%s</tunnel>", section_indent*'\t')
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# infinite backlog section start
logger.info("%s<infinite>", section_indent * '\t')
section_indent += 1
# infinite backlog section param values
params = {
"node_sink_address_list": self.destination_id_list,
"max_queue_size": self.max_queue_size,
"fill_threshold": self.fill_thresh,
"payload_size": self.payload_size
}
logger.info(dict_to_xml(params, section_indent))
# infinite backlog section end
section_indent -= 1
logger.info("%s</infinite>", section_indent * '\t')
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# rx front end section start
logger.info("%s<rx_frontend>", section_indent*'\t')
section_indent += 1
# rx front end section param values
params = {"args":self._args,
"rf_frequency":self._freq,
"rx_gain":self._gain,
"sample_rate":self._rate,
"antenna":self._ant,
"spec":self._spec}
logger.info(dict_to_xml(params, section_indent))
# rx front end section end
section_indent -= 1
logger.info("%s</rx_frontend>", section_indent*'\t')
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# infinite backlog section start
logger.info("%s<tunnel>", section_indent * '\t')
section_indent += 1
# tunnel section param values
params = {
"tun_device_filename": self.tun_device_filename,
"tun_ifname": self.tun_ifname
}
# TODO: Am I missing any interesting parameters?
logger.info(dict_to_xml(params, section_indent))
# infinite backlog section end
section_indent -= 1
logger.info("%s</tunnel>", section_indent * '\t')
def log_my_settings( options, tb, logger ):
print 'logging'
# get current timestamp
epoch_time = time.time()
indent_level = 0
section_indent = (indent_level)
# node state section start
logger.info("%s<node_state>", section_indent*'\t')
section_indent += 1
# get current repo branch and version
#(status, branch) = commands.getstatusoutput("git rev-parse --symbolic-full-name --abbrev-ref HEAD")
#(status, commit) = commands.getstatusoutput("git describe --always --dirty")
branch = commands.getstatusoutput("git rev-parse --symbolic-full-name --abbrev-ref HEAD")[1]
commit = commands.getstatusoutput("git describe --always --dirty")[1]
node_version = branch + '-' + commit
# get machine name
#(status, hostname) = commands.getstatusoutput("uname -n")
hostname = commands.getstatusoutput("uname -n")[1]
# node state section param values
params = {"timestamp":epoch_time,
"traffic_generation_type":options.traffic_generation,
"node_version":node_version,
"mac_ll_version":mac_ll.__version__,
"digital_ll_version":digital_ll.__version__,
"hostname":hostname,
"pckt_log":options.pcktlog,
"statelog":options.statelog,
"node_config":options.config_file,
"frame_file":options.frame_file,
"mac_type":options.node_role,
"calibration_time":tb.cal_time,
}
logger.info(dict_to_xml(params, section_indent))
if tb.traffic is not None:
# traffic_generatione section start
logger.info("%s<traffic_generation>", section_indent*'\t')
section_indent += 1
tb.traffic.log_my_settings(section_indent, logger)
# traffic_generation section end
section_indent -= 1
logger.info("%s</traffic_generation>", section_indent*'\t')
# radio section start
logger.info("%s<radio>", section_indent*'\t')
section_indent += 1
params = {"usrp_serial":tb.usrp_serial,
"usrp_ip":tb.usrp_ip}
logger.info(dict_to_xml(params, section_indent))
# call transmitter's logger
tb.sink.log_my_settings(section_indent,logger)
# call receiver's logger
tb.source.log_my_settings(section_indent,logger)
# radio section end
section_indent -= 1
logger.info("%s</radio>", section_indent*'\t')
# phy section start
logger.info("%s<phy>", section_indent*'\t')
section_indent += 1
# receive section start
logger.info("%s<receive>", section_indent*'\t')
section_indent += 1
# call receive path's logger
tb.rx_path.log_my_settings(section_indent,logger)
# receive section end
section_indent -= 1
logger.info("%s</receive>", section_indent*'\t')
# digital hopper section start
logger.info("%s<digital_hopper>", section_indent*'\t')
section_indent += 1
tb.rx_channelizer.log_results(section_indent,logger)
tb.tx_channelizer.log_results(section_indent,logger)
# digital hopper section section end
section_indent -= 1
logger.info("%s</digital_hopper>", section_indent*'\t')
# phy section end
section_indent -= 1
logger.info("%s</phy>", section_indent*'\t')
# mac section start
logger.info("%s<mac>", section_indent*'\t')
section_indent += 1
tb.tdma_controller.log_my_settings(section_indent, logger)
# mac section end
section_indent -= 1
logger.info("%s</mac>", section_indent*'\t')
# node state section end
section_indent -= 1
logger.info("%s</node_state>", section_indent*'\t')
# catchall for options
ops = vars(options)
logger.info('%s<options>',section_indent*'\t')
section_indent += 1
logger.info(dict_to_xml( ops, section_indent ))
section_indent -= 1
logger.info('%s</options>',section_indent*'\t')
def log_results(self, indent_level, logger):
section_indent = (indent_level)
logger.info("%s<channel_sounding>", section_indent * "\t")
# Log the test parameters
logger.info("%s<sounding_parameters>", (section_indent + 1) * "\t")
test_params = {
"id": self.id,
"tx_papr": self.papr,
"tx_maximum_sample": self.maxv,
"center_frequency_Hz": self.cf,
"bandwidth_Hz": self.samp_rate,
"tx_gain_dB": self.tx_gain,
"rx_gain_dB": self.rx_gain,
"digital_scaling": self.digital_scale,
"K_bins_occupied": self.K,
"nfft_bins": self.nfft,
"number_fft_avg": self.n_avg,
"wait_noise": self.wait_noise,
"wait_tx": self.wait_tx,
"wait_sig": self.wait_sig,
"wait_quit": self.wait_quit
}
logger.info(dict_to_xml(test_params, section_indent + 2))
logger.info("%s</sounding_parameters>", (section_indent + 1) * "\t")
# Wait until we are done observing the channel
done = False
while not done:
time.sleep(0.01)
done = self.post_fft_analysis.SNR_calculation_ready()
# Get the various measurements and write to file
tx_dpwr = (self.digital_scale**2) * self.avgpwr
tx_pwr_eq, rx_pwr_eq = get_pwr_equations(
self.cf, self.tx_gain, self.rx_gain) # returned in dB
snr = [
0,
] * self.nfft
sinr = [
0,
] * self.nfft
pwr = [
0,
] * self.nfft
Np = [
0,
] * self.nfft
Ip = [
0,
] * self.nfft
for n in range(1, self.Lt + 1):
# Get the results
snr[n] = self.post_fft_analysis.return_SNR_2step(n)
pwr[n] = self.post_fft_analysis.return_sig_power(n)
Np[n] = self.post_fft_analysis.return_noise_power(n)
Ip[n] = self.post_fft_analysis.return_odd_bin_power(n)
sinr[n] = self.post_fft_analysis.return_SNR(n)
logger.info("%s<results>", (section_indent + 1) * "\t")
test_params = {
"other_node_id":
n,
"tx_discrete_sig_pwr_dB": (10 * log10(tx_dpwr)),
"rx_discrete_sig_pwr_dB": (10 * log10(pwr[n])),
"rx_discrete_noise_pwr_dB": (10 * log10(Np[n])),
"rx_discrete_txfloor_pwr_dB": (10 * log10(Ip[n])),
"tx_analog_sig_pwr_dB": (tx_pwr_eq + 10 * log10(tx_dpwr)),
"rx_analog_sig_pwr_dB": (rx_pwr_eq + 10 * log10(pwr[n])),
"rx_analog_noise_pwr_dB": (rx_pwr_eq + 10 * log10(Np[n])),
"rx_analog_txfloor_pwr_dB": (rx_pwr_eq + 10 * log10(Ip[n])),
"pathloss_dB": (tx_pwr_eq + 10 * log10(tx_dpwr) -
(rx_pwr_eq + 10 * log10(pwr[n]))),
"snr_dB": (10 * log10(snr[n])),
"signal_to_txfloor_pwr_dB": (10 * log10(sinr[n]))
}
logger.info(dict_to_xml(test_params, section_indent + 2))
logger.info("%s</results>", (section_indent + 1) * "\t")
logger.info("%s</channel_sounding>", section_indent * "\t")
def log_results(self, indent_level, logger):
section_indent = (indent_level)
logger.info("%s<channel_sounding>", section_indent*"\t")
# Log the test parameters
logger.info("%s<sounding_parameters>", (section_indent+1)*"\t")
test_params = { "id":self.id,
"tx_papr":self.papr,
"tx_maximum_sample":self.maxv,
"center_frequency_Hz":self.cf,
"bandwidth_Hz":self.samp_rate,
"tx_gain_dB":self.tx_gain,
"rx_gain_dB":self.rx_gain,
"digital_scaling":self.digital_scale,
"K_bins_occupied":self.K,
"nfft_bins":self.nfft,
"number_fft_avg":self.n_avg,
"wait_noise":self.wait_noise,
"wait_tx":self.wait_tx,
"wait_sig":self.wait_sig,
"wait_quit":self.wait_quit }
logger.info(dict_to_xml(test_params, section_indent+2))
logger.info("%s</sounding_parameters>", (section_indent+1)*"\t")
# Wait until we are done observing the channel
done = False
while not done:
time.sleep(0.01)
done = self.post_fft_analysis.SNR_calculation_ready()
# Get the various measurements and write to file
tx_dpwr = (self.digital_scale**2)*self.avgpwr
tx_pwr_eq, rx_pwr_eq = get_pwr_equations( self.cf, self.tx_gain, self.rx_gain ) # returned in dB
snr = [0,]*self.nfft
sinr= [0,]*self.nfft
pwr = [0,]*self.nfft
Np = [0,]*self.nfft
Ip = [0,]*self.nfft
for n in range(1, self.Lt+1):
# Get the results
snr[n] = self.post_fft_analysis.return_SNR_2step(n)
pwr[n] = self.post_fft_analysis.return_sig_power(n)
Np[n] = self.post_fft_analysis.return_noise_power(n)
Ip[n] = self.post_fft_analysis.return_odd_bin_power(n)
sinr[n]= self.post_fft_analysis.return_SNR(n)
logger.info("%s<results>", (section_indent+1)*"\t")
test_params = { "other_node_id":n,
"tx_discrete_sig_pwr_dB":(10*log10(tx_dpwr)),
"rx_discrete_sig_pwr_dB":(10*log10(pwr[n])),
"rx_discrete_noise_pwr_dB":(10*log10(Np[n])),
"rx_discrete_txfloor_pwr_dB":(10*log10(Ip[n])),
"tx_analog_sig_pwr_dB":(tx_pwr_eq + 10*log10(tx_dpwr)),
"rx_analog_sig_pwr_dB":(rx_pwr_eq + 10*log10(pwr[n])),
"rx_analog_noise_pwr_dB":(rx_pwr_eq + 10*log10(Np[n])),
"rx_analog_txfloor_pwr_dB":(rx_pwr_eq + 10*log10(Ip[n])),
"pathloss_dB":(tx_pwr_eq + 10*log10(tx_dpwr) - (rx_pwr_eq + 10*log10(pwr[n]))),
"snr_dB":(10*log10(snr[n])),
"signal_to_txfloor_pwr_dB":(10*log10(sinr[n])) }
logger.info(dict_to_xml(test_params, section_indent+2))
logger.info("%s</results>", (section_indent+1)*"\t")
logger.info("%s</channel_sounding>", section_indent*"\t")
def log_my_settings(self, indent_level,logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing":"narrowband"}
logger.info(dict_to_xml(params, section_indent))
# narrowband section start
logger.info("%s<narrowband>", section_indent*'\t')
section_indent += 1
# narrowband section param values
params = {"modulation":self._modulation,
"bitrate":self._bitrate,
"samples_per_symbol":self.samples_per_symbol(),
"differential":self.differential(),
"access_code":self._access_code,
"coding":self._use_coding,
"constellation_points":self._constellation_points,
"excess_bw":self._excess_bw,
"chbw_factor":self._chbw_factor,
"freq_bw":self._freq_bw,
"phase_bw":self._phase_bw,
"timing_bw":self._timing_bw,
"channel_access":self._accesstype}
# add optional params if they exist
# check for mod code (currently in psk and qam only)
if "_mod_code" in vars(self.demodulator):
params["mod_code"] = self.demodulator._mod_code
# check for gain_mu (currently in gmsk only)
if "_gain_mu" in vars(self.demodulator):
params["gain_mu"] = self.demodulator._gain_mu
# check for mu (currently in gmsk only)
if "_mu" in vars(self.demodulator):
params["mu"] = self.demodulator._mu
# check for omega_relative_limit (currently in gmsk only)
if "_omega_relative_limit" in vars(self.demodulator):
params["omega_relative_limit"] = self.demodulator._omega_relative_limit
# check for freq_error (currently in gmsk only)
if "_freq_error" in vars(self.demodulator):
params["freq_error"] = self.demodulator._freq_error
logger.info(dict_to_xml(params, section_indent))
# channel_sensor section start
logger.info("%s<channel_sensor>", section_indent*'\t')
section_indent += 1
# vcs section start
logger.info("%s<vcs>", section_indent*'\t')
section_indent += 1
# vcs section param values
params = {"threshold_bits":self.packet_receiver._threshold,
"backoff_bits":self.packet_receiver._backoff,
"expected_pkt_size":self.packet_receiver._expected_pkt_size}
logger.info(dict_to_xml(params, section_indent))
# vcs section end
section_indent -= 1
logger.info("%s</vcs>", section_indent*'\t')
# pcs section start
logger.info("%s<pcs>", section_indent*'\t')
section_indent += 1
# pcs section param values
params = {"pcsthresh":self._pcsthresh,
"pcsalpha":self._pcsalpha,
"pcstrain_niter":self._n_iter,
"pcstrain_iterlen":self._iter_len,
"pcstrain_flag":self._pcstrain_flag,
"learned_pcs_threshold":self.probe.get_threshold(),}
logger.info(dict_to_xml(params, section_indent))
# pcs section end
section_indent -= 1
logger.info("%s</pcs>", section_indent*'\t')
# channel_sensor section end
section_indent -= 1
logger.info("%s</channel_sensor>", section_indent*'\t')
if self._use_coding == True:
# Forward error correction section start
logger.info("%s<forward_error_correction>", section_indent*'\t')
section_indent += 1
# TODO: change the way coding is implemented so a coding module can be
# checked for this information, instead of hard coding it
# Forward error correction section param values
params = {"scheme":"reed_solomon",
"code_rate":(4.0/8.0)}
logger.info(dict_to_xml(params, section_indent))
# Forward error correction section end
section_indent -= 1
logger.info("%s</forward_error_correction>", section_indent*'\t')
# narrowband section end
section_indent -= 1
logger.info("%s</narrowband>", section_indent*'\t')
def log_my_settings(self, indent_level, logger):
'''
Write out all initial parameter values to XML formatted file
'''
section_indent = indent_level
# top level transmit section param values
params = {"multiplexing": "narrowband"}
logger.info(dict_to_xml(params, section_indent))
# ofdm section start
logger.info("%s<ofdm>", section_indent * '\t')
section_indent += 1
# narrowband section param values
params = {
"modulation": self.ofdm_rx._modulation,
"coding": self.ofdm_rx._use_coding,
"number_of_subcarriers": self.ofdm_rx._fft_length,
"number_of_active_subcarriers": self.ofdm_rx._occupied_tones,
"cp_length": self.ofdm_rx._cp_length,
"channel_access": self._accesstype
}
logger.info(dict_to_xml(params, section_indent))
# channel_sensor section start
logger.info("%s<channel_sensor>", section_indent * '\t')
section_indent += 1
# vcs section start
logger.info("%s<vcs>", section_indent * '\t')
section_indent += 1
# vcs section param values
params = {
"threshold_norm": self.ofdm_rx._vcsthresh,
"backoff_samples": self.ofdm_rx._vcsbackoff,
"expected_pkt_size": self.ofdm_rx._expected_pkt_size
}
logger.info(dict_to_xml(params, section_indent))
# vcs section end
section_indent -= 1
logger.info("%s</vcs>", section_indent * '\t')
# pcs section start
logger.info("%s<pcs>", section_indent * '\t')
section_indent += 1
# pcs section param values
params = {
"pcsthresh": self._pcsthresh,
"pcsalpha": self._pcsalpha,
"pcstrain_niter": self._n_iter,
"pcstrain_iterlen": self._iter_len,
"pcstrain_flag": self._pcstrain_flag,
"learned_pcs_threshold": self.probe.get_threshold(),
}
logger.info(dict_to_xml(params, section_indent))
# pcs section end
section_indent -= 1
logger.info("%s</pcs>", section_indent * '\t')
# channel_sensor section end
section_indent -= 1
logger.info("%s</channel_sensor>", section_indent * '\t')
# ofdm section end
section_indent -= 1
logger.info("%s</ofdm>", section_indent * '\t')