Talos

Dashboard

Comment

TALOS — Autonomous Self-Balancing Robotics Platform

Inspiration

TALOS was inspired by a simple question: how can we build a two-wheeled robot that can dynamically support and balance its own body instead of simply driving around?

We wanted to create a project that combined mechanical engineering, electronics, embedded programming, control systems, and software into one physical system. A self-balancing robot was the perfect challenge because even a small delay in sensing or motor response can cause the entire robot to fall.

Instead of relying on a pre-built balancing platform, we designed and developed TALOS as an integrated system, including its mechanical structure, leg mechanism, sensors, motor control, embedded firmware, and web-based control interface.

What We Built

TALOS is a two-wheeled self-balancing robot with actively controlled legs.

The robot uses an MPU6050 IMU to measure its body orientation and angular velocity. AS5600 magnetic encoders provide feedback about the leg positions, allowing the legs to actively maintain a desired posture.

The wheels are controlled continuously based on the robot's measured tilt:

$$u = K_P e + K_D\dot{e}$$

where:

  • $u$ is the wheel control output
  • $e$ is the balance-angle error
  • $K_P$ controls the response to tilt
  • $K_D$ provides damping based on angular velocity

We also experimented with predictive balancing, using the current angular velocity to estimate where the robot's angle is heading rather than waiting until the robot has already tilted significantly.

The robot is accompanied by a web-based control dashboard that allows us to monitor and control the system, including its balance state, sensors, motors, calibration, and safety parameters.

How We Built It

Mechanical System

We designed and assembled the robot around a central body with two independently actuated legs and wheels. The leg mechanism allows TALOS to change its body height while maintaining contact with the ground.

Electronics

An ESP32 acts as the main controller. The system integrates:

  • MPU6050 for body orientation and gyroscope measurements
  • AS5600 magnetic encoders for leg position feedback
  • Continuous-rotation wheel servos for balancing and movement
  • High-torque leg servos for active leg support
  • Buck converters for separate power regulation of the actuator systems

Firmware

The ESP32 firmware handles:

  • IMU initialization and calibration
  • Leg-position calibration
  • Closed-loop leg control
  • Balance control
  • Wheel control
  • Fall detection
  • Sensor fault handling
  • Wi-Fi communication
  • Real-time telemetry
  • Safety states

A major focus was making the control system non-blocking so that networking, telemetry, and configuration do not unnecessarily interfere with the time-critical balance loop.

Web Interface

We developed a browser-based control dashboard so TALOS can be monitored and controlled without relying entirely on a serial terminal.

The interface provides real-time information about the robot and allows parameters and operating modes to be changed remotely.

This makes experimentation much easier because control-system parameters can be changed without repeatedly modifying and uploading firmware.

What We Learned

The biggest lesson was that building a physical control system is very different from simulating one.

A controller that looks good mathematically can behave very differently on a real robot because of:

  • Motor dead zones
  • Servo response time
  • Mechanical backlash
  • Sensor noise
  • Electrical interference
  • Battery voltage fluctuations
  • Wheel traction
  • Centre-of-mass position
  • Communication delays
  • Differences between the left and right mechanical systems

We also learned how important sensor feedback is. Initially, it was tempting to solve problems simply by increasing PID gains. However, excessive gain can make the robot oscillate instead of balancing. We therefore had to consider filtering, gyroscope feedback, output saturation, deadband compensation, and predictive control together.

Another important lesson was fault handling. During development, I2C communication problems with the MPU6050 and AS5600 sensors showed how a single unreliable connection can prevent the entire control system from functioning correctly.

Challenges

Balancing a High Centre of Mass

One of the biggest challenges was getting enough reaction speed from the wheels to correct the robot before it fell.

Because TALOS has a relatively high centre of mass, a small angular error can quickly develop into a large one. We progressively improved the controller by increasing responsiveness, reducing unnecessary filtering delay, using gyro feedback, and experimenting with predictive angle compensation.

Unequal Leg Behaviour

The two legs did not behave identically. One leg could hold the robot's weight more effectively than the other.

This required individual calibration and different support compensation for the left and right actuators rather than assuming that identical PWM values would produce identical mechanical behaviour.

I2C Reliability

The MPU6050 and AS5600 sensors depend on I2C communication. During testing, we encountered repeated communication errors, which led us to isolate the sensors and test the I2C connections independently.

This taught us the importance of separating software problems from electrical and hardware problems during debugging.

Safe Shutdown

Another challenge appeared when turning balance control off. Immediately stopping the leg servos caused the robot to lose support and fall.

We therefore designed the shutdown process to be more gradual: the wheels stop first while the legs continue supporting the robot, followed by a controlled reduction of leg support.

This was an important realization that robot safety needs to be treated as part of the control system itself, rather than as an afterthought.

What's Next

TALOS is still an evolving platform.

Our next goals include improving the mechanical efficiency of the legs, increasing wheel response, refining the balance controller, improving sensor reliability, and expanding the web dashboard.

Ultimately, we want TALOS to become more than a demonstration robot — a platform where mechanical design, embedded systems, control theory, and intelligent software work together in real time.

TALOS taught us that robotics isn't just about making individual components work. The real challenge is making all of those components work together reliably as one system.

Built With

Share this project:

Updates

Submission history