L298N-motorstuurprogramma - Arduino-interface, hoe het werkt, codes, schema's

In deze Arduino-zelfstudie leren we hoe we DC-motoren kunnen besturen met behulp van Arduino. We bekijken enkele basistechnieken voor het besturen van DC-motoren en maken twee voorbeelden waarmee we zullen leren hoe we DC-motoren kunnen besturen met behulp van de L298N-motordriver en het Arduino-bord.

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

We kunnen de snelheid van de DC-motor regelen door simpelweg de ingangsspanning naar de motor te regelen en de meest gebruikelijke methode om dat te doen is door het gebruik van een PWM-signaal.

PWM DC-motorbesturing

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 snel in en uit te schakelen. De gemiddelde spanning hangt af van de duty-cycle, of de hoeveelheid tijd dat het signaal AAN is versus de tijd dat het signaal UIT is in een enkele tijdsperiode.

Dus afhankelijk van de grootte van de motor, kunnen we eenvoudig een Arduino PWM-uitgang aansluiten op de basis van de transistor of de poort van een MOSFET en de snelheid van de motor regelen door de PWM-uitgang te regelen. Het Arduino PWM-signaal met laag vermogen schakelt de poort bij de MOSFET in en uit waardoor de motor met hoog vermogen wordt aangedreven.

H-Bridge DC-motorbesturing

Aan de andere kant, om de draairichting te regelen, hoeven we alleen maar de richting van de stroom door de motor om te keren, en de meest gebruikelijke methode om dat te doen is door een H-brug te gebruiken. Een H-brugschakeling bevat vier schakelelementen, transistors of MOSFET's, waarbij de motor in het midden 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 veranderen.

Dus als we deze twee methoden, de PWM en de H-Bridge, combineren, kunnen we de DC-motor volledig onder controle hebben. Er zijn veel DC-motordrivers die over deze eigenschappen beschikken en de L298N is er een van.

L298N-stuurprogramma

De L298N is een dubbele H-Bridge-motoraandrijving waarmee de snelheid en richting van twee gelijkstroommotoren tegelijkertijd kunnen worden geregeld. De module kan gelijkstroommotoren aansturen met spanningen tussen 5 en 35V, met een piekstroom tot 2A.

Laten we de pin-out van de L298N-module eens nader bekijken en uitleggen hoe deze werkt. De module heeft twee schroefaansluitblokken voor de motor A en B, en een ander schroefaansluitblok voor de aardingspen, de VCC voor de motor en een 5V-pen die zowel een ingang als een uitgang kan zijn.

Dit is afhankelijk van de gebruikte spanning op de motoren VCC. De module heeft een ingebouwde 5V-regelaar die kan worden in- of uitgeschakeld met behulp van een jumper. Als de voedingsspanning van de motor maximaal 12V is, kunnen we de 5V-regelaar inschakelen en kan de 5V-pin worden gebruikt als uitgang, bijvoorbeeld voor het voeden van ons Arduino-bord. Maar als de motorspanning hoger is dan 12V, moeten we de jumper loskoppelen omdat die spanningen schade aan de ingebouwde 5V-regelaar zullen veroorzaken. In dit geval wordt de 5V-pin gebruikt als ingang, omdat we deze op een 5V-voeding moeten aansluiten om het IC goed te laten werken.

We kunnen hierbij opmerken dat dit IC een spanningsval van ongeveer 2V maakt. Dus als we bijvoorbeeld een 12V-voeding gebruiken, zal de spanning op de motorklemmen ongeveer 10V zijn, wat betekent dat we niet in staat zullen zijn om de maximale snelheid uit onze 12V DC-motor te halen.

De volgende zijn 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 aanwezig is, zal de motor worden ingeschakeld en op maximale snelheid werken, en als we de jumper verwijderen, kunnen we een PWM-ingang op deze pin aansluiten en op die manier de snelheid van de motor regelen. Als we deze pin verbinden met een aarde, wordt de motor uitgeschakeld.

Vervolgens worden de pinnen van ingang 1 en ingang 2 gebruikt voor het regelen van de draairichting van motor A, en de ingangen 3 en 4 voor motor B. Met deze pinnen besturen we feitelijk de schakelaars van de H-brug in het L298N IC. Als ingang 1 LAAG is en ingang 2 HOOG, zal de motor vooruit gaan, en vice versa, als ingang 1 HOOG is en ingang 2 LAAG is, zal de motor achteruit gaan. Als beide ingangen hetzelfde zijn, ofwel LAAG ofwel HOOG, zal de motor stoppen. Hetzelfde geldt voor de ingangen 3 en 4 en de motor B.

Arduino- en L298N-motorstuurprogramma

Laten we nu enkele praktische toepassingen maken. In het eerste voorbeeld zullen we het toerental van de motor regelen met een potentiometer en de draairichting veranderen met een drukknop. Hier zijn de circuitschema's.

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

U kunt de benodigde componenten voor deze Arduino-zelfstudie verkrijgen via de onderstaande links:

• L298N-stuurprogramma …………………………….. 
• 12V DC-motor met hoog koppel ………….. 
• DC-motor met kunststof bandenwiel …….
• Arduino-bord ……………………………
• Broodplank en springdraden ………… 

Arduino-code

Hier is de Arduino-code:

/*  Arduino DC Motor Control - PWM | H-Bridge | L298N  -  Example 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);
  // Set initial rotation direction
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Read potentiometer value
  int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0 to 255
  analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin

  // Read button - Debounce
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);

  // If button is pressed - change rotation direction
  if (pressed == true  & rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // If button is pressed - change rotation direction
  if (pressed == false & rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}
Code language: Arduino (arduino)

Beschrijving: Dus eerst moeten we de pinnen en enkele variabelen definiëren die nodig zijn voor het programma. In het setup-gedeelte moeten we de pin-modi en de initiële draairichting van de motor instellen. In de lussectie beginnen we met het lezen van de potentiometerwaarde en brengen vervolgens de waarde die we ervan krijgen, van 0 tot 1023, in kaart met een waarde van 0 tot 255 voor het PWM-signaal, of dat is 0 tot 100% inschakelduur van de PWM-signaal. Vervolgens gebruiken we de functie analogWrite() om het PWM-signaal naar de Enable-pin van het L298N-bord te sturen, die de motor daadwerkelijk aandrijft.

Vervolgens controleren we of we op de knop hebben gedrukt, en als dat waar is, zullen we de draairichting van de motor veranderen door de statussen van Input 1 en Input 2 omgekeerd in te stellen. De drukknop werkt als schakelknop en elke keer dat we erop drukken, verandert de draairichting van de motor.

Arduino Robot Car Control met L298N Motor Driver

Dus als we dit eenmaal hebben geleerd, kunnen we nu onze eigen Arduino-robotauto bouwen. Hier is het schakelschema:

Alles wat we nodig hebben zijn 2 DC-motoren, de L298N-motordriver, een Arduino-bord en een joystick voor de besturing. Wat de voeding betreft, heb ik ervoor gekozen om drie 3.7V Li-ion-batterijen te gebruiken, die in totaal 11V leveren. Ik maakte het chassis van 3 mm dik multiplex, bevestigde de motoren eraan met metalen beugels, bevestigde wielen aan de motoren en vooraan bevestigde een zwenkwiel.

Laten we nu eens kijken naar de Arduino-code en kijken hoe het werkt. (Onderaan vind je de volledige code)

int xAxis = analogRead(A0); // Read Joysticks X-axis
int yAxis = analogRead(A1); // Read Joysticks Y-axisCode language: Arduino (arduino)

Na het definiëren van de pinnen, in het lusgedeelte, beginnen we met het lezen van de joystick X- en Y-aswaarden. De joystick is eigenlijk gemaakt van twee potentiometers die zijn aangesloten op de analoge ingangen van de Arduino en ze hebben waarden van 0 tot 1023. Als de joystick in zijn middenpositie blijft, is de waarde van beide potentiometers of assen ongeveer 512.

We zullen een beetje tolerantie toevoegen en de waarden van 470 tot 550 als middelpunt beschouwen. Dus als we de Y-as van de joystick naar achteren bewegen en de waarde daalt onder 470, dan stellen we de rotatierichting van de twee motoren in op achteruit met behulp van de vier invoerpinnen. Vervolgens zullen we de afnemende waarden van 470 naar 0 converteren naar toenemende PWM-waarden van 0 naar 255, wat eigenlijk de snelheid van de motor is.

// Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }Code language: Arduino (arduino)

Evenzo, als we de Y-as van de joystick naar voren bewegen en de waarde gaat boven 550, zullen we de motoren instellen om vooruit te gaan en de meetwaarden van 550 tot 1023 om te zetten in PWM-waarden van 0 tot 255. Als de joystick in het midden blijft, wordt de motorsnelheid zal nul zijn.

Laten we vervolgens kijken hoe we de X-as gebruiken voor de linker- en rechterbesturing van de auto.

// X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }Code language: Arduino (arduino)

Dus nogmaals, eerst moeten we de X-asmetingen converteren naar snelheidswaarden van 0 tot 255. Om naar links te gaan, gebruiken we deze waarde om de linkermotorsnelheid te verlagen en de rechtermotorsnelheid te verhogen. Vanwege de rekenkundige functies gebruiken we hier twee extra "if"-instructies om het bereik van de motorsnelheid te beperken van 0 tot 255.

Dezelfde methode wordt gebruikt om de auto naar rechts te verplaatsen.

Gerelateerd:Hoe maak je een PWM DC-motorsnelheidsregelaar met behulp van de 555 Timer IC

Afhankelijk van de aangelegde spanning en de motor zelf, kan de motor bij lagere snelheden niet in beweging komen en produceert hij een zoemend geluid. In mijn geval waren de motoren niet in staat om te bewegen als de waarde van het PWM-signaal lager was dan 70. Daarom heb ik deze twee if-statements gebruikt om het snelheidsbereik van 70 tot 255 te beperken. Aan het einde sturen we gewoon de uiteindelijke motorsnelheden of PWM-signaal naar de activeringspinnen van de L298N-driver.

// Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor BCode language: Arduino (arduino)

Hier is de volledige code van het Arduino-robotautovoorbeeld:

/*  Arduino DC Motor Control - PWM | H-Bridge | L298N
         Example 02 - Arduino Robot Car Control
    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); // Read Joysticks X-axis
  int yAxis = analogRead(A1); // Read Joysticks Y-axis

  // Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }
  else if (yAxis > 550) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convert the increasing Y-axis readings for going forward from 550 to 1023 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }

  // X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }
  if (xAxis > 550) {
    // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) {
      motorSpeedA = 255;
    }
    if (motorSpeedB < 0) {
      motorSpeedB = 0;
    }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}Code language: Arduino (arduino)

Dus dat zou alles zijn voor deze tutorial, en in mijn volgende video zullen we deze Arduino-robotauto upgraden door een Bluetooth- en radioapparaat toe te voegen om smartphone- en draadloze bediening mogelijk te maken.

Stel gerust een vraag in de opmerkingen hieronder en vergeet niet mijn verzameling Arduino-projecten te bekijken.