Merge pull request #15 from Western-Formula-Racing/dev-frontend-can-processing

Implement Telemetry DataStore with rolling window and React hooks

Author: haoruizhou

.gitignore

@@ -15,6 +15,7 @@ downloads/
 eggs/
 .eggs/
 lib/
+!pecan/Frontend/pecan-live-dashboard/src/lib/
 lib64/
 parts/
 sdist/
@@ -221,3 +222,4 @@ ENV/
 
 .idea/workspace.xml
 /.idea
+node_modules/

README.md

@@ -49,6 +49,56 @@ daq-radio/
 - Transmits data to base station
 - Supports both real CAN hardware and CSV simulation
 
+### WebSocket Service Architecture
+
+The frontend uses a **centralized WebSocket service** that runs independently of any component, ensuring continuous data flow across all pages.
+
+#### Location
+```
+pecan/Frontend/pecan-live-dashboard/src/
+├── services/
+│   └── WebSocketService.ts    # WebSocket connection manager
+├── App.tsx                     # Service initialization
+└── pages/
+    └── Dashboard.tsx          # Displays data from DataStore
+```
+
+#### How It Works
+
+**1. Service Initialization (App.tsx)**
+- WebSocketService starts when the app mounts
+- Connects to ESP32 WebSocket server
+- Initializes CAN processor with DBC file
+- Stays active during entire app session
+
+**2. Message Processing (WebSocketService.ts)**
+```
+WebSocket Message → CAN Processor → DataStore → React Components
+```
+
+**3. Automatic Reconnection**
+- Up to 5 reconnection attempts on disconnect
+- Linear backoff delay (2s, 4s, 6s, 8s, 10s) TODO: maybe change to exponential 
+- Seamless recovery from network issues
+
+**4. Component Updates**
+- Components use DataStore hooks to access data
+- No WebSocket logic in display components
+- Clean separation of concerns
+
+#### Benefits
+- **Persistent Connection**: WebSocket stays alive across page navigation
+- **Centralized Management**: Single point of control for all telemetry data
+- **Automatic Recovery**: Handles disconnections gracefully
+- **Simpler Components**: Pages focus on display, not data fetching
+- **Scalability**: Multiple pages can show live data without multiple connections
+
+#### Development URL
+```
+Development:  ws://localhost:8080/ws
+Production:   ws://192.168.4.1:8080/ws  (ESP32 Access Point)
+```
+
 ### SavvyCAN Integration
 - Real-time CAN monitoring and analysis
 - UDP forwarding on port 12347

car-simulate/post.py

@@ -1,3 +1,4 @@
+# DEPRECATED (moving to websocket)
 import requests
 import time
 import json

car-simulate/websocket_sender.py

@@ -0,0 +1,89 @@
+import asyncio
+import websockets
+import json
+import csv
+import os
+import time
+
+# WebSocket server URL
+WS_URL = 'ws://localhost:8080/ws'
+
+# Path to the CAN data file (CSV format: timestamp,CAN,canId,data1,data2,data3,data4,data5,data6,data7,data8)
+DATA_FILE = '2025-10-04-09-50-03.csv'  # Replace with the exact filename if different
+
+def load_can_data(file_path):
+    """Load CAN data from CSV file and format as JSON objects."""
+    data = []
+    if not os.path.exists(file_path):
+        print(f"Error: File {file_path} not found.")
+        return data
+    
+    with open(file_path, 'r') as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if len(row) < 11 or row[1] != 'CAN':
+                continue  # Skip invalid rows
+            try:
+                message = {
+                    'time': int(row[0]),
+                    'canId': int(row[2]),
+                    'data': [int(x) for x in row[3:11]]  # 8 data bytes
+                }
+                data.append(message)
+            except ValueError as e:
+                print(f"Skipping invalid row: {row} - {e}")
+    return data
+
+async def send_batch_websocket(websocket, batch):
+    """Send a batch of CAN messages via WebSocket."""
+    try:
+        message = json.dumps(batch)
+        await websocket.send(message)
+        print(f"Sent {len(batch)} messages successfully via WebSocket.")
+    except Exception as e:
+        print(f"Failed to send batch: {e}")
+        raise
+
+async def main():
+    can_data = load_can_data(DATA_FILE)
+    if not can_data:
+        print("No CAN data loaded. Exiting.")
+        return
+
+    batch_size = 100
+    interval = 1 / 5  # 5 Hz = 0.2 seconds
+
+    try:
+        # Connect to WebSocket server
+        print(f"Connecting to WebSocket server at {WS_URL}...")
+        async with websockets.connect(WS_URL) as websocket:
+            print("Connected successfully!")
+            
+            index = 0
+            while True:
+                # Get the next batch of 100 messages, wrapping around if necessary
+                batch = can_data[index:index + batch_size]
+                if len(batch) < batch_size:
+                    # If not enough, take from the start
+                    batch += can_data[:batch_size - len(batch)]
+                
+                await send_batch_websocket(websocket, batch)
+                index = (index + batch_size) % len(can_data)
+                
+                # Wait for the interval
+                await asyncio.sleep(interval)
+                
+    except websockets.exceptions.ConnectionClosed:
+        print("WebSocket connection closed.")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == '__main__':
+    # Install required package: pip install websockets
+    try:
+        import websockets
+    except ImportError:
+        print("Please install websockets package: pip install websockets")
+        exit(1)
+    
+    asyncio.run(main())