Building Physical Projects with Python on the Raspberry Pi

The Raspberry Pi is a tiny computer that can be used in a wide variety of projects. With its GPIO pins, it can be used to interact with the physical world, allowing you to build all sorts of projects that involve sensors, motors, LEDs and more. In this article, we’ll show you how to use Python to interact with the GPIO pins on the Raspberry Pi to build some simple physical projects.

Setting up the Raspberry Pi for Physical Projects

Before we can begin building physical projects with the Raspberry Pi, we need to set it up for use with the GPIO pins. To do this, we need to install the RPi.GPIO Python library. To install it, simply open a terminal and run the following command:

sudo pip3 install RPi.GPIO

This will install the RPi.GPIO library for Python 3. If you’re using Python 2, you’ll need to use pip instead of pip3.

With the library installed, we’re now ready to start building physical projects.

Blinking an LED

The first project we’ll build is a simple LED blinking circuit. We’ll connect an LED to one of the GPIO pins on the Raspberry Pi, then use Python to turn it on and off.

To build this circuit, you’ll need an LED, a resistor (any value between 220Ω and 1kΩ), a breadboard, and a few jumper wires. Here’s how you connect the LED to the Raspberry Pi:

1. Connect the longer leg of the LED (the anode) to GPIO pin 17.
2. Connect the shorter leg of the LED (the cathode) to a resistor.
3. Connect the other end of the resistor to a ground pin (any pin marked GND).

With the circuit built, we’re ready to start writing Python code to turn the LED on and off. Here’s the Python code you need:

import RPi.GPIO as GPIO
import time

# Set the GPIO pin numbering mode
GPIO.setmode(GPIO.BCM)

# Set up GPIO pin 17 as an output
GPIO.setup(17, GPIO.OUT)

# Turn the LED on
GPIO.output(17, GPIO.HIGH)

# Wait for one second
time.sleep(1)

# Turn the LED off
GPIO.output(17, GPIO.LOW)

# Clean up the GPIO pins
GPIO.cleanup()

Let’s take a closer look at how this code works:

• We start by importing the RPi.GPIO library and the time library.
• We then set the GPIO pin numbering mode to GPIO.BCM. This is a way of numbering the pins that corresponds to the numbers on the Broadcom SOC channel used to control the pins.
• Next, we set up GPIO pin 17 as an output by calling GPIO.setup(17, GPIO.OUT).
• We then turn the LED on by calling GPIO.output(17, GPIO.HIGH).
• We wait for one second using time.sleep(1).
• Finally, we turn the LED off by calling GPIO.output(17, GPIO.LOW), and clean up the GPIO pins using GPIO.cleanup().

When you run this code on your Raspberry Pi, you should see the LED turn on for one second, then turn off.

Reading a Button

The second project we’ll build is a button circuit that you can use to control an LED. We’ll connect a button to one of the GPIO pins on the Raspberry Pi, then use Python to detect when the button is pressed and released.

To build this circuit, you’ll need a button, a 10kΩ resistor, a breadboard, and a few jumper wires. Here’s how you connect the button and LED to the Raspberry Pi:

1. Connect one leg of the button to GPIO pin 18.
2. Connect the other leg of the button to a 10kΩ resistor.
3. Connect the other end of the resistor to a 3.3V pin (any pin marked 3V3).
4. Connect the anode of the LED to GPIO pin 17.
5. Connect the cathode of the LED to a ground pin (any pin marked GND).

With the circuit built, we can now write Python code to detect when the button is pressed and released, and use this to turn the LED on and off. Here’s the Python code you need:

import RPi.GPIO as GPIO
import time

# Set the GPIO pin numbering mode
GPIO.setmode(GPIO.BCM)

# Set up GPIO pin 17 as an output
GPIO.setup(17, GPIO.OUT)

# Set up GPIO pin 18 as an input
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# Define a function to handle button events
def button_callback(channel):
    print("Button was pressed!")

# Set up a button callback function for when the button is pressed
GPIO.add_event_detect(18, GPIO.RISING, callback=button_callback)

# Wait for the user to press Ctrl-C to quit the program
try:
    while True:
        time.sleep(0.1)
except KeyboardInterrupt:
    pass

# Clean up the GPIO pins
GPIO.cleanup()

Let’s take a closer look at how this code works:

• We start by importing the RPi.GPIO library and the time library.
• We then set the GPIO pin numbering mode to GPIO.BCM.
• We set up GPIO pin 17 as an output, and GPIO pin 18 as an input with a pull-down resistor.
• We define a function called button_callback that will print a message to the console when the button is pressed. This function will be called automatically by the GPIO library when the button is pressed.
• We set up a button callback by calling GPIO.add_event_detect(18, GPIO.RISING, callback=button_callback). This tells the GPIO library to call the button_callback function whenever GPIO pin 18 goes from low to high (i.e. when the button is pressed).
• Finally, we wait for the user to press Ctrl-C to quit the program, clean up the GPIO pins, and exit.

When you run this code on your Raspberry Pi, you should see a message printed to the console whenever you press the button.

Controlling a Motor

The third project we’ll build is a motor control circuit that you can use to control the speed and direction of a motor. We’ll connect a L293D motor driver chip to the Raspberry Pi, then use Python to control the motor.

To build this circuit, you’ll need a L293D motor driver chip, a DC motor, a breadboard, and a few jumper wires. Here’s how you connect the motor driver chip and motor to the Raspberry Pi:

1. Connect pins 1 and 9 of the motor driver chip to 5V on the breadboard.
2. Connect pins 2 and 15 of the motor driver chip to a ground pin (any pin marked GND).
3. Connect pins 3 and 6 of the motor driver chip to GPIO pins 14 and 15, respectively.
4. Connect pins 4 and 5 of the motor driver chip to the positive and negative terminals of the DC motor, respectively.

With the circuit built, we can now write Python code to control the motor. Here’s the Python code you need:

import RPi.GPIO as GPIO
import time

# Set the GPIO pin numbering mode
GPIO.setmode(GPIO.BCM)

# Set up GPIO pins 14 and 15 as outputs
GPIO.setup(14, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)

# Define a function to set the speed and direction of the motor
def set_motor_speed(speed, direction):
    # Set the direction of the motor
    if direction == "forward":
        GPIO.output(14, GPIO.HIGH)
        GPIO.output(15, GPIO.LOW)
    elif direction == "backward":
        GPIO.output(14, GPIO.LOW)
        GPIO.output(15, GPIO.HIGH)

    # Set the speed of the motor
    pwm = GPIO.PWM(14, 100)
    pwm.start(0)
    pwm.ChangeDutyCycle(speed)

# Set the speed and direction of the motor
set_motor_speed(50, "forward")

# Wait for five seconds
time.sleep(5)

# Stop the motor
set_motor_speed(0, "forward")

# Clean up the GPIO pins
GPIO.cleanup()

Let’s take a closer look at how this code works:

• We start by importing the RPi.GPIO library and the time library.
• We then set the GPIO pin numbering mode to GPIO.BCM.
• We set up GPIO pins 14 and 15 as outputs.
• We define a function called set_motor_speed that takes a speed and direction as arguments, and sets the speed and direction of the motor accordingly. To set the direction of the motor, we set the appropriate GPIO pins high or low. To set the speed of the motor, we use pulse-width modulation (PWM) to generate a variable voltage level. We start a PWM signal by calling GPIO.PWM(14, 100) to create a PWM object with a frequency of 100Hz, and start it by calling pwm.start(0). We then change the duty cycle of the PWM signal by calling pwm.ChangeDutyCycle(speed).
• We set the speed and direction of the motor by calling set_motor_speed(50, "forward") to set the motor to run forward at 50% speed.
• We wait for five seconds using time.sleep(5).
• Finally, we stop the motor by calling set_motor_speed(0, "forward") to set the motor to stop.

When you run this code on your Raspberry Pi, you should see the motor start to spin forward at 50% speed for five seconds, then stop.

Conclusion

In this article, we’ve shown you how to use Python to interact with the GPIO pins on the Raspberry Pi to build some simple physical projects. We’ve built circuits to blink an LED, read a button, and control a motor. These projects are just the beginning – there are countless other projects you can build with the Raspberry Pi and Python. We hope that this article has inspired you to start building your own physical projects with the Raspberry Pi and Python!
ing your ideas and bringing them to life with code and electronics. Always remember to exercise caution when working with electricity and circuits, and to always double-check your connections before testing your circuits.

With some practice, you’ll find that building physical projects with the Raspberry Pi and Python can be a lot of fun, and can lead to some truly amazing projects. So go ahead and try out some of the projects we’ve shown you here, and start exploring the world of physical computing beyond the screen!