enode-host 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

enode_host/model.py

@@ -69,6 +69,7 @@ try:
         SPEED_COL,
         RSSI_COL,
         PPS_COL,
+        BAT_COL,
         LEVEL_COL,
         RT_STREAM_HD5_DIR,
         RT_STREAM_MERGED_DIR,
@@ -82,6 +83,7 @@ except ImportError:
         SPEED_COL,
         RSSI_COL,
         PPS_COL,
+        BAT_COL,
         LEVEL_COL,
         RT_STREAM_HD5_DIR,
         RT_STREAM_MERGED_DIR,
@@ -163,6 +165,7 @@ class Model():
                                                         RSSI_COL, 
                                                         'Children', 
                                                         PPS_COL, 
+                                                        BAT_COL,
                                                         'CMD',       
                                                         #'Children_nodeIDs', # invisable in table
                                                         'PPS-time',   # invisable in table
@@ -184,7 +187,7 @@ class Model():
         self.full_range_xlim = []
         self.merge_full_range = False
         self.psder = {}             # {1:psd_recursive.PSD_Recursive(1024, 62.5), ...}
-        self.psd_xdata = []         # frequency = 1d ndarray
+        self.psd_xdata = {}         # per-node frequency arrays {node_id: 1d ndarray}
         self.psd_ydata = {}         # psd amplitude {1:ndarray}
         self.merged_timehistory_xdata = {}
         self.merged_timehistory_ydata = {}
@@ -200,6 +203,11 @@ class Model():
         self.data_queue = pyqueue.Queue(maxsize=5000)
         self.speed_bytes = {}
         self.node_fs = {}
+        self.node_fs_known = {}
+        self.psd_base_nfft = 1024
+        self.psd_min_nfft = 256
+        self.psd_max_nfft = 16384
+        self.psd_target_df = None
         self.speed_last_calc = datetime.datetime.now(datetime.timezone.utc)
         self.timespan_length = 30
         self._pps_count = 0
@@ -233,6 +241,7 @@ class Model():
         self.parse_node_nums_txt() 
         self.init_mesh_status_data()
         self.init_other_data()
+        self._apply_sampling_rate_from_status()
         
         # Thread for framed connection reports
         self.conn_report_thread = threading.Thread(target=self._conn_report_worker, daemon=True)
@@ -341,10 +350,74 @@ class Model():
         if prev is not None and abs(prev - fs) < 1e-6:
             return
         self.node_fs[node_id] = fs
+        self.node_fs_known[node_id] = True
         if node_id in self.resampler:
             self.resampler[node_id].set_fs(fs)
         if node_id in self.psder:
             self.psder[node_id].set_fs(fs)
+        self._recompute_psd_nfft()
+
+    def _compute_psd_target_df(self):
+        fs_values = [fs for node_id, fs in self.node_fs.items() if self.node_fs_known.get(node_id)]
+        if not fs_values:
+            return None
+        min_fs = min(fs_values)
+        if min_fs <= 0:
+            return None
+        return min_fs / float(self.psd_base_nfft)
+
+    def _choose_nfft(self, fs, target_df):
+        if target_df is None or target_df <= 0:
+            return self.psd_base_nfft
+        nfft = int(round(fs / target_df))
+        if nfft < self.psd_min_nfft:
+            nfft = self.psd_min_nfft
+        elif nfft > self.psd_max_nfft:
+            nfft = self.psd_max_nfft
+        return nfft
+
+    def _recompute_psd_nfft(self):
+        target_df = self._compute_psd_target_df()
+        if target_df is None:
+            return
+        if self.psd_target_df is None or abs(self.psd_target_df - target_df) > 1e-9:
+            self.psd_target_df = target_df
+            self._ui_log(
+                f"[psd] target df={target_df:.6f} Hz (base_nfft={self.psd_base_nfft})"
+            )
+        for node_id, fs in self.node_fs.items():
+            if not self.node_fs_known.get(node_id):
+                continue
+            nfft = self._choose_nfft(fs, target_df)
+            if self.psd_nfft.get(node_id) == nfft:
+                continue
+            self.psd_nfft[node_id] = nfft
+            self.psder[node_id] = psd_recursive.PSD_Recursive(nfft, fs)
+            self.psd_xdata.pop(node_id, None)
+            self.psd_ydata.pop(node_id, None)
+            df = fs / float(nfft)
+            self._ui_log(f"[psd] node={node_id} fs={fs:.3f} nfft={nfft} df={df:.6f} Hz")
+
+    def _update_observed_fs(self, node_id, ts_list):
+        if not ts_list or len(ts_list) < 2:
+            return
+        duration = (ts_list[-1] - ts_list[0]).total_seconds()
+        if duration <= 0:
+            return
+        fs_est = (len(ts_list) - 1) / duration
+        if fs_est <= 0:
+            return
+        fs_nom = self.node_fs.get(node_id)
+        if fs_nom:
+            ratio = fs_est / fs_nom
+            if ratio < 0.5 or ratio > 1.5:
+                return
+        prev = self.node_fs_obs.get(node_id)
+        if prev is None:
+            self.node_fs_obs[node_id] = fs_est
+        else:
+            alpha = 0.1
+            self.node_fs_obs[node_id] = prev * (1 - alpha) + fs_est * alpha
 
     def load_config(self):
         config = configparser.ConfigParser()
@@ -356,7 +429,19 @@ class Model():
                 'tmp_nums_txt': '[]',
                 'str_nums_txt': '[]',
                 'veh_nums_txt': '[]',
-                'option2': 'default_value2'
+                'option2': 'default_value2',
+                'log_file_pps': 'true',
+                'log_file_conn_rpt': 'true',
+                'log_terminal_pps': 'true',
+                'log_terminal_conn_rpt': 'false',
+                'plot_channel_x': 'false',
+                'plot_channel_y': 'true',
+                'plot_channel_z': 'false',
+                'plot_timespan': '30',
+                'plot_time_y_auto': 'false',
+                'plot_time_ylim': '[-2.0, 2.0]',
+                'plot_psd_y_auto': 'false',
+                'plot_psd_ylim': '[1e-06, 10.0]',
             }
             return
 
@@ -367,7 +452,19 @@ class Model():
             'tmp_nums_txt': config.get('Settings', 'tmp_nums_txt', fallback='[]'),
             'str_nums_txt': config.get('Settings', 'str_nums_txt', fallback='[]'),
             'veh_nums_txt': config.get('Settings', 'veh_nums_txt', fallback='[]'),
-            'option2': config.get('Settings', 'option2', fallback='default_value2')
+            'option2': config.get('Settings', 'option2', fallback='default_value2'),
+            'log_file_pps': config.get('Logging', 'file_pps', fallback='true'),
+            'log_file_conn_rpt': config.get('Logging', 'file_conn_rpt', fallback='true'),
+            'log_terminal_pps': config.get('Logging', 'terminal_pps', fallback='true'),
+            'log_terminal_conn_rpt': config.get('Logging', 'terminal_conn_rpt', fallback='false'),
+            'plot_channel_x': config.get('Plot', 'channel_x', fallback='false'),
+            'plot_channel_y': config.get('Plot', 'channel_y', fallback='true'),
+            'plot_channel_z': config.get('Plot', 'channel_z', fallback='false'),
+            'plot_timespan': config.get('Plot', 'timespan', fallback='30'),
+            'plot_time_y_auto': config.get('Plot', 'time_y_auto', fallback='false'),
+            'plot_time_ylim': config.get('Plot', 'time_ylim', fallback='[-2.0, 2.0]'),
+            'plot_psd_y_auto': config.get('Plot', 'psd_y_auto', fallback='false'),
+            'plot_psd_ylim': config.get('Plot', 'psd_ylim', fallback='[1e-06, 10.0]'),
         }
         
     def save_config(self):
@@ -381,6 +478,22 @@ class Model():
             'veh_nums_txt': self.options['veh_nums_txt'],
             'option2': self.options['option2']
         }
+        config['Logging'] = {
+            'file_pps': self.options.get('log_file_pps', 'true'),
+            'file_conn_rpt': self.options.get('log_file_conn_rpt', 'true'),
+            'terminal_pps': self.options.get('log_terminal_pps', 'true'),
+            'terminal_conn_rpt': self.options.get('log_terminal_conn_rpt', 'false'),
+        }
+        config['Plot'] = {
+            'channel_x': self.options.get('plot_channel_x', 'false'),
+            'channel_y': self.options.get('plot_channel_y', 'true'),
+            'channel_z': self.options.get('plot_channel_z', 'false'),
+            'timespan': self.options.get('plot_timespan', '30'),
+            'time_y_auto': self.options.get('plot_time_y_auto', 'false'),
+            'time_ylim': self.options.get('plot_time_ylim', '[-2.0, 2.0]'),
+            'psd_y_auto': self.options.get('plot_psd_y_auto', 'false'),
+            'psd_ylim': self.options.get('plot_psd_ylim', '[1e-06, 10.0]'),
+        }
 
         with open(CONFIG_FILE, 'w') as configfile:
             config.write(configfile)
@@ -451,6 +564,7 @@ class Model():
                                         RSSI_COL:[''], 
                                         'Children':[''],
                                         PPS_COL:[''], 
+                                        BAT_COL:[''],
                                         'CMD':[''],
                                         #'Children_nodeIDs': [''],
                                         'PPS-time':[''],
@@ -478,7 +592,7 @@ class Model():
         self.full_range_xlim = []
         self.merge_full_range = False
         self.psder.clear()
-        self.psd_xdata = []
+        self.psd_xdata = {}
         self.psd_ydata.clear()
         self.speed_bytes = {}
         self.speed_last_value = {}
@@ -486,6 +600,9 @@ class Model():
         self.speed_hist = {}
         self.speed_window_sec = 5.0
         self.speed_last_calc = datetime.datetime.now(datetime.timezone.utc)
+        self.node_fs_obs = {}
+        self.psd_nfft = {}
+        self.node_fs_known = {}
 
         for index, row in self.mesh_status_data.iterrows():
             nodeID = row['nodeID']
@@ -496,14 +613,26 @@ class Model():
             self.resampler[nodeID] = resampling.Resampling(50)            
             self.psder[nodeID] = psd_recursive.PSD_Recursive(1024, 50)
             self.node_fs[nodeID] = 50
+            self.node_fs_obs[nodeID] = None
+            self.psd_nfft[nodeID] = 1024
+            self.node_fs_known[nodeID] = False
             self.speed_bytes[nodeID] = 0
             self.speed_last_value[nodeID] = None
             self.speed_last_rx[nodeID] = None
             self.speed_hist[nodeID] = deque()
             self.pps_flash_until[nodeID] = None
+
+    def _apply_sampling_rate_from_status(self):
+        for _, row in self.mesh_status_data.iterrows():
+            node_id = row.get("nodeID") or row.get("Node ID")
+            if not node_id:
+                continue
+            fs = self._extract_fs_from_daq_label(row.get("DAQ Mode", ""))
+            if fs:
+                self._update_sampling_rate(node_id, fs)
     
 
-    def enqueue_conn_report(self, nodeID, level, parent_mac, self_mac, rssi, acc_model: int = 0, daq_mode: int = 0, daq_on: int = 0, stream_status: int = 0, notify: bool = False):
+    def enqueue_conn_report(self, nodeID, level, parent_mac, self_mac, rssi, acc_model: int = 0, daq_mode: int = 0, daq_on: int = 0, stream_status: int = 0, bat_vol: float | None = None, notify: bool = False):
         try:
             self.conn_report_queue.put_nowait(
                 {
@@ -516,6 +645,7 @@ class Model():
                     "daq_mode": daq_mode,
                     "daq_on": daq_on,
                     "stream_status": stream_status,
+                    "bat_vol": bat_vol,
                     "notify": notify,
                 }
             )
@@ -535,6 +665,7 @@ class Model():
                 daq_mode=item.get("daq_mode", 0),
                 daq_on=item.get("daq_on", 0),
                 stream_status=item.get("stream_status", 0),
+                bat_vol=item.get("bat_vol"),
                 notify=item["notify"],
             )
 
@@ -643,6 +774,7 @@ class Model():
             ts_, ys = self.timestamper[nodeID].push_cc_pps(cc, epoch_time)
             ts = self._time_delay_correction(ts_, node_number)
             if len(ts) > 0:
+                self._update_observed_fs(nodeID, ts)
                 self._ts_count += len(ts)
                 self.plot_dirty = True
                 self.plot_dirty_version += 1
@@ -669,7 +801,11 @@ class Model():
 
                     if self.psder[nodeID].isUpdated:
                         f, asd = self.psder[nodeID].get_asd()
-                        self.psd_xdata = f
+                        fs_nom = self.node_fs.get(nodeID)
+                        fs_obs = self.node_fs_obs.get(nodeID)
+                        if fs_nom and fs_obs:
+                            f = f * (fs_obs / fs_nom)
+                        self.psd_xdata[nodeID] = f
                         self.psd_ydata[nodeID] = asd
         except (OSError, OverflowError, ValueError):
             pass
@@ -699,6 +835,7 @@ class Model():
             RSSI_COL: [''],
             'Children': [''],
             PPS_COL: [''],
+            BAT_COL: [''],
             'CMD': [''],
             'PPS-time': [''],
             'PPS-flash-time': [''],
@@ -774,6 +911,7 @@ class Model():
                                 ts_list, ys = self.timestamper[node_id].push_cc_pps(cc, epoch)
                                 ts_list = self._time_delay_correction(ts_list, node_number)
                                 if ts_list:
+                                    self._update_observed_fs(node_id, ts_list)
                                     with self.plot_mutex[node_id]:
                                         self.timehistory_xdata[node_id] += ts_list
                                         self.timehistory_ydata[node_id] = append(
@@ -791,7 +929,11 @@ class Model():
                                             self.psder[node_id].push(array(yrs), array(trs))
                                             if self.psder[node_id].isUpdated:
                                                 f, asd = self.psder[node_id].get_asd()
-                                                self.psd_xdata = f
+                                                fs_nom = self.node_fs.get(node_id)
+                                                fs_obs = self.node_fs_obs.get(node_id)
+                                                if fs_nom and fs_obs:
+                                                    f = f * (fs_obs / fs_nom)
+                                                self.psd_xdata[node_id] = f
                                                 self.psd_ydata[node_id] = asd
                                     if min_ts is None or ts_list[0] < min_ts:
                                         min_ts = ts_list[0]
@@ -992,7 +1134,7 @@ class Model():
         self_mac[5] += 1
         return self_mac == parent_mac
 
-    def handle_conn_report(self, nodeID, level, parent_mac, self_mac, rssi, acc_model: int = 0, daq_mode: int = 0, daq_on: int = 0, stream_status: int = 0, notify: bool = True):
+    def handle_conn_report(self, nodeID, level, parent_mac, self_mac, rssi, acc_model: int = 0, daq_mode: int = 0, daq_on: int = 0, stream_status: int = 0, bat_vol: float | None = None, notify: bool = True):
         logger.info('Conn Rpt: L={}, par_MAC={}, self_MAC={}, RSSI={}'.format(level, parent_mac, self_mac, rssi))
 
         condition = self._node_condition(nodeID)
@@ -1020,6 +1162,11 @@ class Model():
             "DAQ": daq_status,
             "Stream": stream_label,
         }
+        if bat_vol is not None:
+            try:
+                fields[BAT_COL] = f"{float(bat_vol):3.1f}"
+            except (TypeError, ValueError):
+                pass
         if initial_connect:
             fields[SPEED_COL] = "0.0"
         self._set_node_fields(
@@ -1088,6 +1235,7 @@ class Model():
                             "Parent",
                             RSSI_COL,
                             "Children",
+                            BAT_COL,
                             "CMD",
                         ]:
                             if col in self.mesh_status_data.columns:
@@ -1358,7 +1506,11 @@ class Model():
     def _set_node_fields(self, nodeID, mark_dirty: bool = True, **fields):
         condition = self._node_condition(nodeID)
         if condition is None:
-            return False
+            # Ensure late-arriving nodes (e.g., PPS before status) get a row.
+            self._ensure_node_row(nodeID)
+            condition = self._node_condition(nodeID)
+            if condition is None:
+                return False
         for column, value in fields.items():
             self.mesh_status_data.loc[condition, column] = value
         status = self.node_status.get(nodeID)

enode_host/protocol.py

@@ -27,6 +27,7 @@ class CommandId(enum.IntEnum):
     STOP_SD_STREAM = 0x09
     SD_CLEAR = 0x0A
     SET_DAQ_MODE = 0x0B
+    SHUTDOWN = 0x0C
 
 
 class Mode(enum.IntEnum):
@@ -51,6 +52,7 @@ class StatusReport:
     daq_mode: int = 0
     daq_on: int = 0
     stream_status: int = 0
+    bat_vol: Optional[float] = None
 
 
 @dataclass
@@ -154,7 +156,7 @@ def build_set_daq_mode(mode: int) -> bytes:
 
 
 def parse_status(payload: bytes) -> StatusReport:
-    if len(payload) not in (16, 18, 19, 20):
+    if len(payload) not in (16, 18, 19, 20, 24):
         raise ValueError(f"invalid status payload length {len(payload)}")
     node_type = payload[0]
     node_number = payload[1]
@@ -166,6 +168,9 @@ def parse_status(payload: bytes) -> StatusReport:
     daq_mode = payload[17] if len(payload) >= 18 else 0
     daq_on = payload[18] if len(payload) >= 19 else 0
     stream_status = payload[19] if len(payload) >= 20 else 0
+    bat_vol = None
+    if len(payload) >= 24:
+        bat_vol = struct.unpack(">f", payload[20:24])[0]
     return StatusReport(
         node_type=node_type,
         node_number=node_number,
@@ -177,6 +182,7 @@ def parse_status(payload: bytes) -> StatusReport:
         daq_mode=daq_mode,
         daq_on=daq_on,
         stream_status=stream_status,
+        bat_vol=bat_vol,
     )
 
 
@@ -295,6 +301,10 @@ def build_stop_daq() -> bytes:
     return build_command(CommandId.STOP_DAQ)
 
 
+def build_shutdown() -> bytes:
+    return build_command(CommandId.SHUTDOWN)
+
+
 def build_realtime_stream(toggle: Toggle) -> bytes:
     command_id = (
         CommandId.START_REALTIME_STREAM if toggle == Toggle.START else CommandId.STOP_REALTIME_STREAM