Tag Archives: GPIO

In this lesson we show you how to do digital writes to the GPIO pins from python. If you do not already have a Beaglebone Black Rev C, you can order one HERE.

In order to do this lesson, we need to go back and review the pinout diagram from LESSON 1.

Default Pin Configuration for the Beaglebone Black Rev. C.

In Python, we reference pins by first specifying which header we want (P8 or P9) and then which physical Pin. For Example, to specify pin 12 on the left header, we would refer to it as “P9_12”. For digital output, we should use one of the pins above that is shaded green.

To talk to the GPIO pins in Python, we must first import a library. The latest versions of the Beaglebone Black Rev C. are shipping with the library already installed. If you have an earlier version, you need to update to the latest operating system. You can visit the beagleboard.org web site to download the latest operating system. If you get an error when you try and load the library, you know that either you have typed the command in wrong, or you need to update your operating system. In python to import the library you need to include the line:

import Adafruit_BBIO.GPIO as GPIO

1	import Adafruit_BBIO.GPIO as GPIO

Once you have imported the library, you then need to setup your pin as an output pin:

GPIO.setup("P9_12", GPIO.OUT)

1	GPIO.setup("P9_12", GPIO.OUT)

Now if you want to set that pin high you can use the command:

GPIO.output("P8_10", GPIO.HIGH)

1	GPIO.output("P8_10", GPIO.HIGH)

To set the pin low you can use the command:

GPIO.output("P8_10", GPIO.LOW)

1	GPIO.output("P8_10", GPIO.LOW)

After you are done working with the pin, you should “cleanup” to free the pin up:

GPIO.cleanup()

1	GPIO.cleanup()

These are all the commands you need in order to set the pin “HIGH” or “LOW”. Remember that in the High state, the Beaglebone Black outputs 3.3 Volts.

We can bring things together to make a simple program that will turn the pin on and off in three second intervals. Try and play around yourself with this code. Then try different GPIO pins.

import Adafruit_BBIO.GPIO as GPIO #import GPIO Library
outPin="P9_12"                    #set outPin to "P9_12"
GPIO.setup(outPin,GPIO.OUT)       #make outPin an Output
from time import sleep            #so we can use delays
for i in range(0,5):              #loop 5 times
    GPIO.output(outPin, GPIO.HIGH) # Set outPin HIGH
    sleep(3)                       #Pause
    GPIO.output(outPin, GPIO.LOW) # Set outPin LOW
    sleep(3)                       #Wait
GPIO.cleanup()                     #Release your pins

import Adafruit_BBIO.GPIO as GPIO #import GPIO Library

outPin="P9_12" #set outPin to "P9_12"

GPIO.setup(outPin,GPIO.OUT) #make outPin an Output

from time import sleep #so we can use delays

for i in range(0,5): #loop 5 times

GPIO.output(outPin, GPIO.HIGH) # Set outPin HIGH

sleep(3) #Pause

GPIO.output(outPin, GPIO.LOW) # Set outPin LOW

sleep(3) #Wait

GPIO.cleanup() #Release your pins

Beaglevone Black Rev. C

Beaglebone Black LESSON 1: Understanding Beaglebone Black Pinout

June 5, 2015 admin

This is the first in a series of lessons on the Beaglebone Black. Hopefully you have been with us through our earlier series of lessons on the Arduino, Python, and the Raspberry Pi. If you have been through those lessons learning the Beaglebone will be a snap.

If you are going to follow along with us in these lessons, you can go ahead and order your Beaglebone HERE.

To get started, we need to first of all get our mind around all the different pins. I have put together the diagram below for the default pin assignments for the Beaglebone black.

You can see that the Beaglebone has a large number of pins. There are two headers. Make sure you orient your Beaglebone n the same direction as mine in the picture, with the five volt plug on the top. In this orientation, the pin header on the left is referred to as “P9” and the pin header on the right is referred to as “P8”. The legend in the diagram above shows the funtions, or the possible functions of the various pins. First, we have shaded in red the various 5V, 3.3V, 1.8V and ground pins. Note that VDD_ADC is a 1.8 Volt supply and is used to provide a reference for Analog Read functions. The general purpose GPIO pins have been shaded in green. Note some of these green pins can also be used for UART serial communication. If you want to simmulate analog output, between 0 and 3.3 volts, you can use the PWM pins shaded in purple. The light blue pins can be used as analog in. Please note that the Analog In reads between 0 and 1.8 volts. You should not allow these pins to see higher voltages that 1.8 volts. When using these pins, use pins 32 and 34 as your voltage reference and ground, as pin 32 outputs a handy 1.8 volts. The pins shaded in light orange can be used for I2C. The dark orange pins are primarily used for LCD screen applications.

Raspberry Pi

Raspberry Pi LESSON 31: Making a Dimable LED with Python

June 3, 2015 admin

In this lesson we are ready to bring together a lot of what we learned in earlier lessons. We will create dimable LEDs which will respond to two buttons. If one is pressed the LED will gradually grow dimmer. If the other is pressed, the LED will gradually grow brighter. This will require us to use our skills in using GPIO inputs, pullup resistors, GPIO outputs, and PWM.

For convenience we will use the same circuit we used in LESSON 30, shown below. Also, if you want to follow along with these lessons, you can buy the gear you need HERE.

This Circuit Controls two LED from Push Buttons Using the Raspberry Pi

The objective of this circuit is that we want the LEDs to grow brighter each time the right button is pushed, and we want them to grow dimmer each time to left button is pushed.

The video above steps through and explains this code.

from time import sleep  # Library will let us put in delays
import RPi.GPIO as GPIO # Import the RPi Library for GPIO pin control
GPIO.setmode(GPIO.BOARD)# We want to use the physical pin number scheme
button1=16              # Give intuitive names to our pins
button2=12
LED1=22
LED2=18
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)  # Button 1 is an input, and activate pullup resisrot
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)  # Button 2 is an input, and activate pullup resistor
GPIO.setup(LED1,GPIO.OUT) # LED1 will be an output pin
GPIO.setup(LED2,GPIO.OUT) # LED2 will be an output pin
pwm1=GPIO.PWM(LED1,1000)  # We need to activate PWM on LED1 so we can dim, use 1000 Hz 
pwm2=GPIO.PWM(LED2,1000)  # We need to activate PWM on LED2 so we can dim, use 1000 Hz
pwm1.start(0)              # Start PWM at 0% duty cycle (off)             
pwm2.start(0)              # Start PWM at 0% duty cycle (off)
bright=1                   # Set initial brightness to 1%
while(1):                  # Loop Forever
	if GPIO.input(button1)==0:             #If left button is pressed
		print "Button 1 was Pressed"   # Notify User
		bright=bright/2.               # Set brightness to half
		pwm1.ChangeDutyCycle(bright)   # Apply new brightness
		pwm2.ChangeDutyCycle(bright)   # Apply new brightness
		sleep(.25)                     # Briefly Pause
		print "New Brightness is: ",bright # Notify User of Brightness
	if GPIO.input(button2)==0:             # If button 2 is pressed
		print "Button 2 was Pressed"   # Notify User
		bright=bright*2                # Double Brightness
		if bright>100:                 # Keep Brightness at or below 100%
			bright=100
			print "You are at Full Bright"
		pwm1.ChangeDutyCycle(bright)  # Apply new brightness
		pwm2.ChangeDutyCycle(bright)  # Apply new brightness
		sleep(.25)                    # Pause
		print "New Brightness is: ",bright #Notify User of Brightness

from time import sleep # Library will let us put in delays

import RPi.GPIO as GPIO # Import the RPi Library for GPIO pin control

GPIO.setmode(GPIO.BOARD)# We want to use the physical pin number scheme

button1=16 # Give intuitive names to our pins

button2=12

LED1=22

LED2=18

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Button 1 is an input, and activate pullup resisrot

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Button 2 is an input, and activate pullup resistor

GPIO.setup(LED1,GPIO.OUT) # LED1 will be an output pin

GPIO.setup(LED2,GPIO.OUT) # LED2 will be an output pin

pwm1=GPIO.PWM(LED1,1000) # We need to activate PWM on LED1 so we can dim, use 1000 Hz

pwm2=GPIO.PWM(LED2,1000) # We need to activate PWM on LED2 so we can dim, use 1000 Hz

pwm1.start(0) # Start PWM at 0% duty cycle (off)

pwm2.start(0) # Start PWM at 0% duty cycle (off)

bright=1 # Set initial brightness to 1%

while(1): # Loop Forever

if GPIO.input(button1)==0: #If left button is pressed

print "Button 1 was Pressed" # Notify User

bright=bright/2. # Set brightness to half

pwm1.ChangeDutyCycle(bright) # Apply new brightness

pwm2.ChangeDutyCycle(bright) # Apply new brightness

sleep(.25) # Briefly Pause

print "New Brightness is: ",bright # Notify User of Brightness

if GPIO.input(button2)==0: # If button 2 is pressed

print "Button 2 was Pressed" # Notify User

bright=bright*2 # Double Brightness

if bright>100: # Keep Brightness at or below 100%

bright=100

print "You are at Full Bright"

pwm1.ChangeDutyCycle(bright) # Apply new brightness

pwm2.ChangeDutyCycle(bright) # Apply new brightness

sleep(.25) # Pause

print "New Brightness is: ",bright #Notify User of Brightness

Raspberry Pi

Raspberry Pi LESSON 30: Controlling LEDs from Push Buttons

June 3, 2015 admin

In this lesson we will show how you can control LED’s from push buttons. In order to get started, you will want to expand the circuit we built in LESSON 29 to include two LEDs. The schematic below shows how you will want to hook things up (Also, remember you can see the Raspberry Pi pinout in LESSON 25). Also, as we have mentioned before, if you want to follow along with us in these lessons you can get a kit that has all the gear you need HERE.

In the video lesson, we take you through the code step-by-step. We use the techniques learned in LESSON 29 to detect if a button has been pushed. We introduce two new variables, BS1 and BS2, so indicate the state of the LED’s. A BS1=False means the LED1 is off. A BS1=True means the LED is on. This concept allows us to determine whether we should turn the LED on or off when the button is pushed. Basically, we want to put it in the opposite state when a button is pushed. The code is below. The video shows how it works.

from time import sleep     # Import sleep Library
import RPi.GPIO as GPIO    # Import GPIO Library 
GPIO.setmode(GPIO.BOARD)   # Use Physical Pin Numbering Scheme
button1=16                 # Button 1 is connected to physical pin 16
button2=12                 # Button 2 is connected to physical pin 12
LED1=22                    # LED 1 is connected to physical pin 22
LED2=18                    # LED 2 is connected to physical pin 18
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Make button1 an input, Activate Pull UP Resistor
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Make button 2 an input, Activate Pull Up Resistor
GPIO.setup(LED1,GPIO.OUT,) # Make LED 1 an Output
GPIO.setup(LED2,GPIO.OUT)  # Make LED 2 an Output
BS1=False                  # Set Flag BS1 to indicate LED is initially off
BS2=False                  # Set Flag BS2 to indicate LED is initially off
while(1):                  # Create an infinite Loop
        if GPIO.input(button1)==0:            # Look for button 1 press
                print "Button 1 Was Pressed:"
                if BS1==False:                # If the LED is off
                        GPIO.output(LED1,True)# turn it on
                        BS1=True              # Set Flag to show LED1 is now On 
                        sleep(.5)             # Delay
                else:                         # If the LED is on
                        GPIO.output(LED1,False) # Turn LED off
                        BS1=False               # Set Flag to show LED1 is now Off
                        sleep(.5)
        if GPIO.input(button2)==0: #Repeat above for LED 2 and button 2
                print "Button 2 Was Pressed:"
                if BS2==False:
                        GPIO.output(LED2,True)
                        BS2=True
                        sleep(.5)
                else:
                        GPIO.output(LED2,False)
                        BS2=False
                        sleep(.5)

from time import sleep # Import sleep Library

import RPi.GPIO as GPIO # Import GPIO Library

GPIO.setmode(GPIO.BOARD) # Use Physical Pin Numbering Scheme

button1=16 # Button 1 is connected to physical pin 16

button2=12 # Button 2 is connected to physical pin 12

LED1=22 # LED 1 is connected to physical pin 22

LED2=18 # LED 2 is connected to physical pin 18

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Make button1 an input, Activate Pull UP Resistor

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Make button 2 an input, Activate Pull Up Resistor

GPIO.setup(LED1,GPIO.OUT,) # Make LED 1 an Output

GPIO.setup(LED2,GPIO.OUT) # Make LED 2 an Output

BS1=False # Set Flag BS1 to indicate LED is initially off

BS2=False # Set Flag BS2 to indicate LED is initially off

while(1): # Create an infinite Loop

if GPIO.input(button1)==0: # Look for button 1 press

print "Button 1 Was Pressed:"

if BS1==False: # If the LED is off

GPIO.output(LED1,True)# turn it on

BS1=True # Set Flag to show LED1 is now On

sleep(.5) # Delay

else: # If the LED is on

GPIO.output(LED1,False) # Turn LED off

BS1=False # Set Flag to show LED1 is now Off

sleep(.5)

if GPIO.input(button2)==0: #Repeat above for LED 2 and button 2

print "Button 2 Was Pressed:"

if BS2==False:

GPIO.output(LED2,True)

BS2=True

sleep(.5)

else:

GPIO.output(LED2,False)

BS2=False

sleep(.5)

Raspberry Pi, Tutorial

Raspberry Pi LESSON 29: Configuring GPIO Pins as Inputs

June 3, 2015 admin

We are now ready to learn how to “read” values from the Raspberry Pi GPIO pins. In order to demonstrate this, we will show a simple example using buttons. If you ordered the Raspberry Pi kit we recommend, you already have everything you need, or you can pick your kit up HERE. To start with, you need to put together a simple circuit that connects two push buttons to your Raspberry Pi. Connect according to this schematic.

Simple Circuit Connecting Two Push Buttons to the Raspberry Pi

Note that one leg of each button is connected to the ground rail on the breadboard, that is connected to the Pi ground at physical pin 6. Then we connect the left leg of the left button to physical pin 16, and the left leg of the right button to physical pin 12.

In order to read the state of these buttons, that is, whether they are being pressed or not, we need to write a python program. To begin with we must import GPIO library and specify that we want to

from time import sleep     # Import time library
import RPi.GPIO as GPIO    # Import RPi Library
GPIO.setmode(GPIO.BOARD)   # Specify We Want to reference Physical pins

from time import sleep # Import time library

import RPi.GPIO as GPIO # Import RPi Library

GPIO.setmode(GPIO.BOARD) # Specify We Want to reference Physical pins

Now we are ready to set the pin modes on the pins we are using. We are using pins 12 and 16. We will set up variables so that we can reference the pins by descriptive variables.

button1=16  # Descriptive Variable for pin 16
button2=12  # Descriptive Variable for pin 12
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button1 as input and Activate pull up resistor
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button2 as input and Activate pull up resisor

button1=16 # Descriptive Variable for pin 16

button2=12 # Descriptive Variable for pin 12

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button1 as input and Activate pull up resistor

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) # Set button2 as input and Activate pull up resisor

Note in our GPIO.setup commands, we are not just defining the pins as inputs, we are also activating pullup resistors with

pull_up_down=GPIO.PUD_UP

1	pull_up_down=GPIO.PUD_UP

With this command, the raspberry pi places a pullup resistor between the designated pin and the 3.3 V rail. This means that if we simply read the pin, we will read a “1”, “True”, or “High”, since the pin will see the rail through the pullup resistor. If we connect the pin to ground by pressing a button or switch, the pin will then read a “0”, “False” or “Low” because it will be a straight connection to ground, and as current flows through the pullup resistor, the 3.3 Volts will drop across the pullup resistor. Hence, the pin sees 0 volts.

The result is that with the pullup resistor activated, the pin will always report a “1” until something connects the pin to ground, and then it will read a “0”. This configuration should work for most things, but if you are getting unpredictable results which can result from electrical noise, then try using external pullup resistors.

Now we are ready to read the values from the pins.

while(1): # Create an infinite loop

        if GPIO.input(button1)==0: # button1 will report 0 if it is pressed
                print "Button 1 Pressed"
                sleep(.1)   # delay
        if  GPIO.input(button2)==0: # button 2 will report 0 if it is presses
                sleep(.1)
                print "Button 2 Pressed"

while(1): # Create an infinite loop

if GPIO.input(button1)==0: # button1 will report 0 if it is pressed

print "Button 1 Pressed"

sleep(.1) # delay

if GPIO.input(button2)==0: # button 2 will report 0 if it is presses

sleep(.1)

print "Button 2 Pressed"

Notice that we read from the pin using the GPIO.input command. Also note that for reliable results you need to usually put a small delay in your code. This will help debounce the button, and will also give more stable results.

OK, so our final code is as follows:

from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
button1=16
button2=12
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)
while(1):
        if GPIO.input(button1)==0:
                print "Button 1 Pressed"
                sleep(.1)
        if  GPIO.input(button2)==0:
                sleep(.1)
                print "Button 2 Pressed"

from time import sleep

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BOARD)

button1=16

button2=12

GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)

GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)

while(1):

if GPIO.input(button1)==0:

print "Button 1 Pressed"

sleep(.1)

if GPIO.input(button2)==0:

sleep(.1)

print "Button 2 Pressed"

This code will sit and monitor the buttons, and when one is pressed it will report that that button has been pressed.

Technology Tutorials

Tag Archives: GPIO

Beaglebone Black LESSON 4: Digital Write to the GPIO Pins from Python

Beaglebone Black LESSON 1: Understanding Beaglebone Black Pinout

Raspberry Pi LESSON 31: Making a Dimable LED with Python

Raspberry Pi LESSON 30: Controlling LEDs from Push Buttons

Raspberry Pi LESSON 29: Configuring GPIO Pins as Inputs

Making The World a Better Place One High Tech Project at a Time. Enjoy!