Building an IoT Security Camera With Raspberry Pi and Render

Most of the smart camera control systems available on the market are black boxes that we put in our homes. We don’t really know what’s going on inside them or how they’re updated. While there might be some reliable vendors, we want to explore how to create our own smart camera control system. In doing so, we’ll understand the fundamentals of IoT and potentially evolve this into a fully-fledged product.

In this article, we will walk through how to create a smart camera control system to secure your room. We’ll cover the whole system and how to get it running:

• Hardware assembly

• Software (camera client, dashboard UI client, and server)

• Server deployment

Before we dive in, let’s give a brief overview of today’s IoT landscape.

The IoT Landscape

Just to get a sense of some typical business uses, let’s take a look at some example applications of IoT technologies.

Healthcare, Manufacturing, and Retail

These three fields all have great applications for IoT, and they are technologically quite similar. In these fields, IoT devices are typically used to track equipment and customer interactions with items being sold or that are key to providing specific services. This can be as complicated as an insulin regulation device regularly sending data about a patient or as simple as an Apple AirTag sending the position of a device to prevent theft. At the end of the day, the applications aren’t much different: a small, internet-connected device, that sends some data payload based on observations it has made about the world around it.

Logistics and Transportation

In the logistics and transportation fields, the goal is to make shipping and transport more efficient, cost-effective, and faster. IoT device usage centers around tracking the shipment of goods or automating a warehouse. Some clear examples include warehouse drones or robots, or a GPS tracker for trucks.

Smart Cities, Construction, and Manufacturing

Using IoT devices to better understand how people move in a city or interact with a building are some of the more advanced uses of this type of technology. Power companies may install IoT devices to report on peak electricity usage times per household. Cities may install IoT devices on traffic lights to determine better traffic flows or even adjust the timing of lights on the fly. A waste disposal company may put IoT trackers in garbage bins to understand how many people are using publicly accessible trash cans, to better place them and increase their usage.

Of course, there are many other applications. Today IoT is a normal part of our daily lives, even if we are not fully aware of how much it is used in the world.

IoT used to be complex. For professional applications, IoT continues to be complex, mainly because of the following reasons:

• Hardware: There are different groups of capable hardware, with the most common being microcontrollers, nodes, gateways, and protocol servers.

• Radio protocols: There are many of them, including WiFi, BLe, LoRaWAN, and SigFox.

• Over-the-air (OTA) update process: This is complex, but it is something you want to have if you are deploying thousands of devices in the field.

• Data visualization: Gathering a lot of data is useless if we cannot present it to our users.

• Security

However, IoT does not need to be complex, and there are tools that can simplify the development of basic applications. We can quickly create prototypes and to better understand possible solutions. And with the right amount of effort, we can solve some real-life problems.

Fortunately, very capable hardware is now cheaper than ever, and many modern IoT and SaaS companies have started simplifying the development and deployment of web applications, saving us time while also ensuring they are always available, simple to recreate, and require little to no maintenance costs.

In the hardware area, products like Arduino, NodeMCU, and Raspberry Pi have made getting started with IoT a process that no longer takes weeks or months but now can take just a matter of days.

Similarly, in the software field, companies like Amazon AWS, Google Cloud, Render, and Rancher have made the deployment of an IoT application an easy and fun process!

Now that we’ve laid down the fundamentals, let’s dive into our project.

Creating a Smart Camera Control to Secure Your Room

We’ll create a smart camera control system to secure any room in your house in a few steps:

1. The system takes a picture every time a motion is detected, for which we’ll use a motion detection module.

2. The picture is saved on a remote server.

3. Through a dashboard accessing the server, you can look at all the events, including the photo and a timestamp.

4. We’ll save the last 500 events and clean up all the older ones.

The High-Level Architecture

Below is a graphic that provides the general, high-level architecture of our entire system:

What Components Will We Need?

Hardware

• We’ll need a Raspberry Pi 4, a motion detection sensor, and a camera module, plus some more small hardware items available in the full Bill of Materials (BOM) below.

Software

• A Render.com account to deploy the server used for saving and showing the camera pictures.

• Git, python3, and a code editor.

The total cost of the hardware is around $120. The application should work with Raspberry Pi models with less RAM, which could save $20 or more. However, I did not test those models.

Configuring the Raspberry Pi

Step 1: Plug in your Raspberry Pi with a reliable power source. It’s best to use the official one indicated in the BOM. There was news of some old Raspberry Pi 4 models having issues with some USB-C cables and power supply configurations.

Step 2: Then, install the Raspberry Pi OS. The best guide and tools are available on the official site of Raspberry Pi OS. Please follow that guide if you do not have an OS already on your Raspberry Pi. You will use the SD card during this step.

Because this application does not require a graphical interface, you could install the Raspberry Pi OS Lite version (for experts only). However, if this is the first time you are developing with a Raspberry Pi, you’ll probably be happier if you pick the Raspberry Pi OS with the desktop (64-bit) version. 

Assembling the PIR Motion Sensor

Step 3: Next, we want to test the PIR Motion Sensor to detect movement in our room.

The sensor has three wires, two of them are for the power (+5V and ground), and the third one is for reading the value from the sensor. For our purposes, we will read 1 if the sensor detects a movement, and 0 otherwise. 

It is easy to see the pinout of our Raspberry by using the pinout command. For a full explanation of every pin, you can take a look at Pinout.xyz.

In our case, we want to use a black wire to connect the ground of the sensor to the ground of our board (PIN 6), a red wire to the +5V (PIN 2), and the signal wire to one of the GPIO (PIN 11).

Here are two pictures on how to assemble it:

Some more information is available on Projects | PIR Sensor | Raspberry Pi. If you do not know which cable is which, please remove the cap over the sensor, and check the label on the PCB.

Detecting a Movement

To detect a movement, we will need some piece of software that reads the values from the PIR and notifies us. A simple version of such an application is available in Python on GitHub.

from gpiozero import MotionSensor
from datetime import datetime
from signal import pause

pir = MotionSensor(17)

def capture():
timestamp = datetime.now().isoformat()
print('%s Detected movement' % timestamp)

def not_moving():
timestamp = datetime.now().isoformat()
print('%s All clear' % timestamp)

pir.when_motion = capture
pir.when_no_motion = not_moving

pause()

Just to clarify, we pass the value 17 to MotionSensor() because our motion detector is plugged into GPIO17 (even though, on the physical board, this corresponds to pin 11).

To start it, just run python pir_motion_sensor.py. I use it to tune the timing of the PIR. 

Indeed, there is a risk the sensor does not notify the system every time it detects a movement because there is an internal timer that prevents the system from continuously sending a movement signal (to avoid triggering an action too often). The timer is configurable using a potentiometer as described in the article Testing a PIR | PIR Motion Sensor | Adafruit Learning System.

The timer has a range of 0-255 seconds (255 is all clockwise, 0 is all counter-clockwise). From my experience, I suggest configuring the timer at about 7-10 seconds, so the potentiometer should be turned counterclockwise at an almost horizontal position. In a similar way, there is a sensitivity potentiometer, on which clockwise means more sensitive. 

The output of the command should be something like this:

pi@raspberrypi:~/raspberry-pi-security-camera-client $ python pir_motion_sensor.py

2022-04-21T15:35:35.275947 Detected movement
2022-04-21T15:35:41.607265 All clear

If you see a difference of about 6-7 seconds, then that’s about right. Otherwise, keep tuning the timing potentiometer until you reach the desired timing.

Adding the Camera

The next step is to ensure our camera is correctly assembled. Make sure to assemble it on the right side, or it will not work. Also, be sure to install it with the Raspberry Pi turned off and disconnected from any source of power. This is the best video I have found to walk through this process.

Once done, reboot your Raspberry Pi and ensure you have the new camera stack.

Open a console and type the following:

$ sudo raspi-config

Select the Interface Options menu.

Select Enable/Disable legacy camera support and be sure to disable it.

Finally, save and reboot again.

Picamera2 vs. Picamera

Picamera2 is the new Python port of libcamera. The old project, Picamera is extremely popular but was based on a different system. You can find more information on Bullseye camera system - Raspberry Pi and the official announcement of Picamera2 on a preview release of the Picamera2 library - Raspberry Pi.

Testing the Camera

To test the camera, I created a short script using Picamera2. Picamera2 installation is not trivial, because the project is still under preview. So, I prepared a git repo with all the instructions to install Picamera2 on your Raspberry Pi. You can follow the README.md file and then come back here (I’ll wait!). But, please do not run the main.py script yet. It’s best to verify the camera is set up correctly by running this file first:

$ python example_picamera2.py

The contents of example_picamera2.py are as follows:

from gpiozero import MotionSensor
from picamera2.picamera2 import *
from datetime import datetime
from signal import pause

pir = MotionSensor(17)
camera = Picamera2()
camera.start_preview(Preview.NULL)
config = camera.still_configuration()
camera.configure(config)

def capture():
camera.start()
timestamp = datetime.now().isoformat()
print('%s Detected movement' % timestamp)

metadata = camera.capture_file('/home/pi/%s.jpg' % timestamp)
print(metadata)
camera.stop()

def not_moving():
timestamp = datetime.now().isoformat()
print('%s All clear' % timestamp)

pir.when_motion = capture
pir.when_no_motion = not_moving

pause()

This file will take a snapshot every time the movement detection PIR sensor detects motion, and the image will be placed in the /home/pi directory with a name that is equal to the time of when the camera captured the image.

Here is the image my camera took:

If the script works, then congratulations! You are more than halfway through our project, and everything works locally.

But this is still not an IoT project—we are missing the I in IoT! We still need to make the project capable of being monitored remotely. We also need to guard against the situation where someone accesses our Raspberry Pi, removes the SD Card, and walks away with the recorded image documenting the infringement of our property.

Writing the Client Code and Testing Locally

We are now ready to complete the client software logic that does the following:

1. Set up the camera with Picamera2.

2. Initialize the motion sensor.

3. When a movement is detected, read the event and call a function that:

   1. Captures an image and saves it to a file on the local filesystem.

   2. Uploads the image to a remote server.

   3. Removes the local file if uploaded correctly, to avoid filling up all the space on the Raspberry Pi.

4. When motion is no longer detected after a timeout (6-7 seconds in our case), read the event and print the timestamp with an "All clear" message.

5. Wait for the next event.

This is how the high-level code will look:

def init(settings):
    camera = setup_camera()
    pir = MotionSensor(settings.get('PIR_GPIO'))
    pir.when_motion = picture_when_motion(pir, camera, settings)
    pir.when_no_motion = not_moving
    pause()

The most complex function is picture_when_motion. Usually, when_motion accepts a callback that cannot have any other argument, but reading the documentation carefully shows the following:

when_motion

The function to run when the device changes state from inactive to active.

This can be set to a function that accepts no (mandatory) parameters, or a Python function that accepts a single mandatory parameter (with as many optional parameters as you like).

So I converted it to a function, creating a callback and returning it.

def picture_when_motion(pir, camera, settings):
    setup_path(settings.get('IMG_PATH'))
    def capture_and_upload_picture():
        if camera:
            file_path = capture(camera, settings.get('IMG_PATH'))
            server_settings = settings.get('SERVER')
            uploaded = upload_picture(file_path, server_settings)
            if uploaded:
                cleanup(file_path)
        else:
            print("Camera not defined")
    return capture_and_upload_picture

def upload_picture(file_path, server_settings):
if server_settings.get('base_url'):
url = urljoin(server_settings.get('base_url'), 'upload')
if server_settings.get('user') and server_settings.get('password'):
user = server_settings.get('user')
password = server_settings.get('password')
files = {'file': open(file_path, 'rb')}
print('Uploading file %s to URL: %s' %(file_path, url))
try:
r = requests.post(url, files=files, auth=HTTPBasicAuth(user, password))
image_path = r.json().get('path')
except e:
print(e)
if not image_path or not r.ok:
print('Error uploading image')
return False
print('Image available at: {}'.format(image_path))
return True

curl \
-F "file=@/home/user/Desktop/test.jpg" \
http://localhost:5000/upload

def upload_file():
    if request.method == 'POST':
        # check if the post request has the file part
        if 'file' not in request.files:
            flash('No file part')
            return redirect(request.url)
        file = request.files['file']
        # If the user does not select a file, the browser submits an
        # empty file without a filename.
        if file.filename == '':
            flash('No selected file')
            return redirect(request.url)
        if file and allowed_file(file.filename):
            filename = secure_filename(file.filename)
            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
            return jsonify(success=True, filename=filename, path=urljoin(request.host_url, url_for('download_file', name=filename)))
    return '''
    <!doctype html>
    <title>Upload new File</title>
    <h2>Upload new File</h2>
    <form method=post enctype=multipart/form-data>
      <input type=file name=file>
      <input type=submit value=Upload>
    </form>
    '''

SECRET_KEY='change-this-to-something-unlikely-to-guess'
UPLOAD_FOLDER = './img'
MAX_CONTENT_LENGTH = 16000000
USERNAME = 'admin'
PASSWORD = 'change-this-to-your-unique-password'
SERVER='http://127.0.0.0:5001/'

$ python main.py
* Serving Flask app 'main' (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: on
* Running on all addresses (0.0.0.0)
WARNING: This is a development server. Do not use it in a production deployment.
* Running on http://127.0.0.1:5001
* Running on http://192.168.123.228:5001 (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: 332-932-829

curl \
-F "file=@/Users/luca/Pictures/image.jpeg" \
-u 'admin:password' \
'http://127.0.0.1:5001/upload'
{
"filename": "image.jpeg",
"path": "http://127.0.0.1:5001/download/image.jpeg",
"success": true
}

PIR_GPIO=17
USERNAME='admin'
PASSWORD='change-me-with-a-real-password-please'
API_SERVER='https://your-api-address.onrender.com/'
IMG_PATH='img'

$ curl -v -d '{"keep": "20"}' -H "Content-Type: application/json" -u 'username:password' -X POST http://127.0.0.1:5001/cleanup/

$ curl -v -d '{"keep": "20"}' -H "Content-Type: application/json" -u 'username:password' -X POST http://127.0.0.1:5001/cleanup/

Creating a Minimal Dashboard of Events

With such a simple server setup, the only thing we need to do for displaying the images in order is to query the filesystem and list the files by creation date. This logic is described in the list_files() function.

# List endpoint, get an HTML page listing all the uploaded files link
@app.route('/')
@auth.login_required
def list_files():
files = get_list_of_img_path(path=app.config['UPLOAD_FOLDER'], reverse=True)
images_url = []
for file in files:
images_url.append(urljoin(request.host_url, url_for('download_file', name=os.path.basename(file))))

return render_template('imglist.html', images_url=images_url)

This function calls OS-related APIs and returns a list of files ordered by creation. Then, it returns the data to the imglist.html file, using jinja templating. The essential part of the file is:

<ul>
{% for image in images_url %}
<li><a href="{{image}}">{{image}}</a></li>
{% else %}
<li>No images uploaded yet</li>
{% endfor %}
</ul>

Now, a request to https://your-api-endpoint.onrender.com/ yields the following list:

Looking at Your Dashboard When You Are Abroad

The power of IoT is not just about storing remotely images to keep them more secure or avoiding the loss of data if someone steals or damages your Raspberry Pi. The real power comes from looking at your data from anywhere in the world. Because we have a full internet-accessible URL from Render, we can take a look at our photos no matter where we are, and we can even do some from our mobile device. We just need to log in with the username and password that was put in the .env file of the server.

In the last image, my wife is testing if the camera works—and it does! So cool!

Conclusion

In this article, we walked through how to create a real mid-level IoT project from end to end — from the hardware setup to the server deployment. We used some popular and inexpensive technologies, including:

• Raspberry Pi 4

• Python

• Flask

• Render

You can build a fully functional security camera with remote image upload in just a few hours. Enjoy, and let me know how you modified the project to make it even better!