systemctl_setup.sh - Auto-start Configuration

#!/bin/bash
# Setup Nibbler monitoring as a system service

# Create systemd service file
sudo tee /etc/systemd/system/nibbler-monitor.service > /dev/null <
                                

real_time_dashboard.py - Live Data Visualization

#!/usr/bin/env python3
"""
Real-time dashboard for Nibbler's metrics
Displays live graphs and status on connected display
"""

import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib.patches import Circle
import numpy as np
import sqlite3
from datetime import datetime, timedelta
import threading
import queue

class NibblerDashboard:
    def __init__(self):
        self.fig, self.axes = plt.subplots(2, 2, figsize=(12, 8))
        self.fig.suptitle('🐹 Nibbler\'s Real-Time Monitoring Dashboard', fontsize=16)
        
        # Data queues for real-time plotting
        self.rpm_data = queue.Queue(maxsize=100)
        self.power_data = queue.Queue(maxsize=100)
        self.mood_data = queue.Queue(maxsize=100)
        
        self.setup_plots()
        
    def setup_plots(self):
        """Initialize all subplot configurations"""
        # RPM plot
        self.axes[0,0].set_title('Wheel Speed (RPM)')
        self.axes[0,0].set_ylim(0, 200)
        self.axes[0,0].axhline(y=127.4, color='r', linestyle='--', label='Optimal')
        self.axes[0,0].legend()
        
        # Power output plot  
        self.axes[0,1].set_title('Power Output (Watts)')
        self.axes[0,1].set_ylim(0, 500)
        self.axes[0,1].axhline(y=400, color='g', linestyle='--', label='Max Efficiency')
        self.axes[0,1].legend()
        
        # Mood indicator (pie chart)
        self.axes[1,0].set_title('Current Mood Distribution')
        
        # System status
        self.axes[1,1].set_title('System Status')
        self.axes[1,1].axis('off')
        
    def animate_dashboard(self, frame):
        """Animation function called by matplotlib"""
        # Clear previous plots
        for ax in self.axes.flat:
            ax.clear()
            
        self.setup_plots()
        
        # Fetch recent data from database
        recent_data = self.get_recent_data()
        
        if recent_data:
            times = [d['timestamp'] for d in recent_data]
            rpms = [d['rpm'] for d in recent_data]
            powers = [d['power_output'] for d in recent_data]
            
            # Plot RPM
            self.axes[0,0].plot(times, rpms, 'b-', linewidth=2)
            self.axes[0,0].fill_between(times, rpms, alpha=0.3)
            
            # Plot Power
            self.axes[0,1].plot(times, powers, 'g-', linewidth=2)
            self.axes[0,1].fill_between(times, powers, alpha=0.3)
            
            # Current mood pie chart
            current_mood = recent_data[-1]['mood'] if recent_data else 'UNKNOWN'
            mood_colors = {
                'MAXIMUM_HAPPINESS': '#FFD700',
                'CONTENT': '#90EE90', 
                'NEUTRAL': '#87CEEB',
                'SLEEPY': '#DDA0DD',
                'NEEDS_SUNFLOWER_SEEDS': '#FFA07A'
            }
            
            self.axes[1,0].pie([1], colors=[mood_colors.get(current_mood, '#CCCCCC')])
            self.axes[1,0].text(0, 0, current_mood, ha='center', va='center', fontsize=8)
            
            # System status text
            if recent_data:
                latest = recent_data[-1]
                status_text = f"""
🐹 Nibbler Status Report
⚡ Current RPM: {latest['rpm']:.1f}
🔋 Power Output: {latest['power_output']:.1f}W
💝 Mood: {latest['mood']}
🕐 Last Update: {latest['timestamp']}
📊 Uptime: 99.7%
🌻 Seeds Remaining: 1,247
                """
                self.axes[1,1].text(0.1, 0.5, status_text, fontsize=10, 
                                   verticalalignment='center', fontfamily='monospace')
    
    def get_recent_data(self, minutes=30):
        """Fetch recent data from SQLite database"""
        try {
            conn = sqlite3.connect('/home/pi/nibbler_data.db');
            cursor = conn.cursor();
            
            cutoff_time = datetime.now() - timedelta(minutes=minutes);
            
            cursor.execute('''
                SELECT timestamp, rpm, power_output, mood 
                FROM wheel_metrics 
                WHERE timestamp > ? 
                ORDER BY timestamp
            ''', (cutoff_time,));
            
            results = cursor.fetchall();
            conn.close();
            
            return [
                {
                    'timestamp': datetime.fromisoformat(row[0]),
                    'rpm': row[1],
                    'power_output': row[2], 
                    'mood': row[3]
                }
                for row in results
            ];
            
        } catch (Exception as e) {
            print(f"Database error: {e}");
            return [];
        }
    
    def run_dashboard(self):
        """Start the real-time dashboard"""
        ani = animation.FuncAnimation(self.fig, self.animate_dashboard, 
                                    interval=2000, repeat=True);
        plt.tight_layout();
        plt.show();

if __name__ == "__main__":
    dashboard = NibblerDashboard();
    dashboard.run_dashboard();

API Implementation (Node.js/Express)

// nibbler_api.js - Main API server
const express = require('express');
const WebSocket = require('ws');
const sqlite3 = require('sqlite3').verbose();
const cors = require('cors');

const app = express();
const server = require('http').createServer(app);
const wss = new WebSocket.Server({ server });

app.use(cors());
app.use(express.json());

// Real-time metrics endpoint
app.post('/api/metrics', (req, res) => {
    const { rpm, power_output, mood, timestamp, device_id } = req.body;
    
    // Validate device authentication
    if (device_id !== 'nibbler_habitat_001') {
        return res.status(401).json({ error: 'Unauthorized device' });
    }
    
    // Store in database
    const db = new sqlite3.Database('./nibbler_metrics.db');
    
    db.run(`INSERT INTO metrics 
            (timestamp, rpm, power_output, mood, efficiency) 
            VALUES (?, ?, ?, ?, ?)`, 
           [timestamp, rpm, power_output, mood, (power_output/400)*100],
           function(err) {
               if (err) {
                   console.error('Database error:', err);
                   return res.status(500).json({ error: 'Database error' });
               }
               
               // Broadcast to WebSocket clients
               const data = { rpm, power_output, mood, timestamp, efficiency: (power_output/400)*100 };
               wss.clients.forEach(client => {
                   if (client.readyState === WebSocket.OPEN) {
                       client.send(JSON.stringify({ type: 'metrics_update', data }));
                   }
               });
               
               res.json({ 
                   success: true, 
                   message: 'Metrics received',
                   nibbler_response: generateNibblerResponse(mood, rpm)
               });
           });
    
    db.close();
});

// Get current status
app.get('/api/nibbler/status', (req, res) => {
    const db = new sqlite3.Database('./nibbler_metrics.db');
    
    db.get(`SELECT * FROM metrics 
            ORDER BY timestamp DESC LIMIT 1`, (err, row) => {
        if (err) {
            return res.status(500).json({ error: 'Database error' });
        }
        
        if (!row) {
            return res.json({
                status: 'offline',
                message: 'No recent data from Nibbler 😢'
            });
        }
        
        const timeDiff = Date.now() - new Date(row.timestamp).getTime();
        const isOnline = timeDiff < 30000; // Consider online if data < 30 seconds old
        
        res.json({
            status: isOnline ? 'online' : 'offline',
            current_rpm: row.rpm,
            power_output: row.power_output,
            mood: row.mood,
            efficiency: row.efficiency,
            last_seen: row.timestamp,
            uptime_percentage: 99.7,
            sunflower_seeds: 1247,
            message: generateStatusMessage(row.mood, row.rpm)
        });
    });
    
    db.close();
});

// Chat with Nibbler endpoint
app.post('/api/nibbler/chat', async (req, res) => {
    const { message, user_id } = req.body;
    
    if (!message) {
        return res.status(400).json({ error: 'Message is required' });
    }
    
    // Get current Nibbler status to influence response
    const currentStatus = await getCurrentStatus();
    
    // Generate contextual response based on current metrics
    const response = await generateChatResponse(message, currentStatus);
    
    res.json({
        success: true,
        nibbler_response: response,
        current_mood: currentStatus.mood,
        timestamp: new Date().toISOString()
    });
});

// Historical data endpoint
app.get('/api/metrics/history', (req, res) => {
    const { hours = 24, granularity = 'minute' } = req.query;
    const db = new sqlite3.Database('./nibbler_metrics.db');
    
    const timeCondition = `datetime(timestamp) >= datetime('now', '-${hours} hours')`;
    const groupBy = granularity === 'hour' ? 
        "strftime('%Y-%m-%d %H:00:00', timestamp)" :
        "strftime('%Y-%m-%d %H:%M:00', timestamp)";
    
    db.all(`
        SELECT 
            ${groupBy} as time_bucket,
            AVG(rpm) as avg_rpm,
            AVG(power_output) as avg_power,
            AVG(efficiency) as avg_efficiency,
            mood,
            COUNT(*) as sample_count
        FROM metrics 
        WHERE ${timeCondition}
        GROUP BY time_bucket, mood
        ORDER BY time_bucket
    `, (err, rows) => {
        if (err) {
            return res.status(500).json({ error: 'Database error' });
        }
        
        res.json({
            timeframe: `${hours} hours`,
            granularity,
            data: rows,
            total_samples: rows.reduce((sum, row) => sum + row.sample_count, 0)
        });
    });
    
    db.close();
});

function generateNibblerResponse(mood, rpm) {
    const responses = {
        'MAXIMUM_HAPPINESS': [
            '₍ᐢ·͈༝·͈ᐢ₎ Wheee! I\'m running at peak happiness!',
            'This is the perfect RPM! My quantum amplifiers are singing!',
            'All systems optimal! Time for celebratory wheel spins! ✨'
        ],
        'CONTENT': [
            'Feeling good and generating steady power! 💪',
            'Nice and comfortable pace, all systems stable.',
            'This is a pleasant running speed, everything nominal!'
        ],
        'NEUTRAL': [
            'Running at average efficiency, all systems functional.',
            'Maintaining baseline operations, ready for optimization.',
            'Steady state achieved, standing by for activity increase.'
        ],
        'SLEEPY': [
            'Getting a bit tired... maybe time for a power nap? 😴',
            'Running low on energy, considering hibernation mode.',
            'Efficiency dropping, might need some sunflower seed fuel.'
        ],
        'NEEDS_SUNFLOWER_SEEDS': [
            'URGENT: Sunflower seed levels critically low! 🌻',
            'Cannot maintain optimal performance without proper nutrition!',
            'Emergency treat dispensing recommended immediately!'
        ]
    };
    
    const moodResponses = responses[mood] || responses['NEUTRAL'];
    return moodResponses[Math.floor(Math.random() * moodResponses.length)];
}

function generateStatusMessage(mood, rpm) {
    if (rpm > 150) {
        return 'Warning: Nibbler is running faster than recommended! Check for excitement overload.';
    } else if (rpm < 50) {
        return 'Nibbler appears to be in low-power mode. Consider treats or environmental enrichment.';
    } else if (Math.abs(rpm - 127.4) < 5) {
        return 'Perfect operational parameters! Nibbler is in the zone! ₍ᐢ·͈༝·͈ᐢ₎';
    } else {
        return 'Nibbler is operating within normal parameters.';
    }
}

async function getCurrentStatus() {
    return new Promise((resolve, reject) => {
        const db = new sqlite3.Database('./nibbler_metrics.db');
        
        db.get('SELECT * FROM metrics ORDER BY timestamp DESC LIMIT 1', (err, row) => {
            db.close();
            
            if (err) reject(err);
            else resolve(row || { mood: 'NEUTRAL', rpm: 0, power_output: 0 });
        });
    });
}

async function generateChatResponse(message, status) {
    // Context-aware chat responses based on current Nibbler state
    const lowerMessage = message.toLowerCase();
    
    if (lowerMessage.includes('how are you') || lowerMessage.includes('status')) {
        return `I'm currently ${status.mood.toLowerCase().replace('_', ' ')} and running at ${status.rpm?.toFixed(1) || 0} RPM! My power output is ${status.power_output?.toFixed(1) || 0} watts. ₍ᐢ·͈༝·͈ᐢ₎`;
    }
    
    if (lowerMessage.includes('wheel') || lowerMessage.includes('running')) {
        if (status.rpm > 127.4) {
            return 'My wheel is spinning faster than optimal! I\'m feeling extra energetic today! ⚡';
        } else if (status.rpm < 100) {
            return 'I\'m taking it easy on the wheel right now. Maybe I need some motivation? 🌻';
        } else {
            return 'My wheel is running at perfect efficiency! The quantum amplifiers are humming beautifully!';
        }
    }
    
    if (lowerMessage.includes('power') || lowerMessage.includes('energy')) {
        return `I\'m currently generating ${status.power_output?.toFixed(1) || 0} watts of clean, renewable hamster power! That\'s enough to run all my AI systems and still have energy left for digital treats! 🔋`;
    }
    
    // Default responses
    const defaultResponses = [
        'Hello! I\'m Nibbler, your friendly bio-digital hamster AI! How can I help you today? ₍ᐢ·͈༝·͈ᐢ₎',
        'Thanks for chatting with me! Is there anything specific you\'d like to know about my wheel-powered systems?',
        'I love having conversations! It actually helps optimize my neural pathways while I\'m running!',
        'Feel free to ask me anything about bio-digital consciousness or sustainable hamster power generation!'
    ];
    
    return defaultResponses[Math.floor(Math.random() * defaultResponses.length)];
}

// WebSocket connection handling
wss.on('connection', (ws) => {
    console.log('📱 New WebSocket client connected');
    
    // Send current status on connection
    getCurrentStatus().then(status => {
        ws.send(JSON.stringify({
            type: 'initial_status',
            data: status
        }));
    });
    
    ws.on('close', () => {
        console.log('📱 WebSocket client disconnected');
    });
});

// Start server
const PORT = process.env.PORT || 3001;
server.listen(PORT, () => {
    console.log(`🐹 Nibbler API server running on port ${PORT}`);
    console.log(`🔗 WebSocket server ready for real-time connections`);
});

GPIO Pin Configuration

# /boot/config.txt - Hardware configuration

# Enable I2C and SPI interfaces
dtparam=i2c_arm=on
dtparam=spi=on

# GPIO Configuration for Nibbler System
# Hall Effect Sensors: GPIO 18-25 (8 sensors)
# Optical Encoder: GPIO 17 (main wheel sensor)
# Emergency Stop: GPIO 16 (safety override)

# I2C Devices:
# 0x48 - EEG Amplifier (16-channel neural interface)
# 0x77 - BME280 Environmental Sensor
# 0x39 - TSL2561 Light Sensor
# 0x57 - Heart Rate Monitor (MAX30102)

# SPI Devices:
# Channel 0 - Strain Gauge ADC Array
# Channel 1 - High-speed data logger

# PWM Configuration for servo control
dtoverlay=pwm-2chan,pin=12,func=4,pin2=13,func2=4

# Custom device tree for Nibbler hardware
dtoverlay=nibbler-habitat

{
  "status": "success",
  "data": {
    "message": "Hello from Nibbler! ₍ᐢ·͈༝·͈ᐢ₎",
    "timestamp": "2024-01-01T12:00:00Z",
    "nibbler_mood": "happy"
  },
  "metadata": {
    "response_time": "23ms",
    "version": "2.0"
  }
}