L298N Arduino -opas: DC-moottorin ohjaus alusta loppuun

Ostat 4,90 euron moottoriohjaimen, kytket sen ohjeen mukaan – ja moottori ei liiku, tai se pyörii vain täysillä, tai Arduino käynnistyy uudelleen joka kerta, kun moottori lähtee liikkeelle. L298N on todennäköisesti maailman yleisimmin käytetty harrastemoottoriohjain, ja samalla se, jonka kanssa aloittelija törmää useimpiin ongelmiin. Hyvä uutinen: lähes kaikki nämä viat johtuvat neljästä asiasta, jotka opit tässä oppaassa kertaheitolla. Käymme läpi L298N Arduino -kytkennän alusta loppuun: miksi moottoriohjainta ylipäätään tarvitaan, miten H-silta toimii, miten PWM nopeussäätö kytketään oikein, mitä moduulin kaksi hyppylankaa tekevät ja miten samasta pohjasta rakennetaan toimiva 2WD-robotti.

Opas perustuu ST:n L298-datalehden arvoihin ja käytännön rakenteluun, ja se kertoo rehellisesti myös sen, missä L298N loppuu kesken. Kaikki koodi on testattavissa suoraan Arduino IDE:llä.

Sisällysluettelo

1. Miksi moottoriohjain tarvitaan
2. H-sillan toimintaperiaate
3. L298N-moduulin pinnit ja totuustaulu
4. Osaluettelo ja hinnat
5. Virransyöttö oikein
6. L298N Arduino -kytkentä ja ensimmäinen testi
7. PWM nopeussäätö käytännössä
8. 2WD-robotti Arduinolla
9. Täydellinen ohjelmakoodi
10. Vianetsintä
11. Milloin L298N ei riitä
12. Yhteenveto ja tarvikkeet

Miksi moottoriohjain tarvitaan

ATmega328P:n yksittäisen I/O-pinnin absoluuttinen maksimivirta on 40 mA, ja suositeltu käyttöarvo on noin 20 mA. Vertaa tätä oikeaan moottoriin: 775 DC -moottori 12–24 V vetää tyhjäkäynnillä 0,5–1,7 A ja jumissa jopa 10 A. Se on 25–250-kertainen määrä pinnin kestoon nähden. Pinnin lähtötransistori ei ”rajoita” virtaa, vaan hajoaa – yleensä oikosulkuun, jolloin mukana menee pinni tai koko mikrokontrolleri.

Virta ei ole ainoa ongelma. DC-moottorin ohjaus on hankalaa neljästä syystä:

• Virta: ampeereja vs. milliampeereja.
• Induktiivinen kuorma: kun käämin virta katkeaa, romahtava magneettikenttä synnyttää vastasähkömotorisen voiman V = −L·di/dt, eli kymmenien tai satojen volttien piikin. Piikki rikkoo helposti mikrokontrollerin I/O-rakenteen. Moottoriohjaimissa on vapaakiertodiodit (L298N-moduulissa on), jotka leikkaavat piikin.
• Suunta: yksi pinni voi vain syöttää tai vetää virtaa – se ei voi kääntää jännitteen napaisuutta kuorman yli. Siihen tarvitaan neljä kytkintä eli H-silta.
• Jännitealue: logiikka toimii 5 V:lla, moottori haluaa 12–24 V. Ohjain toimii siltana kahden jännitemaailman välillä.

Oikea ajatusmalli: Arduino on aivot (milliampeerit, logiikkatasot) ja L298N duaali H-silta ohjain on lihakset (ampeerit, moottorijännite). Signaalit kulkevat yhteen suuntaan, teho ei koskaan takaisin.

H-sillan toimintaperiaate

H-silta moottoriohjain koostuu neljästä kytkimestä (Q1–Q4), jotka on aseteltu H-kirjaimen muotoon niin, että moottori on poikkiviiva:

• Q1 + Q4 johtavat → virta kulkee vasemmalta oikealle → moottori pyörii eteen.
• Q2 + Q3 johtavat → virta kulkee oikealta vasemmalle → moottori pyörii taakse.
• Saman puolen kytkimet (Q1+Q3 tai Q2+Q4) → moottorin navat oikosulussa keskenään → moottori toimii generaattorina oikosulkuun → jarrutus.
• Kaikki neljä pois → navat kelluvat → vapaakierto, moottori hidastuu itsekseen.
• Q1 + Q2 samaan aikaan = saman haaran ylä- ja alakytkin johtaa = shoot-through eli suora oikosulku syötön yli. L298N:n sisäinen ohjauslogiikka estää tämän, mikä on iso etu verrattuna neljään erilliseen transistoriin.

L298N sisältää kaksi täydellistä H-siltaa, joten sillä ajetaan kaksi DC-moottoria toisistaan riippumatta – tai yksi bipolaarinen askelmoottori, jolloin kumpikin käämi saa oman siltansa. Piirin lähtöaste on toteutettu NPN-bipolaaritransistoreilla, ei MOSFETeilla, ja juuri siitä johtuu piirin tunnettu jännitehäviö.

L298N-moduulin pinnit ja totuustaulu

Logiikkariman kuusi pinniä:

• ENA – kanavan A enable- eli PWM-tulo. Tehtaalla hyppylankakorkki kytkee sen +5 V:iin.
• IN1, IN2 – moottorin A suuntatulot.
• IN3, IN4 – moottorin B suuntatulot.
• ENB – kanavan B enable- eli PWM-tulo, myös tehtaalla korkitettu.

Ruuviliittimet: +12V (moottorisyöttö 5–35 V, käytännön minimi 6–7 V), GND (yhteinen maa) ja +5V (kaksisuuntainen: hyppylanka paikallaan = 5 V ulos, hyppylanka pois = 5 V sisään). Moottorilähdöt ovat OUT1/OUT2 (moottori A) ja OUT3/OUT4 (moottori B).

Totuustaulu, kanava A

ENA   | IN1  | IN2  | Tulos
------|------|------|--------------------------------
LOW   |  X   |  X   | Pois / vapaakierto
HIGH  | HIGH | LOW  | Eteen, täysi nopeus
HIGH  | LOW  | HIGH | Taakse, täysi nopeus
HIGH  | HIGH | HIGH | Jarru (ylätransistorien kautta)
HIGH  | LOW  | LOW  | Jarru (alatransistorien kautta)
PWM   | HIGH | LOW  | Eteen PWM-nopeudella
PWM   | LOW  | HIGH | Taakse PWM-nopeudella

Klassinen aloittelijan virhe: IN1 = HIGH ja IN2 = HIGH luullen sitä ”kaksinkertaiseksi teholle”. Se on jarru.

Hyppylangat – suurin sudenkuoppa

Kortti tulee paketista niin, että ENA ja ENB on kytketty +5 V:iin keltaisilla hyppylankakorkeilla. Silloin kanavat ovat pysyvästi päällä ja moottori pyörii vain täysillä; IN-pinnit antavat pelkän suunnan. PWM nopeussäätö vaatii korkkien irrottamisen. Jos jätät korkin paikalleen ja kytket Arduinon pinnin ENA:han, sidot Arduinon lähdön suoraan 5 V:n kiskoon – kun koodi vetää pinnin LOW, syntyy oikosulku, joka voi rikkoa pinnin. Säilytä korkit: niitä voi käyttää diagnostiikkaan (”pyöriikö moottori lainkaan, jos enable pakotetaan HIGH?”).

Osaluettelo ja hinnat

• L298N duaali H-silta ohjain – 4,90 € (2 A jatkuva, 3 A huippu kanavaa kohti, 5–35 V, jäähdytyslevy)
• 775 DC Moottori 12–24V – 12,20 € (~4 100 rpm @ 12 V, 5 mm D-akseli)
• LM2596 step-down -jännitemuunnin – 3,90 € (3,2–40 V sisään, 1,3–30 V ulos, hyötysuhde jopa 92 %)
• ATmega328P ’Nano’ ohjain – 9,90 € (16 MHz, PWM-pinnit D3, D5, D6, D9, D10, D11)
• Rengas 68x26mm – 2,40 € (halkaisija 68 mm, sisähalkaisija 51 mm)
• Dupont-hyppylanka 20cm naaras-naaras – Nanolta L298N:n riman pinneihin

Kahden moottorin kokoonpanon osat maksavat yhteensä noin 47,90 € (kaksi 775-moottoria, kaksi rengasta, ohjain, Nano, LM2596 ja hyppylangat). Yhden moottorin koeajokytkentä irtoaa alle 20 eurolla.

Voit lisätä ydinosat suoraan koriin tästä:

Virransyöttö oikein

Moduulissa on 78M05-lineaarisäädin, joka tekee +12V-liittimestä 5 V logiikalle. Hyppylanka kytkee säätimen lähdön +5V-pinniin.

• Hyppylanka paikallaan (moottorisyöttö ≤ 12 V): +5V-pinni on lähtö, josta voi syöttää Nanon. Käytännössä sitä ei kannata kuormittaa kovin paljon.
• Hyppylanka pois (moottorisyöttö > 12 V): +5V-pinni on tulo, ja sinne on pakko syöttää 5 V. Muuten logiikkaosalla ei ole käyttöjännitettä eikä mikään toimi.

Miksi raja on 12 V, kun 78M05 kestää 35 V? Koska lineaarisäädin polttaa eron lämpönä: P = (Vin − 5 V) × Iout. 12 V:lla ja 0,2 A:lla se on 1,4 W, mutta 24 V:lla jo 3,8 W pienessä kotelossa ilman jäähdytystä → lämpösuojaus laukeaa tai piiri hajoaa pysyvästi. Kyse on lämpörajasta, ei jänniterajasta.

Siisti ratkaisu on LM2596 step-down -jännitemuunnin samasta akusta: hakkurina se on ~92 % tehokas, tuskin lämpenee ja antaa logiikalle oman hyvin säädetyn kiskon. Säädä lähtö 5,00 V:iin ennen kuin kytket sen mihinkään: syötä IN+/IN− akusta, jätä lähtö irti, laita yleismittari OUT+/OUT−:iin ja kierrä 25-kierroksista trimmeriä (kierroksia tarvitaan monta) kunnes näyttää 5,00 V. Muista, että tulojännitteen pitää olla vähintään 1,5 V lähtöä korkeampi.

Noin 2 V:n jännitehäviö ja mitä se kustantaa

Datalehden mukaan yläpuolen kyllästysjännite on tyypillisesti 1,35 V (max 2,7 V @ 2 A) ja alapuolen 1,2 V (max 2,3 V @ 2 A). Sarjassa moottorin kanssa häviö on tyypillisesti noin 2 V, pahimmillaan lähes 5 V.

• 12 V syöttö → moottori näkee ~10 V, eli noin 17 % huippunopeutta menetetään.
• Laskuesimerkki 12 V, 1,5 A: häviöteho 2 V × 1,5 A = 3 W yhtä kanavaa kohti. Kaksi moottoria → ~6 W 43 × 43 mm:n moduulissa. Siksi jäähdytyslevystä tulee polttavan kuuma.
• 6 V syötöllä moottori näkee vain ~4 V – siksi pienet lelumoottorit ”eivät oikein pyöri” L298N:llä.
• Kompensointi: nosta syöttöä. Jos haluat moottorille 12 V, syötä ohjaimelle ~14 V – ja irrota 5 V:n hyppylanka.

L298N Arduino -kytkentä ja ensimmäinen testi

Kytkentäkaavio yhdelle moottorille

Nano          L298N
D9  (PWM) --> ENA        [korkki irrotettu]
D8        --> IN1
D7        --> IN2
GND       --> GND

L298N ruuviliittimet
+12V  <-- akun plussa (12 V, vähintään 3 A)
GND   <-- akun miinus JA Nanon GND
+5V   <-- LM2596 OUT+ (5,00 V)   [5 V hyppylanka irrotettu]

LM2596
IN+  <-- akun plussa      OUT+ --> Nanon 5V ja L298N +5V
IN-  <-- akun miinus      OUT- --> yhteinen maa

Moottori
775 nasta 1 --> OUT1     775 nasta 2 --> OUT2

Kytke signaalit ensin, varmista mittarilla, että maa on yhteinen koko kytkennässä, säädä LM2596 5,00 V:iin lähtö irrotettuna – ja kytke akku vasta viimeisenä. Pultaa moottori kiinni ennen ensimmäistä testiä: 775 lähtee renkaan kanssa lentoon pöydältä.

Ensimmäinen testiohjelma

const uint8_t ENA = 9, IN1 = 8, IN2 = 7;

void setup() {
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
}

void loop() {
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
  analogWrite(ENA, 150);          // eteen, noin 59 % pulssisuhde
  delay(2000);
  analogWrite(ENA, 0);            // seis
  delay(1000);
  digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
  analogWrite(ENA, 150);          // taakse
  delay(2000);
  analogWrite(ENA, 0);
  delay(1000);
}

PWM nopeussäätö käytännössä

analogWrite(pin, arvo) ottaa arvon 0–255, joka vastaa 0–100 % pulssisuhdetta. Moottorin näkemä keskijännite on karkeasti V_avg ≈ (arvo/255) × (V_syöttö − 2 V). 12 V:lla ja arvolla 128 se on noin 5 V.

Kolme asiaa, jotka kannattaa tietää:

• Taajuus. ATmega328P:llä 16 MHz:llä oletus on ~490 Hz pinneillä D3, D9, D10, D11 ja ~980 Hz pinneillä D5, D6. Molemmat ovat kuuloalueella, joten käämit surisevat. Taajuutta voi nostaa jakajaa muuttamalla, mutta älä vie L298N:ää yli 20 kHz:iin – BJT-lähtöaste kytkee hitaasti ja lämpenee enemmän. Sopivin alue on noin 1–10 kHz.
• Pulssisuhde ei ole lineaarinen nopeuden kanssa. Alle noin 50–70:n arvoilla 775 ei voita omaa lepokitkaansa, vaan vain hurisee ja kuumenee. Määritä koodissa MIN_PWM (~60) ja skaalaa nopeuspyynnöt välille MIN_PWM…255.
• Ajastimet. D5 ja D6 jakavat Timer0:n millis():in ja delay():n kanssa, joten niiden taajuutta ei kannata muuttaa. D9/D10 ovat Timer1:llä.

// Nostaa D9/D10 (Timer1) taajuuden noin 3,9 kHz:iin
TCCR1B = (TCCR1B & 0b11111000) | 0x02;   // jakaja 8

2WD-robotti Arduinolla

2WD robotti Arduino -alusta syntyy samasta moduulista lisäämällä toinen moottori kanavalle B:

D9  (PWM) --> ENA   vasemman nopeus     D6 (PWM) --> ENB   oikean nopeus
D8        --> IN1                       D5       --> IN3
D7        --> IN2                       D4       --> IN4
Vasen moottori --> OUT1/OUT2            Oikea moottori --> OUT3/OUT4

Koska moottorit ovat rungossa vastakkain, toinen on kytkettävä tai koodattava käänteisesti, jotta ”eteen” tarkoittaa molemmille eteen. Helpoin korjaus: vaihda OUT3 ja OUT4 keskenään. Siisteintä on valita molemmat enable-pinnit samalta ajastimelta, esimerkiksi D9 ja D10, jolloin kanavien PWM-taajuus on identtinen. Kääntyminen tehdään ajamalla pyöriä eri nopeuksilla; paikallaan pyörähdys tehdään ajamalla niitä vastakkaisiin suuntiin.

Välityksen matematiikkaa – tärkeä laskuharjoitus

Rengas 68x26mm -renkaan kehä on π × 0,068 m = 0,2136 m. Jos 775 kytketään suoraan akselille 4 100 rpm:llä, nopeus on 4100/60 × 0,2136 ≈ 14,6 m/s eli noin 52 km/h. Pöytärobotille täysin absurdi. 30:1-välityksellä päästään noin 0,49 m/s, mikä on järkevää. Huomaa myös mekaniikka: 775:n akseli on 5 mm D-akseli ja vain 16 mm pitkä, kun 68 × 26 mm -renkaan napa on tehty tavalliselle harrastevaihdemoottorille. Tarvitset siis navan tai holkkiadapterin, joka sopii 5 mm D-akselille – tai mieluummin pienen vaihteiston.

Täydellinen ohjelmakoodi

/*
  L298N + ATmega328P Nano - 2WD DC-moottorin ohjaus
  Protocache
  ENA/ENB-korkit IRROTETTU. L298N 5V-hyppylanka IRROTETTU,
  logiikka syötetään LM2596:lta 5,0 V.
*/

// ---- Pinnit ----
const uint8_t ENA = 9;   // PWM, vasen nopeus  (Timer1)
const uint8_t IN1 = 8;   // vasen suunta
const uint8_t IN2 = 7;
const uint8_t ENB = 10;  // PWM, oikea nopeus  (Timer1)
const uint8_t IN3 = 5;   // oikea suunta
const uint8_t IN4 = 4;

// ---- Viritys ----
const uint8_t  MIN_PWM      = 60;  // tämän alle moottori vain hurisee
const uint8_t  MAX_PWM      = 255;
const uint16_t RAMP_STEP_MS = 8;   // ms per askel rampitettaessa

int currentLeft  = 0;   // etumerkillinen nopeus -255..255
int currentRight = 0;

void setup() {
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
  stopAll(true);                 // käynnisty jarrutettuna
  Serial.begin(9600);
  Serial.println(F("L298N valmis"));
}

// ---- Matala taso: yksi moottori, nopeus -255..255 ----
void setMotor(uint8_t en, uint8_t inA, uint8_t inB, int speed) {
  speed = constrain(speed, -255, 255);

  if (speed == 0) {                  // vapaakierto
    digitalWrite(inA, LOW);
    digitalWrite(inB, LOW);
    analogWrite(en, 0);
    return;
  }

  bool forward = (speed > 0);
  uint8_t duty = (uint8_t)map(abs(speed), 1, 255, MIN_PWM, MAX_PWM);

  digitalWrite(inA, forward ? HIGH : LOW);
  digitalWrite(inB, forward ? LOW  : HIGH);
  analogWrite(en, duty);
}

void setLeft (int s) { setMotor(ENA, IN1, IN2, s); currentLeft  = s; }
void setRight(int s) { setMotor(ENB, IN3, IN4, s); currentRight = s; }

// ---- Korkea taso ----
void forward(int speed)   { setLeft( speed); setRight( speed); }
void reverse(int speed)   { setLeft(-speed); setRight(-speed); }
void turnLeft(int speed)  { setLeft(-speed); setRight( speed); }  // tankkikäännös
void turnRight(int speed) { setLeft( speed); setRight(-speed); }

void stopAll(bool brake) {
  if (brake) {                       // aktiivinen jarru
    digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW); digitalWrite(IN4, LOW);
    analogWrite(ENA, 255);  analogWrite(ENB, 255);
    delay(150);                      // jarrupulssi, sitten vapautus
    analogWrite(ENA, 0);    analogWrite(ENB, 0);
  } else {                           // vapaakierto
    analogWrite(ENA, 0);    analogWrite(ENB, 0);
    digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW); digitalWrite(IN4, LOW);
  }
  currentLeft = currentRight = 0;
}

// ---- Rampitus: älä koskaan hyppää nollasta täysille ----
void ramp(int targetLeft, int targetRight) {
  while (currentLeft != targetLeft || currentRight != targetRight) {
    if (currentLeft  < targetLeft ) currentLeft++;  else if (currentLeft  > targetLeft ) currentLeft--;
    if (currentRight < targetRight) currentRight++; else if (currentRight > targetRight) currentRight--;
    setLeft(currentLeft);
    setRight(currentRight);
    delay(RAMP_STEP_MS);
  }
}

void loop() {
  ramp(200, 200);   delay(1500);   // kiihdytys eteen
  ramp(0, 0);       delay(300);
  stopAll(true);    delay(500);    // jarru

  ramp(-200, -200); delay(1500);   // kiihdytys taakse
  ramp(0, 0);       delay(500);

  ramp(180, -180);  delay(800);    // pyörähdys paikallaan
  ramp(0, 0);
  stopAll(false);   delay(1000);   // vapaakiertopysäytys
}

Miksi rampitus on tekninen välttämättömyys? Kun pyörivä moottori käännetään hetkessä toiseen suuntaan, syöttöjännite ja moottorin vastasähkömotorinen voima summautuvat käämin yli, ja käynnistysvirta voi olla noin kaksinkertainen jumivirtaan nähden. Rampitus pitää L298N:n 2 A / 3 A -budjetissa ja estää Arduinon jännitekuopan.

Vianetsintä

Moottori ei pyöri lainkaan

1. ENA/ENB-korkit ovat vielä paikallaan, vaikka pinnit on kytketty Arduinoon. Irrota korkit. Yleisin syy.
2. Ei yhteistä maata. L298N GND, Arduinon GND ja akun miinus on kaikki liitettävä yhteen. Jos Arduino on USB:llä ja ohjain verkkolaitteella, IN-pinnit kelluvat. Tämä korjaa yli puolet tapauksista.
3. 5 V:n hyppylanka irti mutta ulkoista 5 V:tä ei ole kytketty → logiikkaosa on kuollut.
4. Moottorisyöttö liian matala; minimi on ~6–7 V jännitehäviön takia.
5. Koodi asettaa IN1:n ja IN2:n samaan tilaan – se on jarru.
6. Ruuviliitin ei purista säiekaapelia. Tinaa pää tai käytä holkkia ja nykäisytestaa joka johto.
7. Mittaa: +12V → GND pitäisi näyttää 9–12 V. Moottori irrotettuna ja IN1 = HIGH, IN2 = LOW, ENA = HIGH, OUT1 → OUT2 näyttää noin (syöttö − 2 V).
8. Ohitustesti: kytke akku suoraan moottorin nastoihin. Pyörii → vika on kytkennässä tai koodissa.

Pyörii vain toiseen suuntaan

Selvitä ensin, onko vika koodissa vai raudassa: vaihda OUT1 ja OUT2 keskenään. Jos toimimaton suunta pysyy samana koodin kannalta, vika on koodissa; jos se seuraa johtoja, vika on raudassa. Rikkoutunut transistoripari on klassinen tapa, jolla L298N kuolee – yleensä äkkinäisen suunnanvaihdon vastasähkömotorisista piikeistä. Siirrä moottori OUT3/OUT4:lle ja aja IN3/IN4/ENB:llä ristiintarkistuksena. Jos molemmat pyörät pyörivät mutta robotti kaartaa, kyse ei ole viasta: toinen moottori on vain peilikuvana asennettu.

Arduino käynnistyy uudelleen kuormituksessa

Syy on jännitekuoppa: käynnistysvirta romahduttaa yhteisen syötön ATmega328P:n alijännitekynnyksen alle, tai harjojen EMI kytkeytyy reset-linjaan. Älä koskaan syötä 775:ää Arduinon tai USB:n läpi.

Anna logiikalle oma säädetty kisko LM2596-muuntimella, lisää 470–1000 µF elektrolyytti +12V/GND-liittimien viereen (huomioi napaisuus!) ja juota 0,1 µF:n keraamiset kondensaattorit moottorin napojen väliin sekä navoista runkoon. Pidä moottorijohdot lyhyinä ja kierrettyinä erillään signaalijohdoista ja rampita nopeudenmuutokset. Mittaa Nanon 5 V:tä moottorin käynnistyshetkellä: jos se painuu alle ~4,3 V, olet löytänyt syyn.

Ohjain kuumenee tai pätkii

Perustaso: joka ampeeri maksaa noin 2 W lämpöä. Kaksi moottoria 1,5 A:lla on ~6 W. Lämmin moduuli on normaalia, mutta niin kuuma, ettei siihen voi koskea hetkeä pidempään, ei ole. L298N:ssä on lämpösuojaus, joka katkaisee lähdöt ja palauttaa ne jäähdyttyään – jos robotti pätkii 30–60 sekunnin jälkeen ja toimii tauon jälkeen, se on ylikuumeneminen, ei koodivika. Laske huippu-PWM:ää, varmista että jäähdytyslevy koskettaa piiriä lämpötahnalla, asenna moduuli avoimeen ilmaan äläkä rungon alle, ja aja 775:ää mieluummin 12 V:lla kuin 24 V:lla: 24 V kaksinkertaistaa lämmön samalla mekaanisella teholla.

PWM ei tee mitään (täysillä tai pois)

ENA/ENB-korkki on paikallaan, enable-pinni ei ole PWM-pinni (Nanolla vain D3, D5, D6, D9, D10, D11), tai koodissa on kutsuttu digitalWrite()-funktiota enable-pinnille analogWrite():n jälkeen, mikä peruuttaa PWM:n.

Milloin L298N ei riitä

Rehellinen arvio: L298N:n 2 A jatkuva / 3 A huippu on 775-moottorin kanssa aivan rajoilla. Se riittää tyhjäkäynti- ja kevytkuormatestaukseen sekä kevyeen 2WD-alustaan tasaisella lattialla, kun käytät pehmeää rampitusta ja rajoitat huippu-PWM:ää. Se ei riitä kovaan kuormaan eikä jumitilanteeseen (10 A). Älä siis anna moottorin jumiutua, pidä virta alle 2 A kanavaa kohti, äläkä käännä suuntaa hetkessä.

Vertailun vuoksi: L298N (BJT) ~2 V häviö, 2 A/kanava, 5–35 V, tarvitsee jäähdytyksen, 4,90 €. TB6612FNG (MOSFET) ~0,5 V häviö, 1,2 A jatkuva, 2,5–13,5 V, pysyy viileänä. BTS7960 (MOSFET-puolisillat) hyvin pieni häviö, jopa ~43 A, 5,5–27 V – oikea vastaus täydellä kuormalla ajettavaan 775:een. Johtopäätös: L298N on paras oppimisohjain (halpa, anteeksiantava, ruuviliittimet, kaikki toiminnot näkyvissä) ja huonoin hyötysuhdeohjain. Kun ymmärrät sen, päivitä.

Luontevat jatkoaskeleet: MPU-6050-gyroskooppimoduuli auttaa robottia ajamaan suoraan gyrotakaisinkytkennällä, ja ESP32 DevKitC tuo WiFi- ja Bluetooth-ohjauksen. Huomaa ESP32:lla kaksi asiaa: logiikka on 3,3 V (mikä yleensä riittää L298N:n HIGH-kynnykseen, tyypillisesti 2,3 V) ja analogWrite() korvautuu ledcWrite()-funktiolla.

Turvallisuuden muistilista

• Kytke maat ensin, teho viimeisenä.
• Säädä LM2596 5,00 V:iin ennen kuin kytket sen mihinkään.
• Huomioi elektrolyyttikondensaattorin napaisuus.
• Kiinnitä moottori ennen ensimmäistä testiä.
• Lisää 3–5 A sulake tai vähintään katkaisija akun plussaan.
• Älä irrota tai kytke moottoreita jännitteen ollessa päällä.
• Tarkista 5 V:n hyppylangan tila aina, kun vaihdat akkua.

Yhteenveto ja tarvikkeet

Jos muistat tästä oppaasta vain viisi asiaa, muista nämä:

1. Irrota ENA/ENB-korkit heti, kun haluat PWM nopeussäädön. Korkki paikallaan = vain täysi nopeus ja riski oikosulkea Arduinon pinni.
2. Yhteinen maa Arduinon, L298N:n ja akun välillä. Tämä yksi johto korjaa yli puolet ”moottori ei pyöri” -tapauksista.
3. 5 V:n hyppylanka pois yli 12 V:n syötöllä – ja silloin logiikalle on pakko syöttää 5 V ulkoa, esimerkiksi LM2596:lta.
4. Laske ~2 V:n jännitehäviö pois jokaisesta laskelmasta. Sama häviö tarkoittaa noin 2 W lämpöä per ampeeri per kanava.
5. Rampita nopeus- ja suunnanmuutokset. Nollasta täysille hyppääminen tuottaa virtapiikin, joka laukaisee lämpösuojauksen tai resetoi Arduinon.

Näillä säännöillä L298N on erinomainen ensimmäinen moottoriohjain: halpa, anteeksiantava ja niin läpinäkyvä, että sen kautta oppii todella ymmärtämään H-siltaa, PWM:ää ja tehonsyöttöä. Kun rajat tulevat vastaan, tiedät täsmälleen miksi – ja mihin päivittää.

Kerää koko projekti kerralla

Tutustu valikoimaamme ja kerää tämän oppaan osat suoraan koriin. Kaikki tuotteet lähtevät varastosta Suomesta.

Jatkokehitystä varten: MPU-6050 kiihtyvyysanturi- ja gyroskooppimoduuli suoraan ajamiseen ja ESP32 DevKitC (WROOM-32) langattomaan ohjaukseen.