Raspberry Pi

Power Adaptor

You may buy it with a complete starting kit or select just the required accessories, including at least a 5 V micro-USB power adaptor supplying at least 2 A and an SD Card.

SD Card

Monitor

Install SD

Follow www.raspberrypi.org/documentation/installation/installing-images/README.md.

I’ll choose Raspbian Stretch² with desktop image from www.raspberrypi.org/downloads/raspbian/. You can choose Lite or any other distribution of course.

Raspberry Pi Configuration

See www.raspberrypi.org/documentation/configuration/.

Raspi-config

See www.raspberrypi.org/documentation/configuration/raspi-config.md.

The first time booting into Raspbian, raspi-config runs on your display. Later on, to open the configuration tool, simply run the following from the command line or via SSH (as explained in the following):

$ sudo raspi-config

• Change user password:

  • The default user on Raspbian is pi with the password raspberry. You can change that here. For convenience, I’ll set the same password: pi, which comes handy. But it is quite the opposite of a secure password, of course.

• Network options:

  • Hostname is the visible name for this Pi on a network. Change the default raspberrypi, if required, for instance, if you have more than one device.

  • Wi-Fi: Enter SSID and passphrase. It allows connecting to a wireless network using the Raspberry Pi 3's built-in wireless connectivity and will let you work remotely on it from your usual development machine, using SSH.

• Boot options:

  • Desktop/CLI: Use this option to change your boot preference to command line or desktop. We’ll choose command line, but desktop can be used too. You can choose autologin.

• Localization options:

  • Choose from keyboard layout, time zone, locale, and Wi-Fi country code. All options on these menus default to British or GB until you change them.

• Interfacing options:

  • Camera, if you have one.

  • SSH: Enable it; this is required to access remotely.

• Advanced options:

  • Memory split: Set at least 256–512 MB for GPU if you are going to run JavaFX.

• Update: Recommended, but it takes a while (only with the Pi connected to the network).

• When finished, reboot.

Note that you can find directly the applied settings in the /boot/config.txt file.

After logging in again, you can check the Wi-Fi settings:

$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

You can add as many SSIDs as you need. You can use

$ sudo iwlist wlan0 scan

to find the available networks at any given location.

Run ifconfig to find if your Pi is connected to the network. As you can see in Figure 12-3, wlan0 is connected, at a given local IP address, and data packages are being received and transmitted (RX, TX).

By default, DHCP is used. If you need a static IP address, check www.raspberrypi.org/documentation/configuration/wireless/access-point.md and run

$ sudo nano /etc/dhcpcd.conf

to configure your eth0 or wlan0 static IP addresses.

In case you have the 7” Raspberry Pi display, you will need to rotate it 180°. Edit the config.txt file:

$ sudo nano /boot/config.txt

Add the following at the end of the file:

lcd_rotate=2

Then, save (Ctrl-O), and exit (Ctrl-X).

Finally, note that you should never power off your Raspberry Pi, by unplugging it from the power source while it is on, before shutting it down, to prevent the risk of damaging the file system. For a proper way to shut it down, run:

$ sudo shutdown –h now

Then wait a bit, and disconnect power.

Remote Connection via SSH

Most of the time, we will connect to the Raspberry Pi through SSH to run headlessly (i.e., without a dedicated monitor and keyboard on the Pi), having direct access from our developing machine (including copy/paste and file transfer options between both of them).

SSH is built into Linux distributions and Mac OS. For Windows and mobile devices, third-party SSH clients are available. On Linux and Mac OS, you can use SSH to connect to your Raspberry Pi from a Linux computer, a Mac, or another Raspberry Pi, without installing additional software. On Windows, the most commonly used client is called PuTTY and can be downloaded from greenend.​org.​uk. See www.raspberrypi.org/documentation/remote-access/ssh/windows.md.

where you need to supply the IP of the device. You can use hostname –I to find this IP if you are already connected to it, but if that’s not the case, you can try to find the device’s IP in the local network using nmap, or a mobile app, like Fing.

Usually the Raspberry Pi uses DHCP, which means it doesn’t have a fixed address, and after rebooting it can probably change. That is not convenient for an SSH connection. We can try to set a fixed IP, or we can also try to use its hostname to connect to it, providing it is broadcasted to the network. This works with Raspbian as it uses the multicast DNS protocol.

Since Mac OS and Linux use Bonjour, both support mDNS. On Windows, you can install Bonjour from here, https://support.apple.com/kb/DL999, for instance.

After you enter the password, you will have access to the Raspberry Pi (Figure 12-4). The first time you will see a security/authenticity warning. Type yes to continue.

Java 11 for ARM

There are a number of options if you want to run Java on your Raspberry Pi. If you want to run a Java 11 distribution, completely based on OpenJDK, with integrated JIT (hotspot), you can use a build from https://adoptopenjdk.net.

Testing Java 11

Let’s test Java 11 and the new Launch Single-File Source-Code Programs feature:

$ cd /home/pi/

$ mkdir ModernClients

$ cd ModernClients

$ nano Test.java

Add a main method as shown in Listing 12-1 or copy the file from Sample0: https://github.com/modernclientjava/mcj-samples/tree/master/ch12-RaspberryPi/Sample0.

public class Test {

    public static void main(String... args) {

        System.out.println("Hello Java " +

             System.getProperty("java.version") + " for ARM!");

    }

}

Listing 12-1

Sample0

Save, exit (Ctrl-O, Ctrl-X), and run:

$ java Test.java

It should print the result of Figure 12-5.

Congratulations on running your first Java 11 application on your brand-new Raspberry Pi! Now that Java has been installed successfully, you can move to the next step: installing JavaFX.

Running JavaFX Applications Locally

We can now try to run a HelloFX sample from https://github.com/modernclientjava/mcj-samples/tree/master/ch12-RaspberryPi/Sample1, which is based on the https://openjfx.io/openjfx-docs/ samples.

Since we have removed the monocle options, now we have a regular windowed application (Figure 12-7). And we can use the mouse to close it and stop the Java process.

The javafx-gradle-plugin only works on Desktop, and it defaults to Linux x86_64, so the native libraries are not compatible, as the Pi will require Linux ARM 32.

Java Remote Platform

NetBeans created a while ago the concept of remote platform. You can define the settings of a JVM on another machine and use an Ant task to deploy and run over SSH on that machine.

This comes very handy of course in the case of the Raspberry Pi.

To install Apache NetBeans 11.1, go to https://netbeans.apache.org/download/nb111/nb111.html and choose the installer for you platform.

Once installed, go to Tools ➤ Java Platforms. Click Add Platform... and select Remote Java Standard Edition.

Provide your details: name of the remote platform, like Pi 11, and host: It can be raspberrypi.local; user, pi; password; and remote JRE path, /opt/jdk-11.0.1+13. See Figure 12-8.

When the remote platform has been created, make sure you add sudo to the exec prefix, as in Figure 12-9.

Finally, with the Raspberry Pi available, click Test Platform and see that the test is successful. Otherwise, make sure all the fields are correctly set.

Let’s try the remote platform with an example. Follow the instructions here, https://openjfx.io/openjfx-docs/#IDE-NetBeans, to create a new Java application without build tools, or download Sample4 from https://github.com/modernclientjava/mcj-samples/tree/master/ch12-RaspberryPi/Sample4.

First of all, make sure the app runs fine on your machine.

and close the dialog.

You will see your app running nicely on the Pi’s display, while you can see the output from the process in the NetBeans output window. And you can even debug the application.

However, this approach has a few problems: it only works on NetBeans, and it is not valid for Maven or Gradle projects.

Gradle SSH Plugin

Another option is the SSH Gradle plugin from https://gradle-ssh-plugin.github.io. It will work on Gradle projects from terminal or any IDE with Gradle support.

Let’s run now this sample, https://github.com/modernclientjava/mcj-samples/tree/master/ch12-RaspberryPi/Sample5, from IntelliJ (or any IDE of your choosing).

Note For convenience, the task sets allowAnyHosts, and host key checking is turned off. It will print a warning message that the process is vulnerable to man-in-the-middle attacks and it is not recommended for production.

With this plugin, hitting Ctrl-C from the terminal just kills the Gradle process, but not the application. To solve this issue, make sure you add an Exit button to the UI.

The app will be built, deployed to the Pi, and executed on it, and you will get the output from the process in your terminal, like in Figure 12-11.

The DIY In-Car Navigation System

The following project is a Proof of Concept of a Do It Yourself homemade in-car navigation system. For that, we are going to install a GPS to the Raspberry Pi. A JavaFX application will display a map, and the GPS readings will be used to center the map in our current location.

Bill of Materials

Raspberry Pi 3 Model B+

7″ display 800 × 480; cage is optional but recommended.

5 V power adaptor for Raspberry Pi and display. Power bank is optional but recommended for field testing.

GPS: Universal Asynchronous Receiver-Transmitter (UART) Serial GPS Neo-7M (micro-USB is optional) (Figure 12-12), for instance, this one: http://wiki.keyestudio.com/index.php/KS0319_keyestudio_GPS_Module.

Four female-female jumper wires for GPIO connection.

Micro-USB: USB adaptor (in case the GPS breakout mounts micro-USB) is optional.

Antenna for the GPS is optional (but when used, the capacitor C2 has to be removed).

Setup for GPIO

We are going to use the General-Purpose Input/Output (GPIO) pins to get serial readings from the GPS.

The Raspberry Pi serial port consists of two signals, a transmit signal (TxD) and a receive signal (RxD), that are available at pins 8 and 10 on the 3 Model B+ (equivalent to GPIO #15 and #16 from Figure 12-13, in that order).

By default, the serial port on the Raspberry Pi is configured as a console port for communicating with the Linux OS shell. In order to access the serial port from a software program, we have to configure it. Open an SSH session, and run

$ sudo raspi-config

Select Interfacing options and now select Serial.

Now you have to select No, to disable the login shell access to serial, and then select Yes to enable the hardware serial port (or UART for Universal Asynchronous Receiver-Transmitter). Accept and reboot your Raspberry Pi.

GPIO Connections

The GPS module requires four connections that can be made using four jumper female-female wires; see Figure 12-14, from right to left:

• VCC pin connected to pin 2 (power 5 V), red jumper

• GND pin connected to pin 6 (ground), yellow jumper

• Rx pin connected to pin 8 (TxD UART, GPIO 15), blue jumper

• Tx pin connected to pin 10 (RxD UART, GPIO 16), green jumper

Note that a breakout board and pin ribbon cable can be used instead, extending the GPIO pins to a breadboard, where the connection to the GPS can be done more easily.

Required GPS Software

We need to install the following software from a terminal:

$ sudo apt-get install gpsd gpsd-clients

where gpsd is the interface daemon for GPS receivers. When finished, if the GPS is already attached, you can start reading it from the lowest-numbered serial port with

$ gpsd /dev/ttyS0

or in case you have connected the USB instead with

gpsd /dev/ttyUSB0

The best option to launch the gpsd is with this service:

$ sudo service gpsd start

Once the service has stared, you can verify its status with

$ sudo systemctl status gpsd.socket

that will display something like shown in Figure 12-15.

If required, you can modify the default settings by editing the file:

$ sudo nano /etc/default/gpsd

Once everything is running properly, you can start a GPS monitor with

cgps /dev/ttyS0

or with

gpsmon /dev/ttyS0

If you are indoors, it is probably that the GPS won’t be able to connect to any satellite, and you won’t receive any value. But you will still get some readings.

If you take your Raspberry Pi outdoors, as long as the Wi-Fi connection holds, you can still be connected through SSH to your machine and visualize these readings and get something like shown in Figure 12-16.

The UI

Let’s define now the JavaFX interface: we are going to display a map that will be centered into the latitude and longitude coordinates retrieved from the GPS reading.

Scene Builder

Finally, we’ll use Scene Builder 11.0.0 from https://gluonhq.com/products/scene-builder/ to design the UI with FXML on our machine.

It is convenient to import Gluon Maps into Scene Builder custom controls library (Figure 12-17).

Then we can create a new FXML file, with a top BorderPane container, and drag and drop the required components: a toolbar on top, the MapView on the center, a VBox with labels on the right to display the current GPSPosition values, and a ListView to display the NMEA sentences at the bottom (Figure 12-18).

Note that with Afterburner, we will create the following files:

Java classes:

• org.modernclients.raspberrypi.gps.view.UIView (Listing 12-10) that extends from FXMLView, a convenient container that takes care of loading the FXLM, CSS, or properties files by convention

• org.modernclients.raspberrypi.gps.view.UIPresenter (Listing 12-14)

Resource files:

• org.modernclients.raspberrypi.gps.view.ui.fxml (Listing 12-11)

• org.modernclients.raspberrypi.gps.view.ui.css (Listing 12-12)

• org.modernclients.raspberrypi.gps.view.ui.properties (Listing 12-13)

package org.modernclients.raspberrypi.gps.view;

import com.airhacks.afterburner.views.FXMLView;

import java.util.ResourceBundle;

public class UIView extends FXMLView {

    public UIView() {

        this.bundle = ResourceBundle.getBundle("/org/modernclients/view/ui");

    }

}

Listing 12-10

UIView class

<?xml version="1.0" encoding="UTF-8"?>

<?import com.gluonhq.maps.MapView?>

<?import javafx.geometry.Insets?>

<?import javafx.scene.control.Button?>

<?import javafx.scene.control.Label?>

<?import javafx.scene.control.ListView?>

<?import javafx.scene.control.Separator?>

<?import javafx.scene.control.ToggleButton?>

<?import javafx.scene.control.ToolBar?>

<?import javafx.scene.layout.BorderPane?>

<?import javafx.scene.layout.Pane?>

<?import javafx.scene.layout.VBox?>

<BorderPane fx:id="pane" xmlns="http://javafx.com/javafx/11.0.1" xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.modernclients.raspberrypi.gps.view.UIPresenter">

   <bottom>

      <ListView fx:id="listView" maxHeight="200.0" BorderPane.alignment="CENTER" />

   </bottom>

   <right>

      <VBox prefHeight="250.0" prefWidth="200.0" styleClass="box" BorderPane.alignment="CENTER">

         <children>

            <VBox>

               <children>

                  <Label styleClass="gps" text="%label.time" />

                  <Label fx:id="timeLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox>

               <children>

                  <Label styleClass="gps" text="%label.position" />

                  <Label fx:id="positionLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox>

               <children>

                  <Label styleClass="gps" text="%label.altitude" />

                  <Label fx:id="altitudeLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox>

               <children>

                  <Label styleClass="gps" text="%label.direction" />

                  <Label fx:id="directionLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox layoutX="10.0" layoutY="112.0">

               <children>

                  <Label styleClass="gps" text="%label.speed" />

                  <Label fx:id="speedLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox layoutX="10.0" layoutY="146.0">

               <children>

                  <Label styleClass="gps" text="%label.quality" />

                  <Label fx:id="qualityLabel" styleClass="gps-data" />

               </children>

            </VBox>

            <VBox layoutX="10.0" layoutY="146.0">

               <children>

                  <Label styleClass="gps" text="%label.satellites" />

                  <Label fx:id="satellitesLabel" styleClass="gps-data" />

               </children>

            </VBox>

         </children>

      </VBox>

   </right>

   <top>

      <ToolBar BorderPane.alignment="CENTER">

         <items>

            <Label fx:id="statusLabel" styleClass="gps-data" text="%label.gps" />

            <Pane maxWidth="1.7976931348623157E308" prefWidth="200.0" />

            <Separator orientation="VERTICAL" />

            <ToggleButton fx:id="showLog" mnemonicParsing="false" text="%button.show.log" />

            <Separator layoutX="324.0" layoutY="10.0" orientation="VERTICAL" />

            <Button mnemonicParsing="false" onAction="#onZoomIn" text="%button.zoom.in" />

            <Button layoutX="10.0" layoutY="10.0" mnemonicParsing="false" onAction="#onZoomOut" text="%button.zoom.out" />

            <Separator layoutX="440.0" layoutY="10.0" orientation="VERTICAL" />

            <Button layoutX="20.0" layoutY="20.0" mnemonicParsing="false" onAction="#onExit" text="%button.exit" />

         </items>

         <padding>

            <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />

         </padding>

      </ToolBar>

   </top>

   <center>

      <MapView fx:id="mapView" BorderPane.alignment="CENTER" />

   </center>

</BorderPane>

Listing 12-11

ui.fxml file

.box {

    -fx-padding: 20;

    -fx-spacing: 10;

    -fx-border-color: darkgray;

    -fx-border-width: 0 0 0 1;

}

.label.gps-data {

    -fx-text-fill: blue;

    -fx-font-size: 1.1em;

}

.label.gps {

    -fx-text-fill: darkgray;

    -fx-font-size: 1.0em;

}

Listing 12-12

ui.css file

button.show.log=Show Log

button.zoom.in=+

button.zoom.out=-

button.exit=Exit

label.time=Time

label.position=Position

label.altitude=Altitude

label.direction=Direction

label.speed=Speed

label.quality=Quality

label.satellites=Number of Satellites

label.gps=GPS Status: {0}

label.gps.fixed=fixed

label.gps.not-fixed=not fixed

Listing 12-13

ui.properties file

Once we have all these files, it is time to add now the presenter (Listing 12-14).

package org.modernclients.raspberrypi.gps.view;

import com.gluonhq.maps.MapPoint;

import com.gluonhq.maps.MapView;

import javafx.application.Platform;

import javafx.beans.binding.Bindings;

import javafx.fxml.FXML;

import javafx.scene.control.Label;

import javafx.scene.control.ListView;

import javafx.scene.control.ToggleButton;

import javafx.scene.layout.BorderPane;

import javafx.scene.paint.Color;

import javafx.scene.shape.Circle;

import org.modernclients.raspberrypi.gps.model.GPSPosition;

import org.modernclients.raspberrypi.gps.service.GPSService;

import javax.inject.Inject;

import java.text.MessageFormat;

import java.util.ResourceBundle;

import java.util.logging.Logger;

public class UIPresenter {

    private static final Logger logger = Logger.getLogger(UIPresenter.class.getName());

    @FXML private BorderPane pane;

    @FXML private Label statusLabel;

    @FXML private MapView mapView;

    @FXML private ListView<String> listView;

    @FXML private Label timeLabel;

    @FXML private Label positionLabel;

    @FXML private Label altitudeLabel;

    @FXML private Label directionLabel;

    @FXML private Label speedLabel;

    @FXML private Label qualityLabel;

    @FXML private Label satellitesLabel;

    @FXML private ToggleButton showLog;

    @FXML private ResourceBundle resources;

    @Inject private GPSService service;

    @Inject private GPSPosition gpsPosition;

    private MapPoint mapPoint;

    public void initialize() {

        logger.info("Platform: " + System.getProperty("embedded"));

        mapView = new MapView();

        mapPoint = new MapPoint(50.0d, 4.0d);

        mapView.setCenter(mapPoint);

        mapView.setZoom(15);

        PoiLayer poiLayer = new PoiLayer();

        poiLayer.addPoint(mapPoint, new Circle(7, Color.RED));

        mapView.addLayer(poiLayer);

        pane.setCenter(mapView);

        service.lineProperty().addListener((obs, ov, nv) -> {

            logger.fine(nv);

            listView.getItems().add(nv);

            listView.scrollTo(listView.getItems().size() - 1);

            if (listView.getItems().size() > 100) {

                listView.getItems().remove(0);

            }

        });

        gpsPosition.timeProperty().addListener((obs, ov, nv) -> {

            statusLabel.setText(

               MessageFormat.format(resources.getString("label.gps"),

                  gpsPosition.isFixed() ? resources.getString("label.gps.fixed") :

                  resources.getString("label.gps.not-fixed")));

            mapPoint.update(gpsPosition.getLatitude(),

                 gpsPosition.getLongitude());

            mapView.setCenter(mapPoint);

        });

        timeLabel.textProperty().bind(Bindings.createStringBinding(() -> {

            float time = gpsPosition.getTime();

            int hour = (int) (time / 10000f);

            int min = (int) ((time - hour * 10000) / 100f);

            int sec = (int) (time - hour * 10000 - min * 100);

            return String.format("%02d:%02d:%02d UTC", hour, min, sec);

        }, gpsPosition.timeProperty()));

        positionLabel.textProperty().bind(Bindings.format("%.6f, %.6f",

            gpsPosition.latitudeProperty(), gpsPosition.longitudeProperty()));

        altitudeLabel.textProperty().bind(Bindings.format("%.1f m",

            gpsPosition.altitudeProperty()));

        speedLabel.textProperty().bind(Bindings.format("%.2f m/s",

            gpsPosition.velocityProperty()));

        directionLabel.textProperty().bind(Bindings.format("%.2f °",

            gpsPosition.directionProperty()));

        qualityLabel.textProperty().bind(Bindings.format("%d",

            gpsPosition.qualityProperty()));

        satellitesLabel.textProperty().bind(Bindings.format("%d",

            gpsPosition.satellitesProperty()));

        statusLabel.setText(MessageFormat.format(resources.getString("label.gps"),

            resources.getString("label.gps.not-fixed")));

        listView.managedProperty().bind(listView.visibleProperty());

        listView.visibleProperty().bind(showLog.selectedProperty());

        showLog.setSelected(false);

    }

    public void stop() {

        service.stop();

    }

    @FXML private void onExit(){

        Platform.exit();

    }

    @FXML private void onZoomIn() {

        if (mapView.getZoom() < 19) {

            mapView.setZoom(mapView.getZoom() + 1);

        }

    }

    @FXML private void onZoomOut() {

        if (mapView.getZoom() > 1) {

            mapView.setZoom(mapView.getZoom() - 1);

        }

    }

}

Listing 12-14

UIPresenter class

The GPSPosition and the GPSService objects are injected into the presenter, and the text properties of the different labels are bound to the JavaFX properties. Note that it is important to stop the service when the application is closed. This will close the serial port and release the GPIO controller.

Next Challenge

If you were able to make it work, now the next challenge for you is to get your Raspberry Pi and display powered from a power bank, so you can run the app while moving, either walking or with a vehicle. It will be convenient to use tethering, creating a hotspot with your mobile device so the required maps can be downloaded from OpenStreetMap. You can add the SSID of your device to the wpa_supplicant.conf file as discussed at the beginning of this chapter.