{"id":1971,"date":"2015-02-15T21:39:34","date_gmt":"2015-02-16T02:39:34","guid":{"rendered":"http:\/\/protofusion.org\/wordpress\/?p=1971"},"modified":"2015-02-15T21:39:34","modified_gmt":"2015-02-16T02:39:34","slug":"low-cost-diy-photobooth","status":"publish","type":"post","link":"http:\/\/protofusion.org\/wordpress\/2015\/02\/low-cost-diy-photobooth\/","title":{"rendered":"Low Cost DIY Photobooth"},"content":{"rendered":"
\"Sample<\/a>

Sample photobooth photostrips<\/p><\/div>\n

Photobooths are popular at many types of social events, including weddings, birthday parties, and school dances. However, renting one can easily cost upwards of $1000, making them impractical for many events. So when a friend mentioned wanting one for her wedding, I jumped at the opportunity to build a low-cost DIY photobooth.<\/p>\n

To make my photobooth cost-efficient, I decided to use a thermal receipt printer to print out black and white photo strips, which eliminates the need for an expensive photo printer and photo paper\/ink. I also added Twitter integration so the photobooth can tweet out every photo strip it takes, and a QR code generator that prints a link to the corresponding Twitter post on each photo strip.<\/p>\n

The BeagleBone Black single-board computer seemed like a perfect match to power this project, and I decided to script everything in Python to keep it simple. Gphoto2 provides the camera interface, CUPS handles the printing, and Python libraries take care of everything else.<\/p>\n

Lets get into the details of how this thing works.<\/p>\n

<\/p>\n

Electronics<\/h2>\n
\"BeagleBone<\/a>

BeagleBone Black<\/p><\/div>\n

The BeagleBone Black will boot up into a usable state without any setup required. However, I found that some gPhoto2 functions did not work with the Debian install that came preloaded on my BBB. To solve this issue, I switched to Arch Linux ARM. Instructions on installing Arch on the BeagleBone can be found here<\/a>.<\/p>\n

The basic features I wanted the photobooth to have are user input to start a photo sequence, camera control to take pictures, Twitter communication to tweet photos, and support for printing the final product. Thankfully each of these features is relatively easy to implement with Python.<\/p>\n

I used Python 3<\/a> to allow support for some newer Python libraries. Unfortunately, this eliminated the possibility of using Adafruit\u2019s Python GPIO library, which is only compatible with Python 2. Instead, I used the manual approach of exporting the GPIO pins to files in the \/sys\/class\/gpio\/ directory and reading the pin status values from the files. In Python, it looks a little something like this:<\/p>\n

\r\nimport io\r\n\r\n# export pin 7\r\nf = open('\/sys\/class\/gpio\/export', 'w')\r\nf.write('7')\r\nf.close()\r\n\r\n# define pin 7 direction as input\r\nf = open('\/sys\/class\/gpio\/gpio7\/direction', 'w')\r\nf.write('in')\r\nf.close()\r\n\r\n# read pin 7 status\r\nf = open('\/sys\/class\/gpio\/gpio7\/value', 'r')\r\nstatus = f.read()\r\nif("1" in status):\r\n    # do something\r\nelif("0" in status):\r\n    # do something else\r\nf.close()\r\n\r\n# unexport pin 7\r\nf = open('\/sys\/class\/gpio\/unexport', 'w')\r\nf.write('7')\r\nf.close()\r\n<\/pre>\n
The GPIO pins can be used to capture button presses and trigger the photo sequence.<\/p>\n
The primary function of a photobooth is to take pictures, so if nothing else we\u2019re going to have a camera in the setup. The Gphoto2<\/a> library takes care of camera integration and simplifies it down to just a few commands. The library supports thousands of camera models, so chances are your camera will work. A list of supported cameras can be found here<\/a>. Since I wanted to take 4 pictures in a row with even spacing and immediately download the pictures, I used the following command and arguments:<\/p>\n
gphoto2 --capture-image-and-download --interval=3 --frames=4 --filename \/tmp\/portrait%n.jpg --force-overwrite<\/code><\/p>\n
The arguments can be modified to fit various needs—for example, saving the photos on the camera’s internal memory after they have been downloaded.<\/p>\n
I wanted to display live view from the camera on a monitor that would allow users to see themselves as they pose for pictures, but I wasn’t able to get this working. Gphoto2 seems to turn off live view on my camera after the first picture is taken, and it won\u2019t come back on until the camera is power-cycled. I will be working to find a solution for this issue in the future, possibly by streaming the live view video to the BBB and displaying it from there, or by replacing the camera with a high-def web cam, but until then I will live without it.<\/p>\n
To give the user feedback when each picture is taken (in the absence of live view), I decided to turn on the camera flash, even though using the built in flash is less than optimal. Without this feedback, it is difficult to tell when each picture is being taken and when the set is finished. To minimize the blinding effect a bright flash tends to have, I turned down the flash brightness to around a 16th of its usual strength.<\/p>\n
Because a photobooth tends to be fairly dark, and since I wasn\u2019t relying on the flash for full lighting, I added some extra lighting to the setup. I decided to use Protofusion\u2019s Luma lighting system<\/a> to give me flexible control over the lighting through the BeagleBone Black. This allowed me to easily set the lighting levels and give some additional feedback regarding program state or errors by flashing the lights different colors. Using the Luma LED Strip Driver and an LED strip, I was able to string lighting around the top of the booth and light it with a soft, distributed light. In the absence of such a high tech lighting system, any standard light source could be used. If the light source tends to be direct and harsh, I would recommend some type of diffuser to distribute and soften it out a bit.<\/p>\n
\"DYMO<\/a>
DYMO 400 Printer<\/p><\/div>\n
I picked the Dymo 400 Labelwriter<\/a> to print the photo strips because I could find it on eBay for pretty cheap, and it seemed widely used and supported. To use it with the BBB, I installed the CUPS printing system and found the Dymo driver in the Arch User Repository (I recommend Packer<\/a> for installing packages from the AUR). Here is a good tutorial on\u00a0installing and configuring CUPS<\/a>.<\/p>\n
To make the Dymo 400 print the way I wanted, I had to make a few tweaks. When I chose the \u201cContinuous Feed\u201d paper option in CUPS, it would print a large margin at the top of strip, so I tried setting a custom paper size. No matter what custom paper size I set, the printer would always print out the strip, and then print out an equal amount of blank paper. There may be a solution to this, but I was unable to find it. So the work around I used was to manually change the default printing settings for the printer, by going through the printer configuration file and changing the printable area for the “Continuous Feed” paper option. The modified file can be found below.<\/p>\n
To format the individual photos into one photo strip, along with some text and a QR code at the bottom, I chose the ImageMagick<\/a> command line image editing tool. I used the convert -append command to assemble all the photos into one image. The one problem I found here was that the large photos taken by the camera were too large for the program to combine into one with the limited RAM on the BeagleBone. Instead, I resized each of the photos and then assembled the smaller images. Since the Dymo 400 printer has a printable width of 672 pixels, I converted all the images down to that size. Here is the sequence of commands I used to assemble a photo strip:<\/code><\/p>\n
# resize each of the pictures and add a border to make them go together nicely
\nconvert \/tmp\/portrait1.jpg -sample 26% -bordercolor '#FFFFFF' -border 2x20 \/tmp\/portrait1.jpg
\nconvert \/tmp\/portrait2.jpg -sample 26% -bordercolor '#FFFFFF' -border 2x20 \/tmp\/portrait2.jpg
\nconvert \/tmp\/portrait3.jpg -sample 26% -bordercolor '#FFFFFF' -border 2x20 \/tmp\/portrait3.jpg
\nconvert \/tmp\/portrait4.jpg -sample 26% -bordercolor '#FFFFFF' -border 2x20 \/tmp\/portrait4.jpg
\n# put the pictures all together and add the protofusion logo
\n# this is the version I tweeted
\nconvert -append \/tmp\/portrait1.jpg \/tmp\/portrait2.jpg \/tmp\/portrait3.jpg \/tmp\/portrait4.jpg \/root\/protofusion.jpg \/tmp\/twitter.jpg
\n# resize the QR code
\nconvert \/tmp\/qrcode.jpg -sample x245 \/tmp\/qrcode.jpg
\n# add the QR code and some text together horizontally
\nconvert +append \/tmp\/qrcode.jpg \/root\/photoboothtext.jpg \/tmp\/qrblock.jpg
\n# add the QR code and text to the photo strip
\n# this is the version I printed
\nconvert -append \/tmp\/twitter.jpg \/tmp\/qrblock.jpg \/tmp\/print.jpg
\n<\/code><\/p>\n
In order to Tweet photos, the photobooth needs to be connected to the internet. I used a TP-LINK TL-WN722N<\/a> wifi dongle I had laying around, but any of the adapters on this list<\/a> as well as many others should work well. The Arch Wiki<\/a> details the steps for connecting to a wifi network in Arch Linux.<\/p>\n
Twitter integration adds a fun twist to the traditional photobooth. I used the twython<\/a> Python Twitter API wrapper, which simplified many of the steps. The only tricky part is authenticating through Twitter\u2019s three step authentication process.\u00a0 I haven’t yet added authentication support to my script, so I just manually hard-coded in the generated keys needed. I hope to add Twitter authentication to the next iteration, and will write about that when I finish it.<\/p>\n
To give users an easy way to find their tweeted photos, I used a Python QR code generator called qrcode<\/a> that generates a QR code with a link to the posted image. The generator takes the link returned by the Twitter API and spits out a QR code which is saved and appended to the photo strip. I also added some custom text next to the QR code to explain what the QR code links to.<\/p>\n
You can find my Python code here: photobooth.zip<\/a>
\nYou can find the cups printer config file I used here: printer_config.zip<\/a><\/p>\n
Here is a list of the tasks (detailed above) that need to be completed to set up the full system:<\/p>\n