Archiv der Kategorie: Raspberry PI 3

Raspberry Pi Mirror OS

Kurzbeschreibung

Mirror OS ist ein Betriebssystem, entwicket für smarte Spiegel. Dies sind Spiegel die eine Art Handy Funktionaltität bieten.

Was wird gebraucht

Vorkenntnisse mit dem Raspberry Pi und Linux können nicht schaden ;). Auch hilft es sicherlich schon mal SSH verwendet zu haben.  Ansonsten braucht ihr folgendes.

Hardware

  • Ich habe noch einen Pi B+ V1.2 rumliegen der soll als erstes Versuchsobjekt dienen.
  • Eine 65GB Microsdkarte.
  • WiFi Adapter 😉

Software

  • Mirror OS hier downloaden.
  • SD Formater hier downloaden.
  • Etcher zum beschreieben der SD Karte hier.

Sonstiges

  • Windows PC

Installation

SD Vorbereiten

Die folgenden Aktionen passieren auf deinem Windows PC. Die Installation über Mac ist auch möglich, dafür bitte den original Link zum Mirror OS folgen.

Formatieren

Ich bin nicht sicher ob dieser Schritt wirklich nötig ist, aber ich habe es, wie auf der mirror OS Seite, beschrieben einfach mal gemacht.

SD Card formater installieren. Hier gibts ne Anleitung.
SD Karte mit „Quick format“ formatieren.

Danach kurz die SD Karte aus dem PC entfernen und wieder einstecken. Da der Formater ein Autoauswurf auslöst ;).

Falls noch nicht geschehen das mirror OS image downloaden.

Nun Etscher installieren, falls noch nicht getan.

Das image auf die SD karte schreiben. Hierfür Etscher starten

Image auswählen

Auf Flashen drücken …

und warten …

Und fertig … ab mit der SD Karte in den PI und starten.

Leider funktioniert mein Raspberry Pi 2B nicht richitig. Ich bekomme keine Verbindung, liegt wahrscheinlich an meine Wifi Adapter.

Somit habe ich mir schnell einen PI3 noch bestellt und siehe das ich bekomme nach einer Weile ein Bild. Jetzt nur noch den Anweisungen auf dem Bildschirm folgen.

  • Über das Handy mit dem angegebenen Netz verbinden
  • Webseite http://glancr.conf öffnen
  • Netzwerk einstellen und eine richtige E-Mail angeben
  • Wenn alles klappt bekommt ihr eine E-Mail in der links zur Konfiguration stehen.
  • Dann noch Module runter laden und installieren
  • Die Module anordnen …

und das wars. Die Bedienung ist einfach und intuitiv. Evtl in der Konfiguration noch das Bild drehen, hier steht wie es geht.

Der Fernsehertest

So kanns aussehen, die Temperatur stimmt wohl noch nicht ganz. Aber wie man sieht spiegelt mein Fernseher auch ;).

Fazit

Wenns mal geklappt hat das Mirror//OS zu installieren, ist es ein wirklich nettes System. Es gibt auch schon ein paar Module die von der Website heruntergeladen und einfach auf der Konfigurationsseite installiert werden können.

Das Arrangieren der einzelen Module ist sehr einfach gehalten. Es kann nur bestimmt werden ob das Modul über den halben oder den ganzen Bildschirm gehen soll und die Reihenfolger untereinander. Was durch dies Anordnung am Ende Rauskommt sieht dann überaschend gut aus ;). So scheinen die Halbbildschirmmodule nach ihrem Platzaufbedarf fliessend nebeneinander angeordnet zu werden.

Alles in allem ein gelungenes OS, gut zu Installieren und zu Konfigurieren.

Problem

Mit dem PI 2 hats bei mir nicht funktiniert, was aber eher den WIFI Adapter geschuldet ist.

Beim ersten Anlauf hat es auch nicht mit dem PI3 Funktioniert. Habe dann das Image nochmal neu auf die SD Karte geschrieben und von Vorne angefangen.

 

Quellen

https://www.sdcard.org/downloads/formatter_4/

https://etcher.io/

mirr.OS

FAQ https://glancr.de/hilfe/

Raspberry PI 3

Der Raspberry Pi 3 ist im Februar 2016 erschienen und löst seinen Vorgänger mit neuen Komponenten ab. Neben einer integrierten WLan Karte besitzt er einen ARM Cortex-A53 Prozessor. Die vier Kerne werden mit 1200 MHz getaktet wird.  Der Arbeitsspeicher ist mit 1024 MB doppelt so groß.

Daten im Überblick

Name Raspberry Pi 3.0  
Anzahl/CPU
ARM Cortex-A53
Takt (MHz)1200/1400
Kerne4
Digital IOs / Pins26
Analog inputs0
PWM2
SPI1
Flash Speicher micro SD Karte
SRam (KB)1024
EEPROM (KB)-
WiFi2,4 GHz 80.11, b/g/n
VerschlüsselungWEB / WPA2 / TKIP /AES
Bluetooth4.1/4.2
UART1
I2C1
Ethernet10/100/100 MBit
Videonormal
Sound3,5 Klinke Stereo
USB-
Betriebsspannung [V]5
Eingangsspannung5
Strom (mA) / Standby (mA)260-730
Größe l x b x h93 x 63,5 x 20
Gewicht [g]40

Headless setup

https://caffinc.github.io/2016/12/raspberry-pi-3-headless/

Aufbau der Platine und Pinout

Pinning für Programmiersprachen

Java

Quellen

Raspberry Pi 3 Model B

https://de.wikipedia.org/wiki/Raspberry_Pi

http://www.pi4j.com

 

Raspberry PI + Servo

Ansteuerung eines Servos mit dem Raspberry PI 3.
Hierbei geht es nur um die grundlegende Technik, der Einsatz könnte beispielsweise ein Mobiler Roboter sein.

Der Servo soll hierbei über den Software PWM angesteuert werden um die Hardwar PWMs für andere Funktionen frei zu halten.

Zusätzlich soll der Servo nicht wie üblich über Integer Werte gesteuert werden sondern über eine Gradzahl im Bezug zur Mittelstellung des Servos.

Das unten stehende Bild zeigt was hiermit gemeint ist.

Auf die eigentliche Funktionsweise eines Servos gehe ich hier nicht ein, dies kann bei Bedarf bei http://rn-wissen.de/wiki/index.php/Servos oder anderen Websites nachgelesen werden.

Benötigte Hardware

  • PI3 (oder älter bitte auf die richtigen Pins achten)
  • Standard-Servo
  • Diverse Kabel ( Vorgefertigte Pin-Header Kabel)

Aufbau der Schaltung

Die Ansteuerung des Servos geschieht in meinem Fall über GPIO 27. Die Spannungsversorgung liefert der PI. Für größere Servos müsste evtl. auf eine externe Spannungsversorgung zurückgegriffen werden.

(Die GPIOs gelten nur in Verbindung mit pi4j und wirePi)

 

Software

Als Entwicklungsumgebung verwende ich BlueJ auf dem PI selbst. Hiermit habe ich die folgenden Klassen erstellt.


Code

Ein Erster Test

Ein guter Anfang ist immer den im Internet gefundenen Code eine Main Funktion zu packen, um zu schauen ob überhaupt was klappt. Dies habe ich in Form der FirstTest Klasse getan. Sie fährt alle Positionen des Servos ab. Die Funktionalität ist hier nicht gekapselt.

import com.pi4j.wiringpi.SoftPwm;

public class FirstTest
{
    static int max = 27;
    static int min = 4;
    static int pin = 27;

    static void setMin(int min){
        FirstTest.min = min;
    }

    static void setMax(int max){
        FirstTest.max = max;
    }

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

        // initialize wiringPi library
        com.pi4j.wiringpi.Gpio.wiringPiSetup();

        // create soft-pwm pins (min=0 ; max=100)
        SoftPwm.softPwmCreate(pin, 0, 200);

        int j = 0;
        // continuous loop
        while (j < 10) {
            // fade LED to fully ON
            for (int i = min; i <= max; i++) {
                SoftPwm.softPwmWrite(pin, i);
                Thread.sleep(100);
            }

            // fade LED to fully OFF
            for (int i = max; i >= min; i--) {
                SoftPwm.softPwmWrite(pin, i);
                Thread.sleep(100);
            }
            j++;
        }

        // make sure to stop software PWM driver/thread if you done with it.
        //
        SoftPwm.softPwmStop(1);
    }
}

Gekapselter Code

Als nächsten Schritt habe ich den Code aus dem ersten Test genommen und ihn mit ein paar Änderungen in eine Klasse gepackt. Hierbei habe ich auch die Umrechnung von absoluten Werten in Grad implementiert. Für den Test der Klasse habe ich wiederum eine Main-Klasse erstellt die alles mal aufruft.

Servo-Klasse

Klasse zur Steuerung des Servos. Die zwei wichtigsten Methoden sind:

  • setPos – Setzen der Position, Wertebereich von posMin bis posMax wobei (posMax-posMin+1)  die Mittelstellung ist.
  • setDeg – Diese Methode projeziert die angegebene Gradzahl auf die möglichen Positionen (aktuell sehr ungenau 🙁 )
import com.pi4j.wiringpi.SoftPwm;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioPin;

/**
 * Control class for servo motors
 * @author Stefan Fambach (With help of many others)
 * @version 0.1
 * 
 * This class can either set position by values between posMin and posMax
 * or it can caluculate the position by an angle where degMin <= angle <= degMax
 * 
 * No warranty free for use see GPL v3.
 */
public class Servo
{
    Pin pin;

    int degMin = -90;
    int degMax = 90;

    int posMin = 4; // to have a center
    int posMax = 25;
    int pos = -1;

    /**
     * range between min and max degree
     */
    double degDelta = degMax - degMin;

    /**
     * range between min and max position
     */
    double posDelta = posMax - posMin;

    /**
     * multiplier for degree to pos calculation
     */
    double multiplier = posDelta/degDelta;

    /**
     * Time in ms to wait after new position is set
     */
    int timeout = 1000;

    /**
     * Default constructor, default pin is GPIO_27
     */
    public Servo(){
        this(RaspiPin.GPIO_27);
    }

    /**
     * Constructor for objects of class Servo
     */
    public Servo(Pin controlPin) 
    {
        this.pin = controlPin;
        // initialize wiringPi library
        com.pi4j.wiringpi.Gpio.wiringPiSetup();

        // create soft-pwm pins (min=0 ; max=100)
        SoftPwm.softPwmCreate(this.pin.getAddress(), 0, 200);

        moveCenter();

    }

    /** 
     * set position in degree, only 20 positions are possible, each step will be calculated
     */
    boolean setDeg(int deg) throws Exception {
        if(deg > degMax){
            throw new Exception( "Entered deg: "+ deg + "is greater maxDeg "+degMax);
        }

        if(deg < degMin){
            throw new Exception( "Entered deg: "+ deg + "is smaller maxDeg "+degMin);            
        }

        if(deg < 0){
            deg = (-degMin)+ deg;
        }else{
            deg -= degMin;
        }

        return setPos((int) (deg * multiplier));
    }

    /** 
     * set position posMin - posMax (default 0-21)
     */
    public boolean setPos(int pos)throws Exception{
        if(pos < 0 ){
            throw new Exception (pos + " Pos to small (<0) ");
        }

        if(pos > posMax ){
            throw new Exception (pos + " Pos to big > "+posMax+")");
        }
        if(pos != this.pos){
            this.pos = pos;
            SoftPwm.softPwmWrite(pin.getAddress(), posMin + pos);
            sleep(timeout);
            SoftPwm.softPwmWrite(pin.getAddress(), 0);
            return true;
        }
        return false;
    }

    /** 
     * set Servo to center position
     */
    public void moveCenter(){
        try{
            setPos((posMax-posMin+1)/2);
        } catch (Exception ex){
            // will hopefully never happen
        }
    }

    /** 
     * set Servo to min position
     */
    public void moveToMinPos(){
        try{
            setPos(0);
        } catch (Exception ex){
            // will hopefully never happen
        }
    }

    /** 
     * set Servo to max position
     */
    public void moveToMaxPos(){
        try{
            setPos(posMax-posMin);
        } catch (Exception ex){
            // will hopefully never happen
        }
    }

    public int getPos(){
        return this.pos;
    }

    public int getDegMin(){
        return degMin;
    }

    public int getDegMax(){
        return degMax;
    }

    public void setDegMin(int min){
        this.degMin = min;
        calculateVariables();
    }

    public void getDegMax(int max){
        this.degMax = max;
        calculateVariables();
    }

    public void setPosMin(int min){
        this.posMin = min;
        calculateVariables();
    }

    public void setPosMax(int max){
        this.posMax = max;
        calculateVariables();
    }

    public int getPosMin(){
        return  this.posMin;
    }

    public int getPosMax(){
        return  this.posMax;
    }

    /**
     * calculate the ranges for deg and pos 
     * as well as the multiplier for degree positioning of the servo
     */
    private void calculateVariables(){
        degDelta = degMax - degMin;
        posDelta = posMax - posMin;
        multiplier = posDelta/degDelta;
    }

    private void sleep(int msec){
        try
        {
            Thread.sleep(msec);
        }
        catch ( InterruptedException e)
        {
        }
    }

    public void release(){
        SoftPwm.softPwmStop(pin.getAddress());
        GpioController gpio = GpioFactory.getInstance();
        gpio.unprovisionPin(new GpioPin[]{gpio.getProvisionedPin(pin)});


    }
}

Test-Klasse

Klasse mit Main-Methode zum Testen der Servo-Klasse. In der Main-Methode werden alle Positionen abgefahren wobei die Positionierung über den Winkel relativ zur 0 Position erfolgt.

import com.pi4j.io.gpio.RaspiPin;


public class TestServo
{

    public static void main(String args[]){

        // Create the range sensor
        Servo servo = new Servo(RaspiPin.GPIO_27); 

        int j = 0;

        do {
            System.out.println("***** Start degree test from left to right *****");     

            int curPos = servo.getDegMin()-1;
            // from left to right
            for(int i = servo.getDegMin(); i < servo.getDegMax(); i++){
                try{
                    servo.setDeg(i);
                }catch(Exception e){
                    System.out.println(e.getMessage());
                }
                int cpos = servo.getPos();
                if(cpos > curPos){
                    curPos = cpos;
                    System.out.print("\n "+curPos+" : ");
                }

                System.out.print(i+" , ");

            }

            System.out.println("***** Start degree test from right to left *****");  
            curPos = servo.getDegMax() + 1;
            // from left to right
            for(int i = servo.getDegMax(); i > servo.getDegMin(); i--){
                try{
                    servo.setDeg(i);
                }catch(Exception e){
                    System.out.println(e.getMessage());
                }
                int cpos = servo.getPos();
                if(cpos < curPos){
                    curPos = cpos;
                    System.out.print("\n "+curPos+" : ");
                }
                System.out.print(i+" , ");

            }
            j++;
        } while (j < 5);

        servo.release();
    }
}

Tips

Das Positionieren über die PI4j Lib ist sehr ungenau für die 180° Bewegungsspielraum des Servos stehen gerade mal rund 20 (+-2) Positionen zur Verfügung. Das sind rund 9° pro Position.  Evtl. sollte man vorher testen welche Positionen für den Aktuellen Zweck am besten geeignet sind. Sollte der genaue Winkel wichtig sein, ist es besser diesen vorab zu messen als ihn über die setDeg Methode berechnen zu lassen.

Es gibt noch weitere Lib’s (Servoblast, … ) die evtl genauer sind, man könnte auch überlegen die Programmiersprache zu wechseln und dann den Ensprechenden Code über das Nativ-Interface anzusprechen. Als nächsten Versuch klingt Servoblast ersteinmal vielversprechend.

Weitere Schritte

PWM in Thread

Ich habe versucht den Software PWM innerhalb eines Threads laufen zu lassen, jedoch ohne Erfolg. Der Servo weigert sich zu funktionieren.  Über die Ursache hierfür bin ich mir noch im unklaren. Ich nehme allerdings an, dass hierdurch der Timer zerschossen wird.

ServoBlast

Nach diversen Tests mit unterschiedlichen Frequenzen habe ich mich entschlossen ServoBlaster od.  besser die PI variante (PiBits) zu verwenden. Die Installation gestaltet sich einfach wie folgt.

# holen der sourcen
wget https://github.com/richardghirst/PiBits/zipball/master

#umbenennen
mv master pibits.zip

#entpacken
unzip pibits.zip

#bauen
cd richardghirst-PiBits-96014c8/ServoBlaster/user
sudo make install 

#ändern des timeout von 2000 auf 500#
sudo nano /etc/init.d/servoblaster 

#eine reboot ist nicht unbedingt erforderlich 
sudo reboot

#ein starten reicht aus 
sudo /etc/init.d/servoblaster start

Programmierbeispiel

An dieser Stelle sollte nun eigentlich ein Code-Beispiel mit ServoBlast folgen. Da ich aktuell aber die Arbeiten am PI eingestellt  habe und mit dem ESP8266 und ESP32 unterwegs bin, sei auf die folgenden Links verwiesen:

https://github.com/richardghirst/PiBits/tree/master/ServoBlaster

http://www.leenabot.com/en/Servo-Motor-driver/

 

Problembehandlung

Exec Funktioniert nicht

Wenn die exec Funktion von Java nix macht ist hier ein guter Link zum Bugfixing.

http://www.javaworld.com/article/2071275/core-java/when-runtime-exec—won-t.html

Probleme mit println

Weiterhin könnte es helfen nicht die println Methode zu verwenden, sondern die print. Da zumindest mein PI den Abschluss der Zeile nicht richtig interpretieren konnte. print( „5=100\n“) hat jedoch funktioniert.

https://github.com/richardghirst/PiBits/tree/master/ServoBlaster

http://www.leenabot.com/en/Servo-Motor-driver/

Quellen

http://razzpisampler.oreilly.com/ch05.html
https://github.com/Pi4J/pi4j/blob/master/pi4j-example/src/main/java/MaestroServoExample.java
https://www.bluej.org/raspberrypi/ServoMotor.html
https://phyks.me/2015/05/controlling-servomotors-on-a-raspberry-pi.html
http://rn-wissen.de/wiki/index.php/Servos
https://github.com/richardghirst/PiBits/tree/master/ServoBlaster
https://github.com/BioMachinesLab/drones/wiki/Installing-Servoblaster

Raspberry Pi Servo Motor Steuerung

Between 0 and 1 – PWM with Raspberry Pi

 


Anhang

Pin-Belegung

 

Pi4J + BlueJ

Da ich am liebsten im Java programmiere, verwende ich die Bibliothek Pi4J zur Ansteuerung der GPIOs am Raspberry Pi 2 und 3.

Auf die Installation der Bibliothek werde ich nicht näher eingehen, da dies auf den folgenden Webseiten schon erschöpfend beschrieben wurde.

http://pi4j.com/install.html
http://pi4j.com/utility/pi4j.html
http://www.forum-raspberrypi.de/Thread-tutorial-ansteuerung-der-gpio-ports-mit-pi4j

Auch wichtig zu wissen ist, dass Pi4J auf der wiringPI Bibliothek aufbaut und diese natürlich mit installiert werden muss.

Als Entwicklungsumgebung verwende ich BlueJ, weil man hier auch gleich noch ein Klassendiagramm mit bekommt.

Also Doku gibts genug, warum dann dieser Beitrag?

Ich möchte nach und nach eine kleine FaQ erstellen mit den Problemen die ich während der Nutzung dieser beiden Tools hatte, habe und haben werde.

Die Ports machen nix

In der alten Version vom BlueJ, scheint in den Einstellungen das Flag zur Auführung als Root nicht richtig initialisiert zu sein. Nach dem Start von BlueJ einfach das Flag entfernen und wieder rein machen dann gehts. Dieses Problem scheint in der aktuellen Version behoben zu sein.

Sollte es dann immer noch nicht klappen einfach mal die IOs auf der Console testen. Hilfe gibts hier oder hier.

Soweit ich weiss muss man zur Ansteuerung der GPIOs root (od. sudo) rechte besitzen. Der Benutzer pi ist ensprechend gut ausgestattet und eignet sich am Besten für erste Tests. (Man soll sich ja nicht mehr als root anmelden ;( ).

Nach dem Upgrade geht nix mehr

Ich habe meinen Raspberry auf die neuste Version aktualisiert. Hierbei wurde auch der Kernel auf die Version 4.9.32 aktualisiert. Danach gingen die GPIOs nicht mehr. Ein Downgrade des Kernels auf die Version 4.4.50 hat das Problem erstmal gelöst. Hilfe hierzu gibt es hier und hier.

Software PWM beim Servo

Für ca. 180° stehen beim Software PWM leider nur 20 Stellungen/Schritte für den Servo zur Verfügung was ca. 9° pro Schritt entspricht.
Weiterhin gibt es durch andere Funktionen im Betriebssystem oft gewackel am Servo (jitter). Man sollte ihn so programmieren, dass die entsprechende Stellung angefahren wird und dann den PWM wieder ausschalten.

Eine bessere Möglichkeit ist natürlich einen Hardware PWM zu verwenden, wenn man noch einen frei hat ;).

Andere Bibliotheken die besser funktionieren sollen habe ich noch nicht getestet hier eine kleine Auflistung, diese müssten dann gegebenen Falls mit dem Java Native Interface angesteuert werden:

Weiteres zu PWM [1] [2] [3]

Weiter Probleme werden sicherlich folgen ….

Raspberry PI 3 + Motorsteuerung

Ziel ist es mit dem Raspberry PI 3 unter Zuhilfenahme einer Motorbrücke, 2 Gleichstrommotoren zu betreiben.

Dies soll später genutzt werden um einen zweirädrigen Roboter anzutreiben.


Hardware

PI3 (oder älter bitte auf die richtigen Pins achten)
Motorbrücke L9110s
2x DC Motor
Diverse Kabel ( Vorgefertigte Pin-Header Kabel)


Testaufbau

GPIOs am Raspberry

  • Motor1 Richtung GPIO 26
  • Motor1 Geschwindigkeit GPIO 1
  • Motor2 Richtung GPIO 24
  • Motor3 Geschwindigkeit GPIO 23

(Die GPIOs gelten nur in Verbindung mit pi4j und wirePi)

Plan


Software

Entwicklungsumgebung

Als Entwicklungsumgebung verwende ich BlueJ auf dem PI selbst. Hiermit habe ich vier Klassen erstellt. Diese werden im folgenden Abschnitt kurz erklärt.


Code

Da ich anfänglich ein paar Probleme hatte und die Motorbrücke nicht wie erwartet reagierte, habe ich mich langsam an das Thema herangetastet.

Digitale Ansteuerung

Zuerst habe ich eine kleine Testklasse geschrieben, welche die Motoren digital ansteuert. Hiermit konnte ich die richtige Verkabelung sicherstellen. Mit diesem Test ist noch keine Geschwindigkeitsregulierung möglich.

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

public class MotorPinTest
{

    public static void main (String args[]){
       GpioController gpio = GpioFactory.getInstance();
        
        
       final GpioPinDigitalOutput pin1 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.LOW);
       final GpioPinDigitalOutput pin2 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26, "MyLED", PinState.LOW);
       
       final GpioPinDigitalOutput pin3 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_23, "MyLED", PinState.LOW);
       final GpioPinDigitalOutput pin4 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_24, "MyLED", PinState.LOW);
       
       
       // play 
       
       int i = 0;
       while (i < 10){
           // forward
           pin1.high();
           pin2.low();
           pin3.high();
           pin4.low();           
           sleep(2000);
           
           // stop
           pin1.low();
           pin2.low();
           pin3.low();
           pin4.low();
           sleep(2000);  
           
           // backward
           pin1.low();
           pin2.high();
           pin3.low();
           pin4.high();

           sleep(2000);           
           
           // stop
           pin1.low();
           pin2.low();
           pin3.low();
           pin4.low();
           
           i++;
           sleep(2000);
        }
        gpio.shutdown();
        gpio.unprovisionPin(new GpioPin[]{pin1,pin2,pin3,pin4});
    }
    
    public static void sleep(long s){
        try{
            Thread.sleep(s);
        } catch (Exception e) {
            // do nothing shit happends
        }
    }
}

PWM Ansteuerung

Als nächstes habe ich eine Testklasse erstellt, die den Hardware PWM benutzt und ebenfalls die Richtungen wechselt.

import com.pi4j.io.gpio.*;
import com.pi4j.util.CommandArgumentParser;
import com.pi4j.util.Console;

public class MotorPwmTest
{
    public static void main (String args[]){
        GpioController gpio = GpioFactory.getInstance();

        GpioPinPwmOutput pwm1 = gpio.provisionPwmOutputPin(RaspiPin.GPIO_01);
        // argument array to search in

        //GpioPinPwmOutput pwm2 = gpio.provisionPwmOutputPin(RaspiPin.GPIO_26);
        final GpioPinDigitalOutput pin2 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26, "MyLED", PinState.LOW);

        GpioPinPwmOutput pwm3 = gpio.provisionPwmOutputPin(RaspiPin.GPIO_23);
        final GpioPinDigitalOutput pin4 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_24, "MyLED", PinState.LOW);

        com.pi4j.wiringpi.Gpio.pwmSetMode(com.pi4j.wiringpi.Gpio.PWM_MODE_MS);
        com.pi4j.wiringpi.Gpio.pwmSetRange(1000);
        com.pi4j.wiringpi.Gpio.pwmSetClock(500);

        // play 
        int j = 0;
        while (j < 10){
            // forward
            pin2.low();
            pin4.low();

            for(int i = 0; i < 1000; i++){
                pwm1.setPwm(i);
                pwm3.setPwm(i);
                sleep(10);
            }
            sleep(2000);

            // stop
            pwm1.setPwm(0);
            pwm3.setPwm(0);
            pin2.low();
            pin4.low();
            sleep(2000);

            // backward
            pin2.high();
            pin4.high();
            for(int i = 0; i < 1000; i++){
                pwm1.setPwm(1000-i);
                pwm3.setPwm(1000-i);
                sleep(10);
            }

            // stop
            pwm1.setPwm(0);
            pwm3.setPwm(0);
            pin2.low();
            pin4.low();
            sleep(2000);

            // turn left
            pin2.low();
            pin4.high();
            for(int i = 0; i < 1000; i++){
                pwm1.setPwm(i);
                pwm3.setPwm(1000-i);
                sleep(10);
            }
            
            // stop
            pwm1.setPwm(0);
            pwm3.setPwm(0);
            pin2.low();
            pin4.low();
            sleep(2000);
            
            // turn right
            pin2.high();
            pin4.low();
            for(int i = 0; i < 1000; i++){
                pwm1.setPwm(1000-i);
                pwm3.setPwm(i);
                sleep(10);
            }
            sleep(2000);           

            // stop
            pwm1.setPwm(0);
            pin2.low();
            pwm3.setPwm(0);
            pin4.low();
            j++;
            sleep(2000);
        }
        gpio.shutdown();
        gpio.unprovisionPin(new GpioPin[]{pwm1,pin2,pwm3,pin4});
    }

    public static void sleep(long s){
        try{
            Thread.sleep(s);
        } catch (Exception e) {
            // do nothing shit happends
        }
    }
}

Funktionalität in Klasse gepackt

Als letzten Schritt habe ich eine Klasse Drive zur Steuerung beider Motoren und die dazu gehörende Testklasse erstellt.

Drive Klasse

Klasse zur Steuerung der zwei Motoren.

import com.pi4j.io.gpio.*;
public class Drive
{
    public static final int STOP = 0;
    private int pwmMax = 1000;

    private GpioPinPwmOutput leftPwm;
    private GpioPinPwmOutput rightPwm;

    private GpioPinDigitalOutput leftDir;
    private GpioPinDigitalOutput rightDir;

    private int speedMin = 200; // with smaller values the engines are not spinning
    private int speedMax = pwmMax-speedMin;
    
    public int getSpeedMax(){
        return speedMax;
    }

    public Drive (Pin leftPwmPin, Pin leftDirPin, Pin rightPwmPin, Pin rightDirPin){
        GpioController gpio = GpioFactory.getInstance();
        
        leftPwm = gpio.provisionPwmOutputPin(leftPwmPin);
        rightPwm = gpio.provisionPwmOutputPin(rightPwmPin);

        com.pi4j.wiringpi.Gpio.pwmSetMode(com.pi4j.wiringpi.Gpio.PWM_MODE_MS);
        com.pi4j.wiringpi.Gpio.pwmSetRange(pwmMax);
        com.pi4j.wiringpi.Gpio.pwmSetClock(500);

        leftDir =  gpio.provisionDigitalOutputPin(leftDirPin, "Left Direction", PinState.LOW);
        rightDir =  gpio.provisionDigitalOutputPin(rightDirPin, "Right Direction", PinState.LOW);

    }
    public void setMinSpeed(int speed) throws Exception{
        if(speed <= STOP){
            throw new Exception("Min Speed to small!");
        }else if (speed > pwmMax){
            throw new Exception("Min Speed to big!");
        }

        speedMin = speed;
        speedMax = pwmMax-speedMin; 
    }

    public void turnLeft(int speed)throws Exception{
        int half = speed/2;// turn speed should be half of the speed 
        leftBackward(half);
        rightForward(half);

    }

    public void turnRight(int speed)throws Exception{
        int half = speed/2; // turn speed should be half of the speed
        leftForward(half);
        rightBackward(half);

    }

    public void backward(int speed)throws Exception{
        leftBackward(speed);
        rightBackward(speed);

    }

    public void forward(int speed)throws Exception{
        leftForward(speed);
        rightForward(speed);

    }

    public void leftForward(int speed)throws Exception{
        stopLeft();
        checkSpeed(speed);
        leftDir.low();
        leftPwm.setPwm(speed+speedMin);
    }

    public void rightForward(int speed)throws Exception{
        stopRight();
        checkSpeed(speed);
        rightDir.low();
        rightPwm.setPwm(speed+speedMin);
    }

    public void leftBackward(int speed)throws Exception{
        stopLeft();
        checkSpeed(speed);
        leftDir.high();
        leftPwm.setPwm(pwmMax- speed-speedMin);

    }

    public void rightBackward(int speed)throws Exception{
        stopRight();
        checkSpeed(speed);
        rightDir.high();
        rightPwm.setPwm(pwmMax-speed-speedMin);

    }

    public void stopLeft()throws Exception{
        leftPwm.setPwm(STOP);
        leftDir.low();
    }

    public void stopRight()throws Exception{
        rightPwm.setPwm(STOP);
        rightDir.low();
    }

    public void stop()throws Exception{
        stopLeft();
        stopRight();
    }

    public void release(){
        GpioController gpio = GpioFactory.getInstance();
        gpio.unprovisionPin(new GpioPin[]{leftPwm,rightPwm,leftDir,rightDir});
    }

    public boolean checkSpeed(int speed) throws Exception{
        if(speed> speedMax){
            throw new Exception("Speed value to high! " + speed +" >"+ speedMax);
        } else if(speed < STOP){
            throw new Exception("Speed value to low!");            
        }
        return true;
    }

}

Test-Drive Klasse

Klasse zum Testen der Motoren. Diese testet, wie auch im vorhergehenden Beispiel,  unterschiedliche Geschwindigkeiten und Richtungen.

import com.pi4j.io.gpio.*;
public class TestDrive
{
    public static void main (String args[]){
        Drive d = new Drive(com.pi4j.io.gpio.RaspiPin.GPIO_01,RaspiPin.GPIO_26,RaspiPin.GPIO_23,RaspiPin.GPIO_24);
        try{
            // play 
            int j = 0;
            while (j < 10){

                // forward
                System.out.print("forward: ");
                for(int i = 0; i < d.getSpeedMax(); i++){
                    d.forward(i);
                    sleep(10);
                }
                sleep(2000);
                System.out.println("...");
                // stop
                System.out.println("Stop");
                d.stop();
                sleep(2000);

                // backward
                System.out.println("backward");
                for(int i = 0; i < d.getSpeedMax(); i++){
                    d.backward(i);
                    sleep(10);
                }

                // stop
                System.out.println("Stop");
                d.stop();
                sleep(2000);

                // turn left
                System.out.println("turn left");
                for(int i = 0; i < d.getSpeedMax(); i++){
                    d.turnLeft(i);
                    sleep(10);
                }

                // stop
                System.out.println("Stop");
                d.stop();
                sleep(2000);

                // turn right
                System.out.println("turn right");
                for(int i = 0; i < d.getSpeedMax(); i++){
                    d.turnRight(i);
                    sleep(10);
                }

                sleep(2000);           

                // stop
                System.out.println("Stop");
                d.stop();
                j++;
                sleep(2000);
            }
        } catch(Exception e){
            // nothing to do wrong speed value
            System.out.println(e.getMessage());
        } finally {
            GpioController gpio = GpioFactory.getInstance();
            gpio.shutdown();
            d.release();
        }
    }

    public static void sleep(long s){
        try{
            Thread.sleep(s);
        } catch (Exception e) {
            // do nothing shit happends
        }
    }
}

 


Tips

Motoren drehen nicht in die richtige Richtung

Sollten die Motoren nicht in die richtige Richtung drehen, einfach die polarität am Anschluss an der Motorbücke vertauchen bis es passt. Sollte das nicht möglich sein, die Methoden forwardLeft/Right() und backwardLeft/Right() entsprechend anpassen.

Raspberry rebooted bei Aktivierung/Betrieb der Motoren

Sollte beim Einschalten/Betrieb der Motoren der Raspberry neu booten, kann dies am hohen Stromverbrauch der Motoren liegen. Dann sollte man überlegen die Motoren entweder über eine zusätzliche Spannungsquelle zu versorgen oder zumindest die Motoren mit einer Spule zu entstören. Condensatoren können zusätzlich Spannungspitzen abfangen.

Mehr zur Entstörung:

http://www.bnhof.de/~ho1645/entstoer.htm
https://www.mikrocontroller.net/articles/Motoransteuerung_mit_PWM

Schaltung mit zusätzlicher Spannungsquelle:

Hier wird der L9110 mit einem LiPo versorgt, wichtig ist es die Masse des Lipo mit der des Raspberries zu verbinden, sonst funktioniert es nicht. Der Lipo sollte im Bereich 3.7v und < 12V liegen (Beschränkung des L9910).

 


Quellen

Beispiel auf GitHub
PI4j Webseite
PWM + Motoren allgemein beim RoboterNetz

Einige andere Webseiten waren auch noch nützlich, einfach mal Google bemühen.


Anhang

Pin-Belegung

http://www.pi4j.com

Mit dem Raspberry PI 3 den Entfernungsmesser US-100 ansteuern

Ansteuerung eines Ultraschall-Entfernungsmessers US-100 mit dem Raspberry PI3 ( oder früher). Ich habe nur Tutorials für den SR-04 gefunden, dieser wird allerdings analog zum US-100 eingebunden.


Hardware

PI3 (oder älter bitte auf die richtigen Pins achten)
US-100 ( Ultraschallsensor)
Brot-Board (zum leichteren Aufbau)
Diverse Kabel ( Vorgefertigte Pin-Header Kabel)


Aufbau

Der US-100 arbeitet mit 3.3V womit man ihn direkt am Raspberry betreiben kann.

Verdrahtung

  • Trigger Pin am GPIO 28
  • Echo Pin an den GPIO 25

(Die GPIOs gelten nur in Verbindung mit pi4j und wirePi)

 


Software

Entwicklungsumgebung

Als Entwicklungsumgebung verwende ich BlueJ auf dem PI selbst. Hiermit habe ich zwei Klassen erstellt.


Code

Distance-Klasse

Klasse zur Steuerung des US-015, mit den Methoden

  • getDistanceMM – Entfernung in Millimetern
  • getDistanceCM – Entfernung in Zentimetern
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.GpioPinDigitalOutput;

public class Distance
{
    // instance variables - replace the example below with your own

    
    
    public static final int     DIVISOR               = 58200;
    public static final int     ERROR_NO_MEASUREMENT  = -1;
    public static final int     ERROR_DIST_TO_SHORT   = -2;
    
    private GpioPinDigitalInput     echo        = null;
    private GpioPinDigitalOutput    trigger     = null;
    private long                     timeOut     = 250000000; // in ns/ time for 4m for 20°C ~232
    private long                     triggerTime = 2;   // 10ms for SR04, 2 for US-100
    private long                     initTime    = 2;    // default 2 ms
      
    /**
     * Constructor for objects of class Distance
     */
    public Distance(GpioPinDigitalOutput trigger, GpioPinDigitalInput echo)
    {
        this.echo = echo;
        this.trigger = trigger;

    }
    
    /**
     * get the distance in mm
     */
    public double getDistMM()
    {
        return aquire()*1000;
    }
    
     /**
     * get the distance in cm
     */
    public double getDistCM()
    {
        return aquire();
    }
    
    /** 
     * returns the time in milli xeconds
     */
    public double aquire(){
        long start = 0;
        double diff = 0;

        try {
           
          trigger.low();
          Thread.sleep(initTime);
          trigger.high();
          Thread.sleep(triggerTime);
          trigger.low();
    
          while (echo.isLow()) {
            start = System.nanoTime();
          }
    
          while (echo.isHigh()) {
              //System.out.print((System.nanoTime() - start)+",");
              if((System.nanoTime() - start) > timeOut){
                  return ERROR_NO_MEASUREMENT;
              }
          }
    
          // check if distance is to short and return errror
          diff =  ((System.nanoTime() - start) / DIVISOR );
          return diff;
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        return -1.0;
    }
}

Test-Klasse

Klasse mit Main-Methode zum Testen der Distance-Klasse. In der Main-Methode wird alle 5 Sekunde ein neuer Wert vom Sensor abgefragt und auf die Console geschrieben.

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.GpioPin;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.io.gpio.PinPullResistance;

public class TestDistance
{

    public static void main(String args[]){
        final GpioController gpio = GpioFactory.getInstance();

        //range sensor pins
        GpioPinDigitalOutput sensor_trigger = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_28, 
                "Sensor Trigger", PinState.LOW);

        GpioPinDigitalInput sensor_echo = gpio.provisionDigitalInputPin(RaspiPin.GPIO_25, 
                "Sensor Echo", PinPullResistance.PULL_DOWN);

        // Create the range sensor
        Distance rangesensor = new Distance(sensor_trigger, sensor_echo);
        int i = 0;
        do {
            i++;
            // Get the range
            double distance = rangesensor.getDistCM();
            
            System.out.println("RangeSensorresult =" + distance + "cm");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        } while (i < 1000);
        

        gpio.unprovisionPin(gpio.getProvisionedPins().toArray(new GpioPin[]{sensor_trigger, sensor_echo}));
        
    }
}

Tips

Bei größerer Beanspruchung des PI ist zu beachten, dass Java die zeitlichen Abfolgen nicht garantiert. Somit kann es zu verfälschten oder keinen Ergebnissen bei der Messung kommen.

Quellen

https://www.modmypi.com/blog/hc-sr04-ultrasonic-range-sensor-on-the-raspberry-pi

http://t1m0b0t.blogspot.de/2014/04/using-ultrasonic-range-sensor-on.html

http://www.lediouris.net/RaspberryPI/HC-SR04/readme.htmlhttps://github.com/OlivierLD/raspberry-pi4j-samples/tree/master/RangeSensor

http://pi4j.com/pins/model-3b-rev1.html

Interfacing HC-SR04 Ultrasonic Sensor with Raspberry Pi

 

Entfernung messen mit Ultraschallsensor HC-SR04 – Raspberry Pi

Anhang

Pin-Belegung

 

Raspberry PI 3 LED ansteuern

Hier der erste Versuch eine LED mit dem Raspberry PI 3 anzusteuern. Aufgebaut wird das Ganze auf einem Brotboard mit Freiluft-Verkabelung.


Hardware

PI3 (oder älter bitte auf die richtigen Pins achten)
LED (Ich habe ne grüne Standard-Led 1,5V)
220 Ohm (Vorwiderstand für die LED)
Brot-Board (zum leichteren Aufbau)
Diverse Kabel ( Vorgefertigte Pin-Header Kabel)


Aufbau

Schaltplan

Verdrahtung


Software

Entwicklungsumgebung

Als Entwicklungsumgebung habe ich zum ersten mal BlueJ auf dem PI verwendet. Mir gefällt daran, dass man hier mit Klassendiagrammen erst einmal die Struktur definiert und im nächsten Schritt mit dem gleichen Tool die Implementierung realisieren kann.

Ein weiterer Vorteil bietet die Testumgebung. Es ist möglich Instanzen von Klassen per Knopfdruck zu erstellen und deren Methoden mit ein paar Klicks zu testen.


Code

LED-Klasse

Klasse zur Steuerung einer LED mit den Methoden On, Off und Toggle.

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

public class Led
{
    // instance variables - replace the example below with your own
    private GpioPinDigitalOutput pin;

    /**
     * Constructor for objects of class Led
     */
    public Led(Pin pinId)
    {
        
        if(pinId == null){
            pinId = RaspiPin.GPIO_01;
        }
        
        GpioController gpio = GpioFactory.getInstance();
        try{        // create gpio controller

               pin = gpio.provisionDigitalOutputPin(pinId);
            
        } catch(Exception e){ 

            // sollte er noch offen sein schliess mal alles und versuche es nochmal
            gpio.shutdown();
            gpio.unprovisionPin(gpio.getProvisionedPins().toArray(new GpioPin[]{}));
            gpio = GpioFactory.getInstance();
            
            pin = gpio.provisionDigitalOutputPin(pinId);
            
        }

    }
    
    void on(){
         pin.high();
    }

    void off(){
         pin.low();
    }

    
    void toggle(){
        if(pin.isHigh()){
            pin.low();
        }else {
            pin.high();
        }
    }
    
    public void close(){
        GpioController gpio = GpioFactory.getInstance();
        gpio.unprovisionPin(gpio.getProvisionedPins().toArray(new GpioPin[]{pin}));
    }
}

Der Try/Catch Block im Konstruktor ist dem Umstand geschuldet, dass meine ersten Tests auch mal schief gingen und dann die GPIOs nicht frei gegeben wurden.
Die Freigabe mache ich aktuell wenig elegant im Konstruktor. Schöner wäre vorher abzufragen ob der Pin schon initialisiert wurde und dann entsprechend weiter zu machen.

Test-Klasse

Klasse mit Main-Methode zum Testen der LED Klasse. In der Main-Methode ist eine Endlosschleife, welche die LED in einem Intervall von 2 Sekunden an und wieder aus schaltet.

public class TestLED
{
    // instance variables - replace the example below with your own
    private int x;

    /**
     * Constructor for objects of class TestLED
     */
    public void main(String args[])
    {
        Led led = new Led(null);
        while (true){
            led.toggle();
            try{
                Thread.sleep(2000);
            } catch(InterruptedException ex){
                // do nothing
            }
        }
    }
}

Tips

Starten des Programms als Root

Die GPIOs müssen als Root angesprochen werden. Im BlueJ gibt es in den Einstellungen einen Button aber dieser scheint nicht richtig initialisiert zu sein. Diesen einfach nochmal rausnehmen und wieder setzten, die Einstellungen speichern, dann sollte es gehen.

Fehlende pi4j Klassen

Wenn es beim compilieren Probleme mit fehlen pi4j Klassen gibt muss das entsprechende Paket installiert werden. (Hier gibt es Hilfe)

LED geht nicht an

Die LED geht einfach nicht an, evtl. mal mit GPIO auf der Console testen. Vielleicht stimmt die Verdrahtung nicht,  es fehlen Einstellungen oder die Pinbelegung stimmt nicht (Hier gibt es Hilfe dazu)

Quellen

http://pi4j.com/example/control.html

Raspberry Pi 2 – mit Java die GPIO ausreizen