Once you’ve completed the camera installation you won’t need to do it again and you can concentrate on taking photos and recording HD video.

Basic Photo Capture

Capturing stills is done using the raspistill command line utiltity and is as easy as typing :

raspistill -o myimage.jpg

This takes a photo which is then saved as “myimage.jpg”. By default the image is previewed on the screen and is captured after a 5 second delay. You can change the delay by using the “-t” option and supplying a time in milliseconds.

In the example below we take a photo with a delay of 3 seconds (3000 milliseconds) :

raspistill -o myimage.jpg -t 3000

This is a list of some of the more common options available when using raspistill :

-?,   --help       : This help information
-w,   --width      : Set image width <size>
-h,   --height     : Set image height <size>
-q,   --quality    : Set jpeg quality <0 to 100>
-o,   --output     : Output filename <filename>
-v,   --verbose    : Output verbose information during run
-t,   --timeout    : Time (in ms) before taking picture
                    (if not specified, set to 5s)
-th,  --thumb      : Set thumbnail parameters (x:y:quality)
-d,   --demo       : Run a demo mode
-e,   --encoding   : Output format (jpg, bmp, gif, png)
-tl,  --timelapse  : Timelapse mode. Takes a picture every <t>ms

-p,   --preview    : Preview window settings <'x,y,w,h'>
-f,   --fullscreen : Fullscreen preview mode
-n,   --nopreview  : Do not display a preview window

-sh,  --sharpness  : Set image sharpness (-100 to 100)
-co,  --contrast   : Set image contrast (-100 to 100)
-br,  --brightness : Set image brightness (0 to 100)
-sa,  --saturation : Set image saturation (-100 to 100)
-ISO, --ISO        : Set capture ISO

-vs,  --vstab      : Turn on video stablisation
-rot, --rotation   : Set image rotation (90,180,270)
-hf,  --hflip      : Set horizontal flip
-vf,  --vflip      : Set vertical flip

To get a full list of options that can be used type :

raspistill | less

Scroll using the arrow keys and press q to return to the command line.

Depending on how you position your camera you may need to use the “-rot” option to ensure your photos are the right way around.

Time Lapse Photo Capture

Another great feature of the utility is the easy capture of a series of images over a specified period of time. You could write your own software to do this but for speed you can’t beat the time lapse options provided :

raspistill -o myimage_%d.jpg -tl 2000 -t 25000

The -tl option sets the time between photos (in milliseconds) and the -t option sets the total time the sequence will last. So in this example a photo will be taken every two seconds (2000ms) for a total time of twenty five seconds (25000ms).

In this example we take a photo every minute (60000 milliseconds) for a total time of 2 hours (60 x 2 x 1000 milliseconds) :

raspistill -o myimage_%d.jpg -tl 60000 -t 7200000

The “%d” results in a sequence of numbered images being produced. In this case you would get images named :

myimage_1.jpg
myimage_2.jpg
myimage_3.jpg
myimage_4.jpg
...

If you change the “%d” to “%04d” you can pad the numbers with zeroes to always give four digits. I much prefer this as it gives you a sequence that looks like :

myimage_0001.jpg
myimage_0002.jpg
myimage_0003.jpg
myimage_0004.jpg
...

Much neater!

As I experiment with the camera I will add other posts and cover some more advanced techniques but until then have fun!

Step 1 – Connect the camera to the Pi

The camera ribbon cable connects to the special connector on the Pi next to the ethernet port. The easiest way to see how the cable is connected is to watch this video. It’s fairly easy you just need to be careful you don’t crease the ribbon cable.

http://www.youtube.com/watch?v=GImeVqHQzsE

Step 2 – Update the SD card

In order to use the camera you must be using a recent operating system that knows that the camera exists. The easiest way to do this is to grab the latest Raspbian image from the RaspberryPi.org site and create a fresh SD card.

Regardless of what version of Raspbian you are using it is highly recommended to update the system using the following commands :

sudo apt-get update

sudo apt-get-upgrade

Depending on how up-to-date your SD card is the second process may take a while.

Step 3 – Enable camera in raspi-config settings

Reboot. If you are using a fresh image the raspi-config utility should load. If it doesn’t then you can run it manually using :

sudo raspi-config

Sekect the “Camera” option and press “Enter”.

Select “Enable” and press “Enter”.

Select “Yes” and press “Enter”. Your Pi will reboot.

Updating your operating and enabling the camera using raspi-config did two things. It told your Pi that there is a camera attached and it added two command line utilities.

• raspistill
• raspivid

These allow you to capture still photos and HD video respectively.

You are now ready to start having fun!

However there are a number of reasons you might wish it wasn’t.

In my testing here are some of the reasons it can get in the way :

• It can cause reflections on objects you are trying to photograph giving them a red glow.
• For nature photography it scares animals.
• For security applications it may draw unnecessary attention to the device.
• It consumes power.

To disable the red LED you simply need to add the following line to your config.txt file :

disable_camera_led=1

To edit the config.txt file you can use Nano :

sudo nano /boot/config.txt

Use the arrow keys to scroll to the end of the file and add “disable_camera_led=1″ to the last line. Press “CTRL-x” to quit. If prompted press “Y” followed by “Return” or “Enter”.

Reboot your Pi with “sudo reboot” and when you next use the camera the red LED will be disabled.

To enable the light again you can either use Nano to remove the line you added above or you can change it to “disable_camera_led=0″. Reboot the Pi and you will have your camera light back.

GPIO Control

Thanks to a hint by @TeamRaspi on Twitter I checked the schematics of the Rev 2 Pi and discovered that once disabled using the process above you can control camera LED using GPIO5. I tested this in Python and it works fine. Here is an example script that blinks the camera LED five times :

#!/usr/bin/env python
import time
import RPi.GPIO as GPIO

# Use GPIO numbering
GPIO.setmode(GPIO.BCM)

# Set GPIO for camera LED
CAMLED = 5

# Set GPIO to output
GPIO.setup(CAMLED, GPIO.OUT, initial=False) 

# Five iterations with half a second
# between on and off
for i in range(5):
  GPIO.output(CAMLED,True)  # On
  time.sleep(0.5)
  GPIO.output(CAMLED,False) # Off
  time.sleep(0.5)

Here is a short clip showing the camera LED being turned on and off using Python :

UPDATE : Since the latest update to Raspbian the disable_camera_led feature appears to have stopped working. Hopefully it will be restored soon! The Python script still allows control of the LED.

I thought it would be best to create a template that I could print out and use to create a camera holder without using the real module. That way I could get all the dimensions correct without worrying about squashing or dropping the module itself.

So here is a diagram showing the main module measurements.

Raspberry Pi Camera Module Diagram

The PCB is 25x24mm and is approximately 1mm thick. The distance between the reverse side of the PCB and the face of the camera is 6mm. The mounting holes will accept a 2mm machine screw according to various posts and photos I have seen.

Printing

You can either print the image above (click to get a bigger version) or use the Raspberry Pi Camera Module Diagram PDF. The image outline and the rectangle in the PDF are 50 x 60mm. You may need to set your printer driver to scale the diagram by 50% to ensure the module comes out 25mm wide.

If I manage to create a camera stand or mount that isn’t too embarrassing I will be sure to write an article about it and share photos.

Disclaimer : I’ve attempted to measure and represent the measurements as best I can using a set of plastic calipers I got free on the cover of a magazine. Please check before cutting or drilling anything.

If there is anything incorrect please let me know and I will correct it.

The camera module is an OV5647 made by OmniVision and measures 8.5 x 8.5 x 5mm. The whole unit including the PCB measures 25mm x 20mm x 9mm. The camera contains a fixed focus 5-megapixel CMOS image sensor and is capable of recording 720p and 1080p HD video at 30 fps.

• 5 megapixel
• 2592×1944 stills
• 1080p at 30 frames per second
• 720p at 60 frames per second
• 640x480p at 60/90 frames per second
• CSi interface with 150mm ribbon cable
• PCB+Camera module weighs 2.4g, ribbon cable weighs 1.0g

The camera is officially supported by the latest Raspbian SD card image but you will need to follow the setup instructions in Eben’s post first.

Here is a video showing how the camera modules ribbon cable should attached to the connector on the Raspberry Pi.

For full instructions on getting the camera working with Raspbian see this excellent camera setup and use post on the RaspberryPi.org site. It includes instructions on taking video and stills. Their is also a detailed set of camera documentation available which details all the command line options for the camera utilities (raspistill, raspivid and raspistillyuv).

Here are some photos of my Camera Module :

I thought this would be a great application to convert for use with a BerryClip 6 LED Buzzer board. So I modified the original code to use 6 LEDs and tweaked a few of the functions. Apart from the LED count I changed the script to use an array of GPIO references so it would be easier to update if you used different pins.

I started with a fresh install of the latest Raspbian SD card image.

#!/bin/bash
#--------------------------------------
#    ___                   ________
#   / _ )___ __________ __/ ___/ (_)__
#  / _  / -_) __/ __/ // / /__/ / / _ \
# /____/\__/_/ /_/  \_, /\___/_/_/ .__/
#                  /___/        /_/
#
#       BerryClip - 6 LED Board
#
# This script uses 6 LEDs to display the
# current CPU usage.
#
# Author : Matt Hawkins
# Date   : 12/05/2013
#
# http://www.raspberrypi-spy.co.uk/
#
# Original script created by chteuchteu
# http://www.chteuchteu.com/
#
# Modified by Matt Hawkins to use the 6 LEDs
# on the BerryClip addon board.
#
# BerryClip LED reference :
# LED 1  - Pin 7  - GPIO4
# LED 2  - Pin 11 - GPIO17
# LED 3  - Pin 15 - GPIO22
# LED 4  - Pin 19 - GPIO10
# LED 5  - Pin 21 - GPIO9
# LED 6  - Pin 23 - GPIO11
#
#--------------------------------------

# Create array of GPIO references
led[1]="11"
led[2]="9"
led[3]="10"
led[4]="22"
led[5]="17"
led[6]="4"

# Configure GPIOs to be outputs
echo ${led[1]} > /sys/class/gpio/export 2> /dev/null
echo ${led[2]} > /sys/class/gpio/export 2> /dev/null
echo ${led[3]} > /sys/class/gpio/export 2> /dev/null
echo ${led[4]} > /sys/class/gpio/export 2> /dev/null
echo ${led[5]} > /sys/class/gpio/export 2> /dev/null
echo ${led[6]} > /sys/class/gpio/export 2> /dev/null
echo "out" > /sys/class/gpio/gpio${led[1]}/direction
echo "out" > /sys/class/gpio/gpio${led[2]}/direction
echo "out" > /sys/class/gpio/gpio${led[3]}/direction
echo "out" > /sys/class/gpio/gpio${led[4]}/direction
echo "out" > /sys/class/gpio/gpio${led[5]}/direction
echo "out" > /sys/class/gpio/gpio${led[6]}/direction

#################################################
#                   FUNCTIONS                   #
#################################################

number=0
gpio=0

function LEDON {
  # Turn ON the LED "number"

  gpio=${led[number]}

  echo "1" > /sys/class/gpio/gpio$gpio/value
  number=0
  gpio=0
}
function LEDOFF {
  # Allow you to turn off the del (the number of the del is contained in "number")
  # number  pin is done at the begining of the function

  gpio=${led[number]}

  echo "0" > /sys/class/gpio/gpio$gpio/value
  number=0
  gpio=0
}

function allON
{
  # Turn ON all the LEDs
  for i in {1..6}
  do
     number=i ; LEDON
  done

}
function allOFF
{
  # Turn OFF all the LEDs
  for i in {1..6}
  do
     number=i ; LEDOFF
  done

}
function flash
{
  counter=0
  while [ $counter -le $1 ]
  do
    allON ; sleep 0.2
    allOFF ; sleep 0.2
    counter=$(( $counter + 1 ))
  done

}

#################################################
#                   MAIN CODE                   #
#################################################

# Turn ON all LEDs in sequence
number=1 ; LEDON ; sleep 0.2
number=2 ; LEDON ; sleep 0.2
number=3 ; LEDON ; sleep 0.2
number=4 ; LEDON ; sleep 0.2
number=5 ; LEDON ; sleep 0.2
number=6 ; LEDON ; sleep 1

# Turn all LEDs OFF
allOFF

# Flash the LEDs 5 times
flash 5

# Start main loop
while true ; do

  # Obtain the current CPU usage percentage
  idle=`vmstat 2 3 | tail -n1 | sed "s/\ \ */\ /g" | cut -d' ' -f 16`
  cpu=$(( 100 - idle ))

  # Switch the LEDs ON or OFF the "cpu" value
  allOFF
  if [ ${cpu} -lt 5 ] ; then
    allOFF
  elif [ ${cpu} -lt 23 ] ; then
    number=1   ; LEDON
  elif [ ${cpu} -lt 41 ] ; then
    number=1   ; LEDON
    number=2   ; LEDON
  elif [ ${cpu} -lt 59 ] ; then
    number=1   ; LEDON
    number=2   ; LEDON
    number=3   ; LEDON
  elif [ ${cpu} -lt 77 ] ; then
    number=1   ; LEDON
    number=2   ; LEDON
    number=3   ; LEDON
    number=4   ; LEDON
  elif [ ${cpu} -lt 95 ] ; then
    number=1   ; LEDON
    number=2   ; LEDON
    number=3   ; LEDON
    number=4   ; LEDON
    number=5   ; LEDON
  else
    number=1   ; LEDON
    number=2   ; LEDON
    number=3   ; LEDON
    number=4   ; LEDON
    number=5   ; LEDON
    number=6   ; LEDON
  fi

done

# Turn all LEDs OFF
allOFF

exit 0

This script can be downloaded directly to your Pi using the following command :

wget http://www.raspberrypi-spy.co.uk/berryclip/6_led/berryclip_cpu_01.sh

The script must be made executable :

chmod +x berryclip_cpu_01.sh

It can then be run from the command line using :

sudo ./berryclip_cpu_01.sh &

The ampersand on the end of the line is required to run the script as a background process and give you your command line back. The number displayed when you run the script is the process ID. You can check the process is still running by typing :

ps aux | grep berryclip

You should see a process with the same ID. If you want to close the process you can type :

sudo kill 1234

Where 1234 is your process ID.

The LEDs will light up based on the CPU utilisation. The percentages required to light each LED are shown below :

None   less than 5%
1 LED  5% or greater
2 LED 23% or greater
3 LED 41% or greater
4 LED 59% or greater
5 LED 77% or greater
6 LED 95% or greater

If you now run “startx” and use some applications (Midori for example) you will see the CPU monitor spring into life! If you don’t like the percentages used in this example they are easy enough to change by adjusting the appropriate numbers in the script.

Here are some photos of the monitor in action :

This wasn’t going to be a scientific test but I wanted a general feeling for how the batteries performed given their different capabilities and price.

The batteries I decided to try were :

• Sanyo eneloop (2000mAh)
• Sanyo eneloop XX (2550mAh)
• 7DayShop Rechargeables (2900mAh)
• 7DayShop “Good to Go” Rechargeables (2150mAh)
• Maxell Alkaline Non-Rechargeables

Due to the time required to run the tests and re-charge the batteries I opted for running the tests with a Raspberry Pi Model B (rev 2) rather than a Model A. Where possible I performed two tests with each set and took the average runtime.

The Test

Maplin Hybrid Charger

The equipment I used was :

• 6 cell AA battery holder
• HobbyKing UBEC voltage regulator
• Maplin 4 cell battery charger
• Raspberry Pi Model B (256mb, rev2)
• BerryClip addon board
• Kingston 2GB SD card with latest Raspbian image

I used a BerryClip so a Python script could provide some visual indication using it’s LEDs. This proved the Pi was processing data throughout the test. I soldered a few pins to the PCB to allow me to attach the wires from the regulator.

With a fresh set of batteries I loaded up the battery holder, connected it to the UBEC and connected that directly to the GPIO Pin 2 (+5V) and Pin 6 (Ground) via the BerryClip PCB. For each test I measured the voltage of the battery pack and the voltage provided by the voltage regulator.

I then used Putty to connect to the Pi via SSH and grabbed the Python test script from my site using :

wget http://www.raspberrypi-spy.co.uk/berryclip/6_led/battery_uptime_test.py

Then ran it using :

sudo python battery_uptime_test.py

The Python script turned the 6 LEDs on and off in sequence while the uptime was displayed in the Putty terminal window on the PC. I simply waited for the batteries to run out of power at which point the terminal window would stop updating. The total runtime could then be noted for that set of batteries.

Results

Here are results :

Conclusions

The results clearly showed the dominance of high capacity rechargeables over standard Alkaline batteries. Given the huge cost per hour I can’t see any real point using Alkalines in Raspberry Pi projects.

When choosing between the others you’ve got a choice. The 7DayShop 2900mAh batteries last longer and are good value for money. For experimenting you should probably consider using these. The Sanyo eneloop and Sanyo eneloop XX are almost there in terms of runtime but are more expensive. They do however have one huge advantage which may justify the extra cost. They are “hybrids” using a more advanced technology and hold their charge over a much longer period of time (85%+ over 1 year). More information can be found on the eneloop Wikipedia page.

The 7DayShop “Good to Go” batteries sit in the middle. They are hybrids and hold their charge but have a modest capacity compared to the eneloops which is reflected in their lower price.

If you plan to charge and then use immediately go for the 7DayShop 2900mAh cells. I use these for kids toys and torches on camping trips etc. They are cheap and I don’t have to worry about the self-discharge.

If you want to charge and not lose much capacity over time then go for one of the Sanyo eneloop variants. The eneloop XX cells are great for digital cameras and long service items as you can depend on them working months or even years after you charged them up. For this reason I use them in my automatic cat feeder which spends a lot of time waiting to be used.

Photos

Here are some photos of the batteries I used in the tests :

This article covers using C, but there will be future posts for using the BerryClip directly from Scratch and also using the node.js javascript language.

The easiest way to do this in C, is to use the  very popular wiringPi C library developed by Gordon Henderson, aka drogon.

The code is available from BitBucket or by cutting and pasting the text below into a file called test1.c :

#include <wiringPi.h>
#include <stdlib.h>

int leds[6] = { 7, 0, 3, 12, 13, 14 };
int BUZZER = 10;
int BUTTON = 11;
void all_leds_off();
void init_pins();

int main (void) {
  //Check we have wiringPi
  if (wiringPiSetup () == -1 ) exit (1);
  init_pins();
  all_leds_off();
  for (;;) {
    if (digitalRead (BUTTON) == 1 ) {
      for (int i = 0; i < 6; i++) {
        digitalWrite (BUZZER,1);
        digitalWrite (leds[i],1);
        delay (50);
        digitalWrite (BUZZER,0);
        delay (450);
      }
      delay (1000);
      all_leds_off();
    }
    delay(50);
  }
  exit(0);
}

void init_pins() {
  //set leds as outputs...
  for (int i = 0; i < 6; i++) {
    pinMode(leds[i], OUTPUT);
  }
  // set buzzer as output...
  pinMode(BUZZER, OUTPUT);

  // set button as an input...
  pinMode(BUTTON, INPUT);
}

void all_leds_off() {
  for (int i = 0; i < 6; i++) {
    digitalWrite (leds[i],0);
  }
}

You will need wiringPi, so please pop over to Gordon’s site to learn how to install wiringPi.

You may notice the pin numbers used in the above example are different to those used in the Python examples.  This is due to wiringPi having it’s own pin numbering system. See Gordon’s pin page for clarification.

To compile test1.c please create a file called Makefile in the same directory as test1.c with the following contents:

DEBUG = -O3
CC    = gcc
INCLUDE = -I/usr/local/include
CFLAGS = $(DEBUG) -Wall -std=c99 $(INCLUDE) -Winline -pipe

LDFLAGS = -L/usr/local/lib
LIBS = -lwiringPi

OBJ = test1.o

BINS = test1

test1: test1.o
        @echo [link]
        $(CC) -o $@ test1.o $(LDFLAGS) $(LIBS)

.c.o:
        @echo [CC] $<
        @$(CC) -c $(CFLAGS) $< -o $@

clean:
        rm -f $(OBJ) *~ test1

In the same directory type

make

To run the program, type

sudo ./test1

Enjoy C, or watch for my next post – if I get a language request in the comments, then I’ll be happy to get the Berry Clip to learn another language in a subsequent post.

It was my first maker faire and my main objective was to hear Eben Upton from the Raspberry Pi Foundation speak. The traffic conditions resulted in his talk being delayed by one hour which gave me, my wife and my son a bit more time to look around.

I wasn’t quite sure how child friendly the event would be but my son loved it. He particularly enjoyed the weaving, spinning, sit on hovercraft and robots.

Meanwhile I wandered over to the Pibow stand and was pleasantly surprised to see Liz Upton. I’m not sure if she noticed the star-struck look on my face as I introduced myself but it was one of many highlights to my day.

It was great to finally see some 3D printers in action. Reprappro.com had three models on display and were busily printing their own spare parts. My son would have happily bought one (with my money) to print an endless supply of Yoda heads.

Once you’ve got one printer you can print some of the parts for the next one!

My wife acquired a free Element14 bag. I acquired a Pimoroni bag. Apparently I no longer own the Pimoroni bag as she thinks it is pretty.

Some of the other highlights of the event included :

• Arthur Amarra and his bluetooth controlled robot arm
• Various robots
• A BBC Micro sending Tweets
• Mr. G‘s Sit-on hover craft
• Fruit controlled music
• Bristol Hackspace CNC mill

There were lots of other bits and pieces and I can’t list them all here. I’m sure they will feature in the various photos appearing on other websites, blogs and social media streams.

At 3pm I joined the queue for Eben’s talk. There were two queues. One for the 50 people with tickets and another for everyone else that turned up anyway. Luckily for them there was some standing room! It was interesting hearing about the development of the Raspberry Pi from one of its creators. A show of hands revealed that most of the audience already owned a Raspberry Pi which was perhaps no surprise. I got a chance to speak to Eben afterwards and now have a pair of signed Pibow cases for my collection. The session was recorded so keep an eye out for the video when it is released.

Here are some random photos I took. There were so many people wandering around it was quite difficult to find the space to take a photo!

If there was something I didn’t take a photo of it is likely it was surrounded by enthusiastic children or my son was dragging me to the next table.

The event was clearly a fantastic success for Bristol and the growing maker community. The organisers, exhibitors and sponsors can be extremely proud of themselves. There are more details on the official Bristol Maker Faire website.

From robot cars to security systems there are plenty of ways of combining these mini-projects into some amazing creations! If you need to buy a present for a Pi owner then these are good starting point.

Ultrasonic Module

Ultrasonic Sensor

Ultrasonic transducer modules are an easy way to add distance measuring capability to your Pi. The device shown in the photo has 2 power pins, 1 trigger pin and 1 echo pin.

Take a look at my “Ultrasonic Distance Measurement Using Python” posts to see how you can connect one to the GPIO header and read it via a simple Python script.

PIR Movement Sensor

PIR Module

Simple “Passive Infra-Red” sensors allow you to detect movement. The sensors I found on eBay only cost a few pounds. They have three pins which can be connected directly to the Raspberry Pi’s GPIO header. These are great for security systems or robotic sensors.

An example python script can be found on the “Cheap PIR Sensors and the Raspberry Pi” page.

Stepper Motor

28BJY-48 Stepper Motor

This was one of the first bits of hardware I attempted to control from the GPIO. The stepper motor came with a controller board which interfaced directly with the GPIO. You feed the device a sequence of inputs and it turns the motor.

Instructions and some example Python can be found on my Stepper Motor Control In Python page.

16×2 or 20×4 Character LCD Display

20×4 LCD Module

16 or 20 character LCD displays are cheap to buy and easy to hook up to the GPIO pins on the Pi. I wrote articles about the 16×2 LCD and 20×4 LCD screens both of which I got from eBay. It doesn’t matter which device you get as long as it is compatible with the “Hitachi HD44780″ LCD controller. Luckily most are based on this very common controller.

With the addition of some basic components you can also adjust the brightness or turn the screen on and off.

USB to Serial Module

USB to Serial Module

A USB to Serial device allows your Pi to communicate over a USB interface. The USB end can be plugged into a PC, Laptop or tablet and the pins can be connected to GPIO pins 8 and 10.

These pins are configured as a serial terminal interface by default and allow you to access the Linux command line from your PC or tablet. It is even possible to power the Pi from the host device if its USB port can supply enough power!

USB WiFi Dongle

Edimax 7811un WiFi Dongle

WiFi dongles are fairly cheap and a great way to connect your Pi to a network without cables. The Edimax 7811 is a popular choice and is easy to configure using the WiFi utility included with the latest Raspbian image.

I’ve also used an Edimax 7711 dongle.

Mini LCD Screen

3.5 inch LCD Screen

There are plenty of small screens available that accept a composite video input. Perfect for hooking up to the Raspberry Pi’s video output. Most of these screens are sold as car reversing camera screens, are powered from 12V and often have two video inputs available.

The one I’ve got was £16 on eBay and I wrote about it in my Cheap Miniature LCD Screen article. I also used it to create a Matrix Screen.

BerryClip 6 LED Buzzer Board

BerryClip Add-on Board

The BerryClip is an addon board for the Pi which plugs directly onto the GPIO header. It provides 6 coloured LEDs, 1 buzzer and 1 momentary switch. These can be controlled using whatever language you prefer but there are lots of example Python scripts to try.

For more details visit the BerryClip page on this site.

USB Bluetooth Dongle

USB Bluetooth Dongle

Bluetooth dongles are cheap and are readily available on the high street or online. I have successfully used a “Origo” branded device and a Tesco “Technika” Nano Bluetooth Adapter. The Tesco dongle cost £5 and isn’t much bigger than the USB plug itself.

A dongle allows you to connect various Bluetooth enabled devices such as keyboards, mice and Wii Controllers.

Nintendo Wii Controller

Nintendo Wii Remote

If you’ve got a Nintendo Wii then it is worth taking a look at my “Nintendo Wii Remote, Python and The Raspberry Pi” page. This explains how you can connect a Wiimote to your Pi and read the status of its buttons in Python. This opens up a whole world of remote control projects.

The YouTube video created by RasPi.TV gives you a taster of the possibilities!