the theo jansen walker

The Theo Jansen Walker

By Kristopher Brown

Kinematics and Mechatronics

Tarek Al-Geddawy

Spring 2015

Table of ContentsIntroduction.......................................................................................................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

1

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

2

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.

3

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.

4

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.

5

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.


Out of the three iterations, this displacement matches the closest to the ideal trace goal.

6

The linear velocity of iteration 3 was analyzed, which can be seen below in figure 13.


The linear acceleration of iteration 3 was analyzed which can be seen below in figure 14.


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 5 th link compared to the 4th

link was helpful in increasing the height of the trace. A reduction of length for the 12 th, 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

7

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.


The linear velocity of this design was analyzed and can be seen in figure 17 below.


The linear acceleration of iteration 4 was also analyzed and is shown below in figure 18.


8

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.

9

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

10

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-bridgeconst int controlPin2 = 3; // connected to pin 2 on the H-bridgeconst int enablePin = 9; // connected to pin 1 on the H-bridgeconst int directionSwitchPin = 4; // connected to the switch for directionconst int rightdirectionSwitchPin =6;const int onOffSwitchStateSwitchPin = 5; // connected to the switch for turning the motor on and offconst int potPin = A0; // connected to the potentiometer's output

// create some variables to hold values from your inputsint onOffSwitchState = 0; // current state of the On/Off switchint previousOnOffSwitchState = 0; // previous position of the on/off switchint directionSwitchState = 0; // current state of the forward direction switchint rightdirectionSwitchState = 0; //current state of the backward direction switchint previousDirectionSwitchState = 0; // previous state of the forward direction switchint previousrightdirectionSwitchState = 0; // previous state of the backward direction switch

int motorEnabled = 0; // Turns the motor on/offint motorSpeed = 0; // speed of the motorint 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);

11

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

12

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.

13

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.

14

the theo jansen walker

Documents