L298N Modulul driverului de motor DC explicat

În acest post vom învăța despre modulul driverului de motor DC L298N dual H-bridge, care poate fi utilizat pentru a conduce motoare DC periate și motoare pas cu pas cu microcontrolere și circuite integrate.

Prezentare generală

Plăcile de circuite modulare sunt cel mai bun salvator de timp pentru proiectanții de electronice, care reduc și erorile de prototipare. Acest lucru este preferat în mare parte de programatorii care scriu coduri pentru microcontrolere care își petrec majoritatea timpului tastând coduri în fața computerului și au mai puțin timp pentru lipirea componentelor electronice discrete.

De aceea, putem găsi tone și tone de circuite modulare diferite sunt create doar pentru plăcile Arduino, este ușor de interfațat și are avantajul celor mai mici erori hardware în timp ce ne proiectăm prototipul.

Ilustrarea modulului L298N:

Modulul este construit în jurul IC L298N și este disponibil în mod obișnuit pe site-urile de comerț electronic.

Folosim Drivere de motor DC deoarece IC-urile și microcontrolerele nu sunt capabile să furnizeze curent nu mai mult de 100 miliamperi în general. Microcontrolerele sunt inteligente, dar nu sunt puternice, acest modul va adăuga niște mușchi la Arduino, circuite integrate și alte microcontrolere pentru a conduce motoare de curent continuu de mare putere.

Poate controla 2 motoare de curent continuu simultan până la 2 amperi fiecare sau un motor pas cu pas. Noi putem controlează viteza folosind PWM și, de asemenea, direcția de rotație a motoarelor.

Acest modul este ideal pentru construirea roboților și proiecte de mutare a terenurilor, cum ar fi mașinile de jucărie.

Să vedem detaliile tehnice ale modulului L298N.

Descrierea pinului:

· În partea stângă există porturile OUT1 și OUT2, care este pentru conectarea motorului de curent continuu. În mod similar, OUT3 și OUT4 pentru un alt motor DC.

· ENA și ENB sunt pini de activare, prin conectarea ENA la ridicat sau + 5V permite porturile OUT1 și OUT2. Dacă conectați pinul ENA la scăzut sau la masă, acesta dezactivează OUT1 și OUT2. În mod similar, pentru ENB și OUT3 și OUT4.

· IN1 la IN4 sunt pinii de intrare care vor fi conectați la Arduino. Dacă introduceți IN1 + Ve și IN2 –Ve de la microcontroler sau manual, OUT1 devine înalt și OUT2 devine scăzut, astfel putem conduce motorul.

· Dacă introduceți IN3 înalt, OUT4 devine înalt și dacă introduceți IN4 scăzut OUT3 devine scăzut, acum putem conduce un alt motor.

· Dacă doriți să inversați direcția de rotație a motorului, inversați polaritatea IN1 și IN2, în mod similar pentru IN3 și IN4.

· Prin aplicarea semnalului PWM la ENA și ENB puteți controla viteza motoarelor pe două porturi de ieșire diferite.

· Placa poate accepta de la 7 la 12V nominal. Puteți introduce puterea la terminalul + 12V și împământare la 0V.

· Terminalul + 5V este OUTPUT, care poate fi utilizat pentru a alimenta Arduino sau orice alt modul, dacă este necesar.

Jersee:

Există trei știfturi jumper pe care le puteți derula în sus vedeți imaginea ilustrată.

Toți jumperii vor fi conectați inițial scoateți sau păstrați jumperul în funcție de nevoile dvs.

Jumper 1 (vezi imaginea ilustrată):

· Dacă motorul are nevoie de mai mult de 12V alimentare, trebuie să deconectați jumperul 1 și să aplicați tensiunea dorită (maxim 35V) la terminalul 12v. Adu altul Alimentare 5V și intrare la terminalul + 5V. Da, trebuie să introduceți 5V dacă trebuie să aplicați mai mult de 12V (când jumperul 1 este eliminat).

· Intrarea de 5V este pentru buna funcționare a IC-ului, deoarece scoaterea jumperului va dezactiva regulatorul încorporat de 5v și va proteja de tensiunea de intrare mai mare de la terminalul de 12v.

· Terminalul + 5V acționează ca ieșire dacă alimentarea este între 7 și 12V și acționează ca intrare dacă aplicați mai mult de 12V și jumperul este îndepărtat.

· Majoritatea proiectelor au nevoie doar de o tensiune a motorului sub 12V, deci păstrați jumper-ul așa cum este și utilizați terminalul + 5V ca ieșire.

Jumper 2 și Jumper 3 (a se vedea imaginea ilustrată):

· Dacă eliminați aceste două jumperi, trebuie să introduceți semnalul de activare și dezactivare din microcontroler, majoritatea utilizatorilor preferă să elimine cei doi jumperi și să aplice semnalul din microcontroler.

· Dacă păstrați cele două jumperi, OUT1 la OUT4 vor fi întotdeauna activate. Amintiți-vă jumperul ENA pentru OUT1 și OUT2. Jumper ENB pentru OUT3 și OUT4.

Acum să vedem un circuit practic, cum putem motoare de interfață, Arduino și alimentarea la modulul driver.

Schematic:

Circuitul de mai sus poate fi utilizat pentru mașinile de jucărie, dacă modificați codul în mod corespunzător și adăugați un joystick.

Trebuie doar să alimentați modulul L289N, iar modulul va alimenta Arduino prin terminalul Vin.

Circuitul de mai sus va roti ambele motoare în sensul acelor de ceasornic timp de 3 secunde și se va opri timp de 3 secunde. După aceea, motorul se va roti în sens invers acelor de ceasornic timp de 3 secunde și se va opri timp de 3 secunde. Aceasta demonstrează podul H în acțiune.

După aceea, ambele motoare vor începe să se rotească încet în sens invers acelor de ceasornic, câștigând viteză treptat la maxim și reducând treptat viteza la zero. Acest lucru demonstrează controlul vitezei motoarelor de către PWM.

Program:

//----------------Program developed by R.GIRISH--------------//
const int Enable_A = 9
const int Enable_B = 10
const int inputA1 = 2
const int inputA2 = 3
const int inputB1 = 4
const int inputB2 = 5
void setup()
{
pinMode(Enable_A, OUTPUT)
pinMode(Enable_B, OUTPUT)
pinMode(inputA1, OUTPUT)
pinMode(inputA2, OUTPUT)
pinMode(inputB1, OUTPUT)
pinMode(inputB2, OUTPUT)
}
void loop()
{
//----Enable output A and B------//
digitalWrite(Enable_A, HIGH)
digitalWrite(Enable_B, HIGH)
//----------Run motors-----------//
digitalWrite(inputA1, HIGH)
digitalWrite(inputA2, LOW)
digitalWrite(inputB1 , HIGH)
digitalWrite(inputB2, LOW)
delay(3000)
//-------Disable Motors----------//
digitalWrite(Enable_A, LOW)
digitalWrite(Enable_B, LOW)
delay(3000)
//-------Reverse Motors----------//
digitalWrite(Enable_A, HIGH)
digitalWrite(Enable_B, HIGH)
digitalWrite(inputA1, LOW)
digitalWrite(inputA2, HIGH)
digitalWrite(inputB1 , LOW)
digitalWrite(inputB2, HIGH)
delay(3000)
//-------Disable Motors----------//
digitalWrite(Enable_A, LOW)
digitalWrite(Enable_B, LOW)
delay(3000)
//----------Speed rise----------//
for(int i = 0 i < 256 i++)
{
analogWrite(Enable_A, i)
analogWrite(Enable_B, i)
delay(40)
}
//----------Speed fall----------//
for(int j = 256 j > 0 j--)
{
analogWrite(Enable_A, j)
analogWrite(Enable_B, j)
delay(40)
}
//-------Disable Motors----------//
digitalWrite(Enable_A, LOW)
digitalWrite(Enable_B, LOW)
delay(3000)
}
//----------------Program developed by R.GIRISH--------------//

Prototipul autorului:

Dacă aveți întrebări cu privire la acest proiect al driverului de motor DC L298N, nu ezitați să exprimați în secțiunea de comentarii, este posibil să primiți un răspuns rapid.