Arduino commando’s om op terug te vallen

Hier vindt u een alfabetische lijst van alle commando’s in arduino. De één al meer voorkomend dan de andere, echter allemaal erg nuttig in de juiste situatie. Wil je weten welke variabelen er juist gevraagd worden bij een moeilijke les of project ? Hier vindt je alle nodige Arduino commando’s en uitleg om verder te gaan. 

Arduino is een taal, en talen leven. Er zijn meestal meerdere mogelijkheden, verschillende commando’s, om het zelfde resultaat te bereiken. Deze pagina zal je enige opheldering of extra uitleg bezorgen.

Deze Arduino commando’s kennen hen toepassing in vele verschillende schakelingen. Sommige zijn noodzakelijk in elke code, andere werken samen met een bepaalde hardware component. Vele van deze commando’s gebruiken we in onze gratis Arduino lessen. In deze lessen leggen we de basis commando’s uit en maken we gebruik van hun effecten en functies in een vooropgestelde schakeling. M.a.w. de perfecte methode om jouw basis te leggen in het programmeren! 

Bovendien kan iedereen die op zoek is naar Arduino onderdelen eenvoudig en voordelig een totaalpakket Arduino bestellen. Dit pakket hebben wij voor jullie samengesteld en bieden wij aan op bol.com. Dit doen we om te garanderen dat er met officiële en kwalitatieve onderdelen gewerkt wordt die voor alle lessen compatibel zijn. Helaas circuleren er tegenwoordig erg veel en van lage kwaliteit namaak producten.

Het apart aankopen van verschillende componenten is al snel zeer kostelijk. De componenten die dit pakket bezit zijn erop gedoeld basis tot sterk variërende complexe schakelingen te bouwen, hopelijk kunnen we jullie hier een beetje mee op weg helpen! En jullie ons!

Arduino commando's

Al bij al is het vinden van officiële en kwalitatieve Arduino onderdelen niet eenvoudig. Via onderstaande link kan je op bol.com met korting jouw pakket bestellen!

-> Bestel hier je pakket!

Arduino commando's:

Alle Arduino commando’s beschikbaar op deze pagina’s zijn vrij om te gebruiken, kopiëren en te delen. Navigeer per categorie door de alfabetische lijst en schuif eenvoudig de tabbladen in en uit waar nodig. Veel succes!

Arduino commando's

Betekenis:

analogRead(); is één van de meest gebruikte Aruino commando’s. Het leest een analoge waarde van de gekozen pin en zet een spanningswaarde uit het interval [0;5] om naar een waarde in het interval [0,1023]. Dit resulteert in een nauwkeurige meting. De lees-nauwkeurigheid bedraagt ongeveer 0,00489V per eenheid.

Context:

analogRead(pin);

Parameters:

pin = het pinnummer of een variabele die hieraan gelijkgesteld is.

Voorbeeldcode:

   int ledRood = 9;    // LED geschakeld aan pin 9
   int meter = 3;        // potentiometer verbonden met pin 3
   int waarde = 0;     // variabele om de gelezen waarde in op te slaan

   void setup()
   {
     pinMode(ledRood, OUTPUT);    // declareer de led als OUTPUT
   }

   void loop()
   {
   waarde = analogRead(meter);             // lees de waarde van de meter
   analogWrite(ledRood, waarde / 4);    // zie ‘analogWrite();’

   }

Notities:

Een analoge meting neemt ongeveer 0,000 1s in beslag. Men kan dus maximaal 10 000 meten per seconde.
Als er niets verbonden is aan de gekozen pin, dan zal de gelezen waarde onstabiel variëren in het interval [0,1023]. Factoren zoals de waardes van andere analoge pinnen en de warmte bepalen deze waarde.

Betekenis

Schrijf een analoge waarde naar de genoemde pin. Deze waarde ligt tussen 0 en 255 waarbij de uiterste waarden respectievelijk de ground ( 0V ) en de 5V ( of 3.3V ) voorstellen. Elke waarde tussen 0 en 255 stelt zijn corresponderende procentueel deel van de 5V voor. Zo kunnen we bijvoorbeeld LED’s dimmen en motoren trager laten draaien. Dit commando wordt vaak samen met het arduino commando analogRead(); gebruikt.

Context:

analogWrite(pin, waarde);

Parameters:

Pin : het pinnummer of de variabele die eraan gelijkgesteld is.

Waarde : een getal tussen 0 en 255.

Voorbeeldcode:

   

   int ledRood = 9;        // LED geschakeld aan pin 9 
   int meter = 3;            // potentiometer verbonden met pin 3 

   int waarde = 0;         // variabele om de gelezen waarde in op te slaan

   void setup() 
   { 
   pinMode(ledRood, OUTPUT);    // declareer de led als OUTPUT 
   }

   void loop() 
   { 
   waarde = analogRead(meter);             // zie ‘analogRead()’
   analogWrite(ledRood, waarde / 4);    // schrijf de waarde naar de LED.
   }

 

Notities:

Een PWM-signaal kan alleen verstuurd worden poorten die aangeduid zijn met het PWM-teken; namelijk een golf.

De gelezen waarden van analogRead(); bevinden zich in het interval [0;1023]. Wanneer we deze waarden willen gebruiken in ons analogWrite commando, dan zullen we deze moeten delen door 4. Zo zullen de gelezen waarden hun waarde hebben in het interval [0;255].

Betekenis:

We gebruiken deze commando’s om onze code te pauzeren. delay(); zal de code pauzeren voor een zelf gekozen duur uitgedrukt in milliseconden. Wanneer we kiezen voor een duur van ‘1000’ zal de code dus één seconde pauzeren. delayMicroseconds(); pauzeert de code voor een waarde uitgedrukt in Microseconden. Een waarde van ‘1000’ zal dan één milliseconde zijn.

Context:

delay( duurMilliseconden );

delayMicroseconds( duurMicroseconden );

Parameters:

duurMilliseconden = de waarde van de pauze uitgedrukt in milliseconden, datatype unsigned long.

duurMicroseconden = de waarde van de pauze uitgedrukt in microseconden, datatype unsigned int.

Voorbeeldcode:

int ledRood = 12;              

void setup() {

pinMode( ledRood , OUTPUT);   

}

 

void loop() {

digitalWrite( ledRood , HIGH);

delay(1000);      // pauzeer de code voor één seconde

digitalWrite( ledRood , LOW);

delayMicroseconds(1000);      // pauzeer de code voor één milliseconde

}

Notities:

Wanneer je gebruik maakt van deze commando’s pauzeer je je code… Dit wil zeggen dat er tijdens deze pauze er niets anders controleert wordt of gebeurt. Je programma is als het ware bevroren! Daarom wordt delay vaak vermeden bij langere codes die gemaakt worden door ervaren programmeurs. Toch is het de eenvoudigste manier om een knipperend ledje te coderen! Als je in je code deze ‘bevriezing’ niet kunt gebruiken, dan gebruik je best het commando millis();.  Hoe je dit programmeert zie je in de voorbeeldcode bij dit commando.

delayMicroseconds(); is precies in het inteval [3,16383]. Buiten deze toleranties kunnen er geen exacte waarden gegarandeerd worden. Voor grotere pauzes neem je best het commando delay();.

Betekenis:

Lees de waarde van, de op de vernoemde pin aangesloten, INPUT. De waarde is ofwel HIGH ofwel LOW. Dit commando wordt gebruikt voor binaire [componenten] zoals een knop.

Context:

digitalRead(pin).

Parameters:

Pin : het pinnummer of de variabele die eraan gelijkgesteld is.

Reactie:

HIGH of LOW

Voorbeeldcode:

   int ledRood = 11;     // LED geschakeld aan pin 11
   int knopLed = 7;      // knop verbonden aan pin 7
   int waarde = 0;        // variabele om de gelezen waarde in op te slaan

   void setup()
   {

   pinMode(ledRood, OUTPUT);      // declareer ledRood als OUTPUT
   pinMode(knopLed, INPUT);        // declareer knopLed als INPUT
   }

   void loop()
   {
   waarde = digitalRead(knopLed);     // lees de waarde
   digitalWrite(ledRood, waarde);       // stuur de waarde naar de LED
   }

Notities:

Als je gekozen pin niet aangeschakeld dan stuurt het commando digitalRead(); soms een HIGH waarde en soms en LOW waarde. Dit is onvoorspelbaar en volgt geen duidelijk patroon.

De analoge pinnen A0,A1 … kunnen ook digitale inputs verwerken.

Betekenis:

Schrijf een 1 ( HIGH ) of een 0 ( LOW ) waarde naar een digital pin.

Als de pin gedeclareerd is al een OUTPUT in de Setup dan stuurt de Arduino bij een HIGH waarde 5V ( of 3.3V bij andere boards ) naar de digitale pin. Bij een LOW waarde trekt hij de digital pin naar de ground, 0V.

Voor meer info over declareren of de opbouw van je schakeling ga terug naar de programmeeromgeving.

Als de pin gedeclareerd is als een INPUT_PULLUP dan activeert, bij een HIGH waarde, de Arduino de interne pullup weerstand. Deze sluit de gadget kort binnenin zodat er bijvoorbeeld bij hoge spanningspieken, wanneer er gewerkt wordt met een externe elektriciteitsbron, er geen schade ontstaat aan de gadget. Dit commando kan gebruikt worden als beveiliging in combinatie met bijvoorbeeld een meter en een voorgeprogrammeerde maximale waarde.

Het is zeer belangrijk dat je de digital pin declareert. Wanneer dit niet het geval is, zal er toch verbinding gemaakt worden, maar als er bijvoorbeeld een led geschakeld wordt dan zal deze gedimd lijken.

Context:

digitalWrite( pin , waarde );

Parameters:

Pin : het pinnummer of de variabele die eraan gelijkgesteld is.

Waarde : HIGH of LOW;

Voorbeeldcode:

   void setup(){
   pinMode(13,
   OUTPUT);     // declareer de pin 13 als OUTPUT
   }

   void loop(){
   digitalWrite(13, HIGH);       // start de digitale pin 13
   delay(1000);                  // wacht 1000 milliseconden
   digitalWrite(13, LOW);        // stop de digitale pin 13
   delay(1000);                  // wacht 1000 milliseconden
   }

Notities:

De analoge pinnen A0,A1 … kunnen ook digitale inputs verwerken.

Betekenis:

millis(); geeft het aantal milliseconden weer sinds de arduino begonnen is met het uitvoeren van het huidige programa. micros(); geeft deze weer in microseconden.

Context:

millis();

micros();

Parameters:

/

Antwoord:

Geeft de tijd sinds het programma begon weer in milliseconden/ microseconden, datatype unsigned long.

Voorbeeldcode:

const int ledRood =  12;
const int intervalKnipper = 1000;    

unsigned long tijd= 0;

unsigned long vorigeTijd =0 ;              

void setup() {
  pinMode( ledRood, OUTPUT);
}

void loop() {
  tijd = millis();

  if (tijd – vorigeTijd >= intervalKnipper) {
      previousMillis = currentMillis;

       if (ledState == LOW) {
      ledState = HIGH;
    }

else {
 ledState = LOW;
   }
}
}

Notities: 

Het commando millis(); zal resetten, terug gelijkgesteld worden aan nul, na 50 dagen. micros(); zal resetten na 70 uur.

Er kunnen errors optreden wanneer je deze commando wil proberen gelijk te stellen aan een kleiner datatype, zoals int. Zelfs bij het gelijkstellen aan een ‘long’-datatpe kunnen er problemen verwacht worden. Deze heeft namelijk slechts een maximale waarde die half zo groot is als een ‘unsigned long’-datatype. Meer informatie over datatypes vindt je op programmeeromgeving arduino.

Betekenis:

Dit commando paart met tone();. De ene stopt namelijk wat de andere geactiveerd heeft.

Stopt de toon gestuurd door een voorgaand tone(); commando. Dit commando geeft geen effect als er geen tone(); commando gestuurd werd naar de gekozen pin.

Context:

noTone( pin );

Parameters:

pin = het pinnummer of een variabele die eraan gelijkgesteld is.

Voorbeeldcode:

   int buzzer =12;   // schakel de buzzer aan poort 12
   int knop =11;      // schakel de knop aan poort 11
   int knopStatus;

   void setup() {
   pinMode ( buzzer , OUTPUT);    // declareer de buzzer als OUTPUT
   pinMode ( knop , INPUT);           // declareer de knop als INPUT
   }

   void loop() {
   knopStatus = digitalRead ( knop );    // lees de waarde van de knop
   if ( knopStatus == HIGH){
   tone(buzzer , 1000);     // schrijf de toon naar de buzzer
   }
   else{
   noTone(buzzer);    // stop met de toon te sturen naar de buzzer
   }
   }

Notities:

Je moet het commando noTone(); sturen naar de eerste pin voordat je het commando tone(); kan sturen naar de tweede pin.

Betekenis:

Dit is één van de onmisbaar Arduino commando’s, het declareert de genoemde pin als OUTPUT, INPUT of INPUT_PULLUP. Een OUTPUT betekend dat de aangesloten gadget een uitvoerende functie heeft. Een INPUT dat de aangesloten een gadget waardes zal versturen dat de Arduino moet ontvangen. Een INPUT_PULLUP kan ik combinatie van een digitalWrite(); gebruikt worden als beveiliging.

Context:

pinMode( pin, declaratie);

Parameters:

Pin : het pinnummer of de variabele die eraan gelijkgesteld is.

Declaratie : INPUT, OUTPUT of INPUT_PULLUP

Voorbeeldcode:

   void setup(){
   pinMode(13, OUTPUT);          // declareer pin 13 als OUTPUT
   }

   void loop(){
   digitalWrite(13, HIGH);       // stuur 5V naar poort 13
   delay(1000);                // wacht 1000 milliseconden
   digitalWrite(13, LOW);        // stop met 5V te sturen naar poort 13
   delay(1000);               // wacht 1000 milliseconden             
   }

Notities:

De analoge pinnen A0,A1 … kunnen ook digitale inputs verwerken.

Betekenis:

Met deze commando’s kunnen we de lengte van een puls bepalen. We kunnen bepalen welke puls we willen, de LOW-puls of de HIGH-puls. Zo zal dit commando timen hoelang een pin respectievelijk LOW of HIGH is.

Dit kunnen we gebruiken bij bijvoorbeeld een knop. Onze knop is standaard LOW, wanneer we deze induwen wordt de knop uiteraard geactiveerd. We kunnen dan de lengte HIGH-puls bepalen. Met andere woorden: we kunnen dus verschillende functies toekennen aan eenzelfde knop naar gelang hoe lang deze ingedrukt wordt.

Beide commando’s zijn zo goed als identiek. pulseInLong(); verwerkt slechts beter langere pulsen, maar de maximale puls-lengte is van beide gelijk.

Context:

pulseInLong ( poort, waarde);

pulseInLong ( poort, waarde, duur);

pulseIn ( poort, waarde);

pulseIn ( poort, waarde, duur);

Parameters:

Poort = welke poort er gecontroleerd moet worden.

Waarde = welke puls er gelezen moet worden, HIGH of LOW.

Duur = de duur, in microseconden, voor het wachten tot de puls gestart is, standaard is dit 1 seconde.

Antwoord:

De lengte van de puls in microseconden.

Voorbeeldcode:

cont Int ledRood = 12;   

const int knop = 11;

unsigned long duurPuls;

 

void setup() {

  Serial.begin(9600);

  pinMode( ledRood, OUTPUT);

  pinMode( knop, INPUT);

}

 

void loop() {

  duurPuls = pulseIn( knop , HIGH)/1000 ;   // omzetten van microseconden naar milliseconden

  Serial.println( duurPuls );

If ( duurPuls < 1000){

Led ( ledRood);

}

 else If ( duurPuls < 2000){

Led ( ledGeel);

}

else if ( duurPuls < 3000){

led ( ledGroen);

}

}

Void led (int led){

digitalWrite ( led, HIGH);

delay ( 1000);

digitalWrite ( led, LOW);

}

Notities: 

Wanneer de pin die dit commando moet controleren geen puls ondergaat, dan zal er een nul gestuurd worden.

Dit commando werkt bij pulsen van 10 microseconden tot 3 min.

Deze commando’s kunnen slechts werken als ‘interrupts’ geactiveerd zijn. Dit omdat ze werken met microseconden. Voor meer info omtrent ‘interrupts’ zie interrupts(); , noInterrupts(); , attachInterrupt(); en detachInterrupt();

 

De HIGH-puls zal beginnen met timen wanneer de overgang van LOW naar HIGH plaatsvind. Wanneer de poort echter al HIGH is wanneer het commando opgeroepen wordt, dan zal het commando wachten tot de poort eerst weer de overgang maakt voor deze zal beginnen timen. De poort zal dus opnieuw eerst LOW moeten worden en dan weer HIGH voordat de timing begint.

Betekenis:

Genereer een zelfgekozen nummer uit een bepaald interval. Dit commando gebruikt statistiek om ervoor te zorgen dat de keuze eerste en vooral random is. Ten tweede zorgt het programma ervoor dat elk getal eenzelfde aantal keren gekozen wordt. Of dit in de realiteit ook zo zal zijn hangt natuurlijk van het aantal malen dat het programma uitgevoerd wordt.

Context:

random ( max);

random ( min , max);

Parameters:

max = de maximale waarde van het interval. Dit getal kan niet gekozen worden.

min = de minimae waarde van het interval. Dit getal kan wel gekozen worden.

interval : [min, max[

Voorbeeldcode:

   long nummer;

   void setup() {

   Serial.begin(9600);

   }

   void loop() {

   nummer = random(300); // [0,299[  Serial.println(randNumber);

   nummer  = random(1020); //[10,19[

   Serial.println(randNumber);

   delay(50);

   }

Notities:

De output van de commando is een ‘long’ datatype. Dit wil zeggen dat het zeer grote getallen kan generen, maar geen kommagetallen. De output is dus steeds een natuurlijk getal. Op onze sectie programmeeromgeving vind je meer info over datatypes.

Betekenis:

De Serial.begin(); commando’s zijn Arduino commando’s die geen representatieve harware component nodig hebben. Ze gebruiken namelijk je pc als uivoerder, maar ook als databron.

Open de mogelijkheid om data te sturen via een bandlengte naar de seriële monitor. De seriële monitor kan geopend worden op de computer en kan gebruikt worden voor een grote waaier aan mogelijkheden. Alle commando’s betreffend de seriële monitor worden aangegeven door ‘Serial.’.

De band geeft de snelheid, in pulsen per second, weer waarmee er met de computer gecommuniceerd wordt. Voor communicatie met de computer gebruikt één van volgende bandlengtes: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, of 115200. 9600 is de grootheid dat het meest gebruikt word voor deze communicatie.

Men kan ook ander waardes specificeren om bijvoorbeeld met bepaalde externe, niet de aangesloten computer, te communiceren met behulp van de gekozen, meestal specifiek voor de component, waarde.

Tot slot hebben we de configuratie. Dit wordt meestal niet ingevuld en volgt dan de standaard SERIAL_8N1 configuratie. De configuratie geeft specificaties weer van een enkele puls. De driedelige combinatie geeft deze specificaties weer. Namelijk de grote, de pariteit en de pauze bits van de datastroom weer.

  • Het eerst cijfer staat voor de grote van de datastroom in bits ( per puls ). De mogelijkheden zijn 5,6,7 of 8 bits per puls.

  • De tweede letter staat voor de pariteit van de doorgestuurd stroom. Er zijn drie mogelijkheden, namelijke ‘N’, none, ‘E’, even, of ‘O’, odd. Een pariteit is het eenvoudigste systeem om fouten op te sporen. Bij ‘E’ moet de optelsom van alle enen in de binaire lijst even zijn. Bij een ‘O’ moet de som oneven zijn. Om dit te bekomen wordt er door de pariteit een extra 0 of 1 toegevoegd.

  • Het derde cijfer staat voor het aantal pauze/stop bits in de stroom. Met andere woorden de grote van de pauze/spatie tussen twee pulsen van de datastroom. In arduino zijn er configuraties met 1 of 2 stop bit(s).

In de standaard configuratie heb het een 8 bits data stroom ( SERIAL_8N1 ), geen pariteit ( SERIAL_8N1 ) en één stop bit ( SERIAL_8N1 )

Context:

Serial.begin( band );

Serial.begin ( band, configuratie);

Parameters:

band = een long integer, meestal ingevuld als getal, die de bandlengte weergeeft.

configuratie = het soort configuratie die de band heeft.

De mogelijke configuraties zijn:

  • SERIAL_5N1

  • SERIAL_6N1

  • SERIAL_7N1

  • SERIAL_8N1

  • SERIAL_5N2

  • SERIAL_6N2

  • SERIAL_7N2

  • SERIAL_8N2

  • SERIAL_5E1

  • SERIAL_6E1

  • SERIAL_7E1

  • SERIAL_8E1

  • SERIAL_5E2

  • SERIAL_6E2

  • SERIAL_7E2

  • SERIAL_8E2

  • SERIAL_5O1

  • SERIAL_6O1

  • SERIAL_7O1

  • SERIAL_8O1

  • SERIAL_5O2

  • SERIAL_6O2

  • SERIAL_7O2

  • SERIAL_8O2

Voorbeeldcode:

    void setup()
    {
    Serial.begin(9600);    // start de seriële communicatie op 9600 bits per puls
    }

   void loop() 
   {
   // code
   }

Betekenis:

Deze commando’s geven jou het eerste getal van hun datatype in de doorgestuurde data. Zo zal Serial.parseInt(); het eerst ‘integer’ in de data isoleren. Serial.parseFloat(); zal dan weer het eerst ‘float’ isoleren. Beiden stoppen wanneer de pauze doorlopen.

Serial.parse zal standaard alle eerste tekens negeren, tot deze een cijfer of een min-teken tegenkomt. Hierna zal het elk volgend cijfer opslaan, totdat het weer een teken tegenkomt. Deze tekens zijn letters, maar ook punten, komma’s of spaties zijn. Men kan echter wel extra aanpassingen maken.

Context:

Serial.parseInt();

Serial.parseInt( status );

Serial.parseInt( status, negeren );

Serial.parseFloat();

Serial.parseFloat( status*);

Serial.parseFloat( status*, negeren );

Parameters:

status: Deze modus bepaalt wat er algemeen genegeerd wordt in de zoektocht naar het eerste ‘integer’ of ‘float’.

  • SKIP_ALL: alle tekens behalve mintekens en cijfers worden genegeerd. Dit is de standaard status en is diegene die gehanteerd wordt wanneer er geen extra voorwaarden gegeven worden. * bij Serial.parseFloat( status); worden ook de decimale punten genegeerd, deze zijn namelijk nodig om het kommagetal te vormen.

  • SKIP_NONE: Er wordt niets genegeerd. Dit wil zeggen dat er ook pas iets zal teruggestuurd worden wanneer de doorgestuurd data begint met een getal. ( ‘integer’ of ‘float’

  • SKIP_WHITESPACE: Alleen spacies, tabs en enters worden genegeerd. Alle witruimte wordt dus genegeerd!

negeren: het teken dat nog extra genegeerd mag worden. Dit wordt veel gebruikt om de scheidingstekens ‘,’ tussen duizendtallen te laten negeren.

Voorbeeldcode:

   float bedrag;
   void setup() {

   Serial.begin ( 9600);
   }

   void loop() {

   Serial.println ( ” geen kommagetallen, bv: GameGoeroe 5″);
   Serial.setTimeout(200000) ;
   bedrag = Serial.parseInt() ;
   Serial.println(bedrag); // 5
   Serial.println(“wel kommagetallen, bv: GameGoeroe 5.1”);
   Serial.setTimeout(200000) ;
   bedrag = Serial.parseFloat() ;
   Serial.println(bedrag); // 5.1

}

Notities:

5.1 Game6.2Goeroe 7.3

Wanneer het Serial.parse commando beëindigt wordt en er nog steeds data over, dan wordt deze meegenomen naar het volgende commando. Zo zal je meerdere commando’s nodig hebben om deze input te verwerken.

float bedrag;
void setup() {

Serial.begin ( 9600);
}

void loop() {

Serial.println ( ” geef input:”);
Serial.setTimeout(200000) ;
bedrag = Serial.parseInt() ;
Serial.println(bedrag); 
bedrag = Serial.parseFloat() ;
Serial.println(bedrag);
bedrag = Serial.parseFloat() ;
Serial.println(bedrag);
bedrag = Serial.parseFloat() ;
Serial.println(bedrag);

}

input:

5.1Game6.2Goeroe7.3

output:

geef input:

5.00

0.10

6.20

7.30

 

Het tweede commando moest ‘.1’ verwerken. We gebruikten als tweede commando Serial.parseFloat(); en kregen zo ‘0.1’ als output. Echter wanneer we Serial.parseInt(); hadden gebruikt, dan hadden we 1 als output gekregen. 

We kunnen ook ons eerst commando, Serial.parseInt();, aanpassen naar Serial.parseFloat, output: 5.1, of naar Serial.parseInt( SKIP_ALL, ‘.’), output: 51.

Betekenis:

Geef de ASCII-weergave, de menselijke leesweergave, van de opdracht weer in de seriële monitor. Men kan zo waardes, maar ook zinnen, woorden … schrijven naar de seriële monitor. Deze Arduino commando’s worden vaak gebruikt om waardes in het programma te ontvangen en zo op te volgen. Ook om een leesbaar ‘verslag’ te maken van wat er elke cyclus gebeurt wordt deze functie vaak gebruikt.

Getallen worden standaard decimaal geprint. Echter men kan ook de opdracht omvormen naar binaire, octale en hexadecimale vorm. De hebben respectievelijk een 2-, 8- en een 16-waardige indeling. Bij kommagetallen, getallen van het type ‘float’, geeft de tweede waarde de afronding weer.

Het verschil tussen Serial.print(); en Serial.println(); Arduino commando’s is merkbaar in de seriële monitor. Bij Serial.print(); wordt de volgende geschreven waarde in de seriële monitor op eenzelfde lijn geschreven. Echter bij Serial.println(); wordt de cursor een regel naar beneden verplaatst.

Context:

Serial.print ( opdracht );

Serial.print ( opdracht , formaat);

Parameters:

opdracht = de waarde of letters die geprint moeten worden.

formaat = de wijze waarop de opdracht geprint moet worden. De standaard is ASCII-weergave en bij kommagetallen wordt er standaard afgerond op twee cijfers na de komma. De mogelijke printwijzen zijn:

  • Serial.print ( opdracht , BIN) -> binaire weergave

  • Serial.print ( opdracht , OCT) -> octale weergave

  • Serial.print ( opdracht , HEX) -> hexadecimale weergave

  • Serial.print ( opdracht , DEC) -> decimale weergave

Voorbeeldcode:

input:

int a = 1;

void setup(){

Serial.begin( 9600);

}

void loop(){

while ( a ==1){

Serial.println ( “gameGoeroe.com”);

delay ( 2000);

Serial.println(“”);

Serial.println( 1.1234567,3);

Serial.println( 1.1234567,7);

delay ( 2000);

Serial.println(“”);

Serial.println( 99, BIN);

Serial.println( 99, OCT);

Serial.println( 99, HEX);

delay( 2000);

Serial.println( “”);

Serial.print( ” tijd:”);

tijd = millis();

Serial.println( tijd);

a++

}

}

 

 

output:

GameGoeroe.com

 

1.123

1.1234567

 

1100011

143

63

 

tijd: 6001

 

 

Notities:

Bij zowel Serial.print(); als Serial.write(); commando’s kan men het aantal doorgestuurde bytes opvragen. Echter bij Serial.print worden de twee aanhalingstekens (” “) meegerekend. Zo geeft “gamegoeroe.com” bij Serial.print(); een waarde van 16, terwijl deze maar 14 tekens telt.

input:

while ( a== 1){

int verzondenBytesWrite = Serial.write(“GameGoeroe.com”);

Serial.println(“”);

Serial.println ( verzondenBytesWrite);

int verzondenBytesPrint = Serial.println ( “GameGoeroe.com”);

Serial.println ( verzondenBytesPrint);

a++

}

 

 

output:

GameGoeroe.com

 14

GameGoeroe.com

16

 

 

 

Betekenis:

Dit commando leest de tekens van de seriële monitor naar een lijst. Deze lijst of ‘buffer’ is van het type ‘char’ of ‘byte’. Het commando eindigt wanneer de vooraf gekozen lengte gehaald wordt of de pauze doorlopen werd. Bij Serial.readBytesUntil(); is er nog een extra voorwaarde. Dit commando zal ook beëindigen wanneer hij het vooraf gekozen teken tegenkomt is de binnen gelezen data.

Context:

Serial.readBytes( lijst , lengte );

Serial.readBytesUntil( teken , lijst , lengte );

Parameters:

teken = het teken, bijvoorbeeld ‘#’, waarnaar Arduino zoekt om het commando te beëindigen. 

lijst = de lijst waarin de data word opgeslagen. De lijst moet van het type char() of byte().

lengte = de maximale lengte van de data die zal worden opgeslagen.

Voorbeeldcode:

   char prijsGelezen[30];
   float bedrag;
   void setup() {
   Serial.begin ( 9600);
   }

   void loop() {

   Serial.println ( ” geef bedrag in euro’s , eindig met #”);
   Serial.setTimeout(200000) ;
   Serial.readBytesUntil(‘#’, prijsGelezen, 30) ;

   }

Notities:

Wanneer er een variabele gelijkgesteld wordt aan dit commando, dan zal de lengte van de ‘buffer’ gegeven worden.

Als je data wil lezen in een ‘String’, gebruik dan de commando’s Serial.readString(); en  Serial.readStringUntil();.

Dit commando slaat de data op in de vorm van ASCII-code. Echter de arduino kent slechts de basis ASCII-code ( 1-127), hierdoor kent het bijvoorbeeld het €-teken niet ( 128 ). Een overzicht van de ASCII-codes vindt je hier.

Betekenis:

Deze commando’s lezen een data van de seriële monitor in een ‘String’. Het commando eindigt wanneer de duur van de pauze doorlopen is. Serial.readStringUntil(); heeft een extra voorwaarde om te beëindigen. Dit commando zal ook beëindigen wanneer hij het vooraf gekozen teken tegenkomt is de binnen gelezen data.

Context:

Serial.readString(); 

Serial.readStringUntil( teken );

Parameters:

teken = het teken, bijvoorbeeld ‘#’, waarnaar Arduino zoekt om het commando te beëindigen. 

Voorbeeldcode:

   String prijsGelezen;
   float bedrag;
   void setup() {
   Serial.begin ( 9600);
   }

   void loop() {
   Serial.println ( ” geef bedrag in euro’s , eindig met #”);
   Serial.setTimeout(200000) ;
   prijsGelezen = Serial.readStringUntil(‘#’) ;

   Serial.println (” geaccepteerd”);
   bedrag = prijsGelezen.toFloat();
   delay (2000);
   Serial.println ( bedrag,2);

   }

Notities:

Bij Serial.readStringUntil(); wordt het teken waarnaar gezocht wordt om te beëindigen niet opgenomen in de ‘String’.

 Als je data wil lezen in een ‘char’ of een ‘byte, gebruik dan de commando’s Serial.readBytes(); en  Serial.readBytesUntil();.

Dit commando slaat de data op in de vorm van ASCII-code. Echter de arduino kent slechts de basis ASCII-code ( 1-127), hierdoor kent het bijvoorbeeld het €-teken niet ( 128 ). Een overzicht van de ASCII-codes vindt je hier.

Betekenis:

Dit commando bepaalt de maximale duur van de pauze, in milliseconden, bij het volgende Seriële data-commando. Zo zal bijvoorbeeld bij het volgende Serial.readbytes(); commando de bepaalde pauze ingaan. Dit commando gaat samen met Serial.readBytes(); , Serial.readBytesUntil(); , Serial.readString(); , Serial.readStringUntil(); , Serial.parselnt(); en Serial.parseFloat();.

Context:

Serial.setTimeout ( tijd );

Parameters:

tijd: duur van pauze in milliseconden

Voorbeeldcode:

   String prijsGelezen;

   float bedrag;

   void setup() {

   // Aangezien dat deze “loop” slechts eenmaal doorlopen wordt, declareer je hier jouw poorten.

   Serial.begin ( 9600);

   }

   void loop() {

   Serial.println ( ” Geef bedrag in euro’s , eindig met #.”);

   Serial.setTimeout(200000) ;

   prijsGelezen = Serial.readStringUntil(‘#’) ;

   Serial.println (” geaccepteerd”);

   bedrag = prijsGelezen.toFloat();

   delay  (2000);

   Serial.println ( bedrag,2);

   }

Betekenis:

Bij Serial.print(); wordt de opdracht in ASCII-weergave geschreven. Echter alle tekens van deze weergave hebben ook een code. Bijvoorbeeld de hoofdletter ‘G’ heeft als ASCII-code 71. Met Serial.write(); wordt de opdracht ingevoerd als ASCII-code en verschijnt als ‘normale’-weergave in de seriële monitor.

Context:

Serial.write( opdracht );

Serial.write( lijst , lengte);

Parameters:

opdracht = de ASCII-code die in ‘normale’-weergave geprint wordt.

lijst = Een lijst met ASCII-codes die geprint moeten worden. Deze lijst is een byte-type grote.

lengte = het aantal ASCII-codes van de lijst die geprint moeten worden.

Voorbeeldcode:

input:

 int a = 1;
 byte lijst [] = {71,97,109,101,71,111,101,114,111,101,46,99,111,109};

   // GameGoeroe.com in ASCII-code

void setup()

   {
   Serial.begin( 9600);    // start de seriële communicatie
   }

   void loop() {
   while ( a ==1){
   Serial.write( 71 );    // druk de letter met als ASCII-code 71
   Serial.println(“”);   // maak een spatie

   delay(2000);

   int verzondenBytes = Serial.write (“GameGoeroe.com”);   // druk GameGoeroe.com
   Serial.println(“”);   // maak een spatie
   Serial.println( verzondenBytes);   // print het aantal bytes

   delay(2000);

   Serial.write (lijst, 4);    // print de lijst tot de vierde waarde
   Serial.println (“”);   // maak een spatie
   Serial.write ( lijst, 14);   // print de lijst tot de viertiende waarde
   a ++;
   }
   }

 

 

output:

G

GameGoeroe.com

 14

Game

GameGoeroe.com

 

 

 

Notities:

Bij zowel Serial.print(); als Serial.write(); commando’s kan men het aantal doorgestuurde bytes opvragen. Echter bij Serial.print worden de twee aanhalingstekens (” “) meegerekend. Zo geeft “gamegoeroe.com” bij Serial.print(); een waarde van 16, terwijl deze maar 14 tekens telt.

Voorbeeldcode:

input:

 while ( a ==1){

   int verzondenBytesWrite = Serial.write (“GameGoeroe.com”);    
   Serial.println(“”);

   Serial.println( verzondenBytesWrite);

   int verzondenBytesPrint = Serial.println( “GameGoeroe.com”); 
   Serial.println ( verzondenBytesPrint); 
   a ++;
   }

 

 

output:

GameGoeroe.com

14

 

GameGoeroe.com

16

 

 

 

 

Betekenis:

We gebruiken dit commando om een ‘String’ om te vormen naar het datatype ‘float’ of ‘integer’. Wanneer de ‘String’ slechts opgebouwd is uit cijfers en een punt ‘.’ , dan zal deze bewerking het getal verkrijgen. 

Context:

onzeString.toFloat();

onzeString.toInt();

Parameters:

onzeString = een datatype ‘String’

Voorbeeldcode:

   String prijsGelezen;

   float bedrag;

   void setup() {

   // Aangezien dat deze “loop” slechts eenmaal doorlopen wordt, declareer je hier jouw poorten.

   Serial.begin ( 9600);

   }

   void loop() {

   Serial.println ( ” Geef bedrag in euro’s , eindig met #.”);

   Serial.setTimeout(200000) ;

   prijsGelezen = Serial.readStringUntil(‘#’) ;

   Serial.println (” geaccepteerd”);

   bedrag = prijsGelezen.toFloat();

   delay  (2000);

   Serial.println ( bedrag,2);

   }

Notities: 

De ‘String moet beginnen met een cijfer. Wanneer dit niet het geval is wordt er een nul teruggestuurd. Wanneer er andere tekens in de ‘String’ gevonden worden, dan worden deze weergegeven met een nul. Zo zal de ‘String’ ” 123Game” omgevormd worden naar ‘Float’ ” 123.00″.

De precisie van [String].toFloat();  is 6-7 cijfers. Langere lijsten zullen vereenvoudigd worden. [String].toInt(); zal alleen werken met getallen in het interval,[-32768 ; 32767]. van een integer.

Betekenis:

Dit commando paart met noTone();. De ene stopt namelijk wat de andere geactiveerd heeft.

Stuur a bloksignaal, zoals PWM, op een bepaalde frequentie naar de aangewezen pin. Het is mogelijk een tijdsinterval te bepalen. Wanneer er geen tijdsinterval gegeven wordt, blijft het commando gelden tot notone(); opgeroepen wordt.

Arduino kan maar één tone(); sturen. Dit wil zeggen dat het niet mogelijk is om twee pinnen op eenzelfde moment het commando tone(); te laten verwerken. Noch verschillende noch gelijke tone(); waarden. Wanneer het commando gestuurd wordt naar een pin die bezig is met het tone(); commando, dan wordt de frequentie aangepast aan het laatst geschreven commando.

Context:

tone(pin, frequentie);

tone( pin, frequentie, duur);

Parameters:

pin = het pinnummer of een variabele die eraan gelijkgesteld is.

frequentie = De variabele integer die de waarde van de frequentie in Hz bevat.

duur = de variabele long die de waarde van de periode in milliseconde bevat.

Voorbeeldcode :

   int buzzer =12;    // schakel de buzzer aan poort 12
   int knop =11;       // schakel de knop aan poort 11
   int knopStatus;

   void setup()

   {
   pinMode ( buzzer , OUTPUT);   // declareer de buzzer als OUTPUT
   pinMode ( knop , INPUT);          // declareer de knop als INPUT
   }
   void loop()

   {
   knopStatus = digitalRead ( knop );    // lees de waarde van de knop
   if ( knopStatus == HIGH){

   tone(buzzer , 1000);      // schrijf een toon naar de buzzer
   }
   else{
   noTone(buzzer);     // stop met de toon naar de buzzer te sturen
   }
   }

Notities:

Het is niet mogelijk om tonen te generen lager dan 31 Hz.

Het commando tone(); zal moeilijkheden opleveren bij de PWM output van pin 3 en 11. Dit geldt voor alle borden, behalve de Mega.

Als je wil een toon spelen op een andere poort, terwijl er al een poort het tone(); commando ontvangt, dan moet je eerst notone(); sturen naar deze pin om vervolgens het tone(); commando naar de nieuwe pin te sturen.

Commando's om je functie te beheersen:

Op onze sectie programmeeromgeving vindt je al de nodige uitleg over de ‘functie’. Toch zijn er codes waarin de functie iets extra nodig heeft. Met deze commando’s kan je je functies uitrusten met extra mogelijkheden die coderen veel aangenamer zullen maken. Zo kan je functies vroeger beëindigen, je voids iets laten terugsturen en het laatste deel van je functie even overlaten…

Betekenis:

Break beëindigt de functies for, while, do…while en swicht…case voordat de gekozen voorwaarde voldaan is. Dit commando verbreekt alleen deze functies, dus de if- en if-else-functies hebben hierin geen enkele invloed! Zo kan je in een for-functie een if-functie met ‘break’ coderen en alsnog het gewenste resultaat behalen. Bij een ‘break’ zal de arduino verwerker na dichtstbijzijnde acculades, die behoren tot boven genoemde functies, opnieuw starten met de code uit te voeren.

Context:

break;

Parameters:

Geen parameters.

 Voorbeeldcode:

const int buzzer = 11;

const int sensor = A0;

int sensorWaarde = 0;

int i = 0;

 

void setup() {

  pinMode ( sensor , INPUT);

  pinMode ( buzzer , OUTPUT);

}

 

void loop() {

   for ( i = 100 ; i < 2500 ; i+100){

  sensorWaarde = analogRead ( sensor);

  if ( sensorWaarde > 800){

    break;

  }

  tone ( buzzer,i );

 }

}

Notities:

Het is belangrijk te weten dat er een groot verschil is tussen break; en return;! Bij break; ‘breek’ je uit de code om daarna weer verder te gaan, bij return; keer je helemaal terug! Dit levert vaak een totaal verschillende output op:
 

int a = 1;
int i = 0;
int p = 0;
void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println( ” * “);
if ( a == 1){
Serial.println(” % “);
for ( i= 0; i < 3; i++){
Serial.println(” – “);
for ( p = 0; p < 3; p++){
Serial.println ( ” + “);
return;
}
Serial.println(” ++ “);
return;
}
Serial.println( ” +++ “);
}
a = 2;
}

 

 

output:

 

*

%

+

*

%

+

 

Door gebruik te maken van return krijgen we een oneindige output. Dit komt omdat ” a = 2;” nooit gelezen zal worden. Alles na de eerste return; zal nooit gelezen worden! Merk ook op dat elk teken slechts eenmaal voorkomt in de reeks, de for-loops worden dus ook slechts steeds eenmaal doorlopen. 

int a = 1;
int i = 0;
int p = 0;
void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println( ” * “);
if ( a == 1){
Serial.println(” % “);
for ( i= 0; i < 3; i++){
Serial.println(” – “);
for ( p = 0; p < 3; p++){
Serial.println ( ” + “);
break;
}
Serial.println(” ++ “);
break;
}
Serial.println( ” +++ “);
}
a = 2;
}

 

 

output:

 

*

%

+

++

+++

 

Met break; hebben we een eindige reeks waarin elk teken, ook de meerdere plussen, steeds eenmaal voorkomen.

Betekenis:

Met continue kun je de rest van de code in je functie overslaan. De verwerker zal dan direct terugkeren naar naar de functie om de voorwaarde opnieuw te controleren. Mocht deze voldaan zijn, dan zal de verwerker weer starten met het uitvoeren van de functie. Dit commando werkt slechts bij functie met herhaling, de for-, while- en do…while-functie dus.

Wanneer de dit commando geactiveerd wordt zal elk volgende regel die behoort tot de functie deze verwerking niet worden uitgevoerd. De verwerker stopt als het ware en begint opnieuw met het verwerken van de functie. Dit commando is dus zeker niet hetzelfde als break; of return;.

Context:

continue;

Parameters:

Geen parameters.

Voorbeeldcode:

const int buzzer = 11;

const int sensor = A0;

int sensorWaarde = 0;

int i = 0;

 

void setup() {

  pinMode ( sensor , INPUT);

  pinMode ( buzzer , OUTPUT);

}

 

void loop() {

   for ( i = 100 ; i < 2500 ; i+100){

  sensorWaarde = analogRead ( sensor);

  if ( 300 <= i <= 600){

    continue;

  }

  tone ( buzzer,i );

 }

}

Betekenis:

return kan gebruikt worden om uit een code te ontsnappen en optioneel een waarde terug te sturen. return zal altijd terug keren naar de uiterste acculades waarin hij zich bevindt. Wanneer je ‘return’ gebruikt in je void loop, dan zal deze ervoor zorgen dat je verwerker terug zal starten bij het begin van de void loop, ongeacht hoe lang de code nog was. Wanneer je met ‘return’ een waarde wil terugsturen, dan mag deze zich , op het hoogste niveau, niet bevinden in een void. Deze moet dan gecodeerd worden in een byte, int, long of float.

Context:

return;

return waarde;

Parameters:

waarde = de waarde dat terug gestuurd moet worden.

Voorbeeldcode:

int i = 0;

 

void setup() {

  // put your setup code here, to run once:

Serial.begin ( 9600);

}

 

void loop() {

  // put your main code here, to run repeatedly:

for ( i; i< 3; i++){

  Serial.println ( uitkomst());

}

}

 

int uitkomst (){

  switch ( i ){

  case 0: 

  return 10;

  case 1:

  return 15;

  case 2:

  return 20;

}

}

Notities:

Het is belangrijk te weten dat er een groot verschil is tussen break; en return;! Bij break; ‘breek’ je uit de code om daarna weer verder te gaan, bij return; keer je helemaal terug! Dit levert vaak een totaal verschillende output op:
 

int a = 1;
int i = 0;
int p = 0;
void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println( ” * “);
if ( a == 1){
Serial.println(” % “);
for ( i= 0; i < 3; i++){
Serial.println(” – “);
for ( p = 0; p < 3; p++){
Serial.println ( ” + “);
return;
}
Serial.println(” ++ “);
return;
}
Serial.println( ” +++ “);
}
a = 2;
}

 

 

output:

 

*

%

+

*

%

+

 

Door gebruik te maken van return krijgen we een oneindige output. Dit komt omdat ” a = 2;” nooit gelezen zal worden. Alles na de eerste return; zal nooit gelezen worden! Merk ook op dat elk teken slechts eenmaal voorkomt in de reeks, de for-loops worden dus ook slechts steeds eenmaal doorlopen. 

int a = 1;
int i = 0;
int p = 0;
void setup() {
Serial.begin(9600);
}

void loop() {
Serial.println( ” * “);
if ( a == 1){
Serial.println(” % “);
for ( i= 0; i < 3; i++){
Serial.println(” – “);
for ( p = 0; p < 3; p++){
Serial.println ( ” + “);
break;
}
Serial.println(” ++ “);
break;
}
Serial.println( ” +++ “);
}
a = 2;
}

 

 

output:

 

*

%

+

++

+++

 

Met break; hebben we een eindige reeks waarin elk teken, ook de meerdere plussen, steeds eenmaal voorkomen.

Arduino commando's voor interrupts:

Interrupts zijn iets zeer speciaal en delicaat om mee te werken. Het is een stuk code die namelijk veel invloed kan hebben op de rest van je programma en het zo helemaal in de war sturen! Het ergste: je zal het nooit merken! Wanneer we interrupts in arduino gebruiken moeten we dus zeer voorzichtig zijn! Hier zetten we alle Arduino commando’s eens op een rij die je kunt gebruiken bij het werken met interrupts. We bespreken attachInterrupt(); , detachInterrupt(); , interrupts(); , noInterrupts(); en volatile. De laatste genoemde is geen commando, maar een extra voorwaarde bij het declareren bij je woorden, vergelijkbaar met const. Maar hier hebben we het later uitgebreider over!

De interrupt service routine:

Een interrupt is in feite een tweede void loop die naast je hoofdcode verwerkt word. We noemen deze speciale void de ISR: interrupt service routines. Deze ISR heeft wel een aantal voorwaarden:

  • Deze void mag geen parameters hebben! Deze void is dus steeds gewoon een verkorting van een deel code.

Niet correct

Correct

void ISR ( led1 , led 2){

// code

}

void ISR (){

// code

}

  • Deze loop mag niets terugsturen.

Niet correct

Correct

void ISR (){

// code

Return 4  // voorbeeld: stuur 4 terug.

// code

}

void ISR (){

// code

}

 

 

  • De code is best zo kort mogelijk.
  • Omdat deze commando’s steunen op interrupts om hun functie te vervullen zullen deze foutieve waarde geven:
  • millis();
  • delay();
  • micros();
  • Het enigste tijdcommando dat werkt in een ISR is dus delayMicroseconds();
  • Wanneer er variabelen zowel in de ISR als in de void loop gebruikt worden, dan moeten ze gedeclareerd worden als ‘volatile’.

De functie van interrupts:

Wanneer het noodzakelijk is dat arduino altijd, constant een poort controleert omdat dat hij nooit mag missen wat er daar gebeurt, dan komen interrupts aan de pas. Een lange code programmeren die steeds, elke lijn, een poort controleert zou anders onmogelijk zijn! In welke code zou je dit ooit moeten gebruiken zie ik u denken. Wel, een noodstop is zeker een voorbeeld, ook wanneer je een sensor programmeert dat een korte verandering moet opvangen: bijvoorbeeld een geluidsensor die een enkele klik moet registeren…

Interrupts zijn dus onmisbaar in sommige, zeer specifieke codes, echter zonder deze commando’s zal het je niet lukken! Zonder meer geklets, laten we eraan beginnen!

Betekenis:

Het eerste wat dit commando doet is duidelijk maken aan de arduino dat er een interrupt-functie moet toegevoegd worden aan een pin. Deze pin wordt in de void setup als INPUT_PULLUP  gedeclareerd.Ook bepaal je met dit commando wat hij moet doen wanneer de interrupt geactiveerd word en tot slot wanneer hij de interrupt moet activeren.

Dit commando wordt gecodeerd in de void setup.

Context:

attachInterrupt ( digitalPinToInterrupt ( poort ), ISR , modus);

Parameters:

digitalPinToInterrupt is een commando dat onze digitale poorten, de poorten die wij gebruiken in onze code, omzet in de interrupt waarde van die poort.

poort = de digitale poort waaraan je interrupt geschakeld is.

ISR = de naam van de void dat je ISR code bevat.

modus = bepaalt wanneer de interrupt geactiveerd moet worden.

          LOW = wanneer de pin low is.

          CHANGE = wanneer de waarde van de pin verandert, wordt gebruikt bij sensoren.

          RISING = wanneer de pin van LOW naar HIGH gaat.

          FALLING = wanneer de pin van HIGH naar LOW gaat.

          Alleen op arduino due, zero en MKR1000 borden:

o   HIGH: wanneer de pin HIGH is. Bij de andere poorten word dit vaak verandert in RISING.

Voorbeeldcode:

// Deze code zal ervoor zorgen dat steeds wanneer de sensor, analoge of digitale, die aangesloten is op poort 2 van waarde verandert, de led ook verandert van stand.

const int ledRood = 12;

const int interruptPoort = 2;

volatile int statusLed = LOW;

void setup() {

pinMode ( ledRood, OUTPUT);

pinMode ( interruptPoort, INPUT_PULLUP);

attachInterrup ( digitalPinToInterrup ( interruptPoort) , knipper , CHANGE);

}

void loop(){

digitalWrite ( ledRood, statusLed);

delay ( 2000 );

}

void knipper(){

statusLed =! statusLed;

}

Notities: 

Niet alle poorten zijn geschikt om een interrupt op te bevestigen. Dit is een overzicht van de geschikte poorten van elke arduino bord. Standaard gebruiken we een arduino uno bord.

BOARD

DIGITAL PINS USABLE FOR INTERRUPTS

Uno, Nano, Mini en andere 328-gebaseerde borden

2, 3

Uno WiFi Rev.2

Alle digitale poorten

Mega, Mega2560 en MegaADK

2, 3, 18, 19, 20, 21

Micro, Leonardo en andere 32u4-gebaseerde borden

0, 1, 2, 3, 7

Zero

Alle digitale poorten, behalve 4.

MKR Family boards

0, 1, 4, 5, 6, 7, 8, 9, A1, A2

Due

Alle digitale poorten.

101

all digital pins (Alleen poorten 2, 5, 7, 8, 10, 11, 12, 13 werken met de modus CHANGE)

Betekenis:

Verwijdert de interrupt op een pin.

Context:

detachInterrupt ( digitalPinToInterrupt ( poort) );

Parameters:

digitalPinToInterrupt is een commando dat onze digitale poorten, de poorten die wij gebruiken in onze code, omzet in de interrupt waarde van die poort.

poort = de digitale poort waarop de interrupt toegevoegd is.

Voorbeeldcode:

interruptPoort = 2;

int status;

void setup() {

pinMode ( interruptPoort, INPUT_PULLUP);

attachInterrup ( digitalPinToInterrup ( interruptPoort) , knipper , CHANGE);

}

void loop(){

detachInterrupt( digitalPinToInterrupt ( interruptPoort));

}

void knipper(){

status = ! status ;

}

Notities: 

Niet alle poorten kunnen interrupts verwerken. Zie attachtInterrupt(); voor een overzicht.

Betekenis:

Zet interrupts respectievelijk aan en uit in je code. Bepaalde commando’s gebruiken interrupts om hun functie te vervullen. Ook sommige inkomende communicatie maakt standaard gebruik van interrupts. Daarom is het standaard ingeschakeld. Echter interrupts draaien op de achtergrond in je processor en kan zo een zeer kleine impact hebben op de timing van je code. Daarom kan het uitgeschakeld worden in tijd-sensitieve delen van de code.

Context:

interrupts();

noInterrupts();

Parameters:

Er zijn geen parameters.

Voorbeeldcode:

void setup(){

}

void loop (){

noInterrupts();

// tijd-sensitieve code

interrupts();

// code

}

Betekenis:

Volatile is een bijkomende declaratie voor een variabele. Deze declaratie is het best vergelijkbaar met ‘const’. Uiteraard heeft deze een anderen functie! 

Wanneer een variabele gedeclareerd is als ‘volatile’ wordt deze niet meer is de opslag van de arduino opgeslagen, maar bij de bron, namelijk in de RAM zelf. Variabelen moeten gedeclareerd worden als ‘volatile’ wanneer de waarde ervan kan veranderen zonder je hoofdcode dat gevraagd heeft. Bij arduino kan dit slechts bij het werken met interrupts en dat slechts wanneer een variabele zowel in de ISR als de void loop gebruikt wordt!

Context:

volatile grootte variabele;

Parameters:

grootte = de grootte van je variabele : byte, int of long.

variabele = de naam van je variabele.

Voorbeeldcode:

// Deze code zal ervoor zorgen dat steeds wanneer de sensor, analoge of digitale, die aangesloten is op poort 2 van waarde verandert, de led ook verandert van stand.

const int ledRood = 12;

const int interruptPoort = 2;

volatile byte statusLed = LOW;

void setup() {

pinMode ( ledRood, OUTPUT);

pinMode ( interruptPoort, INPUT_PULLUP);

attachInterrup ( digitalPinToInterrup ( interruptPoort) , knipper , CHANGE);

}

void loop(){

digitalWrite ( ledRood, statusLed);

delay ( 2000 );

}

void knipper(){

statusLed =! statusLed;

}

Notities: 

Onze arduino heeft een 8-bit processor. Dit wil zeggen dat de arduino de code zal lezen in stukken van 8 bits! Dit kan echter problemen oplever in onze code, problemen die je volledige code in het honderd laten lopen. Bij een ‘byte’ hebben we geen problemen: een byte is 8 bits dus zal in één keer gelezen worden door de void loop. Bij ‘int’ en ‘long’ zal de arduino echter meerdere malen eenzelfde variabele moeten verwerken. Hier kunnen problemen optreden! De ISR kan namelijk de variabele veranderen terwijl de void loop de eerste 8 bits al gelezen heeft, maar de tweede niet! Zo krijg je foutieve waarden en loopt je hele code in de war.

Bij HIGH, LOW en getallen in het interval [0 , 255] is er dus geen probleem. Dan raden we jullie ook aan om deze variabele gewoonweg te declareren als ‘byte’. Bij ‘int’ of ‘long’ zal je de interrupts moeten uitschakelen voordat je de waarde leest. Dit kan met de commando’s noInterrupts(); en interrupts();.

// Deze code zal ervoor zorgen dat steeds wanneer de sensor, analoge of digitale, die aangesloten is op poort 2 van waarde verandert, de led ook verandert van stand.

const int ledRood = 12;

const int sensor = 11;

const int interruptPoort = 2;

volatile int sensorWaarde = 0;

void setup() {

pinMode ( ledRood, OUTPUT);

pinMode ( interruptPoort, INPUT_PULLUP);

attachInterrup ( digitalPinToInterrup ( interruptPoort) , uitschakelen , LOW );

}

void loop(){

noInterrupts();

sensorWaarde = analogRead ( sensor );

interrupts();

analogWrite ( ledRood, sensorWaarde);

delay ( 2000 );

}

void knipper(){

sensorWaarde = 0;

}

Wiskundige Arduino commando's:

Wiskundige commando's

Hier vindt u een overzicht van rekenkundige Arduino commando’s. Arduino kan namelijk meer dan alleen de basisbewerkingen: optellen, verminderen, vermenigvuldigen en delen. Men kan net zo goed rekenen in Arduino als in excel! De meeste van deze Arduino commando’s werken steeds met een referentiewaarde , een constante, en een variabele. In de voorbeeldcodes zullen we echter steeds werken met twee constanten, dit doe we omdat het resultaat van de bewerking zo vaststaat en dus uitgerekend kan worden.

De eenvoudigste bewerkingen hebben geen commando, maar een simpel, veelal zeer bekend, teken.

Optellen

+

3 + 2 = 5

Verminderen

3 – 2 = 1

Vermenigvuldigen

*

3 * 2 = 6

Delen

/

3 / 2 =  1.5

Betekenis:

Berekent de absolute waarde van een getal. Je gebruikt het commando fabs(); als je de absolute waarde van een float datatype wil nemen.

Context:

abs( getal);

fabs ( getal);

Parameters:

getal = het getal waarvan je de bewerking wilt nemen.

Antwoord:

Het getal zonder teken.

Voorbeeldcode:

uitkomst = abs ( 9 );  // = 9

uitomst = abs ( -9 );  // = 9

Notities:

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando.

Betekenis:

Beperk een getal tot een bepaalt interval met een minimale en maximale waarde.

Context:

constrain ( getal, min, max);

Parameters:

getal = het getal waarvan je de bewerking wilt nemen.

min = de minimumwaarde van het interval.

max = de maximumwaarde van het interval.

Antwoord:

Het getal als het getal in het interval ligt.

De minimumwaarde als het getal kleiner is dan het min van het interval.

De maximumwaarde als het getal groter is dan het max het interval.

Voorbeeldcode:

uitkomst = constrain ( 8, 5, 15);   // = 8

uitkomst = constrain ( 3, 5, 15)    // = 3

uitkomst = constrain ( 17, 5, 15)   // = 15

Notities:

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando.

Betekenis:

Verandert een getal van interval terwijl de verhoudingen worden gerespecteerd. Dit commando beperkt geen waarden, waarden buiten het eerste interval zal verhoudingsgewijs ook buiten het tweede interval liggen. Dit kunnen we bijvoorbeeld gebruiken om een sensor-waarde, die bijvoorbeeld altijd in het interval [0 ; 1023] ligt, om te vormen naar een getal in het interval [0, 255] zodat deze gebruikt kan worden voor analogWrite();.

Context:

map ( getal, eersteGrensLaag, eersteGrensHoog, tweedeGrensLaag, tweedeGrensHoog );

Parameters:

getal = het getal waarvan je de bewerking wilt nemen.

eersteGrensLaag = de laagste grens van het eerste interval.

eersteGrensHoog = de hoogste grens van het eerste interval.

tweedeGrensLaag = de laagste grens van het tweede interval.

tweedeGrensHoog = de hoogste grens van het tweede interval.

Antwoord:

Het getal in het nieuwe interval.

Voorbeeldcode:

uitkomst = map ( 6, 3, 9, 0, 3)   // = 1

Notities:

uitkomst = map ( 30, 1, 50, 50, 1);  // 21

De Laagste grens hoeft niet kleiner te zijn dan de hoogste grens van het interval! Zo kan dit commando ook gebruikt worden om getallen in een bepaald interval om te keren.

uitkomst = map ( 10, 5, 25, 30, -100);  // -2

Dit commando verwerkt ook prima intervallen afgesloten door negatieve getallen of door een combinatie van een positief en negatief getal.

 

Dit commando zal geen breuken vormen. Alle breuken worden gedeeld in een volwaardige breuk en een rest. De rest wordt dan onderdrukt en ‘weggegooid’. De breuken worden dus niet rekenkundig afgerond! Zo zal 5,9 niet 6, maar 5 worden. Mocht je toch breuken nodig hebben in je code, dan zal je de bewerking handmatig moeten maken met floats.

 

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando.

Betekenis:

De commando’s max(); en min(); kiezen telkens uit twee getallen respectievelijk de maximale en minimale waarde. Dit heeft uiteraard weinig zin met twee vooraf bepaalde getallen, maar wordt vaak gebruikt met één constante en één variabele.

Context:

max ( eersteGetal, tweedeGetal);

min ( eersteGetal, tweedeGetal);

Parameters:

eersteGetal = het eerste getal waarvan je de bewerking wilt nemen.

tweedeGetal = het tweede getal waarvan je de bewerking wilt nemen.

Antwoord:

Het gevraagde uiterste van de twee getallen, bij min(); het kleinste getal, bij max(); het grootste getal.

Voorbeeldcode:

uitkomst = max ( 9, 3);   // = 9

uitkomst = min( 9, 3);    // = 3

Notities:

Deze commando’s werken zoals gezegd met een variabele! In feite verplichten ze de variabele om zich te bevinden in een zelfgekozen halfopen interval.

Bewerking:

Interval:

min( variabele, 8);

[8 ; -[

max( variabele , 8);

[ 8 ; +[

In strijd met het begrip staat dus elke commando voor de andere grens van een interval! Zo staat de constante in het commando min(); voor de grootste, maximale, waarde van het interval. Ook in het commando max(); staat de constante in strijd met het commando, deze is namelijk de kleinste, minimale waarde van het interval.

 

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando.

Betekenis:

Het commando pow() neemt de macht, ‘power’, van een grondtal. Het commando sq(); neemt het kwadraat van een grondtal en sqrt(); de vierkantswortel. We gebruiken sqrtf() om de snel de vierkantswortel van een datatype float te nemen.

Context:

pow ( grondtal, exponent);

sq( grondtal );

sqrt( grondtal );

sqrtf ( grondtal);

Parameters:

grondtal = het getal waarvan je de bewerking wilt nemen, datatype float.

exponent = de macht dat je wil nemen van een getal, datatype float.

  • Omdat de exponent een breuk mag zijn kan men dus ook wortels nemen met dit commando! Zo heeft de vierkantswortel als exponent 1/2 , de derdemachtswortel 1/3 …

Antwoord:

Het getal verheven tot de macht.

Voorbeeldcode:

uitkomst = pow ( 2, 3 );   // = 8

uitkomst = pow ( 8,  );   // = 2

uitkomst = sq ( 2 );   // = 4

uitkomst = sqrt ( 4 );   // = 2

uitkomst = sqrtf ( 2,25 );   // = 1,5

Notities:

pow ( ‘getal’, 2); = sq ( ‘getal’ );

Als je eenvoudig het kwadraat wil weten van een getal, dan kan je ook het commando sq(); gebruiken. Dit commando is gelijk aan het commando pow(); met als exponent twee.

pow ( ‘getal’, 1/2  ); = sqrt ( ‘getal’);

 

Als je eenvoudig de vierkantwortel wil weten van een getal, dan kan je ook het commando sqrt(); gebruiken. Dit commando is gelijk aan het commando pow(); met als exponent  .

 

Merk op dat je dit commando kan gebruiken voor twee verschillende functies te maken. Men kan hiermee bijvoorbeeld de functie f(x) = x² mee maken, maar ook bijvoorbeeld f(x) =  .

 

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando. Breuken kan je wel direct in het commando schrijven.

Betekenis:

Dit zijn de trigonometrische bewerkingen. Ze nemen de sinus, de cosinus en de tangens van een  hoek uitgedrukt in radialen. 1 rad = 180/pi  °

Context:

sin ( hoek );

cos ( hoek );

tan ( hoek );

Parameters:

hoek = de hoek waarvan je de bewerking wilt nemen.

Antwoord:

De gevraagde waarde eigen aan de bepaalde hoek. Het antwoord van de commando’s cos(); en sin(); zullen steeds in het interval [-1 ; 1]

Voorbeeldcode:

uitkomst = sin ( PI/2 );    // = 1

uitkomst = cos ( 0 );    // = 0

uitkomst = tan ( PI/4 );    // = 1

Notities:

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando. Breuken kan je wel direct in het commando schrijven.

Betekenis:

Dit zijn de cyclometrische functies. Ze nemen de arcsinus ( boogsinus ), arccosinus ( boogcosinus) en de arctangens ( boogtangens ) van een getal.

Context:

asin( getal );

acos( getal );

atan( getal);

atan2 ( teller, noemer);

Parameters:

getal = de hoek waarvan je de bewerking wilt nemen.

teller = de teller van de breuk waarvan de arctan genomen wordt.

noemer = de noemer van de breuk waarvan de arctan genomen wordt.

Antwoord:

Het getal die overeenkomt met de gevraagde sin, cos of tan. De getallen liggen wel steeds in een interval.

asin(); = [ -pi/2 ;  pi/2 ]

acos(); = [0 ; 1]

atan = [ -pi/2 ; pi/2 ]

Voorbeeldcode:

uitkomst = asin ( 1 );   // = pi/2

uitkomst = acos( 1 );    // = 0

uitkomst = atan ( 1 );    // = pi/4

uitkomst = atan ( 3 , 2 );    // = 0,98  / = tan ( 3/2 )

Notities:

Het getal bij de commando’s sin(); en cos(); moet in het interval [-1 ; 1]

 

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando. Breuken kan je wel direct in het commando schrijven.

Betekenis:

Berekend de rest bij een deling. fmod(); gebruiken we bij een deling met kommagetallen, datatype float dus.

Context:

fmod ( teller , noemer);

teller % noemer

Parameters:

teller = teller van de breuk waarvan je de rest wil bepalen.

noemer = noemer van de breuk waarvan je de rest wil bepalen.

Antwoord:

De rest van de breuk.

Voorbeeldcode:

uitkomst = 7 % 5 ;   // = 2

uitkomst = -4 % 5;   // = -4

uitkomst = fmod ( 2.8 , 2);   // = 0.8

Notities:

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando. Breuken kan je wel direct in het commando schrijven.

Betekenis:

Deze commando’s nemen het logaritme van een getal. Het commando log(); neemt het natuurlijk logaritme, neperiaanse logaritme, van het getal. Dit is het logaritme met als basisgetal e. log10(); neemt de tiende log van een getal.

Context:

log ( getal );

log10 ( getal);

Parameters:

getal = het getal waarvan je de bewerking wilt nemen.

Antwoord:

Het logaritme van het getal.

Voorbeeldcode:

e = 2.7182818284590452354;

uitkomst = log ( e );   // = 1

uitkomst = log10 ( 100 );   // = 2

uitkomst = log ( 25 )/ log ( 5 );   // = 2  //  = log5 ( 25);

Notities:

Als je een andere log wil nemen, gebruik de formule: logX ( getal ) = logY ( getal ) / logY ( X)

Zo kan je door gebruik te maken van twee log(); of log10(); commando’s een log nemen met een zelfgekozen basisgetal.

Vermijd ander bewerking tussen de haakjes. Als het getal andere bewerking moet ondergaan, maak deze dan voor het oproepen van dit commando.

Dit was onze complete lijst met Arduino commando’s. Als je extra informatie wilt omtrent een bepaald commando of een commando wilt zien toegevoegd worden aan de lijst, aarzel dan zeker niet om ons te contacteren!

Introductie Arduino:

 Leer hier hoe je zelf kan beginnen met coderen in Arduino!