Installation

Omxplayer is installed on the latest Raspbian image so you may already have it installed. If not you can install it using :

sudo apt-get update
sudo apt-get -y install omxplayer

Basic Usage

To play a video file you just need to type :

omxplayer myvideo.mp4

If you are using HDMI you should use this command to pass audio over the HDMI interface :

omxplayer -o hdmi myvideo.mp4

Other Command Line Options

If you type :

omxplayer

you will be presented with a list of the available command line options :

Usage: omxplayer [OPTIONS] [FILE]
Options :
-h / --help                print this help
-n / --aidx  index         audio stream index    : e.g. 1
-o / --adev  device        audio out device      : e.g. hdmi/local
-i / --info                dump stream format and exit
-s / --stats               pts and buffer stats
-p / --passthrough         audio passthrough
-d / --deinterlace         deinterlacing
-w / --hw                  hw audio decoding
-3 / --3d mode             switch tv into 3d mode (e.g. SBS/TB)
-y / --hdmiclocksync       adjust display refresh rate to match
                           video (default)
-z / --nohdmiclocksync     do not adjust display refresh rate to
                           match video
-t / --sid index           show subtitle with index
-r / --refresh             adjust framerate/resolution to video
-l / --pos                 start position (in seconds)
    --boost-on-downmix     boost volume when downmixing
    --subtitles path       external subtitles in UTF-8 srt form at
    --font path            subtitle font
                           (default: /usr/share/fonts/truetype/
                                      freefont/FreeSans.ttf)
    --font-size size       font size as thousandths of screen height
                           (default: 55)
    --align left/center    subtitle alignment (default: left)
    --lines n              number of lines to accommodate in the
                           subtitle buffer (default: 3)

Keyboard Shortcuts

Here are the keyboard shortcuts that you can use to control features within the player :

Space or p   Pause/Resume
q            Exit OMXPlayer
z            Show Info

-            Decrease Volume
+            Increase Volume

i            Previous Chapter
o            Next Chapter

Left Arrow   Seek -30
Right Arrow  Seek +30
Down Arrow   Seek -600
Up Arrow     Seek +600

1            Increase Speed
2            Decrease Speed

j            Previous Audio stream
k            Next Audio stream
n            Previous Subtitle stream
m            Next Subtitle stream
s            Toggle subtitles
d            Subtitle delay -250 ms
f            Subtitle delay +250 ms

Omxplayer is particularly useful if you are creating videos with the Pi camera module and want to playback the files from the command line.

Note : Before experimenting with network enabled features you should really make sure you have changed your Pi password from the “raspberry” default.

Step 1 – Install Lighttpd

Lighttpd is a lightweight web server application that works well on the Pi. It can be installed using the following command :

sudo apt-get -y install lighttpd

Step 2 – Install PHP

Next we need to install PHP. The order in which php5-common, php5-cgi and php5 are installed is important so don’t change their ordering in the line below :

sudo apt-get -y install php5-common php5-cgi php5

Then enable the Fastcgi module which will handle the PHP pages :

sudo lighty-enable-mod fastcgi-php

Once these packages are installed we can restart the Lighttpd service to pick up the changes :

sudo service lighttpd force-reload

Step 3 – Testing

In order to test your new webserver you need to know the IP address your Pi has on your network. To do this run this command :

sudo ip addr show

You will see a block of information similar to this :

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast
    state UP qlen 1000
    link/ether b1:11:ab:42:24:2c brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.45/24 brd 192.168.0.255 scope global eth0

The IP address in this example is 192.168.0.45. Take this IP address and enter it into the address bar of a web browser on another device.

If everything has worked you should see the default Lighttpd “Placeholder” web page. It’s not very exciting but it is easy to replace with your own page.

Step 4 – Tweak Permissions

Now we will adjust some permissions to ensure the “Pi” user account can write files to the location where Lighttpd expects to find web pages. The /var/www directory is currently owned by the “root” user. So let’s make the “www-data” user and group the owner of the /var/www directory.

sudo chown www-data:www-data /var/www

Now we will allow the “www-data” group permission to write to this directory.

sudo chmod 775 /var/www

Finally we can add the “Pi” user to the “www-data” group.

sudo usermod -a -G www-data pi

For these permissions to take effect it is best to reboot your Pi at this point using :

sudo reboot

Step 5 – Replace the placeholder page

Let’s browse to the /var/www directory and rename this default page :

cd /var/www
mv index.lighttpd.html index.lighttpd.hxxx

Now we can replace it with a new php page :

sudo wget http://www.raspberrypi-spy.co.uk/archive/misc/lighttpd_test.php.txt -O /var/www/index.php

The command above grabs a text file from this website, renames it as “index.php” and saves it to the /var/www directory. If you want to look at the test page first click here.

Note : The ‘-O’ in the command is a capital letter O (O for Orange) not a zero or lowercase o.

Refresh your browser and you should see the new page. If PHP is working OK you will see a summary of your PHP configuration.

You are now ready to populate /var/www with HTML, CSS, JS, PHP and image files just as you would for a normal website. These files could be created by your own programs which gives your projects and experiments a way to publish their data to other devices.

This is yet another great way for other devices to interact with your Pi.

If you want your Pi web server to be available on the internet (i.e. beyond your own network) you will need to follow some additional steps. I’m not covering them here but they usually involve “port forwarding” on your router to enable pages to be requested from your Pi by an external visitor.

Optional Steps

By default web servers communicate over port 80. If you want to change the port number that Lighttpd uses you can easily change it by editing the lighttpd.conf file :

sudo nano /etc/lighttpd/lighttpd.conf

then change the “server port” line to define your chosen port number  :

server.port  = 40045

Exit nano using CTRL-X followed by Y. To restart the server and get it to pick up this change use :

sudo /etc/init.d/lighttpd restart

You can now access your web server on another device on your network using :

192.168.0.45:40045

Recommended Book

If you fancy reading a lot more about Lighttpd in a printed book then take a look at “Lighttpd” by Andre Bogus. This is also available as a Kindle edition as well if you prefer your reference material e-book style.

One thing that has changed in the latest Raspian image is that the alsa sound drivers have improved and are enabled by default. So I decided to hook up a rechargeable powered speaker I had using a short 3.5mm jack plug lead and see if I could play some WAV and MP3 files.

The first thing to do is run :

lsmod | grep snd_bcm2835

and check snd_bcm2835 is listed. If it isn’t then run the following command :

sudo modprobe snd_bcm2835

If the module isn’t loaded automatically when you boot then you can force it to load by using the following process :

cd /etc
sudo nano modules

Then add ‘snd-bcm2835′ so it looks like this :

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be
# loaded at boot time, one per line. Lines beginning with "#" are
# ignored. Parameters can be specified after the module name.

snd-bcm2835

By default the output is set to automatically select the default audio interface (HDMI if available otherwise analog). You can force it to use a specific interface using :

amixer cset numid=3 n

Where <n> is the required interface : 0=auto, 1=analog, 2=hdmi. To force the Raspberry Pi to use the analog output :

amixer cset numid=3 1

I usually have to do this if I boot the Pi with an HDMI cable plugged in. Otherwise it defaults to the 3.5mm jack automatically.

Playing A WAV File Using aplay

Everything should be ready to test some sound files. First up WAV. Use the following commands to grab some WAV files from my sound archive :

wget http://www.freespecialeffects.co.uk/soundfx/sirens/police_s.wav
wget http://www.freespecialeffects.co.uk/soundfx/computers/bleep_01.wav

To play it use :

aplay police_s.wav

If you are lucky the sound will play through your speakers or headphones.

Playing An MP3 Using MPG321

There are numerous ways to play MP3s from the command line but I tend to use MPG321. This can be installed using :

sudo apt-get -y install mpg321

Once installed we can grab an MP3 to experiment with :

wget http://www.freespecialeffects.co.uk/soundfx/household/bubbling_water_1.mp3

The MP3 file can be played using :

mpg321 bubbling_water_1.mp3

The volume can be adjusted using the ‘g’ command line option. In the example below I set the volume to 50% :

mpg321 -g 50 bubbling_water_1.mp3

Playing An MP3 Using Omxplayer

You can also use the excellent Omxplayer to play MP3s. To get a list of options type :

omxplayer

It is installed by default in the latest Raspbian release but if you need to install it manually you can do so using :

sudo apt-get -y install omxplayer

To play a sound file you simply need to type :

omxplayer bubbling_water_1.mp3

The plus (+) and minus (-) keys can be used to adjust the volume of the playback.

This post covers basic audio playing from the command line. If you want to start playing lists of music then you should explore some of the more advanced media software available for the Pi. This includes XBMC and OpenElec.

In a future post I will cover playing audio within Python scripts using Pygame.

Here are some photos showing the rechargeable powered speaker I use for my Raspberry Pi command line audio tests :

This article assume you’ve correctly installed your camera module and had a play with taking photos with it.

Here is a list of the hardware and software I used :

• Raspberry Pi camera module connected to a Model B
• Latest version of Raspbian on an 8GB SD card
• Libav installed on my PC (download here)
• Gimp installed on my PC (download here)
• WinSCP installed on my PC (download here)

Here is an example image from my sequence followed by the effect I was after with a logo in the bottom corner.

Step 1 – Create time-lapse sequence

To start off I needed a sequence of images so I used this command to get the Raspberry Pi camera to create an image every 30 seconds for 1 hour. This was a total of 120 images.

raspistill -o timelapse_%04d.jpg -tl 30000 -t 3600000

To speed things up I decided to create the video on my PC so I copied the 120 images from the Pi to the PC using WinSCP.

Step 2 – Create logo overlay graphic

Next I created my overlay image in Gimp that was 280×280 in size and saved as a PNG file. This format is great because it allowed my logo to sit on a transparent background. This image was named “watermark.png” and copied into the same directory as the set of images from the Pi.

Step 3 – Test video

I used AVConv (part of the Libav library) to compile the MP4 videos. This is an alternative to using FFmpeg. This can be done on the Pi but it is much faster on the PC.

To get a quick feel for the video and decide on a frame rate I created an initial video using :

avconv -r 5 -i timelapse_%04d.jpg
       -r 5 -vcodec libx264 -crf 20 -g 2
       -vf crop=2592:1458,scale=1280:720 timelapse.mp4

Step 4 – Final Video

Once I decided the frame rate was OK it was time to re-render the video. This time I added the additional options to the AVConv command to overlay the logo on top of the video :

avconv -r 5 -i timelapse_%04d.jpg
       -r 5 -vcodec libx264 -crf 20 -g 2
       -vf "movie=watermark.png [watermark];[in] crop=2592:1458,
            scale=1280:720 [cropped],[cropped][watermark]
            overlay=20:20 [out]" timelapse_logo.mp4

Here is the final video complete with a brief rainbow and rain splattered window :

We can use the “raspistill” utility to take a set of time lapsed photos as described in my Taking Hi-Res Photos With The Pi Camera Module article. Make sure you have installed the camera and updated your operating system.

Step 1 – Taking the time-lapsed photos

This command will take a photo every 60 seconds (60000 milliseconds) for 2 hours (7200000 milliseconds) resulting in a sequence of 120 images.

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

The “%04d” will result in a four digit number appearing in each filename.

myimage_0001.jpg
myimage_0002.jpg
...
myimage_0119.jpg
myimage_0120.jpg

Step 2 – Combine images into MP4 video

Once you’ve got your image sequence you will need a method to stitch them together. I decided to use “avconv”. You can install this useful library with the following command :

sudo apt-get -y install libav-tools

To construct the video file from your image sequence you use the command shown below. Although it appears on multiple lines for readability it should be entered as a single line on the command line :

avconv -r 10 -i myimage_%04d.jpg 
       -r 10 -vcodec libx264 -crf 20 -g 15
       timelapse.mp4

The video will be the full resolution of the default image size (2592×1944).

To crop the images and create a more standard 1280×720 resolution video you can use the following command :

avconv -r 10 -i timelapse_%04d.jpg
       -r 10 -vcodec libx264 -crf 20 -g 15
       -vf crop=2592:1458,scale=1280:720
       timelapse.mp4

The “vf” option defines a video filter. In this case two filters which crop the incoming image to 2592×1458 and then scale them to 1280×720.

The “r” option tells avconv to create a video with a frames per second of 10. It appears twice to prevent avconv dropping frames that it thinks are similar.

The “crf” option tells avconv to aim for a quality level of “20″ which is a good starting point. Lowers values are better but will increase the file size.

The “-g” option sets the GOP value. The YouTube Advanced Encoding Settings page recommends that the GOP should be set to half the frame rate so this is set to 15.

The conversion process is very slow on the Pi compared to doing the same thing on a desktop PC. For long sequences with hundreds of frames I would recommend downloading an appropriate version of Libav on your desktop or laptop and build your MP4 files much faster!

Results

Here is a quick-n-dirty timelapse video I took out the window of my man-cave. It consists of 600 frames which were taken at a rate of 1 per minute for 10 hours. Nothing much happened in those 10 hours but it proved the Pi could do the job and that avconv could create the MP4. I got a PC to do the hard work!

When I’ve got the time I am going to make some more interesting timelapse videos. But that is for another day. Hopefully with better weather …

To capture video you can use the “raspivid” utility. This should be available on the Pi assuming you followed my Installing The Raspberry Pi Camera Module guide and upgraded your operating system.

I would recommend you use an 8GB or larger SD card as you will find the space useful once you start capturing video. Use the following command to check how much space you’ve got available :

df -h

This gives you something looking this example from my 8GB SD card :

pi@raspberrypi ~ $ df -h
Filesystem      Size  Used Avail Use% Mounted on
rootfs          7.3G  3.4G  3.6G  49% /
/dev/root       7.3G  3.4G  3.6G  49% /
devtmpfs        180M     0  180M   0% /dev
tmpfs            38M  228K   38M   1% /run
tmpfs           5.0M     0  5.0M   0% /run/lock
tmpfs            75M     0   75M   0% /run/shm
/dev/mmcblk0p1   56M   19M   38M  33% /boot

Here I’ve got over 3GB free which is enough for 30 mins for full HD video. With the default options you will need up to 115MB per minute of HD video.

Using “raspivid” is really easy and the following command will capture 5 seconds of footage :

raspivid -o myvid.h264

You want more than 5 seconds right? So you just add the “t” option and specify a time :

raspivid -o myvid.h264 -t 60000

This will give you 60 seconds (60000 milliseconds) of video. The default resolution is 1920×1080 with a bitrate of 17Mbs giving files of 115MB per minute. To change the video resolution to 1280×720 you can use :

raspivid -o myvid.h264 -w 1280 -h 720

and to set a custom bitrate you can use :

raspivid -o myvid.h264 -w 1280 -h 720 -b 8000000

where “8000000″ is a bitrate of 8000Kbs (kilo bits per second) or 8Mb (8 mega bits per second). The default is usually 17000000. There is no right or wrong answer when it comes to bitrates. You have to experiment and decide what gives you an acceptable result.

As with capturing stills using raspistill there are a number of other advanced options you can use.

-?,   --help        : This help information
-w,   --width       : Set image width <size>. Default 1920
-h,   --height      : Set image height <size>. Default 1080
-b,   --bitrate     : Set bitrate. Use bits per second
                      (e.g. 10MBits/s would be -b 10000000)
-o,   --output      : Output filename <filename>
-v,   --verbose     : Output verbose information during run
-t,   --timeout     : Duration of video (in ms)
-d,   --demo        : Demo mode(cycle through range of camera
                      options, no capture)
-fps, --framerate   : Specify the frames per second to record
-e,   --penc        : Display preview image *after* encoding
                      (shows compression artifacts)
-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
-ev, --ev           : Set EV compensation
-ex, --exposure     : Set exposure mode (see Notes)
-awb, --awb         : Set AWB mode (see Notes)
-ifx, --imxfx       : Set image effect (see Notes)
-cfx, --colfx       : Set colour effect (U:V)
-mm, --metering     : Set metering mode (see Notes)
-rot, --rotation    : Set image rotation (0, 90, 180, 270)
-hf, --hflip        : Set horizontal flip
-vf, --vflip        : Set vertical flip

Additional values that can be supplied for Exposure, Auto White Balance and Image Effects are shown below :

Exposure  mode options  :   
off,auto,night,nightpreview,backlight,spotlight,sports,snow,beach,
verylong,fixedfps,antishake,fireworks   

AWB mode options :   
off,auto,sun,cloud,shade,tungsten,fluorescent,incandescent,
flash,horizon   

Image  Effect mode options :   
none,negative,solarise,sketch,denoise,emboss,oilpaint,h atch,
gpen,pastel,watercolour,film,blur,saturation,colourswap,washedout,
posterise,colourpoint,colourbalance,cartoon  

Metering Mode options  :   
average,spot,backlit,matrix

You may need to flip and rotate your video depending on how you’ve mounted the camera module.

To list all available options you can type :

raspivid | less

Convert Raw H264 Video Data To MP4

The Pi captures video as a raw H264 video stream. This is great but many media players will refuse to play it unless it is “wrapped” in a suitable container format. Luckily it is easy to wrap the data and produce a standard MP4 video file which should play in most media players. To do this wrapping we will use MP4Box which you can install using :

sudo apt-get update
sudo apt-get install -y gpac

Once installed you can then use the following command to wrap your H264 video data in an MP4 container file. This will allow most media players to play the video.

MP4Box -fps 30 -add myvid.h264 myvid.mp4

This will give you a nice video at 30 frames per second that should play in most modern media players.

Creating an MP4 File Using AVCONV

It should also be possible to do this wrapping with AVCONV (an alternative to ffmpeg) but I didn’t have much luck with this method. It creates MP4 files but these weren’t recognised in most of my mediaplayers and when they were I had issues skipping through them. Here are the details for reference :

Install using :

sudo apt-get install -y libav-tool

Use this command to wrap data into MP4 container :

avconv -r 30 -i myvid.h264 -vcodec copy myvid.mp4

“-r 30″ sets the frame rate which should be the same as the rate you used to capture the data. “-i myvid.h264″ defines the input file. “-vcodec copy” makes it clear we do not want to re-encode or convert the data. “myvid.mp4″ is the new output file.

Playing Video Files With OMXPlayer

In order to play your newly created MP4 files you can use OMXPlayer. This is installed by default on the latest Raspbian distribution but you can install manually using :

sudo apt-get -y install omxplayer

To play a video file you can use :

omxplayer myvid.mp4

To send audio via HDMI you can use :

omxplayer -p -o hdmi myvid.mp4

… but at this stage your video is unlikely to have any audio!

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 (2 x 60 x 60 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.