Camera Connection

Always turn off and disconnect the Pi’s power supply when working with electronic circuits.

The Pi Camera connects to the Pi using a ribbon cable and the camera serial interface , or CSI port. This thin cable is included with the camera. Not only does it allow the Pi to communicate with the camera, but it also supplies power to the camera. If you’ve been using an inadequate power supply for your Pi, then the increased current draw required by the camera may mandate the need for a suitable power supply. The 3A supply specified in the Project Overview – Equipment List is sufficient for both the Pi and the camera.

With the exception of the Pi Zero, every single Pi has the camera connection port. This proprietary connection is cheap to manufacture, although it’s not very durable. It’s not so fragile that you should be afraid of using it, or using the Pi or connecting other peripherals or components to your GPIO ports; just don’t go overboard by stressing the connector.

Begin by powering down the Pi and removing the power supply. The camera module comes with the ribbon cable already connected – you only need to connect the other end to the Pi itself – shown in Figure 11-2. Locate the camera module port, which is a narrow, 1-inch long connector behind the LAN port. Gently pull the connector’s plastic cover up, roughly 1/8th of an inch. It won’t fully detach.

Now gently insert the ribbon cable, with the exposed “pins” facing away from the Pi’s I/O section, toward the HDMI and power connections – as shown in Figure 11-3. Don’t force it. If you’re struggling, double-check your cable is the correct orientation and that you’re inserting it square on, and not at an angle. Once seated 1/8th of an inch, gently push the plastic cover back down, clamping down on the cable. Visually inspect the cable, and gently tug it, to ensure it’s seated properly. When ready, apply the power and boot up the Pi.

Pi Camera First Time Configuration

Connect to the Pi over SSH. To begin using the camera, you need to tell the Pi it’s connected. You can do this with the raspi-config utility. The output from this command is shown in Figure 11-4:

sudo raspi-config

Use the arrow and enter keys to navigate around this tool. Scroll down and choose Interfacing Options . Figure 11-5 shows the Interfacing Options menu. Choose P1 Camera, and select yes when asked to enable the Pi Camera. Choose OK when the Pi confirms the camera is enabled. Now use your right arrow key to select finish, and choose yes when the Pi asks to restart.

SCP stands for secure copy . It lets you copy files from one remote location to another. This command is split into three sections. Begin with the scp keyword. This invokes the secure copy tool. The next section is the remote address and file location – separated by a colon. This looks for the file in location Desktop/test_photo.jpg on the remote [email protected] – your IP address will vary, or you could use your pi-car alias here. Finally, specify the location on your computer to put the file, which is /Users/coburn/Desktop/ on my computer – put yours wherever you like.

Open your photo and look at it. It may not be perfect – my photo is blurry and upside down and visible in Figure 11-6. For now, providing that you have something, then that will do. You’ll improve the quality and make it usable later on, but right now, this test is about ensuring the module works properly. If you can’t copy the file, double-check your scp command. Does the file exist at all on the Pi? Was there a problem raspistill raised saving the photo at all? Double-check your work and, if necessary, your wiring.

Camera Live Stream Configuration

To work with this camera feed, the Pi will read in the camera data, interpret it, process it, and stream it to the network over its TCP port. This section isn’t configured in Python. There are many Python libraries available, but a solution which is both simple to configure and that works reliably (or can be defensively programmed around) is difficult to achieve in Python.

For this section, you’ll use the Motion (https://motion-project.github.io/) library to handle the stream. This is a Debian package for working with the Pi Camera. It’s mainly designed around motion detection and video recording (which would be an interesting extension project), yet it has excellent streaming capabilities, and is configured with a config file. It can run as a daemon, so the Pi can configure the stream itself when it boots.

Now load the Pi in your web browser, and use Motion’s default streaming port of 8081:

http://pi-car:8081/

Verify that you see the feed from the camera. Move around and observe as it changes. Note the timestamp in the bottom-right corner of the video. The stream is now ready to pull into your Flask application. You may need to revisit these configuration settings as the project progresses. Perhaps when you install the project into your car, the camera is rotated upside down, or you need to change the quality. Figure 11-7 shows the rotated image stream, complete with timestamp in the lower-right corner.

Pi Camera Focus Adjustment

Like any camera, the Pi Camera V2 has a lens with adjustable focus. There’s no autofocus, it’s purely manual – a mechanical lens adjustment. If your video feed is blurry, and providing you haven’t increased the output dimensions to huge numbers (which will reduce the quality), then you may need to adjust the lens focus.

All cameras use a plane of focus (PoF). This imaginary line defines what is and is not in focus at a given time. Adjusting the focus on a lens moves this plane forward or backward. Everything parallel to the lens at a given distance is in focus, and moving nearer or further from or to the lens gets increasingly out of focus. An object 1M away could be in focus, and something right next to the lens would be out of focus. For these reasons, you won’t be able to get everything the camera sees in focus – it will be a compromise, which may need adjusting once the camera is mounted on your car.

To adjust the Pi’s focus, identify the sensor and lens module on the front of the Pi Camera module. The small black square in the middle of the module houses the lens. Within this square, the lens features a hexagonal casing, known as the lens barrel . By rotating this barrel, you can adjust the plane of focus.

Use a small pair of pliers to grip the outer lens housing – shown in Figure 11-8. Use a small screwdriver to nudge the lens barrel, and use the indentation to grip your tool. Be very careful not to apply too much pressure. Slipping here could damage the lens itself or risk pulling the entire lens assembly away from the module itself. Treat this lens and this maintenance step as you would a pair of glasses, or when putting contact lenses in.

Remember, this focus will need adjusting when the camera is installed in your car.

Camera Flask Code

For this code section, you’ll create a new Flask route to serve the image. Later on, you’ll expand this route to make use of the reversing sensors, but for now, it simply serves the camera feed. This is a simple code change – the Pi is already handling the hard work of the video.

The reverse.py file is the new route for this reversing screen. The template file reverse.html is the markup to render this stream. It lives inside the templates folder, which is a Flask pattern for storing markup files.

This is a new blueprint file. It defines a new route /reverse/ and handles the logic to connect to the stream. There’s lots of logging (as is standard across this project). This file uses the render_template function from Flask. This function renders the contents of a template to the browser – reverse.html. Notice how you don’t need to specify the templates folder, as Flask already knows this is where to look for templates. By using a render template, you can keep your code neater, as all the HTML and markup-specific logic lives in the template itself, ready for reuse by any of your application logic.

You can also pass data to templates. This route passes the stream_url to the template. This stream URL is where the browser can find the video feed. It’s a Fully Qualified Domain Name , or FQDN. It consists of the protocol (http), host (pi-car), and stream port. Notice how the stream port is pulled from the config even though it does not exist. This defensive logic falls back to the 8081 stream port if the config is not set. This lets you easily change the port in the future, just by modifying the config file. You don’t have to dig through the code, which could use this port in numerous locations in a bigger code base.

This is Jinja, the templating language included with Flask. This renders the value “http://pi-car:8081”, as specified in your back-end logic.

Start Flask on your computer, and visit the new URL route at http://127.0.0.1:5000/reverse/. Providing the Pi is on and the Motion service is streaming the video feed, you’ll see the real-time video. Commit your changes, and perform a build on the Pi. Visit the Pi’s URL and verify the route also works there at http://pi-car:5000/reverse/ (shown in Figure 11-9).

Notice how you’re using port 5000 to access the application, but if you look at the code rendered by the reverse route (by right-clicking and choosing inspect to bring up your console developer tools), you’ll see the stream is coming from http://pi-car:8081. This is due to ports, as discussed in earlier chapters. The application runs on port 5000, but the stream runs on port 8081. You don’t need to merge or combine the two – they are independent data feeds coming out of the Pi.

Chapter Summary

This chapter introduced to you the Pi Camera module. You learned how to connect it to the Pi and fine-tune the settings to achieve the best possible quality. You configured the Pi to stream the camera feed over the network and created a basic template to pull this stream into your application. This is the basis for your entire reversing module, which you’ll continue to expand upon later on.

The next chapter shows you how to develop a reverse beeper, to indicate the presence of a rear obstacle.