Raspberry Pi & Pi4J

##Czym jest Raspberry Pi?
Nazwą Raspberry Pi określa się serię bardzo małych komputerów, stworzonych w celu zainteresowania młodzieży programowaniem. Ze względu na swoje możliwości oraz popularność jaką osiągnęły są również często używane w projektach komercyjnych.

Obecnie jest dostępnych parę modeli, m. in. :

• Raspberry Pi model A
• Raspberry Pi model B
• Raspberry Pi model B+
• Raspberry Pi 2 model B
• Raspberry Pi 0
• Raspberry Pi 0 model W
• Raspberry Pi 3 model B

W tym artykule skupiono się jednakże na konkretnym modelu Raspberry Pi 3 B, którego zdjęcie znajduje się poniżej

##Czym wyróżnia się Raspberry Pi?
Malinki, bo tak pieszczotliwie nazywa się te małe komputery, wyróżniają się przede wszystkim pinami GPIO (General Purpose Input/Output pins), których na płytce w naszej wersji jest aż 40. Widoczne są z lewej strony wyżej ukazanego zdjęcia jako wystające z czarnych plastikowych osłon małe metalowe pręciki, jak powiedziałby laik. To one pozwalają wykorzystać nasz komputer do bardziej zaawansowanych celów. Jak sama nazwa mówi są to piny ogólnego przeznaczenia, więc nie ograniczają nas w żaden sposób.
Raspberry Pi jest urządzeniem, które pozwala nam w prosty i przyjemny sposób połączyć elementy programowania, teleinformatyki, elektroniki i robotyki.

##Przygotowujemy nasz hardware, czyli spis rzeczy z których będziemy korzystać
Logicznym jest, że aby korzystać z Raspberry Pi i jego dobrodziejstw w postaci pinów GPIO i nie tylko, trzeba je mieć.

Jest możliwość emulowania Raspberry Pi na systemach Windows i Linux, jednakże autor pomija ten aspekt, ze względu na fakt, że artykuły będą dotyczyć głównie połączenia elektroniki i programowania

W artykułach będą pojawiały się elementy elektroniczne, które będą na bieżąco przedstawiane. Początkowy zestaw, wymagany do uruchomienia pierwszego programu to:

• Raspberry Pi 3 model B
  • Zasilacz do Raspberry
  • Karta pamięci z systemem Raspbian
• Płytka stykowa
• Przewody męsko-męskie
• Sposób połączenia płytki stykowej i pinów GPIO (autor korzysta z modułu ProtoPi Plus i taśmy, jednakże jest możliwość korzystania z przewodów żeńsko-męskich)
• Dioda LED 5mm
• Rezystor 220 Ω

##Przygotowania do programowania, czyli co już powinniśmy znać
Aby dobrze zrozumieć przykład, warto aby czytelnik znał podstawy:

• IDE (w artykułach wykorzystuje się IntelliJ Idea)
• Korzystania z systemu Linux (Raspbian)
• Korzystania z SSH i przesyłania plików za pomocą SCP (opcjonalnie)
• Programowania w języku Java
• Narzędzia Maven

Wybór języka Java przy programowaniu na platformy o ograniczonych możliwościach sprzętowych nie jest optymalnym rozwiązaniem. Z jednej strony JVM sprawia, że przenoszenie programów z jednej platformy na drugą jest banalnie proste, z drugiej obecność maszyny wirtualnej powoduje, że jest zużywanych za dużo zasobów. Java nie jest językiem obsługi zadań niskiego poziomu. Znacznie lepszym wyborem są języki: C, C++, C2 lub dowolny inny wspierający programowanie sprzętowe.

##Pi4J, czyli biblioteka do obsługi GPIO
Na stronie biblioteki Pi4J znajduje się informacja, która w krótki i rzetelny sposób opisuje do jakich celów została biblioteka stworzona:

This project is intended to provide a friendly object-oriented I/O API and implementation libraries for Java Programmers to access the full I/O capabilities of the Raspberry Pi platform. This project abstracts the low-level native integration and interrupt monitoring to enable Java programmers to focus on implementing their application business logic.

To z niej będziemy korzystać. Ważną informacją dla nas jest to, że biblioteka inaczej definiuje numerowanie pinów GPIO, które znajduje się na tej stronie oraz grafice poniżej.

##Czas, aby stała się światłość, czyli pierwszy przykładowy program z użyciem diody LED
Rozpoczynamy nasz pierwszy pierwszy program od utworzenia projektu typu Maven.
Przykładowe nazewnictwo to

Kolejnym krokiem będzie edycja pliku pom.xml. Aby móc skorzystać z Javy 8 dodajemy do niego ten wpis:

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

W celu dołączenia do projektu biblioteki Pi4J dodajemy również wpis:

<dependency>
    <groupId>com.pi4j</groupId>
    <artifactId>pi4j-core</artifactId>
    <version>1.1</version>
</dependency>

Następnie kopiujemy przykład z repozytorium Pi4J dostepny zarówno na GitHubie jak i na stronie biblioteki, który został pokazany poniżej.

// START SNIPPET: control-gpio-snippet

/*
 * #%L
 * **********************************************************************
 * ORGANIZATION  :  Pi4J
 * PROJECT       :  Pi4J :: Java Examples
 * FILENAME      :  ControlGpioExample.java
 *
 * This file is part of the Pi4J project. More information about
 * this project can be found here:  http://www.pi4j.com/
 * **********************************************************************
 * %%
 * Copyright (C) 2012 - 2017 Pi4J
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU General Lesser Public
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/lgpl-3.0.html>.
 * #L%
 */

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;

/**
 * This example code demonstrates how to perform simple state
 * control of a GPIO pin on the Raspberry Pi.
 *
 * @author Robert Savage
 */
public class ControlGpioExample {

    public static void main(String[] args) throws InterruptedException {

        System.out.println("<--Pi4J--> GPIO Control Example ... started.");

        // create gpio controller
        final GpioController gpio = GpioFactory.getInstance();

        // provision gpio pin #01 as an output pin and turn on
        final GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.HIGH);

        // set shutdown state for this pin
        pin.setShutdownOptions(true, PinState.LOW);

        System.out.println("--> GPIO state should be: ON");

        Thread.sleep(5000);

        // turn off gpio pin #01
        pin.low();
        System.out.println("--> GPIO state should be: OFF");

        Thread.sleep(5000);

        // toggle the current state of gpio pin #01 (should turn on)
        pin.toggle();
        System.out.println("--> GPIO state should be: ON");

        Thread.sleep(5000);

        // toggle the current state of gpio pin #01  (should turn off)
        pin.toggle();
        System.out.println("--> GPIO state should be: OFF");

        Thread.sleep(5000);

        // turn on gpio pin #01 for 1 second and then off
        System.out.println("--> GPIO state should be: ON for only 1 second");
        pin.pulse(1000, true); // set second argument to 'true' use a blocking call

        // stop all GPIO activity/threads by shutting down the GPIO controller
        // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
        gpio.shutdown();

        System.out.println("Exiting ControlGpioExample");
    }
}
//END SNIPPET: control-gpio-snippet

Aby nasz kod działał poprawnie potrzebujemy również odpowiedniej konfiguracji sprzętowej.
Oto jak powinna ona wyglądać:

Jesteśmy gotowi! Pozostaje nam uruchomić program i oglądać efekt naszej pracy.

W przypadku programowania w IntelliJ Idea na platformie innej niż Raspberry Pi (czyli sytuacji, w której wymagany jest przesył klasy/jara) można postępować według instrukcji poniżej (autor nie narzuca własych metod).

Aby zapakować nasz projekt w Runnable Jar za pomocą narzędzi Maven dodajemy do pliku pom.xml następujący wpis:

<build>
	<plugins>
		<plugin>
			<artifactId>maven-assembly-plugin</artifactId>
			<configuration>
				<archive>
					<manifest>
						<mainClass>ControlGpioExample</mainClass>
					</manifest>
				</archive>
				<descriptorRefs>
					<descriptorRef>jar-with-dependencies</descriptorRef>
				</descriptorRefs>
			</configuration>
		</plugin>
	</plugins>
</build>

Następnie używając komendy SCP przesyłamy plik na kartę malinki.

Komenda SCP nie występuje w systemie Windows, wymagane jest zewnętrzne oprogramowanie, np. WinSCP

Wymagana jest znajomość adresu IP naszej płytki.
Przykład komendy SCP:

scp Led-1.0-SNAPSHOT-jar-with-dependencies.jar pi@192.168.1.160:/home/pi/JavaProjects

Na końcu pozostaje nam uruchomić program z poziomu SSH (jeżeli nie uruchamiamy go bezpośrednio na Raspberry Pi w systemie Raspbian).

Komenda SSH nie występuje w systemie Windows, wymagane jest zewnętrzne oprogramowanie, np. Putty

Przykładowa komenda łączenia SSH:

ssh pi@192.168.1.160

Możemy zostać poproszeni o podanie hasła (jeżeli konto tego wymaga).
Wywołanie projektu to kolejna przykładowa komenda:

sudo java -jar /home/pi/JavaProjects/Led-1.0-SNAPSHOT-jar-with-dependencies.jar

##Przykładowe gotowe skrypty
Stworzenie Jara, przesłanie go i uruchomienie:

#!/bin/sh
USERNAME='pi'
PASSWORD='malinka1'
IP='192.168.1.160'
FILE_NAME='Led-1.0-SNAPSHOT-jar-with-dependencies.jar'
EXEC_COMMAND='sudo java -jar JavaProjects/Led-1.0-SNAPSHOT-jar-with-dependencies.jar'
SH='[SCRIPT] '

echo $SH"Using Maven to create file"
mvn clean compile assembly:single
echo $SH"Sending file: " $FILE_NAME
sshpass -p $PASSWORD scp target/$FILE_NAME $USERNAME@$IP:/home/pi/JavaProjects 
echo $SH"File sent"
echo $SH"Setting jar executable"
sshpass -p $PASSWORD ssh $USERNAME@$IP 'chmod +x /home/pi/JavaProjects/'$FILE_NAME
echo $SH"Executing jar..."
sshpass -p $PASSWORD ssh $USERNAME@$IP $EXEC_COMMAND
echo $SH"Finished"

Tylko uruchomienie:

#!/bin/sh
USERNAME='pi'
PASSWORD='malinka1'
IP='192.168.1.160'
FILE_NAME='Led-1.0-SNAPSHOT-jar-with-dependencies.jar'
EXEC_COMMAND='sudo java -jar JavaProjects/'$FILE_NAME
SH='[SCRIPT] '

echo $SH"Executing jar..."
sshpass -p $PASSWORD ssh $USERNAME@$IP $EXEC_COMMAND
echo $SH"Finished"