enode-host 0.1.0__py3-none-any.whl

enode_host/storage.py

@@ -0,0 +1,93 @@
+from numpy import floor 
+import datetime 
+from pandas import DataFrame, to_datetime
+import time
+import copy
+import logging
+import os
+try:
+    from .constants import RT_STREAM_HD5_DIR
+except ImportError:
+    from constants import RT_STREAM_HD5_DIR
+import re
+
+logger = logging.getLogger(__name__)
+
+class Storage:
+    
+    def __init__(self, file_length_in_sec):
+        self.file_buf = {} 
+        # the buffer for file outputs 
+        # {
+        #   'acc1':{'t':[], 'y':[], 'last_gridTime':-1}, 
+        #   'acc2':{'t':[], 'y':[], 'last_gridTime':-1}, 
+        # }
+        self.file_length_in_sec = file_length_in_sec
+        self.tmp_length_in_sec = 24 * 60 * 60
+        os.makedirs(RT_STREAM_HD5_DIR, exist_ok=True)
+
+    def _length_for_node(self, nodeID):
+        if isinstance(nodeID, int):
+            return self.file_length_in_sec
+        match = re.match(r"([A-Za-z]+)", str(nodeID))
+        if match and match.group(1).upper() == "TMP":
+            return self.tmp_length_in_sec
+        return self.file_length_in_sec
+
+    def get_gridTime(self, t, nodeID):
+        length = self._length_for_node(nodeID)
+        return floor(t / length) * length
+    
+    def get_filepath(self, nodeID, t):
+        timestamp = datetime.datetime.fromtimestamp(t).strftime('%Y_%m%d_%H%M')
+        label = None
+        if isinstance(nodeID, int):
+            label = f"acc{nodeID:02d}"
+        else:
+            match = re.match(r"([A-Za-z]+)(\\d+)$", str(nodeID))
+            if match:
+                node_type = match.group(1).lower()
+                node_num = int(match.group(2))
+                label = f"{node_type}{node_num:02d}"
+            else:
+                label = str(nodeID).lower()
+        return os.path.join(RT_STREAM_HD5_DIR, f"{timestamp}-{label}.hd5")
+
+    def push(self, nodeID, t, y):
+        if not nodeID in self.file_buf.keys():
+            self.file_buf[nodeID] = {'last_gridTime': -1, 't':[], 'y':[]}
+        
+        for t_, y_ in zip(t, y):
+            current_gridTime = self.get_gridTime(t_.timestamp(), nodeID)
+            if self.file_buf[nodeID]['last_gridTime'] == -1:
+                self.file_buf[nodeID]['last_gridTime'] = current_gridTime
+            elif self.file_buf[nodeID]['last_gridTime'] != current_gridTime:
+                # Save to disk in HDF
+                df = DataFrame(self.file_buf[nodeID]['y'], columns = ['X', 'Y', 'Z'])
+                df.index = to_datetime(self.file_buf[nodeID]['t'])
+                filepath = self.get_filepath(nodeID, self.file_buf[nodeID]['last_gridTime'])
+                df.to_hdf(filepath, key='df', mode='w')
+                logger.info("file saved: {}".format(filepath))
+                # Reinitialise
+                self.file_buf[nodeID]['last_gridTime'] = copy.copy(current_gridTime)
+                self.file_buf[nodeID]['t'] = []
+                self.file_buf[nodeID]['y'] = []
+                
+            self.file_buf[nodeID]['t'].append(t_)
+            self.file_buf[nodeID]['y'].append(y_)
+
+
+
+if __name__ == '__main__':
+    import pandas as pd
+
+    t = [datetime.datetime(2024,1,1,0,i,j)  for i in range(3) for j in range(60)]    
+    y = [[i,2*i,3*i] for i in range(180)]
+    storage = Storage(60)
+    i = 0
+    # t[60*i:60*(i+1)]
+    # y[60*i:60*(i+1)]
+    for i in range(3):
+        storage.push(1, t[60*i:60*(i+1)], y[60*i:60*(i+1)])
+    
+    

enode_host/timestamping.py

@@ -0,0 +1,79 @@
+from numpy import empty, append, array, where, logical_and, delete
+from scipy.interpolate import interp1d
+try:
+    from . import config
+except ImportError:
+    import config
+import struct
+import datetime
+
+class Timestamping():
+     
+    def __init__(self):
+
+        self.CC_ppsEpoch = empty((0, 2), dtype = float)   # array( [[cc0, epoch_PPS0], [cc1, epoch_PPS1]] )
+        self.CC_ACC = empty((0, 4), dtype = float)        # array( [[cc, acc_x, acc_y, acc_z], ...])
+
+    def push_cc_acc(self, cc_acc):
+
+        # only add when it is a new data
+        if self.CC_ppsEpoch.shape[0] > 1 and cc_acc[0] > self.CC_ppsEpoch[1, 0]:
+            self.CC_ACC = append(self.CC_ACC, array([cc_acc]), axis=0) # CC, acc_x, acc_y, acc_z
+    
+    def push_cc_pps(self, CC, epoch_time):
+
+        # Populating CC_ppsEpoch Table
+        self.CC_ppsEpoch = append(self.CC_ppsEpoch, array([[CC, epoch_time]]), axis = 0)
+        if len(self.CC_ppsEpoch) == 1:
+            return [], []
+        elif len(self.CC_ppsEpoch) == 3:
+            self.CC_ppsEpoch = self.CC_ppsEpoch[1:, :]  # shifting CC_ppsEpoch            
+        
+        # timestamping 
+        cc0 = self.CC_ppsEpoch[0, 0]
+        cc1 = self.CC_ppsEpoch[1, 0]
+        idx = where(logical_and(self.CC_ACC[:,0] >= cc0, self.CC_ACC[:,0] < cc1))
+        if len(idx[0]) > 0:
+            cc_acc = self.CC_ACC[idx[0], :]
+            linear_interp = interp1d(self.CC_ppsEpoch[:2, 0], self.CC_ppsEpoch[:2, 1], kind = 'linear')
+            x_interp = cc_acc[:, 0]
+            y_interp = linear_interp(x_interp)
+            t = []
+            for i in range(cc_acc.shape[0]):
+                epoch = int(y_interp[i])
+                suseconds = int((y_interp[i] - epoch) * 1e6)
+                t_ = datetime.datetime.fromtimestamp(epoch, tz=datetime.timezone.utc)
+                t_ = t_.replace(microsecond = suseconds)
+                t.append(t_)
+            y = cc_acc[:, 1:4]
+            # Delete already timestamped points
+            mask = self.CC_ACC[:, 0] >= cc1
+            self.CC_ACC = self.CC_ACC[mask,...]
+            return t, y
+            
+        return [], []
+    
+    
+
+    # rawFileLength_sec = config.rawFileLength_sec
+    # def getGridTime(self, epoch):
+    #     return int(epoch / rawFileLength_sec) * rawFileLength_sec
+    # # FILE SAVING 
+    # if 0:
+    #     if epoch_time > 0: 
+    #         if fid == -1:
+    #             latest_fileName = self.getFileName(streamID, epoch_time)
+    #             fid = open(latest_fileName, "wb")
+    #         elif self.getFileName(streamID, epoch_time) != latest_fileName:
+    #             fid.close()
+    #             latest_fileName = self.getFileName(streamID, epoch_time)
+    #             fid = open(latest_fileName, "wb")
+    #     if fid != -1:
+    #         fid.write(packet[2:])
+    # data = data[packet_size:]
+
+    # def getFileName(self, streamID, epoch_time):
+    #     nodeNumber = (streamID & 0x0FF0) >> 4
+    #     streamID_str = 'ACC{}-ACC'.format(nodeNumber)
+    #     t = datetime.datetime.fromtimestamp(epoch_time)
+    #     return os.path.join(target_dir, '{}-{}'.format(datetime.datetime.strftime(t, '%Y_%m%d_%H%M'), streamID_str))

enode_host/types.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+import datetime
+
+
+@dataclass
+class NodeStatus:
+    node_id: int
+    node_label: str
+    connection: str = "waiting"
+    speed_kb_s: float = 0.0
+    level: Optional[int] = None
+    parent: str = ""
+    rssi_db: Optional[int] = None
+    children: str = ""
+    pps_age: str = ""
+    cmd: str = ""
+    pps_time: Optional[datetime.datetime] = None
+    pps_flash_time: Optional[datetime.datetime] = None
+    daq_time: Optional[datetime.datetime] = None
+    parent_mac: Optional[str] = None
+    self_mac: Optional[str] = None
+    conn_rpt_time: Optional[datetime.datetime] = None
+
+
+@dataclass
+class PpsFlashState:
+    flash_until: Optional[datetime.datetime] = None
+
+
+@dataclass
+class PlotBuffers:
+    timehistory_xdata: List[datetime.datetime] = field(default_factory=list)
+    timehistory_ydata: List[List[float]] = field(default_factory=list)
+    psd_xdata: List[float] = field(default_factory=list)
+    psd_ydata: Dict[int, List[List[float]]] = field(default_factory=dict)