Tag Archives: GPIO

In this tutorial we will see how to read digital values from the GPIO pins. We will be doing digital reads, which means we will be limited to “HIGH” or “LOW” readings. This is a 3.3 volt system, so we need to make sure that the “HIGH” applied signal is 3.3 volts.

Our pinout from LESSON 1 shows which pins are suitable for digital reads.

Beaglebone Black Pinout — Default Pin Configuration for the Beaglebone Black Rev. C.

It is the green GPIO pins which we can use for digital reads. In this lesson we will demonstrate the digital read technique using a simple two button circuit. In order to complete this lesson, you should go ahead and build this circuit.

Beaglebone Button — Example of Simple Beaglebone Black Button Circuit

Notice we are using Pin 1 on Header P9 as the ground and Pins 11 and 13 on header P9 s the input pins. Also note the pulldown resistors are 1000 Ohm. It is important to use at least this much resistance. If you do not have 1,000 Ohm resistors, using something larger NOT something smaller.

Once you have the circuit set up we are ready to begin programming.

First up, you need to import the GPIO library. If you have the latest version of Debian Wheezy, you should have the library on your system. If you do not have it you will need to update and upgrade your operating system. To load the library, you will use the python command:

import Adafruit_BBIO.GPIO as GPIO

1	import Adafruit_BBIO.GPIO as GPIO

We now need to configure out pins P9_11 and P9_13 as inputs. We do this with the command:

GPIO.setup("P9_11", GPIO.IN)
GPIO.setup("P9_13", GPIO.IN)

1 2	GPIO.setup("P9_11", GPIO.IN) GPIO.setup("P9_13", GPIO.IN)

Now to read the state of the buttons, we would use the commands:

state1=GPIO.input("P9_11")
state2=GPIO.input("P9_13")

1 2	state1=GPIO.input("P9_11") state2=GPIO.input("P9_13")

state1 will be True if the top button is pushed, and False if it is not being pushed. Similarly, state2 will be True when the button is being pushed, and False when it is not being pushed.

We can bring these concepts together to make the following program. Play around with the program and see what all you can make it do.

import Adafruit_BBIO.GPIO as GPIO
from time import sleep
topButton="P9_11"
bottomButton="P9_13"
GPIO.setup(topButton, GPIO.IN)
GPIO.setup(bottomButton, GPIO.IN)
while(1):
        if GPIO.input(topButton):
                print "Top Button Pushed"
        if GPIO.input(bottomButton):
                print "Bottom Button Pushed"
        if GPIO.input(bottomButton) and GPIO.input(topButton):
                break
        sleep(.2)
GPIO.cleanup()

import Adafruit_BBIO.GPIO as GPIO

from time import sleep

topButton="P9_11"

bottomButton="P9_13"

GPIO.setup(topButton, GPIO.IN)

GPIO.setup(bottomButton, GPIO.IN)

while(1):

if GPIO.input(topButton):

print "Top Button Pushed"

if GPIO.input(bottomButton):

print "Bottom Button Pushed"

if GPIO.input(bottomButton) and GPIO.input(topButton):

break

sleep(.2)

GPIO.cleanup()

Beaglevone Black Rev. C

Beaglebone Black LESSON 5: Blinking LEDs from GPIO Pins

June 8, 2015 admin

This lesson shows a simple example of how to blink two LEDs from the GPIO pins on the Beaglebone Black. To get going, you will need to hook up the following circuit. (If you have not ordered your Beaglebone Black, you can get one HERE.)

Beaglebone Black LED Circuit — Circuit for Blinking LEDs from Beaglebone Black

Note that the Top LED is connected to Pin “P9_12” and the bottom LED is connected to Pin “P9_11”. We are using 330 ohm current limiting resistors.

The video lesson takes you through several examples of how to blink the LED. Watch the video, and do the examples. Then play around on your own and see what you can make the LEDs do.

Beaglevone Black Rev. C

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

June 8, 2015 admin

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.

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.

Raspberry Pi LED Circuit — 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

Technology Tutorials

Tag Archives: GPIO

Beaglebone LESSON 8: Read Button State from Python

Beaglebone Black LESSON 5: Blinking LEDs from GPIO Pins

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

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

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

Cookies