Connecting to sources…

How to build Sesame Robot (Sesame Robot Project): the whole process

286 steps to build Sesame Robot (Sesame Robot Project), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop …

The README puts hardware at about $50–60 with access to a 3D printer; filament, tools and shipping excluded. FCE's complete kit is $100 and the electronics kit $85 (both sold out on 2026‑10‑31)

Bill of materials · Core Electronics (Both Builds)

PartQty
180 degree MG90S all-metal micro servos · Amazon8 (buy 10 for spares
0.96" SSD1306 I2C OLED · Amazon1
USB-C data/power cable · Amazon1
Rocker power switch (KCD1, panel mount) · Amazon1
22AWG silicone wire kit · Amazon1
30AWG silicone wire kit · Amazon1
Heat-shrink assortment · Amazon1
Small zip ties · Amazon1 pack

Bill of materials · Wiring Option A – S2 Mini / Hand-Wired Harness

PartQty
Lolin/WeMos ESP32-S2 Mini · Amazon1
Small protoboard (approx. 5×7 cm) · Amazon1
3-pin male headers · Amazon8
Buck converter (5–12 V in to stable 5V/3A out) · Amazon1

Buy parts

  • Choose a wiring strategy and open the build guide

    Choose a wiring strategy that fits your parts bin, then follow the build flow in docs/build-guide/README.md.

  • Buy 180-degree MG90S metal-gear servos

    Buy eight 180-degree MG90S all-metal micro servos, or ten for spares. They are the primary hip and leg actuators and include servo horns, but keep the extras.

  • Buy a 0.96-inch SSD1306 OLED

    Buy one 0.96-inch SSD1306 I2C OLED. It is a 128×64 display that slides into the top cover slot.

  • Buy a USB-C data and power cable

    Buy one USB-C data/power cable. It needs to carry 5V/3A for flashing and tethered mode.

  • Buy a KCD1 rocker power switch

    Buy one panel-mount KCD1 rocker power switch. It snaps into the top cover cutout.

  • Buy a 22AWG silicone wire kit

    Buy one 22AWG silicone wire kit for power and ground bus lines.

  • Buy a 30AWG silicone wire kit

    Buy one 30AWG silicone wire kit for signal leads and dense harnessing.

  • Buy a heat-shrink assortment

    Buy one heat-shrink assortment to insulate the OLED, switch, and battery joints.

  • Buy small zip ties

    Buy one pack of small zip ties for bundling wires inside the frame.

  • Buy ESP32-S2 Mini

    Buy 1 Lolin/WeMos ESP32-S2 Mini with native USB-C that fits on a perfboard.

  • Buy small protoboard

    Buy 1 small protoboard, approximately 5×7 cm, to host the header matrix and rails.

  • Buy 3-pin male headers

    Buy 8 3-pin male headers to build the servo breakout; match the spacing to MG90 plugs.

  • Buy buck converter

    Buy 1 buck converter with 5–12 V input and stable 5V/3A output to power the motors and MCU when using batteries.

  • Check kit distro board

    A purchased Sesame Build Kit already includes an assembled, pre-flashed V2 Distro Board, so these parts do not need to be ordered separately.

  • Confirm existing V1 board

    Choose this legacy option only if you already have a V1 board; V1 is phased out but still supported.

  • Buy ESP32-DevKitC-32E

    Buy 1 ESP32-DevKitC-32E (ESP32-WROOM-32) as the base board for Distro Board V1. Use the 32E with a floating PCB antenna, or the 32U with an antenna routed inside.

  • Buy electrolytic capacitor

    Buy 1 1000 µF electrolytic capacitor to smooth the buck converter output; a 10V+ rating is recommended.

  • Buy 4-pin connector header

    Buy 1 4-pin JST-XH or PH header for the optional external connector footprint on the PCB.

  • Buy 2-pin screw terminal

    Buy 1 2-pin screw terminal with a 2.54 mm pitch for the optional battery input on the PCB.

  • Buy M2.5 standoffs

    Buy 4 M2.5×5 mm male-female standoffs to elevate the PCB over the DevKit mounting holes.

  • Select a Compatible Stock Battery

    A Bambu Lab 14500 7.4V 800mAh Li-ion battery fits the new stock battery cavity, while V3 requires the new internal frame to be printed.

  • Use Two Servos Per Leg

    Choose one hip servo and one knee servo for each leg.

  • Choose Sesame Distro Board V3

    Distro Board V3 is the current version. It comes pre-flashed with the latest firmware and supports the Bambu Lab battery.

  • Choose Lolin S2 Mini from Scratch

    Hand-wired Lolin S2 Mini builds remain fully supported. The document recommends them when building from scratch.

  • Gather the parts

    Prepare eight MG90 servos, an S2 Mini or Distro Board, the OLED, and a power source. The BOM in the repository contains everything.

  • Buy Sesame components

    Obtain eight MG90 servos, an ESP32 using a Lolin S2 Mini or Sesame Distro Board, a 128x64 OLED display, a 5 V 3 A power source, and PLA filament for about $50 to $60.

  • Prepare tools and software

    Prepare a 3D printer or printing service, a soldering iron, small screwdrivers, and a computer with the Arduino IDE and ESP32 boards package.

  • Obtain Sesame project files

    Get the CAD, STL files, firmware, Sesame Studio, bill of materials, and build guides from the GitHub repository.

  • Use the Kit's Pre-Flashed Board

    Sesame Build Kits include a pre-flashed Sesame Distro Board V3 or an earlier V2, so no separate board needs to be ordered or assembled.

  • Choose S2 Mini Hand Wiring

    When building from scratch, the S2 Mini with hand wiring approach is recommended. V2/V3 distro boards use advanced SMD components requiring specialized soldering skills or PCB assembly services.

  • Buy a Pre-Assembled V3 Board

    Pre-assembled Sesame Distro Board V3 units are available in limited stock from Full Contact Engineering. The V3 USB-C PD 12V negotiation chip is slightly untested, so a high-quality PD cable is necessary.

  • Obtain the V1 Files

    All V1 files are located in the distro-v1/ directory.

  • Collect electronics, connectors, and fasteners

    Before soldering, use the BOM to collect electronics, power gear, connectors, and fasteners. Prepare the 6–8 main electronic components required by the wiring approach.

  • Choose the power plan and connectors

    Choose between USB-C PD and a battery with a buck converter, then source matching connectors. Two 14500 Li-ion cells fit the stock battery cavity in a 2× AAA holder.

  • Stock consumables and M2 hardware

    Stock solder, flux, heat-shrink tubing, zip ties, and M2 hardware.

  • Choose a wiring approach

    Choose Lolin S2 Mini hand wiring, Sesame Distro Board V3, or a legacy approach based on component availability and comfort managing wire bundles.

  • Obtain the Sesame Distro Board

    The Sesame Distro Board V1 is a custom PCB designed for this project and mounts on top of an ESP32-DevKitC-32E. More PCB information is available in the hardware documentation.

  • Choose a Wiring Strategy

    Compare the protoboard and custom PCB routes in the guide. The Lolin S2 Mini build is recommended for DIY builders; the V3 or early V2 Distro Board included with a Sesame Build Kit is already pre-flashed and ready to use.

  • Source Electronics

    Source electronics using the line-by-line list in bom/README.md, and verify that the power supply meets the 5V/3A requirement.

  • Gather the required electronics

    Check the Bill of Materials for the complete hardware list. Select a supported microcontroller configuration, 8 MG90 servos, and a 5V 3A power source using USB-C PD, a battery with a buck converter, or the listed Bambu Lab battery option.

Print and make

  • Print Sesame in PLA

    Most parts require no supports, but the top cover needs supports in targeted areas.

  • Choose a Top Cover Style

    Three top cover styles are currently available. Enclosed v91 is recommended for its magnetic hat mounts, covered display wires, and multicolor detail support; details are under stl/top-covers/.

  • Print the Upgrade Internal Frame

    For upgrading an older Sesame to the recommended Bambu Lab 14500 Li-ion battery, print the new internal frame STL.

  • Set the Print Material

    Use PLA or PLA+ as the print material.

  • Set Infill and Walls

    Use 8–10% infill, 2 wall loops, and a honeycomb infill pattern.

  • Print Right Joint R1

    Print right joint R1 from R1-v117.stl. This component requires no supports.

  • Print Right Joint R2

    Print right joint R2 from R2-v117.stl. This component requires no supports.

  • Print Right Joint R3

    Print right joint R3 from R3-v117.stl. This component requires no supports.

  • Print Right Joint R4

    Print right joint R4 from R4-v117.stl. This component requires no supports.

  • Print Left Joint L1

    Print left joint L1 from L1-v117.stl. This component requires no supports.

  • Print Left Joint L2

    Print left joint L2 from L2-v117.stl. This component requires no supports.

  • Print Left Joint L3

    Print left joint L3 from L3-v117.stl. This component requires no supports.

  • Print Left Joint L4

    Print left joint L4 from L4-v117.stl. This component requires no supports.

  • Print the Internal Frame

    Print the internal frame from Internal-Frame-v121.stl. This component requires no supports.

  • Print the Bottom Cover

    Print the bottom cover from Bottom-Cover-v121.stl. This component requires no supports.

  • Print the Top Cover

    Choose and print a top cover from stl/top-covers/. The top cover requires supports; Enclosed v91 is recommended.

  • Redesign Components for Major Size Changes

    You may need to redesign certain components when making significant size changes.

  • Edit Native Files With Fusion 360

    Use the Autodesk Fusion 360 personal license to open native `.f3d` files; enable the Design History timeline before changing dimensions to see how assemblies were built.

  • Adjust STEP Models With FreeCAD

    Import `.step` files into FreeCAD, adjust sketches, and re-export STL or STEP files without losing references; use the Part Design workbench for parametric edits.

  • Edit in the Browser With Onshape

    Upload STEP files with the Onshape free plan and edit directly in the browser. It is suitable for Chromebook users or real-time collaboration.

  • Quick Edits With Meshmixer or Blender

    To shave openings or add text, import the STL into Meshmixer or Blender, make the change, and re-export. Use the parametric source for anything dimension-critical.

  • Branch Edits and Preserve Original CAD

    Keep the original STEP or Fusion file untouched and branch edits into a copy so changes can always be rebased onto the upstream design when new hardware revisions ship.

  • Order V3/V2 distro PCB

    Order 1 Sesame Distro Board V3/V2 PCB; it is a fully SMD design that can use PCBway assembly or advanced hand soldering.

  • Order V1 distro PCB

    Order 1 Sesame Distro Board V1 PCB through PCBway using `Gerber_Sesame-Distro-Board_PCB_Sesame-Distro-Board_V1.zip`.

  • Print the V3 Internal Frame

    When using Distro Board V3, print the new internal frame so the battery fits in the new stock battery cavity.

  • Order the V3.1 Distro Board PCB

    Order the Sesame Distro Board V3.1 PCB through the one-click PCBway link. V3.1 corrects trace routing and battery connector polarity, so a new board requires no manual modifications.

  • Upload Gerbers for PCB Fabrication

    Upload the Gerber files to PCBway to have the Sesame Robot boards manufactured.

  • Order Fully Assembled PCBs

    Upload the Gerber, BOM, and Pick-and-Place files to receive fully assembled boards; the document recommends this option for V2.

  • Print Femur Links Flat

    The femur links use squared-off sections instead of rounded ones so they lie flat on the print bed. The parts are designed to print without supports.

  • Print the robot frame

    Print the frame in PLA with minimal supports. Printing takes about an afternoon.

  • Print the Sesame frame

    Print the frame in PLA with minimal supports. Printing takes about an afternoon.

  • Print and clean all plastic parts

    Print the 11 plastic parts, including the internal frame, top and bottom covers, and joints R1–R4/L1–L4, then clean them up.

  • Print the Shell and Joints

    Follow the presets in printing/README.md to prepare the 3D files in hardware/printing/stl.

  • Download and print the STLs

    Download the STLs and follow the Printing Guide. The printed parts are designed for PLA and require minimal supports.

Assemble

  • Arrange all connectors before soldering

    Before soldering, lay out every connector in the order shown on the wiring diagram to keep data lines from crossing.

  • Solder power rails and buck first

    Tin and solder the rails and buck converter first, then route the signal wires. Leave generous length for motors that terminate near the hips.

  • Label the servo leads

    Optionally label each servo lead as S0–S7 with tape flags as soon as it is soldered.

  • Defer the switch and OLED wiring

    Do not permanently wire the power switch or OLED yet. Make those final joints after the electronics are seated in the frame so the cable length can be set exactly.

  • Finish and strain-relieve the harness

    Complete the harness according to the wiring diagram and strain-relieve every joint. Bundle the servo leads loosely by destination, and pre-cut but leave unsoldered the power-switch and OLED leads.

  • Prepare Four Hip Joints

    Find the four hip joints and the one-sided servo horns in the servo motor bags, ignoring the extra included screws.

  • Press In the Short Horn Side

    The servo horn has a taller side and a shorter side. Press the shorter side into the hip joint, with just enough clearance for it to sit flush.

  • Secure the Servo Horn

    Hold the horn flat and secure it with an M2 × 5 mm self-threading screw through the second hole into the plastic. Do not overtighten, because the plastic threads can be permanently damaged.

  • Repeat for Three More Hip Joints

    Repeat the horn insertion and fastening steps for hip joints R1, R2, L1, and L2.

  • Do Not Mount the Servos Yet

    Keep the hip joints off the servos because calibration requires every motor shaft to spin freely.

  • Slide the Leg Shell Over Its Motor

    Before the frame installation, slide each leg shell over its dedicated motor. Route the wires through the built-in gap without pinching them.

  • Route the Motor Wires

    Feed the motor wires through the slot on the side of the leg piece.

  • Insert the Motor Into the Leg

    Push the motor into the holed side of the leg piece and make sure the motor shaft is at the very top.

  • Permanently Secure the Motor

    Confirm that the motor sits flush, then use self-threading screws to permanently affix it to the leg piece.

  • Repeat for the Remaining Legs

    Repeat the shell fitting, wire routing, motor insertion, and motor fastening steps for the remaining legs.

  • Install the power switch

    Press the battery switch firmly into the back slot of the top cover. Do not connect the wires yet.

  • Solder the OLED display wires

    Apply a small amount of solder to the display pin headers for tinning. Use the pre-crimped JST connector wires, match them to the respective display marks, and solder them.

  • Install and secure the OLED display

    Gently push the wired OLED display into its slot inside the top cover. Insert self-threading screws into the small holes beside the display to clamp it permanently in place.

  • Install the battery holder

    Insert the battery holder into the back of the internal frame piece. Route the red and black wires up the slot.

  • Install the four side motors

    Hold the battery wires in place while inserting the four remaining side motors into the internal frame with their shafts facing outward. Insert them at an angle and then press them fully in without pinching any wires at the bottom.

  • Secure the four side motors

    Use self-threading screws to permanently secure all four side motors to the frame. Make sure the motor shafts are closest to the outer edge of the frame.

  • Trim and route loose wires

    Before installing the hardware, trim or bundle stray wires so they cannot flop into the servo gears, and double-check that every connection exits upward.

  • Pre-route long wires upward

    Pre-route long wires upward so they naturally hug the future top cover.

  • Lower the electronics harness

    Lower the electronics harness into the cavity while keeping the USB port toward the rear.

  • Screw in the S2 controller

    Screw the controller, and the optional protoboard, directly into the frame using the provided mounting holes.

  • Secure the optional protoboard

    If you built a small protoboard backplane, secure it with the spare holes in the internal frame so the servo plugs remain easy to reach later.

  • Install V1 board standoffs

    Install four M2.5 × 5 mm male-female standoffs to raise the Sesame Distro Board V1 above the ESP32 DevKit.

  • Secure the raised V1 board

    Then secure the assembly using the top screws.

  • Attach the V3/V2 main board

    Bring the cables gently toward the center, attach the main board to the internal frame, and secure its two corner mounting holes with self-threading screws.

  • Confirm board orientation

    The notch indicates the front and the USB port indicates the back; use these cues whenever the orientation is ambiguous.

  • Connect to the controller portal

    Check the Wi-Fi networks on your phone or computer, then connect to the access point created by the Sesame board to open the controller portal. On desktop, open `sesame-root.local` if the portal does not show; mobile is recommended.

  • Match motor numbers to positions

    Use the diagram to match motor numbers with their physical positions and ensure the frames are roughly oriented correctly.

  • Plug in all eight motors

    Start with Motor 0 and plug its connector into the corresponding board header, aligning the brown wire with the ground rail. Repeat for all eight motors; each motor should whir into life and hold its position.

  • Attach the hip joints

    With the motors in "Stand" mode, select the matching hip joint for each motor and push it onto the motor shaft at a 45-degree angle.

  • Fasten the hip joints

    After confirming correct placement, fasten the hip joint to the motor with an M2.5 machine screw through the main hole into the motor shaft. Tighten gently to avoid over-torquing the motor and causing a brownout.

  • Attach the leg joints

    Repeat the same attachment process for the leg joints. Check their movement and any collisions with "Rest" and "Stand", then affix them using screws.

  • Connect the battery

    Insert the battery wires into the board's screw terminal and tighten them securely with a flathead screwdriver.

  • Route and secure wires

    Flip the robot over and firmly press all the wires into the channels on the underside.

  • Bundle the wires

    Separate the wires gently into left and right groups, wrap and tighten a zip tie around each bundle, and fold each zip tie once so the top cover fits seamlessly.

  • Fit the top cover

    Gently pack all the wire bundles in and slowly press the top cover down onto the electronic components, avoiding shorting or disconnecting anything.

Software

  • Check Whether Flashing Is Needed

    Sesame Build Kit Distro Board V3 and earlier V2 units already come pre-flashed with the latest firmware. Flash firmware only if you want to customize it or update it to a newer version.

  • Enable network mode

    Set your WiFi password and set ENABLE_NETWORK_MODE to true to enable network mode. Leave ENABLE_NETWORK_MODE false to use Access Point mode only.

  • Upload the firmware

    In Arduino IDE, click the Upload button. Wait for compilation and upload to complete.

  • Fix Linux USB permissions

    If the port is missing or access is denied, add your user to the dialout group, then log out and back in.

  • Troubleshoot firmware upload

    If uploading fails, hold the BOOT button while uploading or try a different USB cable. For S3-based boards, check the USB CDC On Boot setting when the port is not found after a reset.

  • Install USB drivers

    Install CP210x drivers for S2 Mini or CH340 drivers for some ESP32 boards. Windows 10/11 usually includes these.

  • Fix network connection

    Verify that ENABLE_NETWORK_MODE is true and that the SSID and password are correct. Check Serial Monitor for connection status, use a 2.4GHz WiFi network, or increase the code's connection timeout, currently 10 seconds and 20 attempts.

  • Resolve the mDNS hostname

    On Windows, install Bonjour Print Services. On Linux, ensure avahi-daemon is installed and running. Try the IP address from Serial Monitor if mDNS is blocked by the router.

  • Troubleshoot API commands

    Send POST requests to /api/command, set the Content-Type header to application/json, and check Serial Monitor for errors and parsed command output. Test connectivity with a simple cURL command first.

  • Open the firmware entry point

    Open `sesame-firmware-main.ino` as the firmware entry point. Keep `face-bitmaps.h`, `movement-sequences.h`, and `captive-portal.h` with it for OLED faces, movement animations, and the web-based remote-control interface.

  • Build firmware with Arduino-ESP32

    Build the firmware with the Arduino-ESP32 framework. It uses a single-core event loop and hardware-based PWM timers for motor control.

  • Enable dual-mode WiFi

    Configure the ESP32 with `WiFi.mode(WIFI_AP_STA)` so its Access Point and Station modes operate simultaneously.

  • Initialize the SoftAP

    Initialize the ESP32 Access Point with `WiFi.softAP()`. Configure a `DNSServer` to listen on UDP port 53 and redirect wildcard DNS queries to the internal gateway at `192.168.4.1`.

  • Advertise the robot over mDNS

    Use the `ESPmDNS` library to broadcast the robot as `sesame-robot.local`, allowing clients to discover it without hardcoded IP addresses.

  • Configure the web API endpoints

    Set up the `WebServer` with `/cmd?go=[dir]` for legacy movement, `/cmd?pose=[name]` for legacy pose triggers, `GET /api/status` for JSON status, and `POST /api/command` for JSON commands.

  • Support face-only commands

    Make `/api/command` detect requests without a `command` field as face-only updates. Update the display without triggering movement animations.

  • Implement non-blocking command handling

    Replace `delay()` with `pressingCheck(String cmd, int ms)`, polling `server.handleClient()` and `dnsServer.processNextRequest()` during animation frames. Use this protocol for motion commands so walking plays only while the button is held.

  • Configure settings endpoints

    Add the `/getSettings` endpoint to retrieve parameter configuration and the `/setSettings` endpoint to change it.

  • Start microphone speech recognition

    Create a speech recognizer and repeatedly open the microphone, print “Listening...”, and set the robot face to idle while listening.

  • Capture speech with a timeout

    Listen for audio with a five-second timeout and set the robot face to thinking after audio is captured.

  • Recognize speech and show emotion

    Recognize the captured audio with Google, print the recognized text, analyze its sentiment, and display the resulting emotion with the talking face enabled.

  • Pause before returning to neutral

    Wait two seconds after command processing, then keep the analyzed emotion but disable the talking state.

  • Handle speech recognition errors

    Show the sleepy face when speech recognition times out and the confused face when the value is unknown.

  • Define the notification handler

    Import requests and define a robot_notification function that uses the local Sesame Robot address.

  • Map notification types to emotions

    Begin the notification emotion map with doorbell as surprised, alarm as angry, and reminder as thinking.

  • Send the mapped face command

    Complete the emotion map with success and error, use default for unmatched types, and post the selected face to the robot command API.

  • Add optional doorbell movement

    For a doorbell notification, optionally send a wave command with the happy face.

  • Customize Idle Blink Timing

    Open sesame-firmware-main.ino and set scheduleNextIdleBlink() to use 3000–7000 milliseconds between random blinks.

  • Customize the idle blink timing

    Modify the timing values in sesame-firmware-main.ino. The documented setting uses 3000 ms as the minimum interval and 7000 ms as the maximum interval between blinks.

  • Upload the Sesame firmware

    Upload the code from the Firmware Directory to the robot. The document identifies Arduino IDE as the required software.

  • Prepare the Arduino IDE

    Use Arduino IDE to prepare and upload the firmware code.

  • Create robot animations in Sesame Studio

    Use Sesame Studio to visually design poses and animation sequences for the robot.

  • Pose the robot in 3D

    Open the Sesame Studio desktop application and visually pose the robot in its 3D viewport using the actual printed STL geometry.

  • Sequence animation frames

    Sequence frames into complex animations and apply custom transitions and delays.

  • Design OLED face bitmaps

    Design 128x64 OLED face bitmaps, or directly open, edit, and save Arduino `face-bitmaps.h` files.

  • Generate firmware animation code

    Generate C++ code containing servo angles and bitmaps that is ready to paste into the firmware.

  • Set up the ESP32 firmware

    Follow the linked Firmware Docs for `sesame-firmware-main.ino`. The firmware handles the robot's kinematics, face display, and WiFi control interface.

  • Connect through the Web UI

    Connect a phone to the robot's built-in Access Point. Use the Web UI to control the robot.

  • Add a custom robot face

    Follow the guide in the firmware docs to add your own bitmap as a custom face.

  • Use the Pre-Flashed V3 Firmware

    When using Distro Board V3, use the latest firmware already flashed onto the board.

Calibrate and test

  • Open the Serial Monitor

    Open Serial Monitor from Tools, set the baud rate to 115200, and reset the board. Startup messages and network information should appear.

  • Test individual motors

    Use the individual motor controls in the Serial Monitor to test the robot and troubleshoot motor behavior.

  • Troubleshoot motor movement

    If the robot does not move, check the power supply and servo connections. If brownouts occur, increase motorCurrentDelay in the web settings.

  • Check ESP32 PWM timer allocation

    Reserve hardware timers 0-3 with `ESP32PWM::allocateTimer(n)` to avoid peripheral conflicts and provide 50Hz PWM signals. If custom firmware experiences network errors, check the timer allocation.

  • Set servo pulse-width mappings

    Map leg servos from 0-180 degrees to 732us-2929us and edit the `servos[i].attach()` calls when needed. For 270-degree servos, use 833us-2167us.

  • Adjust sequential motor-current delay

    Tune `motorCurrentDelay`, which defaults to 20ms between sequential pulses, for the power setup. With a strong dedicated power supply, try setting it to zero; it can also be changed while running through the AP controller settings menu.

  • Use the Default Access Point

    Connect to the Sesame-Controller-BETA WiFi network using password 12345678. The robot's IP address is 192.168.4.1.

  • Open the WiFi Settings Panel

    Connect to the Sesame-Controller-BETA access point and open the captive portal. Go to Settings → WiFi / Network.

  • Select a 2.4GHz WiFi Network

    Tap Scan for Networks and select your 2.4GHz network. For a hidden SSID, tick Enter name manually.

  • Connect the Robot to WiFi

    Enter the network password and tap Connect. The connection takes about 15 seconds; the phone may briefly disconnect while the robot changes WiFi channels, then reconnects automatically.

  • Re-enter WiFi After Reboot

    WiFi credentials entered through the web interface are not persisted because the firmware sets WiFi.persistent(false). After a reboot, the robot returns to access-point mode and the credentials must be entered again.

  • Check the OLED WiFi Information

    During the first 30 seconds without input, the display scrolls the AP SSID and IP, the network name and IP when connected, the mDNS hostname, and captive portal instructions. After the first input, the WiFi information disappears so only faces remain; when connected to both an AP and a network, both connection details are displayed.

  • Read and Update Firmware Settings

    Retrieve the current frameDelay, walkCycles, motorCurrentDelay, and faceFps values with GET /getSettings. Update those values with GET /setSettings and the selected query parameters.

  • Quickly test the MG90 servos

    Quickly test the MG90 servos with a servo tester or Arduino to catch dead-on-arrival units.

  • Adjust and insulate the buck converter

    Trim the buck converter to a 5.1 V output and cover it with heat-shrink tubing.

  • Detach joints before calibration

    Never run calibration with the joints attached.

  • Keep motor shafts free

    All motor shafts should be free-spinning at this point.

  • Inspect the test harness

    Inspect the harness for bare conductors that could short during testing, and add heat-shrink or tape where needed.

  • Open motor testing guide

    Open the linked Motor testing guide.

  • Power the V3/V2 board

    Plug the board into a strong USB power supply; phone fast chargers or laptop chargers work well. V3/V2 Build Kit boards come pre-flashed with Sesame firmware, so no computer or Arduino IDE flashing is needed.

  • Use USB-C for V2 board

    The V2 Distro Board currently has battery-system instabilities and will not work on batteries; plug it in via USB-C.

  • Initialize PWM channels

    Tap the "Standby" button in the portal to initialize the PWM channels. When a motor is plugged in, it will immediately move to its correct active position.

  • Test the hip joint angles

    Tap "Rest" in the portal and check that the hip joint moves perfectly parallel to the body. Tap "Stand" again and check that it returns to 45 degrees; alternate them to confirm correct placement.

  • Test the switch

    Ensure the batteries are charged and inserted, flip the switch, and check whether the Wi-Fi network appears or the display lights up. If it does not work, double-check the connections. V2 Distro board owners must currently run Sesame via USB-C.

  • Adjust Motor Activation Delay

    If the power supply is marginal, raise motorCurrentDelay in the web settings without changing code. The firmware staggers motor activation to reduce the current spike.

  • Connect the Sesame controller

    After connecting to the robot’s access point, open the captive-portal controller. Use it to walk, turn, trigger emotes, and adjust settings such as calibration and speed.

  • Test commands over serial

    Use the serial command line for the same commands during bench testing.

  • Test Sesame motions and display

    Test Sesame's walking, turning, waving, dancing, pointing, push-ups, and worm motions, and confirm that its OLED shows animated faces.

  • Check power and ground lines

    Double-check the power and ground lines before turning the robot on.

  • Cover exposed wires

    Cover exposed wires because they can touch the pin headers and fry the ESP32.

  • Test Before Applying Power

    Test the connections before applying power.

  • Configure the WiFi access point

    Configure the WiFi AP settings before using the flashed firmware.

Use it

  • Connect in AP mode

    When using AP mode only, connect to the Sesame-Controller-BETA WiFi network with password 12345678, then navigate to any website.

  • Connect in network mode

    In network mode, look for the "Connected to network!" message in Serial Monitor. Access the robot at http://sesame-robot.local or at the displayed IP address.

  • Open the Captive Portal

    After connecting to the network, navigate to any website to access the captive portal control interface. If the default password does not work, change AP_PASS in the code.

  • Open the Robot Network Address

    After a successful connection, the panel shows the link to http://sesame-robot.local and the assigned IP address.

  • Control Movement with Legacy Endpoints

    Send the legacy movement requests to move the robot forward, backward, left, or right, or to stop it.

  • Trigger the Robot Poses

    Request the wave, dance, rest, or stand pose through the legacy pose endpoint. Refer to movement-sequences.h for all available poses.

  • Set an Individual Motor Angle

    Address motors 1 through 8 and set each motor to an angle from 0 to 180 degrees.

  • Get the Robot JSON Status

    Request GET /api/status to read the current command, current face, network connection state, AP IP, and network IP.

  • Send a JSON Movement Command

    POST a JSON body containing the command and face to the command endpoint, using Content-Type: application/json. The example executes the forward command with the walk face.

  • Update Only the Robot Face

    POST a JSON body containing only the face field to change the face without triggering movement. The example sets the face to happy.

  • Stop the Robot Remotely

    POST a JSON body with the command set to stop to stop the robot through the JSON API.

  • Query the robot status

    Send an HTTP request to GET /api/status to read the robot’s state and current face.

  • Send robot commands

    Send a movement command, a face, or both to POST /api/command. Anything that can make an HTTP request can drive Sesame, including Python scripts, JavaScript, and home automation.

  • Use the OLED emote animations

    Walk, dance, dead, worm, and every other emote has matching OLED frames, while the idle animation blinks on its own. Conversational faces include happy, sad, angry, surprised, sleepy, love, excited, confused, and thinking, each with a talk_ variant.

  • Create animations, faces, and scripts

    Create animations in Sesame Studio, add faces to the robot, or script it over the API.

  • Control Sesame over Wi-Fi

    Control Sesame from a phone through its own Wi-Fi control panel; no app or Bluetooth pairing is needed.

  • Drive Sesame with its JSON API

    Use Sesame's JSON API to drive the robot with Python, JavaScript, or home automation.

Common problems

  • PCB ordering and fabrication constraints block builds #77 #67
  • Servo setup lacks precise positioning and smooth motion tuning #17 #75 #61
  • Firmware fails to compile due to movement-sequences.h syntax errors #34 #39
  • Battery-powered builds fail when servo loads cause resets #56 #85
  • Supplied CAD and STL files are corrupt or contain no geometry #13 #52 #70
  • Wiring diagrams do not clearly map servo headers to ESP32 pins #4 #31
  • Clone ESP32 boards reset in access-point mode without a firmware workaround #54
  • Printed walls are too thin and lack mechanical resilience #16

Parts

  • 8 × 180° MG90S metal-gear micro servos (buy 10 for spares; must be the 180° version)
  • 0.96-inch SSD1306 I2C OLED (128×64)
  • Controller: a Lolin S2 Mini hand-wired on perfboard (recommended for scratch builds) or the Sesame Distro Board V3.1 (ESP32‑S3, all SMD, pre-flashed in kits)
  • 5V 3A power: USB‑C PD, or a battery with a buck converter; the Bambu Lab 14500 7.4V 800 mAh Li-ion pack is recommended
  • KCD1 rocker switch, 22/30AWG silicone wire, heat-shrink, about 40 M2×5 self-tapping screws, 10 M2.5×5 screws
  • 11 PLA prints: 8 joints, internal frame, top and bottom covers (8–10% infill, supports only for the top cover)

Tools

  • 3D printer or a printing service
  • Soldering iron, solder, flux pen and solder wick
  • Flush cutters and precision screwdrivers
  • Hot air for a self-assembled Distro Board, or PCBWay's assembly service

Skills

  • Basic soldering and harness building
  • Arduino IDE with the ESP32 board package (ESP32Servo must be 3.0.9)
  • Servo calibration before fitting the joints
  • Optional: Python or JavaScript against the JSON API

Software

  • Arduino firmware sesame-firmware-main.ino: web UI, JSON API, serial CLI
  • Sesame Studio: Python animation and face editor that generates firmware C++
  • Sesame Companion App: Python voice companion (Gemini or a local LLM)
  • Community: a Rust browser simulator and the sesame-ml RL tools

Documents