Stair-climbing robot
A winning project - from ideation to final product in 2 weeks!
In this project, we designed and built an Arduino-based stair climbing robot using SolidWorks in two weeks with significant materials constraints. The Stair Walker is designed to climb stairs with any height less than 5 inches and any width greater than 18 inches. In the process of designing, the balance between weight and structural integrity of the robot was a constant consideration. K’nex axles connect the two halves of the custom designed laser cut frame. Three continuous rotation servos, connecting to the axles using 3D printed gears, control the wheels. The robot detects the stairs with a touch sensor, which triggers an additional servo mounted on the back leg to raise the front of the robot. After the front wheels reach the top of the stair, the Arduino cuts the power off to the servo, allowing the servo to unlock and turn freely. The back wheels drive the second pair of wheels up the vertical face of the stairs. Once the first two axles are on the top of the stair, the front four wheels then continue to move on the flat surface of the stair, dragging the back wheels up.
Please see more about the project in the technical report below and watch the video to see it in action!
The Stair Walker
Final Report
Submitted to
The Faculty of Operation Catapult 2018 Rose-Hulman Institute of Technology Terre Haute, Indiana
Group Members: Anya Singhal, Kelly Lin, Andrew Motz, Dallas Mak
Context
Stairs are a space efficient method to facilitate vertical movement, but they pose significant obstacles to any wheeled object. Wheeled vehicles face difficulty climbing stairs because wheels have no way of moving vertically without a support stopping the vehicle from tipping over and falling off the vertical face of the stair. Using a six wheeled, internally pivoting design, a robot can overcome this by raising the third set of wheels to meet the oncoming stairs, allowing for two sets of wheels to always be in contact with flat ground. A wheeled robot with the ability to overcome difficult terrain such as stairs would be useful in emergency response, search and rescue, and military applications.
Introduction
Climbing stairs is widely considered a simple task. However, stairs pose as a major obstacle for those who are disabled. The objective of this project is to create an autonomous robot that can climb stairs while maintaining stability. Several mechanisms were incorporated into the design to achieve this goal.
A servo is a device that has an output shaft that can be adjusted to specific angles. Like motors, they rotate in circular motion and can be used to turn wheels. Servos generally come in two types, Positional Rotation and Continuous Rotation. Positional Rotation servos can only spin in 180 degrees. Continuous Rotation servos can continuously rotate at variable speeds, either forwards or backwards in full circles.
The microcontroller used to control all the processes is called Arduino Uno. Using the downloadable Arduino IDE, code was written to program the Arduino to perform various tasks based off of different inputs. A power switch connects 10V battery to the Arduino.
Servo shields are an Arduino attachment that allows the user to have access to more servo compatible ports than a normal Arduino would have. In the robot, the servo shield allows for easier control of servos, making it easier to manage wires and keep track of each individual servo’s code. The servo shield requires its own power supply, but less voltage than the Arduino; thus a voltage regulator bumps the voltage into the shield down to 5.25V.
When testing and designing any robot, it is hard to know what problems might occur until they happen, whether they are flaws in code or design. Diagnostic difficulty varies depending on which aspect of the robot requires attention. If it is a physical problem with the robot’s frame, it can be easily found and fixed within a reasonable amount of time. However, if there is an electrical problem, there could be many causes, such as faulty wires, code, or the microcontroller. Being able to swiftly identify such problems helps to save time.
The Stair Walker was not created for the sole purpose of making a robot that can climb stairs, but to help create and observe technology that can be applied to the military, search and rescue, and exploration. The concepts and mechanics of the Stair Walker can be applied to urban rescue, combat, and reconnaissance operations, as well as moving over general rough or rocky terrains.
Materials and Methods
The robot consists of an Arduino Uno microcontroller, and Adafruit 16 channel PWM servo shield, 1/8th inch acrylic, store bought and 3D printed K’nex, and HiTec continuous rotation servos. These components are connected with super glue, hot glue, fishing line, zip ties, and mini screws. The materials were supplied by the Rose-Hulman Electrical and Mechanical Engineering departments.
The robot chassis was made of 1/8th inch acrylic sheets. The designs were drawn up on paper, transferred to AutoCAD 3D software, and laser cut using the RHIT EE laser cutting machine. The four parts of the frame are attached by K’nex rods fitted through pre-drilled 1/4th inch holes. For the axles, none of the provided K’nex pieces fit the specifications required, so the axles were 3D printed from open source designs. Servos were mounted to pre-cut holes in the frame and secured with mini screws. These servos were wired to the servo shield mounted on the arduino and the touch sensor to digital port 9. The battery and arduino were mounted on the upper section of the frame.
The rotation of the front section of frame is driven by a pulley and fishing line attached to the horn of a servo. For the wheel axles, K'nex gears are mounted on each servo horn, which in turn mesh with 3D printed gears connected to the axles. The wheels came standard with rectangular axle holes. Thus it was necessary to use a lathe to drill circular holes to glue the axles into. After assembly, zip ties were used to adjust the pressure and alignment of the moveable parts.
The servos are controlled by PWM code run through the Arduino. The code uses a premade library compatible with the servo shield. The code is included in Appendix 1. When the touch sensor is activated by the base of the stairs, the robot backs up for half a second. In the space created by the backwards movement, the front half of the frame is rotated up so the front axle is at or above the height of the stair. Once the front has been raised, the robot continues forward again. As the first axle reaches the stair above, the power is cut to the servo raising the front axle. From this position the servos continue to drive forward, allowing the mechanics of the frame to drive the other two axles up the stair. The process repeats when the touch sensor is activated by the next stair.
Results
The nature of the Stair Walker made it difficult to test until it was completely assembled; Thus, components testing could not guarantee that the components would work when assembled. The electronic system underwent the most testing, and experienced several failures. An early version tested with a 180 degree servo failed to rotate on one direction while spinning a complete rotation in the other direction. Eventually it was determined to be a faulty servo and was replaced. After testing the Arduino system with a battery, it was discovered that the servos stopped responding. Through thorough diagnosis and significant help from the RHIT faculty, it was determined to be a fried chip in the shield. After shield was replaced and voltage regulator installed, the servos began working again.
Once all the components were assembled, extensive testing and revision was required. The initial version suffered from gear and axle misalignment that hindered basic motion. This issue was fixed by rematching gears and adding spacers on the axles. Further testing with plastic blocks revealed a limitation on the size of stair due to the dimensions of the rear frame. The frame was redesigned, re-cut, and reassembled with new larger dimensions. Throughout the entire process, minor tweaks and adjustments were required to the robot to address issues as they came up.
Discussion
The purpose of the our project was to build a robot that climbs stairs using different microcontroller technologies. We succeeded after numerous trials and errors with the design and construction. All the problems we encountered were eventually resolved, and our group learned a lot in the process.
The biggest problem we faced was the structural design of the robot. The six wheeled design was based on a stair-climbing robot model that we found. However, we ended up changing many parts of that design to fit our constraints.
At first, we wanted to control the wheels using DC motors. However, we realized that DC motors can be inaccurate and hard to control. To ensure that the wheels spin at the same speed, we decided to control the wheels using servos controlled by a microcontroller. Our first design of the robot consists of ten servos, with six controlling the wheels and four controlling the joints. In the process of designing this, it became apparent that the weight of ten servos would not allow the robot to climb the stairs. Therefore, we reduced the number of servos to four, three controlling each of the axles, which control the wheels, and one controlling the joint. This change reduced the weight of our robot and made it easier for the robot to pull itself up the stairs.
In the process of designing and manufacturing the custom cut frame, we learned valuable skills about technical communications. On multiple occasions, we had to communicate the the lab technicians how we wanted to change or modify the design we had originally submitted. Several of these occasions resulted in inefficiencies and frustrations from both sides and the changes were not communicated clearly. We discovered the importance of proper planning and diagramming, as well as clearly identifying each section of the sketch thus avoiding the ambiguity of “this part at the back” or “that line over there”. We were eventually able to communicate our designs with pre-drawn diagrams, specific step by step instructions, and clear identification of individual aspects.
After the robot was built, we faced the problem of controlling the rotation of the joint. Our original plan was to pull the front of the robot up using a lever. This plan failed because the servo did not have enough torque. Several options were explored, including larger motors and gearboxes, but they all negatively impacted the efficiency of the robot. We fixed this problem by changing the lever to a pulley. Through the mechanical advantage gained through the pulley, the original servo was able to raise the front of the robot. This was a great example of outside the box thinking being required to solve the problem. We were stuck in the box that the joint had to be directly powered by the servo/motor. Only once we escaped that mental set and started looking at indirect methods were we able to find a method to control the pivot without adding additional weight.
With a robot designed to such limiting specifications, we had to remake entire sections several times. In order to lengthen, flatten out, rewire, or recode a small section, we often had to remove and replace large sections. This was our introduction to the iterative design process. If we had had more time and resources, we would have been able to build new iterations of the robot to address major issues. Instead we replaced large portions at a time, until almost the entire robot was different from the original design.
Throughout the entire design, build, and test process, we learned to communicate different ideas with each others. We had problems with communication at the beginning, which caused misunderstandings and made us fall behind schedule. Slowly, we learned to listen to each other and respect different opinions by opening ourselves up to criticism and accepting other views. It was only through fostering supportive and open communication that we were able to work efficiently and successfully.
Building this robot gave our team several chances to experience important aspects of the engineering process, from technical communications to iterative design. These skills are applicable to all future engineering challenges we will face. Our final robot represents the process of taking a problem, forming a fledgling idea, planning it out, and executing on that plan to form one final product. While our robot only works under certain conditions and environments, it serves as a prototype for larger and more advanced robots. The triple axle pivoting design shows promise for uses in exploratory vehicles such as unmanned rovers. Combined with a sensor and power controls over the front portion of the frame, this design could be adapted to navigate more than stairs such as large boulders, or even small walls. Our robot is limited to stairs of a certain size, but the technology used in overcoming those stairs is applicable far beyond the novelty of climbing stairs.
Appendix 1
#include <Wire.h>#include <Adafruit_PWMServoDriver.h>
// Called this way, it uses the default address 0x40 Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();// You can also call it with a different address you want //Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);
// Depending on your servo make, the pulse width min and max may vary, you want these to be as small/large as possible without hitting the hard stop for max range. // You'll have to tweak them as necessary to match the servos you // have! #define SERVOMIN 500 // this is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX 4000 // this is the 'maximum' pulse length count (out of 4096)
void setup()
{
Serial.begin(9600);Serial.println("16 channel Servo test!");
pwm.begin();
pinMode(9, INPUT_PULLUP);
yield();
}
void setServoPulse(uint8_t n, double pulse)
{
double pulselength;
pulselength = 1000000; // 1,000,000 us per second pulselength /= 60; // 60 Hz Serial.print(pulselength); Serial.println(" us per period"); pulselength /= 4096; // 12 bits of resolution Serial.print(pulselength); Serial.println(" us per bit"); pulse *= 1000000; // convert to us
pulse /= pulselength; Serial.println(pulse);
pwm.setPWM(n, 0, pulse);
}
void loop()
{
//for (int servonum = 4; servonum < 7; servonum++) {
if (digitalRead(9)== LOW){
//Serial.println(servonum); pwm.setPWM(4, 0, SERVOMIN ); pwm.setPWM(5, 0, SERVOMAX); pwm.setPWM(6, 0, SERVOMIN); Serial.println ("back up");
delay(500); pwm.setPWM(4, 0, -SERVOMIN); pwm.setPWM(6, 0, -SERVOMIN); pwm.setPWM(15, 0, SERVOMAX); pwm.setPWM(5, 0, 1000); Serial.println ("pull up"); delay(1000); pwm.setPWM(4, 0, SERVOMAX); pwm.setPWM(6, 0, SERVOMAX); pwm.setPWM(5, 0, 1500); pwm.setPWM(15, 0, 3500); Serial.println ("forward"); delay(250); pwm.setPWM(15, 0, -SERVOMIN); Serial.println("Servo release");
} else {
pwm.setPWM(4, 0, SERVOMAX);
pwm.setPWM(5, 0, SERVOMIN); pwm.setPWM(6, 0, SERVOMAX);
delay(10); // delay .01 second;
delay(1000);
}
}