Skip to the content
2 layers116 × 116 mmPhilo- main, the printed circuit board in 3D

A robot companion that follows you!

Size
116 × 116 mm
Copper layers
2
Thickness
1.6 mm
Parts
66
Nets
58
Pads
258
Tracks, vias
761, 132
Pours
2
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
17 Jun 2026
Updated
16 Oct 2026

Overview

Philo- main is an open-source printed circuit board by dish-glitch, from the dish-glitch/Philobot repository on GitHub. It is a 2-layer board of 116 × 116 mm with 66 parts on 58 nets, routed with 761 tracks and 132 vias.

It is built around the ESP32-WROOM-32, AMS1117-3.3 and MPU-6050. Its parts include 18 capacitors, 14 resistors, 14 connectors, 5 ICs and 2 switches. It belongs with the robots and motor control boards and the ESP32 boards of this library.

Main components

3

README

README.md

Philo — Autonomous Person-Following Robot

A 4-wheeled ground robot that locks onto a person using real-time YOLOv8 pose detection and follows them across a room. Raise your hand and it stops. Lower it and it follows again.

Status License KiCad Platform Vision CAD


Schematic Preview

image

PCB Preview

image

Chassis Preview

Coming soon — Fusion 360 render in progress


What It Does

A Raspberry Pi 5 runs YOLOv8 pose estimation on a live camera feed, detects the nearest person in frame, and continuously streams direction and speed commands to an ESP32 over UART. The ESP32 runs closed-loop PID speed control on four DC motors via dual H-bridge drivers. Three ultrasonic sensors on the front of the chassis act as an independent safety layer — if an obstacle is detected under 25cm, the ESP32 overrides the Pi command and stops regardless of what the vision stack says.

Gesture control: YOLOv8 tracks 17 body keypoints per person. When either wrist keypoint rises above the shoulder keypoint in frame coordinates, the Pi switches to STOP mode and holds it for 5 consecutive frames before acting — this debounces the detection and prevents flickering. Lowering the hand for 5 consecutive frames resumes following. Stop gesture confirmed working in testing.

Sign language recognition: The camera detects ASL hand signs in real time using MediaPipe hand landmarks and a trained classifier. Recognized letters are sent over UART to the ESP32 and displayed live on the onboard OLED (bench-tested on the Arduino stand-in; the ESP32 ASL handler is implemented and awaiting PCB bring-up). Initial testing on Pi 5 shows strong results for most letters — broader testing across different hands, lighting, and environments is still in progress.

Obstacle avoidance: Three HC-SR04 ultrasonic sensors (front-left at -30 degrees, front-center, front-right at +30 degrees) feed into a priority layer in ESP32 firmware. The Pi handles direction. The ESP32 handles not hitting things. These are separate concerns and intentionally kept that way.


How It Works

text
+--------------------------------------------------+
|              Raspberry Pi 5                      |
|                                                  |
|  Camera -> YOLOv8n-pose -> keypoint extraction   |
|               |                                  |
|      Person bounding box offset                  |
|      Wrist vs. shoulder Y position               |
|               |                                  |
|      State machine (FOLLOWING / WAITING)         |
|               |                                  |
|      Serial command -> UART TX                   |
+---------------+----------------------------------+
                |  115200 baud UART
                |  Format: CMD <left> <right> <flags>  (-255..255)
                v
+--------------------------------------------------+
|              ESP32-WROOM-32                      |
|                                                  |
|  UART RX -> parse command                        |
|               |                                  |
|  Ultrasonic check (priority override)            |
|               |                                  |
|  PID speed control per motor side                |
|  PWM via LEDC peripheral at 20kHz               |

Latency budget (targets):

StageTarget
Camera capture~5ms
YOLOv8n-pose inference (imgsz=320)~70ms
Serial transmission~1ms
ESP32 motor response~5ms
Total loop~80ms (~12 Hz)

12 Hz is sufficient for following a walking person. A running person would expose the lag — but that is not the use case.

Why UART and not I2C or SPI: UART is asynchronous and trivially debuggable with a serial monitor. I2C requires the ESP32 to act as master which complicates the Pi-side code. SPI is faster than needed. UART at 115200 baud moves our 20-byte command packets in under 2ms. It is the right tool for this interface.

Why TB6612FNG and not L298N: The L298N drops ~2V across its internal transistors at 1A, wasting power as heat and requiring a heatsink. The TB6612FNG is a MOSFET H-bridge — nearly zero voltage drop, no heatsink needed, physically smaller. It is the correct motor driver for battery-powered mobile robots.

Why YOLOv8n-pose and not separate detection and pose models: One model pass gives you person detection and 17 keypoints simultaneously. Running two models would double inference time and add synchronization complexity. The nano pose model is marginally slower than nano detect-only and eliminates the entire second pipeline.


Hardware

Prices are estimates. Amazon prices fluctuate — verify before ordering. Order DigiKey parts together to share one flat shipping fee (~$8).

ComponentPurposeQtyEst. PriceWhere
ESP32-WROOM-32Main MCU1~$5Amazon
TB6612FNG Dual H-Bridge (bare IC, SSOP-24)Motor driver (2 motors each)2~$2 eaDigiKey
MPU-6050 IMUTilt detection, auto-stop on tip-over1~$2Amazon
JGA25-370 Gear Motors w/ Encoders (6V 200RPM)Drive wheels4~$8 eaAliExpress
80mm Rubber WheelsTraction4~$3 eaAliExpress
HC-SR04 Ultrasonic SensorsObstacle detection3~$1 eaAmazon
SSD1306 OLED 0.96" I2CEyes + ASL display on mast2~$4 eaAmazon
2S LiPo 2200mAhMain battery1~$14Amazon / HobbyKing
2S LiPo Balance ChargerCharging1~$10Amazon
Raspberry Pi 5 (4GB)Vision compute1on handFrom friend — with active cooler
Raspberry Pi Camera Module 312MP, autofocus1on handAttached, confirmed working
AMS1117-3.3 LDO3.3V rail for ESP32 logic1~$1DigiKey
Pololu D24V50F5 Buck (5V 5A)5V rail for Raspberry Pi1~$30Pololu
Littelfuse RGEF700 Polyfuse 7ABattery overcurrent protection1~$2DigiKey
AOD4185 P-channel MOSFETReverse polarity protection1~$1DigiKey
Status LED (any 5mm)Boot/status indicator1~$1Amazon
Tactile switches 6mm THTReset + Boot buttons2~$1Amazon
SMD Resistors 0603 assortmentPull-ups, current limiting—~$9Amazon
SMD Capacitors 0603/0805 assortmentHF decoupling bypass caps—~$10Amazon
Electrolytic caps (1000µF 16V + 2×470µF 16V + 100µF 16V)Bulk decoupling — order separately, not in SMD assortment—~$5DigiKey
XT30 Connector PairBattery connector1~$2Amazon
2.54mm Pin HeadersSensor and UART connectors—~$6Amazon
CP2102 USB-UART ProgrammerFlash ESP32 firmware1~$7Amazon
Custom PCB — JLCPCB (5 boards)From Gerbers1 run~$25JLCPCB
PETG-CF FilamentChassis—$0On hand
M2.5 / M3 Standoffs + ScrewsMounting hardware—~$8Amazon
Total~$215

Repository Structure

text
Philo/
├── hardware/
│   └── kicad/
│       ├── Philo.kicad_sch           # Schematic (ESP32, motors, power, sensors)
│       ├── Philo- main.kicad_pcb     # PCB layout — 116×116mm 2-layer, 4x M3 mounting holes
│       └── gerbers/                  # Production files ready for JLCPCB
│           ├── *.gtl / *.gbl         # Front / back copper
│           ├── *.gts / *.gbs         # Solder mask
│           ├── *.gto / *.gbo         # Silkscreen
│           ├── *.gm1                 # Board outline
│           └── *.drl                 # Drill files
├── firmware/
│   ├── esp32/
│   │   ├── platformio.ini            # PlatformIO config (espressif32 6.9.0)
│   │   └── src/
│   │       ├── main.cpp              # Entry point — 10 Hz sensor + Pi loop
│   │       ├── pins.h                # All GPIO assignments (verified from netlist)
│   │       ├── motors.h / .cpp       # TB6612FNG H-bridge control (PWM via LEDC)
│   │       ├── encoders.h / .cpp     # Interrupt-based wheel encoder counting
│   │       ├── ultrasonic.h / .cpp   # HC-SR04 distance (L / C / R)
│   │       ├── imu.h / .cpp          # MPU-6050 over I²C (accel + gyro)
│   │       ├── display.h / .cpp      # SSD1306 OLED status display
│   │       └── pi_comm.h / .cpp      # UART text protocol to Raspberry Pi
│   ├── arduino/                      # Uno bench-test sketches (ESP32 stand-in)

Build Log

DateMilestone
June 16, 2026Project started. Repository initialized. Team of 4 assembled.
June 17, 2026KiCad schematic started — ESP32, motor drivers, power block
June 21, 2026PCB schematic complete, ERC clean
June 21, 2026PCB layout complete, DRC clean, Gerbers exported
June 22, 2026ESP32 firmware skeleton complete — all modules compile (motors, encoders, ultrasonic, IMU, OLED, Pi UART)
June 22, 2026Gesture stop function confirmed working (tested on Arduino)
June 22, 2026Sign language recognition working for subset of letters — OLED display output confirmed
June 22, 2026Chassis design started in Fusion 360
June 28, 2026Upgraded to Raspberry Pi 5 with active cooler — camera confirmed working
June 28, 2026YOLOv8n-pose running live on Pi 5 — person following confirmed
June 28, 2026ASL sign recognition working well for most letters in initial testing — broader validation ongoing
—PCB ordered from JLCPCB
—Chassis v1 printed in PETG-CF
—PCB arrived, soldered, power-on test passed
—Basic motor spin confirmed over serial
—First person following on robot hardware
—Gesture control working on robot
—Obstacle avoidance tuned
—Demo video filmed
Aug 17, 2026School starts — project complete

Status

  • KiCad schematic — complete, ERC clean
  • PCB layout — complete, DRC clean, Gerbers exported
  • ESP32 firmware skeleton — all modules compile (motors, encoders, ultrasonic, IMU, OLED, Pi UART)
  • ESP32 safety layer — 500ms watchdog, obstacle override, tilt cutoff, sequential ultrasonic firing (needs hardware validation)
  • Pi vision stack — YOLOv8 person following + gesture + ASL running on Pi 5
  • YOLOv8n-pose live on Pi 5 — person following confirmed working
  • Gesture stop — confirmed working in bench testing
  • ASL sign recognition — working well for most letters in initial testing; broader testing ongoing
  • Gesture sensitivity tuning — currently too sensitive, fix tracked in issue #2
  • PCB fabrication (JLCPCB)
  • Chassis design (Fusion 360) — in progress
  • Chassis printed
  • PID speed loop (ESP32)
  • Ultrasonic obstacle avoidance tuning
  • Full system integration on robot hardware
  • Demo video

Team

PersonRole
@dish-glitchPCB design (KiCad) + ESP32 firmware
@sivathamizhan & @dish-glitchRaspberry Pi vision stack — YOLOv8, gesture detection, serial comms
@hummos430Chassis design in Fusion 360 + 3D printing in PETG-CF
@dish-glitch, @hummos430, @sivathamizhanMechanical assembly + integration testing

AI Tools Used

We used Claude (Anthropic) as a reference tool during this project and are disclosing it openly. We had no robotics program, no teacher, and no mentor. AI filled the role a textbook or more experienced teammate would have filled if we'd had access to one.

Where Claude helped:

  • Reviewing GPIO assignments from the KiCad netlist and catching wiring errors before we soldered anything
  • Drafting initial ESP32 firmware modules as a starting point — the team then read through, modified, tested, and debugged everything on actual hardware
  • Diagnosing a PlatformIO build failure (pins_arduino.h not found) caused by a version conflict between espressif32@6.9.0 and 7.0.1
  • Explaining why specific hardware choices make sense (TB6612FNG vs L298N, YOLOv8n-pose vs separate models, UART vs I2C) so we could make informed decisions
  • Helping structure the GitHub repository and draft documentation to a presentable structure.
  • Providing weight and dimension constraints for the chassis — specifically, what size the enclosure needs to be so the motors can actually move it. The chassis itself is fully designed by the team in Fusion 360

What the team built and owns:

  • All hardware decisions — component selection, schematic design, and PCB layout in KiCad
  • The full vision stack — YOLOv8 inference pipeline, ASL classifier, gesture detection, serial comms — written and tested by the team
  • All physical testing and iteration — every debug session, hardware fix, and tuning pass was done by us in the real world
  • The chassis design in Fusion 360 — built by our mechanical lead from scratch
  • Every journal entry — written by the team in our own words

We are happy to answer questions about any part of this project. We have used AI to help build it, but we understand everything we built. If AI helped create any line of code or suggested a part that seemed better, we did the research to understand what that part or code does and why — before it went into the project. The reference robots, papers, and datasheets we used to back up those decisions are collected in docs/RESEARCH.md.


License

MIT — use, modify, share freely. See LICENSE.

Parts

66
QtyValueFootprintReferences
9100nFCapacitor_SMD:C_0603_1608MetricC2, C3, C18, C20, C21, C25, C26, C28, C31
6TestPointTestPoint:TestPoint_Pad_D1.5mmTP1, TP2, TP3, TP4, TP5, TP6
310kResistor_SMD:R_0603_1608MetricR5, R10, R12
310uFCapacitor_SMD:C_0805_2012MetricC17, C19, C32
31KResistor_SMD:R_0603_1608MetricR1, R3, R8
32KResistor_SMD:R_0603_1608MetricR2, R7, R9
24.7kResistor_SMD:R_0603_1608MetricR13, R14
2470uFCapacitor_THT:CP_Radial_D10.0mm_P5.00mmC27, C29
2SW_PushButton_Switch_THT:SW_PUSH_6mmSW1, SW2
2TB6612FNGPackage_SO:SSOP-24_5.3x8.2mm_P0.65mmU6, U7
1100Resistor_SMD:R_0603_1608MetricR11
11000uFCapacitor_THT:CP_Radial_D12.5mm_P5.00mmC22
11uFCapacitor_SMD:C_0603_1608MetricC30
13.3kResistor_SMD:R_0603_1608MetricR6
1AMS1117-3.3Package_TO_SOT_SMD:SOT-223-3_TabPin2U5
1C 10uFCapacitor_SMD:C_0805_2012MetricC23
1C_Polarized 100uFCapacitor_THT:CP_Radial_D6.3mm_P2.50mmC24
1Conn_01x02Connector_AMASS:AMASS_XT30PW-F_1x02_P2.50mm_HorizontalJ7
1Conn_01x04 CenterConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ1
1Conn_01x04 LeftConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ2
1Conn_01x04 rightConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ3
1Conn_01x05Connector_PinHeader_2.54mm:PinHeader_1x05_P2.54mm_VerticalJ8
1ENC_LConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ13
1ENC_RConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ14
1ESP32-WROOM-32RF_Module:ESP32-WROOM-32U8
1J_MASTConnector_PinHeader_2.54mm:PinHeader_1x04_P2.54mm_VerticalJ4
1J_ML_FConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ9
1J_ML_RConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ11
1J_MR_FConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ10
1J_MR_RConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ12
1J_PI_PWRConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJ5
1J_UARTConnector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalJ6
1LEDLED_SMD:LED_0805_2012MetricD1
1MPU-6050Connector_PinHeader_2.54mm:PinHeader_1x08_P2.54mm_VerticalU1
1Polyfuse 7ACapacitor_THT:CP_Radial_D10.0mm_P5.00mmF2
1Q_PMOS_GDSPackage_TO_SOT_SMD:TO-252-3_TabPin2Q2
1R 10kResistor_SMD:R_0603_1608MetricR4

The 62 most common of 66 parts.

Similar boards

  • 4 layers66.8 × 59.2 mmMiners Safety Helmet, the printed circuit board in 3D

    Miners Safety Helmet

    edgeggrr/Miners-Safety-Helmet

    An IoT-based wearable safety helmet designed to enhance underground miner safety through multi-sensor hazard detection, real-time audio-visual alerts, and cloud telemetry via ThingSpeak.

    33 parts3MIT
  • 2 layers70.7 × 100 mmMicromouse V01, the printed circuit board in 3D

    Micromouse V01

    AndrewJNg/Micromouse

    Micromouse alagorithm

    73 parts
  • 4 layers100 × 80 mmHackathon board v2, the printed circuit board in 3D

    Hackathon board v2

    Brian-Nziza/ESP32-Hackathon-Board

    KiCad 10 project. Board is 100 × 80 mm, four layers, fabricated by JLCPCB.

    75 parts
  • 2 layers77.8 × 56 mmGRP Onboarding, the printed circuit board in 3D

    GRP Onboarding

    joshua691/Gaucho-Rocket-Project_Onboarding_IMU_PCB

    This project was developed as part of the onboarding process for Gaucho Rocket Project (GRP). The goal was to design a custom PCB for a rocket motion sensing system capable of collecting inertial measurement data, such…

    42 parts
  • 2 layers65 × 38.2 mmGps tracer, the printed circuit board in 3D

    Gps tracer

    OlegDemk/ESP32_GPS_loger_v1

    GPS logger can log in GPS data every 5 seconds into Micro SD card.

    88 parts
  • 2 layers40 × 60 mmNhat, the printed circuit board in 3D

    Nhat

    tue-minh/PCB_Nhat

    📥 Nhấn vào link bên dưới để xem sơ đồ nguyên lý:

    58 parts
  • 4 layers82 × 100 mmFalcon Edge, the printed circuit board in 3D

    Falcon Edge

    rmingon/Falcon-Edge

    A 3D-printable flying-wing airframe with a custom ESP32 flight computer—open hardware you can solder, screw together, and fly.

    48 parts11
  • 4 layers101.6 × 26.9 mmL2 board, the printed circuit board in 3D

    L2 board

    LulaUAV/Laika-Flight-Computer

    Kicad files for the Laika flight computer

    64 parts2

Questions

How big is the Philo- main PCB?

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

What parts does the Philo- main use?

66 parts, built around the ESP32-WROOM-32, AMS1117-3.3 and MPU-6050. 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 Philo- main KiCad files?

From the dish-glitch/Philobot repository on GitHub, at the commit this page was made from: the board is hardware/kicad/Philo- main.kicad_pcb and its schematic hardware/kicad/POWER.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Philo- main design in my own project?

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