I had recently purchased a camera module for the Raspberry Pi, mainly just out of curiosity, and a desire to learn how to use it. In the back of my mind I had been working on an idea to build a birdhouse and use a Pi to film the birds, but I was currently working on several other projects, so I was in no hurry to start a new one. One evening I was working at my desk in my shop, and I heard some chirping outside the window. I pulled back the curtain to find a Carolina Wren's nest with baby chicks inside chirping away. How fortuitous. Suddenly my project to film birds with the Pi moved to the front of the list. With little knowledge of how to use the camera, I bent a piece of 12awg copper wire into a makeshift camera stand, hooked it up to the Pi, and set it in the window. A quick Google search told me that I could enable the camera module using the raspi-config menu, and then operate the camera from the command line using the following commands for pictures and video respectively:raspistill -o birdpic.jpg
The above command takes an 8 megapixel image and outputs it to a file named birdpic.jpg.
raspivid -o birdvid.h264 -t 10000
The above command takes a video and outputs it to a file named birdvid.h264. The -t specifies the length of the video in miliseconds, so -t 10000 takes a 10 second video.
It worked. I sat there for a little while amusing myself taking video of the birds every time they started chirping, because that usually meant that it was feeding time. The video through the window was decent, and I managed to edit together a short video.
It turns out, as to be expected, the Raspberry Pi Camera Python module is located in the Raspbian repositories, so it can be installed with a quick:
sudo apt-get install python-picamera
I don't want to get too in-depth on how to use this module, so I will just point you to Raspberrypi.org's documentation here. The code is simple. All I am going to do is to monitor the GPIO pin that the motion sensor is connected to. When motion is detected I am going to start recording. After 10 seconds, I am going to check the motion sensor again. If there is no motion, then the clip is over. If there is still motion after 10 seconds then it will wait another 10 seconds and check again. This results in a minimum size clip of 10 seconds, with no maximum size as long as motion continues. To prevent video files from overwriting each other, each clip will contain a time-stamp in the file name. I could have gone a little more advanced with the code, but I was in a hurry to get this up and running, so I kept it simple. Here's the code if anyone would like to use it:
#!/usr/bin/env python
import RPi.GPIO as GPIO
import picamera
import time
MOTION_PIN = 4
camera = picamera.PiCamera()
GPIO.setmode(GPIO.BCM)
GPIO.setup(MOTION_PIN, GPIO.IN)
def take_video():
timestamp = time.strftime("%y-%m-%d-%H-%M-%S")
print 'recording started' # for troubleshooting only
camera.start_recording('vid%s.h264' % timestamp)
camera.wait_recording(10)
while GPIO.input(MOTION_PIN):
camera.wait_recording(10)
camera.stop_recording()
print 'recording stopped' # for troubleshooting only
# Begining of Program
time.sleep(2)
while True:
print 'waiting for motion' # for troubleshooting only
GPIO.wait_for_edge(MOTION_PIN, GPIO.RISING)
print 'motion detected' # for troubleshooting only
take_video()
As always, we need to make the file executable using sudo chmod +x /home/pi/motion-vid.py. I want to have this script run on start-up, so we need to add this file to the /etc/rc.local file, but before we do that, we need to think about the USB flash drive that we are using to store the video. When a USB drive is inserted into the Raspberry Pi, it is not automatically mounted as it is in many other operating systems, so we need to make sure that the Pi also mounts the USB drive on start-up. To do this, we must first determine the name of the drive, and of the partition on the drive. Typically the first USB drive you insert in the Pi will be sda, but in the interest of being thorough we will double check just to be sure using the command ls /dev/sd*.
As you can see above, it returned two values. sda is the name of the drive itself, and sda1 is the name of the partition on the drive. We want to mount the partition. Next we need to look to see if we have a place to mount the drive. Navigate to /mnt using cd /mnt, and see if you have directories there. If not, create a directory named usb (the name is arbitrary) using the command sudo mkdir ./usb. We can now mount the usb drive using sudo mount /dev/sda1 /mnt/usb.
So now that we know how to do it, let's tell the Pi to mount the USB on boot and run the camera script. Open up the /etc/rc.local file using your text editor du jour (i.e. sudo vim /etc/rc.local)and add the following lines to the file:
# The following line mounts sda1 to /mnt/usb
sudo mount /dev/sda1 /mnt/usb
#The following lines runs the script that takes video based on a motion sensor
cd /mnt/usb
sudo /home/pi/motion-vid.py &
And that's it. I put the box on the windowsill next to the birds nest and plugged it in. The first day I got just under 400 video clips, which took up about 3.5 GB. That means with a 16 GB USB drive I would only need to swap out the drive every four days or so. At any time I could log into the Pi over wifi to make sure it was still working, and view any of the clips I chose. And of course, I had to make another bird montage:
And now for the sad conclusion of this project. After a little less than a week of watching the birds, and admittedly becoming a bit attached to the little guys, I was working in my shop when I heard a commotion at the window. I figured the birds were getting active, so I logged into the Pi and pulled down the last video clip. Horrified I watched as one of the neighbor's cats pounced onto the nest and pulled it, and the baby birds, off of the window ledge. C'est la vie. It is nature after all, and cats will be cats. I can't be happy they keep away the mice and snakes, and then fault them for eating the birds. It wasn't the smartest place for the Wrens to build a nest anyway, 2 feet off the ground. At least I got to watch them for a while, and it gave me a good starting point for this project.
So what did I learn, and what's next. Most importantly, next time I film baby birds they will be in a bird house where they will be better protected from predators. My code could also use a little bit of improvement, and next time I will probably just stream the video to a server instead of using the USB drive for storage. I am already working on a design for a bluebird house that will have an internal camera and an external camera, and will be able to conceal the electronics in a separate compartment from the birds. The biggest hurdle to overcome with that project will be powering two Pi Zeros and two cameras, but I'm sure I can come up with something. Until then, stay safe, and keep building.
to control the water flow. You can buy a plastic one cheaper, but I had reservations about connecting a plastic water valve to my plumbing. Basically all I needed to do was to connect a GPIO pin from the Pi to a relay that could then switch on/off the 12V power supply to the valve. I went with a 
since I already had plans for future projects that would require additional relays. I had a 12V / 30 amp power supply from previous projects on hand, which will provide more than enough current for this project, as well as anything I might need it for in the future. The only thing left to plan was a fuse for the power to the valve. For most people a simple in-line fuse holder would solve this problem, but I just so happened to have an old DC fuse panel lying around looking for a job to do, so I put it to use. Here is the schematic for the final design:
wired to a GPIO pin and a short Python script. I used a typical pull-up resistor configuration for the button. If you have never done this before use the diagram is to the right. The Python script will use the RPi.GPIO module to set edge detection on the GPIO pin, and then use a threaded callback function to initiate shutdown. To do the actual shutdown I will use the Python module os to interact directly with the operating system. The code is short and sweet. Feel free to copy or republish it. Here it is:
