Neural-Controlled Robotic ARM | Bare-Metal EMG Controller

Project Overview

A bare-metal embedded system that translates electromyographic (EMG) muscle signals into precise robotic arm movements with minimal latency.

⚡

Real-Time Processing

Interrupt-driven signal processing with 1664-cycle ISR budget at 16MHz

🎯

Fixed-Point Math

Q15 fixed-point arithmetic throughout for consistent, FPU-free performance

🔧

Memory-Mapped I/O

Direct hardware register access with custom linker scripts

🧬

Neural Processing

Hand-optimized assembly for tensor operations and activation functions

Signal Processing Chain

EMG Capture

Surface electrodes detect muscle potentials

→

ADC Sampling

9.6 kHz continuous sampling

→

Baseline Removal

64-sample rolling average

→

Rectification

Full-wave rectification

→

Envelope Detection

IIR low-pass filter (5Hz)

→

PWM Control

Servo actuation (1-2ms pulse)

Live Demo

Watch the neural-controlled robotic ARM in action

System Architecture

Hardware Targets

Primary: ATmega328P @ 16MHz

Memory: 2KB SRAM, 32KB Flash

Extended: STM32F407 ARM Cortex-M4

Features: 168MHz, FPU, DMA

Memory Layout

Flash (.text) 0x0000 - 0x7FFF

SRAM (.data/.bss) 0x0100 - 0x08FF

EEPROM 0x0000 - 0x03FF

Project Structure

Kernel/
├── main.c                          # Core signal processing loop
├── peripherals.c                   # Register-level hardware abstraction
├── interrupt_vector_handler.s      # Custom interrupt vector table
├── startup.s                       # Boot sequence & stack initialization
├── neural_matrix_ops.s             # Neural network operations
├── real_time_scheduler.s           # Real-time task scheduling
└── syscalls.c                      # Minimal C runtime support

System/
├── filter.h                        # Q15 fixed-point DSP filters
├── fixed_point.h                   # Fixed-point arithmetic macros
├── robot_mem_map.h                 # Memory-mapped I/O addresses
└── peripherals.h                   # Hardware register definitions

linker/
└── atmega328p.ld                   # Custom memory layout

stm32f407/
└── src/                            # STM32F407 extensions

Hardware Overview

Neural Robotic Interface Board – NRX-22: A next-gen embedded controller designed for EMG-driven robotic systems

The NRX-22 is a specialized embedded controller capable of running neural signal decoding, predictive control loops, and real-time adaptive actuation. Built for high-performance EMG processing with deterministic latency and minimal power consumption.

⚙️ Central Processing Core

Chipset ETC-μCore A21X

Architecture 64-bit hybrid RISC pipeline

Base Clock 2.8 GHz (adaptive to 3.6 GHz turbo)

Bus Width 128-bit internal data highway

Instruction Cache 512 KB dual-channel L1

Data Cache 1 MB associative 4-way

Vector Engine 128-lane SIMD neural unit for EMG spectral analysis

Operating Voltage 0.9 V – 1.15 V dynamic scaling

🧠 Memory & Storage Architecture

Main Memory Array

4× Memory Dies (M1–M4) with 8 sub-memory controllers each (MCU0–MCU7)

Per Controller: 256 MB LPDDR6E

Lane Width: 32-bit

Aggregate Bandwidth: 102 GB/s

Refresh Clock: 640 MHz per die

Gate Routing & Addressing

Address Bus (M1): 0x00000000 → 0x0FFFFFFF

Bus Interlink Bridge: 0x1A000000 → 0x3FFFFFFF

Neural-Cache Bridge (NCB): 0x40000000 → 0x47FFFFFF

Backup & Redundancy Subsystem

22 auxiliary dies (A1–B22) arranged in dual-tier topology:

Tier A (A1–A11): Neural state & real-time variable snapshots

Tier B (B1–B11): Checksum, ECC, mirror-buffering

Per Backup Chip: 16 MB SRAM + microcontroller recovery

Backup Frequency: 12.4 MHz sync per die

📊 Signal & I/O Layer

EMG Analog Front-End

Channels: 12-channel AFE
Sampling Rate: 48 kHz
Resolution: 16-bit Q15 mode
Address Range: 0x50000000 → 0x5000007C

DAC Output

Pairs: 4 differential pairs
Frequency: 96 kHz smoothing
Resolution: 16-bit

GPIO Controller

Lanes: 48 multiplexed
Address Range: 0x60000000 → 0x600000FF
Max Speed: 480 MHz peripheral clock

PWM Actuator Bus

Loop Frequency: 1.2 MHz
Jitter Tolerance: 0.4 µs
Purpose: Servo actuation control

🕐 Clock & Timing Network

Master Oscillator

48 MHz quartz base with 12-stage digital synthesizer

Effective Range: Up to 3.84 GHz

PLL Cluster

Bus Sync 320 MHz

Neural Compute Core 2.8 GHz

Peripheral Domain 480 MHz

AFE Sampling Clock 48 kHz

📡 Communication Matrix

Dual RF Controller 2.4 GHz + 5.2 GHz band (internal antenna)

UART 115200 bps debug line

SPI Bus 42 MHz multiplexed

I²C Bus 400 kHz (EEPROM + thermal sensor)

CAN-Bus Gateway 2 Mbps (robotic actuator sync)

EtherNet PHY 1 GbE full-duplex, hardware offload

⚡ Power Network

Voltage Rails

Input Power 3.3 V DC regulated

Core Rails 1.15 V

Memory Rails 1.8 V

I/O Rails 3.3 V

Noise Isolation

4 µF tantalum capacitors per subsystem
220 nH inductors per subsystem
Routed through Layer 3 PCB copper plane
Multi-point power distribution

🌡️ Thermal & Debug Layer

Thermal Monitoring

8 miniature thermal diodes linked to sensor controller

Address: 0x70000000

Debug Interfaces

Built-in JTAG & SWD debug ports (top row header)

Real-Time Trace Buffer (RTB)

512 KB for ISR profiling and DMA overflow diagnostics

💾 Firmware Integration

The firmware kernel maps directly to hardware address spaces for optimal performance:

0x80000000

neural_matrix_ops.s

Runs directly on vector unit

0x00000000

interrupt_vector_handler.s

Fast interrupt dispatch

Core Timer #2

real_time_scheduler.s

Executes @ 1 µs tick

0xFFF00000

syscalls.c

Runtime stack frame bridging

📈 Performance Metrics

184 GFLOPs

Peak Compute

Neural operations equivalent

2.1 ms

EMG Response Latency

Input-to-actuator delay

93%

Bus Efficiency

Sustained throughput

1.8 W

Power Draw

Average (2.3 W max)

Getting Started

Prerequisites

Install the required toolchain for AVR development:

# Ubuntu/Debian
sudo apt-get install avr-gcc avr-libc avrdude

# macOS
brew install avr-gcc avrdude

# Arch Linux
sudo pacman -S avr-gcc avr-libc avrdude

Clone Repository

Get the source code from GitHub:

git clone https://github.com/InboraStudio/Neural-Controlled-robotic-ARM-With-Kernal-.git
cd Neural-Controlled-robotic-ARM-With-Kernal-

Build Project

Compile the firmware from the build directory:

cd build
make all

# Check size constraints (must fit in 32KB Flash, 2KB SRAM)
make size

Flash to Hardware

Upload the compiled firmware to ATmega328P:

# Update programmer settings in Makefile if needed
# Default: arduino programmer on /dev/ttyUSB0
make flash

# For custom port (e.g., /dev/ttyACM0)
avrdude -c arduino -p m328p -P /dev/ttyACM0 -b 115200 -U flash:w:../output/emg_servo.hex:i

⚠️ Safety Warning

Demo hardware only. Not for medical use.

Never connect electrodes directly to MCU input
Always isolate EMG amplifiers from microcontroller power rail
Use differential amplifiers (AD620 or INA128) with ±9V rails
Implement DC blocking capacitors on input stages
Maintain 1 MΩ input impedance for safety

Development Workflow

Build Commands

make all Compile, link, generate HEX + disassembly

make flash Program ATmega328P via AVRDUDE

make size Display Flash/SRAM usage

make disasm View assembly listing with symbols

make clean Remove build artifacts

Key Conventions

No dynamic allocation: All buffers statically allocated
Q15 fixed-point: No floating-point operations
Memory-mapped I/O: Direct volatile pointer access
ISR constraints: Keep under 1664 cycles @ 16MHz
Assembly naming: Functions ending in _impl

Debugging Techniques

Cycle profiling: Count ISR instructions in disassembly
Register dumps: Use g_sample_count volatile counter
Memory verification: Check .map file for section placement
Saturation detection: ISR zeros output on ADC clipping

Performance Metrics

ISR Execution: ~1600 cycles per sample
Flash Usage: Typically <16KB of 32KB
SRAM Usage: ~1KB of 2KB available
Power Draw: ~20mA @ 5V (ATmega328P)
Signal Range: 0-5V input, 10-bit resolution

Credits

Kernel Design by Seo Park Jun
System Staging by Chethan Yadav
Core System Designer Dr Chamyoung