all param lists to dicts like in doa sw

This commit is contained in:
Carl Laufer 2022-04-10 11:20:05 +01:00
parent 42a76962d0
commit 0ce484bb0b
3 changed files with 279 additions and 454 deletions

View File

@ -25,24 +25,14 @@ import sys
import queue
import time
import subprocess
import orjson
import json
# Import third-party modules
#Testing dash_devices
#import dash
#from dash.dependencies import Input, Output, State
#import plotly.io as pio
#pio.renderers.default = 'iframe'
import dash_core_components as dcc
import dash_html_components as html
import dash_devices as dash
from dash_devices.dependencies import Input, Output, State
#from dash import html
from dash.exceptions import PreventUpdate
from dash.dash import no_update
@ -52,9 +42,6 @@ import numpy as np
from configparser import ConfigParser
from numba import njit, jit
#from waitress import serve
#from gevent.pywsgi import WSGIServer
from threading import Timer
# Import Kraken SDR modules
@ -82,8 +69,15 @@ daq_start_filename = "daq_start_sm.sh"
#daq_start_filename = "daq_synthetic_start.sh"
sys.path.insert(0, daq_subsystem_path)
settings_file_path = os.path.join(root_path, "settings.json")
# Load settings file
settings_found = False
if os.path.exists(settings_file_path):
settings_found = True
with open(settings_file_path, 'r') as myfile:
dsp_settings = json.loads(myfile.read())
import ini_checker
import save_settings as settings
from krakenSDR_receiver import ReceiverRTLSDR
from krakenSDR_signal_processor import SignalProcessor
@ -93,12 +87,12 @@ class webInterface():
def __init__(self):
self.user_interface = None
logging.basicConfig(level=settings.logging_level*10)
self.logging_level = dsp_settings.get("logging_level", 0)*10
logging.basicConfig(level=self.logging_level)
self.logger = logging.getLogger(__name__)
self.logger.setLevel(settings.logging_level*10)
self.logger.setLevel(self.logging_level)
self.logger.info("Inititalizing web interface ")
if not settings.settings_found:
if not settings_found:
self.logger.warning("Web Interface settings file is not found!")
#############################################
@ -106,7 +100,7 @@ class webInterface():
#############################################
# Web interface internal
self.disable_tooltips = settings.disable_tooltips
self.disable_tooltips = dsp_settings.get("disable_tooltips", 0) #settings.disable_tooltips
self.page_update_rate = 1
self._avg_win_size = 10
self._update_rate_arr = None
@ -114,21 +108,24 @@ class webInterface():
self.sp_data_que = queue.Queue(1) # Que to communicate with the signal processing module
self.rx_data_que = queue.Queue(1) # Que to communicate with the receiver modules
# Instantiate and configure Kraken SDR modules
self.module_receiver = ReceiverRTLSDR(data_que=self.rx_data_que, data_interface=settings.data_interface, logging_level=settings.logging_level*10)
self.module_receiver.daq_center_freq = settings.center_freq*10**6
self.module_receiver.daq_rx_gain = [settings.gain_1, settings.gain_2]
self.module_receiver.rec_ip_addr = settings.default_ip
self.data_interface = dsp_settings.get("data_interface", "shmem")
self.module_signal_processor = SignalProcessor(data_que=self.sp_data_que, module_receiver=self.module_receiver, logging_level=settings.logging_level*10)
self.module_signal_processor.en_PR = settings.en_pr
self.module_signal_processor.PR_clutter_cancellation = settings.clutter_cancel_algo
self.module_signal_processor.max_bistatic_range = settings.max_bistatic_range
self.module_signal_processor.max_doppler = settings.max_doppler
self.en_persist = settings.en_pr_persist
self.pr_persist_decay = settings.pr_persist_decay
self.pr_dynamic_range_min = settings.pr_dynrange_min
self.pr_dynamic_range_max = settings.pr_dynrange_max
# Instantiate and configure Kraken SDR modules
self.module_receiver = ReceiverRTLSDR(data_que=self.rx_data_que, data_interface=self.data_interface, logging_level=self.logging_level)
self.module_receiver.daq_center_freq = dsp_settings.get("center_freq", 100.0) * 10**6
self.module_receiver.daq_rx_gain = [float(dsp_settings.get("gain_1", 1.4)), float(dsp_settings.get("gain_2", 1.4))]
self.module_receiver.daq_squelch_th_dB = dsp_settings.get("squelch_threshold_dB", 0.0)
self.module_receiver.rec_ip_addr = dsp_settings.get("default_ip", "0.0.0.0")
self.module_signal_processor = SignalProcessor(data_que=self.sp_data_que, module_receiver=self.module_receiver, logging_level=self.logging_level)
self.module_signal_processor.en_PR = dsp_settings.get("en_pr", True)
self.module_signal_processor.PR_clutter_cancellation = dsp_settings.get("clutter_cancel_algo", "Wiener MRE")
self.module_signal_processor.max_bistatic_range = dsp_settings.get("max_bistatic_range", 128)
self.module_signal_processor.max_doppler = dsp_settings.get("max_doppler", 256)
self.en_persist = dsp_settings.get("en_pr_persist", True)
self.pr_persist_decay = dsp_settings.get("pr_persist_decay", 0.99)
self.pr_dynamic_range_min = dsp_settings.get("pr_dynrange_min", -20)
self.pr_dynamic_range_max = dsp_settings.get("pr_dynrange_max", 10)
self.module_signal_processor.start()
@ -148,14 +145,15 @@ class webInterface():
self.daq_sample_delay_sync = 0
self.daq_iq_sync = 0
self.daq_noise_source_state= 0
self.daq_center_freq = settings.center_freq
self.daq_center_freq = dsp_settings.get("center_freq", 100.0)
self.daq_adc_fs = "-"
self.daq_fs = "-"
self.daq_cpi = "-"
self.daq_if_gains ="[,,,,]"
self.en_advanced_daq_cfg = False #settings.en_advanced_daq_cfg
self.daq_ini_cfg_params = read_config_file()
self.active_daq_ini_cfg = self.daq_ini_cfg_params[0] #"Default" # Holds the string identifier of the actively loaded DAQ ini configuration
self.en_advanced_daq_cfg = False
self.daq_ini_cfg_dict = read_config_file_dict()
self.active_daq_ini_cfg = self.daq_ini_cfg_dict['config_name'] #"Default" # Holds the string identifier of the actively loaded DAQ ini configuration
self.tmp_daq_ini_cfg = "Default"
self.daq_cfg_ini_error = ""
@ -178,13 +176,14 @@ class webInterface():
# Basic DAQ Config
self.decimated_bandwidth = 12.5
if self.daq_ini_cfg_params is not None:
if self.daq_ini_cfg_dict is not None:
self.logger.info("Config file found and read succesfully")
"""
Set the number of channels in the receiver module because it is required
to produce the initial gain configuration message (Only needed in shared-memory mode)
"""
self.module_receiver.M = self.daq_ini_cfg_params[1]
self.module_receiver.M = self.daq_ini_cfg_dict['num_ch']
#self.module_receiver.M = self.daq_ini_cfg_params[1]
def save_configuration(self):
@ -194,8 +193,8 @@ class webInterface():
data["center_freq"] = self.module_receiver.daq_center_freq/10**6
data["gain_1"] = self.module_receiver.daq_rx_gain[0]
data["gain_2"] = self.module_receiver.daq_rx_gain[1]
data["data_interface"] = settings.data_interface
data["default_ip"] = settings.default_ip
data["data_interface"] = dsp_settings.get("data_interface", "shmem") #settings.data_interface
data["default_ip"] = dsp_settings.get("default_ip", "0.0.0.0") #settings.default_ip
# DOA Estimation
data["en_pr"] = self.module_signal_processor.en_PR
@ -209,12 +208,16 @@ class webInterface():
data["pr_dynrange_max"] = self.pr_dynamic_range_max
# Web Interface
data["en_hw_check"] = settings.en_hw_check
data["en_hw_check"] = dsp_settings.get("en_hw_check", 0) #settings.en_hw_check
data["en_advanced_daq_cfg"] = self.en_advanced_daq_cfg
data["logging_level"] = settings.logging_level
data["disable_tooltips"] = settings.disable_tooltips
data["logging_level"] = dsp_settings.get("logging_level", 0) #settings.logging_level
data["disable_tooltips"] = dsp_settings.get("disable_tooltips", 0) #settings.disable_tooltips
#settings.write(data)
with open(settings_file_path, 'w') as outfile:
json.dump(data, outfile, indent=2)
settings.write(data)
def start_processing(self):
"""
Starts data processing
@ -236,29 +239,6 @@ class webInterface():
self.module_receiver.eth_close()
def close(self):
pass
"""
def config_doa_in_signal_processor(self):
if self._doa_method == 0:
self.module_signal_processor.en_DOA_Bartlett = True
self.module_signal_processor.en_DOA_Capon = False
self.module_signal_processor.en_DOA_MEM = False
self.module_signal_processor.en_DOA_MUSIC = False
elif self._doa_method == 1:
self.module_signal_processor.en_DOA_Bartlett = False
self.module_signal_processor.en_DOA_Capon = True
self.module_signal_processor.en_DOA_MEM = False
self.module_signal_processor.en_DOA_MUSIC = False
elif self._doa_method == 2:
self.module_signal_processor.en_DOA_Bartlett = False
self.module_signal_processor.en_DOA_Capon = False
self.module_signal_processor.en_DOA_MEM = True
self.module_signal_processor.en_DOA_MUSIC = False
elif self._doa_method == 3:
self.module_signal_processor.en_DOA_Bartlett = False
self.module_signal_processor.en_DOA_Capon = False
self.module_signal_processor.en_DOA_MEM = False
self.module_signal_processor.en_DOA_MUSIC = True
"""
def config_squelch_value(self, squelch_threshold_dB):
"""
Configures the squelch thresold both on the DAQ side and
@ -283,91 +263,82 @@ class webInterface():
#webInterface_inst.logger.info("Gain: {:f} dB".format(gain))
webInterface_inst.logger.info("Gain: " + ' '.join(str(x) for x in gain) + " dB")
def read_config_file(config_fname=daq_config_filename):
def read_config_file_dict(config_fname=daq_config_filename):
parser = ConfigParser()
found = parser.read([config_fname])
param_list = []
ini_data = {}
if not found:
return None
param_list.append(parser.get('meta', 'config_name'))
param_list.append(parser.getint('hw', 'num_ch'))
ini_data['config_name'] = parser.get('meta', 'config_name')
ini_data['num_ch'] = parser.getint('hw', 'num_ch')
ini_data['daq_buffer_size'] = parser.getint('daq','daq_buffer_size')
ini_data['sample_rate'] = parser.getint('daq','sample_rate')
ini_data['en_noise_source_ctr'] = parser.getint('daq','en_noise_source_ctr')
ini_data['en_squelch'] = parser.getint('squelch','en_squelch')
ini_data['amplitude_threshold'] = parser.getfloat('squelch','amplitude_threshold')
ini_data['cpi_size'] = parser.getint('pre_processing', 'cpi_size')
ini_data['decimation_ratio'] = parser.getint('pre_processing', 'decimation_ratio')
ini_data['fir_relative_bandwidth'] = parser.getfloat('pre_processing', 'fir_relative_bandwidth')
ini_data['fir_tap_size'] = parser.getint('pre_processing', 'fir_tap_size')
ini_data['fir_window'] = parser.get('pre_processing','fir_window')
ini_data['en_filter_reset'] = parser.getint('pre_processing','en_filter_reset')
ini_data['corr_size'] = parser.getint('calibration','corr_size')
ini_data['std_ch_ind'] = parser.getint('calibration','std_ch_ind')
ini_data['en_iq_cal'] = parser.getint('calibration','en_iq_cal')
ini_data['gain_lock_interval'] = parser.getint('calibration','gain_lock_interval')
ini_data['require_track_lock_intervention'] = parser.getint('calibration','require_track_lock_intervention')
ini_data['cal_track_mode'] = parser.getint('calibration','cal_track_mode')
ini_data['amplitude_cal_mode'] = parser.get('calibration','amplitude_cal_mode')
ini_data['cal_frame_interval'] = parser.getint('calibration','cal_frame_interval')
ini_data['cal_frame_burst_size'] = parser.getint('calibration','cal_frame_burst_size')
ini_data['amplitude_tolerance'] = parser.getint('calibration','amplitude_tolerance')
ini_data['phase_tolerance'] = parser.getint('calibration','phase_tolerance')
ini_data['maximum_sync_fails'] = parser.getint('calibration','maximum_sync_fails')
param_list.append(parser.getint('daq','daq_buffer_size'))
param_list.append(parser.getint('daq','sample_rate'))
param_list.append(parser.getint('daq','en_noise_source_ctr'))
ini_data['out_data_iface_type'] = parser.get('data_interface','out_data_iface_type')
param_list.append(parser.getint('squelch','en_squelch'))
param_list.append(parser.getfloat('squelch','amplitude_threshold'))
return ini_data
param_list.append(parser.getint('pre_processing', 'cpi_size'))
param_list.append(parser.getint('pre_processing', 'decimation_ratio'))
param_list.append(parser.getfloat('pre_processing', 'fir_relative_bandwidth'))
param_list.append(parser.getint('pre_processing', 'fir_tap_size'))
param_list.append(parser.get('pre_processing','fir_window'))
param_list.append(parser.getint('pre_processing','en_filter_reset'))
param_list.append(parser.getint('calibration','corr_size'))
param_list.append(parser.getint('calibration','std_ch_ind'))
param_list.append(parser.getint('calibration','en_iq_cal'))
param_list.append(parser.getint('calibration','gain_lock_interval'))
param_list.append(parser.getint('calibration','require_track_lock_intervention'))
param_list.append(parser.getint('calibration','cal_track_mode'))
param_list.append(parser.get('calibration','amplitude_cal_mode'))
param_list.append(parser.getint('calibration','cal_frame_interval'))
param_list.append(parser.getint('calibration','cal_frame_burst_size'))
param_list.append(parser.getint('calibration','amplitude_tolerance'))
param_list.append(parser.getint('calibration','phase_tolerance'))
param_list.append(parser.getint('calibration','maximum_sync_fails'))
param_list.append(parser.get('data_interface','out_data_iface_type'))
return param_list
def write_config_file(param_list):
webInterface_inst.logger.info("Write config file: {0}".format(param_list))
def write_config_file_dict(param_dict):
webInterface_inst.logger.info("Write config file: {0}".format(param_dict))
parser = ConfigParser()
found = parser.read([daq_config_filename])
if not found:
return -1
parser['meta']['config_name']=str(param_list[0])
parser['hw']['num_ch']=str(param_list[1])
parser['daq']['daq_buffer_size']=str(param_list[2])
parser['daq']['sample_rate']=str(param_list[3])
parser['daq']['en_noise_source_ctr']=str(param_list[4])
parser['meta']['config_name']=str(param_dict['config_name'])
parser['hw']['num_ch']=str(param_dict['num_ch'])
parser['daq']['daq_buffer_size']=str(param_dict['daq_buffer_size'])
parser['daq']['sample_rate']=str(param_dict['sample_rate'])
parser['daq']['en_noise_source_ctr']=str(param_dict['en_noise_source_ctr'])
# Set these for reconfigure
parser['daq']['center_freq']=str(int(webInterface_inst.module_receiver.daq_center_freq))
parser['squelch']['en_squelch']=str(param_list[5])
parser['squelch']['amplitude_threshold']=str(param_list[6])
parser['pre_processing']['cpi_size']=str(param_list[7])
parser['pre_processing']['decimation_ratio']=str(param_list[8])
parser['pre_processing']['fir_relative_bandwidth']=str(param_list[9])
parser['pre_processing']['fir_tap_size']=str(param_list[10])
parser['pre_processing']['fir_window']=str(param_list[11])
parser['pre_processing']['en_filter_reset']=str(param_list[12])
parser['calibration']['corr_size']=str(param_list[13])
parser['calibration']['std_ch_ind']=str(param_list[14])
parser['calibration']['en_iq_cal']=str(param_list[15])
parser['calibration']['gain_lock_interval']=str(param_list[16])
parser['calibration']['require_track_lock_intervention']=str(param_list[17])
parser['calibration']['cal_track_mode']=str(param_list[18])
parser['calibration']['amplitude_cal_mode']=str(param_list[19])
parser['calibration']['cal_frame_interval']=str(param_list[20])
parser['calibration']['cal_frame_burst_size']=str(param_list[21])
parser['calibration']['amplitude_tolerance']=str(param_list[22])
parser['calibration']['phase_tolerance']=str(param_list[23])
parser['calibration']['maximum_sync_fails']=str(param_list[24])
parser['squelch']['en_squelch']=str(param_dict['en_squelch'])
parser['squelch']['amplitude_threshold']=str(param_dict['amplitude_threshold'])
parser['pre_processing']['cpi_size']=str(param_dict['cpi_size'])
parser['pre_processing']['decimation_ratio']=str(param_dict['decimation_ratio'])
parser['pre_processing']['fir_relative_bandwidth']=str(param_dict['fir_relative_bandwidth'])
parser['pre_processing']['fir_tap_size']=str(param_dict['fir_tap_size'])
parser['pre_processing']['fir_window']=str(param_dict['fir_window'])
parser['pre_processing']['en_filter_reset']=str(param_dict['en_filter_reset'])
parser['calibration']['corr_size']=str(param_dict['corr_size'])
parser['calibration']['std_ch_ind']=str(param_dict['std_ch_ind'])
parser['calibration']['en_iq_cal']=str(param_dict['en_iq_cal'])
parser['calibration']['gain_lock_interval']=str(param_dict['gain_lock_interval'])
parser['calibration']['require_track_lock_intervention']=str(param_dict['require_track_lock_intervention'])
parser['calibration']['cal_track_mode']=str(param_dict['cal_track_mode'])
parser['calibration']['amplitude_cal_mode']=str(param_dict['amplitude_cal_mode'])
parser['calibration']['cal_frame_interval']=str(param_dict['cal_frame_interval'])
parser['calibration']['cal_frame_burst_size']=str(param_dict['cal_frame_burst_size'])
parser['calibration']['amplitude_tolerance']=str(param_dict['amplitude_tolerance'])
parser['calibration']['phase_tolerance']=str(param_dict['phase_tolerance'])
parser['calibration']['maximum_sync_fails']=str(param_dict['maximum_sync_fails'])
ini_parameters = parser._sections
error_list = ini_checker.check_ini(ini_parameters, settings.en_hw_check)
error_list = ini_checker.check_ini(ini_parameters, dsp_settings.get("en_hw_check", 0)) #settings.en_hw_check)
if len(error_list):
for e in error_list:
webInterface_inst.logger.error(e)
@ -375,7 +346,7 @@ def write_config_file(param_list):
else:
with open(daq_config_filename, 'w') as configfile:
parser.write(configfile)
return 0,[]
return 0, []
def get_preconfigs(config_files_path):
parser = ConfigParser()
@ -395,7 +366,6 @@ def get_preconfigs(config_files_path):
############################################
webInterface_inst = webInterface()
#############################################
# Prepare component dependencies #
#############################################
@ -428,7 +398,6 @@ fig_layout = go.Layout(
)
fig_dummy = go.Figure(layout=fig_layout)
#fig_dummy.add_trace(go.Scatter(x=x, y=y, name = "Avg spectrum"))
for m in range(0, webInterface_inst.module_receiver.M+1): #+1 for the auto decimation window selection
fig_dummy.add_trace(go.Scatter(x=x,
@ -546,16 +515,14 @@ app.layout = html.Div([
])
def generate_config_page_layout(webInterface_inst):
# Read DAQ config file
daq_cfg_params = webInterface_inst.daq_ini_cfg_params
daq_cfg_dict = webInterface_inst.daq_ini_cfg_dict
if daq_cfg_params is not None:
en_noise_src_values =[1] if daq_cfg_params[4] else []
en_squelch_values =[1] if daq_cfg_params[5] else []
en_filter_rst_values =[1] if daq_cfg_params[12] else []
en_iq_cal_values =[1] if daq_cfg_params[15] else []
en_req_track_lock_values =[1] if daq_cfg_params[17] else []
#daq_data_iface_type = daq_cfg_params[25]
if daq_cfg_dict is not None:
en_noise_src_values =[1] if daq_cfg_dict['en_noise_source_ctr'] else []
en_squelch_values =[1] if daq_cfg_dict['en_squelch'] else []
en_filter_rst_values =[1] if daq_cfg_dict['en_filter_reset'] else []
en_iq_cal_values =[1] if daq_cfg_dict['en_iq_cal'] else []
en_req_track_lock_values =[1] if daq_cfg_dict['require_track_lock_intervention'] else []
# Read available preconfig files
preconfigs = get_preconfigs(daq_preconfigs_path)
@ -572,11 +539,11 @@ def generate_config_page_layout(webInterface_inst):
ant_spacing_feet = ant_spacing_meter*3.2808399
ant_spacing_inch = ant_spacing_meter*39.3700787
cfg_decimated_bw = ((daq_cfg_params[3]) / daq_cfg_params[8]) / 10**3
cfg_data_block_len = ( daq_cfg_params[7] / (cfg_decimated_bw) )
cfg_recal_interval = (daq_cfg_params[20] * (cfg_data_block_len/10**3)) / 60
cfg_decimated_bw = ((daq_cfg_dict['sample_rate']) / daq_cfg_dict['decimation_ratio']) / 10**3
cfg_data_block_len = ( daq_cfg_dict['cpi_size'] / (cfg_decimated_bw) )
cfg_recal_interval = (daq_cfg_dict['cal_frame_interval'] * (cfg_data_block_len/10**3)) / 60
if daq_cfg_params[18] == 0: #If set to no tracking
if daq_cfg_dict['cal_track_mode'] == 0:
cfg_recal_interval = 1
gain_list = [
@ -655,9 +622,6 @@ def generate_config_page_layout(webInterface_inst):
html.Div([
html.Div("Preconfigured DAQ Files", className="field-label"),
#TEST
#dcc.Input(id='daq_cfg_files', value=cfg_data_block_len, type='number', debounce=True, className="field-body"),
dcc.Dropdown(id='daq_cfg_files',
options=[
{'label': str(i[1]), 'value': i[0]} for i in preconfigs
@ -696,8 +660,6 @@ def generate_config_page_layout(webInterface_inst):
]
# --> Optional DAQ Subsystem reconfiguration fields <--
#if len(en_advanced_daq_cfg):
# if daq_cfg_params is not None:
daq_subsystem_reconfiguration_options = [ \
html.Div([
@ -705,7 +667,7 @@ def generate_config_page_layout(webInterface_inst):
html.H3("HW", id="cfg_group_hw"),
html.Div([
html.Div("# RX Channels:", className="field-label"),
dcc.Input(id='cfg_rx_channels', value=daq_cfg_params[1], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_rx_channels', value=daq_cfg_dict['num_ch'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.H3("DAQ", id="cfg_group_daq"),
html.Div([
@ -714,7 +676,7 @@ def generate_config_page_layout(webInterface_inst):
options=[
{'label': i, 'value': i} for i in valid_daq_buffer_sizes
],
value=daq_cfg_params[2], style={"display":"inline-block"},className="field-body"),
value=daq_cfg_dict['daq_buffer_size'], style={"display":"inline-block"},className="field-body"),
], className="field"),
html.Div([
html.Div("Sample Rate [MHz]:", className="field-label", id="label_sample_rate"),
@ -722,37 +684,28 @@ def generate_config_page_layout(webInterface_inst):
options=[
{'label': i, 'value': i} for i in valid_sample_rates
],
value=daq_cfg_params[3]/10**6, style={"display":"inline-block"},className="field-body")
value=daq_cfg_dict['sample_rate']/10**6, style={"display":"inline-block"},className="field-body")
], className="field"),
html.Div([
html.Div("Enable Noise Source Control:", className="field-label", id="label_en_noise_source_ctr"),
dcc.Checklist(options=option , id="en_noise_source_ctr" , className="field-body", value=en_noise_src_values),
], className="field"),
#html.H3("Squelch"),
#html.Div([
# html.Div("Enable DAQ Squelch (NOT ACTIVE):", className="field-label", id="label_en_squelch"),
# dcc.Checklist(options=option , id="en_squelch_mode" , className="field-body", value=en_squelch_values),
#], className="field"),
#html.Div([
# html.Div("Initial Threshold:", className="field-label", id="label_squelch_init_threshold"),
# dcc.Input(id='cfg_squelch_init_th', value=daq_cfg_params[6], type='number', debounce=True, className="field-body")
#], className="field"),
html.H3("Pre Processing"),
html.Div([
html.Div("CPI Size [sample]:", className="field-label", id="label_cpi_size"),
dcc.Input(id='cfg_cpi_size', value=daq_cfg_params[7], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_cpi_size', value=daq_cfg_dict['cpi_size'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Decimation Ratio:", className="field-label", id="label_decimation_ratio"),
dcc.Input(id='cfg_decimation_ratio', value=daq_cfg_params[8], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_decimation_ratio', value=daq_cfg_dict['decimation_ratio'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("FIR Relative Bandwidth:", className="field-label", id="label_fir_relative_bw"),
dcc.Input(id='cfg_fir_bw', value=daq_cfg_params[9], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_fir_bw', value=daq_cfg_dict['fir_relative_bandwidth'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("FIR Tap Size:", className="field-label", id="label_fir_tap_size"),
dcc.Input(id='cfg_fir_tap_size', value=daq_cfg_params[10], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_fir_tap_size', value=daq_cfg_dict['fir_tap_size'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("FIR Window:", className="field-label", id="label_fir_window"),
@ -760,7 +713,7 @@ def generate_config_page_layout(webInterface_inst):
options=[
{'label': i, 'value': i} for i in valid_fir_windows
],
value=daq_cfg_params[11], style={"display":"inline-block"},className="field-body")
value=daq_cfg_dict['fir_window'], style={"display":"inline-block"},className="field-body")
], className="field"),
html.Div([
html.Div("Enable Filter Reset:", className="field-label", id="label_en_filter_reset"),
@ -769,11 +722,11 @@ def generate_config_page_layout(webInterface_inst):
html.H3("Calibration"),
html.Div([
html.Div("Correlation Size [sample]:", className="field-label", id="label_correlation_size"),
dcc.Input(id='cfg_corr_size', value=daq_cfg_params[13], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_corr_size', value=daq_cfg_dict['corr_size'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Standard Channel Index:", className="field-label", id="label_std_ch_index"),
dcc.Input(id='cfg_std_ch_ind', value=daq_cfg_params[14], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_std_ch_ind', value=daq_cfg_dict['std_ch_ind'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Enable IQ Calibration:", className="field-label", id="label_en_iq_calibration"),
@ -781,7 +734,7 @@ def generate_config_page_layout(webInterface_inst):
], className="field"),
html.Div([
html.Div("Gain Lock Interval [frame]:", className="field-label", id="label_gain_lock_interval"),
dcc.Input(id='cfg_gain_lock', value=daq_cfg_params[16], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_gain_lock', value=daq_cfg_dict['gain_lock_interval'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Require Track Lock Intervention (For Kerberos):", className="field-label", id="label_require_track_lock"),
@ -793,7 +746,7 @@ def generate_config_page_layout(webInterface_inst):
options=[
{'label': i[0], 'value': i[1]} for i in calibration_tack_modes
],
value=daq_cfg_params[18], style={"display":"inline-block"},className="field-body"),
value=daq_cfg_dict['cal_track_mode'], style={"display":"inline-block"},className="field-body"),
], className="field"),
html.Div([
html.Div("Amplitude Calibration Mode :", className="field-label", id="label_amplitude_calibration_mode"),
@ -803,27 +756,27 @@ def generate_config_page_layout(webInterface_inst):
{'label': 'disabled', 'value': 'disabled'},
{'label': 'channel_power', 'value': 'channel_power'}
],
value=daq_cfg_params[19], style={"display":"inline-block"},className="field-body"),
value=daq_cfg_dict['amplitude_cal_mode'], style={"display":"inline-block"},className="field-body"),
], className="field"),
html.Div([
html.Div("Calibration Frame Interval:", className="field-label", id="label_calibration_frame_interval"),
dcc.Input(id='cfg_cal_frame_interval', value=daq_cfg_params[20], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_cal_frame_interval', value=daq_cfg_dict['cal_frame_interval'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Calibration Frame Burst Size:", className="field-label", id="label_calibration_frame_burst_size"),
dcc.Input(id='cfg_cal_frame_burst_size', value=daq_cfg_params[21], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_cal_frame_burst_size', value=daq_cfg_dict['cal_frame_burst_size'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Amplitude Tolerance [dB]:", className="field-label", id="label_amplitude_tolerance"),
dcc.Input(id='cfg_amplitude_tolerance', value=daq_cfg_params[22], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_amplitude_tolerance', value=daq_cfg_dict['amplitude_tolerance'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Phase Tolerance [deg]:", className="field-label", id="label_phase_tolerance"),
dcc.Input(id='cfg_phase_tolerance', value=daq_cfg_params[23], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_phase_tolerance', value=daq_cfg_dict['phase_tolerance'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
html.Div([
html.Div("Maximum Sync Fails:", className="field-label", id="label_max_sync_fails"),
dcc.Input(id='cfg_max_sync_fails', value=daq_cfg_params[24], type='number', debounce=True, className="field-body-textbox")
dcc.Input(id='cfg_max_sync_fails', value=daq_cfg_dict['maximum_sync_fails'], type='number', debounce=True, className="field-body-textbox")
], className="field"),
], style={'width': '100%'}, id='adv-cfg-container'),
@ -926,13 +879,10 @@ def generate_config_page_layout(webInterface_inst):
if not webInterface_inst.disable_tooltips:
config_page_component_list.append(tooltips.dsp_config_tooltips)
#if len(en_advanced_daq_cfg):
#if daq_cfg_params is not None:
config_page_component_list.append(tooltips.daq_ini_config_tooltips)
return html.Div(children=config_page_component_list)
spectrum_page_layout = html.Div([
html.Div([
dcc.Graph(
@ -955,7 +905,7 @@ def generate_pr_page_layout(webInterface_inst):
style={"height": "inherit", "width" : "100%"},
id="pr-graph",
figure=pr_fig, #fig_dummy #doa_fig #fig_dummy
)], style={'width': '100%', 'height': '80vh'}), #className="monitor_card"),
)], style={'width': '100%', 'height': '85vh'}), #className="monitor_card"),
])
return pr_page_layout
@ -1159,7 +1109,6 @@ def update_daq_status():
daq_sampling_freq_str = str(webInterface_inst.daq_fs)
daq_cpi_str = str(webInterface_inst.daq_cpi)
app.push_mods({
'body_daq_update_rate': {'children': daq_update_rate_str},
'body_daq_dsp_latency': {'children': daq_dsp_latency},
@ -1383,8 +1332,6 @@ def update_dsp_params(update_freq, en_pr, en_persist, persist_decay, max_bistati
Input('cfg_daq_buffer_size' ,'value'),
Input('cfg_sample_rate' ,'value'),
Input('en_noise_source_ctr' ,'value'),
#Input('en_squelch_mode' ,'value'),
#Input('cfg_squelch_init_th' ,'value'),
Input('cfg_cpi_size' ,'value'),
Input('cfg_decimation_ratio' ,'value'),
Input('cfg_fir_bw' ,'value'),
@ -1412,7 +1359,6 @@ def update_dsp_params(update_freq, en_pr, en_persist, persist_decay, max_bistati
)
def update_daq_ini_params(
cfg_rx_channels,cfg_daq_buffer_size,cfg_sample_rate,en_noise_source_ctr, \
#en_squelch_mode,cfg_squelch_init_th,cfg_cpi_size,cfg_decimation_ratio, \
cfg_cpi_size,cfg_decimation_ratio, \
cfg_fir_bw,cfg_fir_tap_size,cfg_fir_window,en_filter_reset,cfg_corr_size, \
cfg_std_ch_ind,en_iq_cal,cfg_gain_lock,en_req_track_lock_intervention, \
@ -1429,66 +1375,60 @@ def update_daq_ini_params(
# If is was the preconfig changed, just update the preconfig values
if component_id == 'daq_cfg_files':
webInterface_inst.daq_ini_cfg_params = read_config_file(config_fname)
webInterface_inst.tmp_daq_ini_cfg = webInterface_inst.daq_ini_cfg_params[0]
daq_cfg_params = webInterface_inst.daq_ini_cfg_params
if daq_cfg_params is not None:
en_noise_src_values =[1] if daq_cfg_params[4] else []
en_squelch_values =[1] if daq_cfg_params[5] else []
en_filter_rst_values =[1] if daq_cfg_params[12] else []
en_iq_cal_values =[1] if daq_cfg_params[15] else []
en_req_track_lock_values =[1] if daq_cfg_params[17] else []
webInterface_inst.daq_ini_cfg_dict = read_config_file_dict(config_fname)
webInterface_inst.tmp_daq_ini_cfg = webInterface_inst.daq_ini_cfg_dict['config_name']
daq_cfg_dict = webInterface_inst.daq_ini_cfg_dict
if daq_cfg_dict is not None:
en_noise_src_values =[1] if daq_cfg_dict['en_noise_source_ctr'] else []
en_squelch_values =[1] if daq_cfg_dict['en_squelch'] else []
en_filter_rst_values =[1] if daq_cfg_dict['en_filter_reset'] else []
en_iq_cal_values =[1] if daq_cfg_dict['en_iq_cal'] else []
en_req_track_lock_values =[1] if daq_cfg_dict['require_track_lock_intervention'] else []
en_persist_values =[1] if webInterface_inst.en_persist else []
en_pr_values =[1] if webInterface_inst.module_signal_processor.en_PR else []
en_advanced_daq_cfg =[1] if webInterface_inst.en_advanced_daq_cfg else []
cfg_decimated_bw = ((daq_cfg_params[3]) / daq_cfg_params[8]) / 10**3
cfg_data_block_len = ( daq_cfg_params[7] / (cfg_decimated_bw) )
cfg_recal_interval = (daq_cfg_params[20] * (cfg_data_block_len/10**3)) / 60
cfg_decimated_bw = ((daq_cfg_dict['sample_rate']) / daq_cfg_dict['decimation_ratio']) / 10**3
cfg_data_block_len = ( daq_cfg_dict['cpi_size'] / (cfg_decimated_bw) )
cfg_recal_interval = (daq_cfg_dict['cal_frame_interval'] * (cfg_data_block_len/10**3)) / 60
if daq_cfg_params[18] == 0: #If set to no tracking
if daq_cfg_dict['cal_track_mode'] == 0: #If set to no tracking
cfg_recal_interval = 1
app.push_mods({
'cfg_data_block_len': {'value': cfg_data_block_len},
'cfg_decimated_bw': {'value': cfg_decimated_bw},
'cfg_recal_interval': {'value': cfg_recal_interval},
'cfg_rx_channels': {'value': daq_cfg_params[1]},
'cfg_daq_buffer_size': {'value': daq_cfg_params[2]},
'cfg_sample_rate': {'value': daq_cfg_params[3]/10**6},
'cfg_rx_channels': {'value': daq_cfg_dict['num_ch']},
'cfg_daq_buffer_size': {'value': daq_cfg_dict['daq_buffer_size']},
'cfg_sample_rate': {'value': daq_cfg_dict['sample_rate']/10**6},
'en_noise_source_ctr': {'value': en_noise_src_values},
'cfg_cpi_size': {'value': daq_cfg_params[7]},
'cfg_decimation_ratio': {'value': daq_cfg_params[8]},
'cfg_fir_bw': {'value': daq_cfg_params[9]},
'cfg_fir_tap_size': {'value': daq_cfg_params[10]},
'cfg_fir_window': {'value': daq_cfg_params[11]},
'cfg_cpi_size': {'value': daq_cfg_dict['cpi_size']},
'cfg_decimation_ratio': {'value': daq_cfg_dict['decimation_ratio']},
'cfg_fir_bw': {'value': daq_cfg_dict['fir_relative_bandwidth']},
'cfg_fir_tap_size': {'value': daq_cfg_dict['fir_tap_size']},
'cfg_fir_window': {'value': daq_cfg_dict['fir_window']},
'en_filter_reset': {'value': en_filter_rst_values},
'cfg_cal_frame_interval': {'value': daq_cfg_params[20]},
'cfg_corr_size': {'value': daq_cfg_params[13]},
'cfg_std_ch_ind': {'value': daq_cfg_params[14]},
'cfg_cal_frame_interval': {'value': daq_cfg_dict['cal_frame_interval']},
'cfg_corr_size': {'value': daq_cfg_dict['corr_size']},
'cfg_std_ch_ind': {'value': daq_cfg_dict['std_ch_ind']},
'en_iq_cal': {'value': en_iq_cal_values},
'cfg_gain_lock': {'value': daq_cfg_params[16]},
'cfg_gain_lock': {'value': daq_cfg_dict['gain_lock_interval']},
'en_req_track_lock_intervention': {'value': en_req_track_lock_values},
'cfg_cal_track_mode': {'value': daq_cfg_params[18]},
'cfg_amplitude_cal_mode': {'value': daq_cfg_params[19]},
'cfg_cal_frame_interval': {'value': daq_cfg_params[20]},
'cfg_cal_frame_burst_size': {'value': daq_cfg_params[21]},
'cfg_amplitude_tolerance': {'value': daq_cfg_params[22]},
'cfg_phase_tolerance': {'value': daq_cfg_params[23]},
'cfg_max_sync_fails': {'value': daq_cfg_params[24]},
'cfg_cal_track_mode': {'value': daq_cfg_dict['cal_track_mode']},
'cfg_amplitude_cal_mode': {'value': daq_cfg_dict['amplitude_cal_mode']},
'cfg_cal_frame_interval': {'value': daq_cfg_dict['cal_frame_interval']},
'cfg_cal_frame_burst_size': {'value': daq_cfg_dict['cal_frame_burst_size']},
'cfg_amplitude_tolerance': {'value': daq_cfg_dict['amplitude_tolerance']},
'cfg_phase_tolerance': {'value': daq_cfg_dict['phase_tolerance']},
'cfg_max_sync_fails': {'value': daq_cfg_dict['maximum_sync_fails']},
})
return Output('dummy_output', 'children', '') #[no_update, no_update, no_update, no_update]
# If the input was from basic DAQ config, update the actual DAQ params
if component_id == "cfg_data_block_len" or component_id == "cfg_decimated_bw" or component_id == "cfg_recal_interval":
if not cfg_data_block_len or not cfg_decimated_bw or not cfg_recal_interval:
@ -1532,54 +1472,33 @@ def update_daq_ini_params(
else:
cfg_cal_track_mode = 0
param_dict = webInterface_inst.daq_ini_cfg_dict
param_dict['config_name'] = "Custom"
param_dict['num_ch'] = cfg_rx_channels
param_dict['daq_buffer_size'] = cfg_daq_buffer_size
param_dict['sample_rate'] = int(cfg_sample_rate*10**6)
param_dict['en_noise_source_ctr'] = 1 if len(en_noise_source_ctr) else 0
param_dict['en_squelch'] = 0
param_dict['cpi_size'] = cfg_cpi_size
param_dict['decimation_ratio'] = cfg_decimation_ratio
param_dict['fir_relative_bandwidth'] = cfg_fir_bw
param_dict['fir_tap_size'] = cfg_fir_tap_size
param_dict['fir_window'] = cfg_fir_window
param_dict['en_filter_reset'] = 1 if len(en_filter_reset) else 0
param_dict['corr_size'] = cfg_corr_size
param_dict['std_ch_ind'] = cfg_std_ch_ind
param_dict['en_iq_cal'] = 1 if len(en_iq_cal) else 0
param_dict['gain_lock_interval'] = cfg_gain_lock
param_dict['require_track_lock_intervention'] = 1 if len(en_req_track_lock_intervention) else 0
param_dict['cal_track_mode'] = cfg_cal_track_mode
param_dict['amplitude_cal_mode'] = cfg_amplitude_cal_mode
param_dict['cal_frame_interval'] = cfg_cal_frame_interval
param_dict['cal_frame_burst_size'] = cfg_cal_frame_burst_size
param_dict['amplitude_tolerance'] = cfg_amplitude_tolerance
param_dict['phase_tolerance'] = cfg_phase_tolerance
param_dict['maximum_sync_fails'] = cfg_max_sync_fails
param_list = []
param_list.append("Custom")
param_list.append(cfg_rx_channels)
param_list.append(cfg_daq_buffer_size)
param_list.append(int(cfg_sample_rate*10**6))
if en_noise_source_ctr is not None and len(en_noise_source_ctr):
param_list.append(1)
else:
param_list.append(0)
#if en_squelch_mode is not None and len(en_squelch_mode):
# param_list.append(1)
#else:
param_list.append(0) #en_squelch placeholder
#param_list.append(cfg_squelch_init_th)
param_list.append(0) #cfg_squelch_init_th placeholder
param_list.append(cfg_cpi_size)
param_list.append(cfg_decimation_ratio)
param_list.append(cfg_fir_bw)
param_list.append(cfg_fir_tap_size)
param_list.append(cfg_fir_window)
if en_filter_reset is not None and len(en_filter_reset):
param_list.append(1)
else:
param_list.append(0)
param_list.append(cfg_corr_size)
param_list.append(cfg_std_ch_ind)
if en_iq_cal is not None and len(en_iq_cal):
param_list.append(1)
else:
param_list.append(0)
param_list.append(cfg_gain_lock)
if en_req_track_lock_intervention is not None and len(en_req_track_lock_intervention):
param_list.append(1)
else:
param_list.append(0)
param_list.append(cfg_cal_track_mode)
param_list.append(cfg_amplitude_cal_mode)
param_list.append(cfg_cal_frame_interval)
param_list.append(cfg_cal_frame_burst_size)
param_list.append(cfg_amplitude_tolerance)
param_list.append(cfg_phase_tolerance)
param_list.append(cfg_max_sync_fails)
param_list.append(webInterface_inst.daq_ini_cfg_params[25]) # Preserve data interface information
webInterface_inst.daq_ini_cfg_params = param_list
webInterface_inst.daq_ini_cfg_dict = param_dict
if ctx.triggered:
# If we updated advanced daq, update basic DAQ params
@ -1607,7 +1526,6 @@ def update_daq_ini_params(
'cfg_daq_buffer_size': {'value': cfg_daq_buffer_size},
'cfg_corr_size': {'value': cfg_corr_size},
'en_noise_source_ctr': {'value': en_noise_source_ctr},
#'en_squelch_mode': {'value': en_squelch_mode},
'cfg_fir_bw': {'value': cfg_fir_bw},
'cfg_fir_window': {'value': cfg_fir_window},
'en_filter_reset': {'value': en_filter_reset},
@ -1621,8 +1539,6 @@ def update_daq_ini_params(
'cfg_max_sync_fails': {'value': cfg_max_sync_fails},
})
@app.callback(Output('adv-cfg-container', 'style'),
[Input("en_advanced_daq_cfg", "value")]
)
@ -1633,7 +1549,6 @@ def toggle_adv_daq(toggle_value):
else:
return {'display': 'none'}
@app.callback(
None,
[Input(component_id="btn_reconfig_daq_chain" , component_property="n_clicks")],
@ -1645,13 +1560,10 @@ def reconfig_daq_chain(input_value, freq, gain):
if input_value is None:
return Output('dummy_output', 'children', '') #[no_update, no_update, no_update, no_update]
#return [no_update]
# raise PreventUpdate
# TODO: Check data interface mode here !
# Update DAQ Subsystem config file
config_res, config_err = write_config_file(webInterface_inst.daq_ini_cfg_params)
config_res, config_err = write_config_file_dict(webInterface_inst.daq_ini_cfg_dict)
if config_res:
webInterface_inst.daq_cfg_ini_error = config_err[0]
return Output("placeholder_recofnig_daq", "children", '-1')
@ -1661,9 +1573,7 @@ def reconfig_daq_chain(input_value, freq, gain):
# time.sleep(2)
webInterface_inst.daq_restart = 1
# Restart DAQ Subsystem
# Stop signal processing
webInterface_inst.stop_processing()
# time.sleep(2)
@ -1709,12 +1619,15 @@ def reconfig_daq_chain(input_value, freq, gain):
daq_rx_gain = webInterface_inst.module_receiver.daq_rx_gain
rec_ip_addr = webInterface_inst.module_receiver.rec_ip_addr
webInterface_inst.module_receiver = ReceiverRTLSDR(data_que=webInterface_inst.rx_data_que, data_interface=settings.data_interface, logging_level=settings.logging_level*10)
logging_level = webInterface_inst.logging_level
data_interface = webInterface_inst.data_interface
webInterface_inst.module_receiver = ReceiverRTLSDR(data_que=webInterface_inst.rx_data_que, data_interface=data_interface, logging_level=logging_level)
webInterface_inst.module_receiver.daq_center_freq = daq_center_freq
webInterface_inst.module_receiver.daq_rx_gain = daq_rx_gain #settings.uniform_gain #daq_rx_gain
webInterface_inst.module_receiver.rec_ip_addr = rec_ip_addr
webInterface_inst.module_signal_processor = SignalProcessor(data_que=webInterface_inst.sp_data_que, module_receiver=webInterface_inst.module_receiver, logging_level=settings.logging_level*10)
webInterface_inst.module_signal_processor = SignalProcessor(data_que=webInterface_inst.sp_data_que, module_receiver=webInterface_inst.module_receiver, logging_level=logging_level)
webInterface_inst.module_signal_processor.en_PR = en_PR
webInterface_inst.module_signal_processor.PR_clutter_cancellation = PR_clutter_cancellation
webInterface_inst.module_signal_processor.max_bistatic_range = max_bistatic_range
@ -1727,18 +1640,16 @@ def reconfig_daq_chain(input_value, freq, gain):
webInterface_inst.module_signal_processor.start()
# This must be here, otherwise the gains dont reinit properly?
webInterface_inst.module_receiver.M = webInterface_inst.daq_ini_cfg_params[1]
#webInterface_inst.module_receiver.M = webInterface_inst.daq_ini_cfg_params[1]
webInterface_inst.module_receiver.M = webInterface_inst.daq_ini_cfg_dict['num_ch']
# Restart signal processing
webInterface_inst.start_processing()
webInterface_inst.logger.debug("Signal processing started")
webInterface_inst.daq_restart = 0
webInterface_inst.module_receiver.iq_header.active_ant_chs = webInterface_inst.daq_ini_cfg_params[1]
webInterface_inst.daq_cfg_ini_error = ""
webInterface_inst.active_daq_ini_cfg = webInterface_inst.daq_ini_cfg_params[0] #webInterface_inst.tmp_daq_ini_cfg
webInterface_inst.active_daq_ini_cfg = webInterface_inst.daq_ini_cfg_dict['config_name']
return Output("daq_cfg_files", "value", daq_config_filename), Output("active_daq_ini_cfg", "children", "Active Configuration: " + webInterface_inst.active_daq_ini_cfg)

View File

@ -1,106 +0,0 @@
import json
import os
"""
Handles the DoA DSP settings
Project: Kraken DoA DSP
Author : Tamas Peto
"""
root_path = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
settings_file_path = os.path.join(root_path,"settings.json")
settings_found =False
if os.path.exists(settings_file_path):
settings_found = True
with open(settings_file_path, 'r') as myfile:
settings=json.loads(myfile.read())
# DAQ Configuration
center_freq = settings.get("center_freq", 100.0)
uniform_gain = settings.get("uniform_gain", 1.4)
gain_1 = settings.get("gain_1", 1.4)
gain_2 = settings.get("gain_2", 1.4)
data_interface = settings.get("data_interface", "eth")
default_ip = settings.get("default_ip", "0.0.0.0")
# PR Paramaters
en_pr = settings.get("en_pr", 0)
clutter_cancel_algo = settings.get("clutter_cancel_algo", "Wiener MRE")
max_bistatic_range = settings.get("max_bistatic_range", 128)
max_doppler = settings.get("max_doppler", 256)
en_pr_persist = settings.get("en_pr_persist", 1)
pr_persist_decay = settings.get("pr_persist_decay", 0.99)
pr_dynrange_min = settings.get("pr_dynrange_min", -20)
pr_dynrange_max = settings.get("pr_dynrange_max", 100)
#ant_arrangement = settings.get("ant_arrangement", "ULA")
#ant_spacing = settings.get("ant_spacing", 0.5)
#doa_method = settings.get("doa_method", "MUSIC")
#en_fbavg = settings.get("en_fbavg", 0)
#compass_offset = settings.get("compass_offset", 0)
#doa_fig_type = settings.get("doa_fig_type", "Linear plot")
# DSP misc
#en_squelch = settings.get("en_squelch", 0)
#squelch_threshold_dB = settings.get("squelch_threshold_dB", 0.0)
# Web Interface
en_hw_check = settings.get("en_hw_check", 0)
en_advanced_daq_cfg = settings.get("en_advanced_daq_cfg", 0)
logging_level = settings.get("logging_level", 0)
disable_tooltips = settings.get("disable_tooltips", 0)
# Check and correct if needed
#if not ant_arrangement in ["ULA", "UCA"]:
# ant_arrangement="ULA"
#doa_method_dict = {"Bartlett":0, "Capon":1, "MEM":2, "MUSIC":3}
#if not doa_method in doa_method_dict:
# doa_method = "MUSIC"
#doa_fig_type_dict = {"Linear plot":0, "Polar plot":1, "Compass":2}
#if not doa_fig_type in doa_fig_type_dict:
# doa_gfig_type="Linear plot"
def write(data = None):
if data is None:
data = {}
# DAQ Configuration
data["center_freq"] = center_freq
data["uniform_gain"] = uniform_gain
data["gain_1"] = gain_1
data["gain_2"] = gain_2
data["data_interface"] = data_interface
data["default_ip"] = default_ip
# DOA Estimation
data["en_pr"] = en_pr
data["clutter_cancel_algo"] = clutter_cancel_algo
data["max_bistatic_range"] = max_bistatic_range
data["max_doppler"] = max_doppler
data["en_pr_persist"] = en_pr_persist
data["pr_persist_decay"] = pr_persist_decay
data["pr_dynrange_min"] = pr_dynrange_min
data["pr_dynrange_max"] = pr_dynrange_max
#data["ant_arrangement"] = ant_arrangement
#data["ant_spacing"] = ant_spacing
#data["doa_method"] = doa_method
#data["en_fbavg"] = en_fbavg
#data["compass_offset"] = compass_offset
#data["doa_fig_tpye"] = doa_fig_type
# DSP misc
#data["en_squelch"] = en_squelch
#data["squelch_threshold_dB"] = squelch_threshold_dB
# Web Interface
data["en_hw_check"] = en_hw_check
data["en_advanced_daq_cfg"] = en_advanced_daq_cfg
data["logging_level"] = logging_level
data["disable_tooltips"] = disable_tooltips
with open(settings_file_path, 'w') as outfile:
json.dump(data, outfile)

View File

@ -1 +1,21 @@
{"center_freq": 569.0, "gain_1": 25.4, "gain_2": 7.7, "data_interface": "shmem", "default_ip": "0.0.0.0", "en_pr": true, "clutter_cancel_algo": "Wiener MRE", "max_bistatic_range": 128, "max_doppler": 256, "en_pr_persist": true, "pr_persist_decay": 0.99, "pr_dynrange_min": -20, "pr_dynrange_max": 10, "en_hw_check": 0, "en_advanced_daq_cfg": [], "logging_level": 5, "disable_tooltips": 0}
{
"center_freq": 569.0,
"gain_1": 25.4,
"gain_2": 7.7,
"data_interface": "shmem",
"default_ip": "0.0.0.0",
"en_pr": true,
"clutter_cancel_algo": "Wiener MRE",
"max_bistatic_range": 128,
"max_doppler": 256,
"en_pr_persist": true,
"pr_persist_decay": 0.99,
"pr_dynrange_min": -20,
"pr_dynrange_max": 10,
"en_hw_check": 0,
"en_advanced_daq_cfg": [
1
],
"logging_level": 5,
"disable_tooltips": 0
}