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)
| Part | Qty |
|---|---|
| 180 degree MG90S all-metal micro servos · Amazon | 8 (buy 10 for spares |
| 0.96" SSD1306 I2C OLED · Amazon | 1 |
| USB-C data/power cable · Amazon | 1 |
| Rocker power switch (KCD1, panel mount) · Amazon | 1 |
| 22AWG silicone wire kit · Amazon | 1 |
| 30AWG silicone wire kit · Amazon | 1 |
| Heat-shrink assortment · Amazon | 1 |
| Small zip ties · Amazon | 1 pack |
Bill of materials · Wiring Option A – S2 Mini / Hand-Wired Harness
| Part | Qty |
|---|---|
| Lolin/WeMos ESP32-S2 Mini · Amazon | 1 |
| Small protoboard (approx. 5×7 cm) · Amazon | 1 |
| 3-pin male headers · Amazon | 8 |
| Buck converter (5–12 V in to stable 5V/3A out) · Amazon | 1 |
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