Home Sign Up!

Browse Community Submit

All Art Craft Food Games Green Home Kids Life Music Offbeat Outdoors Pets Photo Ride Science Tech

Seg...stick.
by scolton on December 22, 2010 Table of Contents Seg...stick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Intro: Seg...stick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 1: Physics says it's easier to build a full-size self-balancing thing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 2: Gathering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 3: Drive motors, choosing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 4: Drive motors, modding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 5: Drive wheels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 6: It's starting to look like a...something. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 7: And now, the hard part. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 8: Software overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . File Downloads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Step 9: Two sensors, one angle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 2 2 3 4 5 6 7 8 9 9 9

Step 10: A very flattering filter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Step 11: The control part of the controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Step 12: Steering, and other loose ends. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Step 13: Sticking it all together. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Step 14: Links to better self-balancing things. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Related Instructables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

http://www.instructables.com/id/Segstick/

Intro: Seg...stick.
Do-it-yourself self-balancing...things...have been around almost as long as commercial self-balancing things. Obviously the homemade versions are not as smooth, reliable, or failsafe as the real thing, but they are still pretty captivating. And they make great mechanical/electrical builds with some interesting control theory mixed in. In the final step, I provide a few references to good DIY self-balancing...whatever...builds. In 2007, I helped with this other self-balancing scooter build at the MIT Edgerton Center, and since then we've gotten many interesting questions by email about how it works. Baseline self-balancing functionality is actually surprisingly simple, and maybe the purpose of this Instructable is to take this simplicity to the extreme. To that end, I present: Seg...stick. Segstick is a self-balancing...well, literally some kind of broomstick I found in the MITERS workshop. It is powered directly by two DeWalt cordless drills chucked to two 6" wheels. The controller is an Arduino. Additional supporting devices include an Inertial Measurement Unit (IMU) from Sparkfun and two motor drivers from Pololu. Is it the best DIY self-balancing vehicle ever? No, not even close. But it only took about two days to build, and it is stripped down to the bare necessities. Thus, I hope to point out the modules and concepts involved in making any self-balancing vehicle rather than the specifics of this one. To start with, some physics...

Image Notes 1. Segstick.

Step 1: Physics says it's easier to build a full-size self-balancing thing.

One question we get a lot is: Can this work on some kind of miniature self-balancing robot? Yes, but, the laws of physics make it harder to control a small inverted pendulum bot than a full-sized rideable self-balancing vehicle. For one, the mechanical time constant of a small self-balancing robot is faster. Imagine the difference between trying to balance a broomstick on your finger and trying to balance a pencil on your finger. The controller for a small robot has to be that much faster to keep up with the physical system. Additionally, a human rider takes some of the burden off the electronic controller, since the human mind is a pretty good controller too. For example, the accelerometers used on self-balancing platforms can't distinguish between standing still and moving at a constant velocity, but a human rider can. The human rider can adjust by leaning forwards or backwards to speed up or slow down. So, this Instructable focuses on a full-size vehicle, albeit a relatively small one. In the final step, there are some links to balancing robots.

http://www.instructables.com/id/Segstick/

Image Notes 1. The longer the inverted pendulum, the slower the exponential fall.

Step 2: Gathering.
Having decided to build a full-sized self-balancing vehicle, there are a number of essential components and modules to acquire. Here is a complete list of parts used to build the Segstick. Details of and alternatives to several components will be presented in later steps. Big-Ticket Items ($411): 2x DeWalt DC759 18V Cordless Drill (eBay, $60ea new w/o battery or case) 1x DeWalt DC9096 18V Battery (eBay, $40) 2x Polulu High-Power 18v25 Motor Driver ($50ea) 1x Gravitech Arduino Nano 3.0 ($35) 1x Sparkfun Razor 6DOF IMU ($60) 2x AndyMark 6" FIRST Wheel ($13ea) 2x AndyMark 1/2" Keyed Hub ($15ea) McMaster-Type Stuff: 2x Mounted 1/2" Bearings (5913K61) 4x 1/2" Shaft Collar (9414T11) 1x Precision 1/2" Keyed Shaft (1497K131) 1x 1/8" Key Stock (98535A130) Scrounge-ables: - Plywood (3/4", 1/2") - Hose Clamps or Extremely Large Zip Ties. - 1/4-20 Bolts and Nuts - Breadboard or Protoboard - Wire, Heat Shrink, Solder - 5k or 10k Potentiometer. - Polarized 2-Pin Power Connectors (e.g. Deans) - Heat Sink Material And Most Importantly: - A Stick.

http://www.instructables.com/id/Segstick/

Image Notes 1. My stick of choice. I think it's a broomstick handle.

Step 3: Drive motors, choosing.

Segstick uses two DeWalt DC759 18V cordless drills as drive motors. Cordless drills are great because you get a motor, a gearbox, and a way to couple to the drive shaft together in one package. They are also available cheaply on eBay used or without the battery, charger, and case. Cordless drills are not so great because the chuck often has a lot of backlash, which makes controlling the vehicle difficult. I've been informed that some low-end drills actually have less backlash because they don't have an anti-backdrive feature on the chuck. You might also be more willing to sacrifice a cheap drill like this than a nice, working DeWalt. Another option is to use gearmotors from the robotics market, such as the BaneBots P80. You can see these deployed on our first balancing vehicle, as well as Charles Guan's Segfault. These gearboxes give you considerably more gear ratio options (12:1, 16:1, 27:1) and will have less backlash than the DeWalts. The downsides are a higher price and more fabrication required for mounting and attaching a wheel.

Image Notes 1. Use in low gear / 450rpm. 2. NOM.

http://www.instructables.com/id/Segstick/

Image Notes 1. Banebots P80 gearmotor.

Step 4: Drive motors, modding.

If you do choose to go with cordless drills, they will require a bit of hacking to work as balancing vehicle motors. Mainly, this involves getting direct access to the two motor terminals. The drill's motor controller, as nice as it may be, can't do four-quadrant (reversible) motor control, which is required for this project. The mod is pretty quick: After opening the drill case (you will need a Torx driver for the DeWalt case), disconnect the motor leads from the trigger controller. File down a slot in the two halves of the case through which these leads can be passed. Then, reassemble.

Image Notes 1. Trigger speed controller. 2. Gearbox and clutch assembly. 3. Brushed DC motor.

Image Notes 1. Slot for motor leads. 2. Oops.

http://www.instructables.com/id/Segstick/

Step 5: Drive wheels.

Real Segway wheels are huge. There are good reasons to use large wheels (better performance on cracks and rough terrain, for example). For the purpose of building a homemade self balancing vehicle, I've found it easier to use smaller wheels. Segstick's wheels are almost absurdly small (6"). But something in the range of 8-12" would work well with the gear ratios available in cordless drills (low gear) or commercial robot-type gearboxes. It can be tricky to find good drive wheels for a project like this. The vast majority of wheels you might find lying around are caster wheels, with bearings built in. Drive wheels have some way of transmitting torque from a rotating shaft to the wheel, such as a key. The DeWalt drill chucks can accept up to a 1/2" keyed shaft. Some other drills may only go up to 3/8"...avoid these. Here are some good places to look for drive wheels: AndyMark, a supplier for FIRST robotics parts. Segstick use 6" AndyMark wheels with a keyed 1/2" hub. Skyway also sells nice drive wheels in larger sizes. Of course, you can also make a caster wheel into a drive wheel by fabricating and/or attaching a hub. Depending on your level of machining experience, this may be easier than trying to find a drive wheel exactly the size you want.

Image Notes 1. Keyed hub. These were 3/8" but I manually converted them to 1/2". 2. To attach the hub, you can either use through-bolts or tap the wheel for 10-24 or 10-32 machine screws.

http://www.instructables.com/id/Segstick/

Step 6: It's starting to look like a...something.

Unfortunately, you can't just stick the wheels on a shaft, put it in the drill, strap it to a stick, and go. (I wish...that was my original intention.) The drill chuck can't handle that much bending load. So, external bearings to support the rider weight are very necessary. Segstick uses mounted 1/2" ball bearings (McMaster PN: 5913K61). These are great because they can tolerate quite a bit of misalignment. The process: Cut a piece of 3/4" plywood to the dimensions for the deck (where you put your feet), which will also hold the drills, bearings, and eventually the electronics. Then, mark out some holes for the bearings and for extra-extra-large zip ties to hold the drill in place. Hose clamps might work too. Then, drilled all those holes. Pro Tip: If you leave one drill unmodified until the very end, you can use it to make everything else. ;) The bearings are attached with 1/4-20 bolts. In this case, they require 1/2" spacers to match the height of the drill. While fastening everything down, it's useful to put the drive shaft into the bearing and drill chuck, and possibly even to have the drill motor running. This ensures good alignment as things are zip-tied/screwed/bolted/what have you. When everything is ready to go, the wheels go on with locking collars on either side to constrain them axially. Don't forget the key! And don't forget to tighten the chuck...a lot!

Image Notes 1. Marked holes where the zip-ties / hose clamps will go.

Image Notes 1. Future drive motor, but for now it's still useful as a tool.

Image Notes 1. The bearings needed a 1/2" spacer, in this case polycarbonate, to be at the same height as the drill chuck.

Image Notes 1. A locking collar spaces the wheel out from the bearing. 2. The key.

http://www.instructables.com/id/Segstick/

Image Notes 1. A second locking collar on the outside prevents the wheel from falling off. 2. Zip tie constraint #1. 3. Zip tie constraint #2. 4. Zip tie constraint #3. 5. Be sure the chuck is extremely tightened.

Step 7: And now, the hard part.

Anyone can strap wheels to a stick, right? The magic behind a self-balancing thing is in the electronics. The controller must read in accelerometer and gyro data, calculate the angle of the stick, and command the motors to take corrective action, keeping the rider upright. This process of sensing a physical variable (angle), making a decision, and executing a corrective action that will affect that variable is called feedback control. Usually, the controller is some kind of microprocessor. In some rare cases, one might be compelled for unknown reasons to do it entirely with analog circuitry. Segstick instead uses a more conventional digital controller implemented on everybody's favorite: the Arduino. Specifically, it uses the Arduino Nano 3.0 from Gravitech. But any Arduino will do. For sensing, Segstick uses the Sparkfun Razor 6DOF IMU. Really, you only need one accelerometer axis and one gyro axis, as will be discussed in the next step, but this package is so convenient and allows you to mount the board any way you want. Since it uses all 3.3V sensors, it will need to be powered from the Arduino's 3.3V output. Each sensor outputs an analog voltage which is read in by the Arduino's analog to digital converter (ADC). More on that in the next step. For controlling the motors, Segstick uses two Polulu High-Power 18v25 motor drivers. These are tiny but powerful reversible motor controllers capable of providing up to 25A each. I decided to add a heat sink to them, but they seem to run cool enough without it. They do require large-gauge wiring to the battery and to the drill motor leads. The circuit schematic is shown below. How you implement it (breadboard, protoboard, printed circuit board) is up to you. I did it on a vector board that I later cut to size. Soldered connections will generally be more reliable than breadboard-type connections on a moving vehicle, so I'd recommend using sockets for the components but directly soldering wired connections.

Image Notes 1. The dots imply a connection between intersecting lines. All other intersecting lines do not connect.

Image Notes 1. LM7808 voltage regulator to power Arduino. 2. High-current wires are soldered directly to the motor driver boards.

http://www.instructables.com/id/Segstick/

Image Notes 1. I added a heat sink to the motor drivers. Make sure to use Kapton or other insulation between the sink and the board. 2. The board is just screwed into the plywood. 3. High-current connectors for power wiring from the battery and to the motors. 4. 14AWG wire.

Image Notes 1. Steering pot is just zip-tied to the top of the stick...

Step 8: Software overview.

The Segstick's software is written in C for the Arduino. The full software is attached below as a text file. It's only about 120 lines of code, aided somewhat by the convenient Arduino libraries. The code is commented, but for the next few steps I'll go through the important parts of the control algorithm, since this is where the magic happens. The feedback controller really has two critical components: a digital filter that merges signals from the accelerometer and the gyro into a reliable angle estimate, and a proportional-derivative (PD) control algorithm that determines the corrective action to create by outputting voltage to the motors. These two components are the key to making a good self-balancing platform. Other less glamorous but also important ancillary functions are signal input and scaling, steering, PWM generation, output limiting, and debugging. I'll briefly mention these, too, in the next few steps.

File Downloads

segstick.pde.txt (3 KB) [NOTE: When saving, if you see .tmp as the file ext, rename it to 'segstick.pde.txt']

Step 9: Two sensors, one angle.

Another common self-balancing question: Does it use an accelerometer? Or a gyro? Answer: Both. The reason for using two sensors even though there is only one relevant physical variable (angle) is because each type of sensor has advantages and disadvantages by itself. By mixing the best parts of each together, a better overall estimate of the angle is achieved. I wrote this all up in this white paper, but here I will give a brief summary. The Accelerometer. It measures acceleration, right? Well, not really. It measure force per unit mass. So it will measure the force due to gravity as if it were an actual acceleration. The sensitivity for the Sparkfun Razor IMU is given as 300mV/g, meaning the output will change by 0.3V per 9.8m/s^2 of acceleration. How is this converted into an angle? Well imagine using the accelerometer axis that is pointed in the direction of travel of the vehicle. As the vehicle pitches forward, the axis sees positive force due to gravity. As the vehicle pitches backwards, it sees negative force. It's tempting to say that the gain should be 300mV/90, since pitching 90 corresponds to 1g. However, it's the slope of the output near 0 that matters, and thanks to trigonometry this slope happens to be 300mV/rad or 300mV/57.3. See the image below for an illustration of this. Since the Arduino's ADC gives a 10-bit value based on a 5V reference, you can calculate the gain on the raw ADC value by: (57.3/0.3V)*(5V/1024LSB) = 0.932/LSB LSB (least significant bit) is just a way of saying one bit. This is the value by which to multiply the raw analog value to get an angle in degrees. Note that you also need to subtract the zero angle offset from the analog signal. This is best found experimentally, by holding the platform at zero angle and reading off the value. So why not just use the accelerometer to measure the angle and be done? The problem is that the accelerometer can't tell the difference between gravity and actual acceleration. So, if the platform is perfectly level but the vehicle accelerates forwards, it will register the same as tilting backwards. Taking a long-term average, though, the only "acceleration" that remains is gravity. Unfortunately, long-term averaging is not conducive to snappy feedback control. Enter... The Gyroscope. More accurately it should be called an angular rate sensor, since it has little to do with an actual flywheel-based gyroscope. It reports back a signal proportional to the rate of rotation. On a balancing platform, its sensitive axis would be parallel to the axis of rotation of the wheels. The Sparkfun IMU gyros have a sensitivity of 3.33mV//s on the 4x channels, meaning the output changes 3.33mV for every /s of rotation. Since the Arduino's ADC gives a 10-bit value based on a 5V reference, you can calculate the gain on the raw ADC value by:

http://www.instructables.com/id/Segstick/

[(1/s)/0.00333V]*(5V/1024LSB) = 1.466(/s)/LSB This is the value by which to multiply the raw analog input to get an angular velocity in degrees-per-second. Like the accelerometer, the zero offset for the gyro must be subtracted first. It can be found by holding the platform stationary and reading off the analog value. To get from degrees-per-second to degrees, the gyro signal can be integrated. For every step in time, the gyro signal multiplied by the duration of time between steps gives an incremental change in angle. The total angle is the running sum of these increments. This causes a problem, though: If the gyro signal is not exactly zero when the platform isn't rotating (and it never will be) the integration will drift. With no absolute reference, there is no way to correct for this drift with the gyro signal alone. However, for short durations, the gyro provides a very sensitive angle estimate that is immune to noise from horizontal acceleration of the vehicle So one sensor is great for short-term, fast-response angle estimates. The other is great for long term, drift-free absolute angle averages. Are you starting to see where this is going?...

Image Notes 1. These values should be determined experimentally. 2. These values are calculated as above.

Image Notes 1. It's the initial slope that matters for setting the accelerometer gain.

Image Notes 1. The order of subtraction is reversed here to keep the direction for positive angle and positive angular rate consistent. You may have to check this in your implementation. 2. The raw analog values are multiplied by the gains to change to consistent units of degrees [per second].

Step 10: A very flattering filter.

To combine the two sensor readings together in a way that produces the best angle estimate, a special technique called a complementary filter is used. (No, not a complimentary filter, and definitely not a Kalman filter.) The filter is really just a single line of code: angle = A * (angle + rate * DT) + (1 - A) * (float) accel_raw * A_GAIN; Okay, so it's a long line. You can also do it with an op-amp or two. This filter does exactly what is necessary in this scenario: it favors the gyroscope reading for short time durations and the accelerometer average reading for long time durations. Let's break it down: A is the factor that determines the cutoff time for trusting the gyro and filtering in the accelerometer. It's always between 0 and 1, usually close to 1. In this case, A is defined to be 0.962. This means that at every time step, 96.2% of the new angle measurement comes from the old angle measurement plus the integrated gyro measurement. The remaining 3.8% comes from the accelerometer. This slowly averages in the accelerometer over many time steps. DT is the time in seconds between program loops, the time step. Here it is defined to be 0.020 and is set by delay(20) at the end of the loop. The code in the loop itself take much less than 20ms, so the delay dominates the time step. rate is the gyro reading, converted to degrees per second. accel_raw*A_GAIN is the accelerometer reading, converted to degrees. It is very important that these two be in the same unit base before adding together. (You can't add apples to oranges.) The time constant of the filter is the duration of time at which the gyroscope reading starts to be filtered out heavily and the accelerometer reading starts to be averaged in heavily. It's actually a continuous process, but the time constant is a single measure of where the balance begins to shift. The time constant is: tau = DT*(A)/(1-A) = 0.5s So, for this filter, the gyro is trusted for about 0.5 seconds and the accelerometer start to average in significantly after that. This value can be tweaked by changing A.

http://www.instructables.com/id/Segstick/

Image Notes 1. Summing only works if the base units match, which is why everything is first converted to degrees [per second]. 2. The filter outputs sum to one. This is the "complementary" part. 3. The complementary filter can be viewed as a low-pass and a high-pass filter with the same time constant.

Step 11: The control part of the controller.

Maybe the rest of the software is just setup for this part: the feedback control algorithm that actually decides how to correct for leaning and keep the platform balanced. For the Segstick, I used a proportional-derivative (PD) controller, a subset of PID control. Proportional. This is a corrective action that scales proportionally to the angle. If the stick leans forward twice as far, the corrective action is twice as great. This is like the "spring constant" of the system, applying a restoring force as the stick moves away from vertical. Derivative. This is a corrective action that scales proportionally to the derivative of the angle, or the angular rate. If the stick is falling twice as fast, the corrective action is twice as great. This is like the "damping constant" of the system, applying a force that resists rotation in either direction. Together, this forms a mass-spring-damper system, except with virtual springs and dampers. The relative spring constant and damping constant affect how much the system oscillates as it corrects for angular displacement. Simple, right? Here's the code: output += angle * KP + rate * KD; Yep, simple. output is the command to be sent to the motors. KP and KD are tweaked until it balances (or goes goes totally unstable). One subtlety here is that the output command is incremented by the value output by the PD controller. So, if the angle is held at some offset from vertical, the motor command will keep increasing. It's like adding an extra integral to the system, as shown in the block diagram below. Usually in feedback diagrams, the feedback path has a negative sign, but it really depends on the way the motors are set up. Choosing the sign for output can either be done in software (-= instead of +=) or in hardware by just swapping the motor leads. If both wheels start moving the wrong way in response to the angle, you can flip the sign. If one wheel starts moving the wrong way, you can just swap its motor leads.

Image Notes 1. The proportional gain acts on the filtered angle estimate.

Step 12: Steering, and other loose ends.

Steering is accomplished the same way it would be on a tank-drive robot: differential commands sent to the left and right motors. For example, increasing the speed of the left motor while decreasing the speed of the right motor will make it turn right. This is readily implemented based on the signal read in from the steering potentiometer. Outputting to the motors is done by setting a pulse width modulated (PWM) signal on the motor controller inputs. In Arduino land, this is done with analogWrite(). However, the default Arduino PWM frequency is way too low for motor control, so I added some direct register manipulation to force it to be 15.625kHz. Since the controllers are reversible, I use a small forest of if statements to figure out what to put on the DIR pins and whether or not to invert the output command. One very important part of writing good control software is managing data types. You can see in the code that I often explicitly typecast to make sure I'm getting exactly the data type I want at every step of the calculation. Nothing is worse than having your controller freak out because a variable overflowed. For that reason, I also apply limiting at each step to ensure that the variables stay within appropriate ranges. For example, analogWrite() takes an integer value between 0 and 255, so I limit the outputs to this range at every step of the calculation.

http://www.instructables.com/id/Segstick/

Image Notes 1. Hacker stuff. Image Notes 1. Clip as float to prevent the output from incrementing indefinitely. 2. Differential steering command. 3. Clip again as integer after adding steering to ensure that the values sent with analogWrite() are within range. 4. Why does the Arduino constrain() function not do legit things?

Image Notes 1. For the reverse cases, the output command is inverted so that it is still between 0 and 255.

Step 13: Sticking it all together.

The stick is screwed in place, the electronics are all wired, and everything is clipped to an 18V DeWalt battery. (I suggest testing wheels-up with a power supply first.) Here's a quick video of the Segstick jerkily wandering around:

http://www.instructables.com/id/Segstick/

Step 14: Links to better self-balancing things.

Also on Instructables: Self balancing one wheeled electric skateboard - Awesome build by XenonJohn. Easy build self balancing skateboard/robot/segway platform - also XenonJohn. Angle measurement using gyro, accelerometer and Arduino - More complementary filter. Some close to home: The DIY Segway - MIT Edgerton Center Summer Engineering Workshop, 2007. Segfault - Charles Guan's totally analog balancing scooter. The Uno - By BPG Motors. The original [copy]: Building a Balancing Scooter - Trevor Blackwell. Robot versions: Balancing robot Wheeley - I like the technical explanation.

Related Instructables

Easy build self balancing skateboard/robot/segway platform by Steampunk XenonJohn Segway ( Legway ) by bdring

Angle measurement using gyro, accelerometer and Arduino by otaviousp

Zoltar Speaks (Photos) by macgeek800

Zoltar Speaks The Instructable by macgeek800

Self balancing one wheeled electric skateboard by XenonJohn

http://www.instructables.com/id/Segstick/

Comments
41 comments Add Comment

luanlist says:
Hi, I didn't understand how to find A_Zero, G_zero and S-Zero values. Experimentally yes, but how? Thanks

Feb 18, 2011. 9:53 AM REPLY

scolton says:

Feb 18, 2011. 11:31 AM REPLY You can use Serial.prinln() to print the analog value of the sensor readings to the Arduino serial terminal. Then, you can zero the three states. (Hold the platform horizontal and stationary, and set the steering potentiometer to zero.) Record these values and you've got the zeros. Very important note: The zeros will change if you run on USB 5V instead of regulated 5V, so I suggest doing it with the external battery power turned on.

ajmontag says:

Feb 14, 2011. 4:12 PM REPLY Am I correct in saying that the angle and rate values should be based at, and stay near zero? Then the output would be around 0, either +/-, and the sign is intended for direction, correct? Thanks!

scolton says:

Feb 14, 2011. 6:33 PM REPLY Yes, all the control equations assume a small angle approximation, which would only be valid within maybe +/-30deg from 0, which is defined as the base being horizontal. After that, you would need some trig to solve for the angle based on the accelerometer readings. (The rate reading doesn't care about the absolute angle.)

skeleton1102 says:

Jan 2, 2011. 4:29 PM REPLY Question: In the else case at the final stage before output. Is the LOW argument turning that motor off? sorry I dont know much about the electrical/physical aspect of the project. And are the splitting of output into right and left for the right and left motors. BTW the white paper was fantastic. Really helped me for what Im trying to do

scolton says:

Jan 2, 2011. 5:31 PM REPLY Thanks! The LOW and HIGH arguments change the polarity of voltage applied to the motor via the DIR pins on the motor controllers. And yes, output_left and output_right are split for the left and right motors, so that a differential steering command can be applied.

XenonJohn says:
Hi Shane,

Jan 17, 2011. 10:18 AM REPLY

It was your original ??2007 version of the white paper on how a complimentary filter works that gave me enough confidence to attempt a selfbalancing machine. Great instructable. XenonJohn

skeleton1102 says:
hhmmm so the polarity means that the motor will go the other way? I really no nothing about electrical engineering.

Jan 2, 2011. 7:31 PM REPLY

scolton says:

Jan 2, 2011. 8:22 PM REPLY That's correct. The Pololu motor driver boards are H-bridges, so they can drive the motor in either direction, clockwise or counter-clockwise, based on that DIR pin input. It would be the equivalent of reversing the motor leads. The drill controllers can also do this, but they use a mechnical switch that reverses the connections directly, instead of an H-bridge. So, it can't be controlled electronically by the Arduino. Here's a couple good references on how H-bridges can apply forward and reverse polarities: http://en.wikipedia.org/wiki/H-bridge http://www.4qdtec.com/bridge.html

skeleton1102 says:

Jan 3, 2011. 12:15 PM REPLY That helps a lot thank you. The Arduino Constant Refernece says that Low is 0 volts when the pin is configured to output. Wouldn't that mean the no current is leaving that pin? I've never had any sort of physics class so I know nothing about this stuff

scolton says:

Jan 3, 2011. 1:39 PM REPLY Yeah, LOW is 0V and HIGH is 5V. They are just signals, so very little current flows into or out of the pin either way. The motor controller board reads in the signals and then sets the H-bridge accordingly. The H-bridge does all the high-current stuff.

http://www.instructables.com/id/Segstick/

skeleton1102 says:
aaahhhh thats really obvious now that you say it. Thanks a lot youve been a huge help

Jan 3, 2011. 2:19 PM REPLY

skeleton1102 says:

Jan 5, 2011. 3:41 PM REPLY Really sorry about all the questions, but do have any good references on how the whole GAIN values are calculated and set. Im very confused about how the whole LSB thing plays into this, and you know theres the whole not knowing any physics to complicate things

scolton says:
Do you mean the P and D gains? I honestly just picked numbers that sounded reasonable:

Jan 5, 2011. 9:58 PM REPLY

The motor output command is a value between 0 and 255, which sets the voltage send to the motor by the H-bridge. (Actually, it might be 0-511 because I'm using 9-bit PWM...) Each of these steps from 0 to 255 (or 511) is a "least significant bit" or LSB. So, the P gain is 0.5LSB per degree per loop. The loop runs 50 times per second. So, in one second, it will increment the output 0.5*50 = 25 steps per degree of tilt. If the platform is tilted 10 degrees (a pretty severe lean), this will be 250 steps, or almost the full range of the motor controller output, in one second. From that point, I would normally tweak the value up or down depending on the observed behavior. But actually the first values I chose seemed to work okay.

skeleton1102 says:

Jan 6, 2011. 1:08 PM REPLY I get it now, I see the whole steps thing, just calling it LSB confused me because i wikied it and its seemed to do with the right most bit which didn't make much sense to me.

luisma.suarez says:

Jan 4, 2011. 9:36 PM REPLY ok, its offcial, you rock! congrats. excellent work i'll pour over your math when i have the time- but gyro AND A meter? really nice!

clomok says:
Is that knife on the table home-made as well?

Jan 3, 2011. 10:59 AM REPLY

scolton says:
Nope, that's an Allen wrench set I got in Tokyo.

Jan 3, 2011. 11:37 AM REPLY

theugleymonkey says:
Do you think a Motor controller such as this one would be sufficient to replace the one you have used? http://www.robotshop.com/robotics-conection-10a-12-24v-dual-motor-controller-1.html

Jan 1, 2011. 2:19 PM REPLY

teamtestbot says:
Hi, This will probably work out better for you: http://kellycontroller.com/hpm14701700a144vwith-regen-p-869.html

Jan 1, 2011. 3:23 PM REPLY

It'll definitely control the motors in the 18v DeWalt drills. May be a bit large, however, but they're enclosed and waterproof unlike the Pololu boards.

scolton says:

Jan 1, 2011. 3:20 PM REPLY 10A probably is not sufficient to drive the drill motors. It's also only $10 less expensive than the two Pololu controllers, so unless I had one lying around already I wouldn't really be tempted to buy it. Dec 31, 2010. 5:16 PM REPLY

theugleymonkey says:
So I was wondering if I could use motors like one of these http://www.scooterpartscatalog.com/razor-e100-motor-119-17.html http://www.scooterparts4less.com/web_electric/180watt24v_motor.htm

scolton says:

Dec 31, 2010. 6:16 PM REPLY Sure. They would need to be geared down at least about 5:1, even for small wheels. Timing belt would probably be best. I used to think backlash would be a problem for belt or chain-driven platforms, but compared to these drills it would actually be an improvement.

http://www.instructables.com/id/Segstick/

theugleymonkey says:
Do you have any recommendations for the the gears?

Jan 1, 2011. 9:40 AM REPLY

scolton says:

Jan 1, 2011. 11:04 AM REPLY Not sure what the pitch on the motor sprockets are. The first one just says "3M". The second one I think is #25 chain, but I'm not sure. Either way, you can definitely find sprockets, pulleys, chain, belt from www.mcmaster.com or www.sdp-si.com once you know what pitch to look for. (Might have to buy the motor and measure it yourself.)

theugleymonkey says:

Jan 1, 2011. 10:15 AM REPLY Do you think implementing the ArduIMU +v2 would work? How much of the software and configurations do you think would need to be changed? http://www.sparkfun.com/products/9956

scolton says:
Oh, also, MOSI and MISO correspond to D11 and D12, the DIR outputs.

Jan 1, 2011. 10:56 AM REPLY

scolton says:

Jan 1, 2011. 10:50 AM REPLY Definitely. In fact, if I were starting from scratch that's probably how I would do it. (Less wiring.) The changes would be minimal: You have access to the two PWM driving pins, labeled PWM0 and PWM1 on the ArduIMU. These are the same as D9 and D10 on the regular Arduino. So no changes there. The analog pin definitions change a little, but nothing you can't figure out from the schematic. You'd have to use the SDA or SCL pin as the steering pot analog input. (You'll see why on the schematic.)

theugleymonkey says:
So you say for the steering pot to use SDA or SCL. Why is this? Is this because I can use it as ADC 4 or 5?

Jan 5, 2011. 8:32 PM REPLY

scolton says:
Yep.

Jan 5, 2011. 10:06 PM REPLY

ameggs says:
Could you use a dimension engineering Sabertooth motor controller for this project? http://www.dimensionengineering.com/Sabertooth2X25.htm http://www.dimensionengineering.com/Sabertooth2x50HV.htm

Dec 29, 2010. 8:14 PM REPLY

scolton says:
I think either of those would be fine. The 50A version might be good for a larger balancing platform, too.

Dec 30, 2010. 9:06 AM REPLY

static says:
Far out, but can you say impalement hazard? Put some handle bars atop that stick.

Dec 27, 2010. 7:03 PM REPLY

teamtestbot says:
Ahh, but see, this is an Instructable. That's your job!

Dec 28, 2010. 2:32 AM REPLY

janw says:
Great instructable! And a very clear way to explain things! definately worth 5 stars

Dec 27, 2010. 8:37 AM REPLY

drbill says:

Dec 26, 2010. 11:41 PM REPLY I am 56 years old and I am in continual absolute awe at what is being put together by todays kids and I get to see it all here on Instructables. I think you may have a saleable item here if you can make it work as good as a Segway (tm) Kudos

drbill says:
If you make a more refined model, please up-date this I'ble.

Dec 26, 2010. 11:47 PM REPLY

http://www.instructables.com/id/Segstick/

technodude92 says:
Very cool project youve got there. How long till your flying down the halls on your own handmade seg...stick?

Dec 26, 2010. 10:40 PM REPLY

chouf says:
I hear you have good taste in music (we can hear "Air" on your video) ;-)

Dec 26, 2010. 2:30 PM REPLY

godofal says:

Dec 26, 2010. 5:51 AM REPLY lol, awesome :D a tip perhaps: when turning, make the other wheel turn in the opposite direction (or slow down in case of movement) so that you turn in place rather than make a circlish movement nice cheap project though :D

rimar2000 says:
AWESOME! This is genial.

Dec 25, 2010. 6:36 AM REPLY

http://www.instructables.com/id/Segstick/