L298N Arduino -opas: kytkentä ja valmis koodi

DC-moottorin ohjaus on se kohta, jossa moni Arduino-harrastaja polttaa ensimmäisen mikrokontrollerinsa. Moottori näyttää yksinkertaiselta – kaksi johtoa, jännite väliin ja se pyörii – mutta juuri siksi se on ansa. Tässä oppaassa käydään läpi L298N Arduino -kytkentä alusta loppuun: miksi moottoria ei voi ohjata suoraan I/O-pinnistä, miten H-silta toimii, miten suunta ja nopeus ohjataan koodista, miten virransyöttö tehdään siististi ja mitä L298N:n noin kahden voltin jännitehäviö oikeasti maksaa.

Lopussa on kokonainen, kommentoitu Arduino-sketsi kahdelle moottorille, sekä rehellinen arvio siitä, mihin tämä 4,90 euron moduuli riittää ja mihin ei. Tuo osuus on tärkeä: netti on täynnä ohjeita, joissa L298N:n perään laitetaan moottori, jonka jumitusvirta on viisinkertainen ohjaimen kestoon verrattuna.

Miksi moottoria ei voi ohjata suoraan Arduinon pinnistä

Neljä erillistä syytä, ja jokainen niistä riittäisi yksinään.

Virta. ATmega328P:n I/O-pinnin absoluuttinen maksimi on 40 mA, ja suunnitteluarvona kannattaa käyttää 20 mA. Koko piirillä on lisäksi omat yhteisrajansa. Pienikin lelumoottori vetää kuormittamattomana 100–250 mA, ja isompi moottori ampeereja. Rajan ylitys rikkoo pinnin lähtöasteen – yleensä pysyvästi ja usein niin, että naapuripinnit lähtevät mukana.
Induktiivinen takapotku. Moottorin käämi on kela. Kun virta katkaistaan, L·di/dt synnyttää kymmenien tai satojen volttien vastapiikin, joka lyö suoraan läpi 5 voltin CMOS-lähdöstä. Tarvitaan vapaakiertodiodit – L298N-moduulissa ne ovat valmiina.
Suunta. Yksi pinni voi olla vain HIGH tai LOW eli yksi napaisuus. Harjallisen DC-moottorin pyörimissuunta vaihdetaan kääntämällä napaisuus, ja se vaatii fyysisesti neljä kytkintä eli H-sillan.
Harjakohina. Kommutaattorin kipinöinti syöttää laajakaistaista sähköistä kohinaa takaisin käyttöjännitteeseen ja jokaiseen moottoriin kytkettyyn johtoon. Se kaataa tai resetoi mikrokontrollerin, joka jakaa moottorin kanssa samat virtakiskot.

Mikä H-silta on ja miten se toimii

H-silta moottoriohjain koostuu neljästä elektronisesta kytkimestä, jotka on aseteltu H-kirjaimen muotoon: kaksi ylälaidan kytkintä käyttöjännitteeseen, kaksi alalaidan kytkintä maahan, ja moottori H:n poikkiviivana.

Vasen yläkytkin + oikea alakytkin kiinni → virta kulkee vasemmalta oikealle → eteen.
Oikea yläkytkin + vasen alakytkin kiinni → virta toiseen suuntaan → taakse.
Molemmat alakytkimet kiinni → moottorin navat oikosuljettu maahan → moottori toimii oikosuljettuna generaattorina → jarrutus, terävä pysähdys.
Kaikki neljä auki → navat ilmassa → vapaarullaus, ei vääntöä, robotti liukuu eteenpäin.

Saman puolen ylä- ja alakytkimen sulkeminen samanaikaisesti on läpiampuminen (shoot-through) eli suora oikosulku käyttöjännitteen yli. L298N on tältä turvassa rakenteellisesti: kumpaakin puolisiltaa ohjataan yhdestä logiikkatulosta, ja sisäinen logiikka takaa, ettei ylä- ja alatransistori ole koskaan johtavina yhtä aikaa. Tämä on aito etu neljään irralliseen MOSFETiin verrattuna. Lisäksi piirissä on ylikuumenemissuoja.

Huomionarvoista: L298N käyttää bipolaarisia Darlington-transistoreita, ei MOSFETeja. Siitä seuraa sen tunnettu jännitehäviö, johon palataan alempana.

L298N-moduulin pinnit ja jumpperit

Käytämme L298N duaali H-silta ohjain -moduulia. Se hyväksyy moottorijännitteeksi 5–35 V, kestää 2 A jatkuvaa ja 3 A hetkellistä virtaa kanavaa kohti, ja siinä on 220 µF suodatuskondensaattorit, vapaakiertodiodit, ruuviliittimet sekä alumiininen ripajäähdytin.

Riviliittimet ja pinnit

ENA / ENB – kanavan käyttöönotto ja PWM-nopeussäätö. Moduuli toimitetaan niin, että jumpperi on kiinni 5 voltissa.
IN1 / IN2 – kanavan A suunta, IN3 / IN4 – kanavan B suunta.
OUT1 / OUT2 – moottori A, OUT3 / OUT4 – moottori B.
12V (VCC) – moottorijännite 5–35 V. GND – yhteinen maa, pakko yhdistää Arduinon maahan.
5V – lähtö moduulin 78M05-regulaattorilta, kun jumpperi on kiinni, tai tulo ulkoiselle 5 voltille, kun jumpperi on irrotettu.

Kanavan A totuustaulu

ENA LOW, IN-pinnit mitä vain → moottori pois, vapaarullaus.
ENA HIGH/PWM, IN1 HIGH, IN2 LOW → pyörii suuntaan yksi.
ENA HIGH/PWM, IN1 LOW, IN2 HIGH → pyörii toiseen suuntaan.
ENA HIGH, IN1 = IN2 (molemmat LOW tai molemmat HIGH) → jarru.

Tästä syntyy tärkeä opetus: pysäytyksiä on kaksi eri lajia. ENA = 0 antaa moottorin rullata vapaasti, IN1 = IN2 jarruttaa. Robotissa ero näkyy heti: vapaarullaus jatkaa matkaa senttejä liikaa, jarru pysäyttää napakasti.

Kriittinen asennusvaihe: ENA- ja ENB-jumpperit on irrotettava ennen kuin PWM-nopeussäätö toimii. Jumpperin ollessa paikallaan enable on kovakytketty 5 volttiin ja moottori käy vain täysillä päällä tai pois. Tämä on ykkössyy sille, että aloittelija raportoi ”PWM ei tee mitään”.

L298N Arduino -kytkentä penkkitestiin

Ohjaimena on ATmega328P ’Nano’ ohjain. Sen PWM-kelpoiset pinnit ovat D3, D5, D6, D9, D10 ja D11 – ENA ja ENB täytyy osua näistä kahteen.

Johdotukseen riittävät Dupont-hyppylangat (uros-naaras, 10 cm): naaraspää L298N:n piikkirimaan, urospää Nanon riviin. Moottorien tehojohdot menevät sen sijaan ruuviliittimiin – niihin ei pidä käyttää ohutta hyppylankaa, koska 2 ampeeria kuumentaa 28 AWG:n langan.

ENA → D9 (PWM, jumpperi irti)
IN1 → D8, IN2 → D7
IN3 → D6, IN4 → D5
ENB → D10 (PWM, jumpperi irti)
OUT1/OUT2 → moottori A (vasen), OUT3/OUT4 → moottori B (oikea)
12V → akun plus (5–35 V)
GND → akun miinus ja Nanon GND ja LM2596:n IN−/OUT−
5V → LM2596:n OUT+ (5,00 V), moduulin 5V-jumpperi irrotettu

Kytkentätaulukko

L298N	Arduino Nano	Huomio
ENA	D9	PWM-pinni, jumpperi irti
IN1	D8	moottori A suunta
IN2	D7	moottori A suunta
IN3	D6	moottori B suunta
IN4	D5	moottori B suunta
ENB	D10	PWM-pinni, jumpperi irti
GND	GND	pakollinen yhteinen maa
5V	5V	LM2596:lta, 5V-jumpperi irti
12V	–	akun plus, 5–35 V

Kokoamisjärjestys, joka pitää savut poissa: säädä ensin LM2596 mittarilla 5,00 volttiin → kytke maat → kytke logiikkajohdot → kytke moottorijännite vasta viimeisenä → käynnistä moottori kuormittamattomana ja pidä sormi jäähdyttimen lähellä.

Rehellinen varoitus: 775-moottori ja L298N

Moni haluaa kytkeä L298N:n perään 775 DC Moottori 12–24V -moottorin. Luvut eivät täsmää: L298N kestää 2 A jatkuvasti ja 3 A hetkellisesti, kun taas 775 vetää jumissa 10 A tai enemmän, ja käynnistysvirta on käytännössä jumitusvirta muutamien kymmenien millisekuntien ajan.

Käytännön johtopäätös: L298N pyörittää 775:tä kuormittamattomana penkillä, alennetulla PWM-arvolla ja lyhyen demon ajan – se on täysin kelpo tapa opetella kytkentä ja koodi. Se ei ole riittävä ohjain 775:lle oikeassa työssä. Kuormitettuna L298N osuu ylikuumenemissuojaansa, katkoo, nykii ja voi rikkoutua. Oikeaan 775-käyttöön tarvitaan vähintään 10 ampeerin ohjain (BTS7960/IBT-2-luokka tai diskreetti MOSFET-silta) – sellaista ei tällä hetkellä ole valikoimassamme, ja se on rehellisempää sanoa kuin väittää L298N:ää riittäväksi. Käytä siis penkkitestissä pehmeää kiihdytysramppia, jolla käynnistysvirta pysyy spesifikaation sisällä.

Suunnan ohjaus IN-pinneillä

Ensimmäinen sketsi ei tarvitse PWM:ää lainkaan – pelkkä digitalWrite riittää suunnan opetteluun. Pidä ENA-jumpperi tässä vaiheessa kiinni tai kirjoita ENA-pinni HIGH-tilaan.

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

void setup() {
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  digitalWrite(ENA, HIGH);          // kanava paalle, taysi nopeus
}

void loop() {
  digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);   // eteen
  delay(2000);
  digitalWrite(IN1, LOW);  digitalWrite(IN2, LOW);   // jarru
  delay(1000);
  digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH);  // taakse
  delay(2000);
  digitalWrite(ENA, LOW);                            // vapaarullaus
  delay(1000);
  digitalWrite(ENA, HIGH);
}

Jos ”eteen” pyörii väärään suuntaan, vaihda moottorin kaksi johtoa ruuviliittimessä keskenään tai vaihda pinnien numerot koodissa. Kumpi suunta on eteen, riippuu pelkästään kytkennästä.

PWM nopeussäätö ENA-pinnillä

PWM nopeussäätö tehdään kirjoittamalla ENA- tai ENB-pinniin analogWrite(pin, arvo), jossa arvo on 0–255. Kyse on pulssisuhteesta, ei jännitteestä: arvo 128 tarkoittaa, että silta on johtavana noin puolet ajasta.

Kolme asiaa, jotka kannattaa tietää ennen kuin ihmettelee:

Vain PWM-pinnit. Jos ENA on esimerkiksi D7:ssä, analogWrite jättää pinnin LOW-tilaan arvoilla 0–127 ja asettaa sen HIGH-tilaan arvoilla 128–255. Tästä syntyy klassinen ”nopeussäätimessäni on vain kaksi nopeutta” -vika.
Kuultava vinkuna. ATmega328P:n oletustaajuus on noin 490 Hz pinneillä D3, D9, D10 ja D11 sekä noin 980 Hz pinneillä D5 ja D6. Moottorin käämi vinkuu tällä taajuudella kuuluvasti – se on normaalia. Taajuuden voi siirtää kuuloalueen ylle ajastimen esijakajaa muuttamalla (esim. Timer1 noin 31 kHz), mutta L298N:n Darlington-lähdöt kytkevät hitaasti, joten korkea taajuus kasvattaa kytkentähäviöitä ja lämpöä. Pari kilohertsiä on järkevä kompromissi, oletus riittää opetteluun. Huomaa, että Timer0:n muuttaminen rikkoo millis()- ja delay()-funktiot.
Kuollut alue. Alle noin 40–80/255:n pulssisuhteella kuormitettu moottori ei tyypillisesti lähde pyörimään lainkaan, koska vääntö ei voita lepokitkaa. Kun se on kertaalleen liikkeellä, se jatkaa pienemmälläkin arvolla. Ratkaisu on lyhyt täyden tehon potku tai ramppi – ei rikkinäinen ohjain.

Kuollut alue ja suunnanvaihto

Etsi oman moottorisi todellinen kuollut alue sarjaportista:

// kirjoita Sarjamonitoriin luku 0-255
if (Serial.available()) {
  int v = Serial.parseInt();
  v = constrain(v, 0, 255);
  driveA(+1, v);
  Serial.print(F("duty = ")); Serial.println(v);
}

Älä myöskään koskaan hyppää täydestä eteenpäinajosta suoraan täyteen taaksepäinajoon. Tällöin vastasähkömotorinen voima summautuu käyttöjännitteeseen ja virtapiikki on noin kaksinkertainen jumitusvirtaan verrattuna. Pysäytä, odota 50–100 ms, vasta sitten toiseen suuntaan.

Siisti virransyöttö LM2596:lla

Kun moduulin 5V-jumpperi on kiinni, moottorijännite ohjataan 78M05-regulaattorille, jonka 5 voltin lähtö syöttää sillan omaa logiikkaa ja näkyy 5V-pinnissä. Tee näin vain kun moottorijännite on enintään 12 V, ja budjetoi siitä realistisesti noin 0,5 A eikä otsikon ”jopa 1 A”: lineaariregulaattori polttaa 12→5 V pudotuksessa 7 V × I, eli 0,5 ampeerilla 3,5 wattia pienessä kotelossa ilman jäähdytintä. Se tulee erittäin kuumaksi.

Kun jumpperi on irti, regulaattori on ohitettu ja 5V-pinniin täytyy syöttää puhdas ulkoinen 5 V. Muuten sillan logiikka on jännitteetön eikä mikään toimi – oire on täydellinen hiljaisuus, vaikka kaikki ”näyttää” oikealta. Tämä on se tila, jota käytetään yli 12 voltin syötöllä. Jumpperin jättäminen paikalleen 24 voltin akulla on varma tapa tuhota 78M05. Älä myöskään jätä jumpperia kiinni ja syötä samaan aikaan 5 volttia sisään – silloin syötät regulaattorin lähtöä takaperin.

Suositeltu arkkitehtuuri yhdellä akulla käyttää LM2596 step-down -jännitemuunninta. Sen tuloalue on 3,2–40 V, lähtö säädettävissä 1,3–30 V ja maksimivirta 3 A – eli sama akku voi syöttää sekä moottorit että logiikan:

Akku 12 V
  |-- L298N "12V" -liitin  (moottoriteho, 5V-jumpperi IRTI)
  |-- LM2596 IN+/IN-  ->  OUT+ saadetty 5,00 V
                            |-- Arduino Nano 5V-pinni
                            |-- L298N 5V-pinni (sillan logiikka)
Kaikki maat yhteen: akku -, LM2596 IN-/OUT-, L298N GND, Nano GND

Säätöjärjestys on tärkeä: kytke ensin vain akku LM2596:n tuloon, mittaa lähtöä yleismittarilla ja käännä 25-kierroksista trimmeriä kunnes lukema on 5,00 V. Kierrä rauhassa – kierroksia on monta eikä pääteasennossa naksahda mitään. Katkaise sitten virta ja kytke vasta sen jälkeen Arduino ja L298N:n 5V-pinni. Jos ohitat mittauksen, voit syöttää Nanon 5 voltin kiskoon parikymmentä volttia. Hyötysuhde on noin 92 %: 12 voltista 5 volttiin yhdellä ampeerilla LM2596 hukkaa noin 0,4 W siinä missä 7805 hukkaisi 7 W. Muista myös, että tulojännitteen on oltava vähintään 1,5 V lähtöä korkeampi.

Lisää lopuksi 470–1000 µF elektrolyytti L298N:n 12V- ja GND-liittimien väliin lähelle korttia sekä kolme 100 nF keraamista kondensaattoria moottoriin: navasta napaan ja kummastakin navasta moottorin runkoon. Pidä moottorijohdot lyhyinä, mieluiten kierrettyinä, ja kaukana signaalijohdoista.

Jännitehäviö ja sen hinta

L298:n datalehti puhuu kokonaishäviöstä (ylälaidan Vce(sat) + alalaidan Vce(sat) + mittausvastus), joka on suunnilleen 1,8 V tyypillisesti yhdellä ampeerilla ja noin 2,7 V tyypillisesti kahdella ampeerilla. Käytännössä harrastaja mittaa noin 2 V hukkaan sillan yli. Seuraukset:

Nopeus. 12 voltin akulla moottori näkee vain noin 10 V. Harjallisen DC-moottorin tyhjäkäyntinopeus on karkeasti verrannollinen jännitteeseen, eli huippunopeudesta menetetään 15–17 % ennen kuin mitään muuta on tehty. Neljällä AA-paristolla (6 V) moottori näkee ~4 V eikä välttämättä pyöri kuormalla ollenkaan. Nyrkkisääntö: syötä moottorin nimellisjännite plus noin 2 V.
Lämpö. Hukkajännite muuttuu lämmöksi ohjaimessa: P = I × Uhäviö. Yhdellä ampeerilla noin 2 W, kahdella ampeerilla molemmilla kanavilla lähes 8 W – selvästi enemmän kuin pieni ripajäähdytin hoitaa seisovassa ilmassa. Moduulin ”25 W” on piirin absoluuttinen häviöraja kunnollisella kotelojäähdytyksellä, ei tällä piirilevyllä saavutettava luku.
Käyttöaika. Akkukäytössä 2 V häviö 12 voltista on ~17 % akusta lämpönä ohjaimessa.

Vertailun vuoksi: modernit MOSFET-pohjaiset ohjaimet (TB6612FNG, DRV8871, BTS7960) hukkaavat luokkaa 0,1–0,5 V. L298N:n hyveet ovat halpa hinta, poikkeuksellisen hyvä dokumentaatio, anteeksiantavuus aloittelijan virheille ja 35 voltin jännitekesto. Sen paheet ovat jännitehäviö, lämpö ja 2 ampeerin katto. Se on erinomainen oppimisohjain – kunhan tietää rajat.

2WD robotti Arduino: kaksi kanavaa ja koko koodi

Kaksikanavainen ohjaus on juuri se, mihin L298N suunniteltiin: kaksi pientä vaihteistollista moottoria, 150–250 mA kumpikin. Alla oleva sketsi sisältää ajon eteen ja taakse, kääntymisen paikallaan, vapaarullauksen, jarrun ja pehmeän kiihdytyksen.

/*  L298N + Arduino (ATmega328P Nano) — kaksikanavainen DC-moottorin ohjaus
 *  Moottori A: ENA -> D9  (PWM), IN1 -> D8, IN2 -> D7
 *  Moottori B: ENB -> D10 (PWM), IN3 -> D6, IN4 -> D5
 *  L298N GND -> Arduino GND  (yhteinen maa on pakollinen)
 *  L298N 12V -> akku+ ; L298N 5V -> 5 V LM2596:lta (jumpperi irti)
 *  Irrota ENA- ja ENB-jumpperit tai PWM ei toimi!
 */

const uint8_t ENA = 9, IN1 = 8, IN2 = 7;   // vasen moottori
const uint8_t ENB = 10, IN3 = 6, IN4 = 5;  // oikea moottori

const uint8_t MIN_DUTY  = 60;   // tata pienemmalla kuormitettu moottori ei lahde
const uint8_t KICK_DUTY = 200;  // lyhyt potku lepokitkan voittamiseen
const uint16_t KICK_MS  = 40;

void setup() {
  pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
  pinMode(ENB, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);
  stopCoast();
  Serial.begin(9600);
  Serial.println(F("L298N demo valmis"));
}

// ---------- matala taso: yksi kanava ----------
// dir: +1 eteen, -1 taakse, 0 jarru
void driveA(int8_t dir, uint8_t duty) {
  if (dir > 0)      { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);  }
  else if (dir < 0) { digitalWrite(IN1, LOW);  digitalWrite(IN2, HIGH); }
  else              { digitalWrite(IN1, LOW);  digitalWrite(IN2, LOW);  } // jarru
  analogWrite(ENA, duty);
}

void driveB(int8_t dir, uint8_t duty) {
  if (dir > 0)      { digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);  }
  else if (dir < 0) { digitalWrite(IN3, LOW);  digitalWrite(IN4, HIGH); }
  else              { digitalWrite(IN3, LOW);  digitalWrite(IN4, LOW);  }
  analogWrite(ENB, duty);
}

// ---------- robottitaso ----------
void forward(uint8_t duty) { driveA(+1, duty); driveB(+1, duty); }
void reverse(uint8_t duty) { driveA(-1, duty); driveB(-1, duty); }
void turnLeft(uint8_t duty)  { driveA(-1, duty); driveB(+1, duty); }
void turnRight(uint8_t duty) { driveA(+1, duty); driveB(-1, duty); }

// Vapaarullaus: lahdot ilmassa, robotti liukuu pysahdyksiin
void stopCoast() { analogWrite(ENA, 0); analogWrite(ENB, 0); }

// Jarru: molemmat lahdot alas, moottori oikosulussa -> terava pysahdys
void stopBrake() {
  driveA(0, 255); driveB(0, 255);
  delay(150);
  stopCoast();
}

// ---------- pehmea kiihdytys ja hidastus ----------
// Ramppi rajoittaa kaynnistysvirtaa: nain L298N pysyy 3 A rajansa sisalla
void rampTo(int8_t dir, uint8_t target, uint16_t ms) {
  if (target < MIN_DUTY) target = MIN_DUTY;
  uint16_t steps = 32;
  uint16_t stepDelay = ms / steps;
  for (uint16_t i = 1; i <= steps; i++) {
    uint8_t duty = (uint16_t)target * i / steps;
    driveA(dir, duty); driveB(dir, duty);
    delay(stepDelay);
  }
}

void rampDown(uint16_t ms) {
  uint16_t steps = 32;
  for (uint16_t i = steps; i > 0; i--) {
    uint8_t duty = (uint16_t)255 * i / steps;
    analogWrite(ENA, duty); analogWrite(ENB, duty);
    delay(ms / steps);
  }
  stopCoast();
}

// Voita lepokitka, asetu sitten pyydettyyn nopeuteen
void startAt(int8_t dir, uint8_t duty) {
  driveA(dir, KICK_DUTY); driveB(dir, KICK_DUTY);
  delay(KICK_MS);
  driveA(dir, duty); driveB(dir, duty);
}

// Pysayta aina ennen suunnanvaihtoa
void safeReverse(uint8_t duty) {
  stopBrake();
  delay(100);
  startAt(-1, duty);
}

void loop() {
  rampTo(+1, 200, 1500);   // pehmea kiihdytys eteen
  delay(2000);
  rampDown(1000);          // pehmea hidastus
  delay(1000);
  safeReverse(150);        // taakse turvallisesti
  delay(2000);
  stopBrake();
  delay(1000);
  turnLeft(180);  delay(800);
  stopBrake();
  turnRight(180); delay(800);
  stopBrake();
  delay(2000);
}

Mekaaninen tarkistus: 68 mm rengas ja 775-moottori

Laskutoimitus kannattaa tehdä ennen kuin ruuvaat mitään kiinni. Rengas 68x26mm -pyörän kehä on π × 68 mm = 213,6 mm eli 0,214 m. Jos 775-moottori pyörii 12 voltilla noin 4100 kierrosta minuutissa ja vetää pyörää suoraan, nopeus on 4100 × 0,214 m ÷ 60 ≈ 14,6 m/s eli noin 53 km/h. Se ei ole pöytärobotti.

2WD-alusta haluaa noin 0,3–1 m/s eli 85–280 RPM pyörällä, mikä tarkoittaa alennusvaihdetta luokkaa 1:15…1:50. PWM ei korjaa tätä: pyörän vääntö on moottorin vääntö kertaa alennussuhde, joten suoravetoinen 775 kymmenen prosentin pulssisuhteella on sekä hidas että heikko ja jumittuu heti mattoon. Lisäksi 68 mm renkaan keskireikä on tehty pienen vaihteistomoottorin akselille, kun 775:ssä on 5 mm D-akseli – väliin tarvitaan napa-adapteri, jota emme myy. Julkaisukuntoinen 2WD robotti Arduino -projekti tarvitsee siis vaihteistomoottorit ja navat; koodi ja kytkentä yllä pätevät silti sellaisenaan.

Vianetsintä

Moottori ei pyöri lainkaan

ENA/ENB-jumpperi on yhä kiinni, vaikka yritetään PWM:ää – tai irrotettu eikä pinniä ohjata mistään.
Arduinon ja L298N:n välillä ei ole yhteistä maata. Selvästi yleisin yksittäinen syy.
5V-jumpperi on irti mutta ulkoista 5 volttia ei ole kytketty → sillan logiikka on kuollut, oire on täysi hiljaisuus.
IN1 ja IN2 samassa tilassa = jarru, ei ajo.
Pulssisuhde kuolleen alueen alapuolella – kokeile ensin arvoa 200 ja laske sieltä.
ENA ei-PWM-pinnissä, tai käyttöjännite liian matala kun ~2 V häviö vähennetään.
Ruuviliitin ei purista johdinta. Nykäisytesti joka johtoon, erityisesti säikeisiin.

Pyörii vain toiseen suuntaan

IN1 tai IN2 irti, väärässä reiässä tai kylmä juotos.
Koodin pinninumero ei vastaa kytkentää, tai pinni on jo muussa käytössä (D0/D1 = sarjaportti, D13 = LED). Testaa pinni tavallisella vilkkuohjelmalla.
Puolisilta on rikki aiemmasta ylivirrasta: siirrä moottori toiselle kanavalle – jos se toimii nyt molempiin suuntiin, kanava on vaurioitunut.

Arduino resetoituu kun moottori käynnistyy

Klassinen jännitekuoppa. Käynnistysvirta on jumitusvirran luokkaa kymmeniä millisekunteja, ja syöttö notkahtaa alle Nanon brownout-rajan.
Älä syötä Nanoa L298N:n 78M05:stä isoa moottoria ajaessa – käytä LM2596:ta tai erillistä akkua. Älä myöskään syötä moottoritehoa Nanon 5V-pinnistä tai USB:stä (USB antaa ~500 mA).
Lisää 470–1000 µF elektrolyytti lähelle korttia ja 100 nF keraamiset moottoriin.
Käytä ramppia sen sijaan, että hyppäät suoraan arvoon 255. Tarkista myös akun kunto ja johtojen paksuus.

Ohjain kuumenee tai katkoo

Virta on yli 2 A. Lämpösuoja laukeaa, moottori pysähtyy, jäähtyy ja käynnistyy – tunnusomainen nykiminen.
5V-jumpperi kiinni yli 12 voltin syötöllä: silloin kiehuu 78M05, ei silta.
Jatkuva jarrutus kaataa moottorin liike-energian siltaan – jarruta lyhyinä pyrähdyksinä kuten koodissa.
Liian korkea PWM-taajuus kasvattaa kytkentähäviöitä. Anna ilmavirtaa, tarkista jäähdyttimen kiinnitys, laske pulssisuhdetta tai vaihda MOSFET-ohjaimeen.

Ostoslista

Minimikokoonpano penkkitestiin on ohjain, kortti ja hakkurimuunnin – näillä kolmella pääset aloittamaan heti:

Loput osat demoon ja mekaniikkaan:

L298N duaali H-silta ohjain
ATmega328P ’Nano’ ohjain
LM2596 step-down -jännitemuunnin
775 DC Moottori 12–24V (penkkidemoon, kuormittamattomana)
2 × Rengas 68x26mm
Dupont-hyppylanka 10cm (20kpl) uros-naaras

Akku ja pyörännavat eivät ole valikoimassa, joten ne on hankittava muualta.

Yhteenveto

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

Yhteinen maa Arduinon ja L298N:n välillä on pakollinen – se on ykkössyy siihen, ettei mikään toimi.
ENA/ENB-jumpperit irti, muuten PWM ei tee mitään ja moottori käy vain täysillä.
analogWrite vain PWM-pinniin (D3, D5, D6, D9, D10, D11) – muuten saat kaksi nopeutta: pois ja täysi.
Noin 2 V jännitehäviö sillan yli. Syötä moottorin nimellisjännite plus 2 V ja varaudu lämpöön.
2 A jatkuva raja on todellinen. Pieni vaihteistomoottori on kotonaan, 775 ei ole.

Kun perusteet ovat hallussa, seuraava askel on lisätä liikeanturi, enkooderi tai vaihtaa ohjain tehokkaampaan MOSFET-siltaan – mutta totuustaulu, PWM-pinnit ja yhteinen maa kannattaa opetella ensin kunnolla juuri tällä halvalla moduulilla. Se antaa virheet anteeksi tavalla, jota kalliimmat ohjaimet eivät anna.

Tutustu valikoimaamme: kaikki tässä oppaassa käytetyt osat löytyvät L298N-ohjaimesta ja ATmega328P Nano -kortista lähtien Protocachen varastosta, ja ne lähetetään Suomesta.