Postée dans Kompiuterių remontas, kompiuteriai, naujienos, patarimai

Kaip debuginti Arduino su Serial Monitor

Kas tas Serial Monitor ir kam jo reikia

Kai pradedi programuoti Arduino, anksčiau ar vėliau susiduri su situacija, kai kodas tiesiog neveikia taip, kaip tikėjaisi. Lemputė mirksi ne taip, sensorius rodo keistas reikšmes, arba visai nieko nevyksta. Čia ir prasideda tikrasis programavimo darbas – klaidelių medžioklė. Serial Monitor yra vienas iš paprasčiausių ir efektyviausių įrankių, kuris padeda suprasti, kas vyksta tavo Arduino viduje.

Paprasčiausiai tariant, Serial Monitor – tai langas Arduino IDE programoje, kuris leidžia Arduino plokštei „kalbėti” su tavimi. Arduino gali siųsti žinutes į kompiuterį per USB kabelį, o tu gali jas skaityti realiuoju laiku. Tai tarsi pokalbis su mikrovaldikliu, tik viena pusė (Arduino) dažniausiai kalba daugiau.

Daugelis pradedančiųjų šį įrankį atranda atsitiktinai, bet patyrę programuotojai juo naudojasi nuolat. Kodėl? Nes tai greičiausias būdas pamatyti, kokias reikšmes grąžina sensoriai, ar teisingai veikia skaičiavimai, ar programa iš viso pasiekia tam tikrą kodo vietą.

Kaip pradėti naudoti Serial komunikaciją

Pirmiausia reikia suprasti, kad Serial komunikacija – tai duomenų perdavimas iš eilės, vienas bitas po kito. Arduino turi specialius kontaktus (TX ir RX), bet kai jungi plokštę per USB, šie signalai automatiškai konvertuojami, kad kompiuteris juos suprastų.

Kiekviename Arduino kode, kuris naudoja Serial Monitor, rasite dvi pagrindines dalis. Pirmoji – tai inicializacija `setup()` funkcijoje:

„`
Serial.begin(9600);
„`

Šis skaičius 9600 vadinamas baud rate – tai duomenų perdavimo greitis bitais per sekundę. Galima naudoti ir kitus greičius (115200, 57600, 38400), bet 9600 yra standartas, kuris veikia visada ir visur. Svarbiausia – šis greitis turi sutapti su tuo, kurį pasirinksi Serial Monitor lange, kitaip matysi tik nesuprantamus simbolius.

Antroji dalis – tai pačių žinučių siuntimas. Čia naudojami keli pagrindiniai komandos:

„`
Serial.print(„Temperatūra: „);
Serial.println(temperatura);
„`

Skirtumas tarp `print()` ir `println()` paprastas – pastarasis po žinutės prideda naują eilutę. Tai kaip spausti Enter klaviatūroje.

Praktiniai debuginimo triukai

Dabar pereikime prie tikrųjų debuginimo būdų. Vienas populiariausių metodų – tai tiesiog spausdinti viską, kas vyksta programoje. Tarkim, turite kodą, kuris skaito temperatūros sensorių ir įjungia ventiliatorių, kai per karšta:

„`
void loop() {
int temperatura = analogRead(A0);
Serial.print(„Žalia reikšmė: „);
Serial.println(temperatura);

float laipsniai = temperatura * 0.48828125;
Serial.print(„Laipsniai: „);
Serial.println(laipsniai);

if (laipsniai > 25) {
digitalWrite(LED_PIN, HIGH);
Serial.println(„Ventiliatorius ĮJUNGTAS”);
} else {
digitalWrite(LED_PIN, LOW);
Serial.println(„Ventiliatorius IŠJUNGTAS”);
}

delay(1000);
}
„`

Matote? Spausdiname kiekvieną svarbų žingsnį. Taip iškart matai, ar sensorius apskritai veikia, ar skaičiavimai teisingi, ar programa pasiekia teisingą `if` šaką.

Kitas naudingas triukas – naudoti skirtingus žymeklius kodo vietoms identifikuoti. Pavyzdžiui:

„`
Serial.println(„>>> Pradedame matavimą”);
// kodas
Serial.println(„<<< Matavimas baigtas"); ``` Taip lengviau orientuotis, ypač kai programa sudėtinga ir turi daug funkcijų.

Duomenų formatavimas ir skaitomumas

Kai pradedi siųsti daug informacijos, Serial Monitor langas greitai virsta chaotiška simbolių srove. Čia praverčia keli formatavimo būdai.

Pirma, galima naudoti tabuliacijos simbolį `\t`, kad duomenys būtų stulpeliais:

„`
Serial.print(laikas);
Serial.print(„\t”);
Serial.print(temperatura);
Serial.print(„\t”);
Serial.println(drezme);
„`

Antra, skaičiams galima nurodyti tikslumą. Pavyzdžiui, jei nenorite matyti dešimties skaitmenų po kablelio:

„`
Serial.println(skaicius, 2); // tik du skaičiai po kablelio
„`

Trečia, galima naudoti specialius simbolius eilutėms formatuoti. Pavyzdžiui, `\n` sukuria naują eilutę, o `\r` grąžina kursorių į eilutės pradžią (naudinga progress bar’ams).

Dar vienas patarimas – kai siunti daug duomenų, pridėk antraštes pradžioje:

„`
void setup() {
Serial.begin(9600);
Serial.println(„Laikas\tTemp\tDrėgmė”);
Serial.println(„—————————-„);
}
„`

Sensorių reikšmių stebėjimas realiuoju laiku

Vienas dažniausių Serial Monitor panaudojimų – sensorių duomenų stebėjimas. Tarkime, derinote atstumų sensorių. Vietoj to, kad spėlioti, kodėl robotas atsitrenkia į sieną, tiesiog žiūrite, kokias reikšmes grąžina sensorius:

„`
void loop() {
long trukme, atstumas;

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

trukme = pulseIn(echoPin, HIGH);
atstumas = trukme * 0.034 / 2;

Serial.print(„Atstumas: „);
Serial.print(atstumas);
Serial.println(” cm”);

if (atstumas < 10) { Serial.println("!!! PER ARTI !!!"); } delay(100); } ``` Dabar matote tiksliai, kada sensorius „mato" kliūtį, ar reikšmės stabilios, ar šokinėja. Jei reikšmės nestabilios, galbūt reikia filtravimo arba ilgesnio `delay`. Dar vienas praktiškas pavyzdys – kalibruoti analoginius sensorius. Pavyzdžiui, dirvožemio drėgmės sensorius: ``` void setup() { Serial.begin(9600); Serial.println("Kalibruojame sensorių..."); Serial.println("Įdėk į sausą dirvą ir palaukite 10 sek"); } void loop() { int reiksme = analogRead(A0); Serial.println(reiksme); delay(500); } ``` Paleidus šį kodą, matote tikslias reikšmes sausoje ir drėgnoje dirvoje, tada galite jas panaudoti kode kaip ribines vertes.

Klaidelių gaudymas su Serial spausdinimais

Kartais programa tiesiog „užstringa” arba elgiasi keistai. Čia Serial Monitor tampa tikru detektyvu. Metodas paprastas – įterpiame spausdinimo komandas strateginėse vietose:

„`
void loop() {
Serial.println(„1. Pradžia”);

int reiksme = skaitytiSensori();
Serial.println(„2. Po sensoriaus skaitymo”);

if (reiksme > 500) {
Serial.println(„3. Įėjome į IF”);
darykKazka();
Serial.println(„4. Po funkcijos darykKazka()”);
}

Serial.println(„5. Loop pabaiga”);
delay(1000);
}
„`

Jei matote, kad programa spausdina „1” ir „2”, bet niekada „5”, žinote, kad kažkas nutinka tarp „2” ir „5”. Galbūt funkcija `darykKazka()` užstringa begalinėje kilpoje? Arba `delay()` per ilgas?

Ypač naudinga, kai dirbi su bibliotekoms ar funkcijomis, kurių viduje nematai. Pavyzdžiui, SD kortelės skaitymas gali užtrukti arba nepavykti:

„`
Serial.println(„Bandome atidaryti failą…”);
File failas = SD.open(„duomenys.txt”);
if (failas) {
Serial.println(„Failas atidarytas sėkmingai!”);
} else {
Serial.println(„KLAIDA: nepavyko atidaryti failo!”);
return;
}
„`

Dvikryptė komunikacija – komandų siuntimas

Serial Monitor gali ne tik rodyti duomenis, bet ir priimti įvestį. Tai puiki galimybė testuoti programą be papildomų mygtukų ar jungiklių.

Štai paprastas pavyzdys, kaip priimti komandas:

„`
void loop() {
if (Serial.available() > 0) {
char komanda = Serial.read();

if (komanda == ‘1’) {
digitalWrite(LED_PIN, HIGH);
Serial.println(„LED įjungtas”);
} else if (komanda == ‘0’) {
digitalWrite(LED_PIN, LOW);
Serial.println(„LED išjungtas”);
} else {
Serial.println(„Nežinoma komanda”);
}
}
}
„`

Dabar galite tiesiog įvesti „1” arba „0” Serial Monitor lange ir paspausti Enter. Arduino reaguos iškart.

Sudėtingesnis variantas – skaityti visą eilutę:

„`
void loop() {
if (Serial.available() > 0) {
String komanda = Serial.readStringUntil(‘\n’);
komanda.trim(); // pašalina tarpus

if (komanda == „ijungti”) {
digitalWrite(LED_PIN, HIGH);
Serial.println(„Įjungta”);
} else if (komanda == „isjungti”) {
digitalWrite(LED_PIN, LOW);
Serial.println(„Išjungta”);
} else if (komanda.startsWith(„greitis „)) {
int greitis = komanda.substring(8).toInt();
analogWrite(MOTOR_PIN, greitis);
Serial.print(„Greitis nustatytas: „);
Serial.println(greitis);
}
}
}
„`

Taip galite kurti visą komandų sistemą testavimui. Tai ypač naudinga, kai derinote sudėtingus projektus su varikliais, servo, LCD ekranais.

Dažniausios klaidos ir kaip jų išvengti

Pirmoji ir dažniausia klaida – neteisingas baud rate. Jei Serial Monitor lange matote kažką panašaus į „ÿþ¿ÿþ”, tiesiog patikrinkite, ar apatiniame dešiniajame kampe pasirinktas toks pat greitis kaip kode (`Serial.begin(9600)`).

Antra problema – per daug spausdinimo. Jei `loop()` funkcijoje spausdinate kas kartą be jokio `delay`, Serial Monitor bus užvertas tūkstančiais eilučių per sekundę. Tai ne tik sunku skaityti, bet ir lėtina programą. Visada pridėkite bent minimalų `delay(100)` arba naudokite laiko patikrinimus:

„`
unsigned long paskutinisSpausdinimas = 0;

void loop() {
// kitas kodas vyksta nuolat

if (millis() – paskutinisSpausdinimas > 1000) {
Serial.println(duomenys);
paskutinisSpausdinimas = millis();
}
}
„`

Trečia klaida – pamiršti `Serial.begin()` funkcijoje `setup()`. Be šios eilutės Serial Monitor tiesiog neveiks, bet programa veiks normaliai. Tai gali suklaidinti, nes atrodo, kad viskas gerai, tik duomenų nematyti.

Ketvirta – naudoti `Serial.print()` kritinėse laiko atžvilgiu vietose. Pavyzdžiui, pertraukimų (interrupt) funkcijose arba ten, kur skaičiuojami tikslūs laiko intervalai. Serial komunikacija užtrunka laiko ir gali iškraipyti rezultatus.

Kai Serial Monitor nebepakanka – ką toliau

Serial Monitor puikiai tinka paprastam debuginimui, bet turi ribų. Kai reikia vizualizuoti duomenis grafikais, Serial Monitor nebepakanka. Čia praverčia Serial Plotter – kitas Arduino IDE įrankis, kuris tuos pačius duomenis rodo grafikų pavidalu.

Jei siunčiate skaičius atskirtas tarpais arba kableliais, Serial Plotter automatiškai sukuria grafikus:

„`
void loop() {
int sensorius1 = analogRead(A0);
int sensorius2 = analogRead(A1);

Serial.print(sensorius1);
Serial.print(„,”);
Serial.println(sensorius2);

delay(50);
}
„`

Atidarę Serial Plotter (Tools → Serial Plotter) pamatysite dvi linijas, atvaizduojančias abiejų sensorių reikšmes realiuoju laiku. Tai neįtikėtinai naudinga analizuojant signalų formas, triukšmą, tendencijas.

Dar vienas žingsnis – naudoti išorines programas kaip Processing, Python su PySerial biblioteka, arba net Excel. Galite rašyti duomenis į failą, vėliau analizuoti, kurti sudėtingas vizualizacijas.

Profesionalesniam debuginimui egzistuoja ir aparatiniai debuggeriai, bet tai jau visai kita istorija ir kaina. Daugumai projektų Serial Monitor su keliais protingai įterptais `println()` visiškai pakanka.

Kai viskas veikia – kaip išvalyti kodą

Kai projektas baigtas ir veikia, turite pasirinkimą – palikti visus tuos `Serial.println()` arba juos išvalyti. Jei projektas bus naudojamas be kompiuterio, Serial komandos tik užima atmintį ir lėtina programą (nors ir nežymiai).

Paprasčiausias būdas – tiesiog ištrinti arba užkomentuoti:

„`
// Serial.println(„Debug info”);
„`

Bet jei manote, kad ateityje gali prireikti debuginti vėl, galite naudoti sąlyginį kompiliavimą:

„`
#define DEBUG true

void loop() {
int reiksme = analogRead(A0);

#if DEBUG
Serial.print(„Reikšmė: „);
Serial.println(reiksme);
#endif

// kitas kodas
}
„`

Dabar tiesiog pakeitus `#define DEBUG true` į `#define DEBUG false`, visi debug pranešimai automatiškai išnyks iš sukompiliuoto kodo.

Arba dar elegantiškiau – sukurti savo debug funkciją:

„`
void debugPrint(String tekstas) {
#if DEBUG
Serial.println(tekstas);
#endif
}
„`

Taip kodas lieka švaresnis ir lengviau valdomas. Galite net sukurti skirtingus debug lygius (INFO, WARNING, ERROR) kaip tikrose programavimo kalbose.

Bet nebijokite palikti bent minimalaus debuginimo galimybių. Kartais projektas, kuris veikė puikiai mėnesį, staiga pradeda keistai elgtis. Tada būsite dėkingi sau, kad palikote galimybę greitai įjungti Serial Monitor ir pamatyti, kas vyksta viduje. Debuginimas – tai ne vienkartinis darbas, o nuolatinė programavimo dalis, ypač kai kuriate kažką, kas veikia realiame pasaulyje su sensoriais, varikliais ir kitais nenuspėjamais komponentais.

Partager : XFacebookPinterestLinkedin