Az Arduino Serial Plotter egy grafikus eszköz, amely az Arduino IDE-ben található, és lehetővé teszi a felhasználók számára, hogy valós időben figyeljék meg és ábrázolják a soros porton keresztül érkező adatokat. Ez a funkció különösen hasznos a szenzorok és változók időbeli alakulásának nyomon követésében, mivel a beérkező adatokat vonaldiagram formájában jeleníti meg. Az adatokat soros vonalon át küldjük a Serial Plotter felé, ahol azokat grafikonon látjuk viszont. A Serial Plotter használata elősegíti a hibakeresést és a projekt során a valós idejű adatvizualizációt anélkül, hogy külön szoftverre lenne szükség. Az eszköz hasznos az oktatási környezetben, hobbi projekteknél és professzionális alkalmazásokban egyaránt, mivel segít az adatok egyszerű és érthető elemzésében. Az Arduino 1.x verziókban alapfunkciókat biztosít, míg az Arduino 2.0 IDE-ben új, fejlettebb funkciók érhetők el, amelyek tovább növelik a Serial Plotter rugalmasságát és funkcionalitását.

Bevezetés az Arduino Serial Plotter funkcióba

Az Arduino platform sokoldalúsága és egyszerűsége miatt vált a mikrovezérlők programozásának és kísérletezésének egyik legnépszerűbb eszközévé. A kezdő és haladó felhasználók számára egyaránt fontos, hogy a programozás és az elektronikai kísérletek során a valós idejű adatokat vizualizálni tudják. E célból fejlesztették ki az Arduino IDE-ben (Integrated Development Environment, azaz integrált fejlesztői környezet) a Serial Plotter funkciót. A Serial Plotter egy grafikus eszköz, amely lehetővé teszi a felhasználó számára, hogy valós időben figyelje meg a soros porton keresztül érkező adatokat, és azokat egy egyszerű vonaldiagram formájában jelenítse meg. Ez a funkció rendkívül hasznos lehet olyan projektek esetében, ahol szenzoradatok vagy más változók időbeli alakulását szeretnénk nyomon követni. Az Arduino Serial Plotter használatával könnyen megfigyelhetővé válik például egy hőmérséklet-érzékelő, fényérzékelő vagy bármely más analóg vagy digitális szenzor méréseinek változása az idő függvényében.

Tartalomjegyzék

Az alapvető működési mechanizmus ismertetése

A Serial Plotter működése azon alapul, hogy az Arduino programja (más néven sketch) a Serial porton keresztül küld adatokat a számítógépnek. Az Arduino IDE beépített funkciója, a Serial Plotter, ezeknek az adatoknak a megjelenítésére szolgál. A Serial Plotter a Serial.print() vagy Serial.println() függvényekkel küldött adatokat fogadja, majd ezeket egy grafikonon ábrázolja. Az adatküldés során fontos, hogy az egyes értékeket megfelelően elválasszuk, például vesszővel vagy tabulátorral, ha több adatot szeretnénk egyszerre megjeleníteni. A Serial Plotter ezeket az értékeket külön grafikonokon jeleníti meg, amelyek egymás mellett vagy egymás fölött helyezkednek el. A függőleges tengely a küldött értékek nagyságát, a vízszintes tengely pedig az időt reprezentálja.

Az Arduino Serial Plotter használatának előnyei és alkalmazási területei

Az Arduino Serial Plotter számos előnyt kínál a felhasználók számára. Először is, lehetővé teszi a valós idejű adatvizualizációt, ami különösen hasznos, ha egy projekt során változó paramétereket vagy szenzoradatokat kell figyelemmel kísérni. Emellett a Serial Plotter használata segít a hibakeresésben is, mivel lehetővé teszi az adatok azonnali ellenőrzését és megjelenítését anélkül, hogy külön szoftverre lenne szükség.

Az alkalmazási területek széles spektrumot ölelnek fel. Az oktatási környezetben az Arduino Serial Plotter kiváló eszköz a diákok számára, hogy megértsék az adatok időbeli változását és a valós idejű adatelemzést. A hobbi projektekben a szenzorok adatainak megfigyelése és elemzése válik egyszerűvé, míg a professzionális felhasználás során gyors és vizuális visszajelzést ad a rendszer működéséről, így segítve a finomhangolást és az optimalizálást.

A Serial Plotter elérhetősége különböző Arduino IDE verziókban

A Serial Plotter először az Arduino IDE 1.6.6 verziójában jelent meg, és azóta is része az IDE-nek, folyamatosan fejlődve a felhasználói igényeknek megfelelően. Az Arduino 1.x verzióiban elérhető Serial Plotter alapfunkciókat biztosít, mint az adatok grafikus megjelenítése, egyszerű paraméterezés, valamint a különböző adatfolyamok egyidejű vizualizálása. Az Arduino IDE 2.0 verziója számos újítást hozott a Serial Plotter funkció terén, amelyek közé tartozik például a több ablakos megjelenítés lehetősége, a vizualizációs beállítások finomhangolása, és a felhasználói felület testreszabása. Emellett a 2.0 verzióban bevezetett optimalizációk és fejlesztések még inkább felhasználóbaráttá tették a Serial Plottert, különösen komplex projektek esetében. → IDE 2.x SerialPlotter

A Serial Plotter paraméterezésének alapjai az Arduino-1.x verzióban

A Serial.begin() utasítás

Amikor egy Arduino projektnél adatokat akarunk küldeni a számítógépnek, az első lépés az, hogy beállítsuk a kommunikáció sebességét. Ehhez az Arduino programozási nyelvében a Serial.begin() funkciót használjuk. A Serial.begin() meghatározza azt a sebességet (baud rate), amelyen az Arduino és a számítógép kommunikálni fog. Ez a sebesség azt adja meg, hogy hány bit információt tudnak másodpercenként cserélni.

Például, ha a Serial.begin(9600); sort beírjuk a programunkba, akkor azt mondjuk az Arduinonak, hogy 9600 bit/másodperc sebességgel kommunikáljon. Ez az egyik leggyakrabban használt sebesség, és a legtöbb esetben elegendő a Serial Plotter használatához. Azonban, ha nagyobb mennyiségű adatot kell küldenünk, vagy gyorsabb frissítést szeretnénk, akkor magasabb baud rate értékek is alkalmazhatók, mint például 115200.

A Serial.begin() használata nélkül az Arduino nem tud kommunikálni a számítógéppel, így a Serial Plotter sem fog működni. A megfelelő sebesség kiválasztása pedig azért fontos, mert ha túl alacsony, az adatok késéssel jelennek meg; ha pedig túl magas, előfordulhat, hogy az adatokat nem tudja megfelelően feldolgozni az Arduino vagy a számítógép, és hibás értékeket láthatunk.

void setup() {
  Serial.begin(9600);               //Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       // Példaként egy egyszerű adat küldése a soros porton
  int sensorValue = analogRead(A0); //Analóg érték beolvasása
  Serial.println(sensorValue);      //Analóg adat küldése
  delay(100);                       //Kis szünet
}

void setup() {

Serial.begin(9600); //Kommunikáció beállítása 9600 baud sebességgel

}

void loop() { // Példaként egy egyszerű adat küldése a soros porton

int sensorValue = analogRead(A0); //Analóg érték beolvasása

Serial.println(sensorValue); //Analóg adat küldése

delay(100); //Kis szünet

}

A Serial.print() és Serial.println() utasítás

A Serial Plotter akkor tudja megjeleníteni az adatokat, ha azokat a megfelelő módon küldjük el a soros porton keresztül. Két alapvető funkció van, amelyet erre használunk: Serial.print() és Serial.println().

– Serial.print(): Ezzel a parancssal egy értéket vagy szöveget küldhetünk a soros porton keresztül. Azonban az érték vagy szöveg után nem tesz új sort, tehát ha több Serial.print() parancsot használunk egymás után, azok egy sorban jelennek meg.
– Serial.println(): Ez a parancs hasonlóan működik a Serial.print()-hez, de az elküldött érték vagy szöveg után automatikusan egy új sort is kezd. Ez nagyon hasznos, amikor különálló adatokat szeretnénk küldeni, mert a Serial Plotter könnyebben tudja értelmezni az egyes adatokat külön sorokban.

void setup() {
  Serial.begin(9600);               //Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       // Példaként egy egyszerű adat küldése a soros porton
  int sensorValue = analogRead(A0); //Analog érték beolvasása
  Serial.print("Szenzor érték: ");  //Szöveg küldése a PC felé
  Serial.println(sensorValue);      //Analóg adat küldése
  delay(100);                       //Kis szünet
}

void setup() {

Serial.begin(9600); //Kommunikáció beállítása 9600 baud sebességgel

}

void loop() { // Példaként egy egyszerű adat küldése a soros porton

int sensorValue = analogRead(A0); //Analog érték beolvasása

Serial.print("Szenzor érték: "); //Szöveg küldése a PC felé

Serial.println(sensorValue); //Analóg adat küldése

delay(100); //Kis szünet

}

A soros porton küldött adatok előkészítése

Amikor több adatot szeretnénk megjeleníteni a Serial Plotteren, nagyon fontos, hogy azokat megfelelően formázzuk. Az adatok formázása azt jelenti, hogy olyan módon küldjük el őket, amelyet a Serial Plotter értelmezni tud, és ennek megfelelően jeleníti meg. Az egyik legfontosabb dolog, hogy az adatokat megfelelően elválasszuk. Ha például két különböző értéket szeretnénk egyszerre megjeleníteni, akkor ezeket egy Serial.print() paranccsal és valamilyen elválasztó jellel küldjük el, például egy vesszővel vagy tabulátorral. Ezután egy Serial.println() parancs segítségével zárjuk le a sort, hogy a Serial Plotter tudja, hogy ez egy új sorban megjelenő adat.

void setup() {
  Serial.begin(9600);               //Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       // Példaként egy egyszerű adat küldése a soros porton
  int sensorValue1 = analogRead(A0);//Első analóg érték beolvasása (potméter)
  int sensorValue2 = analogRead(A1);//Második analóg érték beolvasása (megvilágítás)
  Serial.print(sensorValue1);       //Adatok küldése
  Serial.print(", ");               //Vesszővel és szóközzel elválasztva
  Serial.println(sensorValue2);
  delay(100);                       //Kis szünet
}

void setup() {

Serial.begin(9600); //Kommunikáció beállítása 9600 baud sebességgel

}

void loop() { // Példaként egy egyszerű adat küldése a soros porton

int sensorValue1 = analogRead(A0);//Első analóg érték beolvasása (potméter)

int sensorValue2 = analogRead(A1);//Második analóg érték beolvasása (megvilágítás)

Serial.print(sensorValue1); //Adatok küldése

Serial.print(", "); //Vesszővel és szóközzel elválasztva

Serial.println(sensorValue2);

delay(100); //Kis szünet

}

A mintakódban két különböző szenzor értékét olvassuk be: sensorValue1 az A0 [Potenciométer] , sensorValue2 az A1 [megvilágításmérő-szenzor] bemenetről. Majd a Serial.print(sensorValue1); elküldi az első szenzor értékét, hozzáadunk egy elválasztó vesszőt és szóközt a Serial.print(", "); utasítással az adatok közé, majd a Serial.println(sensorValue2); utasítással elküldjük a második szenzor értékét és új sort kezdünk. Így biztosítható, hogy a Serial Plotter így két külön grafikonon jelenítse meg az adatokat!

A soros monitort Arduino-1.x alatt megnyitva az alábbi kimenetet láthatjuk (Eszközök – Soros monitor):

Soros adatfolyam - két változó és vesszővel elválasztva — Soros adatfolyam – két változó és vesszővel elválasztva

Több adatsor kezelése és előkészítése

Az Arduino Serial Plotter egyik legnagyobb előnye, hogy egyszerre több adatfolyamot is képes megjeleníteni. Ez különösen hasznos, ha egy projekt során több szenzort használunk, és szeretnénk összehasonlítani azok adatait, vagy ha több változót követünk nyomon egy időben. Ahhoz, hogy több adatot egyszerre megjeleníthessünk, a különböző adatfolyamokat valamilyen elválasztó karakterrel kell elküldenünk, majd a Serial.println() parancs segítségével új sort kezdünk. A Serial Plotter automatikusan felismeri, hogy több adatot küldtünk, és mindegyiket külön grafikonon jeleníti meg.

void setup() {
  Serial.begin(9600);
}

void loop() {
  int temperature = analogRead(A0);  // Hőmérséklet mérés
  int light = analogRead(A1);        // Fényerő mérés
  int humidity = analogRead(A2);     // Páratartalom mérés
  
  Serial.print(temperature);
  Serial.print(", ");
  Serial.print(light);
  Serial.print(", ");
  Serial.println(humidity);
  
  delay(100);
}

void setup() {

Serial.begin(9600);

}

void loop() {

int temperature = analogRead(A0); // Hőmérséklet mérés

int light = analogRead(A1); // Fényerő mérés

int humidity = analogRead(A2); // Páratartalom mérés

Serial.print(temperature);

Serial.print(", ");

Serial.print(light);

Serial.print(", ");

Serial.println(humidity);

delay(100);

}

A programban három különböző szenzorból származó adatot küldünk a PC felé: hőmérséklet, fényerő és páratartalom. Fontos, hogy minden egyes adat után egy vesszővel és szóközzel elválasztva küldjük az értékeket! És persze az utolsó adat után lezárjuk a sort. Így az adatküldéssel előkészítettük, hogy a Serial Plotter három külön grafikonon jelenítse meg a hőmérsékletet, a fényerőt és a páratartalmat. Így könnyen látható, hogyan változnak ezek az értékek az idő múlásával.

Több adatfolyam kezelése és megjelenítése

De miért fontos a több adatfolyam kezelése? Amikor egy Arduino projekt során különböző szenzorokkal vagy változókkal dolgozunk, gyakran előfordul, hogy egyszerre több adatot is figyelnünk kell. Például egy környezetmonitorozó rendszerben lehetnek hőmérséklet-, páratartalom- és légnyomás-érzékelők, és mindhárom adatot valós időben szeretnénk látni és elemezni. Ehhez a Serial Plotter remek eszköz, mert lehetőséget ad arra, hogy több adatfolyamot is egyszerre, egymás melett, szinkronban megjelenítsünk.

Hogyan küldjük el több adatfolyam adatait a Serial Plotternek?

Ahhoz, hogy több adatfolyamot küldhessünk a Serial Plotternek, fontos, hogy az adatokat megfelelően formázzuk. A különböző adatokat el kell választanunk egymástól, hogy a Serial Plotter külön-külön értelmezhesse és megjeleníthesse őket. Az elválasztás módja többféle lehet: történhet vesszővel, tabulátorral vagy más speciális karakterekkel. A lényeg, hogy minden adat külön „oszlopban” legyen, amit a Serial Plotter külön grafikonként tud kezelni.

Potenciometer, hőmérő és megvilágításmérő bekötése

Nézzünk meg egy példát, ahol egyszerre három adatfolyamot küldünk a Serial Plotternek:

void setup() {
  Serial.begin(9600);               //Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       // Példaként egy egyszerű adat küldése a soros porton
  int sensorValue1 = analogRead(A0);//Potméter értékének beolvasása
  int sensorValue2 = analogRead(A1);//Megvilágításmérő értékének beolvasása
  int sensorValue3 = analogRead(A2);//Analóg hőmérő beolvasása (LM35DZ)

  Serial.print(sensorValue1);       //Adatok küldése
  Serial.print("\t");               //Tabulátorral elválasztva
  Serial.print(sensorValue2);
  Serial.print("\t");               
  Serial.println(sensorValue3);     //Utolsó adat zárása
 
  delay(100);                       //Kis szünet
}

void setup() {

Serial.begin(9600); //Kommunikáció beállítása 9600 baud sebességgel

}

void loop() { // Példaként egy egyszerű adat küldése a soros porton

int sensorValue1 = analogRead(A0);//Potméter értékének beolvasása

int sensorValue2 = analogRead(A1);//Megvilágításmérő értékének beolvasása

int sensorValue3 = analogRead(A2);//Analóg hőmérő beolvasása (LM35DZ)

Serial.print(sensorValue1); //Adatok küldése

Serial.print("\t"); //Tabulátorral elválasztva

Serial.print(sensorValue2);

Serial.print("\t");

Serial.println(sensorValue3); //Utolsó adat zárása

delay(100); //Kis szünet

}

Ahhoz, hogy a Serial Plotter megfelelően tudja értelmezni és megjeleníteni az adatokat, azoknak következetesen kell érkezniük. Ha például egy sorban csak két adatot küldünk, de a következő sorban hármat, a Serial Plotter össze fog zavarodni, és az adatokat hibásan jelenítheti meg. Ezért fontos, hogy minden sorban ugyanannyi darabszámú adatot küldjünk!

Az adatok küldésénél használhatunk különböző elválasztó karaktereket, mint például:
– Vessző (,): Gyakran használt elválasztó karakter, amely világosan szétválasztja az adatokat.
– Tabulátor (\t): Szintén gyakran használt elválasztó, amely egy tabulátorhelyet tesz az adatok közé.
– Szóköz ( ): Kevésbé javasolt, mert könnyen okozhat félreértéseket, ha az adat maga is tartalmaz szóközt.

Az előző példában tabulátort használtunk. Soros monitorral megnézve:

Soros adatfolyam - három változó és tabulátorral elválasztva — Soros adatfolyam – három változó és tabulátorral elválasztva

Tipp: az előző soros monitor képével összehasonlítva látható, hogy a tabulátorral kapott adatsor sokkal áttekinthetőbb – még klasszikus számsorozatként is!

De hol van az a Serial plotter?

Most hogy a bejövő adatokat megformáztuk és ehető formába raktuk – jöhet a grafikus megjelenítés. Ehhez az Arduino-1.x Serial Plotterre van szükségünk.

Szóval, az Arduino beépített Serial Plotter kiegészítője egy hasznos eszköz, amely lehetővé teszi az adatok valós idejű grafikus megjelenítését, amelyeket az Arduino lapka soros vonalon küld a számítógépnek. Ez a funkció különösen hasznos, ha érzékelőkről érkező adatokat szeretnénk nyomon követni vagy bármilyen időben változó adatot kell vizualizálni…

Lépések a Serial Plotter megnyitásához

Arduino IDE elindítása: Indítsd el az Arduino 1.x IDE-t a számítógépeden. Az Arduino IDE felületén először ellenőrizd, hogy a megfelelő eszköz (pl. Arduino Uno) ki van-e választva a Tools menüben a Board és a Port opcióknál. Ha magyar nyelvű az Arduino, akkor az Eszközök menüben keresd az Alaplap és a Port pontokat.
Alaplap és Port kiválasztása Arduino-1.x alatt
Serial Monitor indítása: A menüsorban kattints a Tools menüpontra, majd válaszd ki a Serial Plotter opciót. Ezzel megnyitod a Serial Plotter ablakát. Az ablakban valós időben követheted nyomon az Arduino által küldött adatokat grafikus formában. (Magyar Arduino keretrendszerben az Eszközök menüben keresd a Soros plotter menüt!
Fontos! Az Arduino keretrendszer 1.6.6…1.8.18 közé kell hogy essen! A korábbi Arduino keretrendszerekben nincsen benne a Soros Plotter!
Soros plotter által megjelenített adatfolyam

Több adatfolyam kezelése bonyolultabb projekteknél

Néha előfordulhat, hogy több adatfolyam kezelése komplexebb logikát igényel, különösen akkor, ha nem csak szenzoradatokat küldünk, hanem számításokat, mért adatokat vagy éppen valamilyen eseményeket is nyomon követünk. Ilyen esetekben fontos lehet, hogy ne csak az adatokat, hanem azok kontextusát is elküldjük, például melyik szenzor adatait látjuk, vagy milyen mértékegységben vannak az adatok.

Az eddig beolvasott nyers szenzoradatokat normál mértékegységekké alakítjuk. Azaz potenciométert százalékban, a megvilágítást analóg adatként és a hőfokot fokban adjuk meg. Ez így már egy bonyolultabb példa lesz. Ennek a kódja:

void setup() {
  Serial.begin(115200);                               // Kommunikáció beállítása 115200 baud sebességgel
}

void loop() {                       
  // Potméter értékének beolvasása és átalakítása 0-100 tartományba
  int rawValue1 = analogRead(A0);                     // Nyers érték beolvasása (0-1023)
  int sensorValue1 = map(rawValue1, 0, 1023, 0, 100); // Átalakítás 0-100 tartományba
  delay(5);

  // Megvilágításmérő értékének beolvasása
  int sensorValue2 = analogRead(A1);
  delay(5);

  // LM35DZ hőmérséklet-érzékelő beolvasása és átalakítása Celsius-fokra
  int rawValue3 = analogRead(A2);             // Nyers érték beolvasása (0-1023)
  float voltage = rawValue3 * (5.0 / 1023.0); // Feszültség kiszámítása (0-5V)
  float sensorValue3 = voltage * 100.0;       // Hőmérséklet kiszámítása (LM35DZ: 10mV/°C)

// Adatok küldése soros porton
  Serial.print("Potmeter[%]:");       // Potméter érték (0-100)
  Serial.print(sensorValue1);
  Serial.print(", ");                 // Vesszővel elválasztva
  Serial.print("Light[AD]:");         // Megvilágításmérő érték (0-1023)
  Serial.print(sensorValue2);
  Serial.print(", ");                 // Vesszővel elválasztva
  Serial.print("Temp[C]:");           // Hőmérséklet Celsius-fokban
  Serial.print(sensorValue3);
  Serial.println("");
  
  delay(100);                         // Kis szünet
}

void setup() {

Serial.begin(115200); // Kommunikáció beállítása 115200 baud sebességgel

}

void loop() {

// Potméter értékének beolvasása és átalakítása 0-100 tartományba

int rawValue1 = analogRead(A0); // Nyers érték beolvasása (0-1023)

int sensorValue1 = map(rawValue1, 0, 1023, 0, 100); // Átalakítás 0-100 tartományba

delay(5);

// Megvilágításmérő értékének beolvasása

int sensorValue2 = analogRead(A1);

delay(5);

// LM35DZ hőmérséklet-érzékelő beolvasása és átalakítása Celsius-fokra

int rawValue3 = analogRead(A2); // Nyers érték beolvasása (0-1023)

float voltage = rawValue3 * (5.0 / 1023.0); // Feszültség kiszámítása (0-5V)

float sensorValue3 = voltage * 100.0; // Hőmérséklet kiszámítása (LM35DZ: 10mV/°C)

// Adatok küldése soros porton

Serial.print("Potmeter[%]:"); // Potméter érték (0-100)

Serial.print(sensorValue1);

Serial.print(", "); // Vesszővel elválasztva

Serial.print("Light[AD]:"); // Megvilágításmérő érték (0-1023)

Serial.print(sensorValue2);

Serial.print(", "); // Vesszővel elválasztva

Serial.print("Temp[C]:"); // Hőmérséklet Celsius-fokban

Serial.print(sensorValue3);

Serial.println("");

delay(100); // Kis szünet

}

Az adatokat átküldve a grafikonon már megjelenik a címke is:

Magyarázat:
– Kontextus: Itt minden adat mellett megadjuk annak típusát és mértékegységét is. Ez hasznos lehet, ha a Serial Monitoron is figyeljük az adatokat, nem csak a Plotteren.
– Sebesség: 115200 baud sebességgel dolgozunk, ami gyorsabb adatátvitelt tesz lehetővé, így a komplexebb adatsorokat is gyorsan tudjuk küldeni.

Tippek, fontos figyelmeztetések!

Ha az összeállított adatfolyamban eltérő szeparátorkarakterek szerepelnek (szóköz, vessző, tabulátor), akkor a Serial Plotter mindet elválasztónak fogja tekinteni! Sőt, ha a mértékegységeket a számokkal egybeírjuk, akkor a Serial Plotter ezt szövegnek és/vagy diagram-adatnak tekinti!

A Serial Plotter által feldolgozható adat formátuma az alábbi adatfolyamot kell, hogy kövesse:

Arduino serial plotter adatok kontextusban — Serial Plotter adatok kontextusban (RAW: nyers adatfolyam)

Azaz:
– „Potmeter[%]” – Diagramon megjelenő adatcímke (a mértékegység is adatcímke!).
– „:” – Adatcímke és adat elválasztó karakter, kötelezően kettőspont.
– „58” – számadat, mértékegység nélkül.
– „, ” – adatelválasztó (vessző, szóköz, tabulátor).
– „Light[AD]” – Diagramon megjelenő második adatcímke (a mértékegység is adatcímke!)….

És így tovább, és a végén a soremelés zárja az összetartozó adatokat.

„A Serial Plotter jobban tudja”

A Serial Plotter számos automatizmussal rendelkezik, ami a felhasználó életét igyekszik megkönnyíteni. Ez persze nem mindig sikerül….

Az előzőekben a mérési eredményeink az alábbi tartományokban jönnek:
– Potméter: 0…100%,
– Fénymérés: 0….1023,
– Hőfok: 18….28 fok közt.

Ahogy a Serial Plotter az adatokat fogadja, úgy igyekszik a tengelyeket összehangolni. A legkisebb és a legnagyobb eddigi érték van az Y tengelyen. És az utolsó 500 értékből számolódik a megjelenítési tartomány.

Ez érdekes összehasonlításokhoz vezet:

Kicsivel később:

Mivel az utolsó 500 adatból a „csúcsértékek” kikerültek….

Tipp: Ha az átküldött adatsorban létrehozunk egy olyan változót, ami az alsó és a felső értékek közt változik és csak a szélsőértéket veszi fel (pl. minden 100. adat a maximumérték és a többi a minimum), akkor a grafikonunk nem fog átméreteződni! A hátrány, hogy lesz egy utolsó tengelyünk – aminek nem lesz neve, – mivel az adja meg az ábrázolási (elvárt) szélsőértékeket. És egy tüskesorunk, mert össze vannak kötve az adatpontok. Persze, ha tartományon kívül „beesik” érték, akkor az lesz a szélsőértéket meghatározó – 500 adatlépcsőig.

Még egy tipp: ha az utolsó két adatsor a minimum és a maximumérték, akkor két folyamatos vonalat kapunk és az eredmények a között fognak mozogni… És így két névtelen szélsőérték tengelyünk lesz – ráadásként.

Hogyan segíti a Serial Plotter a hibakeresést?

Több adatfolyam kezelése során a Serial Plotter nem csak a vizualizáció miatt hasznos, hanem azért is, mert nagyon sokat segíthet a hibakeresésben. Ha egy szenzor vagy egy változó értékei hirtelen szokatlanul kezdenek viselkedni, a Serial Plotter segítségével gyorsan azonosíthatjuk a problémát. A valós idejű grafikonok könnyen megmutatják, ha valami nem stimmel: például, ha egy érték folyamatosan nő vagy csökken, amikor nem kellene, vagy ha egy szenzor adatai hirtelen kilépnek a megszokott tartományból.

Tipp: A mintakódban a hőmérsékletmérés során nem egyetlen mintából számoljuk a hőfokot, hanem átlagolva és a kilógó alsó és felső 10%-ot kidobjuk, mint mérési pontatlanságot. A korábbi nyers adatsorban ezért nem látod az adatok ugrálását… Pedig az első ADC mérések alapján 18…47 fok közti értékek simán jönnek az ADC, a Aref és a parazita kapacitások és mérési összevisszaságok miatt.

  // Hőmérséklet-érzékelő 20 minta átlagolása a legkisebb és legnagyobb értékek kiszűrésével
  const int numSamples = 20;
  float samples[numSamples];
  float voltage, sensorValue3;
  
  for (int i = 0; i < numSamples; i++) {
    int rawValue3 = analogRead(A2);           // Nyers érték beolvasása
    voltage = rawValue3 * (5.0 / 1023.0);     // Feszültség kiszámítása
    samples[i] = voltage * 100.0;             // Hőmérséklet Celsius-fokban
    delay(10);                                // Kis szünet a mérések között
  }

  // Sorba rendezés
  for (int i = 0; i < numSamples - 1; i++) {
    for (int j = i + 1; j < numSamples; j++) {
      if (samples[i] > samples[j]) {
        float temp = samples[i];
        samples[i] = samples[j];
        samples[j] = temp;
      }
    }
  }

  // Legkisebb 2 és legnagyobb 2 érték eldobása, maradék átlagolása
  float sum = 0;
  for (int i = 2; i < numSamples - 2; i++) {
    sum += samples[i];
  }
  sensorValue3 = sum / (numSamples - 4);

// Hőmérséklet-érzékelő 20 minta átlagolása a legkisebb és legnagyobb értékek kiszűrésével

const int numSamples = 20;

float samples[numSamples];

float voltage, sensorValue3;

for (int i = 0; i < numSamples; i++) {

int rawValue3 = analogRead(A2); // Nyers érték beolvasása

voltage = rawValue3 * (5.0 / 1023.0); // Feszültség kiszámítása

samples[i] = voltage * 100.0; // Hőmérséklet Celsius-fokban

delay(10); // Kis szünet a mérések között

}

// Sorba rendezés

for (int i = 0; i < numSamples - 1; i++) {

for (int j = i + 1; j < numSamples; j++) {

if (samples[i] > samples[j]) {

float temp = samples[i];

samples[i] = samples[j];

samples[j] = temp;

}

// Legkisebb 2 és legnagyobb 2 érték eldobása, maradék átlagolása

float sum = 0;

for (int i = 2; i < numSamples - 2; i++) {

sum += samples[i];

}

sensorValue3 = sum / (numSamples - 4);

Az adatmegjelenítés finomhangolása: skálázás, időzítés és vizualizációs technikák

Miért fontos az adatmegjelenítés finomhangolása?

Amikor adatokat jelenítünk meg a Serial Plotteren, nemcsak az a fontos, hogy a megfelelő adatokat lássuk, hanem az is, hogy ezeket az adatokat könnyen és érthetően tudjuk értelmezni. Ha az adatok túl gyorsan vagy éppen túl lassan frissülnek, vagy ha a grafikon túl kicsi vagy nagy, akkor nehezebb lesz következtetéseket levonni a látottakból. Ezért van szükség az adatmegjelenítés finomhangolására, amely során a skálázással, időzítéssel és különböző vizualizációs technikákkal lehet optimalizálni a grafikonokat.

Skálázás: hogyan igazítsuk az adatokat a grafikonhoz?

A skálázás az egyik legfontosabb technika, amellyel biztosíthatjuk, hogy az adatok a lehető legjobban láthatóak legyenek a Serial Plotteren. A skálázás azt jelenti, hogy az adatokat olyan tartományba helyezzük át, hogy azok megfelelően jelenjenek meg a grafikonon. Például ha van egy szenzorunk, amelynek értékei 0 és 1023 között mozognak (mint egy analóg bemeneti szenzor esetében), de a Serial Plotter 0 és 100 közötti tartományban jeleníti meg az adatokat, akkor az egész grafikon csak egy kis részét fogja kihasználni a rendelkezésre álló helynek. Ezt elkerülhetjük úgy, hogy az adatokat arányosan leosztjuk vagy nagyítjuk. Ilyen jelen esetben a potenciométer, ami 0-100% tartományban akarunk látni. Az összes érték együttes értéktartományban fog mozogni – a szélsőértékek fixálására →A Serial Plotter jobban tudja fejezetben van egy tipp. Amíg egy értékünk van – ez nem okoz nagy problémát….

A potméter 0-100% tartományban mozgatása nagyon egyszerű:

void setup() {
  Serial.begin(9600);                                 // Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       
  // Potméter értékének beolvasása és átalakítása 0-100 tartományba
  int rawValue1 = analogRead(A0);                     // Nyers érték beolvasása (0-1023)
  int scaledValue1 = map(rawValue1, 0, 1023, 0, 100); // Átalakítás 0-100 tartományba

  // Adatok küldése soros porton
  Serial.println(scaledValue1);                       // Potméter érték (0-100)
  
  delay(10);                                          // Kis szünet
}

void setup() {

Serial.begin(9600); // Kommunikáció beállítása 9600 baud sebességgel

}

void loop() {

// Potméter értékének beolvasása és átalakítása 0-100 tartományba

int rawValue1 = analogRead(A0); // Nyers érték beolvasása (0-1023)

int scaledValue1 = map(rawValue1, 0, 1023, 0, 100); // Átalakítás 0-100 tartományba

// Adatok küldése soros porton

Serial.println(scaledValue1); // Potméter érték (0-100)

delay(10); // Kis szünet

}

A kapott grafikon már nem annyira szép…

Egyetlen érték - normalizáltan — Egyetlen érték – normalizáltan (automata tengelyhatárokkal)

Időzítés: a frissítési sebesség helyes beállítása

Az időzítés, vagy pontosabban fogalmazva a frissítési sebesség is kulcsfontosságú az adatmegjelenítés finomhangolásában. Ha az adatokat túl gyakran küldjük, akkor a grafikon „zajos” lehet, gyorsan változó és nehéz lesz értelmezni. Ha viszont túl ritkán küldünk adatokat, akkor a grafikon „darabos” lesz, és az adatok közötti finom részletek elveszhetnek. A mérési metódus megegyezik azzal, ahogyan egy analóg jelet mintázunk és a diszkrét értékek hogyan adják vissza az eredményt.

Analóg-digitál átalakítás során elvesző információ

A megfelelő időzítés megtalálása általában kísérletezést igényel. De általános szabály, hogy olyan frissítési sebességet válasszunk, amely elegendő adatot biztosít a jelenség nyomon követéséhez, de nem túl gyors ahhoz, hogy az adatok feldolgozhatatlanok legyenek.

Például, ha egy gyorsan változó jelet figyelünk (például egy gyorsan forgó motort), akkor kisebb késleltetést választhatunk:

void loop() {
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(10);  // Nagyon gyors frissítés 10 ms-os késleltetéssel
}

void loop() {

int sensorValue = analogRead(A0);

Serial.println(sensorValue);

delay(10); // Nagyon gyors frissítés 10 ms-os késleltetéssel

}

Másrészt, ha egy lassabb jelenséget figyelünk (például a hőmérséklet változását), akkor nagyobb késleltetést választhatunk:

void loop() {
  int sensorValue = analogRead(A0);
  Serial.println(sensorValue);
  delay(1000);  // Lassú frissítés 1 másodperces késleltetéssel
}

void loop() {

int sensorValue = analogRead(A0);

Serial.println(sensorValue);

delay(1000); // Lassú frissítés 1 másodperces késleltetéssel

}

Magyarázat:
– Gyors frissítés (10 ms): Ilyen sebességnél a Serial Plotter nagyon gyorsan megjeleníti az adatokat, ami hasznos lehet gyorsan változó jelek esetén.
– Lassú frissítés (1000 ms): Ilyen sebességnél a Serial Plotter lassabban frissíti a grafikonokat, ami például lassan változó jelek esetében hasznos, mint a hőmérséklet.

Vizualizációs technikák: az adatok jobb értelmezése

A vizualizációs technikák célja, hogy az adatokat úgy jelenítsük meg, hogy azok a lehető legjobban értelmezhetőek legyenek. Az egyik egyszerű, de hatékony technika az, hogy különböző adatokat külön színnel jelenítünk meg, vagy hogy az adatokat különböző skálákon ábrázoljuk, ha azok nagyon eltérő tartományban vannak. A Serial plotter nem támogatja a több slálázású tengelyeket, így ezt szoftver oldalról kell megoldanunk.

Például, ha két adatunk van, amelyek közül az egyik 0 és 1023 között, a másik pedig 0 és 5 között változik, akkor a következő módon jeleníthetjük meg őket:

void loop() {
  int sensorValue1 = analogRead(A0);    //0....1023 értéktartomány
  int sensorValue2 = analogRead(A1);    //0-1-2-3-4-5 diszkrét értékek
  
  float scaledValue2 = (sensorValue2 * (1023.0 / 5.0));  // Skálázás
  
  Serial.print(sensorValue1);
  Serial.print(", ");
  Serial.println(scaledValue2);
  
  delay(100);
}

void loop() {

int sensorValue1 = analogRead(A0); //0....1023 értéktartomány

int sensorValue2 = analogRead(A1); //0-1-2-3-4-5 diszkrét értékek

float scaledValue2 = (sensorValue2 * (1023.0 / 5.0)); // Skálázás

Serial.print(sensorValue1);

Serial.print(", ");

Serial.println(scaledValue2);

delay(100);

}

Magyarázat:
– Skálázás: az első adatot változatlanul hagyjuk, mert az teljes tartományában megjelenik (0-1023). A második adatot viszont skálázzuk, hogy 0 és 5 közötti értéke arányos legyen a 0..1023 adattal (0-204-409-613-818-1023).
– Különböző színek: a Serial Plotter automatikusan különböző színekkel jeleníti meg a különböző adatokat, ami segít azok megkülönböztetésében.

Hogyan segít az adatmegjelenítés finomhangolása a hibakeresésben?

Az adatmegjelenítés finomhangolása különösen hasznos lehet a hibakeresés során. Ha például egy szenzor értékei váratlanul magasra ugranak vagy túl alacsonyak, a megfelelő skálázás és időzítés segíthet gyorsan észrevenni a problémát. Ha az adatokat megfelelően skálázzuk, akkor még a kisebb változások is jól láthatók lesznek a grafikonon, így gyorsabban reagálhatunk a váratlan jelenségekre. Például, ha egy szenzor értékei váratlanul kilépnek a normál tartományból, egy jól skálázott és időzített grafikon azonnal felhívhatja a figyelmünket arra, hogy valami nincs rendben. Ez segít abban, hogy időben lépjünk, és megakadályozzuk a probléma súlyosbodását.

Hibakeresés és diagnosztika a Serial Plotter segítségével

Miért fontos a hibakeresés a Serial Plotter használatával?

Amikor egy Arduino projektet építünk, elkerülhetetlen, hogy időnként hibákkal találkozunk. Ezek a hibák lehetnek hardveres vagy szoftveres jellegűek, de akár a szenzorok, a kapcsolódások vagy a kód működéséből is eredhetnek. A hibakeresés során kulcsfontosságú, hogy minél hamarabb észrevegyük, mi a probléma forrása, és ezt hatékonyan tudjuk javítani. Ebben nyújt nagy segítséget a Serial Plotter, amely valós időben, grafikonok formájában jeleníti meg az adatokat, így segít gyorsan felismerni a hibákat és eltéréseket.

A hibakeresés lépései a Serial Plotter segítségével

A hibakeresés általában egy logikus, lépésről lépésre haladó folyamat, amely során különböző eszközöket használunk a probléma pontos azonosítására. A Serial Plotter ebben az egyik legfontosabb eszköz lehet, különösen, ha az adatokat valós időben szeretnénk figyelni és elemezni.

Az első lépés, hogy beállítjuk a Serial Plottert és elkezdjük figyelni az adatokat. Fontos, hogy a kódunk úgy legyen megírva, hogy a szükséges adatokat folyamatosan küldje a Serial Monitorba vagy a Plotterbe. Ez lehetővé teszi, hogy valós időben lássuk az adatokat, és észrevegyük, ha valami nem stimmel.

Példa:

Tegyük fel, hogy egy hőmérséklet érzékelőt használunk, amelynek értékei hirtelen a vártnál magasabbak lesznek. A kódunk a következő lehet (adatszimulálás potenciométerrel!):

void setup() {
  Serial.begin(9600);                 // Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       
  
  int rawValue1 = analogRead(A0);     // Potméter értékének beolvasása
  
  Serial.print(rawValue1);            // Adatok küldése soros porton
  Serial.println(", 0, 1023");        // Szélsőértékek - diagramfixálás
  
  delay(50);                          // Kis szünet
}

void setup() {

Serial.begin(9600); // Kommunikáció beállítása 9600 baud sebességgel

}

void loop() {

int rawValue1 = analogRead(A0); // Potméter értékének beolvasása

Serial.print(rawValue1); // Adatok küldése soros porton

Serial.println(", 0, 1023"); // Szélsőértékek - diagramfixálás

delay(50); // Kis szünet

}

Ha az adatok a Serial Plotteren megjelennek, azonnal látni fogjuk, ha valami rendellenesen változik. Például, ha az értékek hirtelen túl magasra ugranak, az egyértelműen látszani fog a grafikonon.

Ez lehetne egy hőmérséklet-érzékelőnk, ami hibás adatokat ad. A grafikonon azt látjuk, hogy a hőmérséklet időnként hirtelen kiugrik, de ez nem felel meg a valós körülményeknek. Ekkor érdemes ellenőrizni a szenzor bekötését, esetleg kicserélni a szenzort és újratesztelni a rendszert.

Szimulált kiugró adat — Azonnal látható a kiugró adat

Az adatminták elemzése

A Serial Plotter használatával nem csak az aktuális adatokat figyelhetjük meg, hanem észlelhetjük azokat az adatmintákat is, amelyek hibára utalnak. Ezek a minták lehetnek például:
   – Hirtelen kiugrások: Amikor egy érték hirtelen nagyon magasra vagy alacsonyra ugrik, anélkül, hogy ennek logikus oka lenne.
   – Folyamatos növekedés vagy csökkenés: Ha egy érték folyamatosan nő vagy csökken, az jelezheti, hogy valami nincs rendben.
   – Zajos adatok: Ha az adatok nagyon „zajosak”, azaz értékeik szórása nagyon nagy, az szenzorhibára vagy kapcsolódási problémákra utalhat.

Tippek a áttekinthetőségre

Ha az adatsorba beillesztjük nem csak a szélsőértéket, hanem a kritikus szinteket is, akkor sokkal könnyebb ezek detektálása. A Serial Plotter nemcsak a manuális hibakeresés során lehet hasznos, hanem az automatizált hibakeresési rendszerekben is. Az Arduino kód segítségével automatikusan figyelhetjük az adatokat, és bizonyos küszöbértékek elérésekor figyelmeztetéseket vagy riasztásokat generálhatunk.

void setup() {
  Serial.begin(9600);                 // Kommunikáció beállítása 9600 baud sebességgel
}

void loop() {                       
  int rawValue1 = analogRead(A0);                 // Potméter értékének beolvasása
  
  Serial.print(rawValue1);                        // Adatok küldése soros porton
  Serial.print(", LowLimit:0, HighLimit:1023, "); // Szélsőértékek - diagramfixálás
  Serial.println("Warning:900");
  if (rawValue1 > 900) {                          // Hangos riasztás 
    buzzer();}
  
  delay(50);                                      // Kis szünet
}

void setup() {

Serial.begin(9600); // Kommunikáció beállítása 9600 baud sebességgel

}

void loop() {

int rawValue1 = analogRead(A0); // Potméter értékének beolvasása

Serial.print(rawValue1); // Adatok küldése soros porton

Serial.print(", LowLimit:0, HighLimit:1023, "); // Szélsőértékek - diagramfixálás

Serial.println("Warning:900");

if (rawValue1 > 900) { // Hangos riasztás

buzzer();}

delay(50); // Kis szünet

}

Az adatok összehasonlítása és korrelációk keresése

A hibakeresés során gyakran hasznos, ha több adatot is egyszerre figyelünk, és keresünk közöttük összefüggéseket. Például, ha van egy hőmérséklet- és egy páratartalom-érzékelőnk, akkor érdemes megfigyelni, hogy a hőmérséklet változása hogyan befolyásolja a páratartalom értékeit.

Erre ideális a tájékoztató mérésre szolgáló DHT11 szenzor.

Magyarázat:
– Két adat megfigyelése: Ebben a példában egyszerre két adatot figyelünk (hőmérséklet és páratartalom), amelyeket összehasonlíthatunk a Serial Plotteren.
– Korreláció: Ha a hőmérséklet emelkedésekor a páratartalom is megváltozik, az összefüggésre utalhat. Ezek az összefüggések segíthetnek abban, hogy pontosan meghatározzuk, mi okozza a problémát.

Adatnaplózás a Serial Plotter segítségével?

Az adatnaplózás egy olyan folyamat, amely során a rendszeres időközönként rögzítjük és tároljuk az érzékelők által gyűjtött adatokat. Az adatnaplózás segítségével visszamenőleg elemezhetjük a mért értékeket, és jobban megérthetjük, hogyan viselkedik a rendszerünk hosszabb időn keresztül. Az Arduino projektek esetében ez különösen fontos lehet, például ha hosszabb távon szeretnénk megfigyelni egy hőmérséklet-, páratartalom- vagy más szenzoradatot.

A Serial Plotter az Arduino-1.x alatt csak az adatok valós idejű megjelenítésére alkalmas, azok naplózására nem használható. Hiszen az Arduino 1.x verzióiban a Serial Plotter nem rendelkezik beépített adatnaplózási funkcióval, az adatok egyszerű rögzítését mégis megvalósíthatjuk a Serial Monitor segítségével, amely az adatok fájlba mentését is lehetővé teszi. Az adatokat később elemezhetjük, összehasonlíthatjuk vagy grafikusan ábrázolhatjuk.

A rendszer korlátja: vagy a Serial Plotter fut, vagy a Serial monitor. A két eszköz nem futhat egyszerre – azaz nem lehetséges a kapott „nyers” adatok párhuzamos mentése a kiértékelés alatt!

Ha minden kötél szakad – az adatok rögzítése és mentése

A Serial Monitor képernyőjén megjelenő adatokat könnyen elmenthetjük egy fájlba. Ehhez kövessük az alábbi lépéseket:
    1. Nyissuk meg a Serial Monitort az Arduino IDE-ben.
    2. Válasszuk ki a kívánt adatfolyamot.
    3. A megjelenő adatokat a Ctrl + A billentyűkombinációval kijelölhetjük, majd Ctrl + C segítségével másolhatjuk.
    4. Nyissunk meg egy szövegszerkesztőt (például a Jegyzettömböt), és illesszük be az adatokat.
    5. Mentsük el a fájlt .txt vagy .csv formátumban.

Ez a fájl később könnyen importálható különböző adatkezelő szoftverekbe, például Excelbe, ahol részletesen elemezhetjük az adatokat. Tipp: az adatok elválasztására szolgáló vesszó, tab vagy szóköz a CSV fájlformátumban is a tagolást definiálja!

Az elmentett adatok beolvasása a Serial Plotterba sajnos nem lehetséges.

Excel: adatok elemzése és vizualizációja

Miután rögzítettük az adatokat, megnyithatjuk azokat egy adatkezelő programban, ahol különböző elemzéseket végezhetünk. Az Excel például lehetőséget nyújt az adatok grafikonos megjelenítésére, trendek elemzésére, és különböző statisztikai műveletek végrehajtására.

Példa az adatok vizualizációjára Excelben:
    1. Nyissuk meg az elmentett .csv fájlt Excelben.
    2. Válasszuk ki az adatokat, és készítsünk egy vonaldiagramot.
    3. A diagram segítségével vizualizálhatjuk a hőmérséklet változását az idő függvényében.

Akapott eredmény: egy jól áttekinthető grafikon, amely megmutatja, hogyan változott a hőmérséklet az idő előrehaladtával.

Adatnaplózás automatizálása

Az adatok gyűjtése történhet EEPROM-ba, külső EEPROM, Flash vagy SD kártyára vagy akár IoT felhőbe is. De akár a bejövő soros nyers adatokat Python vagy MathLab segítségével is kezelhetjük. Azonban ez már nem a Serial Plotter használatának része…

Összegzés

A Serial Plotter sok segítséget tud adni adatok kiértékelés, jelkövetésre, de az előnyeit és a hátrányait érdemes áttekinteni.

Az Arduino Serial Plotter alkalmazásának előnyei

Az Arduino Serial Plotter egy olyan hasznos eszköz, amely az Arduino fejlesztők számára nyújt lehetőséget arra, hogy a különböző szenzorokból származó adatokat valós időben, vizuálisan megjelenítsék. A következőkben részletezzük azokat az előnyöket, amelyek miatt érdemes használni ezt az eszközt:

1. Valós idejű adatok vizualizációja: A Serial Plotter lehetővé teszi, hogy azonnal lássuk, mi történik a projektünkben. Ez segít abban, hogy gyorsan észrevegyük az adatmintákban bekövetkező változásokat, ami különösen hasznos lehet például szenzoradatok elemzésekor.
2. Könnyű használat: A Serial Plotter használata nem igényel különleges szoftveres tudást. Az Arduino IDE része, így azonnal elérhető és használatra kész, amint telepítjük az IDE-t. A kezdők számára különösen előnyös, mivel egyszerű és intuitív felületet biztosít az adatok megjelenítéséhez.

3. Több adatfolyam kezelése: Az eszköz képes egyszerre több adatfolyamot is kezelni és megjeleníteni különböző színekkel. Ez megkönnyíti a különböző szenzoradatok egyidejű elemzését és az összefüggések megértését.

4. Hibakeresés támogatása: A Serial Plotter hatékony eszköz a hibakereséshez. Ha valami nem működik megfelelően, a vizuális visszajelzés segíthet gyorsan azonosítani a problémát.

5. Interaktív tanulási lehetőségek: Az eszköz nagyszerű tanulási eszköz is, mivel a valós idejű adatmegjelenítés lehetővé teszi a diákok és hobbi fejlesztők számára, hogy mélyebben megértsék az Arduino működését és az adatok elemzésének alapjait.

Az Arduino Serial Plotter alkalmazásának korlátai

Az előnyök mellett azonban érdemes tisztában lenni a Serial Plotter használatának bizonyos korlátaival is:

1. Korlátozott funkcionalitás: Az Arduino 1.x verzióiban a Serial Plotter csak alapvető funkcionalitást kínál. Például hiányzik a beépített adatnaplózási lehetőség, és nincs lehetőség bonyolultabb vizualizációk készítésére, mint például hisztogramok vagy scatter plotok.

2. Sebesség és adatfeldolgozás: Nagy mennyiségű adat esetén a Serial Plotter teljesítménye csökkenhet, és előfordulhat, hogy nem tud lépést tartani az adatfolyammal. Ez különösen igaz, ha a szenzorok nagy sebességgel küldenek adatokat, mivel a Serial Plotter korlátozott számú adatpontot tud egyszerre megjeleníteni.

3. Nincs hivatalos támogatás a komplex adatfeldolgozáshoz: Az eszköz nem nyújt lehetőséget bonyolultabb adatfeldolgozásra vagy matematikai műveletek elvégzésére a megjelenítés előtt. Az ilyen funkciókat külső szoftverekkel vagy saját kód írásával kell megvalósítani.

4. Korlátozott testreszabhatóság: Bár a Serial Plotter lehetőséget biztosít több adatfolyam megjelenítésére, a testreszabhatósága korlátozott. Nem lehet például az egyes tengelyeket külön-külön skálázni, vagy az adatok megjelenítési stílusát, színét részletesen beállítani.

5. Hardver korlátok: Az Arduino Serial Plotter használata során a megjelenített adatok nagymértékben függnek az Arduino hardverének teljesítményétől. Egy gyengébb mikrokontroller például nehezebben birkózik meg a nagy mennyiségű adat folyamatos küldésével.

Kitekintés az Arduino 2.x – Serial Plotter funkcióira

Az Arduino 2.0 és a későbbi verziók jelentős fejlesztéseket hoznak a Serial Plotter funkcionalitásában. Ezek az újítások célja, hogy a fejlesztők számára még több lehetőséget biztosítsanak az adatok megjelenítésére és elemzésére. Bár a részletes bemutatástól most eltekintünk, érdemes kiemelni néhány fontos fejlesztési irányt (ezek a Arduino javaslatok közt a „fejlesztési csőben” megtalálhatóak):

1. Kiterjesztett adatvizualizációs lehetőségek: Az Arduino 2.0-ban a Serial Plotter új funkciókkal bővül, amelyek lehetővé teszik a fejlettebb grafikus megjelenítéseket, mint például a különböző diagramtípusok és a testreszabható megjelenítési opciók.

2. Beépített adatnaplózás: Az új verziók lehetőséget biztosítanak az adatok közvetlen naplózására és mentésére az IDE-n belül, anélkül, hogy külön külső programokat kellene használni.

3. Interaktív funkciók: A jövőbeli fejlesztések során az interaktivitás is növekszik, például lehetőség nyílik az adatpontok közvetlen manipulálására a grafikonokon, vagy valós idejű visszajelzések generálására a beérkező adatok alapján.

4. Kompatibilitás más eszközökkel: Az Arduino 2.0 jobban integrálható más adatfeldolgozó és vizualizáló eszközökkel, így a fejlesztők könnyebben kombinálhatják a Serial Plottert más szoftverekkel és platformokkal.

5. Felhasználói felület fejlesztése: Az új verziók egyszerűsített és modernizált felhasználói felülettel rendelkeznek, amely még könnyebbé teszi a használatot, különösen a kezdők számára.