Archiv der Kategorie: Raspberry Pi

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/

MQTT Protokoll + Versuchsaufbau

Ich bin im Netz auf den Begriff MQTT gestossen und fand den Ansatz dahinter richtig gut. Deshalb habe ich mir mal einen kleinen Versuchsaufbau gegönnt, den ich im folgenden beschieben habe.

Vorab ein paar Details zu MQTT

Infos zu MQTT

Allgemeines

MQTT regelt die Kommunikation zwischen Datenquellen und Datensenken mittels eines Brokers.

Datenquelle

Quellen für Daten können ganz unterschiedliche Geräte sein, eines haben sie jedoch alle gemeinsam, sie können Netzwerkverbindungen aufbauen um Ihre Daten weiter zu geben und sie haben was, was sie mitteilen wollen.

In der IoT können dies Sensor-Knoten sein, welche ihre Daten an einen oder mehrere Empfänger senden wollen.  Die Liste der möglichen Daten ist hierbei nahe unendlich. Beispiele sind Temperaturwerte, Schaltzustände,  Helligkeitswerte usw.

Die Quelle meldet sich an einem (oder mehreren Brokern?) an. Ihre Daten sendet sie so lange bis diese vom Broker quittiert wurden.

Datensenken (Interessenten)

Senken für Daten sind bei MQTT die sog. Interessenten. Diese möchten bestimmte Informationen von Quellen erhalten und diese dann Auswerten (Berechnung) oder einfach nur Präsentieren (Bildschirmanzeige). Beispiele sind Handy Apps, eine Lampe die wissen will wann sie eingeschaltet wird usw.

Broker

Der Broker dient als Bindeglied zwischen den Quellen und den Senken. Er hat die Aufgabe, Daten von Quellen zu sammeln und diese an die Interessenten weiter zu reichen.  Eine Auswertung/ Aufbereitung der Daten ist ihm nicht gestattet, jedoch darf er die Daten zwischenspeichern, um zum Beispiel neuen Interessenten mit dem zuletzt empfangenen oder auch mit historischen Werten zu versorgen.

Die Idee hinter dem Protokoll ist, dass Leistungsschwache Sensorknoten nur eine Verbindung mit einem Broker (Empfänger Server) aufbauen und nur an diesen senden sie ihre Daten. Der leistungstärkere Broker verteilt die Informationen dann an die Interessenten.

Ein kleines Projekt

Ich habe ein kleines Projekt aufgesetzt, mit einem Sensorknoten als Quelle, einem Broker auf einem Raspberry Pi und meinem Handy als Senke.

Quelle

  • Board Node MCU ESP8266
  • Temperatursensor DHT11
  • Bibliothek pubsubclient

Der genaue Aufbau ist in einem anderen Beitrag bereits beschrieben, weshalb ich mich hier nur auf die MQTT basierten Fakten stürze.

http://fambach.net/dht10-mit-esp8266/

Die Bibliothek installieren:

Hier ist der nach MQTT angepasste Quellcode:

ESP8266TempSensorMQTT

Bitte die Netzwerkdaten und die Brokerdaten an eure Topologie anpassen. Achtung der DHT Sensor benötigt auch eine Bibliothek wie im gelinkten Beitrag beschrieben.

Broker

Raspberry nach belieben aufsetzten oder so wie hier:

http://fambach.net/raspberry-pi-zero-w-headless-installation/

Auf dem Pi dann die Mosquitto software installieren.

Software Download

Link: http://mosquitto.org/download

Die letzte Version holen, der Link kann von der obigen Seite kopiert werden. Die aktuelle Version kann mit wget direkt auf den PI geholt werden:

sudo wget <direkter link zum paket>

in meinem Fall war das

sudo wget http://mosquitto.org/files/source/mosquitto-1.5.tar.gz

Installation

Benötigte libs installieren mit

sudo apt-get install libwrap0-dev libcurl4-openssl-dev libmysqlclient-dev libssl-dev apt-get install uuid-dev 

Paket auspacken:

tar zxf ./mosquitto-1.5.tar.gz

In den ausgepackten Ordner springen und mosquitto …

cd mosquitto-1.5/

… bauen und Installieren …

make
sudo make install
sudo ldconfig

… noch starten

Den ESP8266 starten und die erste Verbindung sollte klappen:

Senke

Ich verwende mein Handy als Senke und einen MQTT Empfänger APP. Ich habe ein paar probiert, bin dann aber erstmal mal bei „IoT MQTT Panel“ hängen geblieben, weil sie auf Anhieb funtkionierte und auch Platzhalter unterstüzt.

Hier der Link

Folgende Einstellungen habe ich vorgenommen, ihr müsst diese natürlich an eure Applikation und Netzwerktopoligie anpassen.

Erstmal eine neue Verbindung erstellen mit den Verbindungsdaten des Mosquitto Servers.

Die Neue Verbindung öffnen

Fazit

Solch ein MQTT Projekt ist in wenigen Stunden aufgebaut und macht Spaß. Dabei hat es noch großes Potential, denn man kann leicht mehrere Knoten mit einem standard Server verbinden und sich die Daten z.B. auf dem Handy anzeigen lassen.

Quellen

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

Java Client Phao

MQTT Git-hub Community Wiki
https://github.com/mqtt/mqtt.github.io/wiki

Github Seite mit MQTT libs
https://github.com/mqtt/mqtt.github.io/wiki/libraries

Lib für ESP8266 und Andere
https://github.com/knolleary/pubsubclient

Mosquitto Broker Konfigurationhilfe

Quick Guide to The Mosquitto.conf File With Examples

MQTT best practice

MQTT Essentials Part 5: MQTT Topics & Best Practices

 

Raspberry Pi 1

Raspberry Pi 1 Model B+

Übersicht

Name Raspberry Pi 1.0/A+/B+  
Anzahl/CPU
ARM1176JZF-S
Takt (MHz)700
Kerne1
Digital IOs / Pins17 - 26
Analog inputs0
PWM2
SPI1
Flash Speicher micro SD Karte
SRam (KB)256/512
EEPROM (KB)-
WiFi-
Verschlüsselung-
Bluetooth-
UART1
I2C1
Ethernet10/100 MBit
Videonormal
Sound3,5 Klinke Stereo
USB1-2
Betriebsspannung [V]5
Eingangsspannung5
Strom (mA) / Standby (mA)80-160
Größe l x b x h93 x 63,5 x 17
Gewicht [g]31

Quellen

Raspberry Pi 1 Model B+

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

https://www.pidramble.com/wiki

Raspberry PI 2.0

Raspberry Pi 2 Model B

Übersicht

Name Raspberry Pi 2.0/B  
Anzahl/CPU
ARM Cortex-A7 / ARM Cortex-A53
Takt (MHz)900
Kerne4
Digital IOs / Pins26
Analog inputs0
PWM2
SPI1
Flash Speicher micro SD Karte
SRam (KB)1024
EEPROM (KB)-
WiFi-
Verschlüsselung-
Bluetooth-
UART1
I2C1
Ethernet10/100 MBit
Videonormal
Sound3,5 Klinke Stereo
USB4
Betriebsspannung [V]5
Eingangsspannung5
Strom (mA) / Standby (mA)200-450
Größe l x b x h93 x 63,5 x 20
Gewicht [g]40

Quellen

Raspberry Pi 2 Model B

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

https://www.pidramble.com/wiki

Raspberry Pi Zero W

Der kleine Bruder des Raspberry kommt mit einer WLan Karte und reduzierten Schnittstellenumfang. Er bestitzt einen Mini-HDMI Anschluss und einen Micro USB Anschluss für Periferie wie Mouse, Tastatur, USB-Festplatten usw.. Die GPIO-Pins müssen beim Zero W selbst aufgelötet werden. Wie unten zu sehen ist, gibt es ein Standardgehäuse mit passenden Ausparungen.

 

Daten im Überblick

Name Raspberry Pi zero
  
Anzahl/CPU
ARM1176JZF-S
Takt (MHz)1000
Kerne1
Digital IOs / Pins26
Analog inputs0
PWM2
SPI1
Flash Speicher micro SD Karte
SRam (KB)512
EEPROM (KB)-
WiFi2,4 GHz, 802.11 b/g/n
VerschlüsselungWEB / WPA2 / TKIP /AES
Bluetooth4.1
UART1
I2C1
Ethernet-
VideoMicro
SoundHDMI digital
USB-
Betriebsspannung [V]5
Eingangsspannung5
Strom (mA) / Standby (mA)80-120
Größe l x b x h65 x 31 x 5
Gewicht [g]9

Pining

Das Pinning ist mit dem Raspberry Pi 2 B+ gleich.

Headless Installation

Raspberry Pi Zero W – Headless Installation

Quellen

https://raspberry.tips/raspberrypi-tutorials/raspberry-pi-modell-b-plus-gpio-pins-worksheet/

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

Raspberry Pi Zero W – Headless Installation

Hier findet ihr eine Anleitung zur Erstinstallation des Raspberry Pi Zero W ohne Monitor und Tastatur mit Hilfe eines Windows PCs. Der Vorteil den Pi Zero W „Kopflos“ (aus dem eng. Headless) zu betreiben ist, dass man die ganzen Adapter für HDMI und USB erstmal nicht braucht. Ausserdem muss man nicht einen extra Monitor besorgen oder den eigenen dauernd umschalten.

Es gibt viele ausführliche Berschreibungen im Netz, auch für andere Betriebssysteme wie Linux und MAC OS, weshalb ich mich hier nur auf die Esenz beschränke. Ich habe einige gute Anleitungen, auch für andere Betreibssystem unter den Quellen gelinkt.

Benötigt wird

Installation

Erst einmal das Raspbian Image downloaden hier.

Mit Hilfe des Programms Etscher wird das Raspbian Image dann an die richtigen Stellen auf der SD Karte geschrieben.
Etscher kann hier gedownloaded werden.
Nach dem Download das Installationsprogramm ausführen und  starten.

Schritte:

  1.  Image auswählen
  2. als Ziel die SD-Karte selektieren
  3.  den Knopf Flash! betätigen

Der eigentliche Schreibvorgang dauert eine Weile. Wenn Etscher fertig ist, die SD-Karte kurz aus dem Slot nehmen und wieder einstecken. Etscher wirft nach dem flashen die SD-Karte software- technisch aus.

Mit dem Explorer das boot Laufwerk öffnen. (Achtung der Rest der SD Karte ist nicht ohne weiteres unter Windows einsehbar.

Mit dem Editor eine Datei mit Namen wpa_supplicant.conf im boot Verzheichnis erstellen und darauf achten, dass Windows nicht die Endung .txt anhängt. In sie werden die WLAN Verbindungsdaten geschrieben:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="test"
    psk="mypassword"
    key_mgmt=WPA-PSK
}

Bitte die SSID und den Key durch die eigenen WLAN Daten ersetzen.

Für den automatischen Start des SSH-Servers, der eine spätere Netzwerkverbindung zum Pi ermöglicht, bedarf es nur einer einfachen Datei mit dem Namen ssh. (Auch hier darauf achten dass Windows kein .txt anhängt.

Das wars für den ersten Start. Die SD-Karte in den Raspberry stecken und einschalten. Es kann etwas dauern bis der Pi sich mit dem WLan verbunden hat, also etwas Geduld.

Um eine SSH Verbindung zum Raspberry aufzubauen, benötigt man seine Adresse oder den Namen unter dem er im Netzwerk angemeldet ist. Ich habe in meinem WLan Accesspoint (z.B. Fritzbox) nachgesehen wie die Adresse lautet.  (Es ist auch möglich den Namen zu verwenden „raspberrypi“. (Da ich aber noch einen Pi im Netz habe würde das bei mir nicht funktionieren).

Zur Verbindung muss das Programm Putty gestartet werden , der Namen oder die Adresse des Raspberry eingegeben werden und der Open Knopf gedrückt werden.

Der initiale Benutzer ist pi und das Passwort raspberry, beide in der geöffneten Konsole eingeben.

Nun kann der Raspberry nach Belieben angepasst werden. Als erstes sollte jedoch das pi Passwort geändert werden. Der Befehl hierfür lautet passwd.

Viel Spaß damit!

Quellen

https://core-electronics.com.au/tutorials/raspberry-pi-zerow-headless-wifi-setup.html

https://www.heise.de/make/meldung/Raspberry-Pi-Zero-W-Bluetooth-und-WLAN-Update-fuer-Mini-Himbeere-3637499.html

https://www.heise.de/ct/artikel/Raspberry-Pi-Das-richtige-Modell-und-Betriebssystem-die-schoensten-Projekte-3303489.html

Raspbian

Raspberry Pi Zero W ausprobiert

Raspberry Pi Zero W

 

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 ….