Raspberry Pi mit Java programmieren

Der Raspberry Pi ist ein Einplatinencomputer, der von der britischen Raspberry Pi Foundation entwickelt wurde. Der Rechner enthält ein Ein-Chip-System von Broadcom mit einem ARM-Mikroprozessor, die Grundfläche der Platine entspricht etwa den Abmessungen einer Kreditkarte. Der Raspberry Pi kam Anfang 2012 auf den Markt; sein großer Markterfolg wird teils als Revival des bis dahin weitgehend bedeutungslos gewordenen Heimcomputers zum Programmieren und Experimentieren angesehen. Der im Vergleich zu üblichen Personal Computern sehr einfach aufgebaute Rechner wurde von der Stiftung mit dem Ziel entwickelt, jungen Menschen den Erwerb von Programmier- und Hardwarekenntnissen zu erleichtern. Entsprechend niedrig wurde der Verkaufspreis angesetzt, der je nach Modell nur etwa 5 bis 35 USD beträgt.

Legoroboter mit dem Raspberry Pi steuern

Hier finden Sie eine ausführliche Dokumentation aus einem Schülerprojekt (zwei Schüler der E1) zur Programmierung eines Legoroboters. Von der Installation des Betriebssystems, über notwendige Tools bis zur Sensorprogrammierung auf dem Rasperry Pi finden Sie hier eine komplette Dokumentation für dieses Projekt.

GPIO-Ports

Die GPIO-Ports des Raspberry Pi lassen sich recht einfach mit Pi4J programmieren. Auf der Homepage von Pi4J [http://pi4j.com/] finden Sie ausführliche Anleitungen zur Installation von Pi4J und viele gute Beispiel-Programme.

Da die Entwicklung von Java Programmen auf dem Pi sehr umständlich ist, ist es besser auf dem PC zu programmieren (z.B. mit Eclipse) und anschließend die Dateien (mit z.B. WinSCP) auf den Pi zu übertragen.

Hier finden Sie Beispielprogramme zu:

GPIO-Ausgänge schalten (Lauflicht)
GPIO-Eingänge abfragen
I2C -Rasp-Info
I2C-Bus: PCF8574-Porterweiterungsbaustein
I2C-Bus: PCF8591 -A/D-Wandler

GPIO-Ausgänge schalten (Lauflicht)

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;
 
/**
 * Lauflicht
 * @author Bös
 */
public class Ausgabeleitungen {
 
  public static void main(String[] args) throws InterruptedException {
 
    System.out.println("<--Pi4J--> Lauflicht ... started.");
 
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
 
    GpioPinDigitalOutput[] pins = new GpioPinDigitalOutput[8];
 
 
    // provision gpio pin #01 as an output pin and turn on
    pins[0] = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_00, "MyLED", PinState.LOW); //GPIO 17, Board-Nr=11
    pins[1] = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.LOW); //GPIO 18, Board-Nr=12
    pins[2]=  gpio.provisionDigitalOutputPin(RaspiPin.GPIO_02, "MyLED", PinState.LOW); //GPIO 27, Board-Nr=13
    pins[3]=  gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03, "MyLED", PinState.LOW); //GPIO 22, Board-Nr=15
    pins[4]=  gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "MyLED", PinState.LOW); //GPIO 13, Board-Nr=16
    pins[5] = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, "MyLED", PinState.LOW); //GPIO 14, Board-Nr=18
    pins[6] = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, "MyLED", PinState.LOW); //GPIO 25, Board-Nr=22
    pins[7] = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07, "MyLED", PinState.LOW); //GPIO 04, Board-Nr=07
 
    System.out.println("--> GPIO state should be: ON");
 
    for(int j=0; j< 10000; j++){
       for(int i=0; i<8; i++){
         System.out.println("LED " + i + " leuchtet!");
         pins[i].high();;
         Thread.sleep(100);
         pins[i].low();;
       }
     }
     gpio.shutdown();
     System.out.println("<--Pi4J--> Lauflicht ... wurde beendet.");
  }
}

GPIO-Eingänge abfragen


GPIO-Eingänge abfragen
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.PinPullResistance;
import com.pi4j.io.gpio.RaspiPin;
 
/**
 * Hinweis: Die Nummerierung der Pins muss bei pi4j nachgeschlagen werden
 * http://pi4j.com/usage.html
 * Es gibt mindetens 3 verschiedene Zählweisen
 */
 
public class EingabeleitungAbfragen {
 
  public static void main(String args[]) throws InterruptedException {
  System.out.println("<--Pi4J--> GPIO Listen Example ... started.");
 
  // create gpio controller
  final GpioController gpio = GpioFactory.getInstance();
 
  // pin#02 entsricht Pin13, wenn man von links nach rechts und von oben nach unten durchzählt (Board-Nr.)
  // pin#02 entspricht auch GPIO#27
  final GpioPinDigitalInput myButton = gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, 
                                                                     PinPullResistance.PULL_DOWN);
  while(true){
     if(myButton.isHigh() ){
         System.out.println("High");
     }else{
         System.out.println("LOW");
     }
     Thread.sleep(500);
   }    
 }
}

Der I2C-Bus

Der I2C-Bus ist ein Zweidraht-Bus, der von Philips entwickelt wurde. Außer der Versorgungsspannung und einer Masseleitung besitzt der Bus die beiden Leitungen SDA und SCL. Über die SDA-Leitungen (= serial data) werden die eigentlichen Daten seriell (nacheinander) übertragen. Die SCL-Leitung (serial clock) gibt den Takt vor. Bausteine für den I2C-Bus sind für wenig Geld zu bekommen und eignen sich auch deshalb gut zum Experimentieren. Hier werden Programme für die Porterweiterungsbausteine (PCF8574 und MCP23017) sowie den A/D-Wandler PCF8591 vorgestellt.

Adressierung der Bausteine

Die hier beschriebenen PCF-Bausteine haben 3 Adress-Pins (A0,A1,A2), die man beliebig auf HIGH oder LOW setzen kann. Hierdurch können bis zu 8 Bausteine einer Sorte an einen I2C-Bus anschließen und adressieren. Mit dem Porterweiterungsbaustein PCF8574 käme man dann auf auf 64 Ports (8 Bausteine mit jeweils 8 Ports). Zusätzlich gibt es diesen Baustein aber noch mit unterschiedlichen Grundadressen (PCF8574, PCF8574A, ..), wodurch noch mehr Ports an einem I2C-Bus möglich werden.

I2C auf dem Raspberry

Zunächst müssen Sie den I2C-Bus auf dem Raspberry Pi aktivieren.

Eine gute Anleitung finden Sie [hier]

Sie müssen die Blackliste bearbeiten:

sudo nano /etc/modprobe.d/raspi-blacklist.conf

Raute vor Zeilen einfügen:

#blacklist spi-bcm2708 
#blacklist i2c-bcm2708

Mit dem Befehl i2cdetect -y 1 bzw. i2cdetect -y 0 können Sie herausfinden, welche I2C-Bausteine aktuell am Raspberry Pi angeschlossen sind.

pi@RasPi ~/Desktop i2cdetect -y 1

I2C-Bus: PCF8574 Quelltext(Lauflicht)


import com.pi4j.gpio.extension.pcf.PCF8574GpioProvider;
import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
 
 
public class PCF8574_Lauflicht {
 
  public static void main(String[] args) {
     I2CBus bus;
     try {
  bus = I2CFactory.getInstance(I2CBus.BUS_1);
  I2CDevice device =bus.getDevice(PCF8574GpioProvider.PCF8574_0x20);
  int i=1;
  while(true){
    if(i>128){
      i=1;
    }
    System.out.println("Schreibe Wert: ");
    device.write((byte) i );
    Thread.sleep(100);
    i=i*2;
       }  
     } catch (Exception e) {
    e.printStackTrace();
     }
  }
}

I2C-Bus: PCF8591 Quelltext

import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
 
public class PCF8591Test {
 public static void main(String[] args) {
   try {
     // create I2C communications bus instance
     I2CBus bus = I2CFactory.getInstance(I2CBus.BUS_1);
     // create I2C device instance
     I2CDevice device = bus.getDevice(0x48);
     System.out.println("Aktueller Zusatnd am PCF8574P = " + device.read());
     Thread.sleep(1000);
     while(true){
  System.out.println("Lese Wert von A/D-Wandler PCF8591: " + device.read() );
  Thread.sleep(500);
     }
   } catch (Exception e) {
  e.printStackTrace();
   }
 }
}

Weitere Informationen

Downloads

Legoroboter (pdf)

zurück