Skip to the content
2 layers41.7 × 49 mmEsp32 connector, the printed circuit board in 3D

Pawels' hobby - main repository of the code for hexapod. Controller used is ESP32 and the code is based on ESP-IDF framework.

Size
41.7 × 49 mm
Copper layers
2
Thickness
1.6 mm
Parts
10
Nets
31
Pads
67
Tracks, vias
130, 18
Pours
1
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
7 Oct 2025
Updated
23 Aug 2026

Overview

Esp32 connector is an open-source printed circuit board by quick-brown-bot, from the quick-brown-bot/hexapod repository on GitHub. It is a 2-layer board of 41.7 × 49 mm with 10 parts on 31 nets, routed with 130 tracks and 18 vias.

It is built around the ESP32-WROOM-32D. Its parts include 3 connectors, 2 capacitors, 2 diodes, 1 resistor and 1 IC. It belongs with the ESP32 boards of this library.

Main components

1

README

README.md

Hexapod

This is the old (V1) version of the project. Active development has moved to V2: quick-brown-bot/hexapod_v2. This repo is closed — kept for reference and continued use, not further development.

An ESP32-powered hexapod robot built as a long-term robotics and embedded systems project.

The goal is not just to make a robot walk, but to learn and at the same time build a platform that is easy to experiment with, tune, and extend. Most robot behavior is configurable at runtime, control inputs are transport-independent, and the motion stack is organized into separated components.

The project combines firmware, hardware design, and system documentation in a single repository.

6 legs, 18 servos, ESP32, ESP-IDF, FreeRTOS, direct PWM.

Hexapod V1

The distributed RS485/RP2040 leg-controller generation of this project has moved to a separate repository: quick-brown-bot/hexapod_v2. This repo covers the original ESP32 direct-PWM robot only. V1 is closed: the hardware and firmware here are done and kept for reference and continued use, not further development.


What Is In This Repository

The repository contains software and hardware assets used to develop and validate the robot.

text
firmware/
└── mainboard/         Main robot firmware (ESP32, direct PWM)

hardware/
├── servo_mainboard/   Central ESP32 board driving the servos directly
├── leg/               Leg controller board
├── esp32_connector/   ESP32 carrier / breakout
├── symbols/           Symbol libraries
├── footprints/        Footprint libraries
└── models/            Mechanical models

docs/
├── common/            Docs shared across subsystems (RPC, WiFi, config)
├── architecture/       System and hardware architecture docs
├── development/        Development docs
└── plans/             Project-wide backlog and research items

Mainboard firmware overview: firmware/mainboard/README.md

The main firmware is built around a fixed 100 Hz control loop and a modular motion pipeline:

text
Controller Input
        ↓
Gait Scheduler
        ↓
Foot Trajectory Generation
        ↓
Inverse Kinematics
        ↓
Motion Limiting
        ↓
Servo Outputs

Current Technical Highlights

Effort Summary

Effort AreaScopeCurrent StatusNotes
Locomotion PipelineCommand mapping, gait scheduler, swing trajectory, whole-body IKImplementedRuns in a fixed 100 Hz control loop
KPP Motion LimitsVelocity, acceleration, jerk limiting and state estimationImplementedRuntime limits are configuration-backed
Controller AbstractionDriver-agnostic core plus transport-specific driversImplementedFlySky iBUS, Wi-Fi TCP, and Bluetooth Classic paths are present
RPC SystemQueue-based command processing and config controlImplementedLive inspection and runtime tuning are available
Configuration PlatformNamespace defaults, migration, discovery, persistenceImplementedCore runtime namespaces are already consumed by modules
Configurator ToolingExternal tuning and visualization UXPlannedFirmware-side groundwork exists; UI work remains

Hardware Snapshot

  • MCU: ESP32 running FreeRTOS through ESP-IDF.
  • Robot layout: 6 legs, 3 degrees of freedom per leg, 18 hobby servos total.
  • Power: 4S LiPo, separate UBEC paths for servo and logic power.
  • PWM: mixed MCPWM and LEDC to reach all 18 outputs on the ESP32.
  • Mechanical: custom 3D-printed chassis and leg parts.

High-Level Architecture

mermaid
flowchart LR
        Control[Controller stack]
        Config[RPC and config]
        App[Application loop]
        Loc[Locomotion]
        Limits[Motion limiting]
        Act[Actuation]
        Robot[Robot hardware]

        Control --> App
        Config --> App
        App --> Loc --> Limits --> Act --> Robot
        Config --> Control
  • Controller stack: receives operator input from supported transports and normalizes it.
  • RPC and config: handles runtime commands, parameter discovery, persistence, and save flows.
  • Application loop: owns boot order and the 100 Hz control cycle.
  • Locomotion: turns operator intent into gait phase, foot targets, and joint-space commands.
  • Motion limiting: constrains commanded motion to configured dynamic envelopes.
  • Actuation: maps joint commands to the PWM outputs that drive the robot.

Runtime Configuration

Configuration is treated as a first-class subsystem rather than a collection of compile-time constants.

Parameters are organized into namespaces. Each namespace owns:

  • parameter definitions,
  • default values,
  • validation rules,
  • persistence behavior,
  • migration logic,
  • RPC discovery metadata.

The configuration manager provides:

  • runtime parameter inspection,
  • runtime modification,
  • save/load operations,
  • namespace registration,
  • NVS persistence,
  • version-aware migration support.

Robot geometry, calibration data, controller settings, motion limits, and other runtime behavior are loaded through this system rather than being hardcoded throughout the codebase.

Motion Pipeline

The locomotion stack converts user commands into joint targets through a sequence of dedicated subsystems:

  • gait scheduling,
  • swing trajectory generation,
  • inverse kinematics,
  • velocity limiting,
  • acceleration limiting,
  • jerk limiting,
  • servo actuation.

The motion loop runs at 100 Hz.

Controller Abstraction

Controller transports are separated from locomotion.

Supported ingress paths currently include:

  • FlySky iBUS,
  • Wi-Fi TCP,
  • Bluetooth Classic.

Each transport driver translates incoming data into a normalized controller state consumed by the motion system.

This allows locomotion, gait generation, and motion limiting to remain independent of transport-specific protocols.

Hardware-Aware Design

The robot uses 18 servos arranged as three joints per leg:

  • Coxa
  • Femur
  • Tibia

Servo signal generation is implemented on ESP32 using a combination of MCPWM and LEDC peripherals to fit within available hardware resources.

Power for logic and servos is separated to improve stability under heavy load.


Engineering Problems Being Explored

This project is primarily a learning and engineering platform.

Current focus areas include:

  • real-time control on resource-constrained hardware,
  • gait generation and scheduling,
  • inverse kinematics,
  • motion smoothing and trajectory constraints,
  • configuration architecture for embedded systems,
  • transport-independent control interfaces,
  • robotics software maintainability,
  • practical servo-driven locomotion.

Documentation

The repository contains detailed documentation covering implementation details and architecture decisions.

Common:

Full documentation index: docs/README.md


Project Status

The project is under active development.

Current work focuses on improving locomotion quality, refining control architecture boundaries, and preparing the next generation of leg electronics while keeping the existing robot operational as a test platform.


License

This repository uses Apache License 2.0 for the mainboard firmware.

License file location: LICENSE

Include the following notice in derivative works:

text
Copyright 2025 Pawel Grudzien

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Parts

10
QtyValueFootprintReferences
1Barrel_JackTerminalBlock_Phoenix:TerminalBlock_Phoenix_MKDS-1,5-2_1x02_P5.00mm_HorizontalJ2
1C_100_nFCapacitor_SMD:C_0805_2012MetricC2
1C_10_µFCapacitor_SMD:C_1206_3216MetricC1
1Conn_01x18Connector_FFC-FPC:TE_1-84952-8_1x18-1MP_P1.0mm_HorizontalJ1
1D_SchottkyDiode_SMD:D_SOD-123D2
1ESP32-WROOM-32DLibrary:ESP32_Dev_BoardU1
1LED_SmallLED_SMD:LED_0805_2012MetricD1
1R_SmallResistor_SMD:R_0805_2012MetricR1
1ReveiverConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ23

The 9 most common of 10 parts.

More from quick-brown-bot/hexapod

1
  • 2 layers99.9 × 85.9 mmHexapod, the printed circuit board in 3D

    Hexapod

    quick-brown-bot/hexapod

    Pawels' hobby - main repository of the code for hexapod. Controller used is ESP32 and the code is based on ESP-IDF framework.

    67 parts2

Similar boards

  • 2 layers72 × 42 mmNRF24 jammer, the printed circuit board in 3D

    NRF24 jammer

    W0rthlessS0ul/nRF24_jammer

    The nRF24 jammer is a powerful tool that requires an ESP32 and configurable numbers of NRF24 modules to assemble.

    51 parts1kMIT
  • 2 layers189.5 × 204.9 mmSmartSpin2k Panelized, the printed circuit board in 3D

    SmartSpin2k Panelized

    doudar/SmartSpin2k

    Transform your spin bike into a Smart Trainer!

    749 parts292GPL-2.0
  • 2 layers40 × 53.6 mmCanLite, the printed circuit board in 3D

    CanLite

    voltlog/CanLite

    ESP32 based CAN development board

    42 parts192GPL-3.0
  • 2 layers147 × 80 mmController, the printed circuit board in 3D

    Controller

    voltlog/Valve-Actuator

    If you are looking for sources of previous revisions (revA, revB, revC) checkout the different branches of this repo.

    93 parts108GPL-3.0
  • 2 layers33.5 × 20 mmJURA WiFi Dongle, the printed circuit board in 3D

    JURA WiFi Dongle

    Jutta-Proto/protocol-cpp

    C++ JURA protocol implementation for controlling a Jura coffee maker over a serial (UART) connection.

    31 parts86GPL-3.0
  • 2 layers99.5 × 90.5 mmMRR ESPA, the printed circuit board in 3D

    MRR ESPA

    maplerainresearch/MRR_ESPA

    A basic 3D printer control board based on ESP32

    130 parts59
  • 2 layers22 × 66.5 mmKbxIrBlaster, the printed circuit board in 3D

    KbxIrBlaster

    kbx81/kbxIRBlaster

    ESP32-based IR MegaBlaster!

    106 parts58CC-BY-SA-4.0

Questions

How big is the Esp32 connector PCB?

It measures 41.7 × 49 mm and has 2 copper layers, 1.6 mm thick.

What parts does the Esp32 connector use?

10 parts, built around the ESP32-WROOM-32D. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Esp32 connector KiCad files?

From the quick-brown-bot/hexapod repository on GitHub, at the commit this page was made from: the board is hardware/esp32_connector/esp32_connector.kicad_pcb and its schematic hardware/esp32_connector/esp32_connector.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Esp32 connector design in my own project?

Its repository states no licence, so its author keeps all rights: ask quick-brown-bot before reusing the design.