How to build PlayBot (open dock that turns a Playdate handheld into a desktop robot): the whole process
86 steps to build PlayBot (open dock that turns a Playdate handheld into a desktop robot), from buying parts, printing and assembly to software, calibration and training…
The creator's estimate in the hardware README: about $100–120 per bot, shipping excluded; the Playdate itself is not included (Panic's official store listed it at $229.00 on 2026‑11‑04, out of stock that day). The custom boards cost about $10 each but are ordered in batches of 5; the optional HuskyLens is not in the estimate. There is no official kit price
Bill of materials · Hardware
| Part | Qty |
|---|---|
| Custom PCBs | 2 |
| Teensy 4.1 microcontroller | 1 |
| TOF10120 | 2 |
| Low profile headers 12 pins | 1 |
| SG90 servo | 1 |
| ITR20001 | 2 |
Buy parts
- Order Two Custom PCBs
Order two custom PCBs from JLCPCB, using the Gerber files and BOMs.
- Buy a Teensy 4.1 Microcontroller
Buy one Teensy 4.1 microcontroller from the PJCRC store.
- Buy Two TOF10120 Sensors
Buy two TOF10120 sensors using the AlliExpress link listed in the document.
- Buy a 12-Pin Low-Profile Header
Buy one set of 12-pin low-profile headers using the example AlliExpress link listed in the document.
- Buy One SG90 Servo
Buy one SG90 servo using the example AlliExpress link listed in the document.
- Buy the robot parts and tools
Prepare the listed 1.3 mm push rod connector, micro SD card, 24 AWG wire, and optional HuskyLens. The price is around 100/120 $ per bot without shipping; custom PCBs cost 10 $ each but must be ordered in bulk of 5. PlayBot requires considerable soldering and custom connectors and wires, so it is not plug-and-play.
- Select the custom power board
Use the custom board with an MCP73831 charger, TPS61023 5V boost converter, and MAX17048 fuel gauge. It supports load sharing and can remain plugged in while the robot runs; it also charges the Playdate while the robot is active, with a red charging LED and a yellow fully charged LED.
- Select the main board
Use the board that connects the various sensors, motors, and servos and distributes power to the Teensy. Special low-profile headers are required to fit the Teensy inside the case.
- Check the DRV8835 product page
Check the Pololu product page for more information about the DRV8835 board.
- Prepare the Playdate console
Prepare a Panic Inc. Playdate handheld console to serve as PlayBot's brain and charging dock.
- Get the complete bill of materials
Open the hardware directory to obtain the complete bill of materials and assembly instructions.
- Obtain a Teensy 4.1
Use a Teensy 4.1 microcontroller as the USB hub for the Playdate and for serial communication.
- Obtain two TOF sensors
Obtain two TOF distance sensors.
- Obtain the TEMT6000 sensor
Obtain a TEMT6000 ambient light sensor.
- Obtain two IR sensors
Obtain two IR sensors.
- Obtain dual encoder motors
Obtain dual motors with encoders for driving the robot.
- Obtain the MAX1704X fuel gauge
Obtain a MAX1704X fuel gauge.
- Add the optional Huskylens camera
For vision AI, an additional camera powered by Huskylens is compatible.
Print and make
- Print the shell and upper frame
Print these 3D-printed parts on a Bambu Lab A1 mini with generic PLA.
- Print the lower frame and base
Print the lower frame and base on a Bambu Lab A1 mini with generic PLA.
- Print the PlayBot frame
PlayBot's frame is entirely 3D printed.
Assemble
- Cut the Teensy USB power trace
Cut the USB power trace to protect the battery-powered Teensy. The document presents this as a recommendation.
- Install male Teensy headers
Solder male headers onto the Teensy main side pins and USB host pins.
- Install female main-board headers
Solder low-profile female headers onto the PlayBot main board so the Teensy can fit inside the case.
- Cut the servo ear flush
Cut the servo's left plastic ear flush with the body.
- Open the servo case
Remove the four screws and open the servo case.
- Cut and identify servo wires
Cut or desolder the wires and note the color code: brown is GND, red is V+, and orange is signal.
- Replace servo wires with JST SH
Solder new wires with a JST SH connector, paying attention to the servo connector wiring.
- Modify and center the servo horn
Enlarge the horn hole with a soldering iron and press-fit it onto the servo axle while the horn is soft. Center the servo position with the test firmware before screwing it.
- Install top-frame brass inserts
Follow the heated brass insert tutorial for PLA and add five brass inserts to the top of the frame.
- Install lower-frame brass inserts
Add four more brass inserts to the bottom of the frame.
- Secure the main board
Secure the main board directly to the frame with four M2 screws.
- Press-fit the ball bearings
Press-fit the two ball bearings into the frame.
- Install the power switch and USB-C
Solder the power switch and USB-C input to the power management board. Press-fit the USB-C plug into the bottom frame and optionally secure it with a small amount of hot glue.
- Screw the power board to the frame
Screw the power board to the bottom of the frame.
- Insert the LiPo battery
Slide the LiPo battery into the dedicated socket on the frame.
- Add four brass inserts
Add 4 brass inserts to the middle frame.
- Attach the DRV8835 board
Attach the DRV8835 board directly in the middle of the part using double-sided adhesive.
- Solder the motor JST connector
Solder the MODE, AIN1, AIN2, BIN1, BIN2, VCC, and GND pins to a 7-pin JST SH connector for the motors.
- Create the custom motor plug
Create a custom plug for the motors. M1 and M2 carry power from the DRV8835 board, while the other four wires provide encoder feedback through ENC1 and ENC2.
- Join the middle and top frames
Before adding the motors, attach the middle and top frames together using 2 M2 screws.
- Create the power harness
Create a power harness with JST PH connectors that powers the main board and DRV8835 from the power board's output.
- Note the main-board connector change
In the last revision, the main board's PH connector was replaced with simple solder pads.
- Install the ball caster wheels
Remove the screws, insert the ball caster wheels, and screw them back onto the frame.
- Create the USB plug
Create a USB plug connected to a 4-pin JST PH connector.
- Secure the PH connector
Add a small amount of hot glue to secure the PH connector.
- Create the PH-to-SH connector
Create a 4-pin PH-to-SH connector to connect to the USERIAL connector on the main board.
- Glue the plastic rings
The USB plugs come with small plastic rings that can be glued to the part.
- Press-fit the dock magnets
Press-fit the magnets into the dock.
- Solder 3-pin JST SH connector to TEMT6000 light sensor
Solder a 3-pin JST SH connector to the light sensor so it connects to the TEMT connector on the main board.
- Screw and bolt light sensor to shell
Screw and bolt the light sensor to the shell.
- Screw and bolt SPDT switch to shell
Screw and bolt the SPDT switch to the shell.
- Solder 4-pin JST SH connector to TOF sensors
Solder a 4-pin JST SH connector to the TOF sensor so it connects to TOF1 and TOF2 on the main board; you can cut the RX/TX wires since I²C is used through a 2-channel multiplexer.
- Mount both TOF sensors front and back of shell
Attach both sensors at the front and back of the shell with M2.5x6 screws and nylon nuts.
- Assemble remaining parts in the given order
Once no errors show up, assemble the remaining parts in the order shown; this is tricky because everything is tightly packed inside the shell.
- Attach screen base with M3 screw
Attach the screen base with an M3 screw; do not overtighten it.
- Cut servo pull rod to 20 mm and attach to arm
Cut a servo pull rod at 20 mm and attach it to the servo's arm with a connector.
- Assemble PlayBot
Assemble the robot by following the assembly instructions in the hardware directory.
Software
- Create the main program
Create PlayBot.ino with a main program loop and initialization, orchestrating all subsystems and managing communication between components.
- Implement the animation manager
Create AnimationManager.h to play animations from the SD card, control servo movements, coordinate motors for animations, and process frames in real time.
- Implement the battery manager
Create BatteryManager.h to monitor battery voltage with the MAX17048 gauge, detect charging state, and report power state to the Playdate.
- Implement the communication manager
Create CommunicationManager.h for USB serial communication with the Playdate, message parsing and routing, and protocol handling for all subsystems.
- Implement the LED controller
Create LEDController.h to control WS2812 LEDs and provide status indication.
- Implement the motor controller
Create MotorController.h with DRV8835 motor driver control, PID-based motor control, encoder feedback processing, and rotation and movement commands.
- Implement the sensor manager
Create SensorManager.h to manage ToF distance sensors, IR edge detection, and light sensor readings. Implement collision detection, sensor data aggregation, and reporting.
- Implement the storage manager
Create StorageManager.h for SD card initialization and file system management.
- Create the system configuration
Create Config.h with system-wide configuration parameters, pin definitions, timing constants, and sensor thresholds.
- Implement debugging and logging
Create Debug.h and Debug.cpp for debugging infrastructure, error logging, setup error tracking, and log buffering and transmission.
- Implement the distance tracker
Create DistanceTracker.h to track total distance traveled, persist distance logs, and record movement statistics.
- Create the hardware configuration
Create HardwareConfig.h and HardwareConfig.cpp with hardware-specific configurations, pin assignments, physical constants, and hardware object initialization.
- Install Teensyduino and Arduino IDE
Install the Arduino IDE and the Teensyduino add-on using the linked page.
- Flash the PlayBot firmware
Use the Arduino IDE with Teensyduino to flash the firmware from the src/PlayBot directory onto the robot.
- Install the PlayBot dependencies
Install USBHost_t36, Encoder, drv8835-motor-shield, SD library, Servo library, MAX1704X, PID_V1, WS2812FX, and CircularBuffer.
- Sideload the Playdate companion app
Get the Lua app from the separate pd-playbot-app repository and sideload it onto the Playdate.
- Install Required Libraries
Install the Encoder, Adafruit_MAX1704X, PCA9540BD, DRV8835MotorShield, and Servo libraries.
- Upload Program to Teensy
Use the Arduino IDE to upload the program to the Teensy.
- Flash animation files to the micro SD card
Flash the micro SD card with the animation files; you can still access the SD card from your computer with the help of the MTP_Teensy library.
Calibrate and test
- Open Serial Monitor
Open the Serial Monitor at 115200 baud.
- Start Sensor Monitoring
Send the character 's' to start monitoring.
- Test Specific Components
Use the commands to test specific hardware components.
- Check connections before testing
Double-check the connections before every step.
- Run the boot-sequence test
Plug in the components and test the boot sequence to ensure everything works correctly.
Use it
- Use the console's integrated sensors
PlayBot uses the Playdate's integrated accelerometer and microphone, and the console sends motor commands and gathers sensor values to the Teensy over serial.
- Use the robot and charging dock
PlayBot can serve as a charging dock for the Playdate, with about 45 minutes of autonomous operation per charge.
- Use the custom Blender rig
Use the custom rig and sequence exporter written in Python from the separate Playbot_Rig repository to animate, render, and export custom animation sequences in Blender.
- PlayBot assembly complete
All parts are assembled and your PlayBot is complete.
Parts
- Two custom boards ordered from JLCPCB: a power board (MCP73831 charger, TPS61023 5V boost, MAX17048 fuel gauge) and a main board
- A Teensy 4.1 microcontroller (with low-profile headers) and a Pololu DRV8835 dual motor driver
- Two N20 6V 500RPM encoder gearmotors with N20 wheels, two mini ball casters and two 6×3×2.5 flanged bearings
- An SG90 servo, a 120 mm servo push rod and a 1.3 mm push-rod connector
- Two TOF10120 sensors, a TEMT6000 light sensor and two ITR20001 IR sensors; a 1S LiPo battery, SPDT switch, male/female USB‑C connectors and a microSD card
- JST SH (pre-crimped recommended) and JST PH connectors, 24 AWG wire, M2 screws and M2×5 heat-set inserts, nylon nuts, an M3×40 nylon screw and four 6×3 magnets; 5 printed parts (base, lower, middle and upper frames, shell)
Tools
- Soldering iron, flux, heat-shrink tubing, precision screwdrivers, tweezers, helping hands with a magnifier, wire strippers (20–30 AWG), Kapton tape
- A JST PH crimp tool; a JST SH crimp tool is optional (expensive, pre-crimped wires work instead)
- A 3D printer (the creator uses a Bambu Lab A1 mini with PLA)
Skills
- Fine soldering and making JST cables; modifying the SG90 (trimming an ear, rewiring, enlarging the horn with a soldering iron)
- Flashing firmware with the Arduino IDE and Teensyduino, testing every step with the sensor-test firmware first
- Sideloading the Lua app onto the Playdate; optionally animating in Blender
Software
- Teensy firmware (Arduino / Teensyduino): motor PID, sensors, battery, LEDs and animation management
- pd-playbot-app: the Lua app on the Playdate, a state machine and behaviour system built on Noble Engine
- Playbot_Rig: a Blender rig and animation-sequence exporter (Python)