Build Your Own Arduino on a Breadboard

Burning The Bootloader (new Microcontroller)

This tutorial explains how to migrate from an Arduino board to a standalone microcontroller on a breadboard. It's similar to this tutorial, but uses an Arduino board to program the ATmega on the breadboard.

Unless you choose to use the minimal configuration described at the end of this tutorial, you'll need four components (besides the Arduino, ATmega328, and breadboard):

• a 16 MHz crystal,
• a 10k resistor, and
• two 18 to 22 picofarad (ceramic) capacitors.

Note that these techniques only work with the Arduino Duemilanove w/ an ATmega328, not the Arduino Uno (or older Arduino boards w/ an ATmega168).

Burning the Bootloader

Using an Arduino board to burn the bootloader onto an ATmega on a breadboard.

If you have a new ATmega328 (or ATmega168), you'll need to burn the bootloader onto it. You can do this using an Arduino board as an in-system program (ISP). If the microcontroller already has the bootloader on it (e.g. because you took it out of an Arduino board or ordered an already-bootloadedATmega), you can skip this section.

To burn the bootloader, follow these steps:

1. Upload the ArduinoISP sketch onto your Arduino board. (You'll need to select the board and serial port from the Tools menu that correspond to your board.)

2. Wire up the Arduino board and microcontroller as shown in the diagram to the right.

3. Select "Arduino Duemilanove or Nano w/ ATmega328" from the Tools > Board menu. (Or "ATmega328 on a breadboard (8 MHz internal clock)" if using the minimal configuration described below.)

4. Run Tools > Burn Bootloader > w/ Arduino as ISP.

You should only need to burn the bootloader once. After you've done so, you can remove the jumper wires connected to pins 10, 11, 12, and 13 of the Arduino board.

Programming via The Arduino Board

Once your ATmega328p has the Arduino bootloader on it, you can upload programs to it using the USB-to-serial convertor (FTDI chip) on an Arduino board. To do, you remove the microcontroller from the Arduino board so the FTDI chip can talk to the microcontroller on the breadboard instead. The diagram at right shows how to connect the RX and TX lines from the Arduino board to the ATmega on the breadboard. To program the microcontroller, select "Arduino Duemilanove or Nano w/ ATmega328" from the the Tools > Board menu (or "ATmega328 on a breadboard (8 MHzinternal clock)" if you're using the minimal configuration described below). Then upload as usual.

Uploading sketches to an ATmega on a breadboard. Remember to remove the microcontroller from the Arduino board!

Minimal Circuit (Eliminating the External Clock)

If you don't have the extra 16 MHz crystal and 18-22 picofarad capacitors used in the above examples, you can configure the ATmega328 to use its internal 8 MHz RC oscillator as a clock source instead. (You don't really need the 10K pullup resistor on the reset pin either, so we remove it to get a truly minimal configuration.)

You'll need to install support for an additional hardware configuration:

1. Download this hardware configuration archive: Breadboard.zip

2. Create a "hardware" sub-folder in your Arduino sketchbook folder (whose location you can find in the Arduino preferences dialog). If you've previously installed support for additional hardware configuration, you may already have a "hardware" folder in your sketchbook.

3. Move the "breadboard" folder from the zip archive to the "hardware" sub-folder of your Arduino sketchbook.

4. Restart the Arduino software.

5. You should see "ATmega328 on a breadboard (8 MHz internal clock)" in the Tools > Board menu.

Once you've done this, you can burn the bootloader and upload programs onto your ATmega328 as described above. Be sure to select "ATmega328 on a breadboard (8 MHz internal clock)" when burning the bootloader. (If you select the wrong item and configure the microcontroller to use an external clock, it won't work unless you connect one.)

Using an Arduino board to burn the bootloader onto an ATmega on a breadboard (w/o an external clock).

 

Uploading sketches to an ATmega on a breadboard.

Getting Rid of the Arduino Board

Once you've programmed the ATmega on the breadboard, you can eliminate the Arduino. To do so, you'll need to provide an alternative power supply for the microcontroller.

Now we will show you how to build an Arduino compatible breadboard with an Atmel Atmega8/168/328 AVR microcontroller and FTDI FT232 breakout board from SparkFun. You could also use the Arduino USB Mini.

Originally created David A. Mellis
Updated from the ITP version by Carlyn Maw
Updated October 23, 2008 by Rory Nugent

Parts

To do this, you'll need:

The Supplies

Basic Parts for wiring up Arduino

• A breadboard
• 22 AWG wire
• 7805 Voltage regulator
• 2 LEDs
• 2 220 Ohm resistors
• 1 10k Ohm resistor
• 2 10 uF capacitors
• 16 MHz clock crystal
• 2 22 pF capacitors
• small momentary normally open ("off") button, i.e. Omron type B3F

USB to Serial Communication Board

You will need a FT232 USB Breakout board from SparkFun.

There are two options available from them:

• FT232RL USB to Serial Breakout Board, SKU BOB-0071
• Arduino Serial USB Board, SKU DEV-08165

If you plan to use the top option and have not yet soldered headers to the breakout board, now would be a good time.

Bootloading your Atmega Chips

There are several options for bootloading your Atmega chips, a few of which are covered in this tutorial. If you wish to bootload your Atmega chips using your breadboard, an additional part will make your life much easier but is not necessary.

AVR Programming Adapter from Sparkfun, SKU BOB-08508

Adding circuitry for a power supply

If you've already worked with microcontrollers, it is likely that you already have a preferred way to wire up a power supply to your board, so go ahead and do it that way. In case you need some reminders, here are some pictures of one way to go about it. (This version uses a 5V regulated power supply)

Top Power lines

Add power and ground wires for where your voltage regulator will be.

Bottom Power lines

Add power and ground wires at the bottom of your board connecting each rail.

Add the 7805 and decoupling capacitors

Add the 7805 power regulator and the lines to power the board. The regulator is a TO-220 package where the Input from the external power supply goes input on the left, ground is in the middle and the 5V output is on the right (when facing the front of the regulator). Add power OUT and ground wires that connect to the right and left rails of the breadboard.

Also, add a 10uF capacitor between the IN of the regulator and the ground as well as a 10uF capacitor on the right rail between power and ground. The silver strip on the capacitor signifies the ground leg.

LED

Add an LED and a 220-ohm resistor on the left side of your board across from the voltage regulator. An LED attached to power like this is a great troubleshooting trick. You'll always know when your board is being powered as well as quickly know if your board is being shorted.

Power Supply Input

The red and black wires to the left of the voltage regulator is where your power supply will be plugged in. The red wire is for the POWER and the black wire is for the GROUND. Be sure to only attach a power supply that is between 7-16V. Any lower and you won't get 5V out of your regulator. Any higher and your regulator may be damaged. A 9V battery, 9V DC power supply, or 12V DC power supply is suitable.

Blank Canvas

Now that the power-basics are done you are ready to load on the chip!

ATMEGA8/168/328 Basics

Arduino Pin Map

Before moving on, check out this image. It's a great resource for learning what each of the pins on your Atmega chip do in relation to the Arduino's functions. This will clarify a lot of confusion behind why you hook up certain pins the way you do. For even more detailed information, take a peek at the datasheet for the Atmega 168 (short version) (long version). Here's the sheet for the atmega328 (short version) (long version)

Add supporting circuitry

Start by connecting a 10k ohm pullup resistor to +5V from the RESET pin in order to prevent the chip from resetting itself during normal operation. The RESET pin reboots the chip when pulled down to ground. In later steps we will show you how to add a reset switch that takes advantage of this.

• Pin 7 - Vcc - Digital Supply Voltage
• Pin 8 - GND
• Pin 22 - GND
• Pin 21 - AREF - Analog reference pin for ADC
• Pin 20 - AVcc - Suppply voltage for the ADC converter. Needs to be connected to power if ADC isn't being used and to power via a low-pass filter if it is (a low pass filter is a circuit that reduces noise from the power source. This example isn't using one)

Add the Clock & Caps

Add a 16 MHz external clock between pin 9 and 10, and add two 22 pF capacitors running to ground from each of those pins.

Add a reset switch

Add the small tactile switch so that you can reset the Arduino whenever we'd like and prepare the chip for uploading a new program. A quick momentary press of this switch will reset the chip when needed. Add the switch just above the top of the Atmega chip crossing the gap in the breadboard. Then, add a wire from the bottom left leg of the switch to the RESET pin of the Atmega chip and a wire from the top left leg of the switch to ground.

LED leads on Arduino pin 13

The chip used on this board is actually already programmed using the blink_led program that comes with the Arduino software. If you already have an Arduino printed circuit board running, it is a good idea to go ahead and check the breadboard version you are building with a chip you know works. Pull the chip from your working Arduino and try it on this board. The blink_led program blinks pin 13. Pin 13 on the Arduino is NOT the AVR ATMEGA8-16PU/ATMEGA168-16PU pin 13. It is actually pin 19 on the Atmega chip.

Refer to the pin mapping above to be sure you are plugging it in correctly.

LED on Arduino Pin 13

Finally, add the LED. The long leg or the anode connects to the red wire and the short leg or the cathode connects to the 220 ohm resistor going to ground.

Arduino-Ready!

At this point if you had already programmed your chip somewhere else and didn't need this breadboard circuit to reprogram the chip, you could stop here. But part of the fun is in-circuit programming so keep going to really make a full USB-Arduino-circuit on a breadboard!

Going All The Way – Full Blown Arduino

Add FT232 USB to Serial Board

Now we'll be adding the USB to Serial breakout board to our Arduino breadboard circuit. If you haven't added male headers to your breakout board, you will need to do it now.

Connect the VCCIO of the breakout board to power and the GND to ground.

The pinouts of the Sparkfun FT232 breakout

Curious what all the pin outs are for the SparkFun FT232 breakout board, just simply flip it over! In this situation we'll be using VCC (to supply 5V from the USB port to your board), GND, TXD, and RXD.

Connecting the TX and RX

Now, it's time to get the USB to serial breakout board talking with your new Arduino setup. Connect the RX (pin 2) of your Atmega chip to the TX of the USB to serial board, and connect the TX (pin 3) of your Atmega chip to the RX of the USB to serial board.

And there you have it... ready to be plugged in, powered up and programmed!

Base On:

• http://arduino.cc/en/Tutorial/ArduinoToBreadboard
• http://arduino.cc/en/Main/Standalone

Shrink Your Arduino Projects (ATtiny) – UPDATED

Programming an ATtiny w/ Arduino 1.0

This tutorial shows you how to program an ATtiny45, ATtiny85, ATtiny44 or ATtiny84 microcontroller using the Arduino software. These are small, cheap ($2-3) microcontrollers that are convenient for running simple programs. The ATtiny45 and ATtiny85 have eight legs and are almost identical, except that the ATtiny85 has twice the memory of the ATtiny45 and can therefore hold more complex programs. The ATtiny44 and ATtiny84 have 14-legs and more inputs and outputs. Thanks to Mark Sproul for his work on making the Arduino core portable across processors.

ATtiny45/85 vs. an Arduino Board

The ATtiny45 or 85 is a great option for running simple Arduino programs: it’s small, cheap and relatively easy to use. It does, however, have some limitations relative to the ATmega328P on an Arduino Uno. There are fewer pins, meaning you can’t connect as many components. There’s less flash memory (4KB or 8KB instead of 32KB), meaning your programs can’t be as big. There’s less RAM (256 or 512 bytes instead of 2KB), meaning you can’t store as much data. And there’s no hardware serial port or I2C port (Wire library), making communication trickier. (There are workarounds, like the SoftwareSerial library or the TinyWire library, but they’re not as robust and flexible.)

In short, then, if your project requires only a few simple inputs and/or outputs, you’re probably fine using an ATtiny. If you’re trying to hook up more components or do more complex communication or data processing, though, you’re probably better off with something like the ATmega328P on an Arduino Uno. If you want something smaller and cheaper than a full Arduino board, you might try using an ATmega328P on a breadboard instead.

Materials and Tools

For this tutorial, you’ll need:

• · An in-system programmer (ISP), a piece of hardware used to load programs onto the ATtiny. Options include:
• o The Tiny AVR Programmer, a board we developed with SparkFun specifically for programming ATtiny45/85s.
• o Another commercial programmer like the AVRISP mkII or USBtinyISP.
• o a Arduino Uno or Duemilanove (w/ an ATmega328, not an older board with an ATmega168). See this tutorial for using an Arduino board as a programmer
• · ATtiny45 or ATtiny85 (8-pin DIP package) or an ATtiny44 or ATtiny84.
• · a solderless breadboard and jumper wires (unless you’re using the TinyProgrammer w/ the ATtiny45 or 85)
• For more information, see our list of materials and parts and our list of prototyping supplies.

• Download

· ATtiny master.zip (hosted by GitHub)

Installing ATtiny support in Arduino

• · If you haven’t already, download the Arduino software, version 1.0.4 (1.0.3 and 1.0.1 should work too, but not 1.0.2). Install the Arduino software, following the instructions for Windowsor for Mac OS X.
• · Download the ATiny master.zip file from the link above.
• · Unzip the attiny master.zip file. It should contain an “attiny-master” folder that contains an “attiny” folder.
• · Locate your Arduino sketchbook folder (you can find its location in the preferences dialog in the Arduino software)
• · Create a new sub-folder called “hardware” in the sketchbook folder, if it doesn’t exist already.
• · Copy the “attiny” folder (not the attiny-master folder) from the unzipped ATtiny master.zip to the “hardware” folder. You should end up with folder structure like Documents > Arduino > hardware > attiny that contains the file boards.txt and another folder calledvariants.
• · Restart the Arduino development environment.
• · You should see ATtiny entries in the Tools > Board menu.

Connecting the ATtiny

You’ll need to provide power to the ATtiny and connect it to your programmer. That is, connecting MISO, MOSI, SCK, RESET, VCC, and GND of the programmer to the corresponding pins on the ATtiny. (Or, if you’re using an circuit w/ an ATtiny, simply connect the programmer to the ISP header on the board – you may also need to power the board separately.)

Instructions and diagrams are available for:

connecting an Arduino (as ISP) to an ATtiny.

using the TinyProgrammer

Programming the ATtiny

Next, we can use the Arduino as an ISP to upload a program to the ATtiny:

• · Open the Blink sketch from the examples menu.
• · Change the pin numbers from 13 to 0.
• · Select the appropriate item from the Tools > Board menu (leave the serial port set to that of your Arduino board).
• · Select the appropriate item from the Tools > Programmer menu (e.g. “Arduino as ISP” if you’re using an Arduino board as the programmer, USBtinyISP for the USBtinyISP, FabISP, or TinyProgrammer, etc).
• · Upload the sketch.

You should see “Done uploading.” in the Arduino software and no error messages. If you then connect an LED between pin 0 and ground, you should see it blink on and off. Note that you may need to disconnect the LED before uploading a new program.

Configuring the ATtiny to run at 8 MHz (for SoftwareSerial support)

By default, the ATtiny’s run at 1 MHz (the setting used by the unmodified “ATtiny45″, etc. board menu items). You need to do an extra step to configure the microcontroller to run at 8 MHz – necessary for use of the SoftwareSerial library. Once you have the microcontroller connected, select the appropriate item from the Boards menu (e.g. “ATtiny45 (8 MHz)”). Then, run the “Burn Bootloader” command from the Tools menu. This configures the fuse bits of the microcontroller so it runs at 8 MHz. Note that the fuse bits keep their value until you explicitly change them, so you’ll only need to do this step once for each microcontroller. (Note this doesn’t actually burn a bootloader onto the board; you’ll still need to upload new programs using an external programmer.)

ATtiny Microcontroller Pin-Outs

Reference

The following Arduino commands should be supported:

• · pinMode()
• · digitalWrite()
• · digitalRead()
• · analogRead()
• · analogWrite()
• · shiftOut()
• · pulseIn()
• · millis()
• · micros()
• · delay()
• · delayMicroseconds()
• · SoftwareSerial (has been updated in Arduino 1.0)

Suggestions and Bug Reports

To report problems or suggest changes to the ATtiny support, please use the issues list on GitHub.

References

• · arduino-tiny: alternative approach to ATtiny support for Arduino
• · TinyWireM & TinyWireS: Wire (I2C / TWI) library for the ATtiny85 (using USI)
• · Servo8Bit: Servo library for the ATtiny45/85.

Alternative: ATmega328P on a Breadboard

If the ATtiny isn’t quite powerful enough but you still want to use a bare microcontroller instead of a full Arduino board, see this tutorial on using an ATmega328P on a breadboard. It allows you to use all the same functions and libraries as the Arduino Uno, but with just a microcontroller and a few small components.

Previous Post: http://myhowtosandprojects.blogspot.pt/2012/10/shrink-your-arduino-projects-attiny.html

Taken From: http://highlowtech.org/?p=1695

Display Linux Applications (X11) on Windows – via Putty (SSH)

X Forwarding with Putty on Windows

Intro to X Forwarding

Unix machines have been able to run software on a remote machine and display the GUI locally for almost two decades. Linux and Mac OS X support X Forwarding with no extra software. Any terminal on Linux should do X Forwarding, Mac users need to run "Applications > Utilities > XTerm". In a command line terminal run "ssh -Y jdoe@compute.example.edu matlab" and you'll be running matlab on "compute.example.edu" but seeing it on your desktop.

Windows users need two pieces of software: an secure shell program (ssh) to establish the remote connection and an X Server to handle the local display.

Prerequisites

• · Putty for SSH
• · Xming for the XServer

Configuring Putty

• 1. Add Unix hostname
• 2. Switch Protocol to SSH
• 3. Type name of session in saved sessions
• 4. Click 'Save'

• 5. Expand the 'SSH' tab from the 'Category' list
• 6. Choose 'X11' from 'SSH' list
• 7. Check 'Enable X11 Forwarding'

• 8. Choose 'Session' from 'Category' list
• 9. Click 'Save'

Starting the X Server on Windows

Configuring Xming

Just run "All Programs > Xming Xming" and leave all at it’s defaults as show in the picture bellow. It should work if you've got PuTTY configured.

Connecting

• 1. Start Xming
• 2. Start Putty
• 3. Double click on the saved session you want

• 4. Enter username and password as requested
• 5. You should now be able to run X applications from the host
  on your local desktop

Based On: http://www.math.umn.edu/systems_guide/putty_xwin32.html

Connect Arduino To Your TV

TV Out with Arduino

This Instructable is for those who would like to use your Arduino to output to a TV. Granted the Arduino is only powerful enough to produce a black and white picture it can still be fun to play with and useful for some projects.

Step 1: Item list

Things you will need:

Hardware

• Arduino
• A TV
• A Protoboard or PCB
• 2 Resistors
• 1x 470 ohm ( Yellow, Violet, Brown )
• 1x 1k ohm ( Brown, Black, Red )
• 2x 2-Pin headers (Only 3 are used but the 4th helps with stability)
• Spare RCA cord you don't mind cutting up

Software
- Arduino Software ( http://arduino.cc/en/Main/Software )
- The TVout library ( http://code.google.com/p/arduino-tvout/ )

Step 2: Assembly

Ok I had already made this connector piece before I decided to make an Instructable.. And I apologize for the poor quality of the images, my cell phone's camera isn't the best but I think you'll get the point.

I got this schematic from the TVout Libraries Google code website:http://code.google.com/p/arduino-tvout/

Step 3: Programming

Now for the fun part... Programming...

When it comes to the TVout Library there is a new version but it's still in beta and I've found it to be buggy so I just use the R5.91 release (http://code.google.com/p/arduino-tvout/downloads/detail?name=TVout_R5.91.zip&can=2&q=)

I'm assuming you have a basic knowledge of Arduino programming so I won't go into too much detail here..

For a complete list of commands for the TVout Library go here( http://code.google.com/p/arduino-tvout/wiki/FDcomplete )

Instructable_01.pde

#include <TVout.h>
TVout TV;
unsigned char x, y;

void setup ( )
{
    TV.start_render( _NTSC );
}

void loop ( )
{
    TV.clear_screen ( );
    TV.print_str ( 10, 10, "TVout FTW!!!" );
    TV.delay ( 60 );
}

For PAL (Europe) TVs just replace the:

  TV.start_render( _NTSC );

with:

  TV.start_render( _PAL );

Step 4: Finished Product

Now this is just the start... There is so many possibilities with this.

Some sites shows how the Arduino can be used as a game console:

Wayne and Layn LLC now makes a shield that uses this library, the video game shield

• http://nootropicdesign.com/hackvision/

Nootropic design is selling a stand alone arduino compatible board the

• http://nootropicdesign.com/hackvision/
• http://nootropicdesign.com/hackvision/games.html 

Also I (JuggaloMemnoch) plan on releasing more projects to further explore uses of the Arduino and TVout library

Base On: http://www.instructables.com/id/TV-Out-with-Arduino/

Mount Windows Network Shares on Linux

Linux mount CIFS Windows Share

Q. How do I mount CIFS (Windows Network Shares) Windows Server / XP / Vista Shared folder under Linux operating systems?

A. Common Internet File System is an application-level network protocol mainly used to provide shared access to files, printers, serial ports, and miscellaneous communications between nodes on a network. You can easily access CIFS (Windows Share) share from Linux and mount them as a regular filesystem.

Mount Linux CIFS share

Mount CIFS (Windows Share) with the default local filesystem permissions:

# mkdir /mnt/cifs
# mount -t cifs //server-name/share-name /mnt/cifs -o username=shareuser,password=sharepassword,domain=nixcraft

# mount -t cifs //192.168.101.100/sales /mnt/cifs -o username=shareuser,password=sharepassword,domain=nixcraft

OR
# mount.cifs //192.168.101.100/sales /mnt/cifs -o username=shareuser,password=sharepassword,domain=nixcraft

Where,

• username=shareuser : specifies the CIFS user name.
• password=sharepassword : specifies the CIFS password. If this option is not given then the environment variable PASSWD is used. If the password is not specified directly or indirectly via an argument to mount, mount will prompt for a password, unless the guest option is specified.
• domain=nixcraft : sets the domain (workgroup) of the user

Taken From: http://www.cyberciti.biz/faq/linux-mount-cifs-windows-share/

Raspberry Pi - GPIO Pins and Python

Tutorial: Raspberry Pi GPIO Pins and Python

· By Mark Kleback

The GPIO pins on a Raspberry Pi are a great way to interface physical devices like buttons and LEDs with the little Linux processor. If you’re a Python developer, there’s a sweet library called RPi.GPIO that handles interfacing with the pins. In just three lines of code, you can get an LED blinking on one of the GPIO pins.

INSTALLATION

The newest version of Raspbian has the RPi.GPIO library pre-installed. You’ll probably need to update your library, so using the command line, run:

sudo python
import RPi.GPIO as GPIO
GPIO.VERSION

The current version of RPi.GPIO is 0.5.4 If you need to update to a newer version, run:

sudo apt-get update
sudo apt-get upgrade

If you don’t have the RPi.GPIO library because you’re using an older version of Raspbian, there are great instructions on the Raspberry Pi Spy website on installing the package from scratch.

USING THE RPI.GPIO LIBRARY

Now that you’ve got the package installed and updated, let’s take a look at some of the functions that come with it. Open the Leafpad text editor and save your sketch as “myInputSketch.py”. From this point forward, we’ll execute this script using the command line:

sudo python myInputSketch.py

All of the following code can be added to this same file. Remember to save before you run the above command. To exit the sketch and make changes, press Ctrl+C.

To add the GPIO library to a Python sketch, you must first import it:

import RPi.GPIO as GPIO

Then we need to declare the type of numbering system we’re going to use for our pins:

#set up GPIO using BCM numbering
GPIO.setmode(GPIO.BCM)
#setup GPIO using Board numbering
GPIO.setmode(GPIO.BOARD)

The main difference between these modes is that the BOARD option uses the pins exactly as they are laid out on the Pi. No matter what revision you’re using, these will always be the same. The BCM option uses the Broadcom SoC numbering, which differs between version 1 and version 2 of the Pi.

from Meltwater’s Raspberry Pi Hardware

In the image above, you’ll see that Pin 5 is GPIO01/03. This means that a v.1 Pi is GPIO 01, while a v.2 Pi is GPIO 03. The BCM numbering is what I’ll be using for the rest of this entry, because it’s universal across other programming languages.

BUILDING A CIRCUIT

Now we’re going to get into inputs and outputs. In the circuit shown below, two momentary switches are wired to GPIO pins 23 and 24 (pins 16 and 18 on the board). The switch on pin 23 is tied to 3.3V, while the switch on pin 24 is tied to ground. The reason for this is that the Raspberry Pi has internal pull-up and pull-down resistors that can be specified when the pin declarations are made.

To set up these pins, write:

GPIO.setup(23, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(24, GPIO.IN, pull_up_down=GPIO.PUD_UP)

This will enable a pull-down resistor on pin 23, and a pull-up resistor on pin 24. Now, let’s check to see if we can read them. The Pi is looking for a high voltage on Pin 23 and a low voltage on Pin 24. We’ll also need to put these inside of a loop, so that it is constantly checking the pin voltage. The code so far looks like this:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(24, GPIO.IN, pull_up_down = GPIO.PUD_UP)
while True:
if(GPIO.input(23) ==1):
print(“Button 1 pressed”)
if(GPIO.input(24) == 0):
print(“Button 2 pressed”)
GPIO.cleanup()

The indents in Python are important when using loops, so be sure to include them. You also must run your script as “sudo” to access the GPIO pins. The GPIO.cleanup() command at the end is necessary to reset the status of any GPIO pins when you exit the program. If you don’t use this, then the GPIO pins will remain at whatever state they were last set to.

THE PROBLEM WITH POLLING

This code works, but prints a line for each frame that the button is pressed. This is extremely inconvenient if you want to use that button to trigger an action or command only one time. Luckily, the GPIO library has built in a rising-edge and falling-edge function. A rising-edge is defined by the time the pin changes from low to high, but it only detects the change. Similarly, the falling-edge is the moment the pin changes from high to low. Using this definition, let’s change our code slightly:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(24, GPIO.IN, pull_up_down = GPIO.PUD_UP)
while True:
GPIO.wait_for_edge(23, GPIO.RISING)
print(“Button 1 Pressed”)
GPIO.wait_for_edge(23, GPIO.FALLING)
print(“Button 1 Released”)
GPIO.wait_for_edge(24, GPIO.FALLING)
print(“Button 2 Pressed”)
GPIO.wait_for_edge(24, GPIO.RISING)
print(“Button 2 Released”)
GPIO.cleanup()

When you run this code, notice how the statement only runs after the edge detection occurs. This is because Python is waiting for this specific edge to occur before proceeding with the rest of the code. What happens if you try to press button 2 before you let go of button 1? What happens if you try to press button 1 twice without pressing button 2? Because the code is written sequentially, the edges must occur in exactly the order written.

Edge Detection is great if you need to wait for an input before continuing with the rest of the code. However, if you need to trigger a function using an input device, then events and callback functions are the best way to do that.

EVENTS AND CALLBACK FUNCTIONS

Let’s say you’ve got the Raspberry Pi camera module, and you’d like it to snap a photo when you press a button. However, you don’t want your code to poll that button constantly, and you certainly don’t want to wait for an edge because you may have other code running simultaneously.

The best way to execute this code is using a callback function. This is a function that is attached to a specific GPIO pin and run whenever that edge is detected. Let’s try one:

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
GPIO.setup(24, GPIO.IN, pull_up_down = GPIO.PUD_UP)
def printFunction(channel):
print(“Button 1 pressed!”)
print(“Note how the bouncetime affects the button press”)
GPIO.add_event_detect(23, GPIO.RISING, callback=printFunction, bouncetime=300)
while True:
GPIO.wait_for_edge(24, GPIO.FALLING)
print(“Button 2 Pressed”)
GPIO.wait_for_edge(24, GPIO.RISING)
print(“Button 2 Released”)
GPIO.cleanup()

You’ll notice here that button 1 will consistently trigger the printFunction, even while the main loop is waiting for an edge on button 2. This is because the callback function is in a separate thread. Threads are important in programming because they allow things to happen simultaneously without affecting other functions. Pressing button 1 will not affect what happens in our main loop.

Events are also great, because you can remove them from a pin just as easily as you can add them:

GPIO.remove_event_detect(23)

Now you’re free to add a different function to the same pin!

ADDING FUNCTIONALITY

As convenient as callback functions are for the GPIO pins, it still doesn’t change the fact that the Raspberry Pi is just not ideal for analog inputs or PWM outputs. However, because the Pi has Tx and Rx pins (pins 8 and 10, GPIO 14 and 15), it can easily communicate with an Arduino. If I have a project that requires an analog sensor input, or smooth PWM output, simply writing commands to the serial port to the Arduino can make things seamless.

Taken From: http://makezine.com/projects/tutorial-raspberry-pi-gpio-pins-and-python/

Raspberry Pi – Make Your Own Pirate Radio ( PiFM )

Raspberry Pirate Radio

This simple hack turns your Raspberry Pi into a powerful FM transmitter! It has enough range to cover your home, DIY drive-in movie, a high school ball game, or even a bike parade (depending on the stragglers).

PiFM software not only boldly enhances the capability of your Pi, but does so with nothing more than a single length of wire. This hack starts with the absolute minimum you need to run a Raspberry Pi — an SD card, a power source, and the board itself — and adds one piece of wire. It’s the coolest Pi device we’ve ever seen with so few materials.

PiFM was originally created by Oliver Mattos and Oskar Weigl, and revised by Ryan Grassel. We’d like to thank the whole PiFM community for inspiration. MAKE’s contribution to the project, the PirateRadio.py script, now enables playback without using the command line, and handles all the most common music file formats automatically. It was written by MAKE Labs engineering intern Wynter Woods. You can find the source code here.

NOTE: The Raspberry Pi’s broadcast frequency can range between 1Mhz and 250Mhz, which may interfere with government bands. We advise that you limit your transmissions to the standard FM band of 87.5MHz–108.0MHz (see Step 3) and always choose a frequency that’s not already in use, to avoid interference with licensed broadcasters.

• PARTS
• TOOLS

Steps

• 1. Make the antenna.
• 2. Flash the SD card and add music.
• 3. Edit the config file.
• 4. Start it up!
• 5. How the PiFM software works.
• 6. Going further.

Step #1: Make the antenna.

· Technically, all you need for an antenna is a piece of wire. For an optimal antenna, you could attach a 75cm wire to pin 4, with a 75cm power cable pointed in the other direction. (That would effectively make a half-wave dipole antenna at 100MHz, near the middle of the FM band.) We just used 40cm of 12 AWG solid wire, since things started tipping over when the wire got longer.

· Cut and strip a female jumper wire. Solder it to one end of your antenna, and insulate with heat-shrink tubing.

· Dab hot glue around the joint for support, and stick it on pin 4 of the GPIO pins of your Raspberry Pi. The glue makes the antenna more rigid so it stands up better.

· NOTE: If you have the Raspberry Pi Starter Kit and you're in a hurry, you can just use a male jumper wire plugged into the Cobbler breakout board! (Both are included in the kit.) It will work, but the range will be roughly half of what you'd get with 40cm of 12 AWG solid copper.

Step #2: Flash the SD card and add music.

· To save you time configuring everything, MAKE Labs made a disk image. Download ithere. (Advanced users who just want the source can find the link in the intro.)

· The original PiFM code proved the concept with impressive results. The MAKE image takes the work out of partitioning the card into system and data partitions. It also auto-mounts the data partition. It uses a fraction of the CPU of the original code and enables playback from MP3, FLAC, and more. And it runs the PirateRadio.py script on startup, so your music starts broadcasting immediately once the transmitter boots up. Ultimately, this will save you a lot of time. But you can't just drag the files to your SD card; it must be flashed to work.

· Flash the image to your SD card. If you're not familiar with the process, it’s easy. Good tutorials can be found here. You can use Win32DiskImager on Windows, or the Command Line Tools (1) instructions if you're on OSX. I'll assume Linux users have moved on already.

· For OSX and Linux users, simply open up the PirateRadio partition and get started. Windows users, follow our instructions for connecting to your Pi via SSH using WinSCP.

· To add music, simply add your artist or album folders to the root of the “Pirate Radio” partition of the SD card. Your music files can be nested within these folders, so there's no need to dump all your music into one mess on the main directory.

Step #3: Edit the config file.

· You can set the frequency you want to broadcast on in the pirateradio.config file. Open it up in a text editor. You should see something like: [pirateradio] frequency = 108.2 shuffle = True repeat_all = True

· Set frequency to the station you want to broadcast on. Useable FM frequencies are typically from 87.5MHz to 108.0MHz. (108.2 was the highest our test radio could reach, and it didn't have any competition from other stations.)

· Set shuffle to True to shuffle files, or to False to play files alphabetically.

· Set repeat_all to True if you want to loop forever through your playlist.

Step #4: Start it up!

Tune your FM radio (or you Mobile Phone) to your frequency of choice and plug in the Raspberry Pi. It will take about 15 seconds to warm up. Once it does, you should hear your music loud and clear.

Step #5: How the PiFM software works.

· From the PiFM wiki: "It uses the hardware on the Raspberry Pi that is actually meant to generate spread-spectrum clock signals on the GPIO pins to output FM radio energy. This means that all you need to do to turn the Raspberry Pi into a (ridiculously powerful) FM transmitter is to plug in a wire as the antenna (as little as 20cm will do) into GPIO pin 4 (aka GPCLK0) and run the code."

· Frequency modulation "is done by adjusting the frequency using the fractional divider." For example, for a target broadcast frequency of 100MHz, the signal is fluctuated between 100.025Mhz and 99.975Mhz, which makes the audio signal.

· The Python code defaults to 87.9 FM with shuffle and repeat turned off. It scans the SD card for music files and builds a playlist based on the options in the config file. It then passes each file along to a decoder based on the filetype. Each file is then re-encoded into a mono format the PiFM radio can handle. This lets you play more than just WAV files: use your MP3, FLAC, M4A, AAC, or WMA files too.

Step #6: Going further.

· Tuck everything in the acrylic case that comes with your Raspberry Pi Starter Kit and you're good to go. Or, if you want something cooler or more subversive, try building an awesome housing of your own. MAKE Labs manager Sam Freeman drew up this little number, a cool radio tower; download it at thingiverse.com/makelabs.

· Add RadioShack's handy USB battery pack so you can carry your station wherever you need to take over the airwaves. (It fits inside the radio tower, too.)

· NOTE: If you have trouble with range, double-check which pin your antenna is plugged into. At MAKE Labs we spent a few hours puzzled by our antenna's performance, only to discover it was one pin over!

Publicado em 06/03/2014

Complete instructions for this episode of Weekend Projects can be found at http://makezine.com/projects/raspberr...
Using a readymade disk image and one simple solder connection, turn your Raspberry Pi into a streaming pirate radio.
This project was originally created by Oliver Mattos and Oskar Weigl. It was revised by Ryan Grassel and extended by MAKE Labs engineering intern Wynter Woods. Go team!
NOTE: The Raspberry Pi's broadcast frequency can range between 1Mhz and 250Mhz, which may interfere with government bands. We advise that you limit your transmissions to the standard FM band of 87.5MHz--108.0MHz and always choose a frequency that's not already in use, to avoid interference with licensed broadcasters.

Taken From: http://makezine.com/projects/make-38-cameras-and-av/raspberry-pirate-radio/

How does This Hack Works / Problems

@StavrosKorokithakis Raspberry Pi has clock generators, that can output square wave to the GPIO pins. If you program clock generator to the desired frequency you'll get the signal, and when you change the frequency, the signal becomes a frequency modulated (FM) radio. Bad points of this approach are: 1) square wave is very noisy -- plenty of harmonics and other frequencies are transmitted, 2) RasPi can output a lot of RF power, blocking some other transmissions in the very wide frequency spectrum.

http://raspberrypi.stackexchange.com/questions/7725/how-does-the-rf-fm-gpio-transmitter-hack-work

 

There's no such thing as square radio waves it's a mixture of multiple sinusoidal waves that make up the squares.
So your FM radio will work but it can only tune into the main sinusoidal component of your signal the rest are nasty harmonic distortions that pollute the entire FM band and beyond to Air Band. Building a radio receiver is very easy with the right transistor like the BF199, however getting a circuit to operate at high frequencies with little or no tuning drift and good reception is difficult.
As I had said earlier the RX/TX boards from eBay have everything you need to broadcast and receive digital signals in one direction you just need to wire it up to the Pi.

http://www.raspberrypi.org/forums/viewtopic.php?t=68201

Square Waves: http://en.wikipedia.org/wiki/Square_wave