L298N variklio tvarkyklė – „Arduino“ sąsaja, kaip tai veikia, kodai, schemos

Šioje „Arduino“ pamokoje sužinosime, kaip valdyti nuolatinės srovės variklius naudojant „Arduino“. Mes gerai apžvelgiame keletą pagrindinių nuolatinės srovės variklių valdymo metodų ir pateikiame du pavyzdžius, per kuriuos išmoksime valdyti nuolatinės srovės variklius naudodami L298N variklio tvarkyklę ir „Arduino“ plokštę.

PWM nuolatinės srovės variklio valdymas

PWM arba impulso pločio moduliacija yra technika, leidžianti greitai ir greitai įjungti ir išjungti maitinimą, kad būtų galima reguliuoti vidutinę įtampos, kuri eina į elektroninį prietaisą, vertę. Vidutinė įtampa priklauso nuo darbo ciklo arba signalo įjungimo laiko, palyginti su signalo išjungimo laikotarpiu per vieną laikotarpį.

Taigi, priklausomai nuo variklio dydžio, mes galime tiesiog prijungti „Arduino PWM“ išėjimą prie tranzistoriaus pagrindo arba MOSFET vartų ir valdyti variklio greitį valdydami PWM išvestį. Mažos galios „Arduino PWM“ signalas įjungia ir išjungia MOSFET vartus, pro kuriuos varomas didelės galios variklis.

„H-Bridge“ nuolatinės srovės variklio valdymas

Kita vertus, norėdami valdyti sukimosi kryptį, mes tiesiog turime invertuoti srovės srauto per variklį kryptį, o dažniausiai tai daroma naudojant H tiltą. „H-Bridge“ grandinėje yra keturi perjungimo elementai, tranzistoriai arba MOSFET, kurių variklis centre sudaro H tipo konfigūraciją. Vienu metu įjungę du konkrečius jungiklius, mes galime pakeisti srovės srauto kryptį ir taip pakeisti variklio sukimosi kryptį.

Taigi, jei sujungsime šiuos du metodus – PWM ir H-Bridge, galime visiškai valdyti nuolatinės srovės variklį. Yra daug nuolatinės srovės variklių tvarkyklių, turinčių šias savybes, o L298N yra viena iš jų.

L298N vairuotojas

L298N yra dviguba „H-Bridge“ variklio pavara, leidžianti vienu metu valdyti dviejų nuolatinės srovės variklių greitį ir kryptį. Modulis gali valdyti nuolatinės srovės variklius, kurių įtampa yra nuo 5 iki 35 V, o maksimali srovė yra iki 2A.

Pažvelkime iš arčiau į L298N modulio pinout ir paaiškinkime, kaip jis veikia. Modulis turi du varžtų gnybtų blokus varikliams A ir B ir dar vieną varžtų gnybtų bloką įžeminimo kaiščiui, VCC varikliui ir 5 V kaištį, kuris gali būti įvestis arba išvestis.

Tai priklauso nuo įtampos, naudojamos varikliuose VCC. Modulyje yra įmontuotas 5 V reguliatorius, kuris yra įjungtas arba išjungtas naudojant trumpiklį. Jei variklio maitinimo įtampa yra iki 12 V, galime įjungti 5 V reguliatorių, o 5 V kaištis gali būti naudojamas kaip išvestis, pavyzdžiui, maitinant mūsų „Arduino“ plokštę. Bet jei variklio įtampa yra didesnė nei 12 V, mes turime atjungti trumpiklį, nes dėl šių įtampų bus pažeistas 5B reguliatorius. Šiuo atveju 5 V kaištis bus naudojamas kaip įvestis, nes mums reikia jį prijungti prie 5 V maitinimo šaltinio, kad IC veiktų tinkamai.

Čia galime pažymėti, kad šis IC sumažina įtampą apie 2 V. Pavyzdžiui, jei naudosime 12 V maitinimo šaltinį, variklių gnybtų įtampa bus apie 10 V, o tai reiškia, kad mes negalėsime pasiekti maksimalaus greičio iš mūsų 12 V nuolatinės srovės variklio.

Toliau pateikiami loginio valdymo įėjimai. Kaiščiai „Įjungti A“ ir „Įjungti B“ naudojami įjungti ir valdyti variklio greitį. Jei ant šio kaiščio yra trumpiklis, variklis bus įjungtas ir veiks maksimaliu greičiu, o jei pašalinsime trumpiklį, prie šio kaiščio galime prijungti PWM įvestį ir tokiu būdu valdyti variklio greitį. Jei prijungsime šį kaištį prie įžeminimo, variklis bus išjungtas.

Tada „Input 1“ ir „Input 2“ kaiščiai naudojami variklio A sukimosi krypčiai valdyti, o variklio B. įėjimai 3 ir 4. Naudodami šiuos kaiščius mes iš tikrųjų valdome „H-Bridge“ jungiklius L298N IC viduje. Jei 1 įvestis yra LOW, o įvestis 2 yra HIGH, variklis judės pirmyn ir atvirkščiai, jei 1 įvestis yra HIGH, o 2 įvestis LOW, variklis judės atgal. Jei abu įėjimai yra vienodi, variklis sustos arba LOW, arba HIGH. Tas pats pasakytina apie 3 ir 4 įėjimus ir variklį B.

„Arduino“ ir „L298N“ variklio tvarkyklė

Dabar padarykime keletą praktinių pritaikymų. Pirmajame pavyzdyje mes valdysime variklio greitį naudodami potenciometrą ir pakeisime sukimosi kryptį naudodami mygtuką. Štai grandinių schemos.

Taigi mums reikia L298N variklio tvarkyklės, nuolatinės srovės variklio, potenciometro, mygtuko ir „Arduino“ plokštės.

Šiai „Arduino“ mokymo programai reikalingus komponentus galite gauti iš toliau pateiktų nuorodų:

Atskleidimas: tai yra filialų nuorodos. Kaip „Amazon“ partneris uždirbu iš kvalifikuotų pirkimų.

„Arduino“ kodas

Štai „Arduino“ kodas:

/*  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);
  }
}

Apibūdinimas: Taigi pirmiausia turime apibrėžti programai reikalingus kaiščius ir keletą kintamųjų. Sąrankos skyriuje turime nustatyti kaiščių režimus ir pradinę variklio sukimosi kryptį. Ciklo skyriuje mes pradedame skaityti potenciometro vertę ir tada susieti vertę, kurią gauname nuo 0 iki 1023, iki PWM signalo vertės nuo 0 iki 255, arba tai yra nuo 0 iki 100% darbo ciklo PWM signalas. Tada naudodami „analogWrite“ () funkciją, mes siunčiame PWM signalą į L298N plokštės „Enable“ kaištį, kuris iš tikrųjų varo variklį.

Tada patikrinsime, ar paspaudėme mygtuką, ir, jei tai tiesa, pakeisime variklio sukimosi kryptį, nustatydami atvirkščiai įėjimo 1 ir 2 įėjimo būsenas. Mygtukas veiks kaip perjungimo mygtukas ir kiekvieną kartą, kai jį paspausime, jis pakeis variklio sukimosi kryptį.

„Arduino“ robotų automobilio valdymas naudojant L298N variklio tvarkyklę

Taigi, kai tai išmokome, dabar galime sukurti savo robotą „Arduino“. Štai grandinės schema:

Viskas, ko mums reikia, yra 2 nuolatinės srovės varikliai, L298N variklio tvarkyklė, „Arduino“ plokštė ir valdymo vairasvirtė. Kalbant apie maitinimą, aš nusprendžiau naudoti tris 3,7 V ličio jonų baterijas, iš viso tiekiančias 11 V įtampą. Aš pagaminau važiuoklę iš 3 mm erkių faneros, variklius pritvirtinau prie jos metaliniais laikikliais, pritvirtinau ratus prie variklių ir priekyje pritvirtinau pasukamą ratą.

Dabar pažvelkime į „Arduino“ kodą ir pažiūrėkime, kaip jis veikia. (Žemiau galite rasti visą kodą)

int xAxis = analogRead(A0); // Read Joysticks X-axis
int yAxis = analogRead(A1); // Read Joysticks Y-axis

Apibrėžę kaiščius, kilpos skyriuje, mes pradedame skaityti vairasvirtės X ir Y ašių vertes. Vairasvirtė iš tikrųjų yra pagaminta iš dviejų potenciometrų, kurie yra prijungti prie analoginių „Arduino“ įėjimų ir kurių vertės yra nuo 0 iki 1023. Kai vairasvirtė lieka vidurinėje padėtyje, abiejų potenciometrų arba ašių vertė yra apie 512.

Mes pridėsime šiek tiek tolerancijos ir vertinsime vertes nuo 470 iki 550 kaip centrą. Taigi, jei judėsime vairasvirtės Y ašimi atgal ir vertė bus mažesnė nei 470, nustatysime dviejų variklių sukimosi kryptį atgal, naudodami keturis įvesties kaiščius. Tada mes konvertuosime mažėjančias vertes nuo 470 iki 0 į didėjančias PWM reikšmes nuo 0 iki 255, o tai iš tikrųjų yra variklio greitis.

// 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);
  }

Panašiai, jei judėsime vairasvirtės Y ašimi į priekį ir vertė bus didesnė nei 550, variklius nustatysime judėti į priekį ir rodmenis nuo 550 iki 1023 paversime PWM reikšmėmis nuo 0 iki 255. Jei vairasvirtė lieka jos centre, variklių greitis bus lygus nuliui.

Toliau pažiūrėkime, kaip naudosime X ašį automobilio kairės ir dešinės valdymui.

// 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;
    }
  }

Taigi vėlgi, pirmiausia turime konvertuoti X ašies rodmenis į greičio vertes nuo 0 iki 255. Norėdami judėti kairėn, mes naudojame šią vertę, kad sumažintume kairiojo variklio greitį ir padidintume teisingą variklio greitį. Čia dėl aritmetinių funkcijų mes naudojame du papildomus teiginius „jei“, kad apribotume variklio sūkių diapazoną nuo 0 iki 255.

Tas pats metodas naudojamas perkeliant automobilį į dešinę.

Susijęs: Kaip sukurti PWM nuolatinės srovės variklio greičio valdiklį naudojant 555 laikmačio IC

Atsižvelgiant į taikomą įtampą ir patį variklį, esant mažesniam greičiui, variklis negali pradėti judėti ir jis skleidžia garsą. Mano atveju varikliai negalėjo judėti, jei PWM signalo vertė buvo mažesnė nei 70. Todėl naudodamasis šiais dviem teiginiais aš iš tikrųjų apsiribojau greičio diapazonu nuo 70 iki 255. Pabaigoje mes tiesiog siunčiame galutinius variklio greičius arba PWM signalas į L298N tvarkyklės įjungimo kaiščius.

// 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

Štai visas „Arduino“ roboto automobilio pavyzdžio kodas:

/*  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...