Variabelen – Claasen-tech https://claasen-tech.nl Sun, 29 Dec 2024 13:55:06 +0000 nl-NL hourly 1 https://wordpress.org/?v=6.7.2 https://claasen-tech.nl/wp-content/uploads/2022/02/cropped-favicon-32x32.gif Variabelen – Claasen-tech https://claasen-tech.nl 32 32 De Arduino C++ taal https://claasen-tech.nl/c-plus-plus/de-arduino-c-plusplus-taal/ Tue, 25 Jun 2024 20:23:55 +0000 https://claasen-tech.nl/?p=3482 , , , ,

Arduino C++ is een versie van C++ aangepast voor Arduino microcontrollers en andere compatibele microcontroller-systemen. Het bevat speciale functies en bibliotheken om hardware zoals sensoren, motoren en dergelijke gemakkelijk uit te lezen of aan te sturen. Arduino C++ code wordt geschreven in de Arduino IDE. Dit is een eenvoudige programmeer omgeving om te gebruiken. Ze helpt bij het ontwikkelen, compileren en uploaden van de code naar de hardware. Hierdoor is het een goede keuze voor zowel beginners als gevorderden.

Voor installatie-instructies van de Arduino IDE en configuratie-details van het ESP32-DevKitC bord, raadpleeg ‘Installeren Arduino IDE‘ en ‘Configuratie van ESP32-DevKitC in Arduino IDE‘. Deze zijn ook te vinden onder ‘Technische Info’.

We gaan hieronder de Arduino C++ taal uitleggen. Hier wordt niet te diep in de Arduino C++ taal in gegaan, maar genoeg om de workshops te maken en meer. Ik begin met het invoeren van de taal delen die we in de workshops gebruiken. Zodra die klaar zijn, voeg ik ook andere toe.

Als je deze pagina voor het eerst bekijkt, kun je het beste van boven naar onderen werken om zo een goed overzicht te krijgen van Arduino C++. Later kun je rechtstreeks naar het onderwerp gaan wat je nog een keer wil bekijken. Zoeken met de zoekbalk kan natuurlijk ook.

  • Wat is de structuur van een programma
    Hier wordt omschreven waar een programma uit bestaat en hoe dit opgebouwd is.
  • setup()
    Dit is de eerste standaard functie die wordt doorlopen. De commando’s die hier uitgevoerd worden, hoeven en/of mogen maar één keer uitgevoerd te worden.
  • loop()
    Dit is de tweede standaard functie die wordt uitgevoerd. Dit is het hoofd gedeelte dat steeds weer wordt herhaald. Dus wordt het einde van deze functie bereikt, begint deze weer vooraan. Er komt geen einde aan.

Wat zijn variabelen

Bijzondere variabelen

  • Arrays
  • Constanten

Over variabelen

zichtbaarheid (scope)

Logische operatoren
(! && ||)

Vergelijkingsoperatoren
(== != < <= > >=)

Rekenkundige operatoren
(= + / * %)

Samengestelde toewijzingsoperatoren
(+= -= *= /= %= ++ – –)

In- en uitvoer

Zelf gemaakte functies

Tijd

Voorwaardelijke structuren

Herhaal structuren

  • for
  • do…while
  • while

Overige

  • break
  • continue
  • goto
  • return

Onder communicatie verstaan we het praten met andere microcomputers, sensoren, computer en gebruikers. Hier gebruiken we diverse protocollen (manieren) voor. Debuggen is het onderzoeken waarom iets gebeurt of juist niet gebeurt. Dit doe je als het programma niet doet wat jij ervan verwacht.

Serial

SPI

Wire / I2C

WIFI

Bluetooth

Debug

Nog geen gegevens

]]>
Float https://claasen-tech.nl/c-plus-plus/float/ Sun, 29 Dec 2024 13:29:46 +0000 https://claasen-tech.nl/?p=3899 ,

Beschrijving
Float is een gegevenstype voor het opslaan van niet gehele (decimale) getallen.

Een float is een datatype dat gebruikt wordt om decimale getallen op te slaan, zoals ‘3.14’ of ‘-0.001’. Het verschil met een integer is dat een float ook waarden kan bevatten tussen hele getallen, wat handig is voor metingen die nauwkeurigheid vereisen, zoals temperatuur of snelheid. Een float neemt 4 bytes aan geheugen in beslag en kan een bereik aan van ongeveer -3.4E38 tot 3.4E38, met een precisie van ongeveer 6-7 cijfers.

  • Opmerkingen en waarschuwingen
    • Let op dat er geen komma wordt gebruikt om de gehele getallen te scheiden van de decimalen, maar een punt. Dus niet ‘3,14’ maar ‘3.14′.
    • Bij het toekennen van een waarde aan een variabele dien je altijd een punt te gebruiken, dus ‘1.0’ en NIET ‘1’.

Syntax
float var = waarde;

Parameters
var: variabelenaam.
waarde: de waarde die je toekent aan die variabele.

Voorbeeld

float Pi = 3.14159;
float temperatuur = 23.5;
float snelheid = 55.5;

Toelichting voorbeeld

Hierboven worden 3 variabelen gedefinieerd en wordt er een begin waarde toegekend. ‘Pi’ krijgt de waarde ‘3.14159’ toegekend, ‘temperatuur’ krijgt de waarde ‘23.5’ en ‘snelheid’ krijgt de waarde ‘55.5’. Neem bijvoorbeeld ‘temperatuur’, elke keer dat een temperatuur sensor uitgelezen wordt die waarde aan de variabele ‘temperatuur’ toegekend. Deze waarde wordt uitgedrukt met 1 of 2 decimalen en kan daardoor dus niet in een integer opgeslagen worden.

Opmerkingen en waarschuwingen
Geen.

]]>
Scope https://claasen-tech.nl/c-plus-plus/scope/ Mon, 22 Apr 2024 20:08:35 +0000 https://claasen-tech.nl/?p=2995 ,

De scope van een variabele verwijst naar het deel van een programma waar de variabele toegankelijk is en gebruikt kan worden. In programmeren bepaalt de scope dus waar een variabele bekend en beschikbaar is voor bewerkingen. Dit is belangrijk voor het beheren van gegevens en het voorkomen van fouten in code.

Er zijn verschillende soorten scopes:

  1. Globale scope: Een variabele die globaal is gedefinieerd, is overal in het programma toegankelijk. Zodra een variabele buiten alle functies en blokken wordt gedefinieerd, wordt deze beschouwd als globaal.
  2. Lokale scope: Een lokale variabele wordt gecreëerd binnen een functie of een blok en is alleen toegankelijk binnen die functie of dat blok. Als je de functie of het blok verlaat, wordt de variabele niet meer herkend en kun je er niet meer mee werken.
  3. Blok scope: Binnen programmeertalen die dit ondersteunen (zoals C++ met de {} haakjes), is een variabele die binnen een blok (zoals een lus of een if-statement) wordt gedefinieerd, alleen binnen dat specifieke blok toegankelijk.

De scope van een variabele helpt bij het organiseren van de code en voorkomt conflicten tussen variabelen die mogelijk dezelfde naam hebben maar in verschillende delen van het programma worden gebruikt. Het zorgt ook voor efficiënt geheugengebruik, omdat lokale variabelen vrijgegeven worden wanneer hun scope eindigt.

Voorbeeld code

int x = 10; // Globale scope

void setup(){
  Serial.begin(115200);
  
  int y = 5; // Lokale scope
  Serial.println(y);
  Serial.println(x);
  Serial.println(k); // niet zichtbaar hier
  Serial.println(z); // niet zichtbaar hier
  Serial.println(j); // niet zichtbaar hier
}

void loop(){
  int k = 8; // Lokale scope
  Serial.println(y); // niet zichtbaar hier
  Serial.println(x);
  Serial.println(k);
  Serial.println(z); // niet zichtbaar hier
  Serial.println(j); // niet zichtbaar hier

  for (int j = 0; j < 100; j++) { // j heeft een blok scope
    Serial.println(y); // niet zichtbaar hier
    Serial.println(x);
    Serial.println(k);
    Serial.println(z); // niet zichtbaar hier
    Serial.println(j);
  }
  
  mijnFunctie();
}

void mijnFunctie(){
  int z = 0; // Lokale scope
  Serial.println(y); // niet zichtbaar hier
  Serial.println(x);
  Serial.println(k); // niet zichtbaar hier
  Serial.println(z);
  Serial.println(j); // niet zichtbaar hier
}

Toelichting voorbeeld
Serial.begin(115200) en Serial.println() zijn functies die het mogelijk maken gegevens op het scherm te zetten binnen het Arduino IDE programma.

Op de regels: 9, 10, 11, 16, 19, 20, 23, 26, 35, 37, 39 gaat het fout. Hier zijn de variabelen NIET zichtbaar en kun je ze dus ook niet gebruiken. Zou je dit programma in de Arduino IDE laden en compileren, geven deze regels errors.

Alle variabelen die buiten de setup()-functie en loop()-functie gemaakt worden, zoals x in het voorbeeld, zijn overal zichtbaar. Deze noemt men ook wel globale variabelen.

]]>
Wat zijn variabelen https://claasen-tech.nl/c-plus-plus/wat-zijn-variabelen/ Sun, 21 Apr 2024 20:55:32 +0000 https://claasen-tech.nl/?p=2989

Variabelen in programmeren zijn als labels of containers waar je informatie in kunt opslaan om later te gebruiken in je programma. Elke variabele heeft een specifieke naam en een waarde die je kunt veranderen, afhankelijk van wat je programma doet. Denk aan een variabele als een soort postvakje waarin je verschillende dingen kunt plaatsen en uit kunt halen wanneer je ze nodig hebt.

Variabelen zijn heel handig omdat ze je toestaan om gegevens te bewaren die je programma moet onthouden en gebruiken terwijl het draait. Ze kunnen cijfers, tekst, lijsten van dingen, of zelfs meer gecompliceerde informatie bevatten. Door variabelen te gebruiken, kan je programma flexibel reageren op verschillende situaties, berekeningen uitvoeren, of beslissingen nemen op basis van de informatie die het heeft opgeslagen.

Hoofdlettergevoelig
Programmeertalen zijn vaak hoofdlettergevoelig, wat betekent dat de namen van variabelen verschillend worden behandeld afhankelijk van het gebruik van hoofdletters en kleine letters. Bijvoorbeeld, leeftijd, Leeftijd en LEEFTIJD zouden in veel talen als drie verschillende variabelen worden gezien.

Bij het benoemen van variabelen is het belangrijk om duidelijke en beschrijvende namen te kiezen die het doel van de variabele weergeven. Hierdoor kan je code gemakkelijker lezen en onderhouden. Er zijn verschillende conventies voor naamgeving, zoals:

  • camelCase: De eerste letter van het eerste woord is klein, en de eerste letters van alle volgende woorden zijn hoofdletters, zonder spaties. Bijvoorbeeld: studentLeeftijd.
  • snake_case: Woorden worden gescheiden door underscores en alle letters zijn klein. Bijvoorbeeld: student_leeftijd.
  • PascalCase: Elk woord begint met een hoofdletter, zonder spaties. Bijvoorbeeld: StudentLeeftijd.

Het is goed om consistent te zijn in de manier waarop je variabelen benoemt binnen je projecten, om de leesbaarheid en het onderhoud van de code te bevorderen.

In de programma’s op deze site wordt camelCase gebruikt.

]]>
Bool https://claasen-tech.nl/c-plus-plus/bool/ Sun, 24 Mar 2024 17:47:13 +0000 https://claasen-tech.nl/?p=2870 ,

Beschrijving
Een bool bevat één van twee waarden, ‘true’ (waar) of ‘false’ (onwaar). (Elke bool variabele neemt één byte geheugen in beslag.).

Syntax
bool var = waarde;

Parameters
var: variabelenaam.
waarde: de waarde die je toekent aan die variabele.

Voorbeeld

// Hier maak je een variabele die aangeeft op welke pin het ledje aangesloten zit.
int pin1 = 22; // GPIO22

// Deze pin lees je de status van de drukknop uit
int pin3 = 36; // GPIO36

// status van de drukknop wordt in deze bool variabele opgeslagen
bool statusPin = false;

// de setup functie wordt een keer uitgevoerd als je het Single Board Computer start of reset.
void setup() {
   // initializeert de digital pinnen 'pin1' en 'pin2' als uitvoer.
   pinMode(pin1, OUTPUT);
   pinMode(pin3, INPUT);
}

// de loop functie loopt keer op keer opnieuw, het is een eindeloze lus.
void loop() {

  // de status van de drukknop wordt opgeslagen in statusPin
  statusPin = digitalRead(pin3); // statusPin krijgt hier de waarde 0 of 1.

  digitalWrite(pin1, statusPin ); // led brandt als statusPin een waarde '1', 'true' of 'HIGH' heeft.

  delay(100);
}

Toelichting voorbeeld
In het voorbeeld hierboven wordt op regel 8 de variabele ‘statusPin’ als bool gedefinieerd en krijgt de waarde ‘false’. Op regel 21 krijgt deze een nieuwe waarde toegekend door het uitlezen van de drukknop met de functie digitalRead. Op regel 23 wordt deze waarde gebruikt door de functie digitalWrite om een led aan of uit te zetten. Lees de opmerking hieronder.

Opmerking

bool waarden en constanten
In de Arduino IDE C++ zijn een aantal constanten (dit zijn variabelen die niet gewijzigd kunnen worden) gedefinieerd. Enkele van die constanten zijn ‘true’, ‘false’, ‘HIGH’ en ‘LOW’. Deze hebben een waarde 0 of 1. Dus de bool-waarden ‘true’, ‘HIGH’ of ‘1’ zijn gelijk. En de bool-waarden ‘false’, ‘HIGH’ en ‘0’ zijn ook gelijk. Hieruit kun je afleiden dat een bool variabele maar 2 waardes kan hebben, 0 of 1.

Hieronder een voorbeeld waar je kunt zien dat ‘1’, ‘true’ en ‘HIGH’ hetzelfde zijn. Daaronder staat de uitvoer van dit programma.

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  delay(5000);
  Serial.println("-- Begin --");
  Serial.println();
}

void loop() {
  // put your main code here, to run repeatedly:
  bool x = false;
  bool y = LOW;
  bool z = 0;
  int waarde = 10;

  Serial.println("De volgende variabelen zijn als volgt gedefinieerd:");
  Serial.println("bool x = false;");
  Serial.println("bool y = LOW;");
  Serial.println("bool z = 0;");
  Serial.println("waarde = 10;");
  Serial.println("--------------------------------------------------");
  Serial.println();

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

  Serial.print("y: ");
  Serial.println(y);

  Serial.print("z: ");
  Serial.println(z);

  Serial.print("Waarde: ");
  Serial.println(waarde);

  waarde = x;
  Serial.print("Waarde = x: ");
  Serial.println(waarde);

  waarde = y;
  Serial.print("Waarde = y: ");
  Serial.println(waarde);

  waarde = z;
  Serial.print("Waarde = z: ");
  Serial.println(waarde);
  Serial.println();
  Serial.println();
  Serial.println();


  x = true;
  y = HIGH;
  z = 1;
  waarde = 15;

  Serial.println("De variabelen zijn opnieuw als volgt gedefinieerd:");
  Serial.println("bool x = true;");
  Serial.println("bool y = HIGH;");
  Serial.println("bool z = 1;");
  Serial.println("waarde = 15;");
  Serial.println("--------------------------------------------------");
  Serial.println();

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

  Serial.print("y: ");
  Serial.println(y);

  Serial.print("z: ");
  Serial.println(z);

  Serial.print("Waarde: ");
  Serial.println(waarde);

  waarde = x;
  Serial.print("Waarde = x: ");
  Serial.println(waarde);

  waarde = y;
  Serial.print("Waarde = y: ");
  Serial.println(waarde);

  waarde = z;
  Serial.print("Waarde = z: ");
  Serial.println(waarde);
  Serial.println();

  delay(240000);
}
-- Begin --

De volgende variabelen zijn als volgt gedefinieerd:
bool x = false;
bool y = LOW;
bool z = 0;
waarde = 10;
--------------------------------------------------

x: 0
y: 0
z: 0
Waarde: 10
Waarde = x: 0
Waarde = y: 0
Waarde = z: 0



De variabelen zijn opnieuw als volgt gedefinieerd:
bool x = true;
bool y = HIGH;
bool z = 1;
waarde = 15;
--------------------------------------------------

x: 1
y: 1
z: 1
Waarde: 15
Waarde = x: 1
Waarde = y: 1
Waarde = z: 1
]]>
Unsigned integer (unsigned int) https://claasen-tech.nl/c-plus-plus/unsigned-int/ Tue, 16 Jan 2024 22:46:51 +0000 https://claasen-tech.nl/?p=2466 ,

Beschrijving
Unsigned integer zijn gegevenstypen voor het opslaan van gehele getallen. Een unsigned int is een integer die niet alleen maar hele getallen opslaat, maar ook alleen maar positieve getallen.

Een unsigned int wordt als een 16-bits (2-byte) waarde opgeslagen. Dit geeft een bereik van 0 tot 65.535. Dit is de kleinste en grootste waarde die een unsigned int kan opslaan. Een unsigned int kan ook alleen maar hele getallen opslaan. Bij een getal met een komma slaat hij alleen het deel op dat links van de komma staat, de rest vergeet hij gewoon. Dus als je een waarde van 7,75 aan een unsigned int toekent, slaat hij alleen 7 op. Houd hier rekening mee bij rekenkundige functies. Dus 7 gedeeld door 2 is 3 en niet 3,5. Als je deze uitkomst weer met 2 zou vermenigvuldigen, krijg je 6 in plaats van 7.

Bij een ESP32-DevKitC bord wordt een unsigned int als een 32-bits (4 byte) waarde opgeslagen. Dit geeft een bereik van 0 tot 4.294.967.295.

Syntax
unsigned int var = waarde

Parameters
var: variabelenaam.

waarde: de waarde die je toekent aan die variabele.

Voorbeeld

unsigned long pin1 = 22;
unsigned long tijd = 36453723456;
unsigned long teller = 0;

Toelichting voorbeeld

Hierboven worden 3 variabelen gedefinieerd en wordt er een begin waarde toegekend. ‘pin1’ krijgt de waarde 22 toegekend, ‘tijd’ krijgt de waarde 36453723456 en ‘teller’ krijgt de waarde 0. Neem bijvoorbeeld ‘teller’, deze zou elke keer als er een knop wordt ingedrukt met 1 opgehoogd worden. Zo weet je hoe vaak een knop ingedrukt is.

Opmerkingen en waarschuwingen
Wanneer unsigned int variabelen hun maximale of minimale waarde overschrijden, treedt er overflow op. Als dit gebeurt is de uitkomst onzeker en kan het programma zelfs vastlopen. Dus je moet er wel voor zorgen dat deze situatie zich niet voordoet.

Het ESP32-DevKitC bord behandelt overflow goed. Het gaat van 4.294.967.295 naar 0 (en anders om). Dit is iets om rekening mee te houden.

]]>
Unsigned long integer (unsigned long) https://claasen-tech.nl/c-plus-plus/unsigned-long/ Sun, 14 Jan 2024 15:01:13 +0000 https://claasen-tech.nl/?p=2431 ,

Beschrijving
Unsigned long integer zijn gegevenstypen voor het opslaan van gehele getallen. Een unsigned long is een integer die niet alleen maar hele getallen opslaat, maar ook alleen maar positieve getallen.

Een unsigned long wordt als een 32-bits (4-byte) waarde opgeslagen. Dit geeft een bereik van 0 tot 4.294.967.295. Dit is de kleinste en grootste waarde die een unsigned long kan opslaan. Een unsigned long kan ook alleen maar hele getallen opslaan. Bij een getal met een komma slaat hij alleen het deel op dat links van de komma staat, de rest vergeet hij gewoon. Dus als je een waarde van 7,75 aan een unsigned long toekent, slaat hij alleen 7 op. Houd hier rekening mee bij rekenkundige functies. Dus 7 gedeeld door 2 is 3 en niet 3,5. Als je deze uitkomst weer met 2 zou vermenigvuldigen, krijg je 6 in plaats van 7.

Een unsigned long en unsigned int hebben bij een ESP32-DevKitC bord hetzelfde bereik.

Syntax
unsigned long var = waarde

Parameters
var: variabelenaam.

waarde: de waarde die je toekent aan die variabele.

Voorbeeld

unsigned long pin1 = 22;
unsigned long tijd = 36453723456;
unsigned long teller = 0;

Toelichting voorbeeld

Hierboven worden 3 variabelen gedefinieerd en wordt er een begin waarde toegekend. ‘pin1’ krijgt de waarde 22 toegekend, ‘tijd’ krijgt de waarde 36453723456 en ‘teller’ krijgt de waarde 0. Neem bijvoorbeeld ‘teller’, deze zou elke keer als er een knop wordt ingedrukt met 1 opgehoogd worden. Zo weet je hoe vaak een knop ingedrukt is.

Opmerkingen en waarschuwingen
Wanneer unsigned long variabelen hun maximale of minimale waarde overschrijden, treedt er overflow op. Als dit gebeurt is de uitkomst onzeker en kan het programma zelfs vastlopen. Dus je moet er wel voor zorgen dat deze situatie zich niet voordoet.

Het ESP32-DevKitC bord behandelt overflow goed. Het gaat van 4.294.967.295 naar 0 (en anders om). Dit is iets om rekening mee te houden.

]]>
Integer (int) https://claasen-tech.nl/c-plus-plus/int/ Sat, 13 Jan 2024 22:59:31 +0000 https://claasen-tech.nl/?p=2383 ,

Beschrijving
Integers zijn gegevenstypen voor het opslaan van gehele getallen.

Deze slaat een int als een 16-bits (2-byte) waarde op. Dit geeft een bereik van -32.768 tot 32.767. Dus dit is de kleinste en grootste waarde die een int kan opslaan. Een int kan ook alleen maar hele getallen opslaan. Bij een getal met een komma slaat hij alleen het deel op dat links van de komma staat, de rest vergeet hij gewoon. Dus als je een waarde van 7,75 aan een int toekent, slaat hij alleen 7 op. Houd hier rekening mee bij rekenkundige functies. Dus 7 gedeeld door 2 is 3 en niet 3,5. Als je deze uitkomst weer met 2 zou vermenigvuldigen, krijg je 6 in plaats van 7.

Het ESP32-DevKitC bord dat ik in de workshops gebruik, slaat een int op als een 32-bits (4-byte) waarde. Dit resulteert in een bereik van -2.147.483.648 tot 2.147.483.647.

Syntax
int var = waarde;

Parameters
var: variabelenaam.

waarde: de waarde die je toekent aan die variabele.

Voorbeeld

int pin1 = 22;
int pin2 = 23;
int duur = 1000;
int teller = 0;

Toelichting voorbeeld

Hierboven worden 4 variabelen gedefinieerd en wordt er een begin waarde toegekend. ‘pin1’ krijgt de waarde 22 toegekend, ‘pin2’ krijgt de waarde 23, ‘duur’ krijgt de waarde 1000 en ‘teller’ krijgt de waarde 0. Neem bijvoorbeeld ‘teller’, deze zou elke keer als er een knop wordt ingedrukt met 1 opgehoogd worden. Zo weet je hoe vaak een knop ingedrukt is.

Opmerkingen en waarschuwingen
Wanneer int variabelen hun maximale of minimale waarde overschrijden, treedt er overflow op. Dit wil zeggen dat als je bij een int variabele met 0 zou beginnen en telt er elke keer 1 bij op. Uiteindelijk bereik je de waarde 32.767 en als je probeert hier 1 bij op te tellen is het resultaat onbekend. Het kan zomaar zijn dat je programma niet meer werkt. Dit geldt ook wanneer je bij 0 begint en er elke keer 1 van af telt. Je bereikt de waarde -32.768 en als je hier 1 van af telt, is het ook onbekend wat er gaat gebeuren. Dus je moet wel controleren of deze situatie zich voordoet.

Het ESP32-DevKitC bord behandelt overflow goed. Het gaat van 2.147.483.647 naar -2.147.483.648 (en anders om). Dit is iets om rekening mee te houden.

]]>