diff options
Diffstat (limited to '_UI/_web_interface/kraken_web_interface.py')
| -rwxr-xr-x | _UI/_web_interface/kraken_web_interface.py | 621 |
1 files changed, 266 insertions, 355 deletions
diff --git a/_UI/_web_interface/kraken_web_interface.py b/_UI/_web_interface/kraken_web_interface.py index ad94de9..b77df98 100755 --- a/_UI/_web_interface/kraken_web_interface.py +++ b/_UI/_web_interface/kraken_web_interface.py @@ -22,27 +22,17 @@ import logging
import os
import sys
-import queue
+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
@@ -69,12 +56,12 @@ sys.path.insert(0, signal_processor_path) sys.path.insert(0, ui_path)
daq_subsystem_path = os.path.join(
- os.path.join(os.path.dirname(root_path),
- "heimdall_daq_fw"),
+ os.path.join(os.path.dirname(root_path),
+ "heimdall_daq_fw"),
"Firmware")
daq_preconfigs_path = os.path.join(
- os.path.join(os.path.dirname(root_path),
- "heimdall_daq_fw"),
+ os.path.join(os.path.dirname(root_path),
+ "heimdall_daq_fw"),
"config_files")
daq_config_filename = os.path.join(daq_subsystem_path, "daq_chain_config.ini")
daq_stop_filename = "daq_stop.sh"
@@ -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
@@ -92,53 +86,56 @@ import tooltips class webInterface():
def __init__(self):
- self.user_interface = None
-
- logging.basicConfig(level=settings.logging_level*10)
+ self.user_interface = None
+ 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!")
-
+
#############################################
# Initialize and Configure Kraken modules #
#############################################
- # Web interface internal
- self.disable_tooltips = settings.disable_tooltips
- self.page_update_rate = 1
+ # Web interface internal
+ 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
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
+ self.data_interface = dsp_settings.get("data_interface", "shmem")
+
# 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.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
+ 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()
-
+
#############################################
# UI Status and Config variables #
#############################################
# DAQ Subsystem status parameters
self.daq_conn_status = 0
- self.daq_cfg_iface_status = 0 # 0- ready, 1-busy
+ self.daq_cfg_iface_status = 0 # 0- ready, 1-busy
self.daq_restart = 0 # 1-restarting
self.daq_update_rate = 0
self.daq_frame_sync = 1 # Active low
@@ -148,21 +145,22 @@ 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 = ""
- # DSP Processing Parameters and Results
+ # DSP Processing Parameters and Results
self.spectrum = None
self.daq_dsp_latency = 0 # [ms]
- self.logger.info("Web interface object initialized")
+ self.logger.info("Web interface object initialized")
# Passive Radar Data
self.RD_matrix = None
@@ -178,13 +176,14 @@ class webInterface(): # Basic DAQ Config
self.decimated_bandwidth = 12.5
- if self.daq_ini_cfg_params is not None:
- self.logger.info("Config file found and read succesfully")
+ 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
+ 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,9 +193,9 @@ 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 = []
- if not found:
+ ini_data = {}
+ if not found:
return None
- param_list.append(parser.get('meta', 'config_name'))
-
- param_list.append(parser.getint('hw', 'num_ch'))
-
- 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'))
-
- param_list.append(parser.getint('squelch','en_squelch'))
- param_list.append(parser.getfloat('squelch','amplitude_threshold'))
-
- 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))
+
+ 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')
+
+ ini_data['out_data_iface_type'] = parser.get('data_interface','out_data_iface_type')
+
+ return ini_data
+
+
+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:
+ 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 #
#############################################
@@ -424,11 +394,10 @@ fig_layout = go.Layout( showlegend=True,
margin=go.layout.Margin(
t=0 #top margin
- )
+ )
)
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,
@@ -544,39 +513,37 @@ app.layout = html.Div([ html.Div(id='page-content')
])
-def generate_config_page_layout(webInterface_inst):
+def generate_config_page_layout(webInterface_inst):
# Read DAQ config file
- 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 []
-
- #daq_data_iface_type = daq_cfg_params[25]
-
+ 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 []
+
# Read available preconfig files
preconfigs = get_preconfigs(daq_preconfigs_path)
-
+
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 []
# Calulcate spacings
wavelength= 300 / webInterface_inst.daq_center_freq
-
+
ant_spacing_wavelength = webInterface_inst.module_signal_processor.DOA_inter_elem_space
ant_spacing_meter = round(wavelength * ant_spacing_wavelength, 3)
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,45 +676,36 @@ 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"),
dcc.Dropdown(id='cfg_sample_rate',
options=[
- {'label': i, 'value': i} for i in valid_sample_rates
+ {'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"),
+ 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")
+ html.Div("CPI Size [sample]:", className="field-label", id="label_cpi_size"),
+ 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")
+ html.Div("Decimation Ratio:", className="field-label", id="label_decimation_ratio"),
+ 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")
+ html.Div("FIR Relative Bandwidth:", className="field-label", id="label_fir_relative_bw"),
+ 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")
+ html.Div("FIR Tap Size:", className="field-label", id="label_fir_tap_size"),
+ 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,70 +713,70 @@ 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"),
+ html.Div("Enable Filter Reset:", className="field-label", id="label_en_filter_reset"),
dcc.Checklist(options=option , id="en_filter_reset" , className="field-body", value=en_filter_rst_values),
], className="field"),
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")
+ html.Div("Standard Channel Index:", className="field-label", id="label_std_ch_index"),
+ 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"),
+ html.Div("Enable IQ Calibration:", className="field-label", id="label_en_iq_calibration"),
dcc.Checklist(options=option , id="en_iq_cal" , className="field-body", value=en_iq_cal_values),
], 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")
+ html.Div("Gain Lock Interval [frame]:", className="field-label", id="label_gain_lock_interval"),
+ 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"),
+ html.Div("Require Track Lock Intervention (For Kerberos):", className="field-label", id="label_require_track_lock"),
dcc.Checklist(options=option , id="en_req_track_lock_intervention" , className="field-body", value=en_req_track_lock_values),
], className="field"),
html.Div([
- html.Div("Calibration Track Mode:", className="field-label", id="label_calibration_track_mode"),
+ html.Div("Calibration Track Mode:", className="field-label", id="label_calibration_track_mode"),
dcc.Dropdown(id='cfg_cal_track_mode',
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"),
+ html.Div("Amplitude Calibration Mode :", className="field-label", id="label_amplitude_calibration_mode"),
dcc.Dropdown(id='cfg_amplitude_cal_mode',
options=[
{'label': 'default', 'value': 'default'},
{'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")
+ html.Div("Calibration Frame Interval:", className="field-label", id="label_calibration_frame_interval"),
+ 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")
+ 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_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")
+ html.Div("Amplitude Tolerance [dB]:", className="field-label", id="label_amplitude_tolerance"),
+ 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")
+ html.Div("Phase Tolerance [deg]:", className="field-label", id="label_phase_tolerance"),
+ 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")
+ html.Div("Maximum Sync Fails:", className="field-label", id="label_max_sync_fails"),
+ 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,14 +879,11 @@ 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([
+spectrum_page_layout = html.Div([
html.Div([
dcc.Graph(
id="spectrum-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
@@ -1008,7 +958,7 @@ def fetch_dsp_data(): iq_header = data_entry[1]
# Unpack header
webInterface_inst.daq_frame_index = iq_header.cpi_index
-
+
if iq_header.frame_type == iq_header.FRAME_TYPE_DATA:
webInterface_inst.daq_frame_type = "Data"
elif iq_header.frame_type == iq_header.FRAME_TYPE_DUMMY:
@@ -1020,16 +970,16 @@ def fetch_dsp_data(): else:
webInterface_inst.daq_frame_type = "Unknown"
- webInterface_inst.daq_frame_sync = iq_header.check_sync_word()
+ webInterface_inst.daq_frame_sync = iq_header.check_sync_word()
webInterface_inst.daq_power_level = iq_header.adc_overdrive_flags
webInterface_inst.daq_sample_delay_sync = iq_header.delay_sync_flag
webInterface_inst.daq_iq_sync = iq_header.iq_sync_flag
webInterface_inst.daq_noise_source_state= iq_header.noise_source_state
-
- if webInterface_inst.daq_center_freq != iq_header.rf_center_freq/10**6:
+
+ if webInterface_inst.daq_center_freq != iq_header.rf_center_freq/10**6:
freq_update = 1
-
- webInterface_inst.daq_center_freq = iq_header.rf_center_freq/10**6
+
+ webInterface_inst.daq_center_freq = iq_header.rf_center_freq/10**6
webInterface_inst.daq_adc_fs = iq_header.adc_sampling_freq/10**6
webInterface_inst.daq_fs = iq_header.sampling_freq/10**6
webInterface_inst.daq_cpi = int(iq_header.cpi_length*10**3/iq_header.sampling_freq)
@@ -1046,7 +996,7 @@ def fetch_dsp_data(): if webInterface_inst._update_rate_arr is None:
webInterface_inst._update_rate_arr = np.ones(webInterface_inst._avg_win_size)*webInterface_inst.daq_update_rate
webInterface_inst._update_rate_arr[0:webInterface_inst._avg_win_size-2] = \
- webInterface_inst._update_rate_arr[1:webInterface_inst._avg_win_size-1]
+ webInterface_inst._update_rate_arr[1:webInterface_inst._avg_win_size-1]
webInterface_inst._update_rate_arr[webInterface_inst._avg_win_size-1] = webInterface_inst.daq_update_rate
#webInterface_inst.page_update_rate = np.average(webInterface_inst._update_rate_arr)*0.8
elif data_entry[0] == "latency":
@@ -1059,7 +1009,7 @@ def fetch_dsp_data(): webInterface_inst.logger.debug("Passive Radar RD Matrix data fetched from signal processing que")
doa_update_flag = 1
webInterface_inst.RD_matrix = data_entry[1]
- else:
+ else:
webInterface_inst.logger.warning("Unknown data entry: {:s}".format(data_entry[0]))
except queue.Empty:
# Handle empty queue here
@@ -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:
@@ -1530,57 +1470,36 @@ def update_daq_ini_params( if cfg_cal_frame_interval > 1:
cfg_cal_track_mode = 2 #[{'label': calibration_tack_modes[1], 'value': calibration_tack_modes[1]}]
else:
- cfg_cal_track_mode = 0
-
+ 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
+
+ webInterface_inst.daq_ini_cfg_dict = param_dict
- 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
-
if ctx.triggered:
# If we updated advanced daq, update basic DAQ params
if component_id == "cfg_sample_rate" or component_id == "cfg_decimation_ratio" or component_id == "cfg_cpi_size" or component_id == "cfg_cal_frame_interval":
@@ -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)
|