Archiv der Kategorie: Motorbrücke

Motorbrücken zur Ansteuerung von motoren.

NodeMCU V2 Motorplatine

Für den NodeMCU V2 gibt es ein Erweiterungsplatine mit Motortreiber. Mit ihr können zwei kleine Motoren (bis 1,2 Ampere) über eine Motorbrücke L293DD angesteuert werden.  Auch der Anschluss eines Schrittmotors ist möglich.

Sie bietet weiterhin zwei getrennte Anschlüsse für die Stromversorgung der Platine und die der Motoren. Die meisten Pins des ESP sind mit einem zusätzlichen Masse/Strom Pin herausgeführt, was den Anschluss von Peripherie erleichtert.

Die Pins D1, D2, D3, and D4 sind von der Motorbrücke belegt.

Daten

Stromversorgung: 4,5V bis 9 V
Motorspannung: 4,5V – 36V
Maximaler Motor Strom: 1,2 A

Ansicht

Frontansicht

Rückansicht

Anschlüsse

Pin-Belegung

Mit den Pins D1 -D4 können die Motoren angesteuert werden weitere Belegungen können der Tabelle unten entnommen werden.

Programmierung

Der Versuchsaufbau gestaltet sich simpel. Den ESP8266 aufs Board stecken, zwei Motoren an die entsprechenden Kontakte anschliessen und das Beispielprogramm unten, auf den ESP laden.

Bibliothek

… habe nach kurzer Suche keine gefunden, für jeden Tip bin ich dankbar.

Eigenes Testprogramm

Hier ein simpler Test. Er lässt beide Mortoren vorwärts drehen, rückwärts drehen und stoppen.

ESP8266MCUV2Motorplatine

Eigene Lib

Werde mir wohl in naher Zukunft mal eine Klasse schreiben, welche alle Funktionen kapselt.

 

Quellen

https://cdn.hackaday.io/files/8856378895104/user-mannual-for-esp-12e-motor-shield.pdf

http://www.instructables.com/id/Motorize-IoT-With-ESP8266/

ESP8266: NodeMCU Motor Shield Review

Arduino Motor Platine V1

Die Motorplatine ist perfekt für kleine Roboter-Projekte geeignet, bei denen 2 bis 4 Antriebsmotoren verwendet werden.

Zusätzlich bietet sie Anschlüsse für zwei Servos und die analogen Ports und mit ihnen auch der I2C Bus, sind durchgeschleift.

Überblick

Hier die wichtigsten Daten im Überblick:

  • 2 Servoanschlüsse
  • 2 Motorbrücken
  • 1 Schieberegistert
  • 1 Resetschalter
  • 1 Externer Spannungsanschluss
  • 1 Power LED
  • Jumper – zur Unterbrechung der Boardspannung

Ansicht

Beschaltung

Einsatz

  • Zwei-Achs-Plotter
  • 2 oder 4 Rad-Roboter
  • Pan/Tilt Stativ

Motorbrücken

Mit Hilfe der Motorbrücken können 4 Gleichstrommotoren oder 2  Schrittmotoren (mit 4 Leitungen) betrieben werden. Die L293D Motorbrücken können Motoren bis zu einem Strom vom 600mA versorgen. (Kurzzeitig bis zu 1,2 A). Wird ein höherer Strom benötigt können weitere L293D IC’s huckepack auf die vorhandenen aufgelötet und parallel betrieben werden.

Das Schieberegister, ermöglicht es mit nur 3 Pins des Arduinos die Drehrichtungen der Motoren zu bestimmen.

(evtl. mal einen Beitrag zum Scheiberegister einfügen…).

Für die Ansteuerung der Motoren gibt es unteranderem eine Bibliothek von Adarfruit. Diese kann über Git oder die Arduino GUI herunter geladen werden (siehe unten).

https://github.com/adafruit/Adafruit-Motor-Shield-library/zipball/master

Die Motorbrücken belegen die folgenden Pins am Arduino:

  • Pin 11 Motor 1 – Geschwindigkeit
  • Pin   3  Motor 2 – Geschwindigkeit
  • Pin   5  Motor 3 – Geschwindigkeit
  • Pin   6  Motor 4 – Geschwindigkeit
  • Pin   4, 7, 8, 12 Richtungsvorgabe für alle Motoren über 74HC595 Register.

Servoanschlüsse

Das Bord verfügt über zwei Steckplätze für Standardservos. Jeder Steckplatz hat drei Pins jeweils einen für Strom, Masse und den Steuereingang.

Die Steuereingänge belegen die folgenden Pins am Arduino:

  • Pin 9    – Servo 1
  • Pin 10 – Servo 2

Externe Spannungsversorgung

Hier können von 4.5V bis zu 25V an Schraubklemmen angelegt werden. Bitte auf die Polung achten sonst rauchts …

Kompatibilität

Der Shield kann mit folgenden Boards verwendet werden.

Arduino Uno

Arduino Uno

Arduino Leonardo

Arduino Leonardo

Uno + WiFi

Bedingt kompatibel, es wird eine externe Spannungquelle benötigt um mehr als einen Servo zu betreiben.

Arduino Uno + WiFi

Software

Bibliothek installieren

Ich habe mir die Bibliothek über GitHub herunter geladen und sie manuell installiert. Über die Arduino GUI geht es etwas einfacher.

Bibliotheksmanger aufrufen:

Nach „motor“ suchen und die „Adafruit Motor Shield Library“ in der letzten Version installieren.  Aufgepasst es gibt eine „Adafruit Motor Shield V2“ diese kann leider nicht für die V1 Platine verwendet werden. (Motorplatine V2).

Servos ansteuern

Im Grunde werden die Servos ganz normal über die Arduino Bibliothek angesprochen. Wichtig für die Motorplatine ist nur, dass hier die Servos an Port 9 und 10 angeschlossen sind.

Meine Billigservos, harkeln einwenig an den Endpunkten, diese könnte man noch ausschliessen indem man die Konstanten min und max anpasst.

Über den Faktor kann die Schrittgröße bestimmt werden und über wait die wartezeit zwischen den einzelnen Schritten.

#include  // inlcude library for servos

// init servos 
#define SERVO_PIN_1 9
#define SERVO_PIN_2 10
Servo servo1;
Servo servo2;

void setup() {

  // initialize serial port
  Serial.begin(9600);
  
  // leonardo workaround waiting for serial port to be ok
  while(!Serial)delay(1);

  // init servos
  Serial.print("Init Servos .");
  servo1.attach(SERVO_PIN_1); Serial.print(".");
  servo2.attach(SERVO_PIN_2); Serial.println(".");
}

const int min = 0, max = 255;
int  cur = 0, factor = 1, wait = 10;

void loop() {
  // put your main code here, to run repeatedly:
  if(cur <= min){ // change to positive direction
    cur = 0; factor *= -1;
    Serial.println("Start positive direction");
  }else if( cur >= 255){ // change to negative direction
    cur = 255; factor *= -1;
    Serial.println("Start negative direction");
  } 

  Serial.print(".");
  servo1.write(cur);
  servo2.write(cur);
  
  cur += factor;
  delay(wait);
}

ServoTest.ino

Motoren Ansteuern

Für einen ersten Test habe ich das vorhandene Beispielprogramm verwendet.

Einfach auswählen, kopilieren und schon läuft Motor 1.

Um alle 4 Motoren zu testen, was nützlich erscheint um die Drehrichtungen (Polung) zu überprüfen, habe ich die Datei wie folgt angepasst.

MotorTest2.ino

Die Ausgabe sollte dann wie folgt aussehen.

Quellen

https://playground.arduino.cc/Main/AdafruitMotorShield

https://learn.adafruit.com/adafruit-motor-shield/library-install

https://learn.adafruit.com/adafruit-motor-shield

https://learn.adafruit.com/adafruit-motor-shield/faq

 

Motorbrücken

Die Ausgänge von Mircrocontroller sind meist nur mit wenigen milli Ampere Strom belastbar. Dies reicht zur Ansteuerung einer LED aus ,ist aber für Motoren und andere Bauteile die mehr Leistung benötigen, nicht ausreichend.

Weiterhin ermöglicht die Motorbrücke eine Erhöhung der Betriebspannung, so können an Microcontrollern die mit 3.3V oder 5V betrieben werden, auch Motoren mit einer Spannung von beispielsweise 12V angeschlossen werden.

Unter folgenden Link ist die Funktion der Motorbrücke sehr gut beschieben, weswegen ich hier auf eine erneute Beschreibung verzichte.

http://www.asurowiki.de/pmwiki/pmwiki.php/Main/Motorbruecke

Schaltung

http://www.asurowiki.de/pmwiki/pmwiki.php/Main/Motorbruecke Copyright GNU FDL

Ansicht

Einfache Motorbrücke für zwei Motoren

Motorbrücken zum Aufstecken auf den Arduino UNO. Hat Ausgänge für 4 Motoren oder 2 vierpolige Schnrittmotoren.

Link zum Artikel

Weitere Bilder folgend …

Quellen

http://www.asurowiki.de/pmwiki/pmwiki.php

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

 

Arduiono Motor Platine V2

Die Motorplatine V2 ist eingetroffen. Ich habe gleich mal das Testprogramm der V1 angepasst und die Platine auf den Wemos Uno gesteckt, um zu sehen ob die Beiden zusammen harmonieren.

Die Ansteuerung der Servos funktioniert auf dem Wemos nicht, da die Pins für die serielle Schnittstelle verwendet werden.

Überblick

Hier die wichtigsten Daten im Überblick:

  • 2 Motorbrücken
  • (2 Servoanschlüsse)
  • 1 Wire (I2c) ansteuerung für die Motoren
  • 1 Externer Spannungsanschluss
  • 1 Power LED
  • Jumper – zur Unterbrechung der Boardspannung
  • Platz für zusätzliche Schaltungen
  • Möglichkeit eine weitere Platine aufzustecken

Ansicht

 

 

Beschaltung

Kompatibilität

Die Platine kann mit folgenden Boards verwendet werden.

Arduino Uno

Arduino Uno

Arduino Leonardo

Arduino Leonardo

Wemos d1 d2 esp8266

Da die Platine über den I2c Bus betrieben funktioniert sie auch mit dem WeMos. Allerdings gibt es die bekannten Einschränkungen bei den Analogen Ports, hier ist nur einer durchgeführt.

WeMos D1 R2 ESP8266

Software

Bibliothek installieren

Installation über die Ardurino GUI.

Bibliotheksmanger aufrufen:

Nach „motor“ suchen und die „Adafruit Motor Shield Library V2“ in der letzten Version installieren. In meinem Fall ist das die 1.0.5.

Achtung es gibt auch eine Biliothek „Adafruit Motor Shield Library“  diese ist für die alte Version des Boards.

Servos ansteuern

Die Ansteuerung der Servos funktioniert auf dem ESPClone nicht, da die Pins für die Serielle Schnittstelle mit verwendet werden. Für die anderen Boards ist sie gleich zur V1 Platine.

Motoren Ansteuern

Ich habe einfach das Testprogramm des V2 Boards angepasst. Weitere Erleuterungen findet ihr hier.

MotorSchieldV2Test.ino

Quellen

https://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino/overview

https://github.com/adafruit/Adafruit_Motor_Shield_V2_Library

https://store.arduino.cc/adafruit-motor-stepper-servo-shield-v2-3

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

Motorbrücke L9110s

Hier ein paar Informationen über die Motorbrücke L9110s. Ich habe ein Modul mit zwei dieser Treiber im Einsatz. Ein Hauptvorteil dieses Moduls ist der geringe Preis. Ein Nachteil ist die geringe Stromabgabe die ihn für größere Motoren unbrauchbar macht.

Zur Steuerung der Motoren sind jeweils zwei Pins pro Motor nötig.

Pinbelegung

Laut dateblatt ist die Beschaltung wie folgt:

Vorwärts:

Pin1 – PWM-Signal für die Geschwindigkeit
Pin2 – Auf Masse

Rückwärts:

Pin1 – Auf Massse
Pin2 – PWM-Signal für die Geschwindigkeit

! Die Beschaltung wie bei Anderen Motorbrücken z.B. L293 .. :

Pin1 – gibt die Geschwindigkeit mit Hilfe einen PWM Signals vor
Pin2 – gibt die Richtung mit digital High/Low vor.

Hat mit diesem Modul nicht funktioniert.

Es gibt jedoch einen Trick um trotzdem nur 2 PWM Pins verwenden zu können:

Vorwärts:

Pin1 – PWM-Signal für die Geschwindigkeit
Pin2 – Auf Masse

Rückwärts:

Pin1 – PWM-Max – PWM-Signal für die Geschwindigkeit
Pin2 – Auf VCC.

PWM-Max ist hierbei der maximale Wert bei dem Der PWM über die komplette Periodendauer auf High ist. Beispiel PWM von 0-255. dann ist PWM-Max = 255.

Technische Daten

BeschreibungWert
Anz. Motor2
TreibershipL9110s
VCCmin2,5V
VCCmax12V
Imax0,8A
Größe2,8 cm x 2,1 cm
Preis~ 0,60€

Beschaltung des Modules

Laut Datenblatt

Vorwärts

A-1A – PWM signal gibt die Geschwindigkeit an
A-1B – auf Masse

B1A – PWM signal gibt die Geschwindigkeit an
B1B- auf Masse

Rückwärts

A-1A – auf Masse
A-1B – PWM signal gibt die Geschwindigkeit an

B1A – auf Masse
B1B- PWM signal gibt die Geschwindigkeit an

Links? drehen

A-1A – PWM signal gibt die Geschwindigkeit an
A-1B – auf Masse

B1A – auf Masse
B1B- PWM signal gibt die Geschwindigkeit an

Rechts? Drehen

A-1A – auf Masse
A-1B – PWM signal gibt die Geschwindigkeit an

B1A – PWM signal gibt die Geschwindigkeit an
B1B – auf Masse

Schaltung mit nur 2 PWMs

PWM-Max = 1000

Vorwärts

A-1A – PWM Signal gibt die Geschwindigkeit an
A-1B – auf Masse

B1A – PWM Signal gibt die Geschwindigkeit an
B1B- auf Masse

Rückwärts

A-1A – 1000 – PWM Signal gibt die Geschwindigkeit an
A-1B – auf Vcc

B1A – 1000 PWM Signal gibt die Geschwindigkeit an
B1B- auf Vcc

Links? drehen

A-1A – PWM Signal gibt die Geschwindigkeit an
A-1B – auf Masse

B1A – 1000 – PWM Signal gibt die Geschwindigkeit an
B1B – auf Vcc

Rechts? Drehen

A-1A – 1000 – PWM Signal gibt die Geschwindigkeit an
A-1B – auf Vcc

B1A – PWM Signal gibt die Geschwindigkeit an
B1B – auf Masse

Quellen

Datenblatt l9110
Datenblatt Platine