enode-host 0.1.0__tar.gz

enode_host-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: enode-host
+Version: 0.1.0
+Summary: Host-side tools that interact with the ESP-IDF firmware.
+Author: eNode team
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt5>=5.15
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: pandas>=2.2
+
+# Host Python Tools
+
+This folder contains host-side Python code that interacts with the ESP-IDF
+firmware (e.g., over serial, sockets, or file exchange). It is kept separate
+from the firmware build to avoid mixing tool dependencies with ESP-IDF.
+
+## Quick start
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+
+enode-host --help
+enode-host socket 127.0.0.1 3333 "hello"
+enode-host server --port 3333 --interactive
+enode-host gui --port 3333
+```
+
+## Notes
+
+- Add runtime dependencies to `pyproject.toml` under `project.dependencies`.
+- Keep device/transport details in small modules so they can be shared by
+  scripts and tests.
+- The GUI uses wxPython; install it if you plan to run `enode-host gui`.
+
+## Protocol (TCP, length-prefixed)
+
+Frame format: 1 byte message type, 2 bytes big-endian payload length, payload.
+
+Message types:
+- 0x10 COMMAND (host -> device)
+- 0x20 STATUS (device -> host)
+- 0x30 ACK (either direction)
+- 0x40 DATA (device -> host, ACC batch)
+- 0x41 PPS (device -> host, immediate PPS)
+
+Commands (payload begins with command_id):
+- 0x01 start_daq
+- 0x02 stop_daq
+- 0x03 set_mode (1 byte: 0 realtime, 1 past)
+- 0x04 start_realtime_stream
+- 0x05 stop_realtime_stream
+- 0x06 start_past_stream (payload: 8-byte start_ms, 8-byte end_ms)
+- 0x07 stop_past_stream
+
+Status payload (16 bytes):
+- node_type: uint8
+- node_number: uint8
+- level: uint8
+- parent_mac: 6 bytes
+- self_mac: 6 bytes
+- rssi: int8
+
+DATA payload:
+- node_type: uint8
+- node_number: uint8
+- sample_count: uint8
+- repeated samples (count):
+  - cc: uint64 (big-endian)
+  - acc_x: float32 (big-endian)
+  - acc_y: float32 (big-endian)
+  - acc_z: float32 (big-endian)
+
+PPS payload:
+- node_type: uint8
+- node_number: uint8
+- cc: uint64 (big-endian)
+- epoch: int64 (big-endian)

enode_host-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Host Python Tools
+
+This folder contains host-side Python code that interacts with the ESP-IDF
+firmware (e.g., over serial, sockets, or file exchange). It is kept separate
+from the firmware build to avoid mixing tool dependencies with ESP-IDF.
+
+## Quick start
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+
+enode-host --help
+enode-host socket 127.0.0.1 3333 "hello"
+enode-host server --port 3333 --interactive
+enode-host gui --port 3333
+```
+
+## Notes
+
+- Add runtime dependencies to `pyproject.toml` under `project.dependencies`.
+- Keep device/transport details in small modules so they can be shared by
+  scripts and tests.
+- The GUI uses wxPython; install it if you plan to run `enode-host gui`.
+
+## Protocol (TCP, length-prefixed)
+
+Frame format: 1 byte message type, 2 bytes big-endian payload length, payload.
+
+Message types:
+- 0x10 COMMAND (host -> device)
+- 0x20 STATUS (device -> host)
+- 0x30 ACK (either direction)
+- 0x40 DATA (device -> host, ACC batch)
+- 0x41 PPS (device -> host, immediate PPS)
+
+Commands (payload begins with command_id):
+- 0x01 start_daq
+- 0x02 stop_daq
+- 0x03 set_mode (1 byte: 0 realtime, 1 past)
+- 0x04 start_realtime_stream
+- 0x05 stop_realtime_stream
+- 0x06 start_past_stream (payload: 8-byte start_ms, 8-byte end_ms)
+- 0x07 stop_past_stream
+
+Status payload (16 bytes):
+- node_type: uint8
+- node_number: uint8
+- level: uint8
+- parent_mac: 6 bytes
+- self_mac: 6 bytes
+- rssi: int8
+
+DATA payload:
+- node_type: uint8
+- node_number: uint8
+- sample_count: uint8
+- repeated samples (count):
+  - cc: uint64 (big-endian)
+  - acc_x: float32 (big-endian)
+  - acc_y: float32 (big-endian)
+  - acc_z: float32 (big-endian)
+
+PPS payload:
+- node_type: uint8
+- node_number: uint8
+- cc: uint64 (big-endian)
+- epoch: int64 (big-endian)

enode_host-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "enode-host"
+version = "0.1.0"
+description = "Host-side tools that interact with the ESP-IDF firmware."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+  {name = "eNode team"}
+]
+dependencies = [
+  "PyQt5>=5.15",
+  "matplotlib>=3.8",
+  "pandas>=2.2",
+]
+
+[project.scripts]
+enode-host = "enode_host.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

enode_host-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enode_host-0.1.0/src/enode_host/__init__.py

@@ -0,0 +1 @@
+"""Host-side utilities for interacting with the ESP-IDF firmware."""

enode_host-0.1.0/src/enode_host/async_socket.py

@@ -0,0 +1,165 @@
+import asyncio
+import struct
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+from .protocol import (
+    MsgType,
+    build_ack,
+    format_mac,
+    parse_acc_batch,
+    parse_pps,
+    parse_sd_chunk,
+    parse_sd_done,
+    parse_status,
+)
+
+
+@dataclass
+class SocketResponse:
+    payload: bytes
+
+
+async def send_message(host: str, port: int, payload: bytes, timeout: float = 5.0) -> SocketResponse:
+    reader: asyncio.StreamReader
+    writer: asyncio.StreamWriter
+
+    try:
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(host, port), timeout=timeout
+        )
+    except asyncio.TimeoutError as exc:
+        raise TimeoutError(f"Timed out connecting to {host}:{port}") from exc
+
+    try:
+        writer.write(payload)
+        await writer.drain()
+        data = await asyncio.wait_for(reader.read(4096), timeout=timeout)
+        return SocketResponse(payload=data)
+    finally:
+        writer.close()
+        await writer.wait_closed()
+
+
+def run_client(host: str, port: int, message: str, timeout: float) -> int:
+    payload = message.encode("utf-8")
+    response = asyncio.run(send_message(host, port, payload, timeout))
+    if response.payload:
+        print(response.payload.decode("utf-8", errors="replace"))
+    return 0
+
+
+async def read_frame(reader: asyncio.StreamReader) -> Optional[tuple[int, bytes]]:
+    header = await reader.readexactly(3)
+    msg_type, length = struct.unpack(">BH", header)
+    if length == 0:
+        return msg_type, b""
+    payload = await reader.readexactly(length)
+    return msg_type, payload
+
+
+async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, clients: Dict[str, asyncio.StreamWriter]) -> None:
+    peer = writer.get_extra_info("peername")
+    peer_id = f"{peer[0]}:{peer[1]}" if peer else "unknown"
+    clients[peer_id] = writer
+    print(f"[server] connected {peer_id} (clients={len(clients)})")
+
+    try:
+        while True:
+            msg_type, payload = await read_frame(reader)
+            if msg_type == MsgType.STATUS:
+                status = parse_status(payload)
+                print(
+                    "[status] "
+                    f"node={status.node_type}:{status.node_number} "
+                    f"level={status.level} "
+                    f"parent={format_mac(status.parent_mac)} "
+                    f"self={format_mac(status.self_mac)} "
+                    f"rssi={status.rssi}"
+                )
+                writer.write(build_ack(MsgType.STATUS, 0, "ok"))
+                await writer.drain()
+            elif msg_type == MsgType.DATA:
+                batch = parse_acc_batch(payload)
+                print(f"[data] node={batch.node_type}:{batch.node_number} samples={len(batch.samples)}")
+                writer.write(build_ack(MsgType.DATA, 0, "ok"))
+                await writer.drain()
+            elif msg_type == MsgType.PPS:
+                pps = parse_pps(payload)
+                print(f"[pps] node={pps.node_type}:{pps.node_number} cc={pps.cc} epoch={pps.epoch}")
+                writer.write(build_ack(MsgType.PPS, 0, "ok"))
+                await writer.drain()
+            elif msg_type == MsgType.SD_STREAM:
+                chunk = parse_sd_chunk(payload)
+                print(
+                    f"[sd] node={chunk.node_type}:{chunk.node_number} "
+                    f"file_time={chunk.file_time} offset={chunk.offset} size={len(chunk.data)}"
+                )
+                writer.write(build_ack(MsgType.SD_STREAM, 0, "ok"))
+                await writer.drain()
+            elif msg_type == MsgType.SD_DONE:
+                done = parse_sd_done(payload)
+                print(
+                    f"[sd] node={done.node_type}:{done.node_number} "
+                    f"file_time={done.file_time} status={done.status}"
+                )
+                writer.write(build_ack(MsgType.SD_DONE, 0, "ok"))
+                await writer.drain()
+            else:
+                print(f"[server] msg_type=0x{msg_type:02X} len={len(payload)}")
+                writer.write(build_ack(msg_type, 0, "ok"))
+                await writer.drain()
+    except asyncio.IncompleteReadError:
+        pass
+    finally:
+        clients.pop(peer_id, None)
+        writer.close()
+        await writer.wait_closed()
+        print(f"[server] disconnected {peer_id} (clients={len(clients)})")
+
+
+async def broadcast_messages(
+    queue: asyncio.Queue[bytes],
+    clients: Dict[str, asyncio.StreamWriter],
+) -> None:
+    while True:
+        payload = await queue.get()
+        if not clients:
+            print("[server] no clients to broadcast to")
+            continue
+        for peer_id, writer in list(clients.items()):
+            try:
+                writer.write(payload)
+                await writer.drain()
+            except ConnectionError:
+                clients.pop(peer_id, None)
+        print(f"[server] broadcast to {len(clients)} clients")
+
+
+async def run_server(
+    host: str,
+    port: int,
+    on_connect_payload: Optional[bytes],
+    command_queue: Optional[asyncio.Queue[bytes]] = None,
+) -> None:
+    clients: Dict[str, asyncio.StreamWriter] = {}
+
+    async def _client_handler(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        if on_connect_payload:
+            writer.write(on_connect_payload)
+            await writer.drain()
+        await handle_client(reader, writer, clients)
+
+    server = await asyncio.start_server(_client_handler, host=host, port=port)
+    addrs = ", ".join(str(sock.getsockname()) for sock in server.sockets or [])
+    print(f"[server] listening on {addrs}")
+
+    async with server:
+        if command_queue is None:
+            await server.serve_forever()
+        else:
+            broadcaster = asyncio.create_task(broadcast_messages(command_queue, clients))
+            try:
+                await server.serve_forever()
+            finally:
+                broadcaster.cancel()

enode_host-0.1.0/src/enode_host/backup/c-wing3.py

@@ -0,0 +1,226 @@
+#!/usr/local/bin/python3
+
+#----------------------------------------------
+# NOTE 
+# 1. Ask Ki about the definition of local axes for M352, or see the line # 397 of model.py
+#    when you look at the screen of the node, 
+#        the direction to the left hand-side is the X-axis
+#        the downward direction is the Y-axis
+#        the direction perpendicular to the screen and coming towards yourself is Z-axis
+#
+#    this is the right-hand rule: 
+#        the direction of you index finger is the x-axis, 
+#        that of the middle finger is the y-axis
+#        that of the thumb is the z-axis
+#
+#---------------------------------------------  
+# HOW TO USE THE SYSTEM
+#
+# 1. please execute this file first, so that the server is ready to receive data from ndoes
+# 2. turn on the node(s)
+#    - the PPS LED on the display can be believed
+#    - please don't believe RSSI, Lv, BAT %, as they are not completed yet.
+# 3. Files are saved under data2 folder in HDF 
+# 4. Please read example.ipynb for how to load data file and display it
+#    - Please notice the time is in UTC to avoid any issues regarding British Summer Time
+# 5. For time-sync, never reset the acc node, but power-cycle it. 
+#    - there are two buttons on the sensor node: 
+#      - one for power next to the USB-c port
+#      - the other for reset next to the SD slot
+#    - pressing the pwr button for 5 sec will shutdown the node, and pressing it for 1 sec will start the node
+
+
+
+import wx
+import view
+import model
+import importlib
+importlib.reload(view)
+importlib.reload(model)
+
+import logging
+import threading
+import queues
+from numpy import array
+import shm_sigproc
+import glob
+import os 
+import esp_mesh
+import pandas as pd 
+from model import CmdType, ChannelType
+from enum import IntEnum
+
+os.remove('log/my_log_file.log')
+
+logging.basicConfig(level=logging.INFO,  # Set the minimum log level
+                    #format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    format='%(name)s - %(levelname)s - %(message)s',
+                    handlers=[logging.FileHandler('log/my_log_file.log'), logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+
+os.makedirs("raw-data", exist_ok = True)
+
+
+class CMD_TYPE(IntEnum):
+    SET_MODE = 0
+    CLEAR_STORAGE = 1 
+    NOTIFY_PARENT = 2
+    NOTIFY_CHILDREN = 3
+    SHUTDOWN = 4
+
+class OPERATION_MODE(IntEnum):
+    ONLINE_DAQ = 0
+    STANDALONE_DATA_PEEKING = 1
+    POST_DAQ_DATA_STREAMING = 2
+    MAINTENANCE = 3
+
+class Controller:
+
+    def __init__(self):
+
+        self.model = model.Model(self)
+        self.view = view.View(self)
+        self.view.Show()
+        self.mesh = esp_mesh.Esp_Mesh(self.model)
+
+        # mesh.begin()
+        # shm_sigproc.begin()
+
+        #
+        # BINDINGS
+        #
+        
+        # node_num_txt
+        self.view.m_textCtrl2.Bind(wx.EVT_TEXT, self.on_change_node_nums)
+
+        # Menu File>Exit
+        self.view.Bind(wx.EVT_MENU, self.on_exit, self.view.m_menu_file_quit)
+        
+        # Menu Data>Export
+        self.view.Bind(wx.EVT_MENU, self.on_data_export, self.view.m_menu_data_export)
+        
+        # Menu CMD>SD clear
+        self.view.Bind(wx.EVT_MENU, self.on_cmd_sdclear, self.view.m_menu_cmd_sdclear)
+        
+        # Menu CMD>Shutdown
+        self.view.Bind(wx.EVT_MENU, self.on_cmd_shutdown, self.view.m_menu_cmd_shutdown)
+        
+        # Menu Tool>clf
+        self.view.Bind(wx.EVT_MENU, self.on_view_clf, self.view.m_menu_view_clf)
+        
+        # Start DAQ Button
+        self.view.m_button1.Bind(wx.EVT_BUTTON, self.Start_Button_onclick)
+        
+        # Stop DAQ Button
+        self.view.m_button2.Bind(wx.EVT_BUTTON, self.Stop_Button_onclick)
+
+        # 
+        self.view.m_choice_OperationMode.Bind(wx.EVT_CHOICE, self.choice_OperationMode_onchange)
+    
+    def on_change_node_nums(self, event):
+
+        self.model.options['node_nums_txt'] = self.view.m_textCtrl2.GetValue()
+        self.model.parse_node_nums_txt()
+        self.model.save_config()
+        self.model.init_mesh_status_data()
+        self.model.init_other_data()
+        self.view.mesh_status_data_view()
+        self.view.m_grid2.ForceRefresh()
+        # Init the time history and PSD plots
+        self.view.init_plot()
+        
+    def on_exit(self, event):
+        
+        self.view.Close()
+
+    def on_data_export(self, event):
+
+        self.model.export()
+
+    def Start_Button_onclick(self, event):
+        
+        map = {
+                OPERATION_MODE.ONLINE_DAQ: 1,
+                OPERATION_MODE.STANDALONE_DATA_PEEKING: 5,
+                OPERATION_MODE.POST_DAQ_DATA_STREAMING: 7,
+               }
+        operation_Mode = self.view.m_choice_OperationMode.GetSelection()
+        
+        self.model.init_other_data()            
+        self.view.init_plot()
+        self.view.figure_update()
+        for inode in self.mesh.sockets.keys():            
+            self.mesh.send_cmd(inode, CMD_TYPE.SET_MODE, data0 = map[operation_Mode])
+            self.model.update_mesh_status_data(inode, 'CMD', "sent")
+            self.view.table_update()
+        logger.info('command sent: {} start'.format(OPERATION_MODE(operation_Mode).name))
+
+    def Stop_Button_onclick(self, event):
+    
+        map = {
+                OPERATION_MODE.ONLINE_DAQ: 0,
+                OPERATION_MODE.STANDALONE_DATA_PEEKING: 4,
+                OPERATION_MODE.POST_DAQ_DATA_STREAMING: 2,
+               }        
+
+        operation_Mode = self.view.m_choice_OperationMode.GetSelection()
+        
+        for inode in self.mesh.sockets.keys():
+            self.mesh.send_cmd(inode, CMD_TYPE.SET_MODE, data0 = map[operation_Mode])
+            self.model.update_mesh_status_data(inode, 'CMD', "sent")
+            self.view.table_update()
+
+        logger.info('command sent: {} stop'.format(OPERATION_MODE(operation_Mode).name))
+        # self.view.gui_update(1)
+    
+    def choice_OperationMode_onchange(self, event):
+        operation_Mode = self.view.m_choice_OperationMode.GetSelection()
+        if operation_Mode == OPERATION_MODE.POST_DAQ_DATA_STREAMING:
+            for inode in self.mesh.sockets.keys():
+                self.mesh.send_cmd(inode, CMD_TYPE.SET_MODE, data0 = 2)
+                self.model.update_mesh_status_data(inode, 'CMD', "sent")
+                self.view.table_update()
+        
+        if operation_Mode == OPERATION_MODE.ONLINE_DAQ:
+            self.PPS_outdate_check = True
+        else:
+            self.PPS_outdate_check = False
+
+
+    def on_view_clf(self, event):
+        self.model.init_other_data()
+        self.view.init_plot()
+        self.view.figure_update()
+        return
+
+    def on_cmd_sdclear(self, event):
+
+        for inode in self.mesh.sockets.keys():            
+            self.mesh.send_cmd(inode, CMD_TYPE.CLEAR_STORAGE) 
+            self.model.update_mesh_status_data(inode, 'CMD', "sent")
+            self.view.table_update()
+        logger.info('command sent: SD Clear sent')
+
+    def on_cmd_shutdown(self, event):
+
+        for inode in self.mesh.sockets.keys():            
+            self.mesh.send_cmd(inode, CMD_TYPE.SHUTDOWN) 
+            self.model.update_mesh_status_data(inode, 'CMD', "sent")
+            self.view.table_update()
+        logger.info('command sent: SD Clear sent')
+
+        return
+
+    
+
+if __name__ == '__main__':
+    app = wx.App()
+    controller = Controller()
+    # controller.view.gui_update(1)
+    app.MainLoop()
+
+
+
+
+