1. The Theo Jansen Walker
By Kristopher Brown
Kinematics and Mechatronics
Tarek Al-Geddawy
Spring 2015

2. 1
Table of Contents
Introduction................................................................................................2
Mobility......................................................................................................2
Using PDF Resource...................................................................................3
Iteration 1..................................................................................................................3
Simulation for further optimization ..............................................................4
Iteration 2..................................................................................................................4-5
Iteration 3..................................................................................................................6-7
Iteration 4..................................................................................................................7-9
Design Summary ..................................................................................................................9-10
Sensing Objects....................................................................................................................10
Arduino Sketch.........................................................................................................11
Arduino Code ...........................................................................................................12
Conclusion............................................................................................................................12
References............................................................................................................................13

3. 2
Introduction:
In this project, I analyzed a four-legged form of the Theo Jansen Walker linkage design. Theo
Jansen, the initial inventor of this design, has been creating this type of sustainable kinematic
contraptions since 1990. They are referred to as ‘Strandbeests’, because their first existence
started on the beach. Their strong characteristic of these walkers is the fact that they do not
require any sensors, motors, or other technology to control or power its movements. This report
will highlight the design strengths of this beast by showing the motion and kinematic analysis
performed by the ‘leg movements’ of the walker when powered by a hypothetical motor.
Mobility:
To determine the movement and flexibility of this ten linkage design, I performed a mobility
analysis using the number of revolute joints and links. This can be seen in figure 1 below.
Figure 1: Mobility analysis
A mobility of 1 degree of freedom means that this linkage mechanism can be controlled and
powered by a single crank.
The next step was to determine the right lengths for these links in order to create an ideal motion
path for the toe of the walker that both supports the mechanism and allows for contact to the
ground at all times. This path can also be referred to as a ‘trace’. The ideal motion trace that I
tried to create for this project can be seen below in figure 2.
Figure 2: Ideal Trace Goal

4. 3
Using PDF resource:
Iteration 1:
At first, I used the PDF resource: The Design and Optimization of a Crank-Based Leg
Mechanism by Amanda Ghassaei from Pomona College Department of Physics and Astronomy.
She recorded the optimized link lengths from Theo Jansen’s book ‘The Great Pretender’. I
sketched the diagram in figure 3 below in SolidWorks Assembly Layout feature.
Figure 3: 1st iteration using Theo Jansen’s optimized lengths
The trace path is also shown in the figure above which is the linear displacement of toe.
Although, this design has a great support phase, the transfer phase is not as round as it could be.
I also analyzed this design’s linear velocity which can be seen below in figure 4.
Figure 4: Linear Velocity (magnitude) for Iteration 1
In figure 5 on the next page, the linear acceleration magnitude for iteration 1 is shown.

5. 4
Figure 5: Linear Acceleration (magnitude) for Iteration 1
Simulation for Further Optimization:
Since the optimized links did not have a great transfer phase trace, I decided to use a simulator to
develop my own linkage lengths and to see the effects of each length change. The simulator from
mekanizmalar.com/theo_jansen.html which can be seen in figure 6 was very helpful in this
endeavor.
Figure 6: Simulation
Second Iteration:
For the second iteration design, I decided to make the two pivots on the same axis instead of
offset from each other like the first iteration. This helped with rounding out and widening the
trace. The lengths of this iteration are much larger in size than the length in the first iteration.
The mechanism sketch, linkage lengths, and trace can be seen in figure 7 on the next page.

6. 5
Figure 7: 2nd iteration linkage lengths, trace, and sketch
Now that I was able to build a design that made the transfer phase rounder, I sacrificed a near flat
support phase. This can be seen by the linear displacement which can be seen in figure 8 below.
Figure 8: Linear Displacement of Iteration 2
The linear velocity was analyzed and is shown in figure 9 below.
Figure 9: Linear Velocity (magnitude) of Iteration 2
In figure 10 on the next page, the linear acceleration of iteration 2 is shown.

7. 6
Figure 10: Linear Acceleration (magnitude) of Iteration 2
Third Iteration:
My goal for my third iteration was to increase the width of the trace in order to create a flatter
support phase. I realized that lengthening link numbers 5 and 3 were helpful in doing this. The
mechanism sketch, linkage lengths, and trace can be found in figure 11 below.
Figure 11: Iteration 3 mechanism sketch and linkage lengths
As can be seen from figure 12 below, I was able to change the linear displacement to flatten out
both the transfer and support phases.
Figure 12: Linear Displacement of Iteration 3
Out of the three iterations, this displacement matches the closest to the ideal trace goal.

8. 7
The linear velocity of iteration 3 was analyzed, which can be seen below in figure 13.
Figure 13: Linear Velocity (magnitude) of Iteration 3
The linear acceleration of iteration 3 was analyzed which can be seen below in figure 14.
Figure 14: Linear Acceleration (magnitude) of Iteration 3
Iteration 4:
After this third iteration, I decided to try and get even closer to the ideal trace by reducing the
width of the trace and increasing the height slightly. The length of the 5th link compared to the 4th
link was helpful in increasing the height of the trace. A reduction of length for the 12th, 3rd, and
the crank links helped with reducing the width of the trace. The mechanism sketch and linkage
lengths can be found in figure 15 below.
Figure 15: Iteration 4 mechanism sketch and linkage lengths

9. 8
I was successful in reducing the width and increasing the height of the trace to better match the
ideal trace goal.
The linear displacement of this design can be seen in figure 16 below.
Figure 16: Linear Displacement of Iteration 4
The linear velocity of this design was analyzed and can be seen in figure 17 below.
Figure 17: Linear Velocity (magnitude) of Iteration 4
The linear acceleration of iteration 4 was also analyzed and is shown below in figure 18.
Figure 18: Linear Acceleration (magnitude) of Iteration 4

10. 9
Unfortunately, when I tried to build iteration 4 in SolidWorks using 3D linkages it was not
feasible. When rotating the crank in a full revolution, the 7th linkage collides into the 9th linkage.
This collision can be seen in figure 19 below.
Figure 19: Collision between 7th and 9th linkage
Design Summary:
Due to the collision of the fourth iteration, I decided to move forward with the third iteration
design. My walker design consists of four ‘legs’ made up of 10 individual links each. The links
are layered and connected to each other by variable length pegs. This overlapping design can be
seen in figure 20 below.
Figure 19: Isometric view of leg Figure 20: Layered connection between 4 links
As was stated earlier in the report, each leg can be powered by a single crank on each side of the
body. The crank highlighted in figure 21 on the next page is attached to a 52” center shaft that is
powered by a hypothetical motor.

11. 10
Figure 21: Power crank attached to two legs
The cranks on both sides of the body are in a 180 degree phase shift from each other, resulting in
the walker’s ability to move forward or backwards while maintaining stability. This walker also
has at least two points of contact with the ground at all times which is why the transfer phase is
so important. This can be seen in figures 22 and 23.
Figure 22: 180 degree shift between cranks Figure 23: Stability with two legs touching ground
Sensing Objects:
Arduino Sketch:
With the hypothetical implementation of two buttons, the walker can determine where objects
are relative to its body and perform a direction function for the respective input. Using an

12. 11
Arduino Uno, I created a program that uses three buttons to do three separate functions: turn the
motor on/off, move the walker forward, and move the walker backwards. The direction buttons
would be on each end of the body and when they are hit by the object, they reverse its current
movement. I used ‘Fritzing’ to create a sketch of the circuit layout required to run the program.
This layout can be seen in figure 24 below.
Figure 24: Arduino Sketch
Arduino Code for three button program:
const int controlPin1 = 2; // connected to pin 7 on the H-bridge
const int controlPin2 = 3; // connected to pin 2 on the H-bridge
const int enablePin = 9; // connected to pin 1 on the H-bridge
const int directionSwitchPin = 4; // connected to the switch for direction
const int rightdirectionSwitchPin =6;
const int onOffSwitchStateSwitchPin = 5; // connected to the switch for turning the motor on and off
const int potPin = A0; // connected to the potentiometer's output
// create some variables to hold values from your inputs
int onOffSwitchState = 0; // current state of the On/Off switch
int previousOnOffSwitchState = 0; // previous position of the on/off switch
int directionSwitchState = 0; // current state of the forward direction switch
int rightdirectionSwitchState = 0; //current state of the backward direction switch
int previousDirectionSwitchState = 0; // previous state of the forward direction switch
int previousrightdirectionSwitchState = 0; // previous state of the backward direction switch
int motorEnabled = 0; // Turns the motor on/off
int motorSpeed = 0; // speed of the motor
int motorDirection = 1; // current direction of the motor
void setup(){
// intialize the inputs and outputs
pinMode(rightdirectionSwitchPin, INPUT);
pinMode(directionSwitchPin, INPUT);
pinMode(onOffSwitchStateSwitchPin, INPUT);
pinMode(controlPin1, OUTPUT);
pinMode(controlPin2, OUTPUT);
pinMode(enablePin, OUTPUT);
// pull the enable pin LOW to start
digitalWrite(enablePin, LOW);
}
void loop(){
// read the value of the on/off switch
onOffSwitchState = digitalRead(onOffSwitchStateSwitchPin);

13. 12
delay(1);
// read the value of the direction switch
directionSwitchState = digitalRead(directionSwitchPin);
rightdirectionSwitchState = digitalRead(rightdirectionSwitchPin);
// read the value of the pot and divide by 2 to get
// a value that can be used for PWM
motorSpeed = analogRead(potPin)/2;
// if the on/off button changed state since the last loop()
if(onOffSwitchState != previousOnOffSwitchState){
// change the value of motorEnabled if pressed
if(onOffSwitchState == HIGH){
motorEnabled = !motorEnabled;
}
}
// if the direction button changed state since the last loop()
if (directionSwitchState != previousDirectionSwitchState) {
// Move the walker forward if pressed
if (directionSwitchState == HIGH) {
motorDirection = 1;
}
}
// if the direction button changed state since the last loop()
if (rightdirectionSwitchState != previousrightdirectionSwitchState) {
//Move the walker backwards if pressed
if (rightdirectionSwitchState == HIGH) {
motorDirection = 2;
}
}
// change the direction the motor spins by talking
// to the control pins on the H-Bridge
if (motorDirection == 1) {
digitalWrite(controlPin1, HIGH);
digitalWrite(controlPin2, LOW);
}
if (motorDirection == 2) {
digitalWrite(controlPin1, LOW);
digitalWrite(controlPin2, HIGH);
}
// if the motor is supposed to be on
if (motorEnabled == 1) {
// PWM the enable pin to vary the speed
analogWrite(enablePin, motorSpeed);
}
else { // if the motor is not supposed to be on
//turn the motor off
analogWrite(enablePin, 0);
}
// save the current On/Offswitch state as the previous
previousDirectionSwitchState = directionSwitchState;
previousrightdirectionSwitchState = rightdirectionSwitchState;
// save the current switch state as the previous
previousOnOffSwitchState = onOffSwitchState;
}
Conclusion:
I thought this project was interesting due to the fact that there is not one right
answer. Extensive research is being done in the engineering field to find
applications for this cutting edge mechanism and it is exciting to look at the

14. 13
mathematical considerations needed to optimize the movement. One of my biggest
struggles throughout this assignment was in building the legs and determining the
length sizes. It is exciting to see that I was able to use engineering intuition to
optimize the trace. I had a goal for each one of my iterations, and it was satisfying
to see after many trials I was able to create a trace that closely relates to the ideal
trace. A disappointment was that the trace that performed the best was not
physically feasible due to collision between the 7th and 9th link. If there was more
time to analyze the problem, I would look into if I could develop a different leg
assembly to use iteration 4 and avoid the collision problem. Overall, this project
exposed me to power that kinematic analysis has on real world applications in
engineering.

15. 14
References
Jansen, Theo. The Great Pretender. Uitgeverij. 2007.
The Design and Optimization of a Crank-Based Leg Mechanism, Pomona College Department
of Physics and Astronomy. 2011. PDF file.