Op de pagina's Digital OUT/IN en Analog IN/OUT hebben jullie de basis gezien die je nodig hebt om een eenvoudig programma te maken met Arduino.
Regelmatig zal je echter op moeilijkere uitdagingen botsen waarbij die basis niet meer voldoende is. Op deze pagina verzamelen we mogelijkheden van Arduino die van pas kunnen komen bij zo'n uitdagingen die we in de klas tegenkomen.
In je Arduino code kan je voor je variabelen gebruik maken van uiteenlopende datatypes. Jullie zijn gewoon om met int en float te werken, maar er zijn er nog heel wat meer. Ga regelmatig eens kijken in de Arduino reference als je twijfelt over de mogelijkheden van een datatype.
Hieronder vinden jullie al enkele datatypes die in jullie code van pas kunnen komen. In de Arduino reference vind je ze allemaal.
Niet elk board heeft dezelfde mogelijkheden. We nemen hier de mogelijkheden van de Uno als basis.
boolean
In Arduino best 'bool'schrijven. Dit is een variabele die slechts 2 waarden kan aannemen 'true' of 'false' (1 of 0). Daarvoor is maar één bit nodig.
int
Een int kan een positief of negatief getal tussen -32.768 en 32767 bevatten zonder decimalen. Hiervoor worden 16 bits (2 bytes) vrijgehouden.
unsigned int
Dit is een int die enkel positieve getallen mag bevatten. Hierdoor kan hij wel getallen bevatten tussen 0 en 65.535.
float
Een float kan een positief of negatief getal bevatten met cijfers achter de komma. Hiervoor worden 32 bits (4 bytes) vrijgehouden.
long
Een long is vergelijkbaar met een int. Omdat hier meer ruimte wordt vrijgehouden (4bytes) kan hij ook veel groter zijn dan een int: van -2.147.483.648 tot 2.148.483.647.
unsigned long
Dit is een long die enkel positieve getallen mag bevatten. Hierdoor kan hij getallen bevatten tussen 0 en 4.294.967.295.
In een programma laat je dingen gebeuren als reactie op bepaalde veranderingen. Die verandering worden in je programma vastgesteld met een test waarbij je gaat kijken naar de waarde/toestand van een bepaalde variabele. Dat ziet er bijvoorbeeld zo uit:
if(potval >= 125) {
digitalWrite (LedR, HIGH) ;
}
De vergelijkingen die je hiervoor kan gebruiken zijn:
== (is gelijk aan)
!= (is niet gelijk aan)
< (is kleiner dan)
> (is groter dan)
<= (is kleiner of gelijk aan)
>= (is groter of gelijk aan)
Let op: vaak worden vergissingen gemaakt door in een vergelijking een enkel = teken te gebruiken ipv ==.
In plaats van een test uit te voeren geef je op die manier die variabele een bepaalde waarde.
Bij een test kan je rekening houden met meerdere factoren. Bijvoorbeeld:
if (potval1 >=125 && potval2 >=250)... //hier moet aan beide voorwaarden voldaan zijn
if (potval1 >=125 || potval2 >=250)... //hier moet aan één van de voorwaarden voldaan zijn
Om bewerkingen te maken binnen Arduino kan je gebruik maken van dezelfde tekens als bij Processing: +, -, /, *
Jullie hebben al vaak gebruik gemaakt van de delay functie. Hiermee laat je een programma even wachten. De parameter na de delay functie geeft aan hoe lang je programma op een bepaald punt moet wachten in 1/1000 van een seconde.
Wil je werken met Microseconden, dan gebruik je delayMicroseconds ();
Bij Arduino hebben we geen klok die de tijd bijhoudt voor ons. Wanneer je echt een klok nodig hebt, kan je wel een klokmodule gebruiken.
Toch kan je op je Arduino wel een tijdmeting doen. Je Arduino houdt immers bij hoe lang een programma al draait. Dat wordt standaard gemeten in millis (1/1000 van een seconde).
Je kan het vergelijken met een loper op een atletiekpiste met een defecte chronometer. Die wil graag de tijd van zijn rondes meten maar de chronometer kan niet op 0 gezet worden. De loper kan dus enkel tussentijden meten.
Toch vindt hij een oplossing: wanneer hij begint te lopen en de eerste tussentijd meet, en op het einde van zijn ronde de tweede tussentijd meet, dan kan hij precies berekenen hoe lang hij over zijn ronde gedaan heeft door de tweede tussentijd af te tellen van de eerste tussentijd.
Hieronder zie je een schakeling en de code om dit idee te testen. Om het eenvoudig te houden wordt hieronder gewoon gemeten hoe lang de drukknop werd ingedrukt.
Unsigned long: Je merkt dat hier gebruik wordt gemaakt van een 'unsigned long'.
Je kan dit vergelijken met een int. Voor een int worden in het geheugen van het programma 16 bits vrijgehouden. Dat maakt dat een int van -32.768 tot hoogstens 32.767 kan gaan.
Je kan ook een unsigned int gebruiken. Dat is een decimaal getal dat enkel positief kan zijn. Je unsigned int kan dan tot 65.535 gaan.
Voor een unsigned long worden 32 bits vrijgehouden in het geheugen. Daardoor kan die tot 4.294.967.295 gaan.
Door de snelle telling met onze millis zitten we al na 1 seconde aan 1000. Vandaar dat we hier een 'unsigned long' gebruiken. Hiermee kunnen we ongeveer 50 dagen de telling bijhouden. Daarna springt de telling van onze millis weer op 0 om opnieuw te beginnen.
Met de 'random' functie vraag je je Arduino om een willekeurige getalwaarde te geven tussen een minimum en maximum waarde. In dit voorbeeld laten we een getal verschijnen tussen 10 (de 10 is meegerekend) en 20 (de twintig is niet meegerekend). Elke seconde zal een getal verschijnen op een nieuwe lijn.
De functie random(10,20) genereert dus één van deze cijfers: 10,11,12,13,14,15,16,17,18,19
Rechts naast de code zie je twee opeenvolgende resultatenreeksen. Daar valt iets vreemds op. Door de manier waarop Arduino 'random' getallen maakt, krijg je met dezelfde code ook steeds dezelfde reeks.
Door in void setup de regel randomSeed(analogRead(0); toe te voegen kunnen we wel een onvoorspelbare reeks maken. Onze Arduino zal dan kijken naar de ruis op pin 0 om de getallen te bepalen. Er mag dan wel niets aangesloten worden op pin 0. Je mag hier eender welke analoge IN pin gebruiken die niet voor iets anders wordt gebruikt.
Naast de tweede code zie je opnieuw twee testen die nu wel een onvoorspelbare reeks geven.