Author Archives: ronaldx

Updated design for 8DOF quadruped robot

I got a new 3D printer, the amazing Prusa I3MK2. I really can recommend this machine ( The heated bed provides a perfect 1 layer every time. I don’t need to “babysit” my prints anymore =).

One of the first thing I have printed is a new design for my 8DOF small quadruped robot. I like the embossed details on the hip pieces and the battery holder mech.


You can download the files from Pinshape or Thingiverse:

You are welcome to customise or edit the CAD design in OnShape, the project is shared using this link:



Let’s review how to we get Felix a 3D printed quadruped robot to walk. Start by downloading or cloning the code from GitHub (

If you haven’t done it yet, get Node.js and install/setup Johnny-Five to communicate with your microcontroller/board.

Getting Felix to walk properly requires some tweaking. We will try to compensate in software for a number of small imperfections in hardware that eventually add up.

You have (or should had) already done a rough calibration of the servos and leg assembly. Now let’s test one leg at a time.

To increase precision get a sheet of graph paper, glue it to some cardboard to add stiffness. Place it between Felix legs like this:


Now copy/write your calibration offset to the index.js file

var config = {
  geometry:{ femur:44, tibia:74, height:110, 
             step_height:10, step_width:26 },
  gait: [ //expected order FR, FL, BR, BL 
  legs:[  //expected order FR, FL, BR, BL
                         label:'Front right',
                         hip:{ pin:0, offset:2, invert:false },
                         knee:{ pin:1, offset:4, invert:false }
                         label:'Front left',
                         hip:{ pin:2, offset:3, invert:true },
                         knee:{ pin:3, offset:-4, invert:true }
                         label:'Back right',
                         hip:{ pin:4, offset:-2, invert:true },
                         knee:{ pin:5, offset:-6, invert:true }
                         label:'Back left',
                         hip:{ pin:6, offset:-3, invert:false },
                         knee:{ pin:7, offset:-4, invert:false }

Run the index.js file. A reference to felix is injected to the REPL.
From the REPL you can call:



Update the values directly in the REPL and recalibrate until you get it right:
Screen Shot 2016-12-18 at 13.56.34.png

Now, control the home position of the leg:


Use the graph to check that the tip of the leg hit it’s mark: directly 110 millimeter beneath the hip joint.


Next, control the two furthest points of the step:


If the home position and the step-pose position are off, you can tweak the leg’s origin values:


Once you are satisfied with your angles offsets and your origin offset, remember to update the values in the index file.  Repeat this steps for the next tree legs.

Now let’s try some walking. Press the “arrow up” key and Felix will start a creeping gait by running the forward method. Press the space bar to pause and resume the walk.

Felix.prototype.forward = function(){
  if(this.state == 'forward_pause')
    this.state = 'forward';

  var c = this._genwalk();
  this.schedule = c;
  this.cycle_idx = 0;
  this.scheduleIdx = 0;
  this.state = 'forward';

This method generates a walk cycle based on the current step properties, set the state and start running the scheduler.

The scheduler consumes an array of “frames”. The rate at which the frames are processed is controlled by the “speed” configuration value.

A frame consist of a command and a payload. Currently they are two types of frames, a control frame like:


When the scheduler encounter this frame it loops back to the start of the scheduler and decrements the count value. If the count value reach zero the schedule continues with the next frame. For an infinite loop the count value can be set to -1.

The other type of frame is a “pose”:

{ cmd:'pose', angles:[{hip:int, knee:int}, {hip:int, knee:int},
{hip:int, knee:int}, {hip:int, knee:int} ] }

When the scheduler encounter this frame, it will position each leg joint to the provided angles.

The generated walk cycle is a creeping gait (or static stable gait) where the body is moved forward at the same time that the stepping leg is being lifted.

An alternative (more stable, but slower cycle) can be implemented by shifting the center of mass first and then  lifting the stepping leg.

To generate the cycle, a step is divided into four key-poses. From pose one to four the legs push the ground behind shifting the body along. In pose four the leg is lifted in a semicircle back to pose one.

A gait  is described as an array of poses:

//expected leg order FR, FL, BR, BL
gait: [

Felix currently master two creep gaits, the “cat” and the “deer”.  In the cat gait the sequence of lifted legs is:

  1. front-right
  2. back-left
  3. front-left
  4. back-right

In the deer  gait the sequence is:

  1. front-right
  2. back-right
  3. front-left
  4. back-left

From one pose to the next the needed transition points are generated by two methods: “_linearTrajectory” and “_ellipticalTrajectory”.

Felix.prototype._linearTrajectory = function(line,
    var trajectory = [];
    var granularity = granularity || 8;

    //find the slope/delta
    var delta_x = line.b.x - line.a.x;
    var delta_y = line.b.y - line.a.y;

    //calculate the distance between the two points
    var distance = Math.sqrt( ((delta_x) * (delta_x)) +
                              ((delta_y) * (delta_y)) );

    if(distance == 0) return [];

    //divide the line int the required number of points
    //decrease the granularity one step to be able to include 
    //the end point
    var skip = (skip_start_point)? 0:1;

    var step_size = distance / (granularity - skip);
    var c_step = (skip_start_point)? step_size:0;

    for(var i=0;i < granularity;i++){
        var inc = c_step / distance;

                          x:Math.round(line.a.x +
                           (inc * delta_x)),
                          y:Math.round(line.a.y + 
                            (inc * delta_y))
        c_step+= step_size;
     return trajectory; 

Felix.prototype._ellipticalTrajectory = function(arc,
      var trajectory = [];
      granularity = granularity || 8;

      //divide the angles int the required number of points
      //decrease the granularity one step to be able to include 
      //the end point
      var skip = (skip_start)? 0:1;
      var step_size = (arc.end_angle - arc.start_angle) / 
                      (granularity - skip);
      var c_angle = arc.start_angle;
      if(skip_start_point) c_angle+= step_size;
      for(var i=0;i < granularity;i++){
        var x = arc.origin.x + arc.radius.x * 

        var y = arc.origin.y + arc.radius.y * 

        trajectory.push({ x:Math.round(x),y:Math.round(y) });
        c_angle+= step_size;
      return trajectory;

The number of transition points in both methods are governed by the configuration variable “granularity”.

The points generated for the poses and transitions are then converted to angles using the Inverse kinematics method described in a previous post. This angles are added to the frame, and the frame is added to the scheduler.

This is a video of the cat style creep gait:

And the “deer” style creep gait:



Initial servo calibration and leg position

Calibrating the servos and getting the initial position of the legs right is quite important in order to get a smooth walking experience.

After setting op your Node.js and Johnny-Five environment create a new directory and add the following script:

var five = require("johnny-five");
var board = new five.Board();

var legs = [
                 lable:'Front right',
                 hip:{ pin:0, offset:0, invert:false },
                 knee:{ pin:1, offset:0, invert:false }
                 lable:'Front left',
                 hip:{ pin:2, offset:0, invert:true },
                 knee:{ pin:3, offset:0, invert:true }
                 lable:'Back right',
                 hip:{ pin:4, offset:0, invert:true },
                 knee:{ pin:5, offset:0, invert:true }
                 lable:'Back left',
                 hip:{ pin:6, offset:0, invert:false },
                 knee:{ pin:7, offset:0, invert:false }

board.on("ready", function() {

  for(var i = 0; i < legs.length; i++){
    legs[i].hip.servo = new five.Servo({
                          controller: "PCA9685",
                          address: 0x40,
                          pin: legs[i]

    legs[i].knee.servo = new five.Servo({
                          controller: "PCA9685",
                          address: 0x40,
                          pin: legs[i]

  for(var i = 0 ; i < legs.length; i++){
    legs[i] + legs[i].hip.offset );
    legs[i] + legs[i].knee.offset );



For the next step is best not to have the thighs/femurs attached (to avoid the risk of striping the servos gears).

Edit the pin number in the script (, etc) to match your setup’s connections and run the script. This will set all servos to 90 degrees.

Now attach the thighs/femurs. The femurs should form a 90 degrees angle in relation to the body.

The shins should also form a 90 degrees angle, but be aware that the shin is slightly lifted as the angle should be from the tip of the shin to the femur (as seen in the graphic).

Due to the coarseness of the teeth on the servo horns the resulting angles  might be off by a couple of degrees. To get it as close as possible edit the offset values in the script (legs.hip.offset, etc). For example if the front right femur is off by 2 degrees to the left set the offset value to legs.hip.offset = -2.

Run the script again and check (preferably with an angle ruler) that all segments are correctly positioned.

Step by step assembly guide

This is a short step by step assembly guide for those of you who have downloaded ( and printed Felix the quadruped robot.

You will need the following parts:


First, press-fit the four hip elements into the two body parts:


Next, join the two body subassemblies using the belt piece:


Now take the servos and press them into the thighs. If they are too loose, shim them up with some tape.


Connect the thigh subassembly to the hip using the servo horn, add the horn screw but don’t tighten it just yet. Repeat for the four legs.


Attach all the shin in the same way:


Your robot should now look like this:


The next post will guide you through connecting the electronics and the initial calibration of the servos.


Here comes the BOM

This are the electronic part you will need to build your own Felix. I’ve created a Wishlist at Adafruit for your convenience:

Quantity Item URL price (USD)
1 8-Channel PWM or Servo FeatherWing Add-on For All Feather Boards PID:2928 9.95
1 Adafruit Feather M0 Bluefruit LE PID: 2995 29.95
1 Lithium Ion Polymer Battery – 3.7v 150mAh PID: 1317 5.95
1 4 x AA Battery Holder with On/Off Switch PID: 830 2.95
1 3×4 Right Angle Male Header – 4 pack PID: 816 2.95
1 Feather Header Kit – 12-pin and 16-pin Female Header Set PID: 2886 0.95
1 Feather Stacking Headers – 12-pin and 16-pin female headers PID: 2830 1.25
8 Micro Servo – MG90S High Torque Metal Gear PID: 1143 79.60
2 Mini Panel Mount DPDT Toggle Switch PID: 3220 2.50
Total: 136.05

Or you can download an Excel file bom.


Computing the inverse kinematics of a two links planar system

This is a short explanation of how to calculate the leg angles in our quadruped robot using basic trigonometry. If you don’t need the explanation but just want an example implementation scroll to the bottom to see the code sample.


As you can see in the graphic above, we want to find the angles A1 and A4:

  • A1 is the rotation angle of our first segment around the hip joint
  • A4 is the rotation angle of our second segment around the knee joint

What we know is L1, L2, P1 and P2 where:

  • L1 is the length of our femur
  • L2 is the length of our tibia
  • P1 is the origin point, or position of our hip (0,0)
  • P2 is the requested end position (or destination) for the feet

So, basically we want to how (much) does our hip and knee need to rotate in order for our feet to reach the requested end position.

We can calculate our knee angle using the law of cosines ( But to do so we need to know the length of the tree sides of the triangle L1, L2 & K.

So we start calculating our missing side K. We find the to segments H1 and H2 using the delta between our origin (P1) and our destination (P2):

int H1 = P2.x - P1.x; //delta on the x axis
int H2 = P2.y - P1.y; //delta on the y axis

Because H1 and H2 create a right-angled triangle, we can use the Pythagorean Theorem ( to find K (the hypothenuse):

float K = sqrt( pow(H1,2) + pow(H2,2));

Now we can get the knee angle:

//angle between L1 & L2 - the to segments, femur and tibia
float A1 = acos(( pow(L1,2) + pow(L2,2) - pow(K,2))/ (2 * L1 * L2));

Getting our hip angle is bit more convoluted. We need to find the angle A2 (no problem, having the tree sides is just more law of cosines), and A3 (another right-angled triangle – more Pythagoras).

//get the angle between the hypothenuse and the first segment (femur)
float A2 = acos( (pow(K,2) + pow(L1,2) - pow(L2,2)) / (2 * K * L1));

//get the angle between the hypothenuse and the x axis

float A3 = asin(H1/K);

Then we add this to angles and subtract the sum from 180 degrees and we are left with our hip angle.

float A4 = (PI / 2) - (A2 + A3);

Below you can see a function implemented for an Arduino sketch.

* Inverse Kinematic function for a two link planar system.
* Given the size of the two links an a desired position,
* it returns a pose struct with angles for both links
struct pose IK(int L1, int L2, struct point P2)
struct pose a;
struct point P1 = { HIP_ORIGIN_X, HIP_ORIGIN_Y }; //origin point (hip)

int H1 = P2.x – P1.x; //delta on the x axis
int H2 = P2.y – P1.y; //delta on the y axis

//this is the hypothenuse between the origin and the target
float K = sqrt( pow(H1,2) + pow(H2,2));

//the hypothenuse can not be larget the the sum of the segments
if( K > (L1 + L2 )) K = L1 + L2;

//knee rotational angle
float A1 = acos(( pow(L1,2) + pow(L2,2) – pow(K,2))/ (2 * L1 * L2));

//convert from radians to degrees and cast as an integer
float A1_ = A1 * RAD_TO_DEG;
int A1__ = (int) A1_;

//get the angle between the hypothenuse and the first segment (femur)
float A2 = acos( (pow(K,2) + pow(L1,2) – pow(L2,2)) / (2 * K * L1));

//get the angle between the hypothenuse and the x axis
float A3 = asin(H1/K);

//get the hip rotational angle
float A4 = (PI / 2) – (A2 + A3); //add the two angles, substract it from half a circle

float A4_ = A4 * RAD_TO_DEG;
int A4__ = (int) A4_;

a.hip_angle = A4__;
a.knee_angle = A1__;

return a;


3D printable Quadruped robot

A contest on Pinshape ( got me to simplify the design of Felix and optimise it for 3D printing. The focus was on minimal support material, fast print time and optimal orientation on the print bed for best first layer adhesion. Other concerns where easy of assembly and sturdinnes of the final robot.


You can download and print the design from Pinshape (

If you want to edit/customise the 3D model, you are free to copy my OnShape project using this link:…

Screen Shot 2016-10-16 at 22.49.40.png

There ain’t much room for my current electronics setup. The servo connectors require a lot of space – even using angled pins. So I have ordered a feather board and a servo feather wing from Adafruit. The feather board has the added bonus that it can be controlled via Iphone/Android using Bluetooth.