Efficient

Easy to Use

If there are areas you don’t want the robot to clean, each manufacturer has the equivalent of boundary markers; some use infrared light while others use special strips (magnetic or other). Some of the more intelligent robots are able to clean multiple rooms, stopping to recharge when needed and continuing where they left off. Don’t want the robot to move around when you’re at home? Not a problem. You can schedule the robot to clean at specific hours and (in certain cases) on specific days.

Compact

Most current robotic vacuums look like a flat, disk-shaped device. It’s flat so it can go under furniture and disk-shaped so it can turn easily, especially in corners. This design currently seems to be optimal, allowing it to reach all those places a normal vacuum can’t. There’s no need to move sofas, stools, and low-set tables. The vacuum’ disk-shape also allows it to go around furniture’s legs and wall corners effectively, cleaning as it goes. Most also feature a bumper to detect and absorb collision with a solid object.

Intelligent

• dirt (not only detect it but to clean that area until no more dirt is detected)
• drops (like stairs for example)
• path (it knows where it’s been)
• charging base (it can sense where its base is and get there)
• obstacles (either by lightly hitting them or detecting them at a distance)
• battery usage
• and more…

Affordable

Upgradeable and Repairable

We’ve all seen those garage sales where a lonely old vacuum lies off to one side being passed up by everyone. Unlike your standard upright vacuum, these can be upgraded with new software to make their cleaning patterns more efficient. Brushes and parts are modular and easily replaced. Want a brush that’s better suited for pet hair? Not a problem! Want a battery that lasts longer? They have those too! Want your robots to communicate with each other? That’s on the way…

If you buy a technological device from a non-technological company, servicing and repairs will be significantly harder than if you purchased from a specialized robotic company like RobotShop. You should also take a look at the warranty offered as this can differ significantly from company to company; a big incentive to buy from specialists is that even after a manufacturer’s warranty has run out, you may still be covered for many more years by the distributor you purchased from.

As with all technological devices, there may be a new type of robotic vacuum which comes out in a few years which includes a “must have” feature. However, since the release of the first mass market robotic vacuum, the shape and technology have not changed much. The most recent advancement has been a scanning laser which maps the room and is proprietary technology on the Neato. iRobot has released a physically smaller vacuum than previous models, but the basic technology is the same. It’s really up to you to choose the features you want most (self-charging base; room mapping; dirt detection; remote control etc.). These robots may be intelligent and advanced, but are robust enough to last a long time and perform reliably so long as you take care to empty the dust bins and periodically check the machine.

These are just some of the reasons that may urge you to get your own robotic vacuum cleaner. Just imagine the time you’ll save vacuuming your house’s entire floor area. You can do something else with all that time you should have spent cleaning. And in this fast changing world, time saved is definitely worth the price.

Arduino Mini / Mini Lite

• Microcontroller ATmega328
• Operating Voltage 5V
• Input Voltage 7-9 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 8 (of which 4 are broken out onto pins)
• DC Current per I/O Pin 40 mA
• Flash Memory 32 KB (2 KB used by bootloader)
• SRAM 2 KB
• EEPROM 1KB
• Clock Speed 16 MHz

Arduino Pro Mini 3.3V / Pro Mini 5V

• Microcontroller ATmega328
• Operating Voltage 3.3V or 5V (depending on model)
• Input Voltage 3.35 -12 V (3.3V model) or 5 – 12 V (5V model)
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 6
• DC Current per I/O Pin 40 mA
• Flash Memory 16 KB (of which 2 KB used by bootloader)
• SRAM 2 KB
• EEPROM 1 KB
• Clock Speed 8 MHz (3.3V model), 16 MHz (5V model)

Arduino Nano / Nano Lite

• Microcontroller Atmel ATmega328
• Operating Voltage (logic level) 5 V
• Input Voltage (recommended) 7-12 V
• Input Voltage (limits) 6-20 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 8
• DC Current per I/O Pin 40 mA
• Flash Memory 32 KB (2KB used by bootloader)
• SRAM 2 KB
• EEPROM 1 KB

Arduino Fio

• Microcontroller ATmega328P
• Operating Voltage 3.3 V
• Input Voltage 3.35-12 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 8 (10 bit resolution)
• DC Current per I/O Pin 40 mA
• Flash Memory 32 KB (of which 2 KB used by bootloader)
• SRAM 3.3 KB
• EEPROM 1024 bytes
• Clock Speed 8 MHz

Arduino LilyPad / Simple LilyPad

• Microcontroller ATmega168V or 328V
• Operating Voltage 2.7-5.5 V
• Input Voltage 2.7-5.5 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 6
• DC Current per I/O Pin 40 mA
• Flash Memory 16 KB (of which 2 KB used by bootloader)
• SRAM 1 KB
• EEPROM 512 bytes
• Clock Speed 8 MHz

Arduino Leonardo

• Microcontroller ATmega32U4 (onboard USB Transceiver)
• Operating Voltage 5 V
• Input Voltage 2.7-5.5 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 12 (10 bit resolution)
• DC Current per I/O Pin 40 mA
• Flash Memory 32 KB (of which 2 KB used by bootloader)
• SRAM 3.3 KB
• EEPROM 1024 bytes
• Clock Speed 16 MHz

Arduino Pro 3.3V / Pro 5V

• Microcontroller ATmega168
• Operating Voltage 3.3V
• Input Voltage 3.35 -12 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 6
• DC Current per I/O Pin 40 mA
• Flash Memory 16 KB (of which 2 KB used by bootloader)
• SRAM 1 KB
• EEPROM 512 bytes
• Clock Speed 8 MHz

Arduino Diecimilla / Duemilanove / Uno

• Microcontroller ATmega168 or 328
• Operating Voltage 5V
• Input Voltage (recommended) 7-12V
• Input Voltage (limits) 6-20V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 6
• DC Current per I/O Pin 40 mA
• DC Current for 3.3V Pin 50 mA
• Flash Memory 16 KB (ATmega168) or 32 KB (ATmega328)
• of which 2 KB used by bootloader

Arduino Ethernet / Ethernet PoE

• Microcontroller ATmega328
• Operating Voltage 5 V
• Input Voltage 7-12 V (36 to 57V PoE)
• Digital I/O Pins 10* (of which 6 provide PWM output)
• Analog Input Pins 6 (10 bit resolution)
• DC Current per I/O Pin 40 mA
• Flash Memory 32 KB (of which 2 KB used by bootloader)
• SRAM 3.3 KB
• EEPROM 1024 bytes
• Clock Speed 16 MHz

Arduino Bluetooth

• Microcontroller ATmega328
• Operating Voltage 5V
• Input Voltage 1.2-5.5 V
• Digital I/O Pins 14 (of which 6 provide PWM output)
• Analog Input Pins 8 (4 are broken out onto pins)
• DC Current per I/O Pin 40 mA
• Flash Memory 16 KB (of which 2 KB used by bootloader)
• SRAM 2 KB
• EEPROM 51 KB
• Clock Speed 16 MHz

Arduino Mega 1280 / 2560

• Microcontroller ATmega1280 or 2560
• Operating Voltage 5V
• Input Voltage (recommended) 7-12V
• Input Voltage (limits) 6-20V
• Digital I/O Pins 54 (of which 14 provide PWM output)
• Analog Input Pins 16
• DC Current per I/O Pin 40 mA
• DC Current for 3.3V Pin 50 mA
• Flash Memory 128 KB or 256KB
• SRAM 8 KB
• EEPROM 4 KB
• Clock Speed 16 MHz

Arduino Mega ADK

• Microcontroller ATmega1280 or 2560
• Operating Voltage 5V
• Input Voltage (recommended) 7-12V
• Input Voltage (limits) 6-20V
• Digital I/O Pins 54 (of which 14 provide PWM output)
• Analog Input Pins 16
• DC Current per I/O Pin 40 mA
• DC Current for 3.3V Pin 50 mA
• Flash Memory 128 KB or 256KB
• SRAM 8 KB
• EEPROM 4 KB
• Clock Speed 16 MHz

This article is a follow-up to the RobotShop Grand Tutorial Series and includes all the hardware chosen in the “Practical Example” at the bottom of each lesson. The RobotShop Rover for Arduino is a small tracked platform designed around the popular Arduino USB microcontroller.

The first product that one might look for after having received the package is the frame. The RobotShop Rover for Arduino aluminum frame (RB-Rbo-11) is powder coated a deep blue and comes with a variety of different mounting hardware used to complete the kit. Aside from standard washers, nuts, and rivets, the hardware also includes a 9V battery clip and leads. On its own, the RobotShop Rover for Arduino frame doesn’t do much, so in order to make a functional tracked mobile robot, you would additional parts.

There are two Solarbotics GM9 gear motors included with the kit capable of up to 66rpm and a maximum of 3kg-cm of torque. These are not the fastest of motors but do allow the robot to carry additional payload. The Standard GM Track Kit  includes all the links and pins you need to make two tracks, as well as two drive sprockets and two idler sprockets. To hold the idler sprockets in place, the kit comes with two Shoulder Bolts with matching washer and nut. Next a standard AA battery holder  holds four AA batteries which power the drive motors and servos.

All the parts listed so far are included with the RobotShop Rover for Arduino Tank Kit (RB-Rbo-13). The RobotShop Rover Tank Kit is ideal if you already have your own Arduino microcontroller or want to use your own parts to complete the robot. In order to make a fully functional robot however, you need additional electronics, starting with a microcontroller.

The Arduino USB Microcontroller is essentially the brain of the RobotShop Rover and includes an ATMega328 processor already installed. To connect the board to your computer, the RobotShop Rover Complete Kit comes with a 6 foot USB cable.

The Arduino board can’t produce a high current, which is why a 5 Amp Low Voltage Dual Serial Motor Controller (RB-Pol-16) is included to power both drive motors. You may notice the pin headers are not soldered onto the board – this allows you to mount it horizontally or vertically, or even solder wires directly to the controller.

At this point you have all the essential parts you need to make a mobile robot, but you may find connections are not easy. To help you easily connect electronics and wires, the kit includes three mini solderless breadboards, a pre-formed jumper wire kit and 25 feet of 22 gauge hook-up wire. The extra wire is used mainly to connect the motors. There are also two mini power switches included whose pins are spaced perfectly for breadboards.

One very attractive aspect to the RobotShop Rover for Arduino is that there is a slot at the front for a standard sized servo. The RobotShop Rover Complete Kit therefore includes a Lynxmotion pan and tilt system with two Hitec HS-422 servo motors. If you have only received the Tank Kit, you are free to add a Hitec HS-422 servo to create a pan system. To complete the kit, the popular Sharp GP2D120 infrared range sensor and associated Sharp IR cable are included to give the robot feedback about its environment.

What are the highlights?

What is so great about this lawn mower?

How to operate the Spyder LB1200?

What are the Spyder’s benefits and drawbacks?

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 7 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)
5. Analog accelerometer, gyroscope and/or IMU
6. Connectors (between the IMU and the Arduino

• Serial data (Tx pin)
• I2C (SDA, SCL)
• Analog
• TTL
• others…

Accelerometer

Accelerometers measure acceleration in one to three linear axes (x, y, z). A single axis accelerometer can measure acceleration in whichever direction it is pointed. This may be good for a rocket, an impact, a train or other scenario where the device really moves in one basic direction. Knowing the acceleration and time, you can use mathematics to find the distance traveled by the object. There are fewer and fewer single and double axis accelerometers on the market because a triple axis accelerometer can do so much more. Thanks to low manufacturing costs the three axes accelerometers are not much more expensive than single or double.

Acceleration due to gravity is a constant and is in fact measurable using an accelerometer. When placed parallel to the ground, acceleration due to gravity would only be “felt” by one axis. However, when tilted, this acceleration would appear as components of two (or three) axes. You can get an idea of how to use an accelerometer to measure tilt here and here.

Connect the accelerometer to the Arduino; each output pin goes to one of the analog pins on the Arduino, the Vin pin goes to the 5V pin on the Arduino (read the user guide to ensure the Vin pin is 5V as opposed to 3.3V), and connect the GND pin to the GND pin on the Arduino. Note that there is no need for additional electronics! Next, open the sample sketch File -> Examples -> Sensors -> ADXL3xx. Upload to the Arduino and see the values change.

In order to choose the right accelerometer, consider the maximum linear acceleration the sensor will be subjected to. If you are planning to add an accelerometer to a small mobile robot, you will likely use a 2g accelerometer (even that is likely overkill), whereas if you are attaching it to a rocket, a 16g accelerometer is likely a better choice. When connected to a 10 bit ADC, the 2g accelerometer will have an accuracy of 2 / 1024 = 0.002g, and the 16g accelerometer will have and accuracy of 16 / 1024 = 0.0156. Therefore if you only need a range of 2g, but purchase a 16g accelerometer, you will only have about 128 possible readings, instead of the full 1024. Conversely, if you choose a 2g accelerometer when you really needed a 16g, you will get a lot of “maximum (1024) “readings since the acceleration is “off the scale”.

Gyroscope

Gyroscopes measure angular velocity in α, β, γ (see image below). Gyroscopes can be used to help with stabilization and well as changes in direction and orientation. Unlike accelerometers, gyroscopes do not have a fixed reference, and only measure changes. To choose the right gyroscope for your needs, consider the maximum angular rate of change (degrees per second) your product will be subjected to. A remote control will likely rotate at less than 1 rotation per minute (360 degrees per second), while a rocket tumbling out of the sky may be rotating at 1500 degrees per second. When connected to the same microcontroller (10 bit for example), the 360 degree/s gyro will have an accuracy of 360 / 1024 = 0.35 deg/s, whereas the 1500 deg/s gyro will have an accuracy of 1500 / 1024 = 1.46 deg/s. Therefore if you chose a 1500 deg/s gyro when you only needed a 360 deg/s gyro, you will only get about 245 readings as opposed to 1024.

Courtesy: Wikipedia

IMU

An IMU (Inertial Measurement Unit) usually consists of an accelerometer and gyroscope and is used to measures an object’s orientation, velocity etc. Often additional sensors (magnetic, temperature) are included to improve accuracy. The number of “degrees of freedom” indicates the number of different axes measured by the chip. For example, combining a three axis accelerometer with a two axis gyroscope would be consider a 3+2 = 5 DoF IMU.

Additional Considerations

When using accelerometers, gyroscopes or inertial measurement units (IMUs) to obtain positions in space, it is important to note that there are several additional factors that will affect the readings, the main obstacle being the sampling rate. Microcontrollers require a certain amount of time to read values being provided to them by the sensor, and because of this, the values between these readings are lost. There are several mathematical methods (a Kalman filter being a popular choice) that attempt to compensate for this. A second source of error is that readings are often affected by fluctuations in temperature. Most datasheets associated with micro-electro-mechanical systems (MEMS) attempt to describe how temperature affects the output.

Want to learn more? Start with the material put out for free by Analog Devices, makes or many MEMS acceleromters, gyroscopes and other sensors.

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 6 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)
5. Standard servo motor (current consumption <50mA)
6. Pin headers / cables
7. Bend /stretch sensor and/ or Force sensor

The output of this “mini circuit” is a signal between 0 to 5V (this is referred to as an analog signal), which is connected to an analog pin of the microcontroller. The microcontroller’s on-board analog to digital converter (ADC) interprets this voltage and assigns it a number which you can use in your code. For 10 bit ADC (2¹⁰), you will get a number between 0 and 1024 representing 0V to 5V. You would need an equation in your code to use this number to send the appropriate signal to a motor controller. As you might have suspected, the code is now identical to that used to get an analog input.

To get sample code, open the Arduino software and go to File -> Examples -> Analog -> AnalogInOutSerial

The video above shows a bend sensor connected to an Arduino, and the Arduino is connected to a small servo motor. The analog value associated with the flex sensor is read by the Arduino, and that value is converted to a rough position. You would merge the Analog example code with the servo code, and add a single line to convert the 0 to 1024 value to 0 to 180 degrees. It is easy to see how, with many of these sensors, you can create a data glove which controls a robotic hand.

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 5 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)
5. Standard servo motor (current consumption <50mA)
6. Pin headers / cables

Controlling a servo motor directly from the Arduino is quite easy. However, a servo motor may require significantly more current than the Arduino can provide. The following example uses a standard sized servo (without any load) powered directly from the Arduino via USB. When powering the servo directly from the Arduino board:

1. Connect the black wire from the servo to the GND pin on the Arduino
2. Connect the red wire from the servo to the +5V pin on the Arduino
3. Connect the yellow or white wire from the servo to a digital pin on the Arduino

Alternatively, you can plug the servo’s wire into three adjacent pins, and set the pin connected to the red lead to “HIGH” and the pin connected to the black lead to “LOW”. If you want to use a more powerful servo, or if you want to connect it to a separate power supply, you would connect the battery / power supply’s red (5V) and black (GND) wires to the servo’s red and black wires, and connect the signal wire to the Arduino. Note that you also need to connect the batter’s GND line to the Arduino’s GND pins (“common ground”).

pinMode(pin number, OUTPUT);

This sets a pin number as dedicated input or output. In this case, we called the pin “servopin” and assigned it a value of 4. The term “pulse” is in black as it is not a reserved word and can be changed by the user. It is best to use descriptive variables when coding to understand what each does, or the information it will contain. Servos operate by sending a timed +5V pulse (usually between 500us and 2500us) to the onboard electronics, which is repeated every ~20ms. This pulse corresponds to a servo position, usually from 0 to 180 degrees.

• 5V for 500 microseconds = 0.5 milliseconds and corresponds to 0 degrees
• 5V for 1500 microseconds = 1.5 milliseconds and corresponds to 90 degrees
• 5V for 2500 microseconds = 2.5 milliseconds and corresponds to 180 degrees
• The relationship is linear, so use mathematics to determine the pulse which corresponds to a given angle. Note that if you send a signal that is greater or lower than the servo can accept (for example, Firgelli linear actuators accept 1 to 2 ms), you might damage the actuator.

Another option for controlling servos is to use the Arduino “servo library” (previously separate from the basic Arduino software, it is now included with V1.0). The servo library manages much of the overhead and includes new, custom commands. If you want to control multiple servo motors, you should use a servo motor controller and a separate power supply between 4.8V to 6V.

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 4 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)
5. IR Distance sensor (preferably Sharp) and corresponding cable
6. Push button and corresponding cables to connect to Arduino

1. Connect the red wire to +5V on the Arduino
2. Connect the black wire to Gnd on the Arduino
3. Connect the yellow wire to an analog pin on the Arduino (in this case we chose A2)

Arduino 5 Minute Tutorials

Since the sensor is connected to the analog input of the Arduino, the code is identical to that of the potentiometer:

Upload this program to the board and change to the Serial Monitor. As you move the front of the distance sensor closer to and away from a solid object or wall, the values should change between 0 to 1023. You can now read values and use them within your code. Check the range for your sensor (not all sensors can read from zero cm); note that some sensors have a minimum distance – although it is always listed in the specifications, try to find it by experimentation. To convert the values to actual distances (in cm or inches), consult the user guide of the sensor.

Arduino and Push Buttons

digitalRead(pin);

digitalWrite(ledPin, status);

turns the ledPin (in this case assigned to digital pin 13) HIGH (1) or LOW (0) depending on the status variable. We initially set the status to be low (0).

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)
5. Potentiometer (rotary or linear) Example: DFRobot Rotation Sensor
6. Optional secondary LED.

Open the sample sketch “AnalogInput” under File -> Examples -> Analog. The comments section has been reduced below to make the code clearly visible.

We see several new lines of code here:

int sensorPin = A0;

The “int” is short for “integer”. The name “sensorPin” was chosen only to describe what the variable represents; “sensor pin”. The fact that the ‘P’ is capitalized makes it easier to see that it is actually two words, since spaces cannot be used. The integer “sensor pin” is equal to A0, where “A0″ is Analog pin 0 on the Arduino. On its own, “A0″ is not a reserved term. However, when used in context, the system recognizes it as analog pin 0. The line must be ended with a semicolon. By declaring a variable in the setup, you can use the term, which in this case is “sensorPin”, throughout the code instead of “A0″. There are two main benefits to this:

1) It makes the code more descriptive

2) If you want to change the value of the variable, you only need to do it in one place.

sensorValue = analogRead(sensorPin);

This line uses the term “analogRead” in order to read the voltage of an analog pin. Most Arduino microcontrollers use 10 bit analog (voltage) to digital (numeric) conversion, which is 2¹⁰ possible numbers = 1024. Therefore a voltage of 0V corresponds to a numeric value of 0. A voltage of 5V corresponds to a numeric value of 1024. Therefore a value of 3V would correspond to a numeric value of:

3/5 =x/1024, x = 3*1024/5 = ~614

Alternatively you could have written: sensorValue = analogRead(A0);

int ledPin = 13;

Once again, the term “ledPin” is not a reserved word in Arduino, it was chosen to describe which pin was connected to the LED. The value “13″ is a normal value, but just like “A0″, when used in context represents pin 13.

int sensorValue = 0;

The term “sensorValue” is not a reserved term either.

Connect the potentiometer to pins A0, 5V and GND. The middle (wiper) lead is the one to connect to the analog pin and the voltage varies on this pin. The orientation of the other two pins does not matter. The other option is to connect the potentiometer to pins A0, A1 and A2. However, you will need to add the following code under void setup():

digitalWrite (A1, LOW);

digitalWrite (A2, HIGH);

This sets the corresponding pins to 0V (GND) and 5V (PWR). Once the potentiometer is connected, upload this sketch to the board and change to the Serial monitor. As you rotate the knob (or slide the slider), the values should change between 0 to 1023. Correspondingly, the LED will blink with a faster or shorter delay.

You can now read values and use them within your code. The new function used here is “analogRead();” where the pin selected is pin #2. If you used analog pin #5, you would change the code to read:

int sensorpin = 5;

If the system does not work, check the syntax and ensure the code uploads correctly. Next, check the connections to the potentiometer ensuring that the middle lead goes to the correct pin, and the other pins are powered at 0V and 5V. If you bought a very cheap or old potentiometer, there is a chance it may be mechanically defective. You can test this using a multimeter and connect the ends to the middle pin and an outer pin. Set the multimeter to read resistance and rotate the knob; if the resistance changes slowly, the pot is working. If the resistance is erratic, you need a new potentiometer.

Now what if you want to see the value yourself? Take a look at the code above and write it in the Arduino interface as a new sketch. Some new code you will see is:

Serial.println(sensorValue);

This sends the value contained in the variable “sensorValue” serially via the USB plug and digital pin 1. Verify, then upload this sketch to your Arduino. Once it is done, press on the “magnifying glass” located towards the top right of the window. This is the “Serial monitor” and monitors communications being sent and received by the Arduino. Here you must verify that the Baud rate is also 9600, or else you will see garbage.

If you did not want the values to appear on a new line every time, you could write

Serial.print(sensorValue);

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 2 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)

The Arduino language is CASE SENSITIVE: a capital letter is not the same as a lower case letter. The following code represents the minimum in order for a program to compile:

The “void setup()” section is widely used to initialize variables, pin modes, set the serial baud rate and related. The software only goes though the section once.

The “void loop()” section is the part of the code that loops back onto itself and is the main part of the code. In the Arduino examples, this is called “Bare Minimum” under File-> Examples -> Basics. Note that you are free to add subroutines using the same syntax:

void subroutinename() {}

Almost every line of code needs to end with a semicolon ‘;’ (there are a few exceptions which we will see later). To write single line comments in the code, type two back slashes followed by the text:

//comments are overlooked when compiling your program

To write multi-line comments, start the comment with /* and end with */

/* This is a multi-line comment and saves you having to always use double slashes at the beginning of every line. Comments are used used to explain the code textually. Good code always has a lot of comments.*/

Serial Communication

void setup() {

Serial.begin(9600);

}

9600 is a good baud rate to start with. Other standard baud rates available on most Arduino modules include: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200 and you are free to specify other baud rates. To output a value in the Arduino window, consider the following program:

Verify the program by pressing the “verify” button (looks like a “play” button in order version or a check sign in Arduino 1.0); you should not get any errors at the bottom of the screen. If you get errors, check that only the two numbers in the code are black, the rest of the text should have been automatically recognized and assigned a color. If part of the text is black, check the syntax (often copy/pasting text from another program can include unwanted formatting) and capitalization.

Next, upload the sketch to the board using the “Upload to I/O Board” button (arrow pointing right). Wait until the sketch has finished uploading. You will not see anything unless you then select the “Serial Monitor” button (rectangle with a circle that looks like a TV in the old software, or what looks like a magnifying glass in the new software). When you select the serial monitor, make sure the baud rate selected is the same as in your program. If you want to save all your programs, we suggest creating a new folder called “reference” and save this program as Hello World.

Blink LED Program

Connect the board to the computer if it is not already connected. In the Arduino software go to File ->  Examples -> Basics -> Blink LED. The code will automatically load in the window, ready to be transferred to the Arduino. Ensure you have the right board chosen in Tools -> Board, and have the right COM port as well under Tools -> Serial Port. If you are not sure which COM port is connected to the Arduino, (on a Windows machine) go to Device Manager under COM & Ports.

Press the “Upload” button and wait until the program says “Done Uploading”. You should see the LED next to pin 13 start to blink. Note that there is already a green LED connected to most boards – you don’t necessarily need a separate LED.

Understanding Blink LED Code

From Lesson 2 you will recognize the basic code void setup(){} and void loop(){}. You will also recognize the green commented sections. The three new lines of code you have not seen before are:

pinMode(13, OUTPUT);

This sets pin 13 as an output pin. The opposite, being INPUT, would have the pin wait to read a 5V signal. Note that the ‘M’ is capitalized. A lower case ‘m’ would cause the word “pinmode” to not be recognized.

digitalWrite(13, HIGH); and digitalWrite(13, LOW);

The line digitalWrite(pin, HIGH); puts a specified pin high to +5V. In this case we chose pin 13 since on the Uno, the LED is connected to pin 13. Replacing HIGH with LOW, the pin is set to 0V. You can attach your own LED using a digital output and the GND pin. Note that the ‘W’ is capitalized.

delay(1000);

The delay(1000); line causes the program to wait for 1000 milliseconds before proceeding (where 1000 is just a convenient example to get a 1 second delay). Note that during a delay, the microcontroller simply waits and does not execute any additional lines of code.

Special Note

Pin 13 incorporates a resistor with the LED, whereas none of the other digital pins have this feature. If you want to connect one or more LEDs to the other digital pins, you need to add a resistor in series with the LED.

Lessons Menu:

• Lesson 1 – Software Downloading / Installing & Interface
• Lesson 2 – Basic Code
• Lesson 3 – Sensors: Potentiometers
• Lesson 4 – Sensor: Infrared Distance
• Lesson 5 – Actuator: Servo Motor
• Lesson 6 – Sensor: Force, Bend, Stretch
• Lesson 7 – Sensor: Accelerometer, Gyro, IMU
• Lesson 8 – Actuator: DC Motor
• Lesson 9 – more to come…

Lesson 1 Hardware:

1. Computer / Laptop or Netbook
2. Arduino Microcontroller
3. USB to Serial Adapter (if your microcontroller does not have a USB port)
4. Appropriate USB cable (Arduino boards draw power from the USB port – no batteries yet)

The popularity of Arduino is steadily increasing and it is fast becoming the microcontroller of choice for students, hobbyists and smaller companies. Many different electronics PCB manufacturing companies are jumping on the bandwagon and producing their own variations of the boards, as well as “shields” (additional circuits that fit directly on top of many Arduino boards to increase their functionality) and accessories. The Arduino website offers free resources and tutorials as well as a language reference to help you understand the code and syntax. In order to get started, you will at the very minimum need an Arduino board. Note that all the Arduino (and most of the clone boards) can use the Arduino software. If you are unsure what hardware to get, the Arduino USB is currently the most popular model, and these 5 minute tutorials are based around it.

Downloading / Installing Arduino Software

1. Go to www.arduino.cc to download the latest version of the Arduino software (Direct link: http://arduino.cc/en/Main/Software and select your operating system; in this case we are using Windows)
2. Save the ZIP file to your desktop (you can move or delete it later)
3. It is convenient to create a new folder called “Arduino” under “Program Files”. To do this, go to “My computer” -> “C:” (or the drive where the operating system is installed) -> “Program Files”, then left click once on “program Files” folder, then select “New”->”Folder” from the main Explorer menu.
4. Extract the entire ZIP folder to this new “Arduino” folder
5. To run the Arduino software, open Windows Explorer by pressing the windows key (usually between the Ctrl and Alt keys on your keyboard) and the ‘E’ character at the same time (there are other ways to access explorer as well).
6. Go to “My computer” -> “C:” (or the drive where the operating system is installed) -> “Program Files” -> “Arduino” In this folder you will see an executable file (blue colored icon named “Arduino”), you can left click (once) and then right click and select “send to” -> Desktop (create shortcut) to have Arduino more easily accessible.
7. Double click the icon on the desktop to start the software.

The Arduino Software Interface

The Arduino interface is pretty “bare-bones”. When you load the software, the first screen you will see is a white window (shown below) with several different shades of blue and blue-green as border.  Arduino projects are called “sketches” and when you start a new sketch, several additional files are also created.

The main headings are “File” “Edit” “Sketch” “Tools” “Help” and several shortcut icons beneath “Verify”, “Upload”, “New”, “Open”, “Save”, and at the far right, the “Serial Monitor”. Note that all these icons are also available from the main menus.

“Older” Arduino Interface

The main headings are “File” “Edit” “Sketch” “Tools” “Help” and several shortcut icons beneath “Verify”, “Stop”, “New”, “Open”, “Save”, “Upload” and “Serial Monitor”. Note that all these icons are also available from the main menus.

1. Launch the Arduino software by double-clicking the Arduino icon
2. Plug one end of the USB into the Arduino and the other end into your computer.
3. Your computer should detect the new device and tell you if it has installed correctly. At this time, two things can happen; if you have an older board using an FTDI chip (ex. Duemilanove based), Windows should detect it and you’re good to go to the next step. If you have a board which uses an ATMega chip to convert USB to serial (for example the UNO), you will need to install the drivers manually.
4. Take a look at your board’s main processor chip (usually found between the pin headers) to see which you have. It will likely be the ATMega168, ATMega328, or a more powerful ATMEga640. ATMega1280 etc
5. In the software, select “Tools” -> “Board” -> You will get a list of possible boards. If you have a different board, select it from the drop-down list; if you have purchased a compatible board, that manufacturer should indicate which board to choose.
6.  In the software, select “Tools” -> “Serial Port” -> COM # (note that if you have several COM ports, you will need to go to Device Manager to see which COM port is assigned to your board.

This section is intended to provide you with an overview of the history of robotics. As you may have guessed, the history of robotics is intertwined with the history of technology, science and the basic principle of progress. Technology used in computing, electricity, even pneumatics and hydraulics can all be considered a part of the history of robotics. Robotics currently represents one of mankind’s greatest accomplishments and is the single greatest attempt of mankind to produce an artificial, sentient being.

Timeline

Articles

• Then and Now: Humanoid Robots by Tom Carroll, Servo Magazine November, 2007
• Then and Now: Robot Arms by Tom Carroll, Servo Magazine August, 2007
• Then and Now: Robotic Vacuum Cleaners by Tom Caroll, Servo Magazine November, 2007
• Then and Now: Robot Power by Tom Carroll, Servo Magazine October, 2007
• Then and Now: Robot Sensors by Tom Carroll, Servo Magazine July, 2007
• Then and Now: Servos by Tom Caroll, Servo Magazine December, 2007
• Then and Now: Robotic Competitions and Contests by Tom Carroll, Servo Magazine, November 2008

Knowledge & Learning

Competitions & Contests

Autonomous life form

Domestic or Professional tasks

Security and Surveillance

RobotShop’s Forum

Official Manufacturer/Supplier Forums

• 3D Connexion
• 4D Systems
• Adafruit
• Arduino
• Basic Micro
• Botmag
• Chumby
• Cytron
• DFRobot
• Element Direct
• Elenco – Snap circuits
• iRobot
• JCM Inventures
• Leaflabs
• LEGO Mindstorms
• Lynxmotion
• Netmedia
• New Micros
• Phidgets
• Pololu
• RadioTronix Support Forum
• Robobrothers
• RobotShop
• RoboteQ
• Robotics Connection
• Robotis Bioloid
• Servo Magazine
• Solutions Cubed
• Sparkfun
• Vex Robotics

Robotic kits allow people of all ages to learn how to assemble and use one or more particular robots. In so doing, people will be able to understand the technology, principles and the equipment behind the design and creation of robots. If you are new to robotics or not quite ready to make the leap to fully custom robots, there is a kit out there that will be correct for your skill level and also allow you to build and possibly code a robot that would have otherwise have been impossible to do on your own.

Almost all robotic kits (aside from kits which teach specific principles) include some form of motion. The majority of these use two or more wheels to propel the robot, while others may use tracks, legs or even blades and wings! Many beginner kits aimed at <12 years old can be easy to construct with only a few snap-together parts, while more complex robots have hundreds of parts and encourage you to create your own semi-custom design. Not to worry, all robot kits include instructions on how to build and use the robot. Note that some kits require soldering; if you are not sure what “soldering” is, take a look at this video.

To know more about robot kits, and which is right for you, here is a list of some of the available kits that you can try out:

Beginner Robot Kits

As the name implies, these robot kits are made for those who are new to robotics and prefer to start simply, with step-by-step instructions. These kits are specially designed to educate and orient those people who would like to explore robotics, but not looking to spend a lot of money or take too long to build a functional bot. Most of these beginner kits are aimed at 12 years old and up, though some can be built by children as young as 8 and 9, while others are versatile enough to entertain adults.

For example, for $39.99, the OWI Arm Edge is one of the most popular kits in this category; it is by far the least expensive robotic arm on the market and although it can’t pick up a full can of cola, it can certainly pick up and move most small objects. Use the arm to move and stack blocks, draw a shape or design and much more! If you really want to get involved, there is an optional computer interface, allowing you to control the arm from the computer.

Intermediate Robot Kits

These robot kits are made for the robot hobbyist who has some knowledge in robotics and/or a related field and is prepared to take more time in building and troubleshooting a kit, but perhaps does not want to start from scratch or attempt higher level programming. These intermediate kits are more involved than beginner robot kits because they require one or more of the following:

- Advanced assembly: Many of these kits require some soldering and working with intricate parts. Some of these kits are designed especially to help improve soldering skills.

- Programming: Almost all of these kits require some programming, and many are oriented towards the hobbyist who is looking to learn how to program, but not necessarily very high level (first time using sensors, motors, creating an autonomous robot etc).

- Capability: unlike the robots in the beginner category, these robots are usually not restricted to just one task or motion. A large number of these kits can be upgraded with additional sensors and parts.

At <$100, the DFRobotShop Rover is intended to be a mobile platform for those who have heard about “Arduino” but are not necessarily sure where to start. The kit includes everything you need to get started in mobile robotics. The PCB includes a standard Arduino Uno as well as a dual motor controller and voltage regulator. Arduino is one of the best ways to get started in “serious” robotics because of its ability to perform complex calculations and communicate with and control other devices.

Advanced Robot Kits

Advanced robot kits employ more complicated designs and structures and require more knowledge of robotics. The most advanced robot kits are currently “humanoid” robots, meaning they almost resemble the human body. Although controlling each joint may be straightforward, the difficulty arises from having to control many at the same time and in such a way to achieve balance and motion.

Other forms of advanced motion include Mecanum and Omni wheels, legged and multi-legged robots (some with as many as 21 degrees of freedom), and platforms with advanced sensors. All of these robots require a higher level of programming and although some code may be provided, it is understood that the customer intends to create their own custom code.

The Kondo KHR series humanoid robots closely resemble a miniature robot human and uses 17 servos to move its legs, arms and head. There is some sample code available, but with a robot like this, almost anything is possible: program it to do some dance moves, climb stairs, do martial arts and much more!

Robot Construction Kits

Robot construction kits are more than just toys: they use interchangeable parts and can be programmed a variety of ways. The sensors and electronics used in many of these kits are complex and need to be programmed in order to be used to their full potential. Many of the kits can even be used to create humanoid robots. Robot construction kits offer the big advantage of saving you the time needed to construct intricate mechanical parts.

The VEX line of construction kits use metal brackets and durable plastic parts and allow you to let your mind go free to come up with whatever robotic design it wants; create a robot arm, a 6WD robot with suspension, a motorcycle and much much more!

Robot Development Platforms

Robot Development Platforms are ideal for the experienced robot builder who is looking for a pre-made platform on which he or she can electronics, a battery pack, sensors and more. Most robotic platforms come with the motors required for each degree of freedom, though most kits leave it to the customer to decide which electronics to select. Many platforms have a downloadable computer interface, though often times the user chooses whichever programming language they are most comfortable with.

Electronic Experimentation Kits

.

Universities

• Boston University Robotics Lab
• Carnegie Mellon Robotics Institute
• ETS Research
• Indiana University CS Research
• Manchester University Research
• McGill University Center for Intelligent Machines
• MIT Robotics Projects
• Penn Engineering CS Research
• Stanford University Artificial Intelligence Lab
• UC Berkely Robotics Lab
• University of Alberta Research
• University of Delaware Research
• University of Laval Robotics Lab
• University of Michigan Research
• University of South Carolina Robotics Research Lab
• University of Western Australia

Goverment and Non-Government Organizations

• Nasa – JPL Robotics
• Nasa ROV Research
• Darpa Research Grants
• NREC: National Robotics Engineering Center
• Lab Automation Association
• Space and Naval Warfare Systems, San Diego
• iRobot: Starter Programs for the Advancement of Knowledge “SPARK”
• La Société Des Arts Technologiques [SAT]

Private pages

• Open Softwear – Arduino

CANADA

Art & Robotics Group

AQRA

ARISE:

Ottawa Robotics Enthusiasts

RoboMontreal

Torobotics

Vancouver Robotics Club

Vancouver Island Robots

Western Canada Robotics Society (Alberta)

USA

Atlanta Hobby Robot Club

Boise Robotics Group

Buffalo Hobby Robot Club

California Polytechnic Robotics Club

Carnegie Mellon Robotics Club

Central Illinois Robotics Club

Central Jersey Robotics Group

Connecticut Robotics Society

Twin Cities Robotics Group

Chibots

CRASH:

Dallas Personal Robotics Group

Denver Area Robotics Club

East Texas Robot Builders

Front Range Robotics (FRR)

Homebrew Robotics Club

LVBOTS:

North Seattle Robotics Group

PAREX:

Portland Area Robotics Society

Robomo: St. Louis Area Robotics Group

Robotics Society of Southern California

San Francisco Robotics Society fo America

Seattle Robotics Society

SHARC (Smoky Hill Area Robotics Club)

SHARP:

South Jersey Robotics Group

The Robot Group

Triangle Amateur Robotics

WORLDWIDE

SI2E:

Robonz:

Robotics Tasmania

Robotics Group of Bogazici University

Robbot

• Microcontroller: ATmega328
• Operating Voltage: 5V
• Input Voltage: 7-9 V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 8 (of which 4 are broken out onto pins)
• DC Current per I/O Pin: 40 mA
• Flash Memory: 16 KB (2 KB used by bootloader)
• SRAM: 2 KB
• EEPROM: 1 bytes
• Clock Speed: 16 MHz

• Microcontroller: ATmega328
• Operating Voltage: 3.3V or 5V (depending on model)
• Input Voltage: 3.35 -12 V (3.3V model) or 5 – 12 V (5V model)
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• Flash Memory: 16 KB (of which 2 KB used by bootloader)
• SRAM: 2 KB
• EEPROM: 1 bytes
• Clock Speed: 8 MHz (3.3V model), 16 MHz (5V model)

• Microcontroller: Atmel ATmega328
• Operating Voltage (logic level): 5 V
• Input Voltage (recommended): 7-12 V
• Input Voltage (limits): 6-20 V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 8
• DC Current per I/O Pin: 40 mA
• Flash Memory: 32 KB (2KB used by bootloader)
• SRAM: 2 KB
• EEPROM: 1 KB

• Microcontroller: ATmega168V or 328V
• Operating Voltage: 2.7-5.5 V
• Input Voltage: 2.7-5.5 V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• Flash Memory: 16 KB (of which 2 KB used by bootloader)
• SRAM: 1 KB
• EEPROM: 512 bytes
• Clock Speed: 8 MHz

• Microcontroller: ATmega328
• Operating Voltage: 3.3V
• Input Voltage: 3.35 -12 V (3.3V version) or 5-12V (5V version)
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• Flash Memory:32 KB (of which 2 KB used by bootloader)
• SRAM: 2 KB
• EEPROM: 1 bytes
• Clock Speed: 8 MHz or 16MHz (5V version)

• Microcontroller: ATMega168 or ATMega328
• Operating Voltage: 5V
• Input Voltage (recommended): 7-12V
• Input Voltage (limits): 6-20V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• DC Current for 3.3V Pin: 50 mA
• Flash Memory: 16 KB (ATmega168) or 32 KB (ATmega328) of which 2 KB used by bootloader

• Microcontroller: ATmega328
• Operating Voltage: 5V
• Input Voltage (recommended): 7-12V
• Input Voltage (limits): 6-20V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 6
• DC Current per I/O Pin: 40 mA
• DC Current for 3.3V Pin: 50 mA
• Flash Memory: 32 KB (ATmega328) of which 0.5 KB used by bootloader

• Microcontroller: ATmega168
• Operating Voltage: 5V
• Input Voltage: 1.2-5.5 V
• Digital I/O Pins: 14 (of which 6 provide PWM output)
• Analog Input Pins: 8 (4 are broken out onto pins)
• DC Current per I/O Pin: 40 mA
• Flash Memory: 16 KB (of which 2 KB used by bootloader)
• SRAM: 1 KB
• EEPROM: 512 bytes
• Clock Speed: 16 MHz

• Microcontroller: ATmega2560
• Operating Voltage: 5V
• Input Voltage (recommended): 7-12V
• Input Voltage (limits): 6-20V
• Digital I/O Pins: 54 (of which 14 provide PWM output)
• Analog Input Pins: 16
• DC Current per I/O Pin: 40 mA
• DC Current for 3.3V Pin: 50 mA
• Flash Memory: 256 KB of which 8 KB used by bootloader
• SRAM: 8 KB
• EEPROM: 4 KB
• Clock Speed: 16 MHz

• Microcontroller: ATmega2560
• Operating Voltage: 5V
• Input Voltage (recommended): 9V
• Input Voltage (limits): 7-18V
• Digital I/O Pins: 54 (of which 14 provide PWM output)
• Analog Input Pins: 16
• DC Current per I/O Pin: 40 mA
• DC Current for 3.3V Pin: 50 mA
• Flash Memory: 256 KB of which 8 KB used by bootloader
• SRAM: 8 KB
• EEPROM: 4 KB
• Clock Speed: 16 MHz
• USB Host: intended for use with Android smart phones

LEARNING CENTER:

FORUM:

SUPPORT CENTER:

Manufacturer Help

Research

Robotic Books:

Robot Magazines:

Community

Clubs:

Kinetic Energy

Momentum

Velocity vs. speed

What to do?