De L298N motordriver onder de knie krijgen: Arduino-besturing, schema's & voorbeeldcode

In deze Arduino-tutorial leren we hoe we DC-motoren met Arduino besturen. We bekijken enkele basistechnieken voor het besturen van DC-motoren en maken twee voorbeelden waarin we leren hoe we DC-motoren besturen met de L298N-motordriver en het Arduino-board.

Je kunt de volgende video bekijken of de geschreven tutorial hieronder lezen.

PWM DC-motorbesturing

We kunnen de snelheid van de DC-motor regelen door simpelweg de invoerspanning naar de motor te regelen, en de meest voorkomende methode om dat te doen is door een PWM-signaal te gebruiken.

PWM, of pulsbreedtemodulatie, is een techniek waarmee we de gemiddelde waarde van de spanning die naar het elektronische apparaat gaat, kunnen aanpassen door de stroom met een hoge snelheid aan en uit te zetten. De gemiddelde spanning hangt af van de duty cycle, of de hoeveelheid tijd dat het signaal AAN is versus de hoeveelheid tijd dat het signaal UIT is in een enkele periode.

Afhankelijk van de grootte van de motor, kunnen we simpelweg een Arduino PWM-uitgang aan de basis van een transistor of de gate van een MOSFET koppelen en de snelheid van de motor regelen door de PWM-uitgang te sturen. Het laagvermogen Arduino PWM-schakelt de gate van de MOSFET aan en uit, waardoor de hoogvermogen motor wordt aangedreven.

H-brug DC-motorbesturing

Aan de andere kant, voor het besturen van de draairichting, hoeven we alleen de richting van de stroom door de motor om te keren, en de meest voorkomende methode om dat te doen is door een H-brug te gebruiken. Een H-brug-circuit bevat vier schakelende elementen, transistoren of MOSFETs, met de motor in het centrum, wat een H-achtige configuratie vormt. Door twee specifieke schakelaars tegelijkertijd te activeren, kunnen we de richting van de stroom veranderen, en dus de draairichting van de motor.

Als we deze twee methoden combineren, PWM en H-brug, kunnen we volledige controle over de DC-motor hebben. Er zijn veel DC-motordrivers die deze functies hebben en de L298N is er een van.

L298N Driver

De L298N is een dubbele H-brug motordriver die snelheids- en richtingscontrole van twee DC-motoren tegelijkertijd toestaat. De module kan DC-motoren aansturen met spanningen tussen 5 en 35V, met een piekstroom tot 2A.

Laten we de pinout van de L298N-module nader bekijken en uitleggen hoe het werkt. De module heeft twee schroefklemblokken voor motor A en B, en nog een schroefklemblok voor de Ground-pin, de VCC voor de motor en een 5V-pin die ofwel een input of output kan zijn.

Dit hangt af van de spanning die gebruikt wordt bij de motor-VCC. De module heeft een onboard 5V-regelaar die in- of uitgeschakeld wordt met een jumper. Als de motorvoedingsspanning tot 12V is, kunnen we de 5V-regelaar inschakelen en de 5V-pin als output gebruiken, bijvoorbeeld om ons Arduino-board te voeden. Maar als de motortspanning groter is dan 12V, moeten we de jumper verwijderen, want die spanningen zouden schade aan de onboard 5V-regelaar kunnen veroorzaken. In dat geval wordt de 5V-pin als input gebruikt, want we moeten hem aan een 5V-voeding koppelen zodat de IC correct werkt.

We kunnen hier opmerken dat deze IC een spanningsval van ongeveer 2V veroorzaakt. Als we bijvoorbeeld een 12V-voeding gebruiken, zal de spanning aan de motorklemmen ongeveer 10V zijn, wat betekent dat we de maximale snelheid niet uit onze 12V DC-motor kunnen halen.

Vervolgens zijn er de logische besturingsingangen. De Enable A en Enable B pinnen worden gebruikt voor het inschakelen en regelen van de snelheid van de motor. Als er een jumper op deze pin zit, is de motor ingeschakeld en werkt hij op maximale snelheid, en als we de jumper verwijderen, kunnen we een PWM-input op deze pin aansluiten en zo de snelheid van de motor regelen. Als we deze pin aan de grond koppelen, wordt de motor uitgeschakeld.

Vervolgens worden de Input 1 en Input 2 pinnen gebruikt voor het besturen van de draairichting van motor A, en inputs 3 en 4 voor motor B. Met deze pinnen besturen we eigenlijk de schakelaars van de H-brug binnenin de L298N IC. Als input 1 LAAG is en input 2 HOOG, zal de motor vooruit draaien, en omgekeerd, als input 1 HOOG is en input 2 LAAG, zal de motor achteruit draaien. In het geval beide inputs hetzelfde zijn, ofwel LAAG of HOOG, stopt de motor. Hetzelfde geldt voor inputs 3 en 4 en motor B.

Arduino en L298N Motordriver

Nu laten we enkele praktische toepassingen maken. In het eerste voorbeeld zullen we de snelheid van de motor regelen met een potentiometer en de draairichting veranderen met een drukknop. Hier is het schakelschema.

We hebben een L298N-motordriver, een DC-motor, een potentiometer, een drukknop en een Arduino-board nodig.

Je kunt de benodigde componenten voor deze Arduino-tutorial via de onderstaande links verkrijgen:

• L298N Driver
• 12V Hoge koppel DC-motor
• DC-motor met plastic wiel
• Arduino-board
• Breadboard en jumperdraden

Arduino-code

Hier is de Arduino-code:

/* Arduino DC-motorbesturing - PWM | H-brug | L298N - Voorbeeld 01
   by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#define enA 9
#define in1 6
#define in2 7
#define button 4
int rotDirection = 0;
int pressed = false;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(button, INPUT);
  // Stel initiële draairichting in
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Lees potentiometerwaarde
  int pwmOutput = map(potValue, 0, 1023, 0, 255); // Map potentiometerwaarde van 0-1023 naar 0-255
  analogWrite(enA, pwmOutput); // Stuur PWM-signaal naar L298N Enable-pin
  // Lees knop - Debounce
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);
  // Als knop ingedrukt - verander draairichting
  if (pressed == true & rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // Als knop ingedrukt - verander draairichting
  if (pressed == false & rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}

Beschrijving: Eerst definiëren we de pinnen en enkele variabelen die nodig zijn voor het programma. In de setup-sectie stellen we de pin-modes in en de initiële draairichting van de motor. In de loop-sectie beginnen we met het uitlezen van de potentiometerwaarde en mappen de waarde die we eruit krijgen, van 0 tot 1023, naar een waarde van 0 tot 255 voor het PWM-signaal, oftewel 0 tot 100% duty cycle van het PWM-signaal. Vervolgens sturen we met de analogWrite()-functie het PWM-signaal naar de Enable-pin van de L298N-board, wat eigenlijk de motor aandrijft.

Vervolgens controleren we of we de knop hebben ingedrukt, en als dat zo is, veranderen we de draairichting van de motor door de Input 1 en Input 2 statussen om te keren. De drukknop werkt als een toggle-knop en elke keer dat we erop drukken, verandert de draairichting van de motor.

Arduino-robotautobesturing met L298N-motordriver

Nu we dit geleerd hebben, kunnen we onze eigen Arduino-robotauto bouwen. Hier is het schakelschema:

We hebben alleen 2 DC-motoren, de L298N-motordriver, een Arduino-board en een joystick voor de besturing nodig. Wat de voeding betreft, koos ik voor drie 3,7V Li-ion-accu's, die samen 11V leveren. Ik maakte het chassis van 3 mm dik multiplex, bevestigde de motoren erop met metalen beugels, bevestigde wielen aan de motoren en plaatste een zwenkwiel aan de voorzijde.

Nu laten we eens kijken naar de Arduino-code en zien hoe het werkt. (Onderaan vind je de complete code)

int xAxis = analogRead(A0); // Lees joystick X-as
int yAxis = analogRead(A1); // Lees joystick Y-as

Na het definiëren van de pinnen, beginnen we in de loop-sectie met het uitlezen van de joystick X- en Y-as waarden. De joystick bestaat eigenlijk uit twee potentiometers die aangesloten zijn op de analoge ingangen van de Arduino en die waarden hebben van 0 tot 1023. Wanneer de joystick in zijn middenposititie blijft, is de waarde van beide potentiometers, of assen, ongeveer 512.

We voegen een kleine tolerantie toe en beschouwen waarden van 470 tot 550 als het midden. Als we de Y-as van de joystick naar achteren bewegen en de waarde onder de 470 daalt, zetten we de draairichting van de twee motoren op achteruit met de vier input-pinnen. Vervolgens rekenen we de dalende waarden van 470 naar 0 om naar stijgende PWM-waarden van 0 tot 255, wat eigenlijk de snelheid van de motor is.

// Y-as gebruikt voor vooruit en achteruit besturing
if (yAxis < 470) {
  // Motor A achteruit
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  // Motor B achteruit
  digitalWrite(in3, HIGH);
  digitalWrite(in4, LOW);
  // Reken de dalende Y-as waarden voor achteruit rijden van 470 naar 0 om naar 0-255 waarde voor PWM-signaal
  motorSpeedA = map(yAxis, 470, 0, 0, 255);
  motorSpeedB = map(yAxis, 470, 0, 0, 255);
}

Op dezelfde manier, als we de Y-as van de joystick naar voren bewegen en de waarde boven de 550 stijgt, zetten we de motoren op vooruit en rekenen we de waarden van 550 tot 1023 om naar PWM-waarden van 0 tot 255. Als de joystick in het midden blijft, is de motortoer nul.

Vervolgens, laten we zien hoe we de X-as gebruiken voor de links- en rechtsbesturing van de auto.

// X-as gebruikt voor links en rechts besturing
if (xAxis < 470) {
  // Reken de dalende X-as waarden van 470 naar 0 om naar stijgende 0-255 waarde
  int xMapped = map(xAxis, 470, 0, 0, 255);
  // Naar links - verlaag linker motorsnelheid, verhoog rechter motorsnelheid
  motorSpeedA = motorSpeedA - xMapped;
  motorSpeedB = motorSpeedB + xMapped;
  // Beperk bereik van 0 tot 255
  if (motorSpeedA < 0) { motorSpeedA = 0; }
  if (motorSpeedB > 255) { motorSpeedB = 255; }
}

Opnieuw, eerst rekenen we de X-as waarden om naar snelheidswaarden van 0 tot 255. Voor het bewegen naar links gebruiken we deze waarde om de linker motorsnelheid te verlagen en de rechter motorsnelheid te verhogen. Hier, vanwege de rekenkundige functies, gebruiken we twee extra "if"-statements om het bereik van de motortoer van 0 tot 255 te beperken.

Hetzelfde principe wordt gebruikt voor het bewegen van de auto naar rechts.

Gerelateerd: Hoe een PWM DC-motorsnelheidscontroller te maken met de 555 Timer IC

Afhankelijk van de aangelegde spanning en de motor zelf, is de motor bij lage snelheden niet in staat om te starten en produceert hij een brommend geluid. In mijn geval konden de motoren niet bewegen als de PWM-waarde onder 70 was. Daarom beperkte ik met deze twee if-statements het snelheidsbereik van 70 tot 255. Aan het einde sturen we de finale motortoeren of PWM-signaal naar de enable-pinnen van de L298N-driver.

// Voorkom brullen bij lage snelheden (Aanpassen aan je motoren. Mijn motoren konden niet starten als PWM-waarde onder 70 was)
if (motorSpeedA < 70) { motorSpeedA = 0; }
if (motorSpeedB < 70) { motorSpeedB = 0; }
analogWrite(enA, motorSpeedA); // Stuur PWM-signaal naar motor A
analogWrite(enB, motorSpeedB); // Stuur PWM-signaal naar motor B

Hier is de complete code van het Arduino-robotauto-voorbeeld:

/* Arduino DC-motorbesturing - PWM | H-brug | L298N
   Voorbeeld 02 - Arduino Robot Auto Besturing
   by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
}

void loop() {
  int xAxis = analogRead(A0);
  int yAxis = analogRead(A1);
  // Y-as gebruikt voor vooruit en achteruit besturing
  if (yAxis < 470) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // X-as gebruikt voor links en rechts besturing
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) { motorSpeedA = 0; }
    if (motorSpeedB > 255) { motorSpeedB = 255; }
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) { motorSpeedA = 255; }
    if (motorSpeedB < 0) { motorSpeedB = 0; }
  }
  // Voorkom brullen bij lage snelheden
  if (motorSpeedA < 70) { motorSpeedA = 0; }
  if (motorSpeedB < 70) { motorSpeedB = 0; }
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Dat was het voor deze tutorial, en in mijn volgende video zullen we deze Arduino-robotauto upgraderen, door een Bluetooth- en radio-apparaat toe te voegen voor smartphone- en draadloze besturing.

Voel je vrij om vragen te stellen in de reacties hieronder en vergeet niet mijn verzameling Arduino-projecten te bekijken.