Arduino IDE – Coding met Arduino – Basic

In de vorige “Arduino Uno” post hebben we kennis gemaakt met de Arduino en met name met de Arduino Uno. Hopelijk is na deze vorige post de indeling en opzet van de Arduino een beetje duidelijk. Echter zijn we dan pas halverwege. Naast de basiskennis over de architectuur, stroom circuits is er ook kennis van programmeren nodig. Arduino heeft een eigen op C gebaseerde programmeertaal. In deze taal ga ik niet meer de onderdelen van programmeren benoemen (zoals b.v. een loop). Deze kennis is te lezen in o.a. mijn Bash, Powershell en Python posts. Hier gaan we echt aan de slag met de Arduino code en opzet. Na deze post zal de taal begrijpelijker zijn en is je eigen eerste sketch snel gemaakt.

Als eerste is het zaak om je Arduino te verbinden met de computer. Dit doe je uiteraard met de USB kabel. Als je de Arduino voor het eerst aansluit op de computer dan zullen de juiste drivers voor de Arduino niet gevonden worden. Daarom raad ik aan om eerst de installatiepackage te downloaden van de Arduino pagina. Vervolgens installeer je de software (default settings zijn ok).

Als de software geïnstalleerd is sluit je de Arduino aan. De drivers zullen nu succesvol gevonden en geïnstalleerd worden. Vervolgens open je de Arduino IDE software. Het eerste dat je moet controleren is of de software het juiste board op de juiste poort gedetecteerd heeft. Om te kijken welk board er gedetecteerd is ga je naar: Hulpmiddelen – Board en selecteer het juiste board. In mijn geval een Arduino Uno.

Daarna controleer je of het board op de juiste poort gekoppeld is. De juiste poort kun je vinden via de device manager (apparaatbeheer). Als je niet weet waar je de device manager kunt vinden gebruik dan het “devmgmt.msc” commando in de command prompt of bij “uitvoeren”. De Arduino staat meestal vermeld onder de “Poorten (COM & LPT)” categorie. Zoals je kunt zien is mijn Arduino verbonden op COM3.

Onder: Hulpmiddelen – Poort staat inderdaad mijn COM3 vermeld. Klik hierop om de poort te activeren zodat de software met de juiste Arduino praat:

Een paar andere dingen die je kunt doen zijn o.a. je board info ophalen via: Hulpmiddelen – Haal Board Info. Hier zie je o.a. je serienummer, product id (PID), vendor id (VID) en het type board.

Onder: Bestand – Voorkeuren vind ik het fijn om de volgende instellingen aan te passen (maar dit is natuurlijk persoonlijk):

Arduino Libraries

Arduino komt standaard met een aantal libraries. Deze kun je vinden via: Schets – Bibliotheek gebruiken. Uiteraard kun je via “Bibliotheken beheren” ook andere libraries toevoegen.

Een library is een collectie van code voor een bepaald doel. Wil je iets gaan programmeren voor een LCD display dan gebruik je b.v. de “LiquidCrystal” library. Als je een library selecteerd dan wordt deze toegevoegd aan je sketch middels een “include” commando. Als je b.v. de LiquidCrystal library toevoegt ziet er dat als volgt uit:

#include <LiquidCrystal.h>

Door het toevoegen van de library kun je in je code alle functies gebruiken die in de aangeroepen library aanwezig zijn. Hierdoor wordt iets programmeren voor een specifiek doel een stuk gemakkelijker.

Arduino Programmer

Voor we met de code van start gaan is het goed om te weten dat je ook een externe programmer kunt gebruiken om je sketch naar de Arduino te schrijven. Door gebruik van de externe programmer wordt je sketch naar het Arduino board gebrand zonder tussenkomst van de bootloader. Hiermee kunt je de volledige programmeerruimte (flash) van de chip op het Arduino-bord gebruiken. Dus met een ATmega168 ontvang je 16 KB in plaats van 14 (op een ATmega8 ontvang je 8 KB in plaats van 7). Gebruik maken van een externe programmer zorgt er ook voor dat je geen last hebt van de vertraging de bootloader nodig heeft wanneer je het board aanzet of reset.

Om gebruik te maken van de externe bootloader moet je met een 2-tal zaken rekening houden:

1. Selecteer de externe programmer via: Hulpprogramma’s – Programmer (default is AVRISP mkll).

2. Kies er tijdens het uploaden van de sketch voor om de programmer te gebruiken. Dus: Schets – Uploaden met programmer.

Arduino IDE Code

Zoals al eerder gezegd wordt Arduino code geschreven in C++ waarbij de zogenaamde “Wiring” library gebruikt wordt voor communicatie met de input en output van de hardware. Het is echter ook mogelijk om code voor de Arduino te schrijven met JavaScript, Python en andere programmeertalen door gebruik te maken van speciale libraries. In deze post gebruiken we de “standaard” C++ Arduino code.

Als we de Arduino voor het eerst starten zien we de volgende demo code:

void setup() {
  // put your setup code here, to run once:
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
}

Wat opvalt zijn de volgende 2 commando’s:

void setup()
void loop()

“void setup” wordt gebruikt voor eenmalige code. In dit blok worden bepaalde zaken gedefinieerd zoals pin modes en libraries. Deze code wordt slechts eenmaal uitgevoerd tijdens het booten van de Arduino.

“void loop” is de loop die keer op keer gedraaid wordt. De loop is feitelijk de applicatie die o.a. gebruik maakt van de definities in de “void setup”.

Het sleutelvoord “void”, ofwel “leeg” wordt bij Arduino gebruikt om functies te maken die geen informatie retourneren. Een lege functie betekent simpelweg dat het een code uitvoert (zoals elke andere functie) en vervolgens wanneer het klaar is, de functie verlaat en terugkeert naar waar het werd genoemd (ook zoals elke andere functie). Het enige verschil is dat er niets geretourneerd wordt.

Zo zouden we in de “void setup” een functie kunnen definiëren die we later weer gebruiken. Door code in functies te segmenteren, kan een programmeur modulaire stukjes code maken die een gedefinieerde taak uitvoeren en vervolgens terugkeren naar het codegebied vanwaar de functie werd “opgeroepen”. Ideaal voor het hergebruik van code. Stel je de volgende code voor (ja we springen meteen in het diepe zodat alles straks duidelijker wordt):

// Als er op een button gedrukt wordt
if(digitalRead(toggleButton) == LOW)
{
  // en als het lampje uit is
  if(digitalRead(ledPin) == LOW)
  {
    // zet dan het lampje aan
    digitalWrite(ledPin, HIGH);
  }
  else
  {
    // en als het lampje aan is, zet hem dan uit
    digitalWrite(ledPin, LOW);
  }
}

Deze code zorgt ervoor dat we een lampje aan en uit kunnen zetten door op een button te drukken. Maar wellicht moeten we deze code 10x herhalen waardoor we veel lijnen programmeercode moeten gebruiken. In dat geval zou je de volgende “void toggleLed” functie kunnen schrijven:

void toggleLed(int pin)
{
  // en als het lampje uit is
  if(digitalRead(pin) == LOW)
  {
    // zet dan het lampje aan
    digitalWrite(pin, HIGH);
  }
  else
  {
    // en als het lampje aan is, zet hem dan uit
    digitalWrite(pin, LOW);
  }
}

Nu roepen we deze functie aan in ons programma waardoor het programma minder code bevat.

void loop()
{
  // Als er op een button gedrukt wordt
  if(digitalRead(toggleButton) == LOW)
  {
    // Verander de status van het lampje
   toggleLed (ledPin);
  }
}

Ok, wie bovenstaande functie zonder uitleg volledig snapte mag een eindje doorskippen. We gaan weer even terug naar het begin 🙂

Een volledig blanco programma zou er dus als volgt uitzien:

void setup()
{
 
}
 
void loop()
{
 
}

Nu gaan we de eerste sketch maken, namelijk het laten knipperen van ons onboard ledje. Zie dit als de “hello world” test maar dan voor Arduino’s.

Zoals we in de vorige post hebben kunnen lezen is deze verbonden met pin nummer 13. Laten we pin nummer 13 eens definiëren:

int boardPin = 13;
 
void setup()
{
 
}
 
void loop()
{
 
}

Wat we hierboven gedaan hebben is het creëren van een variabele genaamd “boardPin” en die variabele geven we als waarde “13” mee. Bij C definiëren we voor het aangeven van de variabele het type. In dit geval een “integer” (rond getal) ofwel “int”.

We willen nu pin nummer 13 instellen als output pin. Headerpinnen kunnen namelijk in input en output mode geschakeld worden. De input mode wordt gebruikt wanneer input verkregen wordt van b.v. een sensor. Om de pinmode in te stellen maken we gebruik van de aanwezige functie “pinMode”.

int boardPin = 13;
 
void setup()
{
pinMode(boardPin, OUTPUT);
}
 
void loop()
{
 
}

Vervolgens gaan we de LED aansturen om uit te gaan alvorens ons programma start. Een signaal kan 2 waardes hebben (met uitzondering van PWM signalen) namelijk uit (LOW) en aan (HIGH). Om het lampjes uit te schakelen gebruiken we de functie “digitalWrite”. Na het aanroepen van de functie definiëren we de pin en de status welke dus LOW is om het lampje uit te schakelen.

int boardPin = 13;
 
void setup()
{
pinMode(boardPin, OUTPUT);
}
 
void loop()
{
digitalWrite(boardPin, LOW);
}

Vervolgens gaan we het lampje laten knipperen door een wachttijd (delay) te creëren van 2 seconde alvorens de status veranderd. Let op, de “void loop” blijft loopen waardoor we slechts 2 statussen en 2 delays hoeven te creëren.

int boardPin = 13;
 
void setup()
{
pinMode(boardPin, OUTPUT);
}
 
void loop()
{
digitalWrite(boardPin, LOW);
delay(2000);
digitalWrite(boardPin, HIGH);
delay(2000);
}

Meer Arduino EDI Code

Wat hebben we al geleerd? Best wel veel eigenlijk. We weten al 2 zinnige commando’s, namelijk:

• pinMode = de status van de pin. Let op: deze is alleen wanneer er een pin als OUTPUT of INPUT gedefinieerd kan worden. Deze hoeft dus niet voor de analoge pinnen gedefinieerd te worden omdat dat alleen input pinnen zijn
• digitalWrite = het sturen van een commando naar een specifieke pin

Ook weten we dat een pin 2 minModes kan hebben en dat een void geen waardes retourneert.

Ook weten we dat we variabele kunnen gebruiken. We zagen wat we voor het definiëren van een variabele de variabele beginnen met het type. Hierbij een wat beter overzicht van de mogelijke datatypes:

• boolean = slechts bestaande uit 2 mogelijkheden. 0 of 1 OF true of false
• byte = een numerieke waarde (8-bits) zonder punten. Ranges zijn van 0 tot 255
• int = een numerieke waarde (16-bits) zonder punten. Ranges zijn van -32.768 tot +32.768
• unsigned int = een numerieke waarde (16-bits) zonder punten. Ranges zijn alleen positief van -0 tot +65.535
• word = zelfde als een unsigned int
• long = een numerieke waarde (32-bits) zonder punten. Ranges zijn van -2147483648 tot +2147483647
• unsigned long = een numerieke waarde (32-bits) zonder punten. Ranges zijn alleen positief van -0 tot +4294967295
• float = een numerieke waarde (32-bits) incl. punten (decimalen). Ranges zijn van -34028235E+38 tot +34028235E+38
• double = zelfde als een float
• char = een karakter welke 1 byte groot is. Het karakter wordt opgeslagen als een numerieke waarde volgens de ASCII chart A = 65.
• string = string is GEEN valide datatype. Een string zijn meerdere karakters achter elkaar. B.v. een woord. Om een string te creëren gebruik je het char datatype en zet je alle karakters tussen dubbele quotes.

  char mijnnaam[ ] = “JarnoBaselier”

  char mijnnaam[ ] = “JarnoBaselier”

Opmerkingen maken tussen de code kan door gebruik te maken van 2 foreward slashes (//) wanneer het slechts 1 regel betreft. Opmerkingen die meerdere regels betreft kunnen geplaatst worden tussen /* en */. Deze code wordt dus gezien als opmerking en overgeslagen tijdens de uitvoering.

// Deze opmerking is 1 regel groot
 
/*
Deze
Opmerking
Is
Meerdere
Regels
Groot
*/

Als we het hebben over variabelen dan is het ook zinnig om even te vertellen wat arrays zijn. Een array is feitelijk een gestructureerde lijst van elementen. Binnen een array is iedere waarde genummerd en kan er in de code ook gerefereerd worden naar een specifieke waarde binnen de array. Het definiëren van een array lijkt ook heel veel op het definiëren van een variabele. Zo doen we dat:

int jaartallen[ ] = {1981, 1982, 1983, 1984};
int jaartallen2[16] = {1981, 1982, 1983, 1984};
int jaartallen3[20] = {-1981, -1982, -1983, -1984};
char fruitsoorten[ ] = ("Appel","Peer","Banaan","Kiwi","Sinaasappel","Mango","Ananas")

De haken in bovenstaande voorbeeld is de eerste array genaamd “jaartallen” te zien met lege haken “[ ]”. Dit is prima. Tijdens het compilen zal de compiler de waardes tellen en een array maken die exact groot genoeg is. Je kunt hier opgeven hoe groot de array is. Jaartallen 2 is 16 karakters groot, voldoende om de 4 jaartallen in kwijt te kunnen. Als er negatieve getallen gebruikt worden moet er ook een positie gedefinieerd worden voor het min (-) karakter en dus zijn er bij “jaartallen3” 20 karakters nodig. Uiteraard kun je ook een array maken met woorden zoals in de array “fruitsoorten”.

Je kunt ook een lege array definiëren die later gevuld wordt. Bijvoorbeeld:

int jaartallen[ ];
int jaartallen2[16];

In bovenstaande jaartallen array is de array zo groot als nodig is tijdens het compileren. Bij jaartallen2 worden er 16 (0-15) int posities gereserveerd in de array. Zoals je ziet worden waardes in een array genummerd v.a. 0. De eerste waarde in een array krijgt nummer 0, de 2e waarde krijgt nummer 1 etc.

Arduino Loops
Natuurlijk kunnen we ook loops gebruiken binnen Arduino code. Er zijn verschillende loops mogelijk zoals:

• If / Else = Deze loop word net zolang uitgevoerd zolang de waarde “true” is. Als de waarde dit niet meer is dan wordt de loop afgebroken en de “else” statement uitgevoerd.
• SwitchCase / Break = Deze loop lijkt op de if/else loop. Hierbij controleren we een variabele aan de hand van een case. Als de variabele overeenkomt met de gevraagde case dan wordt deze uitgevoerd. Zo niet dan wordt er naar de volgende case gekeken.
• For = Bij een for loop word teen blok code een X aantal keer herhaald. Deze loop werkt met een counter. Meestal is de for loop zo opgesteld dat de code uitgevoerd wordt zolang de counter zich begint binnen het opgegeven bereik.
• while = De code in de while loop wordt herhaald zolang een bepaalde conditie “true” is.
• do = De do loop is vergelijkbaar met de while loop. Hier wordt de conditie na de loop gecontroleerd. Bij de while loop is dit aan het begin van de loop.

Hierbij een voorbeeld van een for loop:

int PWMpin = 10; // We definiëren PWM pin nummer 10 als “PWMpin”
 
void setup()
{}
 
void loop()
{
   for (int i=0; i <= 255; i++){
      analogWrite(PWMpin, i);
      delay(10);
   }
}

De loop hierboven zet de counter van de for loop (i) op 0. Vervolgens zeggen we zolang i kleiner of gelijk aan 255 is dat we er 1 bij optellen en de loop uitvoeren. De code die dan uitgevoerd wordt is dat pin nummer 10, de PWM pin de waarde van de counter (i) krijgt. Vervolgens wordt er een delay van 10 milliseconden toegepast en wordt de loop herhaald. Dit zal resulteren dat een aangesloten led de waardes 1 tot 255 krijgt met een delay van 10 ms tussen elke ophoging. De waardes 1 tot 255 komen overeen met 0 tot 5V. Omdat dit een PWM pin is zal het uiteindelijke resultaat een lampje zijn welke begint als uit en zal faden naar volle sterkte.

In bovenstaande loop gebruiken we “analogWrite” terwijl we eerdere “digitalWrite” gebruikte. In principe wordt aangeraden om eigenlijk altijd “digitalWrite” te gebruiken tenzij je een PWN pin aanstuurt. analogWrite stuurt namelijk gepulseerde output naar de PWM pinnen. Niet PWM pennen kunnen een HIGH (5V) en een LOW (0V) signaal uitsturen.

Wat ook even goed is om te verduidelijken is het <= teken in bovenstaande voorbeeld. Dit is een zogenaamde “general operator” en wordt gebruikt om te werken met waardes. We kennen de volgende voorbeelden: == betekend “is gelijk aan” (een enkel = teken is een assignment karakter) + betekend “tel op” - betekend “haal eraf” * betekend “maal” / betekend “delen” % betekend “procentueel” < betekend “minder dan” > betekend “meer dan”
<= betekend “is minder dan of gelijk aan” >= betekend “is meer dan of gelijk aan”
&& betekend “en”
|| betekend “of”
! betekend “niet”

Gebruik analoge input
Input pinnen zijn input pinnen. Deze kunnen gebruikt worden om input te lezen. Het lezen van de huidige waarde doen we met het “analogRead” commando. Bijvoorbeeld:

int reading = analogRead(0);

Hierbij lezen we de waarde van de analoge 0 pin. Wanneer deze pin geen signaal ontvangt zal de waarde 0 zijn en wanneer deze 5V ontvangt zal het signaal 1024 zijn. Uiteraard zal alles wat daartussen zit stapsgewijs overeenkomen. Een input van 2.5V zal overeen komen met de waarde 512 en 1.25V met de waarde 256.

Een uitgebreidere code zal verduidelijken hoe we een gelezen waarde (0-1023) mappen aan een output waarde (0-255). Dit doen we met het “map” commando en illustreren we middels een lichtsensor. Hoe meer licht er in de sensor valt, des te feller de lamp gaat branden.

void setup(){
    // Definieer pin 6 als “output” pin
    pinMode(6, OUTPUT)
}
 
void loop(){
    // lees het voltage level van pin nummer 0
    int sensorValue = analogRead(0);
 
    // map de 0 - 255 input reading aan het 0 - 1023 output signal
    sensorValue = map(sensorValue, 0, 1023, 0, 255);
 
    // schrijf het voltage level naar pin 6 om de lamp te laten branden
    analogWrite(6, sensorValue);
}

Analoog VS PWM signaal

Om goed met de Arduino te kunnen werken is het belangrijk om te weten wat het verschil is tussen een analoog en een digitaal PWN signaal.

Een analoog signaal verwijst over het algemeen naar de spanning van een signaal op een bepaald tijdstip. We kunnen via verschillende elektronische componenten deze signalen manipuleren om elke spanning tussen 0 volt en de spanning van onze krachtbron (3.3 of 5 volt) weer te geven. Een analoog signaal kan een sinusgolf zijn:

Wanneer een signaal digitaal wordt genoemd, kan het over het algemeen slechts twee waarden voorstellen, hoog en laag (of in computertaal, een 0 of een 1). De Arduino microcontroller kan alleen een hoge waarde of een lage waarde uitvoeren. Het kan bijvoorbeeld niet 2,5 V output leveren. Om dit gebrek aan veelzijdigheid te compenseren wordt gebruikgemaakt van een PWM12 ofwel een pulsbreedte gemoduleerd signaal zoals we al besproken hebben.

Een PWM gemoduleerd signaal is een digitaal signaal welke in een korte en vaste tijdsinterval het signaal een gedeelte van de tijd hoog en een gedeelte van de tijd laag houdt.

Het blauwe is een representatie van een PWM signaal. Zie je dat hij alleen hoog of laag gaat en nooit een waarde daartussenin heeft. Elke 1000 monsters op de x-as vertegenwoordigen één PWM-cyclus. Wanneer je je Arduino programmeert, kun je de lengte van deze cyclus wijzigen, maar misschien nog belangrijker, je kunt de Arduino programmeren voor welk percentage van elke cyclus je wilt dat het signaal hoog is. In de Arduino stel je een waarde tussen 0 en 255 in om dit te vertegenwoordigen. Voor dit voorbeeld stellen we het op 51, wat 20% van 255 is, dus voor elke cyclus wordt het signaal 20% van de tijd hoog. Als we de gemiddelde waarde van deze cyclus willen nemen (som elk van de 1000 monsters en delen door 1000), krijgen we een gemiddelde spanning van 1V.

Ok, even terug in perspectief van de Arduino. Wanneer je de PWM-modus hebt geselecteerd, krijg je dat periodieke hoog / laag-signaal zoals hierboven beschreven. Wanneer je naar de analoge modus schakelt, stuur je feitelijk het PWM signaal door een aantal extra circuits voordat het de module verlaat. Deze schakeling (in dit geval een laagdoorlaat filter) converteert dat PWM-signaal naar de gemiddelde waarde van het PWM-signaal, zodat je uitgangssignaal eruit zal zien als de gestreepte rode lijn in plaats van de blauwe lijn.

Als je een staafdiagram-bit hebt, kun je de standaardcode voor de Arduino-module gebruiken om het verschil in actie te zien. Als je een PWM-uitgang programmeert om herhaaldelijk op en neer te gaan, zie je alle LED’s op de staafgrafiek langzaam helderder en vager worden, allemaal tegelijkertijd. Als je het vervolgens naar de analoge modus schakelend zie je dat elke LED na elkaar wordt ingeschakeld en achtereenvolgens wordt uitgeschakeld, allemaal met dezelfde helderheid.

Tips voor Arduino troubleshooting

Als je begint met Arduino zul je merken dat alles niet van een leien dakje zal gaan. Zeker wanner je je eigen circuits en code gaat schrijven zul je vaak te maken krijgen met een vervelend proces genaamd “troubleshooting” 🙂 Het uitpluizen waarom het in godsnaam niet werkt.

Hier een aantal troubleshooting tips:

• Zorg ervoor dat de stoomtoevoer constant is. Zeker als je een batterij gebruikt is het zaak een volle batterij te gebruiken omdat de Arduino gevoelig is voor half lege batterijen.
• Controleer je code op syntax errors. Heb je de puntkomma (;) gebruikt om statements te sluiten en is elke functie voorzien van voldoende (en de juiste) argumenten?
• Vertel bij het definiëren van variabele altijd wat voor type het is (int, byte etc.).
• Kijk goed naar de foutmeldingen (onderin) de Arduino editor. Zo is het makkelijker om de regel te bepalen waar het probleem zich voordoet en weet je ongeveer wat er mis is.
• Gebruik juiste bekabeling en spreek de juiste componenten aan.
• Als niks werkt (b.v. de software krijgt geen connectie meer met je board), reset dan de Arduino eens. Soms werkt dit fantastisch.

Meest voorkomende Arduino commando’s

• analogRead
  Leest de waarde van een analoge pin. Waardes tussen de 0 en 5 volt worden gelezen en gekoppeld aan een integer van 0 tot 1023. Dit is .0049 volts per waarde.
• delay
  Pauzeert het programma voor de opgegeven tijdsperiode (in milliseconde). 1 seconde is 1000 milliseconde.
• digitalWrite
  Dit commando zorgt ervoor dat een digitale pin die als OUTPUT pin geconfigureerd is aan (HIGH) of uit (LOW) staat. Als de pin aan staat dan stuurt deze een 5V of 3.3V signaal uit. Dit is afhankelijk van de power input van de Arduino.
• map
  Dit commando nummert een waarde om van het ene bereik naar het andere bereik. Map beperkt de waardes niet binnen een specifiek bereik omdat waarden buiten een bereik soms bedoeld en nuttig zijn. De functie constrain () kan vóór of na deze functie worden gebruikt, als er wel limieten voor de bereiken zijn gewenst.
• pinMode
  Configureert een digitale pin als INPUT of als OUTPUT pin.
• Serial.available
  Verkrijg het aantal bytes (tekens) dat beschikbaar is voor lezen vanaf de seriële poort. Dit zijn gegevens die al zijn ontvangen en zijn opgeslagen in de seriële ontvangstbuffer (64 bytes).
• Serial.begin();
  Stelt de datasnelheid in voor seriële datatransmissie. De waarde die gebruikt wordt is bits per seconde (baud). Default is 9600, maar de volgende waardes worden eveneens vaak gebruikt: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 of 115200. Je kunt echter ook andere waardes opgeven om bijvoorbeeld te communiceren over pinnen 0 en 1 met een component dat een bepaalde baudrate vereist.
• Serial.println
  Stuurt gegevens uit naar de seriële poort met leesbare ASCII-tekst gevolgd door een regelterugloopteken (ASCII 13 of ‘\ r’) en een ENTER teken (ASCII 10 of ‘\ n’). Deze syntax is vrijwel identiek aan Serial.print ().
• Serial.read
  Leest inkomende data vanaf de seriële pinnen.

Conclusie

Ik weet dat dit slechts een korte overview is van alle mogelijkheden. Ik hoop echter wel dat jullie dit interessant vonden en dat je nu klaar bent om je eigen sketches te gaan schrijven. Uiteraard volgen er nog meer projecten met de Arduino en dan duiken we uit uiteraard ook weer de code in 🙂 Vragen… kom maar op! Likes… graag… strooien maar!

PS: Klik hier voor een prachtige 1-page Arduino Cheatsheet van SparkFun!