Special shout out to Matt Timmons-Brown for this project idea. He is the author of a really good book on Raspberry Pi robotics: (Learn Robotics with Raspberry Pi). Go check it out!
Video
Here is a video of what we will build in this tutorial.
Requirements
Here are the requirements:
Build a line-following robot using Raspberry Pi.
You Will Need
The following components are used in this project. You will need:
These sensors have an infrared (IR) receiver and transmitter.
Black things (e.g. black electrical tape) absorb IR light; white things (e.g. white poster board) reflect IR light.
The receiver will not be able to detect IR light emitted by the transmitter when the robot is over the black electrical tape. Output (OUT pin) of the sensor will be LOW.
The receiver will detect IR light emitted (and then reflected) by the transmitter when the robot is on top of the white poster board because the white poster board will reflect the IR light (black will absorb the IR light). The output (OUT pin) of the sensor will go HIGH.
The robot will use the information provided by this sensor to steer itself and follow the black electrical tape line.
Connect the VCC pin of the IR line sensor to pin 1 of the Raspberry Pi.
Connect the GND pin of the line sensor to the blue (negative) ground rail of the solderless breadboard.
Connect the OUT pin of the line sensor to pin 21 (GPIO 9) of the solderless breadboard.
Testing the Infrared Line Sensor
Power up your Raspberry Pi, and open IDLE.
Create a new program called test_line_following.py.
Save it in to your robot directory.
Here is the code:
import gpiozero
import time
# Description: Code for testing the
# TCRT5000 IR Line Track Follower Sensor
# Author: Addison Sears-Collins
# Date: 05/29/2019
# Initialize line sensor to GPIO9
line_sensor = gpiozero.DigitalInputDevice(9)
while True:
if line_sensor.is_active == False:
print("Line detected")
else:
print("Line not detected")
time.sleep(0.2) # wait for 0.2 seconds
Create a line-following course using your black electrical tape and your poster board. It should look something like this.
I recommend leaving a 3-inch margin between the side of the poster board and the course. Don’t make curves that are too sharp.
Run your test program from a terminal window.
cd robot
python3 test_line_following.py
Move your track in front of the sensor to see if the terminal prints out “Line detected. “
If you are running into issues, use a screwdriver to adjust the sensitivity of the sensor.
That white and blue potentiometer is what you should tweak.
Connect the other IR line sensor.
Connect the VCC pin of the IR line sensor to pin 17 of the Raspberry Pi using a female-to-female jumper wire.
Connect the GND pin of the IR line sensor to the blue (negative) ground rail of the solderless breadboard.
Connect the OUT pin of the IR line sensor to pin 23 (GPIO 11) of the Raspberry Pi.
Attaching the Sensors
Attach the first IR line sensor you wired up to the front, left side of the robot.
Attach the second IR line sensor to the right side of the robot.
Both sensors need to be just off the ground and can be mounted using 2×2 Lego blocks that extend downward from the body of the robot.
A piece of VELCRO is sufficient to attach both sensors.
Run the wires connected to the IR line sensors down through the gap in the robot body.
Create the Line-Following Program in Python
Open IDLE on your Raspberry Pi.
Create a new file inside your robot directory named
line_following_robot.py
Here is the code:
import gpiozero
# File name: line_following_robot.py
# Code source (Matt-Timmons Brown): https://github.com/the-raspberry-pi-guy/raspirobots
# Date created: 5/29/2019
# Python version: 3.5.3
# Description: Follow a line using a TCRT5000 IR
# Line Following Sensor
robot = gpiozero.Robot(left=(22,27), right=(17,18))
left = gpiozero.DigitalInputDevice(9)
right = gpiozero.DigitalInputDevice(11)
while True:
if (left.is_active == True) and (right.is_active == True):
robot.forward()
elif (left.is_active == False) and (right.is_active == True):
robot.right()
elif (left.is_active == True) and (right.is_active == False):
robot.left()
else:
robot.stop()
Deploying Your Line-Following Robot
Place your robot on your track. Make sure the line-following sensors are directly above the black line.
Verify that your Raspberry Pi is connected to battery power, and your 4xAA battery pack is turned on.
Run your program from inside the robot directory.
cd robot
python3 line_following_robot.py
Watch your robot follow the line! Press CTRL-C anytime to stop the program.
In this post, I will show you how to add light to a Raspberry Pi wheeled robot.
Special shout out to Matt Timmons-Brown for this project idea. He is the author of a really good book on Raspberry Pi robotics: (Learn Robotics with Raspberry Pi). Go check it out!
Requirements
Here are the requirements:
Add lights to a wheeled robot using the Adafruit NeoPixel Stick with 8 RGB LEDs.
You Will Need
The following components are used in this project. You will need:
Cut four pins off one of the male pin header connectors with a pair of scissors.
Solder the four pins to the DIN (stands for “data-in”) side of the RGB LED stick.
If you don’t know how to solder, check out my video below.
Connect the 5VDC pin of the RGB LED stick to the positive (red) 5V rail of the solderless breadboard.
Connect the GND (Ground) pin of the RGB LED stick to the blue (negative) rail of the solderless breadboard.
Connect the DIN pin of the RGB LED stick to pin 19 (GPIO 10) of the Raspberry Pi. This is the Master Output Slave Input (MOSI) pin that the Pi uses to send information out via the SPI protocol (more on this in a second).
Mount the RGB LED on the Robot using Velcro. You can mount it anywhere you want.
Power up your Raspberry Pi.
Open a terminal window.
Verify that pip is installed. Pip is a tool that enables you to install and manage libraries that are not a part of Python’s standard library. Type the following commands in the terminal window.
sudo apt-get update
sudo apt-get install python3-pip
Install the rpi_ws 281x library.
sudo pip3 install rpi_ws281x
Make sure the SPI bus is enabled.
SPI is a communication interface built-in to several of the GPIO pins of the Raspberry Pi. It is good to use the SPI bus when you want data to be streamed over short distances, continuously with no interruptions.
Type this terminal command:
sudo raspi-config
Interfacing Options → SPI
Select Yes
Finish
Reboot the Raspberry Pi.
sudo reboot
Wait for the Raspberry Pi to reboot, then open a terminal window again in Raspberry Pi (I’m using Putty).
Modify the Graphics Programming Unit core frequency so that it is 250 MHz.
sudo nano /boot/config.txt
Scroll down, and add this to the bottom of the file.
core_freq = 250
CTRL-X –> Y –> ENTER to save
Reboot the Raspberry Pi.
sudo reboot
Testing the rpi_ws281x Library
Open IDLE on your Raspberry Pi.
Create a new file.
Save it as rgb_library_test.py
Type the following code:
#!/usr/bin/env python3
# NeoPixel library strandtest example
# Author: Tony DiCola (tony@tonydicola.com)
#
# Direct port of the Arduino NeoPixel library strandtest example. Showcases
# various animations on a strip of NeoPixels.
# Code source (Matt-Timmons Brown): https://github.com/the-raspberry-pi-guy/raspirobots
# Minor edits by Matt Timmons-Brown for "Learn Robotics with Raspberry Pi"
import time
from rpi_ws281x import *
import argparse
# LED strip configuration:
LED_COUNT = 8 # Number of LED pixels.
#LED_PIN = 18 # GPIO pin connected to the pixels (18 uses PWM!).
LED_PIN = 10 # GPIO pin connected to the pixels (10 uses SPI /dev/spidev0.0).
LED_FREQ_HZ = 800000 # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10 # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 255 # Set to 0 for darkest and 255 for brightest
LED_INVERT = False # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL = 0 # set to '1' for GPIOs 13, 19, 41, 45 or 53
LED_STRIP = ws.WS2811_STRIP_GRB # Strip type and color ordering
# Define functions which animate LEDs in various ways.
def colorWipe(strip, color, wait_ms=50):
"""Wipe color across display a pixel at a time."""
for i in range(strip.numPixels()):
strip.setPixelColor(i, color)
strip.show()
time.sleep(wait_ms/1000.0)
def theaterChase(strip, color, wait_ms=50, iterations=10):
"""Movie theater light style chaser animation."""
for j in range(iterations):
for q in range(3):
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, color)
strip.show()
time.sleep(wait_ms/1000.0)
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, 0)
def wheel(pos):
"""Generate rainbow colors across 0-255 positions."""
if pos < 85:
return Color(pos * 3, 255 - pos * 3, 0)
elif pos < 170:
pos -= 85
return Color(255 - pos * 3, 0, pos * 3)
else:
pos -= 170
return Color(0, pos * 3, 255 - pos * 3)
def rainbow(strip, wait_ms=20, iterations=1):
"""Draw rainbow that fades across all pixels at once."""
for j in range(256*iterations):
for i in range(strip.numPixels()):
strip.setPixelColor(i, wheel((i+j) & 255))
strip.show()
time.sleep(wait_ms/1000.0)
def rainbowCycle(strip, wait_ms=20, iterations=5):
"""Draw rainbow that uniformly distributes itself across all pixels."""
for j in range(256*iterations):
for i in range(strip.numPixels()):
strip.setPixelColor(i, wheel((int(i * 256 / strip.numPixels()) + j) & 255))
strip.show()
time.sleep(wait_ms/1000.0)
def theaterChaseRainbow(strip, wait_ms=50):
"""Rainbow movie theater light style chaser animation."""
for j in range(256):
for q in range(3):
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, wheel((i+j) % 255))
strip.show()
time.sleep(wait_ms/1000.0)
for i in range(0, strip.numPixels(), 3):
strip.setPixelColor(i+q, 0)
# Main program logic follows:
if __name__ == '__main__':
# Process arguments
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--clear', action='store_true', help='clear the display on exit')
args = parser.parse_args()
# Create NeoPixel object with appropriate configuration.
strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL)
# Intialize the library (must be called once before other functions).
strip.begin()
print ('Press Ctrl-C to quit.')
if not args.clear:
print('Use "-c" argument to clear LEDs on exit')
try:
while True:
print ('Color wipe animations.')
colorWipe(strip, Color(255, 0, 0)) # Red wipe
colorWipe(strip, Color(0, 255, 0)) # Blue wipe
colorWipe(strip, Color(0, 0, 255)) # Green wipe
print ('Theater chase animations.')
theaterChase(strip, Color(127, 127, 127)) # White theater chase
theaterChase(strip, Color(127, 0, 0)) # Red theater chase
theaterChase(strip, Color( 0, 0, 127)) # Blue theater chase
print ('Rainbow animations.')
rainbow(strip)
rainbowCycle(strip)
theaterChaseRainbow(strip)
except KeyboardInterrupt:
if args.clear:
colorWipe(strip, Color(0,0,0), 10)
Save it.
Open a new terminal window.
Run the test using the following command:
python3 rgb_library_test.py -c
The -c at the end makes sure that the RGB LEDs turn off when you type CTRL-C in the terminal window.
Managing the RGB LEDs Using the Nintendo Wii Remote Control
Now we will create a program to control the LEDs using our Wii remote. Open a new terminal window on your Raspberry Pi, and go to the robot directory.
cd robot
Open a new file in IDLE named rgb_wii_remote.py
Type the following code into the program:
import gpiozero
import cwiid
import time
from rpi_ws281x import *
# Author: Matt Timmons-Brown for "Learn Robotics with Raspberry Pi"
# Description: Enables control of the LED with the Wii Remote
# Minor modifications made by Addison Sears-Collins
robot = gpiozero.Robot(left=(22,27), right=(17,18))
print("Press and hold the 1+2 buttons on your Wiimote simultaneously")
wii = cwiid.Wiimote()
print("Connection established")
wii.rpt_mode = cwiid.RPT_BTN | cwiid.RPT_ACC
LED_COUNT = 8
LED_PIN = 10
LED_FREQ_HZ = 800000
LED_DMA = 10
LED_BRIGHTNESS = 150
LED_INVERT = False
LED_CHANNEL = 0
LED_STRIP = ws.WS2811_STRIP_GRB
strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL, LED_STRIP)
strip.begin()
def colorWipe(strip, color, wait_ms=50):
"""Wipe color across display a pixel at a time."""
for i in range(strip.numPixels()):
strip.setPixelColor(i, color)
strip.show()
time.sleep(wait_ms/1000.0)
while True:
buttons = wii.state["buttons"]
if (buttons & cwiid.BTN_PLUS):
colorWipe(strip, Color(255, 0, 0)) # Red wipe
if (buttons & cwiid.BTN_HOME):
colorWipe(strip, Color(0, 255, 0)) # Blue wipe
if (buttons & cwiid.BTN_MINUS):
colorWipe(strip, Color(0, 0, 255)) # Green wipe
if (buttons & cwiid.BTN_B):
colorWipe(strip, Color(0, 0, 0)) # Blank
x = (wii.state["acc"][cwiid.X] - 95) - 25
y = (wii.state["acc"][cwiid.Y] - 95) - 25
if x < -25:
x = -25
if y < -25:
y = -25
if x > 25:
x = 25
if y > 25:
y = 25
forward_value = (float(x)/50)*2
turn_value = (float(y)/50)*2
if (turn_value < 0.3) and (turn_value > -0.3):
robot.value = (forward_value, forward_value)
else:
robot.value = (-turn_value, turn_value)
Save the program.
Place your robot in an open space, and run the following command from inside your Pi’s robot directory.
python3 rgb_wii_remote.py
You can press the home, minus, and plus buttons to activate different lights.
Turn off the lights using the B button, and stop the program by typing CTRL-C.
In this tutorial, I will show you how to program a Raspberry Pi-controlled wheeled robot so that it can detect and avoid obstacles autonomously (fancy word for “all by itself”). I have already done this for an Arduino-controlled robot, now let’s do it for our Raspberry Pi-controlled robot.
Special shout out to Matt Timmons-Brown for this project idea. He is the author of a really good book on Raspberry Pi robotics: (Learn Robotics with Raspberry Pi). Go check it out!
In order to give our robot the ability to “see” obstacles in front of it, we need to connect it up to a sensor. We will use the HC-SR04 ultrasonic sensor, a popular sensor in the do-it-yourself robotics world.
The HC-SR04 has a transmitter and a receiver. The transmitter sends out a 10 microsecond sound wave that is beyond the range of what humans are able to hear. The receiver waits for that sound wave to reflect back. The distance to the object is calculated based on the duration of the echoed sound wave, which is directly proportional to the duration the sound wave traveled (from transmitter to object to receiver).
The distance is calculated based on our knowledge of the speed of sound in dry air at 20°C, which is 343 meters per second (1 mile in 4.7 seconds).
Distance in meters = Speed in meters per second x [(Time in seconds) / 2]
We divide the time by 2 because the sound wave traveled from the HC-SR04 sensor to the object and then back to the sensor. We only want to know the one-way distance from the sensor to the object, not the roundtrip distance. Therefore, in our distance calculation, time is divided by 2.
Determining What Resistors You Need
The Raspberry Pi’s GPIO pins have a working voltage of 3.3V. The HC-SR04 operates on 5V logic. If you connect the HC-SR04 directly to the Raspberry Pi, you might break your Raspberry Pi. This is because when the Echo pin (the receiver) of the HC-SR04 receives the sound wave that was originally emitted by the Trigger pin (the transmitter), the Echo pin will go from LOW (0V) to HIGH (5V). This HIGH signal is then sent to one of the GPIO pins on the Raspberry Pi. But since the GPIO pins can only handle 3.3V, you will overload the Raspberry Pi with voltage.
We must reduce the voltage produced by the ECHO pin (5V) to a level that the Raspberry Pi can handle (3.3V). In order to transform a larger voltage into a smaller voltage, we need to make a circuit known as a voltage divider. The output voltage of a voltage divider is a fraction of the input voltage.
A voltage divider uses two resistors to divide a single voltage into two smaller voltages. The voltage drop across a resistor in a series circuit is directly proportional to the size of the resistor because of a famous law, known as Ohm’s Law (V = IR; Voltage = Current x Resistance).
So, what do we need in order to build a voltage divider? All that is needed are two resistors connected in series (one right after the other) from the input voltage (the voltage you want to reduce) to the ground. You also need a jumper wire to insert in between the two resistors. This jumper wire is the output (target) voltage of the voltage divider and connects to the GPIO pin of the Raspberry Pi.
(3.3/5)(1000) = [1 - (3.3/5)]R2Gather similar terms
[(3.3/5)(1000)]/[1 - (3.3/5)] = R2 Divide by [1 - (3.3/5)]
1941.176 Ω = R2
1941 Ω resistors don’t exist, but we do have a 2000 Ω (2kΩ) resistor. Let’s see what the output voltage is in this case:
R1 = 1000 Ω
R2 = 2000 Ω
Vin = 5V
Vout = ?
Remember the voltage divider equation:
Let’s solve for Vout
Vout = 5 x [2000/(1000 + 2000)]
Vout = 5 x [2000/3000]
Vout = 3.3333... which is close enough to our target voltage
What would have happened if we used a 3000 Ω resistor instead?
Vout = 5 x [3000/(1000 + 3000)]
Vout = 5 x (3000/4000)
Vout = 3.75V which is >3.3V and will break the Raspberry Pi
Therefore, it is always good to use a resistor for R2 that has a little bit less resistance than what you calculate mathematically. That way you protect your Raspberry Pi from damage.
Connect the HC-SR04
Make sure the Raspberry Pi is turned OFF.
Grab two long female-to-male jumper wires.
Connect the VCC pin of the HC-SR04 to the red (positive) rail of the solderless breadboard (the one connected to the Raspberry Pi).
Connect the GND pin of the HC-SR04 to the blue (negative) rail of the solderless breadboard (the one connected to your Raspberry Pi).
Here is the Raspberry Pi pin diagram:
Using a female-to-female jumper wire, connect the Trigger (labeled Trig) pin of the HC-SR04 to pin 16 (GPIO 23) of the Raspberry Pi.
Connect the Echo pin of the HC-SR04 to an empty row on the solderless breadboard. I connected it to e26.
Connect a 1 kΩ resistor from a hole on the same row as the jumper wire (connected to the Echo pin) to an empty row on the solderless breadboard. I connected it from d26 to d22.
Connect a jumper wire from the 1 kΩ resistor to pin 18 (GPIO 24) of the Raspberry Pi. I connected it to c22.
Connect a 2 kΩ resistor from the same row as the pin 18 jumper wire (you just inserted) to the blue (negative) ground rail of the solderless breadboard. I put the resistor in cell b22 of the breadboard.
Write the Python Program
Now we need to write some code so that the Raspberry Pi can use the HC-SR04 sensor.
Power up the Raspberry Pi.
Open a terminal window.
Navigate to the robot directory
cd robot
Create a new program in the Nano Text Editor, We will name it test_ultrasonic_sensor.py.
nano test_ultrasonic_sensor.py
Here is the code.
import gpiozero # GPIO Zero library
import time # Time library
# File name: test_ultrasonic_sensor.py
# Code source (Matt-Timmons Brown): https://github.com/the-raspberry-pi-guy/raspirobots
# Date created: 5/28/2019
# Python version: 3.5.3
# Description: Test the HC-SR04 ultrasonic
# distance sensor
# Assign the GPIO pin number to these variables.
TRIG = 23
ECHO = 24
# This sends out the signal to the object
trigger = gpiozero.OutputDevice(TRIG)
# This variable is an input that receives
# the signal reflected by the object
echo = gpiozero.DigitalInputDevice(ECHO)
# Send out a 10 microsecond pulse (ping)
# from the trasmitter (TRIG)
trigger.on()
time.sleep(0.00001)
trigger.off()
# Start timer as soon as the reflected sound
# wave is "heard" by the receiver (echo)
while echo.is_active == False:
pulse_start = time.time() # Time of last LOW reading
# Stop the timer one the reflected sound wave
# is done pushing through the receiver (ECHO)
# Wave duration is proportional to duration of travel
# of the original pulse.
while echo.is_active == True:
pulse_end = time.time() # Time of last HIGH reading
pulse_duration = pulse_end - pulse_start
# 34300 cm/s is the speed of sound
distance = 34300 * (pulse_duration/2)
# Round to two decimal places
round_distance = round(distance,2)
# Display the distance
print("Distance: ", round_distance)
You can place an object a certain distance away from the sensor to check its accuracy. Let’s do 12 cm, and see what distance reading we get printed out on the terminal window.
Run the program by typing:
python3 test_ultrasonic_sensor.py
If you get a reasonable reading, move on to the next section below.
Mounting the HC-SR04 Ultrasonic Sensor
Mount the ultrasonic sensor to the front of the robot using VELCRO or permanent mounting tape.
Let’s program our robot so that it avoids any objects that are less than 15 cm away from it.
Since this program will be somewhat lengthy, I will open IDLE, an Integrated Development Environment that makes developing and debugging Python code a whole lot easier than using Nano, the Linux command line text editor.
Open VNC Viewer to access your Raspberry Pi.
Click the Raspberry Pi icon in the upper left part of the screen, and go to Programming -> Python 3 (IDLE).
Go to File → New File
Here is the code for the program.
import gpiozero # GPIO Zero library
import time # Time library
# File name: obstacle_avoiding_robot.py
# Code source (Matt-Timmons Brown): https://github.com/the-raspberry-pi-guy/raspirobots
# Date created: 5/28/2019
# Python version: 3.5.3
# Description: A robot that avoids objects
# using an HC-SR04 ultrasonic distance sensor.
# Assign the GPIO pin number to these variables.
TRIG = 23
ECHO = 24
# This sends out the signal to the object
trigger = gpiozero.OutputDevice(TRIG)
# This variable is an input that receives
# the signal reflected by the object
echo = gpiozero.DigitalInputDevice(ECHO)
# Create a Robot object that is attached to
# GPIO pins 17, 18, 22, and 27 of the
# Raspberry Pi. These pins are inputs for the
# L293D motor controller.
# Objects have data and behavior that is
# predefined by the Robot class (i.e. blueprint)
# declared inside the GPIO Zero library.
# Change the order of the numbers inside
# the parentheses until you get the desired
# behavior.
robot = gpiozero.Robot(left=(22,27), right=(17,18))
# Get the distance to the object
def get_distance(trigger, echo):
# Send out a 10 microsecond pulse (ping)
# from the trasmitter (TRIG)
trigger.on()
time.sleep(0.00001)
trigger.off()
# Start timer as soon as the reflected sound
# wave is "heard" by the receiver (echo)
while echo.is_active == False:
pulse_start = time.time() # Time of last LOW reading
# Stop the timer one the reflected sound wave
# is done pushing through the receiver (ECHO)
# Wave duration is proportional to duration of travel
# of the original pulse.
while echo.is_active == True:
pulse_end = time.time() # Time of last HIGH reading
pulse_duration = pulse_end - pulse_start
# 34300 cm/s is the speed of sound
distance = 34300 * (pulse_duration/2)
# Round distance to two decimal places
round_distance = round(distance,2)
return(round_distance)
while True:
distance_to_object = get_distance(trigger,echo)
# Avoid objects less than 15 cm away
if distance_to_object <= 15:
robot.right() # Right for
time.sleep(0.25) # 0.25 seconds
else:
robot.forward() # Forward for
time.sleep(0.1) # 0.1 seconds
Save the file as obstacle_avoiding_robot.py.
Exit IDLE.
When you are ready to run the program, place your robot on the floor in a large open space.
Open a terminal window on the Raspberry Pi and type:
python3 obstacle_avoiding_robot.py
Congratulations! You have developed an autonomous robot that can avoid running into objects all on its own.
When you are done watching your robot avoid obstacles, stop running your program by typing CTRL-C.
Potential Improvements to the Robot
Right now, our robot has only one ultrasonic sensor. We could add more HC-SR04 sensors to make our robot more robust. This would require only small modifications to our original code.
