Connecting to sources…

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

PartQty
Custom PCBs2
Teensy 4.1 microcontroller1
TOF101202
Low profile headers 12 pins1
SG90 servo1
ITR200012

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)

Documents