╔══════════════════════════════════════════════════════════════════════════════╗
║ MOTOROLA DREAM MACHINE - EEG ROBOT CONTROL ║
║ Complete System Architecture ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│ HARDWARE LAYER │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────┐ ┌──────────────────┐
│ Emotiv Flex │ │ Robot Arm │
│ EEG Headset │ │ (UR/KUKA) │
│ │ │ │
│ • 32 channels │ │ • 6 DOF │
│ • 256 Hz │ │ • Real-time │
│ • Wireless │ │ • Safety limits │
└────────┬────────┘ └────────▲─────────┘
│ │
│ Brain Signals │ Movement Commands
│ (LSL Protocol) │ (RTDE/API)
▼ │
┌──────────────────────────────────────────────────────────────────────────────┐
│ DATA ACQUISITION LAYER │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ emotiv_producer.py │
│ ──────────────────────────────────────────────────────────────────── │
│ • Connects to Emotiv via LSL │
│ • Validates channel mapping (14/32 channels) │
│ • Monitors signal quality (impedance, saturation) │
│ • Publishes to Kafka: "raw-eeg" topic │
│ • Format: EEGSample (timestamp, 32 channels, sample_data) │
└───────────────────────────────────┬─────────────────────────────────────┘
│
│ EEG Samples
│ (JSON over Kafka)
▼
┌──────────────────────────────────────────────────────────────────────────────┐
│ MESSAGE BROKER LAYER │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ Apache Kafka (Docker) │
│ ───────────────────────────────────────────────────────────────────── │
│ │
│ Topic: "raw-eeg" Topic: "robot-commands" │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ Partition 0 │ │ Partition 0 │ │
│ │ ──────────────── │ │ ──────────────── │ │
│ │ • EEGSample │ │ • RobotCommand │ │
│ │ • 256 msgs/sec │ │ • 0.5-10 msgs/s │ │
│ │ • Retention: 7d │ │ • Retention: 7d │ │
│ └──────────────────┘ └──────────────────┘ │
│ │
│ Components: Zookeeper, Kafka Broker, Schema Registry │
└────────┬──────────────────────────────────────────────────▲─────────────┘
│ │
│ Consume EEG Samples │ Produce Commands
│ (256 Hz stream) │ (~1 Hz predictions)
▼ │
┌──────────────────────────────────────────────────────────────────────────────┐
│ AI INFERENCE LAYER │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ ai_consumer.py (EEGToRobotInference) │
│ ──────────────────────────────────────────────────────────────────── │
│ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 1. Buffering & Windowing │ │
│ │ • Maintains sliding window buffer (4 seconds = 1024 samples) │ │
│ │ • Steps forward every 2 seconds (512 samples) │ │
│ │ • Real-time sample accumulation from Kafka │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 2. Preprocessing │ │
│ │ • Extract frequency bands: Delta, Theta, Alpha, Beta, Gamma │ │
│ │ • Welch PSD for each time frame │ │
│ │ • Shape: (1, 32 channels, 5 bands, 12 frames) │ │
│ │ • Convert to PyTorch tensor │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 3. EEG2Arm Model Inference │ │
│ │ ┌───────────────────────────────────────────────────────┐ │ │
│ │ │ • 3D CNN: Spatial-temporal features │ │ │
│ │ │ • Graph Conv: Electrode topology (10-20 system) │ │ │
│ │ │ • Transformer: Temporal sequence modeling │ │ │
│ │ │ • MLP Head: Classification to 5 commands │ │ │
│ │ └───────────────────────────────────────────────────────┘ │ │
│ │ Output: (1, 5) logits → Softmax → Probabilities │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 4. Command Generation │ │
│ │ • Argmax → Class: 0=REST, 1=LEFT, 2=RIGHT, 3=FWD, 4=BACK │ │
│ │ • Confidence: max(probabilities) │ │
│ │ • Publish RobotCommand to Kafka │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ │
│ Performance: 10-50ms inference (CPU), ~8 predictions/sec │
└────────────────────────────────────────────┬────────────────────────────┘
│
│ RobotCommand
│ (command, confidence, timestamp)
▼
┌──────────────────────────────────────────────────────────────────────────────┐
│ ROBOT CONTROL LAYER │
└──────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ integrated_robot_controller.py (RobotArmController) │
│ ──────────────────────────────────────────────────────────────────── │
│ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 1. Safety Validation │ │
│ │ • Confidence threshold: >= 0.6 │ │
│ │ • Command timeout: < 2000ms since last command │ │
│ │ • Velocity limits: < 0.2 m/s (configurable) │ │
│ │ • Workspace bounds: Cartesian limits │ │
│ │ • Result: ACCEPT or REJECT │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 2. Command Mapping │ │
│ │ • REST → Stop: velocity = [0, 0, 0, 0, 0, 0] │ │
│ │ • LEFT → velocity = [-0.1, 0, 0, 0, 0, 0] │ │
│ │ • RIGHT → velocity = [0.1, 0, 0, 0, 0, 0] │ │
│ │ • FORWARD → velocity = [0, 0.1, 0, 0, 0, 0] │ │
│ │ • BACKWARD → velocity = [0, -0.1, 0, 0, 0, 0] │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ 3. Robot Execution │ │
│ │ ┌────────────┬────────────┬────────────┐ │ │
│ │ │ Mock Robot │ UR Robot │ KUKA Robot │ │ │
│ │ ├────────────┼────────────┼────────────┤ │ │
│ │ │ Testing │ ur-rtde │ KUKA SDK │ │ │
│ │ │ No HW req │ speedL() │ (future) │ │ │
│ │ └────────────┴────────────┴────────────┘ │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ │
│ Safety: Emergency stop on errors, watchdog timer, position monitoring │
└────────────────────────────────────────────┬────────────────────────────┘
│
│ Robot Movement
│ (Physical motion)
▼
[Robot Arm Moves]
╔══════════════════════════════════════════════════════════════════════════════╗
║ DATA FLOW TIMELINE ║
╚══════════════════════════════════════════════════════════════════════════════╝
T=0ms Emotiv samples brain activity (1 sample)
▼
T=4ms LSL transmits to emotiv_producer
▼
T=14ms Kafka receives EEGSample message
▼
T=19ms ai_consumer buffers sample
▼
T=4000ms 4-second window complete → Preprocessing starts
▼
T=4020ms Band power extraction complete
▼
T=4050ms Model inference complete (30ms)
▼
T=4055ms RobotCommand published to Kafka
▼
T=4060ms integrated_robot_controller receives command
▼
T=4061ms Safety validation (1ms)
▼
T=4062ms Command mapped to velocity
▼
T=4070ms Robot starts moving
▼
T=4150ms Robot reaches target position (80ms movement)
Total end-to-end latency: ~150ms from thought to movement ✅
╔══════════════════════════════════════════════════════════════════════════════╗
║ KEY COMPONENTS ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌─────────────────────────────────────────────────────────────────────────────┐
│ EEG2Arm Model Architecture │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Input: (Batch, 32, 5, 12) = (B, Channels, Bands, Frames) │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ 3D CNN Stem │ │
│ │ • DWConvBlock 1: 3D depthwise conv + pool (time/2) │ │
│ │ • DWConvBlock 2: 3D depthwise conv │ │
│ │ • PointwiseMix: 1×1×1 conv (32→64 channels) │ │
│ │ Output: (B, 64, F', T') │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Graph Convolution Network │ │
│ │ • Reshape to: (B*T', 32, 2*F') │ │
│ │ • GCNLayer 1: 2*F' → 32 features (with adjacency) │ │
│ │ • GCNLayer 2: 32 → 32 features │ │
│ │ • Models 10-20 electrode topology │ │
│ │ Output: (B*T', 32, 32) │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Transformer │ │
│ │ • Reshape to: (B, T', 32*32=1024) │ │
│ │ • Positional encoding (sinusoidal) │ │
│ │ • 2-layer transformer encoder (causal mask) │ │
│ │ • 4 attention heads, 2048 FFN dim │ │
│ │ • Takes last time step: (B, 1024) │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ MLP Head │ │
│ │ • FC: 1024 → 128 │ │
│ │ • ReLU + Dropout(0.3) │ │
│ │ • FC: 128 → 5 (output classes) │ │
│ │ Output: (B, 5) logits │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ Parameters: ~500,000 trainable │
│ Optimization: Adam, CrossEntropy loss, LR scheduling │
└─────────────────────────────────────────────────────────────────────────────┘
╔══════════════════════════════════════════════════════════════════════════════╗
║ CONFIGURATION SUMMARY ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌─────────────────────────────────────────────────────────────────────────────┐
│ EEG Configuration │
├─────────────────────────────────────────────────────────────────────────────┤
│ Sample Rate: 256 Hz │
│ Channels: 32 (Emotiv Flex) or 14 (EPOC/Insight) │
│ Window Size: 4 seconds (1024 samples) │
│ Step Size: 2 seconds (512 samples) │
│ Frequency Bands: Delta(0.5-4), Theta(4-8), Alpha(8-12), │
│ Beta(12-30), Gamma(30-45) Hz │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ AI Configuration │
├─────────────────────────────────────────────────────────────────────────────┤
│ Model: EEG2Arm (CNN + GCN + Transformer) │
│ Input Shape: (32, 5, 12) = channels × bands × frames │
│ Output Classes: 5 (REST, LEFT, RIGHT, FORWARD, BACKWARD) │
│ Inference Device: CPU (can use GPU with --device cuda) │
│ Prediction Rate: ~0.5 Hz (every 2 seconds) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Robot Configuration │
├─────────────────────────────────────────────────────────────────────────────┤
│ Supported Types: Mock (testing), UR (via ur-rtde), KUKA (future) │
│ Max Velocity: 0.2 m/s (configurable) │
│ Max Acceleration: 0.5 m/s² (configurable) │
│ Workspace: [-0.5, 0.5] × [-0.5, 0.5] × [0.0, 0.5] meters │
│ Min Confidence: 0.6 (60% to execute command) │
│ Command Timeout: 2000ms (stop if no command) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Kafka Configuration │
├─────────────────────────────────────────────────────────────────────────────┤
│ Broker: localhost:9092 (configurable) │
│ Topics: raw-eeg (input), robot-commands (output) │
│ Partitions: 1 per topic │
│ Replication: 1 (single broker) │
│ Retention: 7 days │
│ Compression: LZ4 │
└─────────────────────────────────────────────────────────────────────────────┘
╔══════════════════════════════════════════════════════════════════════════════╗
║ TESTING MODES ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌─────────────────────────────────────────────────────────────────────────────┐
│ Mode 1: File-Based Testing (No Hardware) │
├─────────────────────────────────────────────────────────────────────────────┤
│ Data Source: S012R14.edf (sample EEG file) │
│ Producer: producer/producer.py │
│ Robot: Mock (simulated) │
│ Purpose: Development, CI/CD, demonstrations │
│ Command: ./run_integration_test.sh │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Mode 2: Live Emotiv Testing (EEG Hardware) │
├─────────────────────────────────────────────────────────────────────────────┤
│ Data Source: Emotiv Flex 2.0 headset via LSL │
│ Producer: producer/emotiv_producer.py │
│ Robot: Mock (testing) or Real (production) │
│ Purpose: Real-time brain signal processing │
│ Command: python producer/emotiv_producer.py │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Mode 3: Full Production (EEG + Robot) │
├─────────────────────────────────────────────────────────────────────────────┤
│ Data Source: Emotiv Flex 2.0 headset via LSL │
│ Producer: producer/emotiv_producer.py │
│ AI Model: Trained EEG2Arm model │
│ Robot: UR or KUKA robot arm │
│ Purpose: Brain-controlled robot operation │
│ Command: [Multi-terminal setup - see QUICK_START_GUIDE.md] │
└─────────────────────────────────────────────────────────────────────────────┘
╔══════════════════════════════════════════════════════════════════════════════╗
║ STATUS SUMMARY ║
╚══════════════════════════════════════════════════════════════════════════════╝
INFRASTRUCTURE: ✅ Complete (Kafka, Docker, Python environment)
DATA ACQUISITION: ✅ Complete (File + LSL + Emotiv-specific)
AI MODEL ARCHITECTURE: ✅ Complete (EEG2Arm implementation)
AI MODEL TRAINING: ⚠️ Demo only (needs real data)
ROBOT CONTROL: ✅ Mock complete, UR ready, KUKA partial
INTEGRATION: ✅ Complete (end-to-end pipeline working)
DOCUMENTATION: ✅ Comprehensive (30+ pages)
TESTING: ✅ Automated test script available
SAFETY: ✅ Basic safeguards implemented
OVERALL STATUS: 🟢 70% Complete - Ready for Hardware Testing
NEXT STEPS:
1. Test with Emotiv hardware
2. Collect training data
3. Train AI model
4. Connect robot arm
5. Fine-tune and optimize
═══════════════════════════════════════════════════════════════════════════════
Created: October 8, 2025
Version: 1.0
Project: Motorola Dream Machine