Alexander Robotics

The AVR and the Arduino

2011-10-10T00:00:00-05:00

Introduction

The beauty of the Arduino lies in its simplicity. A look under the covers of the Arduino and its IDE, however, reveals a fascinating chipset and an open, extensive toolchain.

From A to Z with the AVR

The MCU on the Arduino is an 8-bit RISC chip called the AVR. I’ll get to the Arduino component of the chip shortly (hint: the bootloader plays a big role), but first, let’s focus on what happens from programming on a computer to executing the program on the AVR. While there’s an 8-bit AVR and 32-bit AVR variety, we’ll assume 8-bit for this post.

Overview of the AVR toolchain

One reason for the popularity of the AVR is the free (as in beer and speech) toolchain. At the second highest level of this toolchain is the compiler: AVR-GCC. AVR-GCC converts C code into assembly language files. Although AVR-GCC compiles C, it’s basic C, which means referencing registers by memory address, lack of floating-point support, and so forth.

Luckily AVR-GCC is only the second highest level; at the top of the toolchain is the AVR Libc. This is the C library all AVR programs use. The library takes care of naming all the registers, supporting floating-point, adding helpful AVR-macros, and plenty more. The AVR Libc library can be included with:

#include <avr/io.h>

After writing C code that references the AVR Libc library, AVR-GCC compiles the code into individual assembly files, which the Assembler turns into object files (files in a format runnable by the AVR), the linker then combines the multiple object files into a single object file that, finally, is converted into a HEX file. Whoa, let’s take a breather.

…and breather over. The resulting file after this compile process is an Intel formatted HEX file. This HEX file is the executable instructions and, once uploaded to the AVR, will be processed as is.

How do we upload the HEX file to the AVR? An 8-bit AVR by itself cannot communicate over the USB protocol. An In-System Programmer connects from the computer (via USB or Serial port) to the AVR. When starting the upload, the programmer activates the AVR’s reset pin, which puts the microcontroller in Programming mode. Once in Programming mode, the AVR can accept the instructions from the programmer, which allows for writing the file to the AVR’s flash memory.

In-System Programmer for the AVR

The final piece of the AVR toolchain is AVRDUDE, a command line utility that sends the compiled code to the In-System Programmer or Development board for execution.

The Arduino

The AVR has up to 2KB of flash memory dedicated to a bootloader, a special region of memory that always executes after a reset. A bootloader combined with the AVR’s ability to write to its own flash memory allows the AVR to program itself over serial. Yep, a bootloader negates the need for the In-System Programmers and Development boards, requiring only a simple serial connection to the computer to program it. The bootloader can perform this serial programming by listening to the Tx/Rx (transmit and receive) lines on the AVR and write the instructions it receives to memory.

The Arduino comes with such a bootloader burned onto the AVR chip. See, even though a bootloader allows for programming via a serial connection, the bootloader itself needs to be programmed into the board initially using an In-System Programmer.

While any serial connection should work with the AVR chip and the bootloader, most Arduinos contain a USB interface. USB’s protocol is different than the simple serial protocol the AVR expects. Instead of doing the conversion on the AVR, a separate chip converts from USB to serial. On boards like the Duemilanove and earlier, this was an FTDI chip. On boards starting with the Uno, an Atmega8U2 is used to convert USB to serial. This 8U2 is more capable than the FTDI chip, allowing for the Arduino to broadcast itself as other devices, like a USB keyboard.

The (optional!) Arduino IDE

The Arduino IDE actually uses the same AVR toolchain described earlier. The IDE hides the complexity and presents a simple interface to the user.

But guess what? Any plain old text editor or IDE can be used to program the Arduino. Since the brain of the Arduino is simply the AVR chip with a booatloader, the exact same toolchain described in the AVR section can be used. AVRDUDE even comes with presets for dealing with the Arduino bootloader.

In addition to wrapping up the toolcahin, the Arduino IDE also includes useful C libraries that build on top of AVR Libc. The libraries included with each program can be found in the hardware/cores/arduino directory of the IDE.

Getting started with the TurtleBot

2011-08-21T00:00:00-05:00

My TurtleBot arrived! I pre-ordered the robot from Clearpath Robotics in June and their robotsmiths sent it out last week. I’m ecstatic.

Wait, what’s a TurtleBot?

The TurtleBot is a robot consisting of an iRobot Create (a Roomba, without the vacuum), a Kinect, a gyro sensor, and a netbook computer.

The TurtleBot represents the most advanced and complete robot platform to reach the thousand-dollar price point yet. While all the components of the TurtleBot have been available for almost a year, the TurtleBot platform brings everything together in one standard package.

The creators of the TurtleBot are also the maintainers of the Robot Operating System (ROS), which the TurtleBot runs. ROS is a popular, extensible collection of libraries and tools for robotics. The beauty of ROS is anyone can contribute a package for it. Need the ability to interpret Kinect sensor data? There’s a package for that. Looking for an algorithm to intelligently navigate a room? Yep, there’s a package for that.

The TurtleBot arrived, now what?

Assembling

I’m going to assume the TurtleBot arrived fully assembled with ROS installed. If a TurtleBot kit was ordered instead, the documentation includes detailed instructions on assembling and the ROS TurtleBot page contains TurtleBot-specific ROS installation.

However, even an assembled TurtleBot requires a few extra build instructions before beginning.

First, the gyro sensor must be connected to the Create, as pictured. The gyro sensor aids in providing better odometry to the robot. In other words, the sensor provides more accurate sense of direction and speed.

USB cannot supply the 12V the Kinect requires. The TurtleBot includes an adapter cable that splits the Kinect cable into a USB adapter and a power adapter. The power adapter connects to the gyro sensor and draws its power from the Create.

Gyro sensor/Power adapter. Black cable is the Kinect power cable.

Finally, while tempting to leave the netbook open on top of the robot, be sure to secure it! The TurtleBot can jitter when being teleoperated, which will cause the laptop to fall off the top. Secure the netbook to the top (bungee cords? velcro? I’m open to suggestions) or leave the computer snug in the bottom deck.

Netbook snug in bottom deck.

Network Configuration

When logging in to the TurtleBot netbook the TurtleBot stack will start up in the background. The network will need to be configured the first time logging into the laptop as most interaction with the robot will happen over SSH from the workstation.

Before continuing any further, change the default passwords. Seriously, someone will SSH into the robot at the least opportune time. Treat the robot like any server and secure it.

The following instructions will change the password for the turtlebot user and root user.

# Changes the password for the user turtlebot
passwd
# Changes the password for root
sudo passwd

To test the network configuration, SSH from the workstation into the netbook. ROS does not have to be installed on the workstation for SSH-only sessions.

# SSH into the TurtleBot
# The IP address of the TurtleBot can be found using ifconfig
ssh turtlebot@10.0.1.18

Run an “app”

Okay, the boring stuff is over, time to get the TurtleBot to do something. A simple app to start with is the Keyboard Teleoperation app, which allows the TurtleBot to be controlled by the workstation’s keyboard. To begin, run the keyboard_teleop.launch in the SSH shell:

roslaunch turtlebot_teleop keyboard_teleop.launch

Now, pressing the arrow keys from the workstation should move the robot forward or backward, or turn left or right.

What does roslaunch do? Well, ROS is based on the idea of connecting separate, specialized programs called nodes. One node can process data from a Kinect while another node computes a navigation route. A launch file is an XML file describing which nodes to run. Roslaunch reads in the launch file and executes the nodes with any specified parameters.

For example, keyboard_teleop.launch sets the velocity of the TurtleBot and listens to the keyboard for direction instructions (referenced as cmd_vel in the file).

Most of the TurtleBot “apps” are launch files and their associated nodes. Running these apps is a matter of running roslaunch on the launch file.

Where to go from here?

There are more advanced apps ready to play with on the TurtleBot. Following the Network Setup and Bring Up tutorials will be necessary before running the advanced apps.

The gmapping app creates a 3D map of the robot’s environment. It may look simple from videos, but actually navigating the TurtleBot around and seeing it update the map in real-time is nerdtastic. The Gmapping app also serves as an excellent introduction to the SLAM technique, which helps a robot understand its surroundings.

A list of apps configured for the TurtleBot are available on the TurtleBot wiki.

Digging deeper into the robot’s capabilities will involve digging into the Robot Operating System. Luckily, ROS has exceptional documentation, including a start guide and tutorials covering developing for ROS.

What if I have a question?

The first place I recommend for support is the TurtleBot wiki pages on ros.org. The answer may be a couple links in, or simply be a matter of re-reading the instructions (which has helped me a few times already).

If you need to ask a question, answers.ros.org is a Stack Overflow-like Q&A site with many knowledgeable and friendly roboticists.

Open Hardware Summit 2010

2010-10-03T00:00:00-05:00

Organizers of the Open Hardware Summit. Images by Bill Ward.

It was a big week for the open source hardware movement, starting with the first conference dedicated to open hardware: the Open Hardware Summit. Yep, a conference just for open hardware. And it sold out. Big name presenters in the rather nascent field include Limor Fried of Adafruit, Chris Anderson of DIYdrones, Massimo Banzi of Arduino, and Bunnie Huang of Chumby. The OHS was followed by the New York Maker Faire.

While plenty happened, two big announcements were new Arduino boards and an updated draft for the Open Source Hardware (OSHW) Definition.

New Arduino boards

Arduino Uno

Massimo and the rest of the Arduino team announced the successor to the Duemilanove: the Uno. The Uno and the more recent Duemilanoves share the same ATmega328 chip with 32 KB of flash memory (for storing programs), 2 KB of SRAM (for storing variables), and 1 KB of EEPROM (for storing “long-term” data). The Uno is also FCC certified, opening the door for using the Arduino in new fields with regulation requirements.

The biggest change is a new USB-to-Serial chip. When you plug an Arduino into the computer using a USB cable, the computer sees the Arduino as a serial device. This allows sending commands and getting feedback between the computer and the Arduino. The previous chip — the FTDI FT232RL — has been replaced with the Atmel Atmega8u2 chip. Before, the computer only saw the Arduino as a serial device, with the Atmega8u2 the computer can see the Arduino as a keyboard, or a mouse, or whatever the developer decides.

The flagship Arduino — the Mega — was also updated to the Mega 2560. The ATmega2560 chip used in the Meaga 2560 has 256 KB of flash memory, twice that of the Mega while keeping the same size of SRAM and EEPROM. The Mega 2560 also uses the Atmega8u2 USB-to-Serial chip found in the Uno.

Though capable of speeds up to 20 Mhz, both the Uno and the Mega 2560 remain calibrated at the previous speed of 16 Mhz.

Updated Open Source Hardware Draft Definition

Discussing the Open Source Hardware Definition.

Back in July, several news outlets reported OSHW ratified a constitution. What was agreed upon was version 0.3 of the definition of Open Source Hardware by several players in the community. While ratified, the definition/license is still evolving, as Bunnie Huang described in his post.

Version 0.4 came out during the week with some minor changes and clarifications. These changes include:

Adding a Scope criteria specifying what part of the hardware falls under the license
Preferring native file formats as documentation, for example, the CAD files over a PNG
Requiring sufficient documentation on how to interface with the hardware in software

Honestly, when I started this post, I was expecting more changes between the drafts. Diffing the two definitions showed otherwise. Oh well, that’s a good sign there’s still a general consensus.

To the future

The Open Hardware Summit was the culmination of the growing OSHW movement. Yet the summit is just the beginning. There’s a strong community of hardware hackers, not only online, but in your city. Hackerspaces are forming, meetups are starting, and the local community is growing. It’s an exciting time to get started!

Voltage Regulators

2010-09-10T00:00:00-05:00

An issue quickly became apparent after setting up the Arduino and motor driver: the robot could not roam farther than the length of the USB cable powering the Arduino. A longer AC-to-DC power adapter cable would extend the range, but still keep the robot tethered. To truly roam free, the Arduino needed a battery supply.

The Arduino features a 5V on-board voltage regulator. A voltage regulator takes a higher voltage power source and regulates the power to its specified voltage. The remaining voltage is dissipated as heat.

While the Arduino’s ideal operating voltage is 5V, the recommended external input voltage is between 7 and 12V. The higher voltage required compensates for the dropout voltage - the smallest voltage difference between the input power supply and the rated output of the voltage regulator. A dropout voltage can range from 100mV for a low-dropout regulator to 2V and more for regulators like the common 78xx series.

The robot already has a 12V battery pack for the motors. Realistically, I could plug that unregulated power into the Arduino’s Vin and Gnd inputs and be okay because of the Arduino’s built-in voltage regulator. But a fresh charge of the battery actually produces around 14V — still acceptable, but that would generate more heat on the Arduino’s board than I am comfortable with. Enter the 7809.

The 7809 is part of the 78xx series of linear regulators. The 7805 has an output voltage of 5V, the 7809 has an output voltage of 9V, and so forth. Connecting a 7809 between the unregulated 12V power supply and the Arduino moves the power regulation task away from the microcontroller and onto its own circuit. This modular approach allows for easier improvements to the power supply circuit, like a more efficient voltage regulator or reverse-battery protection.

Arduino and Motor Driver with Voltage Regulator

The 7809 is rather straightforward to hook up, consisting of a positive input terminal for the unregulated power supply, a ground terminal, and an output terminal that outputs 9V to the Arduino’s Vin pin. A 100uF capacitor was added between the input terminal and ground and a 10uF capacitor was added between the output terminal and the Arduino. Capacitors act as mini-power supplies, smoothing current and providing quicker discharges when the connected circuit needs power faster than the battery can supply.

Read the specifications

I have made plenty of mistakes while learning robotics. And will continue to do so. Before writing this post, I actually had a 7805 linear regulator between the unregulated power supply and the Arduino. Even though I knew about the dropout voltages, I still thought that since the Arduino operates at 5V, I should supply 5V. The specifications clearly state a recommended input voltage of 7 to 12V. While the robot ran okay with the 7805 now, I could have had a tough time debugging an incorrect voltage from the Arduino later.

From Idea to Prototype: Brains

2010-08-24T00:00:00-05:00

The machine has a chassis and motors now, but still remains the Scarecrow of robots. There are two directions to take when giving a robot a brain: analog circuits or a microcontroller. BEAM robotics is the best example of analog circuits for logic, using transistors and comparators to determine the robot’s behavior. The schematic is the program. A microcontroller consists of a processor, input and output pins, voltage regulators, and some method to connect it to a computer for programming. The right microcontroller depends on your price and performance needs.

I went with an Arduino Duemillanove (pronunciation) microcontroller because at $30 it’s affordable and offers enough performance. And to get the blog cred. I bought the Arduino from Adafruit.com. I like what Lady Ada (Limor Fried) is doing for the Open Source Hardware movement and am happy to support the business.

The Arduino’s purpose in this iteration is simply to tell the two motors which direction to turn. Because an Arduino cannot provide the necessary power for these 12V motors, it controls a motor driver, which supplies the higher power.

A basic motor driver consist of an H-bridge and some supporting capacitors and diodes to help smooth the current. The SN754410 is a quad half H-bridge. If an H-bridge can control a single motor, the quad half H-bridge can power two motors (4 (quad) * .5 (half) * 1 = 2). The motor driver in this robot uses the SN754410 because it’s a popular chip with good documentation, can drive up to 36V at 1A continuous current, and is cheap at around $2 per chip.

Hardware

Arduino and Motor Driver

The image of a completed motor driver connected to an Arduino may seem daunting. Let’s break it down into easier-to-digest chunks.

SN754410

The core component in this motor driver is Texas Instrument’s SN754410. The datasheet tells us what each pin on the chip is for, what the voltage requirements of that pin are, and so forth. The datasheet is the reference when building a circuit.

Unregulated Power Supply

The motor driver uses a 12V unregulated power supply. Regulated power is a clean, steady voltage, usually from a component known as a Voltage Regulator. Unregulated power is the raw output from the power supply. Motors are thirsty beasts and need access to the raw power, which is why the 12V battery connects directly into the SN754410’s supply voltage (Vcc).

Enable Inputs

The Arduino provides a constant 5V supply to three inputs on the SN754410. The top right input of the SN754410 (pin 16) supplies the power for the logic circuitry on the chip. The SN754410 avoids the noisy, unregulated supply for the more precise logic functionality.

The bottom right input (pin 9) enables the right motor, and the top left input (pin 1) enables the left motor. The two enable inputs are always set to High (5V) so, you guessed it, the two motors will always be enabled. To be clear here, enabled does not mean the motors will be on; it means they are allowed to turn on.

Arduino PWM pins to SN754410

The Arduino uses two pins for each motor to control that motor’s direction. The H-Bridge post brings some insight into why; essentially, one pin will be Low and one will be High for turning clockwise. To switch directions, simply switch the pins’ output voltage. To stop the motor (a coast stop, not an electronic brake), both pins should be set to Low.

When I use Low or High, I’m usually referencing Arduino’s digitalWrite function, which can write a 0V (Low) or 5V (High). It’s binary.

A quick note here: When using a function like digitalWrite or analogWrite, that pin will output the selected value until told otherwise. In other words, when you set pin 5 to Low and pin 6 to High, the motor will spin until you change the values of pin 5 and 6.

Now what if we want more control over speed, rather than Off and Fast? Enter Pulse Width Modulation (PWM). PWM still sends a High voltage through its pin, but in configurable bursts known as duty cycles. Calling analogWrite with a scale of 0–255 sets the PWM duty cycle. For example, analogWrite(pin, 255) is equivalent to digitalWrite(pin, High) and analogWrite(pin, 127) is about half the speed of the digitalWrite with High.

Only some pins on the Arduino support PWM; the pins used in this layout (5, 6, 9, 10) all do. A pin that supports PWM can be used with analogWrite or digitalWrite. Also — a point that confused me at first — since only one pin per motor is set to High or whatever PWM value, the other pin is still set to Low or 0 if using digitalWrite or analogWrite respectively.

SN754410 output to motors

For the final hardware chunk, let’s look at how the SN754410 powers the motor. SN754410’s outputs 3 and 6 power the left motor, and outputs 11 and 14 power the right motor. You should be okay connecting these outputs directly to the motor leads. Still, motors are noisy and thirsty, so let’s alleviate these issues some.

A 0.1 μF capacitor sits between ground and each motor terminal. The capacitor serves two purposes: smooth the voltage to the motor and provide quick power when the battery can’t catch up (usually happens when the motor starts).

Another simple task to reduce motor noise is twist the wires connecting to the motor leads. Twisting reduces the “electromagnetic radiation” interference produced from the motor.

Software

A brief history of the Arduino is in order to answer a simple question: What language do you program an Arduino with?

Processing is an open source Java-based language with its own IDE (a programming environment). Processing was designed as a language for non-programmers to pick up. It hides a lot of the boilerplate code from the programmer.

The Wiring project came along as an affordable development board (sound familiar?). Wiring used the Processing IDE and a simplified C/C++ language for programming the board, which was based on an Atmel AVR chip.

The Arduino was originally derived from the Wiring project, using the Processing IDE and Wiring language. The original Arduino used a cheaper Atmel AVR chip than the wiring board, the ATmega 8.

Okay, to answer the question: The Arduino is programmed with the Wiring language, a language similar to C and C++ with some extra functionality for dealing with hardware and extras like Libraries. The IDE used to write the code and upload it to the Arduino is based on Processing. Phew. Oh, and an Arduino program is called a “sketch.”

The sketch below moves the robot forward for 10 seconds, then backwards, turns left, turns right, and repeats. The code uses Pulse Width Modulation when controlling the motors.

// Sets the Left motor to pins 5 and 6
int motor_left[] = {6, 5};
// Sets the Right motor to pins 9 and 10
int motor_right[] = {10, 9};

// Run when the Arduino starts up or is reset.
// Configures initial values for the first run.
void setup() {
  // Sets up Serial communication with the computer.
  // Not used in this sketch, but useful when printing
  // to the computer screen when debugging.
  Serial.begin(9600);
  
  // Sets the Arduino's pins to OUTPUT for controlling
  // the motor. A pin can be used to INPUT or OUTPUT.
  for (int i = 0; i < 2; i++) {
    pinMode(motor_left[i], OUTPUT);
    pinMode(motor_right[i], OUTPUT);
  }
}

// The loop runs as long as the Arduino is on.
void loop() {
  // Stops each motor
  motor_stop();
  // Delays in milliseconds, so 5000 = 5 seconds.
  // Added a delay here because I wanted a few seconds
  // for the robot to pause before each run.
  delay(5000);
  
  // Drive forward for 10 seconds. drive_forward()
  // sets the motion of the motion of the motors, the
  // delay sets the duration of the movement.
  drive_forward();
  delay(10000);
  motor_stop();

  // Drives backwards for 10 seconds
  drive_backward();
  delay(10000);
  motor_stop();

  // Turns Left
  turn_left();
  delay(5000);
  motor_stop();

  // Turns right
  turn_right();
  delay(5000);
  motor_stop();
}


// Sets each motor lead to 0V, causing the motor to
// coast to a stop.
void motor_stop() {
  analogWrite(motor_left[0], 0);
  analogWrite(motor_left[1], 0);

  analogWrite(motor_right[0], 0);
  analogWrite(motor_right[1], 0);
}

// Sets the motors to both go forward at a little
// over half speed. 150 is the Pulse Width Modulation
// setting, 255 is max, 0 is minimum.
void drive_forward() {
  analogWrite(motor_left[0], 150);
  analogWrite(motor_left[1], 0);

  analogWrite(motor_right[0], 150);
  analogWrite(motor_right[1], 0);
 
  // The digitalWrite equivalent
  //digitalWrite(motor_left[0], HIGH);
  //digitalWrite(motor_left[1], LOW);
  //digitalWrite(motor_right[0], HIGH);
  //digitalWrite(motor_right[1], LOW);  
}

// Sets the motors to drive backwards.
void drive_backward() {
  analogWrite(motor_left[0], 0);
  analogWrite(motor_left[1], 150);
  
  analogWrite(motor_right[0], 0);
  analogWrite(motor_right[1], 150);
}

// Turns left by turning one motor clockwise and the
// other counterclockwise.
void turn_left() {
  analogWrite(motor_left[0], 0);
  analogWrite(motor_left[1], 150);
  
  analogWrite(motor_right[0], 150);
  analogWrite(motor_right[1], 0);
}

// Turns Right by turning one motor counterclockwise
// and the other clockwise.
void turn_right() {
  analogWrite(motor_left[0], 150);
  analogWrite(motor_left[1], 0);
  
  analogWrite(motor_right[0], 0);
  analogWrite(motor_right[1], 150);
}

Downloads

The source for the Arduino to Motor Driver image requires the open source program Fritzing to view. The Arduino source code is available as well.

As this entire website is stored in source control — including posts, images, and files — you can check out GitHub for updates and history on any these files.

Robot Books for Beginners

2010-08-09T00:00:00-05:00

Robot Building For Beginners

My strategy for finding books is go to Amazon, search for a topic, then browse based on reviews and what others bought. This strategy lead me to the appropriately titled Robot Building for Beginners. If you’re new to robotics or electronics in general, buy this book. Right now.

David Cook walks through a variety of topics, from understanding tools like a multimeter to motors, wheels, and couplers. The book centers around building a basic line following robot, with each chapter covering a new feature of the robot. There is no mention of an Arduino — or any microcontroller for that matter — it’s all transistors, resistors, and comparators.

Cook’s writing eases you into what can be intimidating topics, holding your hand along the way. You’re left with a broad understanding of the mechanical and electrical components involved in a robot. Still, this is a beginner book and really serves to wet your appetite for more.

Intermediate version: Intermediate Robot Building

Electronics for Dummies

When I first started learning robotics, I went to Fry’s for a few capacitors and diodes to build a circuit I saw on Instructables. While scouring, I saw Electronics for Dummies. “Ha, I am far too smart for this book,” I said aloud, and then — when nobody was looking — I grabbed the book and ran to the checkout counter.

I’m glad I did.

If you’re new to electronics, Electronics for Dummies gives a good overview of why a component behaves a certain way. The book answers several questions like: How does a capacitor work? What happens when resistors are in parallel? What are the different types of semiconductors? And so forth.

As Electronics for Dummies covers the fundamentals well, I recommend it for anyone wanting a foundation for working with electronics. If you know how to calculate an RC time constant, a “for Dummies” book can probably be skipped. Also be warned, the book does not go into detail about using this electronics knowledge in creating your own circuits.

Intermediate version: Electronics Self-Teaching Guide.

Practical Arduino: Cool Projects for Open Source Hardware

I discovered Practical Arduino: Cool Projects for Open Source Hardware when searching Amazon for, surprise surprise, “Arduino.” The top result is Getting Started with Arduino, by one of the founders of the project. I had picked up Getting Started with Arduino from the Maker Faire a couple years back and found it a good absolute beginners book, but left me wanting more.

Practical Arduino features 14 Arduino projects — not a single one is a robot. While at first off put by this revelation, I came to appreciate the book more for focusing on everything else an Arduino can do.

Projects include an RFID security system, a weather station, and even a device to monitor your car’s on-board computer. Reading the book provides a strong insight into the Arduino and microcontrollers in general with topics like Interrupt Service Routine and Pulse Width Modulation. Practical Arduino is similar to Robot Building for Beginners in the way electronic components are explained (both are also Apress books). For example, when a setup requires an extra capacitor, the authors take the time to explain their motivations for doing so.

Visualizing H-bridges

2010-06-20T00:00:00-05:00

Introduction

While writing an upcoming post for the Idea to Prototype series covering “Brains”, it became clear a significant portion of the topic is the motor driver — a circuit to control the movement of the robot’s motors. The critical component of the motor driver is the H-bridge, enough so, I felt it deserves its own post.

There are solid resources available on H-bridges already. The goal here is to cover the H-bridge from a high-level, to help visualize its purpose.

A motor has two leads. Each lead has three possible states: connected to positive voltage, connected to ground, or open. The value of each lead not only controls the movement of the shaft clockwise or counterclockwise, but also allows for braking or coasting.

Left Lead	Right Lead	Result
Open	Open	Coast
Positive	Positive	Brake
Positive	Ground	Counterclockwise
Ground	Ground	Brake
Ground	Positive	Clockwise

H-Bridge lead connections and their affect on the motor.

The H-bridge circuit can connect each lead to ground or positive (and sometimes open). So what? A microcontroller can too.

The big deal is that an H-bridge can connect a motor’s leads to a higher voltage unregulated power, like 9, 12, and 24 volts. A microcontroller or logic chip may supply up to 5V, but many motors require 6V or more. A motor may also use 150 mA, 300 mA, on up — a current microcontrollers cannot provide. When working with an H-bridge, a lower powered signal — like the pins of a microcontroller — configures how the H-bridge supplies the motor with the awesome power connected to it.

Circuit Scenarios

An H-bridge, in its most high level view, is four switches: two for each motor lead. One switch on each side connects to positive, the other switch on each side connects to ground.

Coasting

When all the switches are open, there is an open circuit and the motor is free to coast. Coasting is also called “slow decay” as the motor’s energy is consumed slowly due to friction.

Counterclockwise

When the left switch connected to positive is closed and the right switch to ground is closed, a closed circuit occurs and the motor spins counterclockwise.

Clockwise

As expected, the motor spins clockwise when the switches are reversed.

Brake low

With both sides’ switches connected to ground, motor energy is quickly drained. Ground to ground and positive to positive creates what is called an “electronic brake” or “fast decay”. An electronic brake dissipates the energy from a motor quickly to help slow it down. It does not serve as a physical brake to the motor. Ground to ground is called “braking low” and positive to positive is called “braking high.”

Short circuit

The more observant readers may have noticed a possible predicament. What if the switch connected to positive and the switch connected ground are both closed on the same side? Exactly what you would expect to happen. The electricity travels the path of least resistance, and a motor is certainly more resistant than a wire, so a short circuit is formed. Many H-bridge implementations prevent the ability to close both positive and ground on the same side, and thus prevent the short circuits.

Chips

Two popular H-bridge chips (technically quad half H-Bridge chips) are the SN754410 and its predecessor, the L293D. The two chips are identical in pin layout, but the SN754410 is capable of 1A continuous output current at higher voltages. Plenty of resources are online for using the chips as part of a robot’s motor driver, including my next post.

From Idea to Prototype: Chassis

2010-06-05T00:00:00-05:00

CAD

While designing the drive train, I also started drafting the chassis in a CAD program. Using a 3D CAD tool helped determine the fit of each drive train component within the set boundaries of the chassis. I highly recommend taking the time to draw your robot in a CAD program before ordering parts. Pairing the v-belt for a pulley of the right diameter with the bore size to fit the bearings and shaft requires a precision computers are simply better at.

I used Google Sketchup for the CAD program. SketchUp is a free, entry level CAD program that runs on both Windows and Mac OS X. Of course I would like to use Solidworks or AutoDesk Inventor, but the cost is too high for a hobbyist. Plus, SketchUp meets all my needs at this stage.

CAD drawing of the chassis with two motorized wheels and two caster wheels.

Build

After I was happy with the design and ordered the parts for the drive train, I set out to create a physical chassis. For some, the steps may be obvious, but coming from a computer science background, I have found the transition from idea on paper to tangible object non-trivial.

The overall layout was simple enough to make out of wood, but I wanted a more precise chassis. I needed the holes bored in the correct place and each component to line up. And really, a fabricated chassis would just look cooler. I decided on the routes of 3D printing or CNC milling. 3D printing essentially prints plastic along three axes. The cost of a low-end 3D printer has dropped significantly thanks to projects like MakerBot and RepRap. Milling is a subtractive process, taking a block of plastic and cutting to form.

Most companies that do stereolithography (3D printing) or milling require an STL file. An STL file represents the surfaces of the 3D drawing. SketchUp does not export to the STL format natively, but CADspan has a free plugin to do just that. An excellent tutorial can be found here.

I contacted a few rapid prototype companies in Austin for quotes on printing the chassis. I had no idea how much to expect. The first quote back was for a “Stereolithography Apparatus Prototype” and cost $1,989. Whoa. Roughly $2,000 was far more than I expected to spend.

Another response from a Mr. Allison at ATi recommended a local milling company to try. As milling carves from a solid block of plastic, it would be sturdier and the chassis design is simple enough for the operation. Hopeful now, I contacted the milling company and got a quote for $1,155 ($480.00 set-up + $675.00 per part). The contact explained the cost of the 3” ABS plastic was $175.00 per sq.

Needless to say, I had to reevaluate my options. With no access to a 3D printer like the RepRap (though a new Austin HackerSpace may change that soon) and professional services proving too expensive, I decided to go the cheapest, simplest route: wood. It’s an initial prototype after all.

Basic wooden platform.

I know, the result is even simpler than the CAD drawings. Let’s call it a prototype of the prototype. I wanted to move on to the brains of the robot instead of focusing too long on the drive train for this iteration of the prototype.

For those curious, I attached the inline skate wheel to the motor hub by drilling the same plank of wood to both the wheel and the hub. It worked surprisingly well.

Motor hub to wheel coupling. The job looks a bit messier in high resolution.

From Idea to Prototype: Drive Train

2010-05-31T00:00:00-05:00

After sketching the robot and selecting a motor, my next step was planning out how to connect the motors to the wheels for propulsion. In other words, figuring out the robot’s drive train. The motor selection step and drive train design can be switched or worked in parallel.

Initial design — and failure

My original plans for the robot called for mounting a motor directly to each of the two back wheels and placing two caster wheels in the front. I crafted a rudimentary prototype by screwing a pneumatic model airplane wheel to a mounting hub, coupled to the motor shaft. I mounted the two motors to a frame of thin slabs of wood using Polulu’s motor bracket.

Around the time of building this prototype, the rather self-explanatorily titled book ”Building Robot Drive Trains” arrived at my doorstep. Early in the book, the flaws in coupling a wheel to a motor directly became obvious, too often invoking the “Duh, what was I thinking?” response. The biggest flaw in direct coupling is the robot’s requirement to carry a payload around 14 kg. The radial load — the perpendicular force on the motor’s shaft — would be too much if the shafts had to support the weight of the robot. A high radial load stresses the motor’s bearing and wears down its life expectancy.

Decoupling

I needed to decouple the motor from the wheel. Back to sketching.

My three options from a high-level view were: connect the motor and wheels via gears, using belt and pulley, or via an extended shaft. Hehe. I ruled out gears because I did not want to deal with the precision necessary in placing the gears and lining up the teeth. It was a toss-up between belt and pulley versus putting another shaft between the motor and wheel. I ended up drawing plans for both.

The belt and pulley design involved coupling the motor to a pulley and another pulley to a shaft, which spun the wheel, and then connecting the two pulleys using a belt.

CAD drawing of the belt and pulley drive train

The big choice on a belt and pulley setup is v-belt or timing belt. A v-belt is smooth and shaped like a stunted letter V. The tension turns the pulleys. A timing belt is notched and lines up with the timing pulley’s teeth. The timing belt has the benefits of transferring torque more efficiently and allowing less slippage. I consider the v-belt’s property of allowing slippage a feature. For example, if the robot is being stopped by an outside force while the motor is still going, the slippage lets the motor still spin rather than burn up from the resistance. I decided to try both a v-belt and timing belt setup and test empirically.

To extend the motor’s shaft, I connected a shaft between the wheel and motor’s shaft. I used pillow blocks to support the shaft and handle the radial load from the wheels. A pillow block is a mount, bored through with a ball bearing. The perpendicular stress on the shaft is distributed to each bearing. To connect the motor shaft to the extended shaft, I utilized shaft couplings.

Where to buy

My biggest complaint about building robots, a complaint that does not apply to the world of software, is where to find parts. I hope when the Personal Robot market matures, more standardization will take place with the hardware aspects. Perhaps when the term PR becomes as prevalent as PC.

McMaster.com. McMaster-Carr is an industrial parts supplier, complete with a wide selection of pulleys, belts, bearings, wheels, and thousands of other components. McMaster-Carr is to hardware what DigiKey and Mouser are to electronics. To boot, the website is impressively easy to navigate (please take some notes, DigiKey) and includes helpful explanations detailing what to look for in each component. The downside: a substantial markup for each part.

From Idea to Prototype: Motor Selection

2010-05-20T00:00:00-05:00

After sketching my idea for a robot, I was left with several unknowns: what to use for the brains, the muscle, the power, the frame. I opted to approach the “muscle” first.

After reading the exceptional Robot Building for Beginners and several robot building tutorials online, I was still left perplexed when selecting a DC motor. How much torque is needed and what’s an acceptable RPM were my two top questions. A helpful tutorial by Society of Robots, Robot Dynamics, helped me calculate the specifications I would need in a motor.

Motor calculations

Rather than repeat the knowledge expressed in Robot Dynamics, I present to you my actual calculations and decisions that influenced them.

The first specification to calculate was the RPM of the motor.

RPM = velocity / wheel circumference

My target speed for the robot was slightly faster than an adult’s average walking speed (approximately 80 m/min). I added an arbitrary 20 m/min to be “slightly” faster. I also assumed a wheel diameter of 0.076 m, roughly the size of an inline skate wheel.

The resulting RPM calculations were

RPM = (100 m/min) / (3.14 * 0.076 m) = 419 RPM

Next, I needed to calculate the torque requirements.

torque = force * distance

A Newton is a measurement of force, which I tackled first.

force = mass * acceleration

I expected the robot to weigh about 14 kg with payload. For acceleration, I summed two values: the acceleration on a flat surface and the acceleration on an incline. I took the tutorial’s advice for the flat acceleration.

acceleration for flat plane ≈ half velocity ≈ 0.080 m/sec^2

The incline formula calculates the acceleration needed to overcome gravity at an angle so the robot won’t fall backwards.

acceleration for incline = gravity * sin (theta * pi/180)

I assumed an angle of 20°.

9.81 m/sec^2 * sin (20 * pi / 180) = 0.335 m/sec^2

The final calculation was 0.80 m/sec^2 + 3.355 m/sec^2 giving a total acceleration of 4.155 m/sec^2. As can be seen, an incline drastically impacts the force required.

With the mass and acceleration, I calculated the force requirements.

force = 14 kg * 4.155 m/sec^2 = 30.17 newtons

The distance in the torque value derives from the distance between the wheels axis and where the force is applied. In other words, the distance is the wheel’s radius.

distance = wheel's radius = 0.038 m

I estimated the total torque and the torque per motor at

torque = 30.17 N * 0.038 m = 1.146 N m torque per motor = 1.145 N m / 2 = 0.573 N m

Motor selection

With the required RPM and torque (419 RPM and 0.573 N m, respectively), I had the criteria needed to select a motor.

I started with basic googling for robot motor, robot motor store, and so forth. A few good sites in terms of selection and details were Robot Market Place, Pololu, and Lynxmotion. These pages often use different units for measuring torque, like kg-cm or oz-in. An online torque conversion chart will help.

I ended up selecting the motor from Pololu. Pololu had the same motor with different gear ratios, allowing me to choose more torque or more speed. The closest matching motor was the 29:1 geared DC motor. (Full disclosure: I actually bought two 67:1 geared motors because of an original miscalculation.)

An important motor selection criteria I did not use in my above calculations was voltage. Honestly, I didn’t care at this stage. If a 6 V motor met my requirements, perfect. Ideally, I wanted a motor between 6 and 12 V, but I would be willing to go up to 24 V. My power supply planning would come later.

Please contact me if you notice an inaccuracy in the calculations. I’ll update the post as needed.

Alexander Robotics

The AVR and the Arduino

Introduction

From A to Z with the AVR

The Arduino

The (optional!) Arduino IDE

Getting started with the TurtleBot

Wait, what’s a TurtleBot?

The TurtleBot arrived, now what?

Assembling

Network Configuration

Run an “app”

Where to go from here?

What if I have a question?

Open Hardware Summit 2010

New Arduino boards

Updated Open Source Hardware Draft Definition

To the future

Voltage Regulators

Read the specifications

From Idea to Prototype: Brains

Hardware

Software

Downloads

Robot Books for Beginners

Robot Building For Beginners

Electronics for Dummies

Practical Arduino: Cool Projects for Open Source Hardware

Visualizing H-bridges

Introduction

Circuit Scenarios

Chips

Further Reading

From Idea to Prototype: Chassis

CAD

Build

From Idea to Prototype: Drive Train

Initial design — and failure

Decoupling

Where to buy

From Idea to Prototype: Motor Selection

Motor calculations

Motor selection