Project 2: Walker

Here is the full project description.

Documentation (description, images, video, code, etc) due to website by Wed (1/31) at 9pm.

Here is some initial research (YouTube video searches) of LEGO-based walkers to get you started.

Note: Part of the requirement of this project (read the description) is to vary the speed to see the effect on the behavior/motion (forward and backward, and slow to fast). For research in this area, check out this article.

Here is the YouTube video linked in the article:



Walker

"Frogger" Walking Robot
Brian Reaney, Julia Noble

First video: robot walking at high motor speed. Successful except that uneven motor power causes it to turn right.
Second video: robot "walking backwards" (reverse motor speed). Unsuccessful.
Third video: robot walking at low motor speed. Unsuccessful.

We synchronized the motors on our robot so that it would leap forward rather than trot, kind of like a frog. This only ended up working at medium to high motor speeds (above 500 power) and it didn't work for walking backward. This kind of makes sense since it was optimized for a dynamic gait that is more similar to running (you don't have the same gait when you run backward). One problem with our robot is that the motor on the left was more powerful than the motor on the right, so when it leaps forward it tends to turn right (when we ran the motors at the same power with no load the left one spun faster). The idea for the leg mechanism came from a particular kind of 6-bar linkage we learned about in machine design that has linear motion along part of its cycle and then lifts up for the other part. We figured this would be ideal for walking motion, although it ended up requiring the motors to run fast enough that the robot jumped in order to actually get the foot to lift. Alternating the left and right sides might have worked better if our motors were able to supply equal power, but keeping each side in phase helped the motors maintain the same rate of rotation.
We made many adjustments during the construction and testing of this robot, playing around with the lengths of mechanical links, experimenting with different "feet," testing different gait patterns, adjusting the position of the brick to control center of mass. If we were to keep iterating our design or build another walking robot, there are clearly many more details we could consider and adjust.

CODE:

!/usr/bin/env python3

def main():

ev3 = Device('this')

Connect the Large motor to port A

speed = -300

motor = ev3.LargeMotor('outA')

motor2 = ev3.LargeMotor('outD')

a = motor.position

print(a)

b = motor2.position

print(b)

motor.run_to_abs_pos(position_sp=(a-b))

motor.run_forever(speed_sp=speed)

motor2.run_forever(speed_sp=speed)

sleep(60)

motor.stop()

motor2.stop()

if name == 'main':

main()

Feb 7 2018 Read →

Project 2: Walker

Aruni Kacker and Max Luo

The goal of the project was to create a robot that moved by walking, rather than on wheels. Our design used two motors, one to power a pair of legs on each side. Each pair of legs was connected to the motor by a gear train, to ensure that both legs would be powered and to create an offset between the legs. This ensured that at any point, one leg on each side was on the ground, while the other leg was moving, to allow for locomotion. In addition, the separate control of each pair of legs allows the robot to turn by powering one motor while leaving the other stationary.

Image

Our robot has an ultrasonic sensor because the same design was used for Project 1. Unfortunately, the code specific to Project 2 that demonstrated the robot turning was corrupted, but the code for proportional control in Project 1 demonstrates the robot's ability to walk at different speeds. We will upload code of the robot turning as soon as possible.

Video:

This video demonstrates the robot walking forwards, and then turning by powering only one motor.

This video was originally used for project 1, but shows the robot walking at various speeds.

Code:

Unfortunately the code for Project 2 was lost, but the code below of the proportional control works to make the robot walk at various speeds.

Image

Our robot design was inspired by the following videos:

https://youtu.be/TjzxO3D_gzU

https://youtu.be/uwwfHIotius

Jan 31 2018 Read →

Project2: The Walker

Ziyi Zhang Rui Shi

31/1/2018

Description

Our robot is a walker which is driven by two motors. To simulate the move of animals, we use four legs rather than wheels or tracks to achieve the walking function. Through control the motors with Python language, the robot can accomplish functions of walking forward and backward.

We use pedals as our robot's front feet to keep balance and stable while walking. We connect the one side legs to one gear and connect the gear with one motor. This design can ensure coordination. To make the walker move more efficiently, back legs of the walker is triangle in shape. While walking, the area where the back foot touches the ground is very small, which offers more power to the walker.

Construction

Basically, our robot has three main components. Motors, controller, and four legs. Motors are fixed on the body of controller. We used some bricks and sticks in front of and on the back of the motors to reinforce them so that they won’t dislocate during the walking process. Two gears are installed on the motors to drive our legs. Each front leg is connected directly on the gear, and the back leg is installed on the front leg to ensure two legs can walk consistently. The main technology we use is the crank mechanism which can efficiently convert the rotation of gears into straight motion. Since both legs are also attached with the ‘’body” of the robot, they can rotate for a small angle and walk like animials

Thinking Process

At first, we challenged to use only one motor to achieve the functionality of walking. However, we faced a lot of trouble with fixing the motor on the body and controlling the four legs to move differently as we thought. Therefore, we finally decided to use to motors. Also, we tried to use gear set to move the legs, but we failed when trying to fix all the gears we want on the body due to the irregular shape of the motor and we couldn’t control the distance between the legs because the width of gears is definite. Lately we found that crank mechanism is suitable for this situation. Another problem we encountered is the shape of the legs, at first, we used a shaft to support the whole robot, but it was really unstable. However, four rectangular bricks will make the robot hard to move, we tested a lot of combinations and this one we finally used is the best one.

Images

Image

Side view:

Image

Rear view:

Image

Side view:

Image

Video Description

Code

Our code can drive the motor to achieve normal speed movement, high speed movement and move backward. The two motors are connected to port A and port B. We can see from the video that our robot can have better performance when move at high speed, and it can also walk smoothly when move backwards.

Image

Jan 31 2018 Read →

ME 84 HW #2: Butterfly Swimmer Michael Phelps

Shunta Muto, Osvaldo Calzada

Research

The team did research on other people’s projects of walking EV3 robot on Youtube. The videos inspired us to use various mechanism including gear train and rotation-translation movement conversion from the motor. However, for this project, we figured that the initial design should be simple with smallest number of parts, so that we can add on different features and to continuously improve. We started off with multiple support towards the back of the design, but this resulted in too much friction causing the walker to move less. We then removed the supports and placed the single ball bearing, but the significant inclination towards the rear resulted in the design not moving much. This made us focus into trying to balance the center of mass between both stages of the gait ( when the wheels are touching the carpet, and when they’re rotating freely).

Failed Attempt

First, the team tried to come up with a mechanism to construct a 4-leg walking robot. This robot would have had two motors (right and left) that drive the gears, which are then connected to the mechanism that converts rotational motion to vertical motion. The vertical motion is used to produce a “step” of the walk. However, we realized that the parts we have in the EV3 kit may not be enough to construct the robot of our design. Furthermore, we realized that our design looks similar to the previous projects of other people, so we decided to come up with our original design with trial and error. Thus, we began prototyping with the simple design of a walking robot that consist of two motors and two legs. Two motors were used because this would improve the torque capacity of the robot.

Robot Construction

Our robot construction is very simple. It only requires two motors, two L-shaped legs, tail, and anchors. Legs are connected to the motors directly on each side, but the motors are connected through a rod so that they are synchronized in motion. At the tail, we connected a ball bearing so that it produces minimum friction while supporting the robot from the back. Anchors are simply bars that keep the robot from falling to the side while the legs are not in touch with the ground.

Image Image

above: Robot construction sideview

below: Robot construction rearview

Robot Walking Mechanism

The robot walks like a swimmer in butterfly stroke. The motors act as the right and left legs and they move continuously in a synchronized manner, just as a swimmer rotates the arms in butterfly strokes. As the legs push the ground, the robot jumps forward. When the legs are off the ground, anchors and the tail temporarily support the robot allowing the legs to rotate around and repeat the process.

Result

Videos below show the robot walking forward and back at low (speed=50), mid (speed=150), and high speed (speed=300). We noticed that the robot actually moves more distance/time backward than forward…:) We also noticed that lower speed provides more distance per stroke and helps the robot to keep its path straight, because high speed results in a lot of “bumps” when the robot touches the ground in a small free-fall after each stroke. These bumps cause the robot to change direction slightly after each stroke. In conclusion, our Michael Phelps robot can walk pretty well (forward AND backwards)!

Above: Low, speed = 50

Middle: Mid, speed = 150

Below: high, speed = 300

Code:

This robot keeps walking forever !

def main():

ev3 = Device('this')

Rmotor = ev3.LargeMotor('outC') #Large Motor Port C

Lmotor = ev3.LargeMotor('outB') #Large Motor port B

speed = 500

while True:

Rmotor.run_forever(speed_sp = speed)

Lmotor.run_forever(speed_sp = speed)

if name == 'main':

main()

Sources:

Michael Phelps Swimming Butterfly: https://www.youtube.com/watch?v=jd67PMryIT0

Bi-Ped Walker: https://www.youtube.com/watch?v=XdRzgwtMpUE

4-Legged Walker: https://www.youtube.com/watch?v=u0K274aB9YQ&t=5s

6-Legged Walker: https://www.youtube.com/watch?v=ZK5rndlI0bU

Jan 31 2018 Read →

Project 2: Walker

By Isaac Collins, James Liao, and Andrew Sack

Overview:

The goal of this project was to design a robot walker. Our final design was a walker with 4 legs driven by a single motor, successfully able to navigate forwards and backwards at 3 different speeds.

Research:

We got a lot of inspiration from this video, including the use of 4-bar linkage legs to keep the feet always parallel to the ground and the drive linkage.

Upon construction, we also noticed a few similarities between our robot and another well known walker:

Image

Unfortunately, though we cannot test it, we are forced to assume that our robot holds a similar flaw as the AT-AT and must avoid Lego X-Wings at all cost.

Construction:

Image Image Image Image Image

Drive mechanism:

The robot is powered by a single continuously rotating motor. The robot is utilizes only 1 motor to move by having the legs on each side attached to the motor 180 degrees apart.This causes the sides move offset from each other. The legs are connected by individual linkages to the outside of a gear attached the the motor shaft. When the motor spins this causes the legs to move back and forth.The best linkage was determined by testing different linkage lengths to optimize motion and balance, though piece availability also played a role. The linkage lengths were determined to be 9 and 7 hole-lengths for the front and back legs respectively along each side.

Legs:

The legs were made by using a 4 bar parallel linkage, so that no matter what direction the legs were going the ‘feet’ of the robot would always be parallel to the ground. By using a flipped L piece, this concentrated the majority of our robot’s weight onto distinct points on the ground which gave us greater traction, especially on low friction surfaces such as tabletops. Slippage was still an issue our robot dealt with especially at higher speeds.

Performance:

Our walker successfully performed to match our tests, with the leg design minimizing slippage, however at higher speeds the robot still would slip and sway back and forth while in motion. By using longer  linking pieces and positioning the L beams as the ‘feet’ of the robot, we maintained balance at all three speeds even if it became more unstable as the motor speed increased. Even with slippage as well, the robot could still keep moving forward, though it did have difficulty driving straight. One further way not tested that could have been used to improve traction between the robot and the floor would have been to add rubber components available in the kit to the feet. Overall this robot performed to expectations and successfully walked.

Software:

The software for this robot is very simple, since the robot only needs one motor rotating continuously for it to move. The core code is that the motor is turned on at a given speed, the code waits for a certain amount of time, and then the motor is turned off. However, since the robot needs to be able to move at multiple speeds and directions, the included file is slightly longer to demonstrate multiple speeds.

Code: walker.py

Jan 31 2018 Read →

TomBot (the GOAT)

The task of this assignment was to create a robot using the LEGO MINDSTORMS EV3 set that moved forward/backwards without requiring wheels. In other words, we were to create a walking robot.

Research

Various YouTube videos were watched to get an idea of how this task is generally accomplished, but none were explicitly used for inspiration. Most of the idea came from ME42 knowledge of four-bar linkages and more than a few failed attempts to design Tom.

Description

Tom is a four-legged walker driven by one motor that rotates 4 gears. The motor is connected to the output port D as shown in the header image.

Image

Each front leg is driven by what is essentially a four-bar linkage mechanism. The first link is ground (Tom's motor and brain), the second is the top gear connected to the motor axle (which can be modeled as a short beam that completes a full rotation), the third member is the one with wings on it (translates motion from the motor region to the front region), and the fourth member is the front leg and foot. This can be seen below. The front leg is on the left.

Image

The hind legs instead, are entirely driven by gears.  Each hind leg relies on the rotation of two gears, one of the motor axle gears and the auxiliary gear on one side of Tom. This can be seen above. The hind legs are to the right.

The driving mechanisms are entirely symmetrical, but set 180° out of phase. This is critical because it allows Tom to balance on three legs at a time and drive himself forward.

Tom also has striking blue eyes, a cute little mouth and fangs, two large horns, and wings that move.

Additionally, Tom's is very easy to feed as you can get to the battery pack but removing one LEGO connection and rotating the EV3 brain around a pivot in the rear. Tom remains entirely intact during this procedure.

Image

The Code

Tom was designed to be able to walk both forwards and backwards at a variety of speeds ranging from 1050 (in our case full speed backwards) to 0 (which is not moving at all) to -1050 (full speed forwards). During testing it was noted that Tom was able to proficiently move in both directions; this makes sense because all of his linkages were fully constrained and the assembly was limited to one degree of freedom. It was also noted that there was a maximum optimal speed around 500. Any slower and the bot was limited by how slow the motor could turn, any faster and Tom would actually tear himself apart at the joints.

Image

Jan 31 2018 Read →

Robert Hrabchack

Riley Kolus

1/31/2018

QuadBot - The Walking Robot

Intro:

For this assignment, we were instructed to build a robot that walks. The robot could use any walking mechanism we wished, so long as it did not roll. Once constructed, we needed to demonstrate that our robot could move both forwards and backwards at variable speed.

The Robot:

To accomplish the objectives above, we decided to go with a six-legged robot, of which four legs would move. The four mobile legs were placed in the for corners of the robot, and moved by the rotation of a gear to which they were fixed by a pin (see images below). This pin introduced the necessary cyclical motion for walking, while another pin, halfway down the leg, connected the leg to a stationary part of the robot via a linkage. This linkage constrained the motion of the leg so that its end could only move through an elliptical path, much like a foot on an animal. We built four of these legs, two front legs and two back legs. Each set of legs was actuated by one motor.

Initially, our robot only had these four legs, but when it came time to make the robot walk, we found it merely undulated in a semi-disturbing way, but could not go anywhere. We tried changing offsets between front and back legs, and between both legs in front or back, though nothing could make the robot travel. Finally, we decided to add a peg leg in the front, to help left the moving legs off the ground during their recovery swing. This turned out to be the key to achieving forward motion, so we added a second peg in the back to perform the same function for the back pair of legs. Our hexapod robot was complete.

The Code:

The programming of this robot was exceedingly simple, involving only a command to move in one direction or the other at a predetermined speed. We accomplished this by creating a speed variable entitled “MotorSpeed,” and assigned it a value -100 to 100. By passing this variable to both motor drive commands, we were easily able to drive our robot forwards and backwards. Changing speed was only a matter of changing the MotorSpeed variable.

Image

Testing:

Testing this robot revealed problems with our design. Initially, it highlighted the need to give the robot something to sit on during its recovery swing, leading us to add the peg legs. Later testing became revealed that our robot did not increase its speed linearly with increases in the MotorSpeed variable. Since we were using lego pieces as legs, the robot lacked traction on the ground, and increasing MotorSpeed led to decreased contact time with the ground during each step cycle, creating more slippage. We found that increasing the motor speed paradoxically slowed down our robot’s travel speed. In order to fix this, we did two things. First, we adjusted the speeds at which we would drive the robot. Above 60% of the possible motor output, the robot could not maintain a gait that was conducive to forward motion. Too much undesired flexion in the gear shafts and resistance in the linkage system led to changes in the forward/backward offset, as one motor was slowed when the other was not. Driving the motors below 60% reduced this phenomenon a great deal, making it manageable. The second thing we did was add rubber bands to each of the legs, giving the robot a miniscule amount of traction. This greatly aided the robot’s forward motion, preventing backsliding almost altogether.

With these changes in place, our robot was able to drive both forwards and backwards at the changing speed (still limited to 60%) successfully.

Jan 31 2018 Read →

BILLY THE PENGUIN - by Alex and Sahana

Description

This is Billy the Waddling Penguin. Billy has two motors directly underneath his brain (the brick). The motors are connected from the back of the brick and to secure it, there are also connections on the side. Each motor controls a gear train, and each gear train is attached to one of Billy's legs. Each motor is run at the same time and at the same power, with the two legs in different starting positions, such that one leg takes a step forward while the other leg prepares itself to do the same, and so on. Unfortunately, Billy has had 1 too many fish, and has some difficulty getting his feet fully off the ground due to his weight. However, the motion of the motors and the legs still generate enough momentum so that Billy is able to waddle forward.

The gear train uses four gears -- the largest gear available in the LEGO kit is the driver. This gear train is designed such that the other gears in the train move at a higher speed than the motor. Two 24 tooth gears are used to move the legs, with an 8 tooth gear between them to make sure that each part of the leg moves in the same direction.

Something to note is that one of the motors inherently moved slower than the other--something that was not discovered until much later. Hence, since one motor moves more slowly than the other, in some of the videos, Billy's path may be skewed to one direction (like when billy moves backwards).

The motion when Billy went slower vs. when Billy went faster was a lot smoother. When Billy went fast, he jostled around a little bit but the slow motion was closer to the intended design. 
Images

Image

Connection of Brick to Motors

Image

Side view: gear train structure, legs, some connections of brick to motor

Image

Back View of Billy (left)

Image

Back view of Billy (right)

Video

Billy moving forward at motor speed = -10

Billy moving forward at motor speed = -1000

Billy moving backwards

Code

Image

References

https://www.youtube.com/watch?time_continue=1&v=TjzxO3D_gzU

Jan 30 2018 Read →

Komodo the Walking Robot

By Martin Majkut and Omar Sanchez

The goal of this project was to change rotational motion into locomotion without the use of wheels. To do this, we first spent a minutes researching examples of non-rotational locomotion. After looking at some really cool robots, we found the following example converting rotational motion into reciprocating motion:

Image

We made an initial design using this method (of which we forgot to take pictures of). Our design was very unstable and would constantly fall over. So, we made improvements to the design by lowering the center of gravity both through motor orientation, placement and shortening the lengths of the legs. By keeping the EV3 and motors in line, we could have the center of mass as close to the ground as possible. The orientation of the motors is also key because it allowed us to use beams that are longer than the shortest beams in the kit, thus giving us a little bit more travel of the legs to move the robot forwards or backwards. Once the motors were connected, it was all about making the design as stable as possible. We added beams so the construction would not fall apart, added gears and tracks to increase stability while walking, and finally added the rubber beams (?) to allow Komodo the traction it required to move.

Gallery:

Image Image Image Image Image Image Image

Jan 30 2018 Read →

Project 2: Walker

Description: Our group created three different robotic walkers that unfortunately did not make any forward progress (you can see our iterations in the video). The final design is inspired by a praying mantis (http://robotsquare.com/2012/02/27/tutorial-manty/) and uses a variation on a two bar linkage with some points that allow freedom in some directions while restricting others. The motors are rotated 180 degrees from each other to allow the legs to push off one at a time. There is a touch sensor to allow the user to stop the Mantis from moving. The Ultrasonic sensor was used purely for aesthetic purposes to make the walker look more animal-like.  The video shows the robot moving slow, fast, and backwards.

Code: #!/usr/bin/env python3 ev3 = Device("this")
def manageRange(n): return max(min(n,1050),-1050) def main(): speed = None #keep going until the button is pressed while True: speed = -30 #variable for speed outA = ev3.LargeMotor('outA') outA.run_forever(speed_sp= manageRange(speed* 10.50)) outC = ev3.LargeMotor('outC') outC.run_forever(speed_sp= manageRange(speed* 10.50)) if ev3.TouchSensor('in3').is_pressed: outA = ev3.LargeMotor('outA') outA.stop(stop_action="hold") outC = ev3.LargeMotor('outC') outC.stop(stop_action="hold") break if __name__ == '__main__': main()
Image

Jan 30 2018 Read →

In the video you will see the walker move forward, backwards, turn to the left, turn to the right, and then move forward at a faster speed.

Description

Our robot walker is inspired by the following video:

Lack of pieces limited our design but the basic premise is the same:  two motors attached to a gear train that facilitate movement.

Image

Figure 1 - Plan View of Walker

You can see the basic frame of the walker here, with two motors on each side.

Image

Figure 2 - Side View of Walker

Here the back legs are what provide the friction necessary to move the walker. You can also see the gear train.

Code

!/usr/bin/env python3

ev3 = Device("this")

from time import sleep

def main():

MotorC = ev3.LargeMotor('outC')

MotorB = ev3.LargeMotor('outB')

MotorB.run_forever(speed_sp=300)

sleep(1)

Moving forward:

MotorB.run_forever(speed_sp=300)

MotorC.run_forever(speed_sp=300)

sleep(6)

MotorB.stop(stop_action='brake'); MotorC.stop(stop_action='brake')

sleep(1)

Moving backward:

MotorB.run_forever(speed_sp=-250)

MotorC.run_forever(speed_sp=-250)

sleep(4)

MotorB.stop(stop_action='brake'); MotorC.stop(stop_action='brake')

sleep(1)

Turning right:

MotorB.run_forever(speed_sp=350); MotorC.run_forever(speed_sp=-100)

sleep(6)

MotorB.stop(stop_action='brake');MotorC.stop(stop_action='brake'); sleep(1)

Turning left:

MotorC.run_forever(speed_sp=350); MotorB.run_forever(speed_sp=-100)

sleep(6)

MotorC.stop(stop_action='brake');MotorB.stop(stop_action='brake'); sleep(1)

Supa fast

MotorB.run_forever(speed_sp=500)

MotorC.run_forever(speed_sp=500)

sleep(10)

if name == 'main':

main()

Jan 30 2018 Read →