Een DC-motor aansturen met behulp van een L293D-motorstuurmodule met Arduino PWM

Een DC-motor aansturen met behulp van een L293D-motorstuurmodule met Arduino PWM

Een robot bouwen of een geautomatiseerd project realiseren komt vaak neer op één fundamentele uitdaging: het nauwkeurig aansturen van een gelijkstroommotor. Je moet hem niet alleen aan en uit kunnen zetten, maar ook de snelheid en richting kunnen regelen. Hier komt de L293D-motorstuurchip om de hoek kijken. Deze handleiding leidt je stap voor stap door het bouwen van een robuuste motorcontroller met een Arduino en de populaire L293D-chip. Aan het einde kun je met slechts een paar regels code een motor op elke gewenste snelheid en in elke richting laten draaien.

Dit project is een fundamentele bouwsteen voor talloze toepassingen. Hier zijn een paar ideeën om je te inspireren:

• Bouw een robot met twee wielen: Gebruik twee van deze circuits om een robotchassis aan te drijven, waarbij je elk wiel onafhankelijk aanstuurt voor nauwkeurige bewegingen en bochten.
• Maak een automatische plantenwatergever: Stuur een kleine waterpomp aan om op basis van bodemvochtsensormetingen precies de juiste hoeveelheid water aan je planten te geven.
• Ontwerp een slimme ventilator: Vervang de handmatige schakelaar van een tafelventilator door een systeem dat de snelheid automatisch aanpast op basis van temperatuur of een afstandsbediening.
• Maak een gemotoriseerde cameraglijder: Beweeg een camera langzaam en constant over een rail voor vloeiende time-lapsevideo's.
• Bouw een zonnevolgsysteem: Gebruik een motor om een zonnepaneel langzaam de zon over de hemel te laten volgen, waardoor de energieopbrengst wordt gemaximaliseerd.

Hardwarecomponenten

Verzamel voordat je begint de volgende componenten. De L293D is de ster van de show en fungeert als brug tussen de laagvermogen stuursignalen van je Arduino en de hoogvermogen vereisten van de motor.

• Arduino-board (Uno, Nano, etc.)
• L293D-motorstuurchip (of een module op basis hiervan)
• Een gelijkstroommotor (werkend tussen 4,5V en 36V)
• Externe voeding (bijv. een 9V-batterij of een labvoeding)
• Jumperkabels
• Breadboard (optioneel, maar handig voor prototyping)

De L293D-motorstuurchip begrijpen

De L293D is een viervoudige half-H-driver, wat betekent dat hij vier onafhankelijke halfbrugcircuits bevat. Deze configuratie stelt hem in staat om de richting van een motor te regelen door de polariteit van de spanning op de aansluitingen om te keren. Hij kan tot twee gelijkstroommotoren aansturen met volledige richtings- en snelheidsregeling, of tot vier motoren als je ze alleen aan en uit hoeft te zetten.

Een van de belangrijkste kenmerken van de L293D zijn de ingebouwde vrijloopdiodes. Motoren zijn inductieve belastingen, wat betekent dat ze weerstand bieden aan veranderingen in stroom. Wanneer je plotseling de stroom naar een motor onderbreekt, genereert deze een hoogspanningspiek die je Arduino kan beschadigen. De "D" in L293D geeft aan dat deze beschermingsdiodes al in de chip zijn geïntegreerd, waardoor je ze niet extern hoeft toe te voegen. Dit is een cruciaal verschil met de oudere L293-chip, die externe diodes vereist voor veilige werking.

Een ander belangrijk detail zijn de stroomlimieten van de chip. De L293D kan een continue stroom van maximaal 600 mA per kanaal aan. Als je motor meer stroom trekt dan dit, raakt de chip oververhit en kan permanent beschadigd raken. Voor motoren die meer stroom nodig hebben, heb je een krachtigere driver nodig, zoals de L298N of een speciale motorschield.

Bekabelingshandleiding

De bekabeling voor dit project is eenvoudig. We gebruiken één motor, waarvoor één volledige H-brug (twee halfbruggen) van de L293D nodig is. De video demonstreert de bekabeling duidelijk, en hieronder wordt een diagram getoond.

Hier is een overzicht van de verbindingen:

• Voedingsaansluitingen: Verbind pin 16 (VCC1) met de 5V-pin van de Arduino. Dit voedt de interne logica van de chip. Verbind pin 8 (VCC2) met je externe motorvoeding (bijv. 9V). Dit levert stroom aan de motor zelf. Verbind pinnen 4, 5, 12 en 13 met de gemeenschappelijke massa van zowel je Arduino als je externe voeding.
• Motoraansluitingen: Verbind de twee aansluitingen van je gelijkstroommotor met pinnen 3 en 6 van de L293D. De polariteit maakt op dit moment niet uit, omdat het omkeren van de richting in de code simpelweg de draairichting van de motor omkeert.
• Stuuraansluitingen: Verbind pin 1 (1,2EN) met Arduino-pin 9. Dit is de "enable"-pin, die fungeert als hoofdschakelaar voor de motor. Verbind pin 2 (1A) met Arduino-pin 10 en pin 7 (2A) met Arduino-pin 11. Dit zijn de ingangspinnen die de richting en snelheid van de motor regelen.

Uitleg van de code

De meegeleverde code is goed gestructureerd en eenvoudig aan te passen. De sleutel tot het aanpassen van dit project ligt in een paar eenvoudige variabelen en functieaanroepen bovenaan de sketch. (in video op 07:05)

// DC-motorregeling
#define P1A 10 // definieer pin 10 als P1A
#define P2A 11 // definieer pin 11 als P2A
#define EN12 9 // definieer pin 9 als de 1,2EN-enable

const int speedStep =15;
const int speedDelay = 1000;// vertraging tussen snelheidstoename

• #define P1A, P2A, EN12: Deze regels definiëren welke Arduino-pinnen zijn verbonden met de ingangspinnen van de L293D. Als je andere pinnen hebt gebruikt in je bedrading, wijzig je hier de nummers. Als je bijvoorbeeld EN12 op pin 6 hebt aangesloten, verander je #define EN12 9 in #define EN12 6.
• const int speedStep = 15;: Deze variabele bepaalt de stap waarmee de motorsnelheid verandert in de eerste demonstratielus. Een kleinere waarde (bijv. 5) zorgt ervoor dat de motor soepeler versnelt, terwijl een grotere waarde (bijv. 50) ervoor zorgt dat de snelheid abrupt toeneemt.
• const int speedDelay = 1000;: Dit stelt de vertraging in milliseconden in tussen elke snelheidsstap. Samen met speedStep bepaalt dit hoe snel de motor van nul naar volle snelheid opbouwt. Een waarde van 1000 betekent dat er een pauze van één seconde is tussen elke snelheidsverandering.

Het hart van het project is de aangepaste L293D()-functie. Deze functie vereenvoudigt de besturingslogica, zodat je de richting, snelheid en aan/uit-status van de motor met één regel code kunt instellen. Zo gebruik je het:

L293D('L', 255, 1);  // Draai tegen de klok in op volle snelheid
L293D('R', 127, 1);  // Draai met de klok mee op halve snelheid
L293D('L', 0, 0);    // Stop de motor

• Eerste argument (Richting): Een enkel teken, 'L' of 'R', dat de richting van de motor instelt.
• Tweede argument (Snelheid): Een geheel getal van 0 tot 255 dat de motorsnelheid instelt met PWM. 0 is gestopt en 255 is volle snelheid.
• Derde argument (Enable): Een geheel getal, 1 om de motor te laten draaien of 0 om deze te stoppen.

Live projectdemonstratie

In de video zie je het project in actie. De motor start vanuit stilstand en verhoogt geleidelijk zijn snelheid in stappen, wat de PWM-regeling demonstreert. De Seriële Monitor toont de huidige status en snelheid. Je ziet ook de golfvorm op een oscilloscoop, die visueel laat zien hoe de duty-cycle van het PWM-signaal toeneemt naarmate de motor sneller draait. Dit is een geweldige manier om te begrijpen hoe PWM werkt—het schakelt de stroom snel aan en uit, en de verhouding van "aan"-tijd (de duty-cycle) bepaalt de gemiddelde spanning en dus de motorsnelheid. (in video op 11:07)

Het tweede codevoorbeeld toont een praktischere toepassing. Het laat de motor op volle snelheid in één richting draaien, stopt hem, laat hem op halve snelheid draaien en draait hem vervolgens langzaam in de tegenovergestelde richting. Dit demonstreert hoe je de L293D()-functie kunt gebruiken om complexe bewegingssequenties voor je projecten te creëren.

Hoofdstukken

• [00:00] Introductie en projectoverzicht
• [00:30] De L293D-motorstuurmodule begrijpen
• [01:16] L293D-pinconfiguratie en specificaties
• [04:40] De L293D verbinden met Arduino en motor
• [07:05] Uitleg van de code en aanpassingen
• [11:07] Live demonstratie van snelheids- en richtingsregeling
• [12:30] PWM-golfvormen bekijken op een oscilloscoop

Afbeeldingen

L293D-Motor-Driver-IC

two motor driver between motor and MCU for both directions

Motor driver between motor and MCU for one direction

L293D_unidirectional_battery_wiring_bb

L293d_unidirectional_wiring

L293D-Motor-Driver-IC

two motor driver between motor and MCU for both directions

Motor driver between motor and MCU for one direction

L293D_unidirectional_battery_wiring_bb

L293d_unidirectional_wiring

/*
 * This is the Arduino code to control the speed of a motor using an L293D DC motor driver.

Watch instructions for this video: https://youtu.be/akQoGNUzhHI

 // Written for Robojax.com video 

 * Code is available at http://robojax.com/learn/arduino

 * 
 // Written by Ahmad S. for Robojax.com on 
// August 11, 2018 at 13:23 in Ajax, Ontario, Canada
// This code is AS IS without warranty. You may share it if you keep this note with the code.
*/
// DC motor control
#define P1A 10 // define pin 10 as P1A
#define P2A 11 // define pin 11 as P2A
#define EN12 9 // define pin 9 as the 1,2EN enable

const int speedStep =15;
const int speedDelay = 1000;// delay between speed increment

void setup() {
  // L293 Motor Control Code by Robojax.com 20180811
  Serial.begin(9600);// setup Serial Monitor to display information
  pinMode(P1A, OUTPUT);// define pin as OUTPUT for P1A
  pinMode(P2A, OUTPUT);// define pin as OUTPUT for P2A
  pinMode(EN12, OUTPUT);// define pin as OUTPUT for 1,2EN

  Serial.println("Robojax");
  Serial.println("L293D Motor Speed Control");
  
  // L293 Motor Control Code by Robojax.com 20180811   
}

void loop() {
  // L293D Motor Control Code by Robojax.com 20180811

 for(int speed=0; speed<=255; speed +=speedStep)
 {
  L293D('L',speed, 0);// 
  delay(speedDelay);// delay between each step
 }

  delay(50);// 50 millisecond delay
  // L293D Motor Control Code by Robojax.com 20180810 
}//loop end




/*
 * L293D(char dir,int spd, int en)
 * dir is a character: 'L' for clockwise direction
 *  or 'R' for counter-clockwise direction
 *  en is an integer: 1 to rotate, 0 to stop
 *  spd is the speed value from 0 to 255
 */
void L293D(char dir,int spd, int en)
{
  if(dir =='L')
  {
    if(en ==0){
       Serial.println("CW Motor Stopped");
    }else{
       Serial.print("Rotating CW: "); 
       Serial.println(spd);//print actual speed value        
    }
    digitalWrite(EN12 ,en);// Enable 1A and 2A 
    analogWrite(P1A,spd);// send PWM with spd value to P1A
    digitalWrite(P2A,LOW);// LOW signal to P2A       
   
  }else{
    if(en ==0){
       Serial.println("CCW Motor Stopped");
    }else{
       Serial.print("Rotating CCW: "); 
       Serial.println(spd);//print actual speed value     
    }    
    digitalWrite(EN12 ,en);// Disable 1A and 2A    
    digitalWrite(P1A,LOW);// Keep this pin LOW
    analogWrite(P2A,spd);// send PWM with spd value to  P2A  
  }
}//L293D end

++
/*

 * This is the Arduino code to control the speed of a motor using an L293D DC motor driver.
 * This code will control the motor with different directions and speed.

Watch instructions for this video: https://youtu.be/akQoGNUzhHI

 // Written for Robojax.com video 

 * Code is available at http://robojax.com/learn/arduino

 * 
 // Written by Ahmad Shamshiri for Robojax.com on 
// August 11, 2018 at 13:23 in Ajax, Ontario, Canada.
// This code is AS IS without warranty. You may share it if you keep this note with the code.
*/
// DC motor control
#define P1A 10 // define pin 10 as P1A
#define P2A 11 // define pin 11 as P2A
#define EN12 9 // define pin 9 as the 1,2EN enable

const int speedStep =15;
const int speedDelay = 1000;// delay between speed increment

void setup() {
  // L293 Motor Control Code by Robojax.com 20180811
  Serial.begin(9600);// setup Serial Monitor to display information
  pinMode(P1A, OUTPUT);// define pin as OUTPUT for P1A
  pinMode(P2A, OUTPUT);// define pin as OUTPUT for P2A
  pinMode(EN12, OUTPUT);// define pin as OUTPUT for 1,2EN

  Serial.println("Robojax");
  Serial.println("L293D Motor Speed Control");
  
  // L293 Motor Control Code by Robojax.com 20180811   
}

void loop() {
  // L293D Motor Control Code by Robojax.com 20180811


  L293D('L',255, 1);// maximum speed to the LEFT
  delay(3000);// wait for 3 seconds

  L293D('L',255, 0);// stop motor
  delay(2000);// wait for 2 seconds

  L293D('L',127, 1);// half speed to the LEFT
  delay(3000);// wait for 3 seconds  

  L293D('L',255, 0);// stop motor
  delay(2000);// wait for 2 seconds

  L293D('R',90, 1);// slow to the RIGHT
  delay(3000);// wait for 3 seconds  

  L293D('L',255, 0);// stop motor
  delay(2000);// wait for 2 seconds

  // L293D Motor Control Code by Robojax.com 20180810 
}//loop end




/*
 * L293D(char dir,int spd, int en)
 * dir is a character: 'L' for clockwise (CW) direction
 *  or 'R' for counter-clockwise (CCW) direction.
 *  en is an integer: 1 to rotate, 0 to stop.
 *  spd is the speed value from 0 to 255.
 */
void L293D(char dir,int spd, int en)
{
  if(dir =='L')
  {
    if(en ==0){
       Serial.println("CW Motor Stopped");
    }else{
       Serial.print("Rotating CW: "); 
       Serial.println(spd);//print actual speed value        
    }
    digitalWrite(EN12 ,en);// Enable 1A and 2A 
    analogWrite(P1A,spd);// send PWM with spd value to P1A
    digitalWrite(P2A,LOW);// LOW signal to P2A       
   
  }else{
    if(en ==0){
       Serial.println("CCW Motor Stopped");
    }else{
       Serial.print("Rotating CCW: "); 
       Serial.println(spd);//print actual speed value     
    }    
    digitalWrite(EN12 ,en);//enable 1A and 2A    
    digitalWrite(P1A,LOW);// Keep it LOW P1A
    analogWrite(P2A,spd);// send PWM with spd value to  P2A  
  }
}//L293D end