L298N kettős H-híd, 2 DC motor, 5-35V, 2A csatornánként

A Dupla H-híd L298N modul egy egyenáramú motorok meghajtására szolgáló vezérlő, amely az L298N áramkör köré épül. Két DC motort tud egymástól függetlenül vezérelni irány és sebesség szerint, vagy egy bipoláris léptetőmotort. Robotokban kerekekkel, távirányítós autókban, kis szállítószalagokon és minden olyan projektben találkozunk vele, ahol a mikrokontrollernek olyan motort kell mozgatnia, amely többet fogyaszt, mint amennyit a kártya egy lába képes adni.

Ebben az útmutatóban Arduino Uno R3-at használunk, mert a modulnak szüksége van egy mikrokontrollerre, amely vezérlőjeleket ad neki, és az Uno 5 V-os logikai szintje közvetlenül illeszkedik a modul bemeneteihez. Két, fokozatmentes TT motort vezérlünk, amelyeket 9 VDC-s hálózati adapterről táplálunk.

Működés:

Egy DC motor a kapcsain lévő feszültség polaritásától függően az egyik vagy a másik irányba forog. A H-híd egy négy kapcsolóból álló elrendezés, amely lehetővé teszi, hogy egy logikai jelből megfordítsuk ezt a polaritást. Az L298N áramkör két ilyen hidat tartalmaz, így két motort tud vezérelni. Az A motorhoz az IN1 és IN2 bemenetek tartoznak, a B motorhoz pedig az IN3 és IN4 bemenetek.

A forgásirányt a motor két bemenetén lévő szintek kombinációja határozza meg. A HIGH szint mindkét bemeneten soha nem használható, mert károsíthatja a modult.

A sebességet PWM jellel szabályozzuk az ENA (A motor) és az ENB (B motor) lábakon. Az Arduino Unón az analogWrite függvény 0 és 255 közötti értékeket fogad el. A 0 érték azt jelenti, hogy a motor áll, a 255 pedig folyamatos táplálást jelent. A motorra jutó átlagos feszültség hozzávetőleg Vmotor = (VS - Vcadere) x PWM / 255.

Az L298N belsőleg veszít egy részt a feszültségből, hozzávetőleg 1,8 - 3,2 V-ot 1 A áramnál, és közel 5 V-ot 2 A áramnál. Ebben az áramkörben a VS 9 V, tehát 255-ös PWM mellett egy körülbelül 1 A-t fogyasztó motor hozzávetőleg 7 V-ot kap. A TT motorokat 3 - 6 V-ra tervezték, ezért a PWM értéket 200-ra korlátozzuk. 200-nál az átlagos feszültség hozzávetőleg 7 x 200 / 255 = 5,5 V, ami a motorok biztonságos tartományán belül van.

A modul egy 78M05 stabilizátort is tartalmaz, amely 5 V-ot tud előállítani a logikai részhez. Ha az 5V-EN jumper be van dugva, a stabilizátor aktív, és a +5V csatlakozó 5 V-os kimenetté válik, legfeljebb 0,5 A áramerősséggel. Ez a változat csak akkor használható, ha a VS feszültség legfeljebb 12 V. 12 V felett a jumpert ki kell venni, és a +5V csatlakozót külső forrásból kell táplálni.

Csatlakoztatás:

A motorokat egy legalább 1 A-es, 9 VDC-s hálózati adapterről táplálja, amely egy csavaros sarkú jack csatlakozón keresztül kapcsolódik. Az Arduino Uno kártyát külön, az USB kábelen keresztül kell táplálni. Az adapter mínuszát, a modul GND pontját és az Uno kártya GND lábát össze kell kötni, különben a vezérlőjelek nem lesznek közös referenciával, és a motorok nem reagálnak megfelelően. A modul bemenetei közvetlenül elfogadják az Uno 5 V-os logikai szintjét, ezért nincs szükség szintillesztőre.

Az ENA és ENB jumpereket távolítsa el a modul táplálása előtt, hogy a sebességet PWM-mel tudja szabályozni. A modulon már van két 220 uF-os kondenzátor és a motorok védődiódái, ezért további alkatrészeket nem kell hozzáadni.

Gombok, beállítások és jelzők:

Az 5V-EN jumper: a jumperrel bekapcsolva indítsa el. Ebben az áramkörben a VS 9 V, így a stabilizátor aktív maradhat. A +5V csatlakozót nem kell az Arduinóhoz kötni, mert az Uno kártya USB-n keresztül kap táplálást. Soha ne táplálja külső forrásból a +5V csatlakozót, amíg a jumper be van dugva.

Az ENA és ENB jumperek: mindkettőt távolítsa el az első indítás előtt. Ha a jumper be van dugva, az adott motor folyamatosan maximális sebességgel fut, és a PWM vezérlés nincs hatással rá. A szabályozás akkor működik, ha a motor sebessége változik, miközben a program az analogWrite értékét módosítja.

A táplálást jelző LED: az adapter csatlakoztatása után a LED-nek azonnal ki kell gyulladnia. Ez az első dolog, amit ellenőrizni kell, ha valami nem működik.

Panel és könyvtárak:

Az Arduino IDE-ben válassza a Tools > Board > Arduino AVR Boards > Arduino Uno menüpontot. Az Arduino AVR Boards csomag az Arduino IDE-vel együtt érkezik, ezért nem kell külön telepíteni. A program csak az Arduino alapfunkcióit használja, így nem szükséges könyvtárat telepíteni.

A kód:

A program minden motort előre és hátra forgat, két sebességgel, majd mindkét motort együtt jártatja. Másolja be az Arduino IDE-be, és töltse fel az Uno kártyára.

/*
  L298N dual H-bridge motor driver demo
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Libraries: none, the sketch uses only the core Arduino functions
  Wiring:
    ENA -> D9 (PWM)    IN1 -> D8    IN2 -> D7
    ENB -> D3 (PWM)    IN3 -> D5    IN4 -> D4
    L298N GND -> Arduino GND and the adapter minus
    L298N +12V -> adapter plus (9 VDC, min. 1 A)
    Remove the ENA and ENB jumpers so PWM can control the speed
*/
// Motor A pins
const int ENA = 9;   // Speed of motor A (PWM)
const int IN1 = 8;   // Direction input 1 of motor A
const int IN2 = 7;   // Direction input 2 of motor A
// Motor B pins
const int ENB = 3;   // Speed of motor B (PWM)
const int IN3 = 5;   // Direction input 1 of motor B
const int IN4 = 4;   // Direction input 2 of motor B
// Maximum PWM value, keeps 3-6 V motors in a safe range when VS is 9 V
const int MAX_PWM = 200;
// Run motor A at a given speed, forward or backward
void setMotorA(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN2 : IN1, LOW);
  digitalWrite(forward ? IN1 : IN2, HIGH);
  analogWrite(ENA, speed);                // Apply the speed
  Serial.print("Motor A: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Run motor B at a given speed, forward or backward
void setMotorB(int speed, bool forward) {
  speed = constrain(speed, 0, MAX_PWM);   // Limit the speed
  // Write LOW first, so both inputs are never HIGH at the same time
  digitalWrite(forward ? IN4 : IN3, LOW);
  digitalWrite(forward ? IN3 : IN4, HIGH);
  analogWrite(ENB, speed);                // Apply the speed
  Serial.print("Motor B: ");
  Serial.print(forward ? "forward" : "backward");
  Serial.print(", PWM ");
  Serial.println(speed);
}
// Stop motor A
void stopMotorA() {
  analogWrite(ENA, 0);        // No drive
  digitalWrite(IN1, LOW);     // Both inputs LOW
  digitalWrite(IN2, LOW);
  Serial.println("Motor A: stopped");
}
// Stop motor B
void stopMotorB() {
  analogWrite(ENB, 0);        // No drive
  digitalWrite(IN3, LOW);     // Both inputs LOW
  digitalWrite(IN4, LOW);
  Serial.println("Motor B: stopped");
}
void setup() {
  // Configure all control pins as outputs
  pinMode(ENA, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
  Serial.begin(9600);         // Start the serial monitor
  Serial.println("L298N motor driver test started");
  // Make sure both motors are off at start
  stopMotorA();
  stopMotorB();
  delay(1000);
}
void loop() {
  // Motor A: forward at two speeds, then backward
  setMotorA(120, true);
  delay(2000);
  setMotorA(200, true);
  delay(2000);
  stopMotorA();
  delay(1000);
  setMotorA(200, false);
  delay(2000);
  stopMotorA();
  delay(1000);
  // Motor B: forward, then backward
  setMotorB(200, true);
  delay(2000);
  stopMotorB();
  delay(1000);
  setMotorB(200, false);
  delay(2000);
  stopMotorB();
  delay(1000);
  // Both motors together
  setMotorA(150, true);
  setMotorB(150, true);
  delay(3000);
  stopMotorA();
  stopMotorB();
  delay(3000);            // Pause before the cycle repeats
}

A kód működése:

Az elején a lábak a következő konstansokkal vannak megadva: ENA, IN1, IN2, ENB, IN3 és IN4, pontosan a csatlakoztatási táblázat szerint. A MAX_PWM konstans értéke 200, és a sebességet korlátozza, hogy a TT motorok ne kapjanak 6 V-nál többet.

A setup függvényben minden lábat kimenetként konfigurálunk, elindítjuk a soros monitort 9600 baudon, és mindkét motort leállítjuk, hogy alaphelyzetbe állításkor ne induljon el semmi nemkívánatos.

A setMotorA és setMotorB függvények megkapják a sebességet és az irányt. A sebességet a constrain függvénnyel korlátozzák, először LOW szintet írnak arra a bemenetre, amelynek inaktívnak kell lennie, és csak utána HIGH szintet a másikra. Így ugyanazon motor két bemenete soha nincs egyszerre HIGH állapotban. Végül az analogWrite alkalmazza a sebességet az enable lábon. A stopMotorA és stopMotorB függvények mindkét bemenetet LOW szintre állítják, a sebességet pedig 0-ra.

A loop függvény a tesztsorozatot futtatja: az A motor előre két sebességgel, leállítás, az A motor hátra, majd ugyanezek a lépések a B motorral, végül mindkét motor együtt. A szüneteket a delay függvény adja, a soros monitor üzenetei pedig minden lépésnél megmutatják, milyen parancs ment ki.

Eredmény:

Nyissa meg a Serial Monitort 9600 baudon. A program feltöltése után megjelennek az alábbi üzenetek, és a motorok ugyanabban a sorrendben mozognak. Ha valamelyik motor az üzenettel ellentétes irányban forog, cserélje meg egymással a motor két vezetékét az OUT csatlakozónál.

L298N motor driver test started
Motor A: stopped
Motor B: stopped
Motor A: forward, PWM 120
Motor A: forward, PWM 200
Motor A: stopped
Motor A: backward, PWM 200
Motor A: stopped
Motor B: forward, PWM 200
Motor B: stopped
Motor B: backward, PWM 200
Motor B: stopped

Gyakori problémák:

A motorok egyáltalán nem mozognak. A leggyakoribb ok a táplálás vagy a föld. Ellenőrizze, hogy a táplálást jelző LEDég-e, és hogy az Uno kártya GND lába össze van-e kötve a modul GND lábával. Közös föld nélkül a vezérlőjeleket nem ismeri fel a rendszer.

Az egyik motor mindig maximális sebességgel jár, a PWM értékétől függetlenül. Az ENA vagy ENB jumper még be van dugva. Vegye ki, hogy a D9 vagy a D3 láb tudja szabályozni a sebességet.

A motor zúg, de kis sebességnél nem indul el. Egy bizonyos PWM érték alatt az átlagos feszültség túl kicsi ahhoz, hogy legyőzze a sebességváltó súrlódását. Növelje az analogWrite értékét, vagy szükség esetén használjon nagyobb VS feszültséget.

A motor a kívánttal ellentétes irányba forog. Cserélje meg egymással a motor két vezetékét az OUT csatlakozónál, vagy változtassa meg a kódban az adott motorhoz tartozó HIGH és LOW értékeket.

Az Uno kártya újraindul, amikor a motorok elindulnak. A motorok zavarokat és feszültségesést okoznak a földön. Ellenőrizze a földvezetékeket, használjon legalább 1 A-t szolgáltató adaptert, és tartsa távol a motorok vezetékeit a jelvezetékektől.

A modul hűtőbordája felmelegszik. Nagy áramnál ez normális, mert a teljesítmény egy része az L298N áramkörben disszipálódik. Ha hosszú ideig nem érinthető meg, csökkentse a terhelést, vagy biztosítson szellőzést.

Korlátok és tanácsok:

A modul motorokhoz 5 - 35 VDC feszültséget fogad el, és csatornánként legfeljebb 2 A áramot tud adni. A belső feszültségesés miatt a motor a táplálófeszültségnél kevesebbet kap, ezért válassza úgy a VS feszültséget, hogy az 2 - 3 V-tal a motor névleges feszültsége fölött legyen. Kis, 3 - 6 V-os motorokhoz egy 9 V-os tápforrás, a PWM kb. 200-ra korlátozásával, biztonságos választás.

Az L298N áramkör nem hatékony, ezért elemről működő, nagy fogyasztású motorokhoz a MOSFET tranzisztorokkal működő meghajtó megfelelőbb. Ugyanakkor a modul kiválóan alkalmas tanulásra és kis robotokhoz. Ugyanezzel az elrendezéssel építhet két kerekes robotot, ha távolságérzékelőt vagy távirányítót ad hozzá. Soha ne kapcsoljon HIGH szintet egyszerre az IN1 és IN2, vagy az IN3 és IN4 bemenetekre.