Build a Miniature Self-Driving Car

The one shown in Figure 2 is just a suggestion. You can use other materials and other shapes for the road, including different combinations of curves, intersections, etc. In general, you should make sure your road has at least one lane that is wide enough for your robot and is clearly marked by lane lines on both sides. Make sure the lines are much lighter than the road surface (e.g., white and yellow tape on a black road).

Figure 2. An example road to test your self-driving car, made from posterboard, cardstock, and tape.

Follow the instructions in this video; however, instead of mounting the 4xAA battery pack on top of the robot, mount it on the lower plate. Then mount your Arduino next to the breadboard on the top plate. This will give you easier access to the circuit when connecting it to the Arduino.

How to Assemble Your BlueBot Chassis

https://www.youtube.com/watch?v=SBeGl_IgWwY

If you plan to use the example code provided by Science Buddies, assemble the circuit as shown in Figures 3 and 4. The Arduino pins used in this diagram match the ones used in our example code (see Step 4). If you try to use our example code without matching this wiring diagram exactly, the code will not work properly.

Take your time and carefully double-check all of your wiring. This is a complicated circuit with a lot of connections. You should connect the batteries last to avoid the risk of creating short circuits while you work.

Note: It is important to make sure all components in the circuit have a common ground, but you must be very careful not to short different positive voltages together (e.g., 5 V from the Arduino and 6 V from the 4xAA battery pack).

Following is one suggested order in which you can build the circuit, but you do not need to do it in this order.

Note: Connections are made with male-male jumper wires unless otherwise indicated.

1. Connect the left and right ground buses on the breadboard. Do not connect the two power buses. You will use them for different voltages.
2. Connect the Arduino's GND pin to the breadboard's ground bus.
3. Connect the Arduino's 5 V pin to the breadboard's right-side power bus.
4. Pins on the L293D H-bridge are numbered 1–16, counterclockwise from the top left. Connect them as follows:
   1. Pin 1 to Arduino pin 10
   2. Pin 2 to Arduino pin 3
   3. Pin 3 to the right motor's negative wire
   4. Pin 4 to ground
   5. Pin 5 to ground
   6. Pin 6 to the right motor's positive wire
   7. Pin 7 to Arduino pin 2
   8. Pin 8 to the left-side power bus (which will be connected to 6V later)
   9. Pin 9 to Arduino pin 9
   10. Pin 10 to Arduino pin 4
   11. Pin 11 to the left motor's positive wire
   12. Pin 12 to ground
   13. Pin 13 to ground
   14. Pin 14 to left motor's negative wire
   15. Pin 15 to Arduino pin 5
   16. Pin 16 to 5 V
5. Connect the PING))) ultrasonic sensor using male-female jumper wires.

   Note: If you are using the HC-SR04 ultrasonic sensor, you will need to modify your circuit and code slightly, as shown in our HC-SR04 ultrasonic sensor tutorial video.

   1. GND pin to ground
   2. 5V5 V pin to 5 V
   3. SIG pin to Arduino pin 7
6. Looking at the bottom (with the pins facing you), orient the infrared (IR) sensor so the small notch in one corner is to the lower right (see Figure 5 for recommended color coding). Connect the left sensor as follows:
   1. Pin 1 to 5 V through a 220 Ω resistor
   2. Pin 2 to ground
   3. Pin 3 to ground
   4. Pin 4 to 5 V through a 10 kΩ resistor and to Arduino analog input pin A0
7. Connect the right IR sensor as follows:
   1. Pin 1 to 5 V through a 220 Ω resistor
   2. Pin 2 to ground
   3. Pin 3 to ground
   4. Pin 4 to 5 V through a 10 Ω resistor and to Arduino analog input pin A1
8. Connect an LED with a 220 Ω current-limiting resistor between Arduino pin 8 and ground.
9. Connect an LED with a 220 Ω current-limiting resistor between Arduino pin 6 and ground.
10. Finally, connect the 4xAA battery pack to your circuit.
    1. Connect the negative wire to the breadboard's ground bus.
    2. Instead of connecting the positive wire directly to the left-side power, connect it to a switch on the breadboard first, then connect the switch to the left-side power bus (assuming you previously connected the right-side power bus to 5 V; remember not to short the two voltages together). This will allow you to easily turn the battery pack on and off.

Figure 3. A breadboard view of the circuit. Click here to download a larger version of the breadboard view.

Figure 4. A schematic view of the circuit. Click here to download a larger version of the schematic view.

Figure 5. Male-female jumper wires connected to the IR sensor's pins. You will see a small diagonal notch on one corner of the sensor. With the pins facing you and this notch in the lower right, the pins are numbered 1, 2, 3, 4 counter-clockwise starting from the upper left. Connect blue, black, green, and red wires to pins 1, 2, 3 and 4 respectively.

The ultrasonic sensor should be on the front of the robot, facing forward, at an appropriate height to detect obstacles.

The infrared sensors should be on the left and right of the robot, toward the front, facing downward, a few millimeters from the ground. See Figure 6.

Figure 6. Sensors mounted to the front of the robot with tape and craft sticks.

Carefully read through the commented code. This code has commands to control the robot's motors and to take readings from the sensors, but it does not have an algorithm to tell the robot how to drive based on the sensor readings. Coming up with that part is your job!

The infrared sensors can be affected by ambient light conditions in the room and their distance from the ground, so they must be calibrated before use.

1. Make sure the switch for your 4xAA battery pack is off.
2. Upload the starter code to your Arduino and leave the Arduino plugged into the USB cable.
3. Open the serial monitor (Tools → Serial Monitor).
4. Wave your hand back and forth in front of the ultrasonic sensor. The "ultrasonic sensor (cm)" value should change.
5. Place your robot on the road and move it around so one of the sensors goes over one of the lines you made with tape. The reading for that IR sensor should change. Compare the reading to the value when the sensor is over the dark road. Experiment with the sensors to determine a good "threshold" value (i.e., when the reading is below that value, you know the sensor detects a line). You can set the thresholds for the left and right sensors separately in the code using the leftIRthreshold and rightIRthreshold variables. The thresholds might be different, especially if the sensors are not the same distance from the ground.

You can sketch this algorithm using a flowchart (Figure 7) or "pseudocode" (Figure 8)—conceptual code where you do not worry about the exact syntax or use of proper commands. Figures 7 and 8 show example code for a robot that drives in a clockwise loop (i.e., makes a continuous right turn) without driving off the left edge of the road. (This very simple code would not work for making a left turn or other more complex behaviors like stopping at intersections or avoiding obstacles.)

Here are some ideas for other things you can try:

1. Make your robot automatically stay in a lane (avoid driving over the line on either the left or right side).
2. Make the robot automatically stop at a crosswalk (when both sensors detect a line).
3. Make the robot automatically stop if there is an obstacle less than a certain distance in front of it.
4. Make the robot stop at an intersection, make a 90 degree turn, and then keep driving.
5. Make the robot back up and turn around when it encounters an obstacle that does not move out of the way after a certain amount of time.
6. Advanced: implement "adaptive cruise control" by making the robot automatically try to stay a fixed distance behind an object in front of it.

From the starting point, the chart asks 'Does the left IR sensor detect a line?' If yes, the vehicle should turn right. If no, it should drive forward. In either case, return to 'Does the left IR sensor detect a line?'

Figure 7. A very simple flowchart representing an algorithm for a robot to drive in a clockwise circle without crossing a line.

Edit the starter code to implement your algorithm. When you are ready, upload the code to your Arduino and place the robot on your road. This time you will need to disconnect the USB cable and power your Arduino with the 9 V battery instead. When you are ready, turn on the power switch to the 4xAA battery so the motors can start spinning. Watch your robot go!

Watch your robot closely and analyze its behavior. Does it match what you expect based on your algorithm? It might not work perfectly on the first try, and that is okay. Now it is time to debug!

Common issues and troubleshooting steps include, but are not limited to, the following:

1. The robot fails to detect a line. Double-check your IR sensor readings and adjust the threshold variables if needed. Also try to make sure your road is as flat as possible, as the distance between the sensor and the ground will affect the reading.
2. The robot detects the line, but overshoots turns. Try adjusting the turnspeed1 and turnspeed2 variables to change how fast the robot turns. You can also adjust the straightspeed variable to change how fast the robot drives straight.
3. The robot does not drive straight when both motor speed variables are the same. This can happen if one motor has slightly more friction than the other. You can compensate for this by changing the motor speeds so they are not both the exact same value.

Keep iterating and improving your code until you get the performance you want out of your self-driving Arduino car.