Walbi, the walking biped

Wouldn’t it be great if we could make a biped robot with some servos? The Inner Geek thought so and this is the result…

Walbi, design, assembly and programming

That’s Walbi, the WALink BIped, a robot we created for a Machine Learning project that never got off the ground (neither did Walbi, but that’s because it has both feet solidly planted on the ground).

Walbi standing
Walbi standing

Walbi uses an Arduino Nano for “brain”, LX-16A servos for “muscles” and plastic 3D printed parts for “bones”. The LewanSoul LX-16A servos are dream servos for small(ish) robotic projects, as they are light, can move over 19 kg.cm and are connected with a single cable, running from servo-to-servo, making cabling the robot child’s play.

LewanSoul LX-16A servos and supports
LewanSoul LX-16A servos and four support types

Walbi is a 2:1 scale humanoid and its legs are 55 cm tall (21.7 in) from heel to waist and weigh 1,1 Kg (2.4 lbs). The white parts of its body were 3d-printed, but could as easily have been made out of lightweight sturdy wood.

Walbi feet
Walbi feet

Programming Walbi is very simple. You can download below the two programs needed to do motion capture and playback, and with then you can make Walbi walk, crawl, climb, jump or dance! You only have to move its legs to a desired pose, record that pose, shape Walbi it into another pose, record it and so forth, and then, when you have recorded the complete sequence, you can seat back and watch it perform skilfully the moves you taught it.

Walbi hip detail
Walbi hip detail
Walbi in walking pose
Walbi learning to walk

Maybe you can teach yours to riverdance 😀

Building the Walbi

Walbi was 3D printed in PLA plastic, using a FlashForge Creator Pro printer. You can download the STL files from Thingiverse, or use an alternate method to build the feet, leg “bones” and waist, using wood or metal. The servo supports attach to these parts, to the servos and to one another.

STL design on 123D

As shown on the diagram below, you will need metal supports of the four different types available to attach the servos to the parts printed and to each-other.

Walbi servo support use
Walbi servo support usage


In order to control the LX-16A servos you need a LewanSoul Debug Board.

LewanSoul Debug Board

It will receive commands from a serial port on the Arduino Nano. As we used the Arduino’s hardware serial to communicate with the computer, we had used the SoftwareSerial library to create a second serial port on the Nano, in order to connect to the Debug Board.

Wiring is minimized with serial servos. There is a cable from each servo to the next (serial cable provided with the servos) and the servos at the waist plug directly into the Debug Board. Your computer connects to the USB port of the Arduino and the Arduino is connected to the Debug Board using three jumper wires (TX, RX and GND) connected to the Arduino  pins that you configure for SoftwareSerial – we used pins 10 and 1 in the code1.

The servos use a baud rate of 115200 (if you know how to change it please tell us, as this is too high). This baud rate is high for SoftwareSerial, so we had to implement error checking and retrial functionalities. In some cases persistence was required to get a correct reading.


The servos can provide 19.5kg.cm at 7.4v. We used 6v and the stall current was below three amps.


You can get the Arduino code from the Github repository.

Two programs are used for motion capture and replay, a technique similar to the one used in movies. You start by shaping the robot into a pose. As the servos default to motor off, you can rotate the servos by hand. Once you have the robot in the desired pose, you use the Walbi_record program to read and display all servo angles. You then feed those angle readings into the poseAngles variable in Walbi_play, and use the program to play back the sequence of poses recorded, at a speed set using the timeToMove variable (in mili-seconds).

We hope you enjoyed the project. Feel free to share your love by leaving a comment, subscribing the blog or any other type of feedback action.
We appreciate it!

Inner Geek nuggets

Here are some tips and tricks learned while creating Walbi:

  • The supports for the LX-16A only attach to the servo in ONE position, so it is very easy to connect them incorrectly, specially to the 3d-printed parts. We had to reassemble Walbi a couple of times to correct assemly mistakes that were quite hard to spot.
  • The servos came with ID 1 by default. Assign each servo a different ID before mounting them on the robot, or it will be impossible to communicate with multiple connected serial servos with the same ID.
  • Using cable ties really improves appearence
  • The servos come with the screws required to connect the horns to the servos and the horns to the supports. The supports come with the screws required to attach them to the servos. You will need to purchase separately screws for support to support connections and support to plastic parts connection. We used DIN912 M2-6 and M2-10 screws and nuts.
  • You can improve traction by sticking silicone pads to the soles of the robot’s feet.
  • It is preferable to use metal servo horns, as the plastic ones that come with the servos will tear if (when) the legs smash into each other during tests. If the horns tear, the robot will gain slack and movement playback will lose accuracy (which otherwise is surprisingly good).
Tear in plastic servo horn
Tear in plastic servo horn

Minimalist LiDAR

LiDAR assembled.png

A long weekend is the perfect chance to release the InneR GeeK, so this time around I built a one degree of freedom LiDAR, using a breakout board of the compact GY-530 Time-of-flight ranging sensor, which is absolutely minuscule.

Let’s start with the “ingredients”:

  • Arduino Nano (or any other, really)
  • SSD1306 OLED screen
  • VL53LOX breakout board
  • Servo (micro servo such as the sg90 is perfect)
  • 3d-printed parts (you can pick-up the STL files at the Minimalist-LiDAR Thingiverse repository)

The cabling is straightforward. You connect:

  • The OLED screen and the VL53LOX board’s GND, SCL and SDA pins (I2C) to the Arduino’s I2C pins;
  • The servo signal cable (yellow) to a digital pin (used D5);
  • The GND and 5V of the servo, OLED and VL53LOX to a 5 Volt external power source;
  • The GND of the Arduino to the GND of the external power source (if you miss this step the servo won’t budge or will move erratically).

Using the VL53LOX is straightforward. You initialize it with a few lines:

#include "Adafruit_VL53L0X.h"
Adafruit_VL53L0X lox = Adafruit_VL53L0X();
VL53L0X_RangingMeasurementData_t reading;

And you take a reading using:

lox.rangingTest(&reading, false);

To access the measured value, use:

measurement = reading.RangeMilliMeter;

The hard part of the project was shrinking the code down so that it would fit the Arduino Nano’s small memory. Here are some tricks I used to reduce the code size and get it to upload and run properly:

  • Started using the <Adafruit_SSD1306.h> library to draw on the OLED screen but had to replaced it with the <U8g2lib.h> to save space;
  • Used #define for constants
  • Used byte instead of int
  • Used float instead of double
  • Calculated screen position to servo angle relations offline and loaded the results into arrays
  • Exhaled before compiling (sort of 🙂 )

Captura de Tela 2018-05-16 às 00.09.00It finally worked, but if you want to replicate this I suggest you use an ES32 or some other board with more memory.

You can download the code at the Github repository for the project

Feel free to comment, suggest, tip or provide any other kind of feedback. That’s what sharing is all about!