Archiv der Kategorie: Java

Java – IP Fernbedienung

Zweck des Ganzen ist eine Fernbedienung für meine Roboter.

Da alle Roboter (zumindest die fortschrittlicheren) über eine Netzwerkverbindung verfügen, möchte ich eine kleine App entwickeln, die per Konfiguration Telegramme an einen bestimmten Empfänger versenden kann.

Erster Wurf

Im ersten Schritt soll die Fernbedienung nur aus einem Tastenfeld bestehen. Der Benutzer kann die Anzahl Zeilen und Spalten bestimmen und die Knöpfe einzeln konfigurieren. Dies sollte ausreichen eine einfache Fernsteuerung zu erstellen.

Std. Layout 3 x 3 Felder
Konfigurierte Version des 3×3 Std. Layouts.

 

 

Java Socket Konsolen Server

Die Java Socket Konsole öffnet einen Server auf einem definierten Port. Der Port kann beim Start mit übergeben werden. Wird kein Port angegeben ist der standard Port 2021.  Alles was an diesen Port gesendet wird, erscheint als zeilenbasierte Ausgabe in einem Fenster.

Das Programm ermöglicht genau eine Verbindung.  Über die Textbox am Fuß des Dialogs und den „send“ Knopf kann Text an den verbundenen Client gesendet werden.

Vorausetzung

Java Version >= 7 muss installiert sein
Wurde bis jetzt nur unter Win 10 getestet

Starten

Die Datei kann einfach per Mouse-Doppelkick gestartet werde.

Ein starten über die die Konsole, um den Port mit zu geben, sieht wie folgt aus.

Der Port kann direkt hinter dem Dateinamen angegeben werden.

Ausgabe

Dateien

Jar Archiv

SocketConsole

Sourcen (Eclipse Projekt)

net.fambach.net.socket.console.zip

Probleme

Bei Problemen Mail an mich anfrage(at)fambach.net

Quellen

http://openbook.rheinwerk-verlag.de/javainsel9/javainsel_21_006.htm

https://docs.oracle.com/javase/7/docs/api/java/net/Socket.html

https://docs.oracle.com/javase/tutorial/networking/sockets/index.html

https://javabeginners.de/Netzwerk/Socketverbindung.php

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