Les 8: Schrijven in de seriële monitor

In de vorige lessen werkten we steeds met externe hardware componenten. Componenten zoals knoppen en ledjes gebruikten we frequent in onze schakelingen. Toch gebruikten we meer dan alleen deze componenten… Onze computer was in alle lessen een aanwezig element. We programmeerden er onze codes op en gebruiken het als spanningsbron. Maar de mogelijkheden eindigen daar niet! In de komende lessen zullen we leren hoe we deze bron van mogelijkheden kunnen gebruiken. Deze les leren we hoe we data kunnen sturen naar onze computer. Deze zullen we dan op het scherm van onze computer kunnen analyseren door gebruik te maken van een nieuwe, digitale tool: De seriële monitor.

De seriële monitor:

Door gebruik te maken van de seriële monitor op onze computer kunnen we de doorgestuurde data van de Arduino ontvangen. We vinden de seriële monitor bij de hulpmiddelen in Arduino of met de sneltoets Ctrl+Shift+M.

Seriële monitor aanvragen.

Wanneer we een Arduino aansluiten op onze computer kunnen we altijd de seriële monitor openen. Deze bestaat uit drie delen: De taakbalk, de data-invoer en de instellingen van de seriële monitor. De taakbalk zullen we gebruiken in onze huidige les, les 9. Met deze balk kunnen we onze computer een observerende functie geven. In de data-invoer zullen we de doorgestuurde data naar de Arduino terugvinden. De instellingen stellen ons in staat om de bandlengte te bepalen en aan te passen. De meest gebruikte en voorkomende bandlengte is 9600. Deze veranderen we niet.

Seriële monitor

De functie van de Seriële monitor:

We sturen data naar onze computer… Dat wil zeggen dat onze computer voor de Arduino een uitvoerende functie heeft. Als we de vergaarde kennis van de vorige lessen gebruiken verwachten we een een soortgelijk commando te vinden:

pinMode ( “computer” ; OUTPUT);

Dit is echter niet het geval! De computer kan in eenzelfde programma een uitvoerende en een observerende functie hebben. Ook het verdelen van deze functie over twee verschillende poorten is niet mogelijk. De computer is namelijk slechts met één poort, via de usb-kabel, met de Arduino verbonden.

We moeten dus een andere manier vinden om het onderscheidt te maken. Dit doen we door gebruik te maken van verschillende commando’s. We introduceren een nieuw soort commando’s: de Serial. -commando’s. Deze commando’s gebruiken we voor alle communicatie over bandlengtes.

Meestal zal deze communicatie verlopen met de aangesloten computer. Maar ook andere componenten kunnen deze manier van communicatie gebruiken. De communicatie tussen meerdere Arduino’s is hier een voorbeeld van. In deze les zullen we de commando’s Serial.begin();, Serial.print() en Serial.write gebruiken. Deze commando’s sturen data naar de computer. Meer info over deze commando’s vindt je op onze algemene pagina Arduino commando’s.

Opbouw:

We beginnen zoals altijd met het declareren van onze woorden. Zoals je ziet zullen we een algemene variabele gebruiken ‘a’ en een variabele gemaakt voor grote getallen ‘tijd’.

Serial.begin(9600);

In onze void setup() beginnen we de seriële communicatie op een bandlengte van 9600. Vaak willen we dat alle data op eenzelfde bandlengte word doorgestuurd. Daarom coderen we Serial.begin vaak in de void setup. Dit wil zeggen dat alle data van de Serial; -commando’s op deze bandlengte zal doorgestuurd worden. Onze seriële monitor moet dus ingesteld staan om deze bandlengte te kunnen ontvangen.

Notities:

Serial.begin (9600);
Serial.println (“GameGoeroe”);
delay (2000);
Serial.begin (4800);
Serial.println(“”);
Serial.println (“gameGoeroe”);

Wanneer we de Serial.begin niet in de void setup declareren, krijgen we geen foutmelding. Maar wanneer we de output op de seriële monitor bekijken, dan valt er iets op. De “GameGoeroe” die verstuurd word over de bandlengte 4800 vindt men toch terug op de bandlengte 9600, maar dan als een reeks niets betekende letters. Ook de “GameGoeroe”, die verstuurd is via de bandlengte 9600, resulteert in een reeks niets betekende letters op de seriële monitor met bandlengte 4800.

In onze void loop beginnen we met het gelijkstellen van onze tijd aan het commando millis();. Dit kan niet gedaan worden in de void Setup omdat de tijd vanzelfsprekend niet stilstaat. Mochten we dit declareren in de void setup, dan zou de variabele ‘tijd’ nul blijven. Millis(); geeft namelijk de tijd weer sinds het programma gestart is. Nu zal ‘tijd’ steeds worden ge-update, want de void loop wordt immers steeds opnieuw doorlopen.

In deze code gebruiken een eenvoudig if-functie zodat alle waarden slechts eenmaal geprint worden in de seriële monitor.

Serial.print();

 

Serial.println (” GameGoeroe.com “);

Met dit commando sturen we het woord GameGoeroe.com naar de seriële monitor. De twee aanhalingstekens duiden de arduino dat GameGoeroe.com geen variabele is. De verwerker zal dus het woord letterlijk doorsturen.Het verschil tussen Serial.print() en Serial.println() zit met in de visualisatie in de seriële monitor. Het aanhangsel ‘ln’ staat voor ‘line’ en zorgt ervoor dat nadat deze data doorgestuurd is, de cursor in de seriële monitor een lijn daalt.

 

Serial.println ( 1.1234567,3);
Serial.println ( 1.1234567, 7);

In beide gevallen wordt hetzelfde getal geprint in de seriële monitor. Bij het eerste commando zal het getal echter afgerond worden op drie cijfers na de komma. Het tweede commando rondt het getal dan weer af af op zeven getallen. Vaak wordt dit weggelaten en wordt dus het volledige getal geprint.

 

Serial.println ( 99 , BIN);
Serial.println ( 99 , OCT);
Serial.println ( 99 , HEX);

Deze commando’s zullen het getal 99 driemaal printen. Eenmaal in binaire vorm, eenmaal in octale vorm en eenmaal in hexadecimale vorm. Dit wordt is twee situaties gebruikt. Namelijk wanneer men data moet sturen naar een component die slechts één vorm van data kan verwerken. Ook wanneer men data binnenleest en die men wil veranderen van vorm wordt dit commando gebruikt.

 

Serial.print ( “tijd: “);
tijd = millis();
Serial.println ( tijd);

We starten met het commando Serial.print();. Hierna zal de cursor in de seriële monitor dus niet veranderen van lijn. Ook hier zetten we “tijd:” tussen twee aanhalingstekens. We doen dit omdat we willen dat dit letterlijk geprint wordt. Voor we daadwerkelijk de variabele printen, zorgen we ervoor dat deze ge-update wordt. Daarna printen we de waarde van de variabele ‘tijd’. Dit doen we door het commando Serial.println(); te gebruiken. Nu zetten we het woord niet tussen aanhalingstekens, want we willen dat de Arduino-verwerker de waarde van de variabele doorstuurt.

Serial.write();

Serial.write ( 55);
Serial.println(“”);
Serial.write ( “hello”);

Met Serial.write wordt de opdracht in ASCII-code geschreven. De output zijn dan de ‘normale’-tekens die overeenkomen met die ASCII-code. Zo is 55 de ASCII-code van 7. Wanneer we woorden tussen aanhalingstekens zetten, dan volgt Serial.write dezelfde regel als Serial.print. Meer info over de ASCII-code vindt je in deze tabel.

Output in de Seriële monitor:

Seriële monitor

code

// Eerst zetten we onze woorden om in taal die Arduino begrijpt. 

long tijd;
int a = 1;

void setup() {
// Aangezien dat deze ” loop ” slechts eenmaal doorlopen wordt, declareer je hier jouw poorten.  

Serial.begin ( 9600);
}

void loop() {
// Vervolgens zetten we hier de opdrachten die uitgevoerd moeten worden. Deze “loop” wordt dus steeds herhaald. 

tijd = millis();
if ( a == 1){
Serial.println (“GameGoeroe.com “);
Serial.println(“”);
delay ( 2000);
Serial.println ( 1.1234567,3);
Serial.println ( 1.1234567, 7);
Serial.println(“”);
delay (2000);
Serial.println ( 99 , BIN);
Serial.println ( 99 , OCT);
Serial.println ( 99 , HEX);
Serial.println(“”);
delay ( 2000);
Serial.print ( “tijd: “);
tijd = millis();
Serial.println ( tijd);
Serial.println(“”);
delay ( 2000);
Serial.write ( 55);
Serial.println(“”);
Serial.write ( “hello”);
a = 2;
}
}

Notities

De data-invoer van de seriële monitor wordt vaak gebruikt om een code te testen. Een tweede functie van de seriële monitor is om belangrijke waarden uit de code te controleren. Bij het maken van de codes uit de voorgaande lessen gebruikten we steeds een led. Dit deden we omdat deze een visuele bevestiging was van het succes van de code. De bevestiging kan men ook krijgen door gebruik te maken van de Serial. -commando’s. Het controleren van een code met deze commando’s zorgt ervoor dat we geen extra hardware nodig hebben. Echter het grootste voordeel is dat we zelf kunnen bepalen wat er verstuurd wordt. Zo kunnen we een duidelijk overzicht maken van de fouten in het programma. Dit komen we zeker nog tegen in toekomstige lessen en projecten.

Schakeling

Om deze code te testen hoeven we niets te schakelen.

Lege schakeling

Basislessen Arduino 66.6%

Ondertussen heb je al een globaal idee van de functie en werking van onze seriële monitor. En cruciale factor bij het Arduino gebeuren. In deze code kan je alvast eens proberen om andere waarden en woorden door te sturen naar de seriële monitor.

Als je deze code vlotjes beheerst, ga dan over naar les 9!

Geplaatst in Programmeren Arduino voor dummies.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *