Raspberry Pi Lab

Tag: LED

NOT Logic

by on Jan.07, 2014, under Code, Digital Logic, Electronics

not-symbol-transparentSo when building electronic circuits, there may be times when you want the circuit to behave opposite of the input it received.  For this we need a logical NOT gate.

A NOT gate is a simple concept.  Whatever the input, the output is the opposite.

To demonstrate this concept, I’ve created a circuit in which the LED is always on unless it receives a HIGH signal from the GPIO.  Here is the circuit I used…

not-gateThe LED gets power directly from the 5v rail.  R1 is the limiter that prevents the LED from being blown out by too much voltage.  The LED stays lit because the transistor at Q1 does not have an input signal.  Therefore Q1 is “open.”  When the GPIO is changed to HIGH, the transistor closes and allows the flow of electrocity to by-pass the LED straight to ground.

The R2 resistor could be a variety of sizes.  In fact, you could, probably get by without it at all.  The 2N222A transistor I used is rated for a typical 40v and 600 mA.

The Python code on the RPi is equally simple.  All we need to do is set the #23 pin to HIGH and the LED goes off.  If you want it to blink, add a pause and then set the #23 pin to low and pause again.  Repeat.

Here’s the code…

#!/usr/bin/env python

# The circuit that goes along with this program is
# wired in such a way that the LED is always on unless
# a HIGH signal is received from the Rpi.
 
import RPi.GPIO as GPIO
 
DEBUG = 1
 
GPIO.setmode(GPIO.BCM)
RED_LED = 23
GPIO.setup(RED_LED, GPIO.OUT)
 
if DEBUG:
   print "LED turned OFF"
while True:
   GPIO.output(RED_LED, True)

 

1 Comment :, , , more...

Three Blink LED – Part Two

by on Jan.05, 2014, under Electronics, Projects

3LED-transparentA couple of days ago I created a circuit for a three led blinking circuit.  The circuit description and the Python code can be found in my previous post.

In that example, I drove the LEDs directly off the GPIO pin with a 560 ohm resister.  That worked well because the GPIO pin can provide 3.3 v at up to 16mA.  However, I reader suggested that driving the LEDs directly off the 5v power rail and switching them on and off with a transistor on the GPIO pin.

The readers was absolutely right.  The transistor is basically a digital switch.  It has three pins called the collector, emitter, and base.  The collector and emitter pins complete the circuit.  The base pin is the switch.  By connecting the base pin to the RPi’s GPIO and setting it to High (1), the circuit is complete and the LED lights up.  Setting the GPIO to low (0) opens the circuit and turns the LED off.

This allows the LED to get its power from some other source than the GPIO pin itself.  The RPI has a 5v pin that is capable of 300 mA.  This additional voltage and current would allow us to use more LEDs per GPIO pin or control other devices that require more than the GPIO is capable of providing..

In my new circuit I took the 5v pin of the RPi to a 560 ohm resistor.  The resistor connected to the positive leg of the LED which then connected its negative leg to the collector pin of an N2222 transistor.  The emitter leg of the transistor then connected to ground.  The base pin of the transistor connected to a GPIO pin.  I set op three of these LED circutis.  Red on GPIO 25.  Green on GPIO 23.  Blue on GPIO 18.

three led isolatedIt really didn’t matter which GPIO pins I used.

I chose these particular pins because those are the same pins I used in my previous Three LED Blink circuit.  Therefore the Python code did not have to change at all for this to work.  The GMail Notify example I posted will also work with this re-designed circuit.

As a side note… The 560 ohm resister is larger than the minimum resister needed for this circuit.  According to Ohm’s Law (I = V/R), the minimum resister value would be 150 ohms.  That is R = (5v – 2v) / 20mA = 150 ohms.  5v being the voltage supplied by the power rail and 2v being the requirement of my particular LED.  The difference, 3v, needts to be resisted away so as not to blow up the LED.  By using the 560 ohm resistor instead of the 150 ohm minimum, my LED will shine sligntly less bright, but I’m ok with that.

 

 

 

Leave a Comment :, , , , , , , , , , more...

Current Draw In My Three LED Circuit

by on Jan.04, 2014, under Electronics

ohms-lawI an previous post I described a Three LED circuit and Python code to drive the LEDs.  A reader posted, via Facebook, the following question…

“You decided to drive them directly through a resistor instead of going through a transistor. What is the current draw on the GPIO pins?”

Well, I am certainly not an electrical expert, but I think I can attempt to talk about the math behind this circuit.

As you recall,  I drove the LED but connecting a GPIO pin to a 560 Ohm resister.  The resistor was connected to the positive leg of the LED.  Lastly, the negative leg of the LED was connected to ground.

I used a 10mm Red LED purchased from Ada Fruit.  The datasheet for this LED can be found at on the Ada Fruit website.  In short, the forward voltage of the LED is a typical 2.0 v with a maximum of 2.4 v.  It draws 20mA.

Ohm’s Law reads the current (I) = Voltage (v) / Reistance (R).   I=V/R

Well, we already know that the LED wants to run at 2.0 V and draw 20mA.  We just need to know what size resistor to place on the LED so as not to blow up the LED.  A simple algebraic re-arrangement of Ohm’s law tells us that R=V/I

The GPIO pins on the RPi all output 3.3v.  Since the GPIO is giving us 3.3 V when we only need 2.0 V, we will have to remove (resist) 1.3V.  Now we can calculate the minimum resistor size.

R = (3.3 V = 2.0 V) / 0.02A = 65 ohms.

That means the minimum size resistor for this circuit using this LED is 65 Ohms.  Using a larger resistor just means the LED won’t shine as brightly as it would with the minimum sized resistor.

So why did I decide to use the 560 ohm resistor?  Simple… That is what I had available in my toolbox.

I think I can now answer the reader’s actual question of how much current was actually drawn from the GPIO pin.

Because I used a 560 ohm resistor and I know the voltage provided by the GPIO and the voltage used by the LED, I can calculate the current draw via Ohm’s Law.

I = V/R

The LED needs 2v of the 3.3 v provided on the GPIO and we know the resister is 560 ohms.

I = (3.3 V – 2.0 V) / 560 ohms = 0.0023 A = 0.23mA

The spec sheet says we can draw up to 16mA from a GPIO (as long as we don’t do that much for more than one pin at a time).  So our 0.23mA is well within spec..

 

 

 

 

 

 

Leave a Comment :, , , , , more...

GMail Notify

by on Jan.03, 2014, under Code, Projects

gmail-plus-raspberryThe idea of today’s project is to make an Gmail Notify program for the RPi.  I started with the idea for this program from the AdaFruit tutorial site, but I have made some significant changes to their code to make it do more of what I thought would be useful.

I used the same circuit I built for the Three LED Blink program I built in my previous post.  That circuit used a blue LED.  This program doesn’t use the blue LED, but since it is on the circuit, I went ahead and set up the pin on the GPIO and insured that it was, in fact, turned off.

Before building this project. I added these three lines to my python setup.

sudo pip install feedparser
sudo easy_install -U distribute
sudo pip install RPi.GPIO

The ‘feedparser’ line is specific to the needs for this program.  However, I believe the other two lines should be added to my RPi GPIO setup script.  I have NOT added them to the script – yet.  So I executed them before starting this project.

The idea of this program is simple.  When the program starts assume that I already know I have messages that are unread and just go ahead and set the alert status to “all clear.”  The fact is, I have – quite letterally – thousands of unread messages.  So if I were to set the “alert condition” If I have any unread messages would be pretty counter productive.

The “all clear” condition sets the green LED to a solid on state.  The “alert status” condition sets the red LED to a blinking state.  This lighting scheme is based on alert vs all clear.  If a stop light makes more sense to you, then you might want to reverse the colors.  Make it what works for you.

With that said, here is the code…

#!/usr/bin/env python

# Script:   r00t   root@bjbranson.com
# v1.0      2 January 2014

# GMail Atom RSS Feed: http://email.about.com/od/gmailtips/qt/et081005.htm
# Feedparser Docs: http://pythonhosted.org/feedparser/

# GMail and Google Apps use the same URL for the RSS Feed:
# Use your full email address as the username to distinguish
# that you are using Google Apps.

# I have thousands of unread messages so I want the program
# to start with the assumption of "no new messages" then alert
# me when additional new mail arrives.

import RPi.GPIO as GPIO
import feedparser
import time
 
DEBUG = 0                 # turn debug mode on or off
USER = "youruserid"       # if gmail just userid before the @; if apps use full email address
PASS = "yourpassword"
BASE_OFFSET = 0           # How many more than inital count will trigger alert
MAIL_CHECK_FREQ = 10      # check mail every X seconds
 
def get_new_messages ():
   feed = feedparser.parse(imapurl)
   newmails=int(feed["feed"]["fullcount"])
   return newmails   

GPIO.setmode(GPIO.BCM)
GREEN_LED = 24
RED_LED = 25
BLUE_LED = 18                   # Blue LED not used, but is wired
GPIO.setup(GREEN_LED, GPIO.OUT)
GPIO.setup(RED_LED, GPIO.OUT)
GPIO.setup(BLUE_LED, GPIO.OUT)

GPIO.output(RED_LED, False)     # Used as alert
GPIO.output(BLUE_LED, False)    # Not used but make sure it is turned off 
GPIO.output(GREEN_LED, False)   # Used to indicate "no attention needed"

imapurl = "https://"+USER+":"+PASS+"@mail.google.com/gmail/feed/atom" 
if DEBUG:
   print imapurl

initial_count = get_new_messages()
offset = BASE_OFFSET + initial_count

while True:

   newmails = get_new_messages()
 
   if DEBUG:
      print "You have", newmails, "new emails!"
 
   if newmails > offset:
      GPIO.output(GREEN_LED, False)  # Set alert condition.
      GPIO.output(RED_LED, True)     # Red LED on and Green LED off.
      blinks = MAIL_CHECK_FREQ
      while (blinks > 0):
         blinks = blinks - 1
         GPIO.output(RED_LED, True)  # Program is intended to check messages every
         time.sleep(0.5)             # MAIL_CHECK_FREQ seconds. Therefore, the blink
         GPIO.output(RED_LED, False) # rate can not take more than one second per cycle.
         time.sleep(0.5)             # So be on 1/2 second and off 1/2 second.
         if DEBUG:
            print ("Blinks Remaining is %s." % (BLINKS))
   else:
      GPIO.output(GREEN_LED, True)   # NO alert
      GPIO.output(RED_LED, False)    # Green on; Red off
      time.sleep(MAIL_CHECK_FREQ)    # Since we are NOT blinking we can just sleep
                

 

Leave a Comment :, , , more...

A Three LED Blink

by on Jan.03, 2014, under Code

My first RPi circuit.

My first RPi circuit.

My first actual circuit is a three LED blinking system.  It is a pretty simple circuit.  I have a ground pin coming off the GPIO to the blue rail on the bread board.  Then a red LED on pin 25, a green LED on pin 24, and a blue LED on pin 18.  Each LED has a 560 ohm resister.

The Python code then cycles through each LED making them blink in sequence.

It isn’t a complicated circuit or a complicated program.  However, it is an excellent starting point and a great “Hello World” program.

In my next post, I’ll use the same circuit to indicate when I have new messages waiting in my GMail account.  Should be fun.

Here is the code I used…

#!/usr/bin/env python
 
import RPi.GPIO as GPIO, time
 
DEBUG = 0
PAUSE = 1
 
GPIO.setmode(GPIO.BCM)
RED_LED = 25
GREEN_LED = 24
BLUE_LED = 18
GPIO.setup(RED_LED, GPIO.OUT)
GPIO.setup(GREEN_LED, GPIO.OUT)
GPIO.setup(BLUE_LED, GPIO.OUT)

while True:
        if DEBUG:
                print "LED ON."

        GPIO.output(RED_LED, True)
        GPIO.output(GREEN_LED, False)
        GPIO.output(BLUE_LED, False)

        time.sleep(PAUSE)

        if DEBUG:
    	print"LED OFF"

        GPIO.output(RED_LED, False)
        GPIO.output(GREEN_LED, True)
        GPIO.output(BLUE_LED, False)

        time.sleep(PAUSE)

        GPIO.output(RED_LED, False)
        GPIO.output(GREEN_LED, False)
        GPIO.output(BLUE_LED, True)

        time.sleep(PAUSE)

Leave a Comment :, , , , , , more...

Archives

All entries, chronologically...

Our Partners

Please take a minute to visit our partners

Looking for something?

Search the Site

If you can't find what you are looking for, please leave a comment somewhere, subscribe to our feed and hopefully your question will be answered shortly, so please visit again!