Hey everyone,

My teammate and I competed at the All America Micromouse Contest (AAMC 2026) at UCLA IEEE a few months back and took 3rd place overall. We just cleaned up and open-sourced our entire codebase and build log: https://github.com/enkhbold470/neuromouse26

A few interesting engineering details from the build:

1. The "Ugly Protoboard" Pivot:
   Our V1 was a custom-designed, clean PCB. But every time we had power rail noise or needed to tweak sensor positioning, we were stuck waiting a week for a board respin. We scrapped it and built V2 on raw perfboard with point-to-point soldering and a mechanical keyboard blue switch for mode select. It looked like a rat's nest, but being able to desolder and reposition an IR emitter in 15 minutes is what got us to the competition.

2. ESP32-S3 instead of STM32:
   Almost every competitive micromouse runs on STM32. We went with an ESP32-S3 running PlatformIO. We used the ESP32 hardware PCNT (Pulse Counter) peripheral for 4x encoder decoding so the CPU didn't choke on interrupts, and cached explored maze walls into ESP32 NVS flash so the fast run could skip sensing entirely.

3. Motion Control & Algorithms:
   - 16x16 flood-fill BFS solver.
   - 200 Hz PID control loop timed purely with "micros()" 😂
   - no RTOS tasks or "delay()" in the control path.
   - Trapezoidal velocity profiling that fuses consecutive straight cells into a single acceleration corridor so the mouse doesn't brake every 180mm cell.
   - 4x IR emitter/receiver pairs (SFH4545 + TEFT4300) with lookup tables for distance calibration + MPU-6500 gyro for yaw-hold.

4. 6x3 Home Maze vs 16x16 Real Maze:

We tested at home on a tiny 6x3 grid made of homedepot whiteboard ~$10 board + 3D printed walls. Scaling to the official 16x16 (256 cells) UCLA maze was brutal because millimeter errors compound fast over long straightaways.

The 0.96" OLED display was the real MVP on competition day— like seeing live battery, IR readings, and flood-fill maps on-robot meant we could debug in the 5-minute prep window without opening a laptop.

> 🎬 Competition full run video is on YouTube: https://www.youtube.com/watch?v=2M4ZANPrZ4s

> ⭐️ Repo / Schematics / Firmware: https://github.com/enkhbold470/neuromouse26

Happy to answer any questions about the sensor tuning, flood-fill implementation, or motor control!

TL;DR: open-source wearable EEG hardware (MIT). real PCBs, not a breadboard flex. on-head berger test passed (~29.7× alpha eyes-closed vs open).

why

most EEG is either closed, expensive, or impossible to modify. we wanted the opposite: something we actually soldered, powered from lipo, and streamed — then published.

stack

• AFE: analog devices AD8422 instrumentation amp
• ADC: TI ADS1220 (24-bit)
• MCU: seeed xiao ESP32-S3
• release: netlists, gerbers, photos, platformio firmware, pinout/BOM docs

three boards

1. main carrier (MCU + ADC + power + UI)
2. AFE daughter
3. expansion ADC strip (SPI, no MCU)

proof it hears something brain-shaped

classic berger effect on channel out0:

• eyes open vs eyes closed
• welch PSD, alpha ~8–12 Hz (peak near 10 Hz)
• closed/open power ratio ≈ 29.7× → pass

(photos of boards + time series + PSD in the repo readme.)

repo

https://github.com/enkhbold470/oyu

IRL limits

• prototype / research / hobby — not a medical device
• this open drop is mark 3–class (not a 32-ch clinical system)
• electrode placement and contact quality still make or break your run

happy to answer questions on pinout, fab, firmware stream format (b/s serial), or the AFE path.

if open BCI matters to you: star, fork, roast the design, send a photo of your fab.

Sharing a project I've been working on. It's a Model Context Protocol server that turns EEG signal into plain numbers, like focus, calm, and attention, that an AI assistant can read and talk about instead of just showing a chart. It works with OpenBCI, Muse, NeuroFocus, and LSL streams. No headset? There's a synthetic mode built in so you can try the whole thing without hardware. Open source, MIT license.

https://github.com/enkhbold470/bci-mcp

Hey everyone, just wanted to share a project I've been working on to push the boundaries of LLM context. BCI-MCP is an open-source Model Context Protocol server that hooks your cognitive state straight into your AI assistant.

Instant Setup: claude mcp add bci-mcp -- npx -y bci-mcp

No Hardware Needed: Built-in synthetic brain mode lets you test the telemetry pipeline immediately.

Hardware Ready: Native support for OpenBCI, Muse, and LSL.

Use Case: Let your IDE or assistant know when you are actually locked in vs. when you're fatigued and need simpler explanations.

Check out the architecture and full setup guide here:

https://deepwiki.com/enkhbold470/bci-mcp/1-overview

Drop a comment if you try it out!