#!/usr/bin/env python3 """ WebSocket-based Raspberry Pi Telemetry Simulator. Connects to AI Intelligence Layer via WebSocket and: 1. Streams lap telemetry to AI layer 2. Receives control commands (brake_bias, differential_slip) from AI layer 3. Applies control adjustments in real-time Usage: python simulate_pi_websocket.py --interval 5 --ws-url ws://localhost:9000/ws/pi """ from __future__ import annotations import argparse import asyncio import json import logging from pathlib import Path from typing import Dict, Any, Optional import sys try: import pandas as pd import websockets from websockets.client import WebSocketClientProtocol except ImportError: print("Error: Required packages not installed.") print("Run: pip install pandas websockets") sys.exit(1) # Configure logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) logger = logging.getLogger(__name__) class PiSimulator: """WebSocket-based Pi simulator with control feedback.""" def __init__(self, csv_path: Path, ws_url: str, interval: float = 60.0, enrichment_url: str = "http://localhost:8000"): self.csv_path = csv_path self.ws_url = ws_url self.enrichment_url = enrichment_url self.interval = interval self.df: Optional[pd.DataFrame] = None self.current_controls = { "brake_bias": 5, "differential_slip": 5 } def load_lap_csv(self) -> pd.DataFrame: """Load lap-level CSV data.""" logger.info(f"Loading CSV from {self.csv_path}") df = pd.read_csv(self.csv_path) logger.info(f"Loaded {len(df)} laps") return df def lap_to_raw_payload(self, row: pd.Series) -> Dict[str, Any]: """ Convert CSV row to raw lap telemetry (for enrichment service). This is what the real Pi would send. """ return { "lap_number": int(row["lap_number"]), "total_laps": int(row["total_laps"]), "lap_time": str(row["lap_time"]), "average_speed": float(row["average_speed"]), "max_speed": float(row["max_speed"]), "tire_compound": str(row["tire_compound"]), "tire_life_laps": int(row["tire_life_laps"]), "track_temperature": float(row["track_temperature"]), "rainfall": bool(row.get("rainfall", False)) } async def enrich_telemetry(self, raw_telemetry: Dict[str, Any]) -> Dict[str, Any]: """ Send raw telemetry to enrichment service and get back enriched data. This simulates the Pi → Enrichment → AI flow. """ import aiohttp try: async with aiohttp.ClientSession() as session: async with session.post( f"{self.enrichment_url}/ingest/telemetry", json=raw_telemetry, timeout=aiohttp.ClientTimeout(total=5.0) ) as response: if response.status == 200: result = await response.json() logger.info(f" ✓ Enrichment service processed lap {raw_telemetry['lap_number']}") return result else: logger.error(f" ✗ Enrichment service error: {response.status}") return None except Exception as e: logger.error(f" ✗ Failed to connect to enrichment service: {e}") logger.error(f" Make sure enrichment service is running: python scripts/serve.py") return None def lap_to_enriched_payload(self, row: pd.Series) -> Dict[str, Any]: """ Convert CSV row to enriched telemetry payload. Simulates the enrichment layer output. """ # Basic enrichment simulation (would normally come from enrichment service) lap_number = int(row["lap_number"]) tire_age = int(row["tire_life_laps"]) # Simple tire degradation simulation tire_deg_rate = min(1.0, 0.02 * tire_age) tire_cliff_risk = max(0.0, min(1.0, (tire_age - 20) / 10.0)) # Pace trend (simplified) pace_trend = "stable" if tire_age > 25: pace_trend = "declining" elif tire_age < 5: pace_trend = "improving" # Optimal pit window if tire_age > 20: pit_window = [lap_number + 1, lap_number + 3] else: pit_window = [lap_number + 10, lap_number + 15] # Performance delta (random for simulation) import random performance_delta = random.uniform(-1.5, 1.0) enriched_telemetry = { "lap": lap_number, "tire_degradation_rate": round(tire_deg_rate, 3), "pace_trend": pace_trend, "tire_cliff_risk": round(tire_cliff_risk, 3), "optimal_pit_window": pit_window, "performance_delta": round(performance_delta, 2) } race_context = { "race_info": { "track_name": "Monza", "total_laps": int(row["total_laps"]), "current_lap": lap_number, "weather_condition": "Wet" if row.get("rainfall", False) else "Dry", "track_temp_celsius": float(row["track_temperature"]) }, "driver_state": { "driver_name": "Alonso", "current_position": 5, "current_tire_compound": str(row["tire_compound"]).lower(), "tire_age_laps": tire_age, "fuel_remaining_percent": max(0.0, 100.0 * (1.0 - (lap_number / int(row["total_laps"])))) }, "competitors": [] } return { "type": "telemetry", "lap_number": lap_number, "enriched_telemetry": enriched_telemetry, "race_context": race_context } async def stream_telemetry(self): """Main WebSocket streaming loop.""" self.df = self.load_lap_csv() # Reset enrichment service state for fresh session logger.info(f"Resetting enrichment service state...") try: import aiohttp async with aiohttp.ClientSession() as session: async with session.post( f"{self.enrichment_url}/reset", timeout=aiohttp.ClientTimeout(total=5.0) ) as response: if response.status == 200: logger.info("✓ Enrichment service reset successfully") else: logger.warning(f"⚠ Enrichment reset returned status {response.status}") except Exception as e: logger.warning(f"⚠ Could not reset enrichment service: {e}") logger.warning(" Continuing anyway (enricher may have stale state)") logger.info(f"Connecting to WebSocket: {self.ws_url}") try: async with websockets.connect(self.ws_url) as websocket: logger.info("WebSocket connected!") # Wait for welcome message welcome = await websocket.recv() logger.info(f"Received: {welcome}") # Stream each lap for idx, row in self.df.iterrows(): lap_number = int(row["lap_number"]) logger.info(f"\n{'='*60}") logger.info(f"Lap {lap_number}/{int(row['total_laps'])}") logger.info(f"{'='*60}") # Build raw telemetry payload (what real Pi would send) raw_telemetry = self.lap_to_raw_payload(row) logger.info(f"[RAW] Lap {lap_number} telemetry prepared") # Send to enrichment service for processing enriched_data = await self.enrich_telemetry(raw_telemetry) if not enriched_data: logger.error("Failed to get enrichment, skipping lap") await asyncio.sleep(self.interval) continue # Extract enriched telemetry and race context from enrichment service enriched_telemetry = enriched_data.get("enriched_telemetry") race_context = enriched_data.get("race_context") if not enriched_telemetry or not race_context: logger.error("Invalid enrichment response, skipping lap") await asyncio.sleep(self.interval) continue # Build WebSocket payload for AI layer ws_payload = { "type": "telemetry", "lap_number": lap_number, "enriched_telemetry": enriched_telemetry, "race_context": race_context } # Send enriched telemetry to AI layer via WebSocket await websocket.send(json.dumps(ws_payload)) logger.info(f"[SENT] Lap {lap_number} enriched telemetry to AI layer") # Wait for control command response(s) try: response = await asyncio.wait_for(websocket.recv(), timeout=5.0) response_data = json.loads(response) if response_data.get("type") == "control_command": brake_bias = response_data.get("brake_bias", 5) diff_slip = response_data.get("differential_slip", 5) strategy_name = response_data.get("strategy_name", "N/A") message = response_data.get("message") self.current_controls["brake_bias"] = brake_bias self.current_controls["differential_slip"] = diff_slip logger.info(f"[RECEIVED] Control Command:") logger.info(f" ├─ Brake Bias: {brake_bias}/10") logger.info(f" ├─ Differential Slip: {diff_slip}/10") if strategy_name != "N/A": logger.info(f" └─ Strategy: {strategy_name}") if message: logger.info(f" └─ {message}") # Apply controls (in real Pi, this would adjust hardware) self.apply_controls(brake_bias, diff_slip) # If message indicates processing, wait for update if message and "Processing" in message: logger.info(" AI is generating strategies, waiting for update...") try: update = await asyncio.wait_for(websocket.recv(), timeout=45.0) update_data = json.loads(update) if update_data.get("type") == "control_command_update": brake_bias = update_data.get("brake_bias", 5) diff_slip = update_data.get("differential_slip", 5) strategy_name = update_data.get("strategy_name", "N/A") self.current_controls["brake_bias"] = brake_bias self.current_controls["differential_slip"] = diff_slip logger.info(f"[UPDATED] Strategy-Based Control:") logger.info(f" ├─ Brake Bias: {brake_bias}/10") logger.info(f" ├─ Differential Slip: {diff_slip}/10") logger.info(f" └─ Strategy: {strategy_name}") self.apply_controls(brake_bias, diff_slip) except asyncio.TimeoutError: logger.warning("[TIMEOUT] Strategy generation took too long") elif response_data.get("type") == "error": logger.error(f"[ERROR] {response_data.get('message')}") except asyncio.TimeoutError: logger.warning("[TIMEOUT] No control command received within 5s") # Wait before next lap logger.info(f"Waiting {self.interval}s before next lap...") await asyncio.sleep(self.interval) # All laps complete logger.info("\n" + "="*60) logger.info("RACE COMPLETE - All laps streamed") logger.info("="*60) # Send disconnect message await websocket.send(json.dumps({"type": "disconnect"})) except websockets.exceptions.WebSocketException as e: logger.error(f"WebSocket error: {e}") logger.error("Is the AI Intelligence Layer running on port 9000?") except Exception as e: logger.error(f"Unexpected error: {e}") def apply_controls(self, brake_bias: int, differential_slip: int): """ Apply control adjustments to the car. In real Pi, this would interface with hardware controllers. """ logger.info(f"[APPLYING] Setting brake_bias={brake_bias}, diff_slip={differential_slip}") # Simulate applying controls (in real implementation, this would: # - Adjust brake bias actuator # - Modify differential slip controller # - Send CAN bus messages to ECU # - Update dashboard display) # For simulation, just log the change if brake_bias > 6: logger.info(" → Brake bias shifted REAR (protecting front tires)") elif brake_bias < 5: logger.info(" → Brake bias shifted FRONT (aggressive turn-in)") else: logger.info(" → Brake bias NEUTRAL") if differential_slip > 6: logger.info(" → Differential slip INCREASED (gentler on tires)") elif differential_slip < 5: logger.info(" → Differential slip DECREASED (aggressive cornering)") else: logger.info(" → Differential slip NEUTRAL") async def main(): parser = argparse.ArgumentParser( description="WebSocket-based Raspberry Pi Telemetry Simulator" ) parser.add_argument( "--interval", type=float, default=60.0, help="Seconds between laps (default: 60s)" ) parser.add_argument( "--ws-url", type=str, default="ws://localhost:9000/ws/pi", help="WebSocket URL for AI layer (default: ws://localhost:9000/ws/pi)" ) parser.add_argument( "--enrichment-url", type=str, default="http://localhost:8000", help="Enrichment service URL (default: http://localhost:8000)" ) parser.add_argument( "--csv", type=str, default=None, help="Path to lap CSV file (default: scripts/ALONSO_2023_MONZA_LAPS.csv)" ) args = parser.parse_args() # Determine CSV path if args.csv: csv_path = Path(args.csv) else: script_dir = Path(__file__).parent csv_path = script_dir / "ALONSO_2023_MONZA_LAPS.csv" if not csv_path.exists(): logger.error(f"CSV file not found: {csv_path}") sys.exit(1) # Create simulator and run simulator = PiSimulator( csv_path=csv_path, ws_url=args.ws_url, enrichment_url=args.enrichment_url, interval=args.interval ) logger.info("Starting WebSocket Pi Simulator") logger.info(f"CSV: {csv_path}") logger.info(f"Enrichment Service: {args.enrichment_url}") logger.info(f"WebSocket URL: {args.ws_url}") logger.info(f"Interval: {args.interval}s per lap") logger.info("-" * 60) await simulator.stream_telemetry() if __name__ == "__main__": asyncio.run(main())