Bob API Portal

#!/usr/bin/env python3
"""
Project Bob - Comprehensive Redis Data Viewer

This script connects to Project Bob's public Redis data stream and displays a
comprehensive overview of the vessel's telemetry, organized by subsystem.

- Connects to the Redis cloud instance with read-only credentials.
- Fetches data from multiple subsystems: GPS, Navigation, Power, System, etc.
- Displays the data in a clean, formatted, and continuously updating table.
- Handles connection errors and missing data gracefully.
"""
import redis
import time
import os
from datetime import datetime

# --- Configuration ---
REDIS_HOST = 'redis-17021.fcrce172.us-east-1-1.ec2.redns.redis-cloud.com'
REDIS_PORT = 17021
REDIS_USERNAME = 'readonlyuser'
REDIS_PASSWORD = 'Trawlingforlikes1!!'

# --- Key Groups ---
# Define the Redis keys we want to monitor, grouped by subsystem
KEY_GROUPS = {
    "🚢  Vessel Status": {
        "Position": "sensors:gps:current_lat",
        "Heading": "sensors:navigation:heading",
        "Speed (knots)": "sensors:gps:velocity_knots",
        "Mode": "sensors:navigation:mode"
    },
    "🌍 GPS System": {
        "Latitude": "sensors:gps:current_lat",
        "Longitude": "sensors:gps:current_lon",
        "Satellites": "sensors:gps:satellites",
        "Altitude (m)": "sensors:gps:altitude",
        "Fix Quality": "sensors:gps:fix_quality"
    },
    "⚡ Power System": {
        "Battery (V)": "sensors:mppt:battery_voltage",
        "Solar Panel (W)": "sensors:mppt:array_power",
        "Motor Power (W)": "sensors:odrive:power",
        "Charge State": "sensors:mppt:charge_state_mapped"
    },
    "🧭 Navigation & Control": {
        "Compass Heading": "sensors:mag:heading",
        "Rudder Angle (°)": "sensors:stepper:angle",
        "Target Bearing": "sensors:navigation:target_bearing",
        "Distance to Target (km)": "sensors:navigation:distance_to_target"
    },
}

def connect_to_redis():
    """Establishes a connection to the Redis server."""
    print("🌊 Connecting to Bob's Redis data stream...")
    try:
        r = redis.Redis(
            host=REDIS_HOST,
            port=REDIS_PORT,
            username=REDIS_USERNAME,
            password=REDIS_PASSWORD,
            decode_responses=True,
            socket_connect_timeout=5,
            socket_timeout=5
        )
        r.ping()
        print("✅ Connection successful!")
        return r
    except redis.exceptions.AuthenticationError:
        print("❌ Authentication failed. Check username and password.")
        return None
    except redis.exceptions.ConnectionError as e:
        print(f"❌ Connection error: {e}")
        return None
    except Exception as e:
        print(f"❌ An unexpected error occurred: {e}")
        return None

def fetch_data(redis_client, keys_to_fetch):
    """Fetches a batch of keys from Redis using a pipeline."""
    pipe = redis_client.pipeline()
    for key in keys_to_fetch:
        pipe.get(key)
    try:
        values = pipe.execute()
        return values
    except redis.exceptions.ConnectionError:
        print("⚠️ Lost connection to Redis. Attempting to reconnect...")
        return None
    except Exception as e:
        print(f"⚠️ Error during data fetch: {e}")
        return None

def display_data(data):
    """Clears the screen and displays the fetched data in a structured format."""
    os.system('cls' if os.name == 'nt' else 'clear')
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print("=" * 60)
    print(f"  PROJECT BOB - LIVE TELEMETRY  |  {timestamp}")
    print("=" * 60)

    for group_name, keys in KEY_GROUPS.items():
        print(f"\n{group_name}")
        print("-" * 25)
        for name, key in keys.items():
            value = data.get(key, "N/A")
            # Try to format numbers nicely, otherwise display as is
            try:
                value_str = f"{float(value):.2f}"
            except (ValueError, TypeError):
                value_str = str(value) if value is not None else "N/A"
            print(f"  {name:<25}: {value_str}")
    
    print("\n" + "=" * 60)
    print("Press Ctrl+C to exit. Updating every 5 seconds...")

def main():
    """Main loop to connect, fetch, and display data."""
    redis_client = connect_to_redis()
    if not redis_client:
        return

    all_keys = [key for group in KEY_GROUPS.values() for key in group.values()]
    unique_keys = sorted(list(set(all_keys)))

    try:
        while True:
            values = fetch_data(redis_client, unique_keys)

            if values is not None:
                data_dict = dict(zip(unique_keys, values))
                display_data(data_dict)
            else:
                # Attempt to reconnect if fetch failed
                redis_client = connect_to_redis()
                if not redis_client:
                    print("Could not re-establish connection. Exiting.")
                    break
                time.sleep(5) # Wait before retrying after reconnect
                continue

            time.sleep(5)
    except KeyboardInterrupt:
        print("\n\n👋 Exiting Bob's telemetry viewer. Safe travels!")
    except Exception as e:
        print(f"\nAn unexpected error occurred in the main loop: {e}")

if __name__ == '__main__':
    main()

# Install required packages
pip install redis

#!/usr/bin/env python3
"""
Bob's Historical Data Analyzer
Pulls complete InfluxDB telemetry into pandas DataFrame every 30 seconds
Analyzes Bob's journey patterns, performance metrics, and ocean conditions
"""
import pandas as pd
import time
from datetime import datetime, timedelta
from influxdb_client_3 import InfluxDBClient3

def connect_to_influx():
    """Connect to Bob's InfluxDB historical data store"""
    print("📊 Connecting to Bob's InfluxDB time series database...")
    
    try:
        # InfluxDB connection parameters
        token = "RRp6hGho7p5rxi_BEUJzQcFdks6jWHSxHeW7ja21T0HR8lDXBLsvxPze93CmJnB5X_sl1qdya8CxdGnuOk3Jxg=="
        org = "bob"
        host = "https://us-east-1-1.aws.cloud2.influxdata.com"
        database = "bob-telemetry"
        
        # Create InfluxDB client connection
        client = InfluxDBClient3(host=host, token=token, org=org)
        
        print("✅ Connected to Bob's historical database!")
        return client, database
        
    except Exception as e:
        print(f"❌ InfluxDB connection failed: {e}")
        return None, None

def fetch_complete_telemetry(client, database, hours_back=24):
    """Fetch comprehensive telemetry data from InfluxDB"""
    print(f"🔍 Fetching last {hours_back} hours of Bob's complete telemetry...")
    
    try:
        # Comprehensive SQL query to get all major telemetry streams
        # This pulls GPS, power, navigation, and environmental data
        query = f'''
        SELECT 
            time,
            -- GPS & Navigation Data
            gps_lat as latitude,
            gps_lon as longitude,
            gps_velocity_knots as speed_knots,
            gps_satellites,
            navigation_heading as compass_heading,
            navigation_mode,
            
            -- Power & Energy Systems
            battery_voltage,
            solar_power_watts,
            motor_power_watts,
            power_consumption_total,
            
            -- Environmental Conditions  
            air_temperature_c,
            water_temperature_c,
            wave_height_meters,
            wind_speed_knots,
            wind_direction,
            
            -- System Health
            cpu_temperature,
            system_uptime_hours,
            memory_usage_percent,
            storage_usage_percent
            
        FROM "{database}"."autogen"."telemetry"
        WHERE time >= now() - interval '{hours_back} hours'
        ORDER BY time DESC
        LIMIT 10000
        '''
        
        # Execute query and convert to pandas DataFrame
        print("⏳ Executing query...")
        table = client.query(query=query, database=database, language='sql')
        df = table.to_pandas()
        
        # Convert time column to datetime if it's not already
        if 'time' in df.columns:
            df['time'] = pd.to_datetime(df['time'])
            df.set_index('time', inplace=True)
        
        print(f"✅ Retrieved {len(df)} telemetry records!")
        return df
        
    except Exception as e:
        print(f"❌ Error fetching telemetry: {e}")
        # Fallback to simplified GPS-only query if comprehensive query fails
        try:
            print("🔄 Trying simplified GPS query...")
            simple_query = f'''
            SELECT time, current_lat, current_lon, velocity_knots, satellites
            FROM "{database}"."autogen"."gps" 
            WHERE time >= now() - interval '{hours_back} hours'
            ORDER BY time DESC
            LIMIT 5000
            '''
            
            table = client.query(query=simple_query, database=database, language='sql')
            df = table.to_pandas()
            
            if 'time' in df.columns:
                df['time'] = pd.to_datetime(df['time'])
                df.set_index('time', inplace=True)
                
            print(f"✅ Retrieved {len(df)} GPS records (simplified mode)")
            return df
            
        except Exception as e2:
            print(f"❌ Simplified query also failed: {e2}")
            return None

def analyze_telemetry(df):
    """Analyze Bob's telemetry data and print insights"""
    if df is None or df.empty:
        print("⚠️ No data to analyze")
        return
    
    print("\n" + "="*80)
    print("📈 BOB'S TELEMETRY ANALYSIS")
    print("="*80)
    
    # Basic dataset info
    print(f"📊 Dataset Overview:")
    print(f"   • Time Range: {df.index.min()} to {df.index.max()}")
    print(f"   • Total Records: {len(df):,}")
    print(f"   • Data Points: {len(df.columns)} metrics")
    print(f"   • Duration: {(df.index.max() - df.index.min()).total_seconds()/3600:.1f} hours")
    
    # GPS Analysis (if available)
    if 'latitude' in df.columns or 'current_lat' in df.columns:
        lat_col = 'latitude' if 'latitude' in df.columns else 'current_lat'
        lon_col = 'longitude' if 'longitude' in df.columns else 'current_lon'
        
        print(f"\n🌍 GPS Position Analysis:")
        print(f"   • Current Position: {df[lat_col].iloc[0]:.6f}°, {df[lon_col].iloc[0]:.6f}°")
        print(f"   • Position Range: {df[lat_col].min():.4f}° to {df[lat_col].max():.4f}° latitude")
        print(f"   • Distance Span: ~{abs(df[lat_col].max() - df[lat_col].min()) * 69:.1f} miles N-S")
    
    # Speed Analysis
    speed_col = None
    for col in ['speed_knots', 'velocity_knots']:
        if col in df.columns:
            speed_col = col
            break
            
    if speed_col:
        print(f"\n🏃 Speed Analysis:")
        print(f"   • Current Speed: {df[speed_col].iloc[0]:.2f} knots")
        print(f"   • Average Speed: {df[speed_col].mean():.2f} knots")
        print(f"   • Max Speed: {df[speed_col].max():.2f} knots")
        print(f"   • Speed Std Dev: {df[speed_col].std():.2f} knots")
    
    # Power Analysis (if available)
    if 'battery_voltage' in df.columns:
        print(f"\n🔋 Power System Analysis:")
        print(f"   • Current Battery: {df['battery_voltage'].iloc[0]:.2f}V")
        print(f"   • Battery Range: {df['battery_voltage'].min():.2f}V - {df['battery_voltage'].max():.2f}V")
        if 'solar_power_watts' in df.columns:
            print(f"   • Avg Solar Power: {df['solar_power_watts'].mean():.1f}W")
    
    # Data Quality Assessment
    print(f"\n📊 Data Quality:")
    missing_data = df.isnull().sum()
    total_possible = len(df) * len(df.columns)
    missing_percent = (missing_data.sum() / total_possible) * 100
    print(f"   • Data Completeness: {100-missing_percent:.1f}%")
    print(f"   • Missing Values: {missing_data.sum():,} out of {total_possible:,}")
    
    # Show recent data sample
    print(f"\n📋 Most Recent Data (last 5 records):")
    print(df.head().to_string())

def main():
    """Main analysis loop - fetches and analyzes data every 30 seconds"""
    # Connect to InfluxDB
    client, database = connect_to_influx()
    if not client:
        return
    
    print("🔄 Starting continuous telemetry analysis... (Press Ctrl+C to stop)")
    print("📅 Data will refresh every 30 seconds")
    
    try:
        while True:
            # Get current timestamp
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            print(f"\n🕐 [{timestamp}] Fetching latest telemetry data...")
            
            # Fetch comprehensive telemetry data
            df = fetch_complete_telemetry(client, database, hours_back=24)
            
            # Analyze the data
            analyze_telemetry(df)
            
            # Optional: Save data to CSV for further analysis
            if df is not None and not df.empty:
                filename = f"bob_telemetry_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
                df.to_csv(filename)
                print(f"\n💾 Data saved to: {filename}")
            
            print(f"\n⏱️  Waiting 30 seconds for next update...")
            print("-" * 80)
            
            # Wait 30 seconds before next analysis
            time.sleep(30)
            
    except KeyboardInterrupt:
        print(f"\n👋 Analysis stopped. Bob's data lives on!")
        print("📁 Check your directory for saved CSV files with Bob's telemetry data.")

# Run the analyzer
if __name__ == '__main__':
    main()

# Install required packages
pip install influxdb-client-3 pandas