Projects in detail

The SSR and SR6 boards are a family of multi-axis, closed-loop motion-control platforms built around the ESP32. The goal: replace stacks of expensive, low-feature commercial controllers with a single, compact, fully open-hardware board that can drive multiple actuators with precise position feedback.

The SR6PD variant adds on-board USB-C Power Delivery, negotiating higher voltages directly from a PD source so the board can run high-power motion without a separate brick or bench supply. The result is a clean, cable-light setup that's easy to integrate into a larger machine.

Why it exists

Off-the-shelf multi-servo controllers tend to be costly, closed, and feature-poor. By publishing the schematics, BOM, and firmware, anyone can fabricate, modify, and extend the hardware — and the ESP32 brings Wi-Fi, Bluetooth, and plenty of headroom for control loops and networking.

Engineering highlights

Tight integration of power delivery, motor drive, and feedback on a small board means careful attention to power-plane layout, thermals, and load testing — validated on the bench before firmware ever ran.

candrive is a complete CAN motor-control stack split into three clean layers: a shared wire protocol, the driver firmware, and a host library. Keeping them separate means the protocol can evolve once and both ends stay in sync.

candrive_protocol

The wire protocol plus CRC, written in C and shared by both the firmware and the host. A single source of truth for message framing and integrity checking across the bus.

candrive_fw

The driver firmware, written in Rust for memory safety on the metal. It speaks the candrive protocol over CAN and runs the actual motor-control loop.

candrive_host

An Arduino / PlatformIO host library that commands the bus, with pluggable backends — ESP32 TWAI, STM32 bxCAN, or a generic transport — so the same host code runs across very different microcontrollers.

CANStop is an open-hardware combination endstop and stepper-motor controller on a single CAN node, with NEMA17 mounting. An embedded TMC2209 drives the motor; a second hardware variant is designed to be compatible with an external TMC2209 board, since many makers in the Voron community already have one on hand.

The connector trick

CANStop uses an XT30 2+2 connector — pairing high-power cabling alongside a twisted pair for CAN data in one rugged plug. It's an elegant way to carry both power and a clean differential signal to a moving toolhead without a cable bundle.

Why CAN

Putting the endstop and motor controller on the CAN bus collapses wiring and lets the toolhead talk to the rest of the machine over a single, noise-resistant differential pair — a natural fit for modern CoreXY printers.

OpenScoot is an open-source, CAN-based motor controller for e-scooters — a hackable alternative to the locked-down firmware that ships on commercial machines. It uses field-oriented control (FOC) to drive brushless hub motors smoothly and efficiently.

Open by design

Commercial scooter controllers are sealed black boxes. OpenScoot puts the control loop, the bus, and the tuning back in the owner's hands, so the ride can be repaired, retuned, or extended rather than throttled by a vendor.

DataCrypt is an electronic interpretation of the word game Decrypto — and a study in multi-board embedded design. A motherboard coordinates a set of player modules, each a small microcontroller talking over I2C.

Minimalist MCUs

Much of the fun was squeezing a full-featured I2C driver and game logic onto minimalist parts like the ATtiny85 — proving you don't need a big chip to build a responsive, multi-node tabletop experience.

From mockup to motherboard

The project moved from cardboard mockups to a Mk1 hardware build to a full custom motherboard, iterating on layout, displays, and input handling at each step.

HexCell is a set of hexagonal PCBs, each hosting LEDs and a microcontroller, that connect to their neighbors over UART. Messages pass through input and output channels, so a cluster of tiles becomes a self-organizing network — an embedded art piece and a hands-on study in graph theory.

Two implementations

The original firmware (HexCellMkII) is written in C; a later rewrite, hexcell-rust, explores the same mesh in embedded Rust — a great side-by-side look at building the same networked behavior in two very different languages.

Networking as art

Because each tile only knows its immediate neighbors, interesting global patterns emerge from purely local rules — message routing, propagation, and color all driven by the shape of the connected graph.

MB Pixel is both a communication-network experiment and a fun art piece. Each pixel is a standalone microcontroller that connects to its neighbors in a square grid and networks to spontaneously form a coherent, controllable set of RGB pixels.

A cheaper variant

One variant omits the transceiver in favor of a simple diode for communication — a neat cost/complexity trade-off that keeps the per-pixel bill of materials tiny while still passing messages between neighbors.

Emergent displays

Like HexCell, the interesting behavior is emergent: drop a pile of pixels onto a grid and they negotiate into a single addressable surface, no central controller required.

Disarmed is an electronics and embedded-systems project — an exercise in design, modularity, fabrication, prototyping, and game design. It's a set of PCBs that communicate over SPI and I2C to drive various displays and inputs.

How it plays

A master control board coordinates the modules and runs the game rules. The player races against the clock to derive and enter the correct inputs to "disarm" the device and win.

Minimalist by choice

Many of the embedded boards run on the ATtiny85 — chosen for the twin challenge of fitting a full-featured I2C driver into a tiny MCU, and putting a stash of leftover parts to good use.