Overview

Leika is an open-source quadruped robot built around the ESP32 microcontroller. The project combines embedded firmware, web-based control interfaces, and a physics-based simulation environment to create a complete robotics development platform. Using FreeRTOS for real-time task management, the robot handles inverse kinematics, gait generation, sensor fusion, and wireless communication simultaneously.

The project includes a PyBullet simulation environment for testing control algorithms and training reinforcement learning policies before deploying to hardware.

Key Features

Hardware & Firmware

• ESP32-based control system with FreeRTOS
• Inverse kinematics with 3-DOF legs
• Multiple gait implementations (Bezier trot, 8-phase crawl)
• Real-time sensor integration
• Multiple hardware variants (standard, Yertle, and upcoming ✨Leika Mini✨)

Web Controller

• Self-hosted web interface embedded in firmware
• Dual joystick control with real-time robot visualization
• Complete configuration interface (calibration, network, settings)
• Built with Svelte and embedded using LittleFS

Simulation & Training

• PyBullet physics simulation with Gymnasium interface
• Reinforcement learning support (PPO, SAC)
• Parallel training infrastructure
• Model evaluation and comparison tools
• Interactive kinematics playground

Architecture

Control Flow

The robot implements a sense-plan-act control architecture:

1. Sense: Read IMU, magnetometer and gensture sensor
2. Plan: Process sensor data, compute inverse kinematics, generate gait trajectories
3. Act: Send servo commands, stream telemetry data

Kinematics

The kinematics system allows control through Cartesian coordinates rather than raw joint angles. This abstraction simplifies motion planning and enables intuitive control.

The robot's body pose in the world reference frame:

$$T_{body}=\left[x_b,y_b,z_b,\phi, \theta,\psi\right]$$

Where:

• $x_b, y_b, z_b$ are Cartesian coordinates of the body center
• $\phi, \theta,\psi$ represent roll, pitch, and yaw angles

Foot positions in the world reference frame:

$$P_{feet}=\{(x_{f_i},y_{f_i},z_{f_i})|i=1,2,3,4\}$$

The inverse kinematics solver converts these high-level commands into joint angles for the 12 servos (3 per leg). The kinematics library is implemented in C++ for the ESP32 firmware and TypeScript for the web controller, enabling both real-time control and browser-based visualization.

Web Controller

The web interface is built with SvelteKit and compiled to static assets that are embedded directly in the ESP32 firmware. This approach eliminates the need for external servers and ensures the controller is always synchronized with the firmware version.

Features:

• Real-time 3D robot visualization
• Dual joystick control with configurable input mapping
• Network configuration and WiFi management
• Servo calibration tools
• System monitoring and diagnostics
• Firmware over-the-air updates

Motion Control

The motion system is implemented as a finite state machine supporting multiple locomotion modes:

Available Gaits

Trot Gait (12-Point Bezier)

• Uses continuous phase time $t\in[0,1]$ with configurable swing/stance ratios
• Swing phase: 12-point Bezier curve for smooth foot trajectories
• Stance phase: Sinusoidal curve for body weight transfer
• Supports diagonal leg pairs moving in opposition
• Enables dynamic turning through trajectory modification

8-Phase Crawl Gait

• Static stability: three feet always on ground
• Sequential leg lifting with center-of-mass shifting
• Discrete phase transitions based on phase time accumulation
• Suitable for rough terrain and slow, stable locomotion
• Based on the implementation from mike4192's spotMicro

Static/Dynamic Posing

• Direct body pose control without locomotion
• Used for manual positioning, rest states, and transitions

Controller Input Mapping

Simulation Environment

A PyBullet-based physics simulation is available for algorithm development and reinforcement learning training:

cd simulation
pip install -r requirements.txt
python play.py

Features:

• Real-time interactive control with GUI
• Multiple terrain types (flat, heightmap, maze)
• Gymnasium-compatible interface for RL
• PPO and SAC algorithm support
• Parallel training capabilities
• Training scripts with TensorBoard integration

The simulation environment allows testing control algorithms and training policies before deploying to hardware. See simulation/README.md for detailed documentation.

Hardware Variants

Leika (Standard)

The original design supporting 12 servos with full 3-DOF leg control. Suitable for experimentation and learning about quadruped robotics.

Yertle

A crossbreed between Kangal, SpotMicro and Open Quadruped

Leika Mini (In Development)

A smaller and more affordable variant currently under development. Leika Mini aims to lower the entry barrier while being fully compatible with the platform.

Kinematics Configuration

Motion Limits:

• Maximum roll/pitch: ±15°
• Maximum body shift: W/3 in X and Z directions
• Maximum step length: 80% of leg reach
• Maximum step height: 50% of leg reach

The kinematics system automatically adapts to the selected hardware variant through compile-time configuration flags (SPOTMICRO_ESP32, SPOTMICRO_ESP32_MINI, SPOTMICRO_YERTLE).

Hardware & Electronics

Mechanical Components

The robot body is constructed from 3D-printed parts based on various Spot Micro community designs:

• robjk reinforced shoulder remix
• Kooba SpotMicroESP32 remix
• KDY0532 original design

Electronics

Getting Started

Hardware Build

Complete build instructions are available in the documentation:

1. Components and BOM
2. Assembly Instructions
3. Software Installation
4. Initial Configuration
5. Running the Robot

Firmware Development

Prerequisites:

• PlatformIO IDE or CLI
• Node.js 18+ (for web controller development)

Build and flash:

git clone https://github.com/runeharlyk/SpotMicroESP32-Leika
cd SpotMicroESP32-Leika

cd app
pnpm install
cd ..

pio run -t upload
pio run -t uploadfs

Configuration is managed through factory_settings.ini and features.ini in the esp32/ directory.

Simulation Only

To experiment with the simulation environments without hardware:

cd simulation
pip install -r requirements.txt
python play.py

For development workflows and contribution guidelines, see docs/6_developing.md and docs/7_contributing.md.

Project Structure

├── app/                    # SvelteKit web controller
├── docs/                   # Build and software documentation
├── esp32/                  # ESP32 firmware (PlatformIO)
│   ├── include/           # Firmware headers
│   ├── src/               # Firmware source
│   └── lib/               # Third-party libraries (TensorFlow Lite Micro)
├── simulation/             # PyBullet simulation environment
├── hardware/              # 3D printable parts and CAD files
├── scripts/               # Utility scripts

Documentation

• Software Architecture
• API Reference
• Kinematics Details
• Motion System

Roadmap

Track planned features and active development on the project board. Report bugs or request features through GitHub issues.

Related Projects

If you're interested in quadruped robotics, check out:

• mike4192's Spot Micro - ROS-based implementation with advanced features
• SpotMicroAI - Community hub for Spot Micro variants
• Stanford Pupper - Another affordable quadruped platform
• OpenQuadruped - Research-focused quadruped project

License

This project is licensed under the MIT License - see LICENSE.md for details.

Contact

Rune Harlyk - runeharlyk.dk

Project Repository: https://github.com/runeharlyk/SpotMicroESP32-Leika