DIY Photo Frame: Pictures Powered by Pi

Published: 2024-11-02 | By: Tyler Talaga Author

Overview

Imagine transforming a Raspberry Pi into your own custom digital photo frame that seamlessly syncs with your Google Photos album. This guide will walk you through building just that—a project I originally tackled as a Christmas gift last year.

With a bit of Python, Kivy, and some creative spirit, you’ll convert a small touchscreen monitor and a Raspberry Pi into a dynamic, ever-updated picture frame. Don’t worry—this project is simpler than it sounds. I’ll guide you step-by-step, with plenty of room for customization to make it uniquely yours.

well_alright

Key Features

This frame isn’t just about showcasing photos. Here’s what makes it stand out:

  • Interactive UI: Built with Kivy, this touchscreen interface is as intuitive as it is interactive, letting you navigate photos easily.
  • Weather and Time Display: Adds a touch of practicality by showing the current weather and time alongside your photos.
  • Automatic Updates: Regularly syncs new photos and tidies up old ones, keeping your display fresh and relevant.

Hardware

To get started, you’ll need a few pieces of hardware. Don’t worry if you’re new to this—everything here is easy to find, and I’ll provide some links to help.

  • Raspberry Pi: A Raspberry Pi 4 Model B is recommended for its performance.
  • Touchscreen Monitor: A small touchscreen monitor (e.g., a 7- or 10-inch display) is ideal (like this one).
  • MicroSD Card: At least 16GB, preloaded with Raspberry Pi OS.
  • Power Supply: A power adapter (preferably USB-C and one with a switch) for the Raspberry Pi (like this one).
  • Raspberry Pi Case (Optional): An appropriate case for both the Raspberry Pi and monitor to keep everything tidy (exhibit A).
  • Mounting Screws (Optional): If you’re using a case, you'll need longer mounting screws to attach the Raspberry Pi to the monitor (like these).

Software

1. Clone the Repository

First, let’s clone the GitHub repository, which contains all the scripts and configuration files you’ll need:

git clone https://github.com/tyler-tee/Digital-Photo-Frame.git
cd Digital-Photo-Frame

This will download the project and navigate into the project directory, where you’ll manage everything from here on out.

2. Install Python and Prerequisites

Next, make sure Python 3.9 or later is installed on your Raspberry Pi. Then, install the required dependencies:

pip install -r requirements.txt

3. Configure Google Photos API Access

To use Google Photos with your digital photo frame, you need to set up access using the Google Photos API. Here’s how:

  1. Enable the Google Photos API:

  2. Go to the Google API Console.

  3. Select your existing project or create a new one.
  4. From the menu, select APIs & Services > Library.

  5. Search for "Google Photos" and click Enable.

  6. Create OAuth 2.0 Credentials:

  7. In the Google API Console, navigate to APIs & Services > Credentials.

  8. Click Create Credentials > OAuth client ID.
  9. You may be prompted to configure your consent screen—follow the instructions provided.
  10. Choose Web application as the application type and enter a name.
  11. Under Authorized redirect URIs, add the URIs that will handle the OAuth flow for your app.

  12. Once created, you will get a Client ID and Client secret—save these securely as they will be needed to authenticate your app.

  13. Save Credentials:

  14. Save your credentials in a file named client_secret.json in the /scripts folder. This will allow your application to authenticate and sync photos from your Google Photos library.

For more detailed guidance, check out Google’s official documentation.

4. Find Your Google Photos Album ID

Next, you'll need the ID of the Google Photos album you want to display. This ID is unique to each album and is used to fetch photos from the correct source.

Google doesn't make finding this ID easy, but I've included a script to help.

Run album_identifier.py and select your album:

$ python album_identifier.py
Please visit this URL to authorize this application: https://accounts.google.com/o/oauth2/auth?response_type={redacted}&access_type=offline 

Albums found:
1. Christmas - Dad

Enter the number of the album to retrieve its ID: 1

The ID for the album 'Christmas - Dad' is: {album ID here}
Do you want to save this album ID to config.json? (yes/y to confirm): y
Album ID successfully updated in config.json.

5. Take it for a Spin

Now that all of the nuts and bolts are in place, it’s time to see your app in action. Run the run_photo_display.py script to start the display:

$ python run_photo_display.py

first_run

Photos as a Service

Next, let’s set the app up as a local service. This will ensure the photo frame runs automatically when the Raspberry Pi boots up, so you (and your recipient) won't have to worry about manually starting it each time.

wake_up

Here’s a look at the systemd service file (found in services/run_photo_display.service):

[Unit]
Description=Digital Photo Frame
After=network.target

[Service]
ExecStart=/usr/bin/python3 /path/to/run_photo_display.py
WorkingDirectory=/path/to/
StandardOutput=inherit
StandardError=inherit
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

This configuration ensures your primary script starts after network services are available, runs under the pi user, and automatically restarts if there’s an issue.

  1. Copy services/run_photo_display.service to the systemd directory:
sudo cp services/run_photo_display.service /etc/systemd/system/
  1. Enable the service to run on startup:
sudo systemctl enable run_photo_display.service
  1. Start the service:
sudo systemctl start run_photo_display.service

Assemble!

With the brains in place, it’s finally time to put the bits and bobs together. Setting up the hardware is straightforward, and before long you'll be looking at a finished product.

assembly

  1. Optional – Assemble Your Raspberry Pi Case: If you purchased a case for the Raspberry Pi, now is the time to put it together.
  2. Attach the Pi and/or Case to the Monitor: Attach your assembly to the monitor using provided hardware.
  3. NOTE: If you're attaching a case, you'll probably need longer m2.5 mounting screws (mine turned out to be m2.5x8mm).
  4. Connect the Monitor: Connect the touchscreen monitor to the Raspberry Pi using the supplied

HDMI cable and power connector. 4. Power Up: Connect your power supply, ensuring all connections are secure before turning it on.

dpf-back

Final Touches

Congratulations—you’ve built your very own digital photo frame! Not only is it a unique, heartfelt gift, but it’s also something that can keep evolving. Add new albums, redesign the interface, or introduce new interactive features. The possibilities are endless, so feel free to fork the repo and make it your own.

dpf-front