Eelco: /* Vergelijkingsoperatoren */

2016-05-25T08:17:45Z

Vergelijkingsoperatoren

← Oudere versie		Versie van 25 mei 2016 10:17
Regel 178:		Regel 178:
	x <= y // at most		x <= y // at most
	</syntaxhighlight>		</syntaxhighlight>

			Let op: voor het vergelijken van 2 waarden gebruik je <code>==</code>. Als je een enkele <code>=</code> gebruikt, betekent dit toekenning. Je krijgt hiervoor meestal geen waarschuwing van de compiler, maar je programma doet niet wat je bedoelt.

	=== Logische operatoren ===		=== Logische operatoren ===

Eelco: /* if */

2016-05-25T08:16:02Z

← Oudere versie		Versie van 25 mei 2016 10:16
Regel 232:		Regel 232:


	Een verkorte vorm van het if-statement gebruik je als "opdracht2" leeg is: er hoeft in het else-geval niets gedaan te worden:		Een verkorte vorm van het if-statement gebruik je als <code>opdracht2<code> leeg is: er hoeft in het else-geval niets gedaan te worden:
	<syntaxhighlight lang="cpp">		<syntaxhighlight lang="cpp">
	if (conditie) {		if (conditie) {

Eelco: /* if */

2016-05-25T08:15:11Z

@@ Regel 201: / Regel 201: @@
 === if ===
 Het if-statement heeft de vorm:
@@ Regel 241: / Regel 221: @@
 Een voorbeeld van een conditie is: <code>ledState == HIGH</code>. Het teken <code>==</code> staat voor "is gelijk aan". Deze vergelijking heeft <code>true</code> als resultaat wanneer <code>ledState</code> gelijk is aan <code>HIGH</code>; in alle andere gevallen is het resultaat <code>false</code>.
 Een verkorte vorm van het if-statement gebruik je als "opdracht2" leeg is: er hoeft in het else-geval niets gedaan te worden:
@@ Regel 246: / Regel 236: @@
 if (conditie) {
    opdracht1;
+}
 </syntaxhighlight>

Eelco: /* if */

2016-05-25T08:13:40Z

@@ Regel 222: / Regel 222: @@
 } else {
    ledState = LOW;
+}
 </syntaxhighlight>

Eelco: Nieuwe pagina aangemaakt met ' == Sketch: setup, loop == void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(1000); digitalW...'

2016-05-25T08:10:16Z

Nieuwe pagina aangemaakt met ' == Sketch: setup, loop == <syntaxhighlight lang="cpp"> void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(1000); digitalW...'

Nieuwe pagina

== Sketch: setup, loop ==

<syntaxhighlight lang="cpp">
void setup() {
pinMode(13, OUTPUT);
}

void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
</syntaxhighlight>

Een Arduino-programma of "sketch" bevat, naast allerlei andere definities, twee functie-definities:
* <code>setup</code>: wordt eenmaal uitgevoerd, bij het opstarten van het programma
** deze functie gebruik je voor het initialiseren van de pinnen en andere interfaces;
* <code>loop</code>: wordt herhaald uitgevoerd (totdat de Arduino uitgezet wordt, of herstart).
** het eigenlijke programma: een niet-eindigende herhaling.

Dit zijn beide functies zonder resultaat; het woordje <code>void</code> geeft aan dat het resultaat "leeg" is. (Zie functies.)
Deze functies hebben ook geen parameters.

Het "main" programma van de Arduino kun je je als volgt voorstellen:
<syntaxhighlight lang="cpp">
setup();
while (true) {
loop();
}
</syntaxhighlight>

== Commentaar ==

<syntaxhighlight lang="cpp">
x = 12; // this is comment
</syntaxhighlight>

* commentaar begint met <code>//</code> en eindigt aan het eind van de regel;
* commentaar gebruik je om de lezer van het programma te helpen;
* voor de computer heeft dit commentaar geen betekenis.

== Functie met resultaat ==

<syntaxhighlight lang="cpp">
int sqr(int x) { // function definition
return x * x;
}

y = sqr(x + 1); // function call
</syntaxhighlight>

<syntaxhighlight lang="cpp">
int max(int a, int b) { // function definition
if (a >= b) {
return a;
} else {
return b;
}
}

x = max(x - 15, 0); // function call
</syntaxhighlight>

* een functiedefinitie begint met het type van het resultaat; in deze voorbeelden: <code>int</code>, ofwel integer.
** een <code>int</code>-waarde is een geheel getal (meestal een 16-bits getal, in het bereik -32768..32767).
* dan: de naam van de functie
** deze kun je zelf kiezen; gebruik een naam met een duidelijke betekenis;
* de parameters, tussen <code>()</code>; elke parameter heeft een type en een naam (als een variabele);
* de body, tussen <code>{}</code>; deze bevat de opdrachten (statements) voor het uitrekenen van het functieresultaat
** de opdracht <code>return expr;</code> zorgt ervoor dat de waarde van de expressie als functieresultaat opgeleverd wordt;
** deze opdracht beëindigt de functie: de verwerking wordt voortgezet ("keert terug") op de plaats van de aanroep.

* de aanroep (gebruik) van een functie in een expressie bestaat uit de naam van de functie gevolgd door de parameters tussen haakjes;
* deze parameters zijn expressies;

== Functie zonder resultaat ==

<syntaxhighlight lang="cpp">
void fname(type1 par1, type2 par2) {
statementx(par1 + 11, par2);
statementy(par2, 42);
}

void ledOn(int pin) {
digitalWrite(pin, HIGH);
}

ledOn(ledR);
ledOn(ledG);
</syntaxhighlight>

* de '''definitie''' van een functie zonder resultaat begint met <code>void</code>
** het woordje <code>void</code> geeft aan dat het functieresultaat "leeg" is;
* daarna: de naam van de functie
** gebruik een functienaam met een duidelijke betekenis;
* dan: de parameters, tussen <code>()</code>
** gebruik parameternamen met een duidelijke betekenis;
* tenslotte: de body met de opdrachten tussen <code>{}</code>.
* een functie zonder resultaat gebruik je voor het effect van de opdrachten (statements) in de body;

De '''aanroep''' van een functie noteer je als de naam van de functie met daarachter de parameter-waarden tussen haakjes
* bijvoorbeeld: <code>digitalWrite(led, HIGH)</code>

Wat is de betekenis van een aanroep van de functie <code>ledOn(ledR);</code>?
* je kunt de parameters als lokale variabelen van de functie beschouwen;
* deze variabelen worden geïnitialiseerd met de parameter-waarden (expressies) in de aanroep;
** <code>int pin = ledR; </code>
* de opdrachten in de body van de functie worden uitgevoerd:
** <code> digitalWrite(pin, HIGH); </code>
* daarna is de functie klaar en gaat de verwerking verder op de plaats van aanroep.

== Variabele, declaratie, initialisatie ==

<syntaxhighlight lang="cpp">
int led = 13;

unsigned long now = millis();
</syntaxhighlight>

Een variabele koppelt een naam aan een waarde. In de loop van het programma kun je een variabele koppelen aan een nieuwe waarde (toekenning).

Voordat je een variabele kunt gebruiken, moet je deze declareren: je geeft dan het type van de variabele, de naam, en soms een beginwaarde (initialisatie).
* <code>int</code> - type van de variabele; "int" staat voor integer: geheel getal (typisch: 16 bits getal, -32768..32767)
* <code>led</code> - naam van de variabele. Gebruik namen met een duidelijke betekenis.
* <code>13</code> - de beginwaarde van de variabele.

Het type van een variabele geeft aan welk soort waarden deze variabele kan aannemen. Dit kan gebruikt worden om te bepalen hoeveel geheugenruimte er nodig is voor de variabele. Je kunt foutmeldingen krijgen als je een operatie op een variabele probeert uit te voeren die niet voor dat type gedefinieerd is.

=== Variabele: gebruik in expressie ===

Je kunt daarna de naam van een variabele gebruiken in een uitdrukking (expressie). Voor het uitrekenen van die uitdrukking wordt dan waarde gebruikt die op dat moment gekoppeld is aan de variabele.

=== Toekenning (assignment) ===

<syntaxhighlight lang="cpp">
x = 13;
x = (y + 12) * z;
x = x + 12;
x += 12;
ledStatus = HIGH;
ledStatus = 1 - ledStatus;
ledRedStatus = 255 - ledGreenStatus;
ledStatus = min(ledStatus + 15, 255);
</syntaxhighlight>

Door middel van een toekenning, met het teken <code>=</code>, koppel je een nieuwe waarde aan een variabele.

Voorbeeld: <code>x = x + 12;</code>:
* reken eerst de uitdrukking <code>x + 12</code> uit, met de waarde die op dit moment aan <code>x</code> gekoppeld is.
* ken deze waarde toe aan <code>x</code>. In het vervolg van de uitvoering van het programma is <code>x</code> aan deze waarde gekoppeld, totdat je een andere waarde aan <code>x</code> toekent.

Let op: voor de vergelijking van twee waarden gebruik je <code>==</code>. Als je een enkele <code>=</code> gebruikt, betekent dat toekenning. Dit is meestal niet wat je bedoelt, maar de compiler zal je meestal niet waarschuwen.

== Expressies en operatoren ==

=== Rekenkundige operatoren ===

<syntaxhighlight lang="cpp">
x + y // add
x - y // subtract
x * y // multiply
x / y // divide
x % y // remainder
x && y // logical and (conditional)
x || y // logical or (conditional)
</syntaxhighlight>

=== Vergelijkingsoperatoren ===
<syntaxhighlight lang="cpp">
x == y // equals to
x != y // differs from
x > y // greater than
x >= y // at least
x < y // less than
x <= y // at most
</syntaxhighlight>

=== Logische operatoren ===

<syntaxhighlight lang="cpp">
! x // not
x && y // logical and (conditional)
x || y // logical or (conditional)
</syntaxhighlight>

=== Bit-operaties ===

<syntaxhighlight lang="cpp">
x & y // bitwise and
x | y // bitwise or
x << y // x leftshift y positions
x >> y // x rightshift y positions
</syntaxhighlight>

== Besturingsstructuren (control structures) ==

=== if ===

<syntaxhighlight lang="cpp">
if (cond) {
action();
}

if (digitalRead(onButton) == LOW) {
digitalWrite(led, HIGH);
}
</syntaxhighlight>

<syntaxhighlight lang="cpp">
if (cond) {
action1();
} else {
action2();
}

if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
</syntaxhighlight>

=== while ===

<syntaxhighlight lang="cpp">
while (cond) {
action();
}
</syntaxhighlight>

=== for ===

<syntaxhighlight lang="cpp">
for (i = start; i < limit; i++) {
action(i);
}
</syntaxhighlight>

== Arduino functies ==

<syntaxhighlight lang="cpp">
pinMode(led, OUTPUT);
pinMode(button, INPUT);
pinMode(button, INPUT_PULLUP);

digitalWrite(led, ledState);
buttonState = digitalRead(button);
ldrState = analogRead(ldr);
analogWrite(led, ledState);

now = millis();
delay(500);
delayMicroseconds(500000);
now = micros();
</syntaxhighlight>

== Libraries and preprocessor ==

<syntaxhighlight lang="cpp">
#include <stdio.h>
#include "mydefs.h"
</syntaxhighlight>

<syntaxhighlight lang="cpp">
Serial.begin(9600);

Serial.print("x=");
Serial.println(x);

if (Serial.available() > 0) {
nextByte = Serial.read();
}
</syntaxhighlight>

Arduino/Programmeren - Bewerkingsoverzicht

Eelco: /* Vergelijkingsoperatoren */

Eelco: /* if */

Eelco: /* if */

Eelco: /* if */

Eelco: Nieuwe pagina aangemaakt met ' == Sketch: setup, loop == void setup() { pinMode(13, OUTPUT); } void loop() { digitalWrite(13, HIGH); delay(1000); digitalW...'