Dauerkalender

Motortreiber L293D mit drei Motoren
(und zwei unterschiedlichen Betriebsspannungen)

Der kleine 16-beinige Motortreiber L293D soll in diesem Versuch gleich drei Motoren gleichzeitig ansteuern. Eigentlich ist der zweikanalige Baustein für zwei Motoren ausgelegt, und zwar so, dass die Drehzahl und Drehrichtung für beide Motoren separat einstellbar ist. Werden an einem Kanal zwei Motoren statt nur einem angeschlossen, lässt sich die Drehrichtung der beiden Abnehmer nicht mehr verändern. Um die Schaltung noch ein wenig interessanter zu gestalten, werden beide Kanäle mit unterschiedlichen Spannungen betrieben. Am ersten Kanal wird ein 12VDC-Gleichstrommotor angeschlossen. An den zweiten Kanal schließen wir zwei 5VDC-Gleichstrommotoren. Zu beachten ist die Gesamtleistung der Motoren. Der Treiber L293D kann eine Belastung von bis zu 600 mA pro Kanal vertragen, kurzfristig sogar etwas mehr. Grundsätzlich ist der IC für kleine Motoren vorgesehen. Für den Treiber spricht zusätzlich die Tatsache, dass er bereits Freilaufdioden integriert hat. Sie fangen die bei Gleichstrommotoren entstehenden Induktionsspannungen ab.
Die Schaltung statten wir mit zwei Tastern und zwei Potentiometern aus. Mit einem Taster werden die Motoren gestartet, mit dem zweiten kann die Drehrichtung des Motors, der an dem ersten Kanal angeschlossen ist, geändert werden. Mit beiden Potis werden die Drehzahlen der Motoren gesteuert. Eine blaue Leuchtdiode informiert, ob die Steuerung der Motoren aktiviert wurde.

L293D

Der Motortreiber L293D kann zwei Motoren steuern. Die Drehzahl und Drehrichtung können von extern eingestellt werden. Die wichtigsten Daten:

Anwendung: DC-Motor-Treiber, Relaistreiber, Schrittmotor-Treiber, Zwei-Phasen-Motor-Treiber
Versorgungsspannung: 4,5 .. 36 VDC
Eingangsspannung: 2,3 ... 7 VDC
Belastbarkeit: 600 mA pro Kanal (1A Spitzenstrom)
Schutz vor Übertemperatur: Ja
Temperaturbereich: 0 .. +70 °C

Schaltplan

Die Hauptspannungsversorgung der Schaltung beträgt 12VDC. Mit der Spannung wird der erste Kanal des Motortreibers L293D versorgt. Mit der Spannung wird der Motor 1 (12VDC) betrieben. Der zweite Kanal des Motortreibers wird mit der 5VDC Spannung versorgt, die aus dem Spannungsregler stammt. Mit dieser Spannung wird gleichzeitig der Arduino Nano versorgt. Die Drehrichtung des Motors 1 wird mit den Eingängen Pin 2 (Arduino Ausgang Pin D4) und Pin 7 (Arduino Ausgang D3) bestimmt. Wenn am Eingang Pin 2 High-Potenzial anliegt, am Pin 7 dagegen Low-Potenzial, dreht der Motor in eine Richtung. Wenn man die Potenziale vertauscht, erfolgt eine Drehung in andere Richtung. Weisen beide Inputs das gleiche Potenzial auf, bremst der Motor und bleibt stehen. Die Umschaltung der Drehrichtung erfolgt mit dem Taster S1. Die Drehgeschwindigkeit des Motors wird mit einem PWM-Signal am Pin 1 (Arduino Ausgang D5, PWM-fähig) bestimmt. Entsprechende Vorgabe erfolgt mit dem Potentiometer P1, der an den analogen Eingang A0 des Arduino angeschlossen ist.
Mit dem zweiten Kanal des Motortreibers werden zwei Motoren gesteuert. Die Funktionalität der Eingänge entspricht dem ersten Kanal. In dieser Konstellation kann die Drehrichtung der Motoren M2 und M3 nicht verändert werden. Beide Motoren bekommen auch die gleiche Drehgeschwindigkeitsvorgabe. Die Drehzahl wird mit dem Potentiometer P2 bestimmt.
Die Schaltung wird mit dem Taster S2 aktiviert bzw. deaktiviert. Der aktuelle Zustand wird mithilfe der Status-Leuchtdiode LED1 signalisiert.

Testschaltung

Programm (Sketch)

#define Drehrichtung_Motor1_A 3                     // Arduino Pin D3
#define Drehrichtung_Motor1_B 4                     // Arduino Pin D4
#define Taster_Drehrichtung_Umkehr_Motor1 2         // Arduino Pin D2
#define PWM_Drehzahl_Motor1 5                       // Arduino Pin D5
#define PWM_Drehzahl_Motor2_3 6                     // Arduino Pin D6
#define Poti_Drehzahl_Motor1 A0                     // Arduino Pin A0
#define Poti_Drehzahl_Motor2_3 A1                   // Arduino Pin A1
#define Taster_Motoren_Start 7                      // Arduino Pin D7
#define Motoren_gestartet 8                         // Arduino Pin D8

bool Taster_Start, Merker1;
bool Taster_Richtung, Merker2;
bool Richtung;
int Drehzahl_M1;
int Drehzahl_M2_M3;
int Start;
unsigned long Millis;
unsigned long Millis_Start_alt;
unsigned long Millis_Richtung_alt;

//*********************************************************************************************
void setup() {

  pinMode(Drehrichtung_Motor1_A, OUTPUT);
  pinMode(Drehrichtung_Motor1_B, OUTPUT);
  pinMode(PWM_Drehzahl_Motor1, OUTPUT);
  pinMode(Motoren_gestartet, OUTPUT);
  pinMode(Taster_Drehrichtung_Umkehr_Motor1, INPUT_PULLUP);
  pinMode(Taster_Motoren_Start, INPUT_PULLUP);
}

//*********************************************************************************************
void loop() {

    Millis = millis();                                         // Zeit Messung

    // ----------------------------------------------------------------------------------------
    Taster_Start = digitalRead (Taster_Motoren_Start);         // TASTER Motoren Start
    if (!Taster_Start && !Merker1) {                           // Ein Signal muss mindestens
        Millis_Start_alt = Millis;                             // 100 ms anliegen, bevor eine
        Merker1 = true;                                        // Reaktion erfolgt.
    }   
    if (Taster_Start && Merker1 && Millis - Millis_Start_alt <= 100) {
        Merker1 = false;
        Millis_Start_alt = Millis;
    }    
    if (Taster_Start && Merker1 && Millis - Millis_Start_alt > 100) {
        Start = !Start; 
        Merker1 = false;
        Millis_Start_alt = Millis;
    }
    digitalWrite(Motoren_gestartet, Start);  // LED einschalten

    // ----------------------------------------------------------------------------------------
    Taster_Richtung = digitalRead (Taster_Drehrichtung_Umkehr_Motor1);   // TASTER Richtung M1
    if (!Taster_Richtung && !Merker2) {
        Millis_Richtung_alt = Millis;
        Merker2 = true;
    }   
    if (Taster_Richtung && Merker2 && Millis - Millis_Richtung_alt <= 100) {
        Merker2 = false;
        Millis_Richtung_alt = Millis;
    }    
    if (Taster_Richtung && Merker2 && Millis - Millis_Richtung_alt > 100) {
        Richtung = !Richtung; 
        Merker2 = false;
        Millis_Richtung_alt = Millis;
        digitalWrite(Drehrichtung_Motor1_A, LOW);                // Bremsen
        digitalWrite(Drehrichtung_Motor1_B, LOW);
        delay (500);
    }    
    // ----------------------------------------------------------------------------------------

    if (not Richtung) {                                          // Drehrichtung Motor 1 RECHTS
        digitalWrite(Drehrichtung_Motor1_A, HIGH);      
        digitalWrite(Drehrichtung_Motor1_B, LOW);
    }
    if (Richtung) {                                              // Drehrichtung Motor 1 LINKS
        digitalWrite(Drehrichtung_Motor1_A, LOW);
        digitalWrite(Drehrichtung_Motor1_B, HIGH);
    }

    if (Start) {                                                 // Motoren Start / Stop
        Drehzahl_M1 = analogRead(Poti_Drehzahl_Motor1) / 4;      // Poti Einstellung ablesen
        analogWrite (PWM_Drehzahl_Motor1, Drehzahl_M1);          // PWM-Ausgang beschreiben

        Drehzahl_M2_M3 = analogRead(Poti_Drehzahl_Motor2_3) / 4; // Poti Einstellung ablesen
        analogWrite (PWM_Drehzahl_Motor2_3, Drehzahl_M2_M3);     // PWM-Ausgang beschreiben
    } 
    else
    {
        analogWrite (PWM_Drehzahl_Motor1, 0);                    // Motoren STOP
        analogWrite (PWM_Drehzahl_Motor2_3, 0);
    }
}
//*********************************************************************************************
         

Trotz, dass der Motortreiber integrierte Dioden enthält, die induktive Spannungen abfangen sollen, kann es durchaus vorkommen, dass gelegentlich Spannungsspitzen entstehen, die den Mikrocontroller stören können. In unserem Fall werden die Tastereingänge aus diesem Grund besonders behandelt. Hier bestimmen wir, dass der Mikrocontroller auf ein Signal nur dann reagieren soll, wenn das Signal länger ansteht. Auf diese Weise wird auch die Prellung der Taster abgefangen. Die im Programm eingestellte Überwachungszeit beträgt 100 ms. Das bedeutet, dass das Signal von einem Taster mindestens 100 ms anstehen muss, bevor der Mikrocontroller irgendeine Aktion startet. Für den Anwender heißt das, er muss den Taster etwas länger als die eingestellte Überwachungszeit gedrückt halten.

Mit einem Oszilloskop können die störende Signale beobachtet werden.

Ansonsten beinhaltet das Programm keine Geheimnisse. Mit dem Taster S2, der an Pin 7 des Arduino angeschlossen wird, werden die Motoren gestartet. Das wird dadurch realisiert, dass zu dem Motortreiber die PWM-Signale herausgeschickt werden. Sobald die Werte einen bestimmten Pegel erreichen, beginnen die Motoren zu drehen. Die Drehgeschwindigkeit wird mit den Potentiometern P1 und P2 bestimmt. Mit dem Taster S1 wird die Drehrichtung des ersten Motors verändert.
Eine blaue Leuchtdiode signalisiert, ob die Motoren „scharf“ sind und man mit der PWM-Vorgabe beginnen kann.

Links zum Thema

Kurzvideo

Kurzvideo

Weitere Themen: