My Cart

Robot Kit: Build and program your own Arduino-controllable Tracked Robot

Difficulty Level: Expert -


The Robot Kit is an Arduino-controllable tracked robot platform that is less than 10 cm × 10 cm—small enough to qualify for Mini Sumo. It includes two micro metal gearmotors coupled to a pair of silicone tracks, a stainless steel bulldozer-style blade, an array of six infrared reflectance sensors for line following or edge detection, a buzzer for simple sounds and music, a 3-axis accelerometer, magnetometer, and gyro for detecting impacts and tracking orientation. Just sold and assemble it, add 4 AA batteries and an Arduino (or compatible controller) and you are ready to push!


    - 1 x Robot Kit:
    • 1x Chassis kit
    • 1x Robot shield
    • 2x Motors
    • 1x Reflectance sensor array
    • 1x Ultra sonic range module

Preparation Time: 120 minutes

Buy now
NOTE: Depending on the platform chosen to develop the project, the ingredients and the schematics shown in this tutorial can vary.

Step 1: The Shield

1.1 Features and components

The main features of the robot are labeled in this diagram:


The robot has an internal compartment for four AA batteries. We recommend using rechargeable AA NiMH cells, which results in a nominal voltage of 4.8 V (1.2 V per cell). You can also use alkaline cells, which would nominally give you 6V.

A direct connection to the battery terminals is provided by the battery charger connector on the rear edge of the shield, which can be used to recharge the batteries without removing them from the chassis. The positive pin of the charge connector, on the left, is indicated by a plus sign (+). A charger connected by clipping its alligator clips to a pair of jumper wires inserted into the charge connector, works well for charging the Zumo.

After passing through reverse protection, the battery voltage is connected to the rest of the shield by the power switch. The switched battery voltage is designated VBAT and provides power to the motors through the DRV8835 motor driver. An on-board boost regulator, also supplied from VBAT, generates 7.45 V to power the Arduino through its Vin pin. In turn, the Arduino’s regulated 5V and 3.3V voltages supply power to the motor driver logic, buzzer circuit, and compass module on the shield.

WARNING: When powering the Arduino from the shield, you must never connect a different power supply to the Arduino’s VIN pin or plug a power supply into the Arduino’s power jack, as doing so will create a short between the shield’s power supply and the Arduino’s power supply that could permanently damage both the Arduino and the shield.
NOTE: When the Arduino is connected to a computer via USB, it will receive power (and supply 5V and 3.3V to the shield) even when the shield’s power switch is off. This can be useful if you want to test your Arduino program without allowing the motors to run, since turning the power switch off disconnects motor power (VBAT).


There are five LEDs on the shield:

  • A set of power LEDs, one blue and one red, is located in each of the two rear corners of the shield.
  • A yellow user LED is located on the right edge of the shield. It is connected to digital pin 13 on the Arduino, in parallel with the Arduino’s onboard user LED.


Two pushbuttons can be soldered to the shield:

  • The reset pushbutton is located on the left edge of the shield. It is connected to the Arduino’s RESET pin and can be pressed to reset the Arduino.
  • The user pushbutton is located on the rear edge of the shield. It is connected to digital pin 12 on the Arduino; pressing the button pulls the pin low. The Pushbutton library, included with the libraries makes it easy to detect and debounce button presses with this pushbutton.

Motor driver

An integrated DRV8835 dual motor driver on the shield drives the two micro metal gearmotors. Four Arduino pins are used to control the driver:

  • Digital pin 7 controls the right motor direction (LOW drives the motor forward, HIGH drives it in reverse).
  • Digital pin 8 controls the left motor direction.
  • Digital pin 9 controls the right motor speed with PWM (pulse width modulation).
  • Digital pin 10 controls the left motor speed with PWM.

The ZumoMotors library provides functions that allow you to easily control the motors, and it can optionally take care of flipping a direction signal for you if you accidentally soldered in a motor backwards.


The shield comes with a buzzer that can be used to generate simple sounds and music (for example, you could use it to produce an audible countdown at the beginning of a sumo match). The buzzer control line is labeled BZ on the shield; if you alternate between driving it high and low at a given frequency, the buzzer will produce sound at that frequency.

The ZumoBuzzer library uses hardware PWM to play notes on the buzzer, with digital pin 3 on an Arduino Uno or an older Arduino, or with digital pin 6 on an Arduino Leonardo. A jumper is provided to connect the BZ input to the appropriate Arduino output

Front expansion area

A number of I/O, power, and ground connections are brought to the front of the shield to allow the mounting of additional sensors and other components.

Inertial sensors

The shield includes on-board inertial sensors, which can be used to sense acceleration and orientation for advanced applications:

  • The shield features an LSM303D 3-axis accelerometer and magnetometer and an L3GD20H 3-axis gyroscope.

1.2 Front expansion

The pins in the front expansion area of the shield are shown in the following diagram:

The front expansion makes available digital pins 2, 4, 5, and 11 and analog pins A0 through A5. It also provides access to the two I2C pins (SDA and SCL). However, please note that the I2C pins are not independent pins; they are respectively duplicates of analog pins A4 and A5 on the Uno R3 and digital pins 2 and 3 on the Leonardo. Typically, you will only be able to use these pins for either I2C communication or general I/O, not both. Additionally, pin A1 is used to monitor the battery voltage if you install the battery monitor jumper.

Please note that only components and connectors in the front three rows of pins can extend below the shield; the fourth row covers the chassis and is only suitable for components mounted above the shield.

If you use an Arduino Uno R2 or an older Arduino, which lack separate I2C pins, the SDA and SCL pins on the shield will not be connected to anything. To use an I2C device on those pins, you can connect SDA to A4 and SCL to A5 yourself by bridging across those two sets of pins in the front expansion area.

NOTE: Depending on the Arduino model, digital pin 3 or 6 is used to control the buzzer if you install the buzzer control jumper. If you are using an Uno, pin 6 will be available for general-purpose I/O. If you are using a Leonardo, pin 3 will be available if you are not using I2C. These pins are not accessible via the front expansion, but they can be accessed from other points on the shield and used for interfacing with additional electronics if free. Additionally, digital pin 12 can be used for interfacing with many types of additional electronics, especially if you are not using the shield’s user pushbutton. Pin 12 is completely free when the pushbutton is in its default, unpressed state, and it is pulled low through a 1k resistor when the pushbutton is pressed.

1.3 Jumper settings

The shield has several jumpers that let you change the way it is connected to the Arduino, as shown in the picture below.

  • The battery level jumper connects the Arduino’s analog pin 1 to a voltage divider circuit that allows you to monitor the battery voltage. This jumper is disconnected by default and can be connected by soldering a short length of wire between the two holes.

The divider outputs a voltage equal to two-thirds of the battery voltage, which will always be safely below the Arduino’s maximum analog input voltage of 5 V. For example, at a battery voltage of 4.8 V, analog pin 1 will be at a level of 3.2 V. Using Arduino’s analogRead() function, where 5 V is read as a value of 1023, 3.2 V is read as a value of 655. To convert it back to the actual battery voltage, multiply this number by 5000 mV×3/2 and divide by 1023:

unsigned int batteryVoltage = analogRead(1) * 5000L * 3/2 / 1023;
  • The buzzer control jumper connects one of the Arduino’s PWM outputs to the buzzer on the shield. This jumper is disconnected by default on both the assembled and kit versions of the robot; it must be connected to enable the buzzer.

If you have an Arduino Uno or an older Arduino (with an ATmega328P or ATmega168 microcontroller), you should jumper the two holes bracketed with the label 328P to connect the BZ pin to digital pin 3. If you have an Arduino Leonardo, you should jumper the two holes bracketed with the label 32U4 to connect the BZ pin to digital pin 6. These are the pins our ZumoBuzzer library expects the buzzer to be connected to for each respective microcontroller.

  • The compass/gyro I2C jumpers connect the I2C clock (SCL) and data (SDA) lines of the inertial sensors on the shield to the SCL and SDA pins on the Arduino. These jumpers are connected by default, but can be disconnected by cutting the thin trace between each pair of holes.

On the Arduino Uno R3, SCL and SDA are duplicates of analog pins 5 and 4, respectively. On the Arduino Leonardo, SCL and SDA are duplicates of digital pins 3 and 2, respectively. Using the I2C sensors on the shield will prevent these pins from being used for other purposes, and the I2C pull-up resistors will affect readings on these pins even if the compass is not being actively used, so you must cut the jumpers to disconnect the inertial sensors and pull-ups if you want to repurpose the SCL and SDA pins.

Please note that the SCL and SDA pins do not exist on Arduino hardware versions prior to the Uno R3, so you will have to manually connect SCL to analog pin 5 and SDA to analog pin 4 on the shield in order to use the compass with an older Arduino. The most convenient place to do this is in the front expansion area, where these pins are all located together, as indicated by the light blue boxes in the picture above.

NOTE: Instead of making a wire connection, you can solder a 1×3 male header to the buzzer jumper holes to allow the use of a shorting block for connecting the buzzer. You can also use male headers and shorting blocks for the battery level jumper and compass jumpers if you have an Arduino Uno with an SMD (surface mount) microcontroller or an Arduino Leonardo. However, there is not enough clearance to use male headers on the battery level and compass I2C jumpers if you are using an Arduino with a DIP (through-hole) microcontroller.

1.4 Inertial sensors (accelerometer, magnetometer, and gyro


The shield includes on-board inertial sensors that can be used in advanced applications, such as helping your robot detect collisions and determine its own orientation.

The shield has a compass module that combines a 3-axis accelerometer and 3-axis magnetometer into a single package with an I2C interface. This chip is an LSM303D.

This shield also adds an L3GD20H 3-axis gyroscope on the same I2C bus.

We recommend carefully reading the LSM303D and L3GD20H datasheet to understand how these sensors work and how to use them.

Using the sensors

Level shifters built into the shield allow the inertial sensors, which operate at 3.3 V, to be connected to the 5 V logic level pins of the Arduino. The sensors, level shifters, and I2C pull-up resistors are connected to the SCL and SDA pins on the shield by default, but they can be disconnected by cutting traces to allow those pins to be used for other purposes. It is necessary to make some additional connections on the shield if you want to use the compass with an older Arduino without separate SCL and SDA pins

There isa basic LSM303 Arduino library and L3G Arduino library that makes it easier to interface the sensors with an Arduino, as well as an example project that demonstrates how to use the magnetometer to help the robot coordinate its turns.

Notes on the magnetometer

Please note that the magnetometer in the LSM303 is affected by currents in the motors and buzzer when they are operating, as well as metal in the batteries, and the readings are easily influenced by magnetic distortions in the environment around the robot (such as rebar in a concrete floor). As a result, it is very hard to accurately determine the robot’s absolute heading based on the magnetometer data. However, in our tests, we found that the magnetometer was still useful for detecting relative orientation changes; for example, once the magnetic readings are compensated for a particular environment, they can be used to help the Zumo turn left or right by a specific angle instead of just timing how long to run the motors to make such a turn.

NOTE: In our tests, we found that the batteries, motors, and motor current affect the z axis of the magnetometer much more strongly than the x and y axes, so you probably will want to ignore the z readings. We were generally able to get decent results using only the x and y magnetometer readings to determine heading. Additionally, you might need to decrease the magnetometer sensitivity; if the magnetometer returns a value of -4096, that is a sign that the sensitivity range is set too narrow for your particular environment.

1.5 Arduino pin assignment table

Digital pins Shield function Notes/alternate functions
0 digital I/O RX for programming and serial communication on Uno and older Arduinos
1 digital I/O TX for programming and serial communication on Uno and older Arduinos
2 digital I/O (front expansion) I2C SDA on Leonardo
3 digital I/O optional jumper to buzzer control line for Uno and older Arduinos I2C SCL on Leonardo
4 digital I/O (front expansion)
5 digital I/O (front expansion)
6 digital I/O optional jumper to buzzer control line for Leonardo
7 right motor direction control line
8 left motor direction control line
9 right motor PWM control line
10 left motor PWM control line
11 digital I/O (front expansion)
12 digital I/O user pushbutton (pressing pulls low)
13 digital I/O yellow user LED (high turns LED on)
Analog pins Shield function Notes/alternate functions
A0 analog input and digital I/O (front expansion)
A1 analog input and digital I/O (front expansion) optional jumper to battery level voltage divider
A2 analog input and digital I/O (front expansion)
A3 analog input and digital I/O (front expansion)
A4 analog input and digital I/O (front expansion) I2C SDA on Uno and older Arduinos
A5 analog input and digital I/O (front expansion) I2C SCL on Uno and older Arduinos

Step 2: Preparing the shield

2.1 Tools

Some basic tools are needed. If you don't already have them on hand, then yo will need to purchase them. They will be used time and time again for your soldering projects, so if you have the available funds, choose tools that are well made.

Soldering Iron

You will need a basic soldering iron, a base to hold it, and a wet sponge. If possible, a soldering station, as seen in the picture above, is preferable because it includes an iron, a stand, a sponge, and a power unit.

The power unit is nice because you can maintain a constant temperature. At the very least, a soldering iron with a pencil shape and a fine point tip is recommended. Please do not use a soldering gun. These can damage sensitive electronics because they generate an electromagnetic spike.


Solder is to DIY electronics as glue is to paper. It is an alloy used to join two metal surfaces together.

Flush cutter

A flush cutter is a nippe/pincer for cutting off excess electronic components leads.

Small Phillips screwdriver

For jobs where most screwdrivers are too big.

3 mm Allen wrench (hex key)

A tool of hexagonal cross-section used to drive bolts and screws that have a hexagonal socket in the head.

long-nose pliers

Cutting and holding pliers used to bend, re-position and cut

2.2 Components

  • Robot Shield:
    • Right-angle slide switch
    • Two pushbuttons
    • Buzzer
    • 2-Pin battery-charging header
    • Three jumper wires (for soldering motors to the chassis)
    • Two 25-pin 0.1′′ straight breakaway male headers
    • Four blue shorting blocks
    • Two 5/16′′ #2-56 machine screws
    • 1/16′′ black acrylic spacer plate (two pieces)
  • Chassis kit:
    • Zumo chassis main body
    • 1/16′′ black acrylic mounting plate (not used with the Zumo Shield)
    • Two drive sprockets
    • Two idler sprockets
    • Two 22-tooth silicone tracks
    • Two shoulder bolts with washers and M3 nuts
    • Four 1/4′′ #2-56 screws and nuts
    • Battery terminals
    • Basic sumo blade
  • Two 75:1 HP micro metal gearmotors
  • Reflectance sensor array
  • 2.3 Assembly

    Please follow these instructions carefully to assemble your Robot Kit properly.

    Through-hole parts

    Solder the included through-hole components to the shield:

    • Power switch
    • Reset pushbutton
    • Buzzer
    • Charging connector (1x2-pin female header)

    On the bottom of the board, trim any leads longer than 1/16” (the thickness of the spacer plate) so they do not prevent the shield from sitting flat on the spacer plate and chassis.

    Arduino headers

    Separate the 1×40-pin breakaway male header into the appropriate segments for connecting your Arduino and solder them to the shield. These header segments should be soldered to the sets of holes outlined with white rectangles on the top of the shield, with the pins facing up.

    The newest Arduino boards, including the Uno R3 and the Leonardo, use one 1×10 header, two 1×8 headers, and one 1×6 header; older Arduino boards use two 1×8 headers and two 1×6 headers (the two pairs of pins highlighted above in red should not be populated if you are using this board with an older Arduino that does not support these additional pins). Please make sure you solder the appropriate headers for your particular Arduino!

    An easy way to line up the Arduino headers for soldering is to plug them into an Arduino, then place the shield upside- down on top of them, as shown in the picture below. Be careful to insert the header pins into the correct set of holes before you begin soldering.

    NOTE: if you use this alignment technique, make sure your soldering iron temperature is not excessively hot and avoid holding the iron on a single pin for more than a few seconds as this could melt the Arduino’s female headers.

    On the bottom of the board, trim the four Arduino header pins closest to the front of the board on each side to prevent them from contacting the motor housings. If you think there is a chance these pins might still touch the motor cases, you can put some electrical tape on the motors to act as insulation.

    Jumpers and additional connections

    Optional: If you want to enable the buzzer, enable the battery level input, or disable the compass, now is a good time to add and/or cut jumper connections to configure the shield to your liking. This can also be done later, though soldering to these pins is more difficult once the robot is assembled (especially if you decide later you want to add header pins for use with shorting blocks; this would require a lot of disassembly). The jumpers are explained in detail in Section 3.c. The buzzer and battery level jumpers can be connected by soldering in a short piece of wire between the two holes, while the compass I2C connections can be broken by cutting the trace on the top of the board between the holes. Note: there is not enough clearance to use male headers on the battery level and compass I2C jumpers if you are using an Arduino with a DIP (through-hole) microcontroller.

    Instead of making a wire connection, you can solder a 1×3 male header to the buzzer jumper holes to allow the use of a shorting block for connecting the buzzer. You can also use male headers and shorting blocks for the battery level jumper and compass jumpers if you have an Arduino Uno with an SMD (surface mount) microcontroller, Arduino Leonardo. However, there is not enough clearance to use male headers on the battery level and compass I2C jumpers if you are using an Arduino with a DIP (through-hole) microcontroller.

    Optional: At this point, you might consider soldering additional components (such as sensors), or headers or wires for connecting them, to the shield. If you do this, please check to make sure your part placement does not interfere with the shield’s ability to mate with the Arduino or the chassis. In particular, note that only components in the outermost three rows of the front expansion area can extend below the board (the fourth front- expansion row can only be used for pins extending above the board), and if you add any through-hole parts to the prototyping areas on the shield, you will need to drill corresponding holes in the acrylic spacer plate for the leads to fit into.


    Cut two of the included jumper wires in half to form four segments, and trim off the ends that are covered in adhesive (the adhesive could interfere with making a good electrical connection to the motor). These wire segments will be used as motor leads.

    Solder a pair of leads to each motor. You might find it helpful to make a small bend at the tip of each lead to hook into the hole in the motor lead tab to hold it in place for soldering. Warning: holding the soldering iron against the motor lead for more than a few seconds can start to damage the motor brushes, so try to be reasonably quick/efficient with this soldering; if the first attempt does not go well, remove the soldering iron and let the motor cool for a few seconds before trying again.

    Each motor’s positive terminal is indicated by a plus sign (+) in the black plastic end of the motor, visible at the bottom of the picture above. The motors should be soldered into the shield with the positive terminal closest to the front, so you should attach the leads to allow the motors to be oriented this way. (However, don’t worry if you accidentally get the orientation of one or both motors wrong. You can later compensate for it via software with the motors library.

    Place the motors into the channel in the front of the chassis, aligning the gearbox with the grooves in the channel. The front plate of the gearbox should be even with the edge of the chassis.

    Chassis and shield

    To assemble the chassis with the Zumo Shield, you should use the two-piece acrylic spacer plate that is included with the shield. You will not need the one-piece mounting plate that is included with the Zumo chassis.

    Place an M3 nut in each of the two side slots near the rear of the chassis. The slots are sized so that nuts will not be able to rotate within them. (These nuts will be used to mount the idler sprockets later.)

    If you want, peel the protective paper masking off both sides of the acrylic spacer plate pieces (the spacer plates in our pictures show what they will look like with the masking peeled off).

    Alternatively, you can leave the masking on for additional thickness. If you leave the masking on, it will be mostly concealed when the robot is fully assembled.

    Cover the chassis and motors with the spacer plate pieces and then the Zumo shield. The holes in the spacer plate should line up with the through-holes in the shield resting on top of it, and the motor leads should be aligned so they pass through the slots in the spacer as shown in the picture below. There is only one correct orientation for these plates. (The plate consists of two separate pieces to make it possible to disassemble the Zumo without having to desolder the motors or battery terminals).

    In each of the four mounting holes, insert a #2-56 machine screw through the shield, spacer plate, and chassis, and tighten it against a nut under the chassis. It is usually easier to place the nut into the recess first and hold it there with a finger or piece of tape while inserting the screw. Note that the kit includes two different sizes of #2-56 machine screws: 1/4′′and 5/16′′. The two longer screws are intended for use in the front holes (near the motors) if you are also mounting a sumo blade; otherwise, you can use the shorter 1/4′′ screws for all four mounting holes.

    If you are also adding a basic sumo blade, you can either mount it now or add it later after you are done soldering the motors and battery contacts. (Note: If you intend to solder anything to the front expansion area of the shield, such as a reflectance sensor array, you will have more room to work if you do the soldering before adding the sumo blade.)

    NOTE: There is a small chance the mounting tabs of the blade can cause shorts where it contacts the shield if the PCB solder mask is not thick enough, so we recommend adding some electrical tape or other insulating material between the blade and shield.

    To install the blade, first bend its mounting tabs to the appropriate angle. Next, place them on top of the shield so that the holes line up with the two front mounting holes and insert the two longer (5/16′′) #2-56 machine screws (included with the shield) through the blade, shield, spacer plate, and chassis. Be careful when adjusting the angle of the sumo blade while it is mounted to the chassis, as this can crack the acrylic spacer plate if you apply sudden or excessive force. We recommend you do not try bending the blade while it is mounted to the chassis.

    Solder each motor lead to the shield, then trim off the excess length of wire.

    Battery contacts

    Turn the chassis over and install the battery terminal contacts as shown in the picture below. The three double-contact pieces should be firmly pressed into place until they are flush with the interior surface of the battery compartment. The two individual contacts should be inserted into the battery compartment so that their solder tabs protrude through the holes in the top of the chassis; you might want to temporarily tape these two individual contacts in place until they have been soldered to the shield as described in the next step, or you can use a battery to temporarily hold them in place.

    Solder the two individual contacts to the shield from the top. Note that if you are using a battery to hold the contact in place during soldering, the battery might act as a heat sink, making it more difficult to solder or requiring a higher soldering iron temperature. The battery terminal slot in the PCB should be completely filled with solder as shown in the picture below.

    Sprockets and trank

    Place an idler sprocket on each shoulder bolt, followed by a washer. The side of the sprocket with “teeth” should face the same direction as the threaded end of the bolt, so that the teeth end up pointing in towards the chassis.

    Insert the shoulder bolts through the side of the chassis into the nut. Use a 3 mm hex key (Allen wrench) to tighten the bolts until the washers are snug against the chassis. Be careful not to overtighten the shoulder bolts as doing so can bend the washers.

    NOTE: Be careful if you use threadlocking adhesives like Loctite as these can corrode the chassis. You should first test any such adhesives on a concealed part of the chassis to ensure they will not damage it.

    Press the output shafts of the motors into the drive sprockets, with the “teeth” of the sprockets facing the motor. The end of the gearbox shaft should end up flush with the outside of the sprocket. A good way to accomplish this is to set the wheel on a table top and press the motor shaft into the wheel until it contacts the table.

    At this point, you can add the silicone tracks by stretching them around the sprockets on each side of the chassis. Your Robot Shield and chassis are now complete; just add batteries and an Arduino to get your robot moving!


    If you later decide you want to solder additional parts to the robot Shield, it is possible to remove it from the chassis with some careful effort.

    • Remove the tracks from the chassis and carefully pull the drive sprockets off the motors.
    • Remove the battery cover and batteries from the chassis.
    • Unscrew all four sets of machine screws and nuts holding the shield to the chassis.
    • Squeeze the negative battery terminal spring and gently ease both battery terminals out through the holes in the chassis. The motors will stay attached to the shield as it separates from the chassis.
    • Carefully bend both motors away from the shield to allow the front piece of the spacer plate to be removed.

    You can reassemble the robot afterwards by following this procedure in reverse. (Make sure to replace the spacer plate pieces properly).

    2.4 Reflectance sensor array


    The reflectance sensor array is an easy way to add line-following and edge- detection capabilities to the robot. It is designed specifically to mount to the front expansion area of the shield, and it includes everything you need for installation. Note that the robot can be used without it.

    Assembling the sensor array

    The reflectance sensor array ships with all of the components you need to connect it to the robot shield:

    • Sensor array PCB with the surface-mount parts prepopulated.
    • 2x12 extended 0,1” male header (will be soldered to sensor PCB).
    • 2x12 0,1” female header (will be soldered to the robot shield)
    • 1x3 0,1” straight male header (optionally soldered to sensor PCB)
    • blue shorting block

    Before soldering in the main male header strip, we recommend soldering one of the two included 1×3 male headers into the set of three holes along the edge of the board. This step is optional but recommended because it allows dynamic control of the IR emitters (and red LEDs). By controlling when these LEDs are on, you can save power and make your programs easier to debug. If you skip this step, the IR emitters will just be on whenever the sensor array is plugged in and the robot is on. We recommend using the right-angle header mounted as shown in the picture below, but the straight 3-pin header will also work if you do not have anything already soldered to the robot shield’s front expansion area that would interfere. If you choose to install this header, please make sure you are doing it in a way that will not prevent installation of the sensor array (e.g. by installing it on the wrong side or by installing the right- angle pins in the wrong orientation)! If you are going to install this 3-pin header, it is generally easier to do so before soldering the larger 24-pin header.

    To enable dynamic control of the IR emitters, install the 3-pin header and use the included blue shorting block to connect the LEDON pin to the appropriate digital I/O pin. If you are using an Arduino Uno or older Arduino, you should use the shorting block to connect LEDON to digital pin 2 (the position that puts it flush with the edge of the board); if you are using an Arduino Leonardo, you should use the shorting block to connect LEDON to analog pin 4 (A4).

    The extended 2×12 male header strip should be mounted to the sensor array PCB on the opposite side from the components. Make sure you solder the shorter side of the pins to the PCB, not the longer side! Note that only 12 of the 24 pins are actually used by the sensor array; these pins have silkscreen circles around them on the component side of the board, and these are the only pins that need to be soldered, though it is fine to solder all 24 pins.

    Connecting to the shield

    The 2×12 female header included with the reflectance sensor array should be soldered to the front expansion area of the shield so that it is centered in the expansion area and flush with the chassis (rows 2 and 3). While it is fine to solder all 24 pins to the shield, only the 12 pins required by the reflectance sensor array need to be soldered (see the Array pinout section below for more information on which pins are required).

    Array pinout

    The reflectance sensor array gets all the necessary power and I/O connections from the 12 header pins that are circled on the silkscreen:

    The default I/O connections are to pins that are otherwise unused by the shield. The shield uses one digital I/O pin for each sensor (5, A2, A0, 11, A3, and 4), and if you add the LEDON shorting block, one additional pin (either A4 or 2) is used. To configure the Reflectance Sensor Array library to use this default pinout, simply call init with no arguments:


    If you opt to leave off the LEDON shorting block, you should use the QTR_NO_EMITTER_PIN initialization parameter: reflectanceSensors.init(QTR_NO_EMITTER_PIN) . Otherwise, the library code will still be trying to do something with the emitter pin (A4 or 2, depending on which Arduino you are using), and this would interfere with your being able to use that pin for alternate purposes.

    When soldering the male 2×12 header to the sensor array, you only need to solder those pins that you will be using. If you solder all 24 pins, the sensor array will be connected to additional pins from the Zumo shield’s front expansion area, though the array does not do anything with them in its default configuration:

    Disabling or remapping sensors

    Many applications do not require all six reflectance sensors, and you might want additional I/O lines for other things (e.g. obstacle detectors). In such cases, you can disable specific sensors and free up their associated I/O lines. The array PCB has six pairs of through holes, each of which corresponds to a different sensor. The order of the pairs matches the order of the sensors. When viewing the component side of the PCB, the right hole of each pair connects to an Arduino I/O line and the left hole connects to sensor. There is a single trace on the component side of the PCB between the two holes of each pair, and this trace can be cut to disable the sensor and free up the I/O line. The proper place to cut is marked on the silkscreen by carets.

    For example, if you want to use your robot for solving a line maze, you can likely get by with just four sensors: you can use the middle two sensors for tracking the line and the outer two sensors for detecting intersections. To free up the I/O lines associated with the other two sensors, you could make the following modification:

    Now you effectively have a four-sensor array and analog pins A2 and A3 are available for general-purpose use. To configure the ReflectanceSensorArray library to use this new configuration, call init with these arguments:

    byte pins[] = {4, 11, A0, 5}; 
    reflectanceSensors.init(pins, 4);

    Alternatively, you could make two ReflectanceSensorArray objects, one for the two exterior sensors and another for the two interior sensors, which might allow for cleaner code, but the drawback is that you can no longer read all four sensors in parallel with this approach.

    If you later decide you want to re-enable those sensors, you can connect across the cut trace with a wire, or you can use a wire to remap the sensor to a different pin. The following example shows how you could re-enable the A2 sensor and remap the A3 sensor to pin A5 instead:

    To configure the ReflectanceSensorArray library to use this remapped configuration, call arguments:

    byte pins[] = {4, A5, 11, A0, A2, 5}; 
    reflectanceSensors.init(pins, 6);

    Or, if you are not using an I/O line to control the IR emitters:

    byte pins[] = {4, A5, 11, A0, A2, 5};
    reflectanceSensors.init(pins, 6, 2000, QTR_NO_EMITTER_PIN); // 2000 = timeout after 2 ms

    Step 3: The libraries

    These libraries make it easy to get started writing Arduino sketches to control your robot. A link to dowload the library and installation instruction can be found oh the github page

    Once installed, we recommend you to try out the example sketches for each library, o get a better understanding of how to use the library functions.

    The libraries include the following:

    3.1 ZumoMotors

    The ZumoMotors library provides functions for PWM-based speed (and direction) control of the two motors on the Zumo with the onboard DRV8835 dual motor driver. On Arduinos with ATmega328P, ATmega168, and ATmega32U4 microcontrollers, the motor control functions use hardware PWM outputs from Timer1 to generate pulse width modulation at a 20 kHz frequency.

    If you accidentally soldered a motor to the Zumo Shield backwards you can simply call flipLeftMotor(true) and/or flipRightMotor(true) to make the motors behave consistently with the directions in your code.

    3.2 ZumoBuzzer

    The ZumoBuzzer library provides functions that allow various sounds to be played on the buzzer of the Zumo Shield, from simple beeps to complex tunes.

    3.3 Pushbutton

    The Pushbutton library provides a set of functions that are useful for detecting and debouncing pushbutton presses. While the most obvious application of this library is to work with the Zumo Shield’s user pushbutton on digital pin 12, this library can be used as a general-purpose library for interfacing many types of buttons and switches to an Arduino, even without a Zumo Shield.

    3.4 ZumoReflectanceSensorArray

    This library provides a set of functions for reading reflectance values from the reflectance sensor array

    This library depends on the QTRSensors library. The ZumoReflectanceSensorArray class is a subclass of QTRSensorsRC. The functions provided by QTRSensorsRC can also be used on the ZumoReflectanceSensorArray class.

    3.5 QTRSensors

    This library is a general library for interfacing with Pololu QTR reflectance sensors. Since the Zumo reflectance sensor array has the same interface as the QTR RC reflectance sensors, the ZumoReflectanceSensorArray library uses QTRSensors to read the sensor array.

    Step 4: Example projects

    These examples demonstrate how to program the robot to perform more complex and interesting tasks.

    RC Robot

    By connecting an RC receiver and running this example program, you can turn your robot into a radio-controlled vehicle. With the libraries installed, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > RCControl.

    An easy way to connect the receiver to the Zumo Shield is to solder two 1×3 male header strips to the locations shown in the diagram below, then plug in a pair of standard servo between the receiver and the Shield. (If your receiver has a separate power source, you should only connect the signal and ground wires between it and the robot.)

    This program uses Arduino’s PulseIn library to read the signals from the receiver. By default, it assumes the throttle and steering channels are connected as the diagram shows on pins 4 and 5, respectively. The signals from the two channels are mixed to determine the left and right motor speeds, allowing for more intuitive control.

    Simple border-detecting sumo robot

    Adding sensors to the robot allows it to sense and react to its surroundings. In a sumo competition where two robots try to push each other out of a circular ring, it is important for a robot to be able to detect the border of the ring so it can avoid driving over the edge. Since standard robot sumo rings are colored black with a white border around the edge, infrared reflectance sensors are great for this purpose. The Reflectance Sensor Array conveniently mounts six of these sensors in a module designed to plug directly into the front expansion header of the Shield.

    This example demonstrates how to program a robot equipped with a reflectance sensor array to drive around and stay within a sumo ring. Note that it only uses the two outermost sensors on the array, which are sufficient for border detection. With the Libraries installed, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > BorderDetect.

    You might need to edit a few things in this sketch to make it work well with your robot:

    • If one or both of your motors have been connected backwards, uncomment lines 48 and/or 49 to correct their directions.
    • Adjust the speeds and durations in lines 13-17. Generally, lower speeds and shorter durations should work better with faster motors, while higher speeds and longer durations should be more appropriate for slower motors.
    • Finally, the sensor reading threshold used to differentiate between black and white surfaces, defined on line 10, might need to be changed to suit your environment.

    Upload the sketch, place the robot on a sumo ring (or a similar large dark surface with a light border), and press the user pushbutton. Be ready to catch the robot in case it drives off the ring! If everything works right, the robot should sound a countdown with its buzzer and then start driving forward until it detects the ring border; it should then back up, turn, and continue. If not, try adjusting some of the parameters as described above. Here are some specific troubleshooting tips:

    • If the robot overshoots the ring border, try lowering FORWARD_SPEED (especially if it is going very fast) or reducing QTR_THRESHOLD .
    • If the Zumo stops at the border but turns too much or not enough before continuing, adjust TURN_SPEED and/or TURN_DURATION .
    • If you do not hear any sound from the buzzer, make sure you have the buzzer control jumper configured correctly for your Arduino.

    Collision-detecting sumo robot

    This example extends the simple border-detecting sumo robot example described in the previous section, making use of the accelerometer to detect collisions. With the Libraries installed, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > SumoCollisionDetect. This example also requires the LSM303 library to be installed.

    This program uses the X and Y components of the acceleration measured by the LSM303 to determine when it has made contact with an adversary robot in a sumo competition. When it detects contact, the Zumo speeds up, which should allow it to either more effectively push the opponent out of the ring or to escape the opponent if it collided at an undesired angle (from the rear or side). To read more about how this program works, please see the comments contained in SumoCollisionDetect.ino.

    Line follower

    This example program demonstrates how a robot with a reflectance sensor array can be programmed to follow lines and run a line-following course. With the Libraries installed, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > LineFollower.

    Maze solver

    This example program demonstrates how a robot with a reflectance sensor array can be programmed to solve a line maze. With the Libraries installed, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > MazeSolver.

    Using the compass

    This example program demonstrates using the magnetometer in the Shield’s LSM303 3-axis compass module to help the robot coordinate ninety-degree turns and drive in squares. With the Libraries installes, the sketch file can be opened in Arduino by selecting File > Examples > ZumoExamples > Compass. This example also requires the LSM303 library to be installed.

    Because the batteries, motors, and motor current affect the z axis of the magnetometer much more strongly than the x and y axes, this program calculates the robot’s orientation using only the x and y readings from the magnetometer, assuming that the robot is always level. In order to prevent external, locally varying magnetic fields (e.g. from rebar in a concrete floor) from affecting the robot’s navigation too much, the program measures the magnetic heading before each turn, then turns ninety degrees relative to that heading.