Arduino DC Motor Control Tutorial – L298N |

PWM | H-Bridge

În acest Arduino Tutorial vom învăța cum să controlați motoarele DC folosind

Arduino. Ne uităm bine la câteva tehnici de bază pentru controlul motoarelor DC și facem două
exemple prin care vom învăța cum să controlam motoarele DC folosind driverul L298N și placa
Arduino.

Prezentare generală

Putem controla viteza motorului DC prin simpla control a tensiunii de intrare la motor
și cea mai obișnuită metodă de a face acest lucru este prin utilizarea semnalului PWM.

Controlul motorului PWM DC

PWM sau modulația lățimii impulsurilor este o tehnică care ne permite să ajustăm
valoarea medie a tensiunii care se deplasează la dispozitivul electronic prin pornirea și oprirea
alimentării la viteză rapidă. Tensiunea medie depinde de ciclul de funcționare sau de timpul în
care semnalul este pornit față de timpul în care semnalul este oprit într-o singură perioadă de
timp.
 Deci, în funcție de dimensiunea motorului, putem conecta o ieșire PWM Arduino la
baza tranzistorului sau la poarta unui MOSFET și putem controla viteza motorului prin controlul
ieșirii PWM. Semnalul PWM Arduino de putere redusă pornește și se oprește la poarta de la
MOSFET prin care este condus motorul de mare putere.

Controlul motorului DC de la H-Bridge

Pe de altă parte, pentru a controla direcția de rotație, trebuie doar să inversăm direcția
fluxului curent prin motor și cea mai obișnuită metodă de a face acest lucru este folosirea unui
pod H. Un circuit H-Bridge conține patru elemente de comutare, tranzistoare sau MOSFET-uri,
cu motorul în centru, care formează o configurație tip H. Prin activarea a două comutatoare
particulare în același timp, putem schimba direcția fluxului curent, schimbând astfel direcția de
rotație a motorului.
 Deci, dacă combinăm aceste două metode, PWM și H-Bridge, putem avea un control
complet asupra motorului DC. Există multe drivere DC care au aceste caracteristici, iar L298N
este unul dintre ele.

L298N Driver

L298N este un conducător motor dublu H-Bridge, care permite controlul vitezei și
direcției a două motoare cc în același timp. Modulul poate conduce motoarele DC care au
tensiuni între 5 și 35V, cu un curent de vârf de până la 2A.

Să aruncăm o privire mai atentă la pinul modulului L298N și să explicăm cum

funcționează. Modulul are două blocuri cu șurub pentru motoarele A și B și un alt bloc de borne
pentru pinul de împământare, motorul VCC pentru motor și un pin 5V care poate fi fie o intrare,
fie o ieșire.
 Aceasta depinde de tensiunea utilizată la motoarele VCC. Modulul are un regulator de
5V la bord care este activat sau dezactivat cu ajutorul unui jumper. Dacă tensiunea de alimentare
a motorului este de până la 12V, putem activa regulatorul 5V și pinul 5V poate fi folosit ca
ieșire, de exemplu pentru alimentarea plăcii noastre Arduino. Dar dacă tensiunea motorului este
mai mare de 12V, trebuie să deconectăm jumperul deoarece aceste tensiuni vor cauza
deteriorarea regulatorului 5V de la bord. În acest caz pinul 5V va fi folosit ca intrare ca avem
nevoie de conectați-l la o sursă de alimentare de 5V pentru ca IC să funcționeze corect.

Putem observa aici că acest IC face o scădere de tensiune de aproximativ 2V. De

exemplu, dacă folosim o sursă de alimentare de 12V, tensiunea la terminalele motoarelor va fi de
aproximativ 10V, ceea ce înseamnă că nu vom putea obține viteza maximă din motorul nostru de
12V DC.

Următoarele sunt intrările de control logic. Butoanele Activare A și Activare B sunt

utilizate pentru activarea și controlul vitezei motorului. Dacă pe acest pin există un jumper,
motorul va fi activat și va funcționa la viteza maximă și dacă scoatem jumperul, putem conecta o
intrare PWM la acest pin și astfel controla viteza motorului. Dacă conectăm acest pin la o masă,
motorul va fi dezactivat.
 Apoi, pinii de intrare 1 și de intrare 2 sunt utilizați pentru controlul direcției de rotație a
motorului A și a intrărilor 3 și 4 pentru motorul B. Folosind aceste știfturi, de fapt controlam
comutatoarele podului H din interiorul IC L298N. Dacă intrarea 1 este LOW și intrarea 2 este
HIGH, motorul se va deplasa înainte și invers, dacă intrarea 1 este HIGH și intrarea 2 este LOW
motorul se va deplasa înapoi. În cazul în care ambele intrări sunt identice, fie LOW sau HIGH
motorul se va opri. Același lucru este valabil și pentru intrările 3 și 4 și motorul B.

Arduino și L298N

Acum să facem niște aplicații practice. În primul exemplu vom controla viteza
motorului cu ajutorul unui potențiometru și vom schimba direcția de rotație cu ajutorul unui
buton. Iată schemele de circuite.

Avem nevoie de:

 un driver L298N
 un motor DC
 un potențiometru
 un buton de apăsare
 o placă Arduino.

Codul Arduino este:

1. /* Arduino DC Motor Control - PWM | H-Bridge | L298N - Example 01

2.
3. by Dejan Nedelkovski, www.HowToMechatronics.com
 4. */
5.
6. #define enA 9
7. #define in1 6
8. #define in2 7
9. #define button 4
10.
11. int rotDirection = 0;
12. int pressed = false;
13.
14. void setup() {
15. pinMode(enA, OUTPUT);
16. pinMode(in1, OUTPUT);
17. pinMode(in2, OUTPUT);
18. pinMode(button, INPUT);
19. // Set initial rotation direction
20. digitalWrite(in1, LOW);
21. digitalWrite(in2, HIGH);
22. }
23.
24. void loop() {
25. int potValue = analogRead(A0); // Read potentiometer value
26. int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0 to 255
27. analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin
28.
29. // Read button - Debounce
30. if (digitalRead(button) == true) {
31. pressed = !pressed;
32. }
33. while (digitalRead(button) == true);
34. delay(20);
35.
36. // If button is pressed - change rotation direction
37. if (pressed == true & rotDirection == 0) {
38. digitalWrite(in1, HIGH);
39. digitalWrite(in2, LOW);
40. rotDirection = 1;
41. delay(20);
42. }
43. // If button is pressed - change rotation direction
44. if (pressed == false & rotDirection == 1) {
45. digitalWrite(in1, LOW);
46. digitalWrite(in2, HIGH);
47. rotDirection = 0;
48. delay(20);
49. }
50. }

Descriere:
Deci, mai întâi trebuie să definim pinii și unele variabile necesare pentru program. În
secțiunea de configurare trebuie să setăm modurile pin și direcția inițială de rotație a motorului.
În secțiunea buclă, începem prin citirea valorii potențiometrului și apoi mapăm valoarea pe care
o obținem de la 0 la 1023, la o valoare de la 0 la 255 pentru semnalul PWM sau de la ciclul de
funcționare de la 0 la 100% Semnal PWM. Apoi, folosind funcția analogWrite () trimitem
semnalul PWM la pinul Enable al plăcii L298N, care de fapt conduce motorul.

Apoi, verificăm dacă am apăsat butonul și dacă este adevărat, vom schimba direcția de
rotație a motorului prin setarea inversă a stărilor Input 1 și Input 2. Butonul de comandă va
funcționa ca buton de comutare și de fiecare dată când îl apăsăm, va schimba direcția de rotație a
motorului.

Arduino Robot de control auto folosind L298N Driver

Deci, odată ce am învățat acest lucru, acum putem construi mașina noastră robustă
Arduino. Iată circuitul schematic:

Tot ce avem nevoie este 2 Motoare DC, driverul L298N, o placă Arduino și un joystick
pentru control. În ceea ce privește sursa de alimentare, am ales să folosesc trei baterii Li-ion de
3.7V, furnizând un total de 11V. Am scos șasiul din placaj de 3 mm, am atașat motoarele la
acesta folosind suporturi din metal, roți atașate la motoare și în față atașat o roată rotativă.
Acum, să aruncăm o privire la codul Arduino și să vedem cum funcționează. (Jos de tot puteți găsi codul
complet)
1. int xAxis = analogRead(A0); // Read Joysticks X-axis
2. int yAxis = analogRead(A1); // Read Joysticks Y-axis

După definirea pinilor, în secțiunea buclă, începem să citim valorile joystick-ului X și

Y. Joystick-ul este de fapt compus din două potențiometre care sunt conectate la intrările
analogice ale Arduino și au valori între 0 și 1023. Când joystick-ul rămâne în poziția sa centrală,
valoarea atât a potențiometrelor, cât și a axelor este de aproximativ 512.
 Vom adăuga o mică toleranță și vom considera valorile de la 470 la 550 ca centru.
Deci, dacă mișcăm axa Y a joystick-ului înapoi și valoarea merge sub 470, vom seta direcția de
rotație a două motoare înapoi cu ajutorul celor patru pini de intrare. Apoi, vom converti valorile
în scădere de la 470 la 0 în creșterea valorilor PWM de la 0 la 255, care este de fapt viteza
motorului.
1. // Y-axis used for forward and backward control
2. if (yAxis < 470) {
3. // Set Motor A backward
4. digitalWrite(in1, HIGH);
5. digitalWrite(in2, LOW);
6. // Set Motor B backward
7. digitalWrite(in3, HIGH);
8. digitalWrite(in4, LOW);
9. // 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
10. motorSpeedA = map(yAxis, 470, 0, 0, 255);
11. motorSpeedB = map(yAxis, 470, 0, 0, 255);
12. }

Similar, dacă mișcăm axa Y a joystick-ului înainte și valoarea merge peste 550, vom
seta motoarele să meargă înainte și să convertească citirile de la 550 la 1023 în valori PWM de la
0 la 255. Dacă joystick-ul rămâne în centrul său viteza motoarelor va fi zero.

Apoi, să vedem cum folosim axa X pentru controlul stânga și la dreapta al mașinii.

1. // X-axis used for left and right control

2. if (xAxis < 470) {
3. // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
4. int xMapped = map(xAxis, 470, 0, 0, 255);
5. // Move to left - decrease left motor speed, increase right motor speed
6. motorSpeedA = motorSpeedA - xMapped;
7. motorSpeedB = motorSpeedB + xMapped;
8. // Confine the range from 0 to 255
9. if (motorSpeedA < 0) {
10. motorSpeedA = 0;
11. }
12. if (motorSpeedB > 255) {
13. motorSpeedB = 255;
14. }
15. }

Din nou, mai întâi trebuie să convertim citirile din axa X în valori de viteză de la 0 la
255. Pentru deplasarea spre stânga, folosim această valoare pentru a micșora viteza stânga a
motorului și pentru a mări viteza motorului drept. Aici, din cauza funcțiilor aritmetice, folosim
două declarații suplimentare "if" pentru a limita intervalul de viteză al motorului de la 0 la 255.
Aceeași metodă este folosită pentru deplasarea autovehiculului spre dreapta.

În funcție de tensiunea aplicată și motorul însuși, la viteze mai mici, motorul nu poate
începe să se miște și produce un sunet buruiat. În cazul meu, motoarele nu s-au putut deplasa
dacă valoarea semnalului PWM a fost sub 70. Prin urmare, folosind aceste două declarații de
fapt, am limitat de fapt intervalul de viteză de la 70 la 255. La final, trimitem doar vitezele finale
ale motorului sau Semnalul PWM către pinii de acționare ai driverului L298N.

1. // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM
value was below value of 70)
2. if (motorSpeedA < 70) {
3. motorSpeedA = 0;
4. }
5. if (motorSpeedB < 70) {
6. motorSpeedB = 0;
7. }
8. analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
9. analogWrite(enB, motorSpeedB); // Send PWM signal to motor B

Iată codul complet al exemplului de mașină robot Arduino:

1. /* Arduino DC Motor Control - PWM | H-Bridge | L298N

2. Example 02 - Arduino Robot Car Control
3. by Dejan Nedelkovski, www.HowToMechatronics.com
4. */
5.
6. #define enA 9
7. #define in1 4
8. #define in2 5
9. #define enB 10
10. #define in3 6
11. #define in4 7
12.
13. int motorSpeedA = 0;
14. int motorSpeedB = 0;
15.
16. void setup() {
17. pinMode(enA, OUTPUT);
18. pinMode(enB, OUTPUT);
19. pinMode(in1, OUTPUT);
20. pinMode(in2, OUTPUT);
21. pinMode(in3, OUTPUT);
22. pinMode(in4, OUTPUT);
23. }
24.
25. void loop() {
26. int xAxis = analogRead(A0); // Read Joysticks X-axis
27. int yAxis = analogRead(A1); // Read Joysticks Y-axis
28.
29. // Y-axis used for forward and backward control
30. if (yAxis < 470) {
31. // Set Motor A backward
32. digitalWrite(in1, HIGH);
33. digitalWrite(in2, LOW);
34. // Set Motor B backward
35. digitalWrite(in3, HIGH);
36. digitalWrite(in4, LOW);
37. // 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
38. motorSpeedA = map(yAxis, 470, 0, 0, 255);
39. motorSpeedB = map(yAxis, 470, 0, 0, 255);
40. }
41. else if (yAxis > 550) {
42. // Set Motor A forward
43. digitalWrite(in1, LOW);
44. digitalWrite(in2, HIGH);
45. // Set Motor B forward
46. digitalWrite(in3, LOW);
47. digitalWrite(in4, HIGH);
48. // 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
49. motorSpeedA = map(yAxis, 550, 1023, 0, 255);
50. motorSpeedB = map(yAxis, 550, 1023, 0, 255);
51. }
52. // If joystick stays in middle the motors are not moving
53. else {
54. motorSpeedA = 0;
55. motorSpeedB = 0;
56. }
57.
58. // X-axis used for left and right control
59. if (xAxis < 470) {
60. // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
61. int xMapped = map(xAxis, 470, 0, 0, 255);
62. // Move to left - decrease left motor speed, increase right motor speed
63. motorSpeedA = motorSpeedA - xMapped;
 64. motorSpeedB = motorSpeedB + xMapped;
65. // Confine the range from 0 to 255
66. if (motorSpeedA < 0) {
67. motorSpeedA = 0;
68. }
69. if (motorSpeedB > 255) {
70. motorSpeedB = 255;
71. }
72. }
73. if (xAxis > 550) {
74. // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
75. int xMapped = map(xAxis, 550, 1023, 0, 255);
76. // Move right - decrease right motor speed, increase left motor speed
77. motorSpeedA = motorSpeedA + xMapped;
78. motorSpeedB = motorSpeedB - xMapped;
79. // Confine the range from 0 to 255
80. if (motorSpeedA > 255) {
81. motorSpeedA = 255;
82. }
83. if (motorSpeedB < 0) {
84. motorSpeedB = 0;
85. }
86. }
87. // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM
value was below value of 70)
88. if (motorSpeedA < 70) {
89. motorSpeedA = 0;
90. }
91. if (motorSpeedB < 70) {
92. motorSpeedB = 0;
93. }
94. analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
95. analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
96. }

Source:https://howtomechatronics.com/tutorials/arduino/arduino-dc-motor-control-tutorial-l298n-pwm-h-bridge/