Recently, I bought a camera module for the Raspberry Pi and experimented a little bit with the possibilities a scriptable camera provides. The new Camera Module V2 offers 8.08 MP from a Sony sensor and can be controlled with a well documented Python library. It allows to take HD videos and shoot still images. Assembly is easy, but as the camera is attached with a rather short ribbon cable, which renders the handling is a bit cumbersome. For the moment, a modified extra hand from my soldering kit acts as a makeshift.
The initial setup is easy and just requires a few steps, which is not surprising because most of the documentation is targeted to kids in order to encourage their inner nerd. Still works for me as well 🙂
Attach the cable to the raspberry pi as described here. You can also buy an adapter for the Pi Zero. Once the camera is wired to the board, activate the module with the tool raspi-config.
Then you are ready to install the Python library with sudo apt-get install python3-picamera, add your user to the video group with usermod -a -G video USERNAME and then reboot the Raspberry. After you logged in again, you can start taking still images with the simple command raspistill -o output.jpg. You can find some more documentation and usage examples here.
What I really enjoy is making timelapse videos with the Raspberry Pi, which gives a nice effect for everyday phenomena and allows to observe processes which are usually too slow to follow. The following Gif shows a melting ice cube. I took one picture every five seconds.
The following script creates a series of pictures with a defined interval and stores all images with a filename indicating the time of shooting in a folder. It is rather self explanatory. The camera needs a little bit of time to adjust, so we set the adjustTime variable to 5 seconds. Then we take a picture every 300 seconds, each image has a resolution of 1024×768 pixels.
import os import time import picamera from datetime import datetime # Grab the current datetime which will be used to generate dynamic folder names d = datetime.now() initYear = "%04d" % (d.year) initMonth = "%02d" % (d.month) initDate = "%02d" % (d.day) initHour = "%02d" % (d.hour) initMins = "%02d" % (d.minute) initSecs = "%02d" % (d.second) folderToSave = "timelapse_" + str(initYear) + str(initMonth) + str(initDate) +"_"+ str(initHour) + str(initMins) os.mkdir(folderToSave) # Set the initial serial for saved images to 1 fileSerial = 1 # Create and configure the camera adjustTime=5 pauseBetweenShots=300 # Create and configure the camera with picamera.PiCamera() as camera: camera.resolution = (1024, 768) #camera.exposure_compensation = 5 # Start the preview and give the camera a couple of seconds to adjust camera.start_preview() try: time.sleep(adjustTime) start = time.time() while True: d = datetime.now() # Set FileSerialNumber to 000X using four digits fileSerialNumber = "%04d" % (fileSerial) # Capture the CURRENT time (not start time as set above) to insert into each capture image filename hour = "%02d" % (d.hour) mins = "%02d" % (d.minute) secs = "%02d" % (d.second) camera.capture(str(folderToSave) + "/" + str(fileSerialNumber) + "_" + str(hour) + str(mins) + str(secs) + ".jpg") # Increment the fileSerial fileSerial += 1 time.sleep(pauseBetweenShots) except KeyboardInterrupt: print ('interrupted!') # Stop the preview and close the camera camera.stop_preview() finish = time.time() print("Captured %d images in %d seconds" % (fileSerial,finish - start))
This script then can run unattended and it creates a batch of images on the Raspberry Pi.
The file name preserves the time of the shot, so that we can see later when a picture was taken. But the tool also stores EXIF metadata, which can be used for processing. You can view the data with the exiftool.
ExifTool Version Number : 9.46 File Name : 1052.jpg Directory : . File Size : 483 kB File Modification Date/Time : 2016:07:08 08:49:52+02:00 File Access Date/Time : 2016:07:08 09:19:14+02:00 File Inode Change Date/Time : 2016:07:08 09:17:52+02:00 File Permissions : rw-r--r-- File Type : JPEG MIME Type : image/jpeg Exif Byte Order : Big-endian (Motorola, MM) Make : RaspberryPi Camera Model Name : RP_b'imx219' X Resolution : 72 Y Resolution : 72 Resolution Unit : inches Modify Date : 2016:07:05 08:37:33 Y Cb Cr Positioning : Centered Exposure Time : 1/772 F Number : 2.0 Exposure Program : Aperture-priority AE ISO : 50 Exif Version : 0220 Date/Time Original : 2016:07:05 08:37:33 Create Date : 2016:07:05 08:37:33 Components Configuration : Y, Cb, Cr, - Shutter Speed Value : 1/772 Aperture Value : 2.0 Brightness Value : 2.99 Max Aperture Value : 2.0 Metering Mode : Center-weighted average Flash : No Flash Focal Length : 3.0 mm Maker Note Unknown Text : (Binary data 332 bytes, use -b option to extract) Flashpix Version : 0100 Color Space : sRGB Exif Image Width : 1024 Exif Image Height : 768 Interoperability Index : R98 - DCF basic file (sRGB) Exposure Mode : Auto White Balance : Auto Compression : JPEG (old-style) Thumbnail Offset : 1054 Thumbnail Length : 24576 Image Width : 1024 Image Height : 768 Encoding Process : Baseline DCT, Huffman coding Bits Per Sample : 8 Color Components : 3 Y Cb Cr Sub Sampling : YCbCr4:2:0 (2 2) Aperture : 2.0 Image Size : 1024x768 Shutter Speed : 1/772 Thumbnail Image : (Binary data 24576 bytes, use -b option to extract) Focal Length : 3.0 mm Light Value : 12.6
The Raspberry Pi would need a lot of time to create an animated Gif or a video from these images. This is why I decided to add new images automatically to a Git repository on Github and fetch the results on my Desktop PC. I created a new Git repository and adapted the script shown above to store the images within the folder of the repository. I then use the following script to add and push the images to Github using a cronjob.
cd /home/stefan/Github/Timelapses now=$(date +"%m_%d_%Y %H %M %S") echo $now git pull git add *.jpg git commit -am "New pictures added $now" git push
You can add this to you user’s cron table with crontab -e and the following line, which adds the images every 5 minutes,
*/5 * * * * /home/stefan/Github/Timelapses/addToGit.sh
On a more potent machine, you can clone the repository and pull the new images like this:
cd /home/stefan-srv/Github/Timelapses now=$(date +"%m_%d_%Y %H %M %S") echo "$now" git pull --rebase
The file names are convenient for being able to read the date when it was taken, but most of the Linux tools require the files to be named within a sequence. The following code snippet renames the files into a sequence with four digits and pads them with zeros if possible.
a=1 for i in *.jpg; do new=$(printf "%04d.jpg" "$a") #04 pad to length of 4 mv -- "$i" "$new" let a=a+1 done
Imagemagick offers a set of great tools for images processing. With its submodule convert, you can create animated Gifs from a series of images like this:
convert -delay 10 -loop 0 *.jpg Output.gif
This adds a delay after each images and loops the gif images infinitely. ImageMagick requires a lot of RAM for larger Gif images and does not handle memory allocation well, but the results are still nice. Note that the files get very large, so a smaller resolution might be more practical.
Still Images to Videos
The still images can also be converted in videos. Use the following command to create an image with 10 frames per second:
avconv -framerate 10 -f image2 -i %04d.jpg -c:v h264 -crf 1 out.mov
Example: Nordkette at Innsbruck, Tirol
This timelapse video of the Inn Valley Range in the north of the city of Innsbruck has been created by taking a picture with a Raspberry Pi Camera Module V2 every 5 minutes. This video consists of 1066 still images.