
Controller
google/mozc-devices
Circuit diagrams and firmware source code for Gboard DIY keyboards

A custom omnidirectional mobile robot combining ESP32-S3 firmware, micro-ROS, and ROS 2 Nav2 for autonomous indoor navigation.
Lilithbot PCB v2 is an open-source printed circuit board by arthur-wirjo, from the arthur-wirjo/lilybot_project repository on GitHub, published under the MIT licence. It is a 2-layer board of 70 × 56 mm with 11 parts on 64 nets, routed with 151 tracks and 0 vias.
Its parts include 4 ICs and 1 connector. It belongs with the ESP32 boards of this library.
A custom omnidirectional mobile robot combining ESP32-S3 firmware, micro-ROS, and ROS 2 Nav2 for autonomous indoor navigation.
Lilybot is a personal robotics project built to explore the full stack of an autonomous robot from scratch, from mechanical design and PCB design to embedded motor control and ROS 2 navigation.
The original motivation was simple: I wanted to build a small "smart walking table" that could help carry items around, such as bringing water or transporting cooking utensils to my dorm pantry. More importantly, this project became a way for me to learn how to build a complete autonomous robot system myself instead of only working on isolated parts.
The robot uses an ESP32-S3 for low-level control and sensing, and a Raspberry Pi 5 for higher-level ROS 2 tasks such as LiDAR processing, SLAM, localization, and navigation.
The custom PCB includes:
The level shifters are used because the ESP32 operates at 3.3V logic while the motor interfaces operate at 5V logic.
The motors used in this project are inexpensive geared BLDC motors with built-in motor drivers and encoder feedback. They are convenient for prototyping, but the velocity response is noticeably nonlinear under PWM control.
A simple PID controller alone was too slow and resulted in noticeable drift. Adding feedforward improved the response, but drift remained, especially at certain velocity ranges. I also tried a 2nd-order feedforward model with PID, which improved things further but was still not consistent enough across the full operating range.
To address this, I wrote a motor testing program to measure steady-state motor speed at different PWM duty cycles, plotted the results in a spreadsheet, and converted the data into a 1D lookup table. Linear interpolation was then used between table entries to generate the feedforward term. Combined with PID feedback, this gave the most satisfactory real-world performance.
The system is split into two computing layers.
The ESP32-S3 handles low-level real-time tasks:
The Raspberry Pi 5 handles high-level ROS 2 tasks:
To keep the firmware more reliable and responsive, the ESP32-S3 uses both cores for separate responsibilities.
Core 0 is dedicated to the low-level control loop. Its tasks include:
Core 1 handles communication-heavy and less timing-critical tasks:
cmd_vel commandsThis separation helped keep the control loop more stable while still maintaining communication with the Raspberry Pi.
These instructions assume the Raspberry Pi 5 is running Ubuntu 24.04 and development is done over SSH.
cd ~
git clone https://github.com/arthur-wirjo/lilybot_project.gitLilybot firmware is developed using ESP-IDF.
Install prerequisites:
sudo apt-get update
sudo apt-get install git wget flex bison gperf python3 python3-venv cmake ninja-build ccache libffi-dev libssl-dev dfu-util libusb-1.0-0Clone ESP-IDF:
mkdir -p ~/esp
cd ~/esp
git clone -b v6.0.2 --recursive https://github.com/espressif/esp-idf.gitInstall the toolchain:
cd ~/esp/esp-idf
./install.sh esp32Export the environment:
. $HOME/esp/esp-idf/export.shOptionally, add this alias to ~/.bashrc for convenience:
alias get_idf='. $HOME/esp/esp-idf/export.sh'Then reload:
source ~/.bashrcIn one terminal:
cd ~/lilybot_project/firmware_esp32s3/micro-ROS
idf.py flash monitorIn another terminal:
cd ~/lilybot_project/firmware_esp32s3
docker run -it --rm -v /dev:/dev --privileged --net=host microros/micro-ros-agent:jazzy serial --dev /dev/ttyAMA0 -b 115200Alternatively:
./run_microros_agent.shIn another terminal:
cd ~/lilybot_project/ros2_ws
colcon buildThe main setup commands are:
ros2 launch my_robot_description rsp.launch.py
ros2 run foxglove_bridge foxglove_bridge
ros2 launch sllidar_ros2 sllidar_c1_launch.py serial_port:=/dev/ttyUSB0
ros2 run robot_localization ekf_node --ros-args --params-file src/lilybot_localization/config/ekf.yaml
ros2 launch slam_toolbox online_async_launch.py slam_params_file:=src/lilybot_localization/config/mapper_params.yaml
ros2 launch nav2_bringup bringup_launch.py use_sim_time:=False autostart:=True map:=src/lilybot_navigation/dorm_map.yaml params_file:=src/lilybot_navigation/config/custom_nav2_params.yaml
ros2 run nav2_map_server map_saver_cli -f src/lilybot_navigation/dorm_mapAdditional setup commands are documented in the repository.
This project was built solo, including:
One of the main challenges was achieving stable and consistent wheel speed control using low-cost motors with nonlinear PWM-to-speed behavior.
The progression was roughly:
The lookup-table-based feedforward gave the best results in practice.
Encoder-based odometry was noisier than expected, especially due to the characteristics of the motors and drivetrain. This made low-pass filtering important for producing more stable velocity and odometry estimates.
Using both ESP32 cores helped keep the real-time motor control loop more reliable while offloading communication and sensor publishing to the other core.
Looking back with more hardware experience from my later DIY FOC controller project, I would have used a ground copper pour instead of manually routing ground traces point-to-point. In this case the board was simple and low power, so it still worked acceptably, but it was still not the best layout practice.
| Qty | Value | Footprint | References |
|---|---|---|---|
| 3 | convenient BLDC motor | lilithbot foorprint library:BDLC Motor | M1, M2, M3 |
| 2 | 3.3v & 5.5v Logic Shifter | lilithbot foorprint library:Logic Shifter | U2, U3 |
| 1 | GY-9250 IMU | lilithbot foorprint library:imu | U4 |
| 1 | PDB board | lilithbot foorprint library:PDB | P1 |
| 1 | esp32-s3-devkitc-1-n16r8 | lilithbot foorprint library:esp32-s3-devkitc-1-n16r8 | U1 |
The 8 most common of 11 parts.

google/mozc-devices
Circuit diagrams and firmware source code for Gboard DIY keyboards


FrameworkComputer/ExpansionCards
Reference designs and documentation to create Expansion Cards for the Framework Laptop

hoglet67/RGBtoHDMI
Bare-metal Raspberry Pi project that provides pixel-perfect sampling of Retro Computer RGB/YUV video and conversion to HDMI

hackclub/OnBoard
💡 Join 1,000 teenagers and make your first PCB with a $100 grant!


tardate/LittleArduinoProjects
a collection of "Little Electronic & Arduino Projects", most involving electronics or an Arduino in one way or another!

basilfx/TRADFRI-Hacking
Hacking IKEA TRÅDFRI products, such as light bulbs, window blinds and other accessories.
It measures 70 × 56 mm and has 2 copper layers, 1.6 mm thick.
11 parts. 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.
From the arthur-wirjo/lilybot_project repository on GitHub, at the commit this page was made from: the board is electronics/lilithbot PCB v2.kicad_pcb and its schematic electronics/lilithbot PCB v2.kicad_sch. PCBKit opens the board in the browser, with nothing to install.
Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).