Building Snake Robots: ESP32, Gaits & Servos

Learning Goal: Design and assemble a multi-segment biomimetic snake robot, programming lateral undulation and sidewinding locomotion gaits using chained micro-servos and an ESP32.

Estimated Total Study Time: 26 Hours

Module 1: Foundations of Snake Locomotion & Kinematics

In this module, you will explore the biology and physics of serpentine movement. You will learn how natural snakes leverage friction and muscle waves to move across surfaces, and examine the foundational mathematical models—specifically Shigeo Hirose's Serpenoid Curve—used to translate biological slithering into joint-by-joint robotic control.

Core Kinematic Concept: The Serpenoid Curve

While high-level kinematics lectures cover general arm coordinates, snake robots rely on a specific spatial formula first characterized by Dr. Shigeo Hirose. The Serpenoid Curve represents the target winding angle $\theta_i$ of the $i$ -th joint as a function of time $t$ :

$\theta_i(t) = A \sin(\omega t + i \beta) + \gamma$

Where:

$A$ is the amplitude of the wave (controlling the winding tightness).
$\omega$ is the temporal frequency (controlling the propagation speed).
$\beta$ is the spatial phase shift (controlling the wave frequency along the body length).
$i$ is the joint index (0, 1, 2... $N-1$ ).
$\gamma$ is the angular offset (used to steer the robot left or right).

Note on Pool Gaps: The core video pool lacks a direct derivation of this formula. Ensure you review the mathematical breakdown above, as it is the framework you will code in Module 4.

Module 1 Knowledge Checkpoint

Explain how anisotropic scale friction enables a snake to generate forward thrust from lateral movements.
Define the four primary biological gaits of snakes: lateral undulation, sidewinding, concertina, and rectilinear.
Identify how many degrees of freedom (DoF) are present in a 1D snake robot with 8 hinge joints.
Explain how the $\gamma$ variable in the Serpenoid Curve formula changes the path of a snake robot.

Module 2: ESP32 Microcontroller & Multi-Servo Control

In this module, you will shift from theory to control systems. You will learn to configure your ESP32 environment, interface with the PCA9685 16-channel PWM controller over I2C, and safely manage high-current wiring diagrams to prevent power spikes from resetting your microcontroller.

Module 2 Knowledge Checkpoint

Successfully configure the Arduino IDE to compile and upload code to your ESP32 board.
Connect the PCA9685 to the ESP32’s hardware I2C pins (typically GPIO 21 for SDA and GPIO 22 for SCL).
Explain why you should never power multiple servos directly from the ESP32's onboard 3.3V or 5V voltage regulators.
Wire an external high-current power supply to the PCA9685 terminal block while maintaining a common ground with the ESP32.

Module 3: Mechanical Assembly & Power Systems

In this module, you will design and construct the physical body of the snake robot. You will learn to construct modular, alternating 3D-printed joint segments, analyze joint rotation limits to prevent mechanical collision, and configure battery systems using buck converters to supply high current.

Mechanical Assembly Principles

When assembling your snake robot's links:

Mechanical Clearance: Ensure each segment can rotate at least $\pm 45^\circ$ without physical interference from wiring or neighboring shells.
Servo Zeroing: Before mounting your horn linkages, connect your servos to the PCA9685 and programmatically write a $90^\circ$ (neutral) position. Mount the horns so that the joint is perfectly straight when at $90^\circ$ .
Alternating vs. Single-Axis: If you plan to only perform lateral undulation, align all servos vertically so that all joints swing horizontally. If you plan to sidewind or climb, alternate each segment $90^\circ$ relative to the last (Segment 0 horizontal, Segment 1 vertical, Segment 2 horizontal, etc.).

Module 3 Knowledge Checkpoint

Assemble at least 8 mechanical segments of the snake robot with securely mounted servos.
Programmatically center all servos to their neutral 90-degree position before securing the output horns.
Connect a 2S or 3S LiPo battery through a high-current buck converter, adjusting the potentiometer to output a steady 5V–6V DC.
Inspect the wire harness routing to ensure no cables are pinched or stretched when the joints flex to their mechanical limits.

Module 4: Programming Lateral Undulation Gaits

In this module, you will develop the core software that drives the snake forward. You will write code that calculates the Serpenoid Curve dynamically and propagates this mathematical wave through your chained servo motors.

Step-by-Step Programming Guide & C++ Template

Note on Pool Gaps: Because the video library lacks a direct step-by-step code tutorial for programming lateral undulation on an ESP32, utilize the following code block as your starting point.

Assuming you are using a 1D snake (all joints swing horizontally, connected to PCA9685 channels 0 to $N-1$ ):

#include <Wire.h> #include <Adafruit_PWMServoDriver.h>

// Initialize the PCA9685 driver (Default address: 0x40) Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define USMIN 600 // Minimum pulse length out of 4096 (approx 0 degrees) #define USMAX 2400 // Maximum pulse length out of 4096 (approx 180 degrees) #define NUM_SERVOS 8 // Number of segments

// Serpenoid Parameters float amplitude = 35.0; // Wave amplitude in degrees float spatial_phase = 0.6; // Phase shift between adjacent joints (beta) float speed_coef = 4.0; // Speed multiplier for the temporal wave (omega) float steering_offset = 0.0; // Left/Right trim (gamma)

void setup() { Serial.begin(115200); pwm.begin(); pwm.setOscillatorFrequency(27000000); pwm.setPWMFreq(50); // Standard Analog Servos run at 50Hz delay(10); }

// Helper to map angles (0-180) to PCA9685 PWM pulse ticks int angleToTicks(double angle) { double pulse = map(angle, 0, 180, USMIN, USMAX); return (int)(pulse * 4096 / 20000); // Map pulse width to 12-bit duty cycle (20ms period) }

void loop() { float time_seconds = millis() / 1000.0;

for (int i = 0; i < NUM_SERVOS; i++) { // Calculate the target angle using the Serpenoid Curve formula float targetAngle = amplitude * sin(speed_coef * time_seconds + i * spatial_phase) + 90.0 + steering_offset;

// Constrain angle to prevent physical servo binding
targetAngle = constrain(targetAngle, 45.0, 135.0);

// Write angle to PCA9685 output channel
pwm.setPWM(i, 0, angleToTicks(targetAngle));

// Optional: Print to Serial Plotter to verify wave offsets
if (i == 0) Serial.print("J0:");
Serial.print(targetAngle);
if (i < NUM_SERVOS - 1) Serial.print(",");

} Serial.println(); delay(15); // Dynamic delay step }

Module 4 Knowledge Checkpoint

Program your ESP32 to calculate and print sinusoidal values to the Arduino Serial Plotter.
Adapt the code template above to compile and run on your ESP32 board.
Tune the spatial_phase value to observe how it changes the number of wave cycles on your snake.
Tune the amplitude value to optimize mechanical propulsion without causing joint servo binding.

Module 5: Advanced Gaits: Sidewinding and Steering

In this module, you will learn to implement advanced 3D locomotion gaits. By controlling both horizontal and vertical joint structures, you will learn how to phase-shift perpendicular waves to lift parts of the body off the ground, enabling diagonal sidewinding and turning maneuvers.

Mathematics & Code Implementation of Sidewinding

Note on Pool Gaps: Because there are no direct code walkthroughs for programming 3D sidewinding in the standard video pool, review and implement the mathematical concept detailed below:

Sidewinding requires a 3D snake body where segments alternate between horizontal joints (even indexes) and vertical joints (odd indexes).

Two waves are run simultaneously down the body:

$\theta_{\text{horizontal}, 2k}(t) = A_h \sin(\omega t + 2k \beta)$

$\theta_{\text{vertical}, 2k+1}(t) = A_v \sin(\omega t + (2k+1) \beta + \Delta \phi)$

Where $\Delta \phi$ is the phase difference between the vertical and horizontal waves (typically set to $\pm 90^\circ$ or $\pm \pi/2$ radians). This phase shift coordinates the joint lifting: while a segment is flexing laterally, it is lifted vertically off the ground to clear friction, then placed back down to push off.

ESP32 Implementation Concept for Sidewinding:

To implement this in your code, loop through your servos and apply the respective wave equation based on whether the joint index is odd or even:

for (int i = 0; i < NUM_SERVOS; i++) { float targetAngle = 90.0; float t_phase = speed_coef * time_seconds + i * spatial_phase;

if (i % 2 == 0) { // Horizontal Joints targetAngle += amp_horizontal * sin(t_phase) + steering_offset; } else { // Vertical Joints targetAngle += amp_vertical * sin(t_phase + phase_shift_3d); }

pwm.setPWM(i, 0, angleToTicks(targetAngle)); }

Module 5 Knowledge Checkpoint

Explain how vertical and horizontal waves interact to lift and anchor parts of a sidewinding snake robot.
Program a phase shift ( $\Delta \phi$ ) of exactly 90 degrees ( $\pi/2$ ) between alternating vertical and horizontal joints.
Implement a dynamic steering offset that allows you to turn the snake while maintaining a sidewinding gait.
Test the snake robot on different surfaces, tuning amplitude ratios ( $A_h / A_v$ ) to minimize slip.

Course Map

Key People Index

Dr. Shigeo Hirose
- Context: Pioneer in biomechanics and robotic engineering. He was the first to model serpentine motion mathematically and introduced the Serpenoid Curve to robotics.
Matthew Travers
- Context: Researcher at the Carnegie Mellon University (CMU) Biorobotics Lab. His team developed modular climbing snake robots (including the EELS project designed for extraterrestrial exploration).
James Bruton
- Context: Renowned robotics designer and former toy developer. He provides invaluable open-source guides on mechanical assembly, linkage designs, and joint testing for multi-servo systems.

Final Self-Assessment

Perform this comprehensive final inspection to verify that your biomimetic snake robot is fully functional:

Physical Check: All mechanical joints rotate smoothly through their range ( $\pm 45^\circ$ ) without catching wires or hitting structural limits.
Power Safety: The buck converter steps down battery voltage to a level safe for your servos (5V–6V) and does not warm up under active workloads.
Signal Check: The ESP32 communicates with the PCA9685 over I2C without bus drops or logic resets when the servos start drawing current.
Mathematical Modeling: You can explain the function of Amplitude ( $A$ ), Frequency ( $\omega$ ), and Spatial Phase ( $\beta$ ) in the Serpenoid Curve.
Symmetric Motion: Under lateral undulation, the snake’s joint positions trace out a clean sine wave when monitored on the Serial Plotter.
Forward Undulation: The robot moves forward on a high-friction surface (like carpet) using lateral undulation.
Steering Verification: The robot turns left and right when you write a non-zero steering offset value ( $\gamma$ ) to the joint equations.
3D Gait Execution: The robot sidewinds across flat terrain using alternating joint structures coordinated by perpendicular, phase-shifted waves.

Explore Further

Related Robotics Roadmaps

View All→

robotics

Building Snake Robots: ESP32, Gaits & Servos

Module 1: Foundations of Snake Locomotion & Kinematics

Recommended Videos

Core Kinematic Concept: The Serpenoid Curve

Module 1 Knowledge Checkpoint

Module 2: ESP32 Microcontroller & Multi-Servo Control

Recommended Videos

Module 2 Knowledge Checkpoint

Module 3: Mechanical Assembly & Power Systems

Recommended Videos

Mechanical Assembly Principles

Module 3 Knowledge Checkpoint

Module 4: Programming Lateral Undulation Gaits

Recommended Videos

Step-by-Step Programming Guide & C++ Template

Module 4 Knowledge Checkpoint

Module 5: Advanced Gaits: Sidewinding and Steering

Recommended Videos

Mathematics & Code Implementation of Sidewinding

ESP32 Implementation Concept for Sidewinding:

Module 5 Knowledge Checkpoint

Course Map

Key People Index

Final Self-Assessment

Related Robotics Roadmaps

CDPR: Kinematics, Arduino & Winch Control

Rocker-Bogie Rover: Build, Stereo Vision & ROS

Building AGVs: QR Navigation & Lifter Systems

EMG Exoskeletons: Design, Control & Actuation