Shopping

While the Raspberry Pi is a solid computer on its own, most of the time you will not be able to do anything with it without a few other extra pieces. In this chapter, you will need a few accessories.

Table 3-1 provides a shopping list, but you can decide what type and where to buy things.

Once you have gathered all the parts (Figure 3-1), it’s time to get the software running on the Pi.

Downloading the OS

The Raspberry Pi will refuse to even look at a beautiful cat like Marcel without an operating system. There are a few operating systems readily available on the Raspberry web site.

Ubuntu Mate and Ubuntu Core are new and good alternatives, but we will focus on the official operating system, Raspbian, because most of the documentation available for the Raspberry is based on it. It’s also quite easy to get started with it.

Raspbian is a Debian-based operating system, so most Linux aficionados will be at ease with it and its included aptitude package manager. Even though packages have to be compiled specifically for the ARM-based CPU of the Raspberry, the package list is quite up-to-date and mostly in sync with the main Debian line.

To be able to use the operating system as a bootable image that the Raspberry can use, we first need to download the image file onto a local computer and create a bootable disk specifically for the Raspberry Pi.

To download the very big OS file (don’t try this while tethering on your phone), head to https://www.raspberrypi.org/downloads/ and look for the Raspbian icon shown in Figure 3-2.

Click the icon. You will then land on the Raspbian-specific download page, as shown in Figure 3-3, where you can find the link to the zip file to retrieve.

We don’t need a full desktop install and all the proposed software, but we will aim for simplify so “Raspbian Buster with desktop” will be sufficient for us now.

Creating the Bootable SD Card

With the OS file on your computer, you are ready to create the bootable device. As noted on the Raspberry web site, the easiest way to get the OS on the Pi is by using Etcher, which is software to create the bootable SD card from a zip file or an .img file.

Etcher is available from https://www.balena.io/etcher/, and it can run on any platform, such as macOS, Windows, and Linux. The screenshots in this book were taken on Windows.

The first step after starting the application is to select the downloaded zip file, as shown in Figure 3-4.

With the image file selected and the SD card inserted into an SD slot of your computer, let’s select the SD card you want to write the OS onto, as shown in Figure 3-5.

The card used here was specifically chosen because it’s so big, so you ignore the message shown about its size, as shown in Figure 3-6.

Finally, let’s go ahead and “flash” the card, in other words, write the files onto the card. The progress is shown and should take no more than two to three minutes, as shown in Figure 3-7.

In the last step, Etcher will check the integrity of the copied data, as shown in Figure 3-8.

Once the flashing and the validation are done, Windows will try to use the drive as before, but the format of the SD card is now not readable without a specific driver, as shown in Figure 3-9. You can safely ignore the message and click Cancel.

The card is here, so let’s now plug in the cables of the Pi.

Connecting the Cables

I have found plugging things together to be quite fun and relaxing and could actually be used in personal therapy for the tough world we live in.

Things usually are easier to understand with a picture, so make sure to refer to Figure 3-10 to see where things fit together on the actual board.

Finally, with the micro SD card inserted into the Raspberry Pi 4, you are ready to power things on (or have you already?).

First Boot

The first boot is quite fast. The boot process includes a step where the file system needs to be resized, which is now handled automatically by Raspbian on first boot. You should get a welcome screen like the one shown in Figure 3-11.

With the keyboard, mouse, and screen plugged in, you can do quite a bit, but for most of the tasks we are going to do in this chapter, we want to work over SSH, which requires a network connection.

You can plug an Ethernet cable into the Ethernet port of the Pi, but WiFi works quite well. On the top right, click the WiFi icon and enter your WiFi settings in the dialog box, as shown in Figure 3-12.

Click to enable the SSH server, as shown in Figure 3-13.

Now let’s connect to the Raspberry via SSH.

Finding Your Raspberry Using nmap

This will display the IP address you need to use to connect to the Raspberry Pi.

If you’re out of luck and without a keyboard, a screen, a mouse, or all of these, you can revert to some simple commando countermeasures and use nmap to find all the Raspberry Pis on the network (and all the computers and Chinese smartphones for that matter).

Here, 192.168.1.∗ is the start of your own desktop IP address and where the Raspberry would be. Note that for this to work, we’re assuming that your computer and the Raspberry are on the same network.

What does the command actually do? In short, nmap simply scans the local network for available machines and open ports.

The -p switch scans for a given port, and the -O switch says to gather as much information as possible about each found host.

Running the previous nmap command on the local network gives us something like Figure 3-14.

and then get connected, as shown in Figure 3-15.

We made one connection, but we’re going to have to repeat those connection steps over and over, so let’s save a few SSH settings for later by modifying a configuration file both locally and on the remote Raspberry.

Setting Up SSH Easily

Usually when connecting via SSH , you disable password authentication, especially the default authentication of the Raspberry Pi, and set up a key from your local machine to connect to the remote machine and then set up that remote machine to accept only one key, or a limited number of them, so as to prevent random security attacks.

Once the command has run successfully, two files are generated: an id_rsa.pub file and an id_rsa file. pub is your public key that you can give to anyone, and id_rsa is your private key and should be handled with the utmost care.

To tell the Raspberry Pi about your public key and recognize you, you add it as a one-liner to the /home/pi/.ssh/authorized_keys file, creating the file and the .ssh parent folder if needed.

With all these settings, you may be wondering if this was all worth it. Let’s get a bit of instant gratification to prove that it was. Via an SSH connection, we will now open an application with a UI, for example the included Chromium browser.

Figure 3-16 shows how Chromium is executing on the Pi but opening its window on the computer.

Setting Up the Java OpenJDK

All the code in this book is Java code, so we’ll need to install the Java Development Kit and runtime on the Raspberry Pi.

As an optional dependency, you can also install Maven. Maven is not really required for most of the examples of the book, but this will stop Visual Studio Code from displaying annoying messages that it cannot find the (unnecessary) Maven executable.

sudo at the start of each command line is used to get the required escalated privileges to install new software with apt.

The output of the previous commands should be similar to Figure 3-23.

Alternative to Setting Up the Java SDK

The current selection of JDK on Raspberry Pi 4 running Buster (the latest Raspbian version) is quite impressive. Sometimes, however, especially on older versions of Raspbian, you could be stuck with an outdated JDK for quite some time.

It’s worth noting that companies like Azul and Bellsoft have released up-to-date versions of the JDK specifically compiled for the ARM CPU, the processor running on the Raspberry Pi.

With the Java Development Kit now installed on your Raspberry Pi, let’s move on to the meat of this chapter, running OpenCV code in Java and on the Pi.

Checking Out the OpenCV/Java Template

Let’s quickly review these three one by one.

Performing a Git Clone

It is possible and convenient to simply check out code from Visual Studio Code straight to your Pi. This is done via the command palette and typing anything starting with git.

You will get a few options, one of them being Git: Clone , as shown in Figure 3-24.

From here, enter the location of the template repository as follows, as shown in Figure 3-25:

https://github.com/hellonico/opencv-java-template.git

Finally, confirm by clicking Open in the dialog box (Figure 3-26).

The project is now checked out on the Raspberry and ready to be executed.

Downloading the Zip File

Alternatively, you can download the zip file from the project template. This can be done using the wget command in the terminal in case you do not want to use Git at all.

wget https://github.com/hellonico/opencv-java-template/archive/master.zip

unzip master.zip

Figure 3-27 shows the Terminal tab of Visual Code Studio.

This has the advantage of not being reliant on Git but has the consequence that it is harder to share updates between different Raspberry Pis.

Using Maven

A third way to set up the project is the same technique that was used to originally create the Git template repository: using the build tool Maven. In the Java ecosystem, quite a few people are a bit afraid of going the Maven way, but for a set of given tasks, Maven is a pretty solid choice.

Maven , once installed, can create a project for you with all the required files through the Maven archetypes.

The following command, once copied and pasted onto the Terminal tab, will generate the project structure for you, as shown here:

mvn org.apache.maven.plugins:maven-archetype-plugin:2.4:generate

   -DarchetypeArtifactId=maven-archetype

   -DarchetypeGroupId=origami

   -DarchetypeVersion=1.0

   -DarchetypeCatalog=https://repository.hellonico.info/repository/hellonico/

   -Dversion=1.0-SNAPSHOT

   -DgroupId=hello

   -DartifactId=opencv-java-template

The important parameters of the command have been highlighted in the previous snippet and are explained here:

• archetypeVersion: This is the version of the project structure, here 1.0. There may be a few updates soon, but don’t expected too many. It’s better to create your own.

• version: This is the version of your project; it usually starts at 1.0-SNAPSHOT.

• groupId: This is the Maven group of your project, like com.google, etc.

• artifactId: This is the name of the project within the groupId. It must be unique.

  Here we are using an older version of the archetype plugin; with this version, it is easier to retrieve artifacts from the custom Maven repository at repository.hellonico.info.

  Later versions of the archetype plugin require a deeper knowledge of the Maven framework, which is out of the scope of this book.

Whichever technique you use, you can now open the remote folder. You should see something similar to the tree in Figure 3-28.

Again, the files are located on the Raspberry Pi, the Java code will be executed on the Raspberry Pi, but the editor is effectively running on your local computer.

Installing the Visual Code Java Extension Pack Remotely

If you remember from Chapter 1, we installed plugins to get Visual Studio Code to understand and run Java. We’ll do the same here, but this time on the Raspberry Pi.

Figure 3-29 shows the Marketplace tab, where you can search for the same plugin that was installed before, the Java Extension Pack. Note in Figure 3-30 how Visual Studio Code nicely asks you if you want to install the plugin on the Raspberry.

Figure 3-31 and Figure 3-32 show the last two steps of installing the Visual Code Java plugin on the Raspberry Pi.

You should now have your editor showing the familiar Run and Debug links straight in the editor, as shown in Figure 3-33.

All the steps were quite long the first time around, but now you’re ready for some good times. You are all set up for running some OpenCV/Java on the Raspberry Pi.

Running the First OpenCV Example

Without further ado, let’s click the Run button and get the program to execute.

Clicking the Run button runs the same program as in Chapter 1, but the program is executed on the Raspberry Pi this time. The output shows the familiar 3×3 matrix, as in Figure 3-34.

Note that various downloads are done in the background on the first run, so the command takes a bit of time. On the second run, things are quicker.

As a reminder, debugging works here in the same way as in Chapter 1. As an exercise, try adding a breakpoint to pause the program execution after running Debug and then add a watch expression on System.getProperty() to show the java.vm.vendor value. Since we are now running on the Raspberry Pi, the value should be Raspbian, as shown in Figure 3-35.