Introductie

Beste robotica leerling, wat heb jij een interesse in Arduino! de lesmethode opzoeken is de eerste stap in je leven van de elektrotechniek. Deze lesmethode is geschreven door Max Rothkrantz en Taeke-Jan Siemensma voor hun PWS in 2025. We hebben alle kennis over de Arduino die we hadden en zelfs wat meer opgeschreven voor jou, om te lezen en te leren Success!

Hoofdstuk 0 - Arduino Documentatie

Structuur

Schetsen

Methode en parameter	Beschrijving
`void loop()`	Hoofdfunctie voor continue code-uitvoering.
`void setup()`	Initialisatiefunctie, één keer aangeroepen bij het opstarten.

Controlestructuur

Methode en parameter	Beschrijving
`break`	Beëindigt een lus of switch-instructie.
`continue`	Slaat de rest van een lus-iteratie over.
`do...while`	Voert een codeblok herhaaldelijk uit zolang aan een opgegeven voorwaarde wordt voldaan.
`else`	Onderdeel van de if-else-instructie.
`for`	Maakt een lus met een opgegeven initialisatie, voorwaarde en toename.
`goto`	Draagt de controle over aan een gelabelde verklaring.
`if`	Voorwaardelijke verklaring voor besluitvorming.
`return`	Beëindigt een functie en retourneert optioneel een waarde.
`switch...case`	Multi-way branch-instructie.
`while`	Maakt een lus met een opgegeven voorwaarde.

Verdere syntaxis

Methode en parameter	Beschrijving
`#define (define)`	Macrodefinitie voor codevervanging.
`#include (include)`	Bevat een bestand in de broncode.
`/* */ (block comment)`	Blokkeer commentaar voor meerdere regels.
`// (single line comment)`	Commentaar in één regel.
`; (semicolon)`	Verklaring terminator.
`{} (curly brackets)`	Codeblok, vaak gebruikt met besturingsstructuren.

Rekenkundige operatoren

Methode en parameter	Beschrijving
`% (remainder)`	Modulo-operator voor het bepalen van de rest van een deling.
`* (multiplication)`	Vermenigvuldigingsoperator.
`+ (addition)`	Opteloperator.
`- (subtraction)`	Aftrekoperator.
`/ (division)`	Divisie-operator.
`= (assignment operator)`	Toewijzingsoperator.

Vergelijkingsoperatoren

Methode en parameter	Beschrijving
`!= (not equal to)`	Controleert of twee waarden ongelijk zijn.
`< (less than)`	Controleert of de linkerwaarde kleiner is dan de rechterwaarde.
`<= (less than or equal to)`	Controleert of de linkerwaarde kleiner of gelijk is aan de rechterwaarde.
`== (equal to)`	Controleert of twee waarden gelijk zijn.
`> (greater than)`	Controleert of de linkerwaarde groter is dan de rechterwaarde.
`>= (greater than or equal to)`	Controleert of de linkerwaarde groter is dan of gelijk is aan de rechterwaarde.

Booleaanse operatoren

Methode en parameter	Beschrijving
`! (logical not)`	Keert de logische waarde om, true wordt false en vice versa.
`&& (logical and)`	Logische AND-operator, retourneert true als beide operanden true zijn.
`\|\|(logical or)`	Logische OF-operator, retourneert true als ten minste één operand true is.

Pointer-toegangsoperatoren

Methode en parameter	Beschrijving
`& (reference operator)`	Retourneert het geheugenadres van een variabele.
`* (dereference operator)`	Geeft toegang tot de waarde waarnaar een aanwijzer verwijst.

Bitgewijze operatoren

Methode en parameter	Beschrijving
`& (bitwise and)`	Voert een bitsgewijze AND-bewerking uit.
`<< (bitshift left)`	Verschuift bits naar links.
`>> (bitshift right)`	Verschuift bits naar rechts.
`^ (bitwise xor)`	Voert een bitgewijze XOR-bewerking (exclusieve OF) uit.
`\\| (bitwise or)`	Voert een bitgewijze OF-bewerking uit.
`~ (bitwise not)`	Keert alle bits om.

Samengestelde operatoren

Methode en parameter	Beschrijving
`%= (compound remainder)`	Voert een modulo-bewerking uit en wijst het resultaat toe aan de linker operand.
`&= (compound bitwise and)`	Voert een bitsgewijze AND-bewerking uit en wijst het resultaat toe aan de linkeroperand.
`*= (compound multiplication)`	Vermenigvuldigt de linkeroperand met de rechteroperand en wijst het resultaat toe aan de linkeroperand.
`++ (increment)`	Verhoogt de waarde van de operand met 1.
`+= (compound addition)`	Voegt de rechteroperand toe aan de linkeroperand en wijst het resultaat toe aan de linkeroperand.
`-- (decrement)`	Vermindert de waarde van de operand met 1.
`-= (compound subtraction)`	Trekt de rechteroperand van de linkeroperand af en wijst het resultaat toe aan de linkeroperand.
`/= (compound division)`	Deelt de linkeroperand door de rechteroperand en wijst het resultaat toe aan de linkeroperand.
`^= (compound bitwise xor)`	Voert een bitgewijze XOR-bewerking uit en wijst het resultaat toe aan de linker operand.
`\\|= (compound bitwise or)`	Voert een bitgewijze OF-bewerking uit en wijst het resultaat toe aan de linkeroperand.

Variabelen

Opsommingen

Enum-type	Opsomming	Beschrijving
`PinStatus`	`HIGH / LOW`	Logische HOGE en LAGE waarden (`1`En`0`).
`PinMode`	`INPUT`/`OUTPUT`/`INPUT_PULLUP`/ `INPUT_PULLDOWN`/`OUTPUT_OPENDRAIN`	Constanten voor het specificeren van pin-modi (`0`,`1`,`2`,`3`,`4`).
	`LED_BUILTIN`	Constante die de ingebouwde LED-pin vertegenwoordigt. *
	`true / false`	Booleaanse constanten voor waar en onwaar (`1`En`0`).

Conversie

Methode en parameter	Beschrijving
`(unsigned int)`	Typecasting naar ongetekende int.
`(unsigned long)`	Typecasting naar ongetekend lang.
`byte()`	Typecasting naar byte.
`char()`	Typecasting naar char.
`float()`	Typecasting om te zweven.
`int()`	Typecasting naar int.
`long()`	Te lang typecasten.
`word()`	Typecasting naar woord.

Gegevenstypen

Methode en parameter	Beschrijving
`array`	Verzameling variabelen van hetzelfde type.
`bool`	Gegevenstype Booleaans.
`boolean`	Booleaans gegevenstype (synoniem voor bool).
`byte`	8-bits ongetekend gegevenstype.
`char`	8-bits tekengegevenstype.
`double`	Gegevenstype met drijvende komma en dubbele precisie.
`float`	Gegevenstype met drijvende komma en enkele precisie.
`int`	Gegevenstype geheel getal.
`long`	Gegevenstype: lang geheel getal.
`short`	Gegevenstype: kort geheel getal.
`size_t`	Gegevenstype Ongetekend geheel getal.
`string`	Volgorde van tekens (geen primitief type).
`String()`	String-klasse in Arduino.
`unsigned char`	Ongetekend 8-bits tekengegevenstype.
`unsigned int`	Gegevenstype Ongetekend geheel getal.
`unsigned long`	Gegevenstype met ongetekende, lange gehele getallen.
`void`	Geeft de afwezigheid van een type weer.
`word`	16-bits ongetekend gegevenstype.

Variabele scope en kwalificaties

Methode en parameter	Beschrijving
`const`	Kwalificatie om constanten te definiëren.
`scope`	Geen specifiek trefwoord; verwijst naar de variabele scope.
`static`	Kwalificatie om statische variabelen te declareren.
`volatile`	Kwalificatie om vluchtige variabelen te declareren.

Nutsvoorzieningen

Methode en parameter	Beschrijving
`PROGMEM`	Kwalificatie om gegevens in het programmageheugen op te slaan.
`sizeof()`	Operator om de grootte van een gegevenstype of variabele te bepalen.

I/O Functies

Digitale I/O

Methode en parameters	Beschrijving	Retourneren
`int digitalRead(int pin)`	Leest de status van een digitale pin.	`int`
`void digitalWrite(int pin, int state)`	Schrijft een status naar een digitale pin.	Niets
`void pinMode(int pin, int mode)` *	Definieer de modus van een pin.	Niets

* Beschikbare modi zijn:

INPUT(0)
OUTPUT(1)
INPUT_PULLUP(2)
INPUT_PULLDOWN(3)
OUTPUT_OPENDRAIN(4)

Analoge I/O

Methode en parameters	Beschrijving	Retourneren
`int analogRead(int pin)`	Leest de waarde van een analoge pin in een resolutie van 10 bits (0-1023). *	`int`
`void analogReadResolution(int resolution)`	Stelt de ADC-leesresolutie in bits in.	Niets
`void analogReference(int reference)`	Wijzigt de spanningsreferentie voor een bord.**	Niets
`void analogWrite(int pin, int value)`	Schrijft een waarde naar een PWM-ondersteunde pin in een resolutie van 8 bits (0-255).**	Niets
`void analogWriteResolution(int resolution)`	Stelt de schrijfresolutie voor een bord in.	Niets

* Het waardebereik verandert op basis van de resolutie. 0-1023 is een resolutie van 10 bits, 0-4096 is een resolutie van 12 bits, enzovoort.
**Elk bord/elke architectuur heeft een aantal verschillende referentiespanningen beschikbaar.
***Het waardebereik verandert op basis van de resolutie. 0-255 is de standaardwaarde (8-bits).

Geavanceerde I/O

Methode en parameters	Beschrijving	Retourneren
`void tone(int pin, int frequency, long duration)`	Genereert een vierkante golf op de opgegeven pin, met een duty cycle van 50%.	Niets
`void noTone(int pin)`	Stopt de generatie van een vierkante golf op de opgegeven pin.	Niets
`long pulseIn(int pin, int state, long timeout)`	Leest een puls (HOOG of LAAG) op een pin en retourneert de lengte van de puls (in microseconden)	`long`
`long pulseInLong(int pin, int state, long timeout)`	Geeft de lengte van de puls terug (in microseconden)	`long`
`int shiftIn(int pin, int clockPin, int bitOrder)` *	Verplaatst een byte met gegevens één bit per keer en retourneert de waarde van de gelezen bit.	`byte`
`void shiftOut(int pin, int clockPin, int bitOrder, byte value)` **	Verschuift een byte aan gegevens één bit per keer.	Niets

* DebitOrderparameter is ofwelMSBFIRST(1) ofLSBFIRST(0) (meest / minst significante bits).
**De pin die gebruikt wordt voorshiftOut()moet worden geconfigureerd als eenOUTPUT, met behulp vanpinMode()

Wiskundige Functies

Wiskunde

Methode en parameters	Beschrijving	Retourneert
`int abs(int value)`	Bereken de absolute waarde van een getal.	`int`
`int constrain(int value, int min, int max)`	Beperkt een getal tot een bepaald bereik.	`int`
`long map(long val, long min, long max, long newMin, long newMax)`	Hiermee wordt een getal van het ene bereik opnieuw toegewezen aan een ander bereik.	`long`
`int max(int val1, int val2)`	Retourneert de grootste van twee waarden.	`int`
`int min(int val1, int val2)`	Retourneert de kleinste van twee waarden.	`int`
`double pow(double base, double exponent)`	Verheft een grondtal tot de macht van een exponent.	`double`
`int sq(int value)`	Bereken het kwadraat van een getal.	`int`
`double sqrt(double value)`	Bereken de vierkantswortel van een getal.	`double`

Trigonometrie

Methode en parameters	Beschrijving	Retourneert
`cos(double angle)`	Bereken de cosinus van een hoek in radialen.	`double`
`sin(double angle)`	Bereken de sinus van een hoek in radialen.	`double`
`tan(double angle)`	Bereken de tangens van een hoek in radialen.	`double`

Willekeurige getallen

Methode en parameters	Beschrijving	Retourneert
`int random()`	Genereert een pseudo-willekeurig getal tussen 0 en `RAND_MAX` .	`int`
`void randomSeed(unsigned long seed)`	Zaadjes in de willekeurige getallengenerator.	Niets

Hoofdstuk 1 - Voorkennis programmeren

Initialisatie

Tijdens de initialisatie maak je de code klaar voor gebruik, je stelt variabelen in, importeert bibliotheken.... Het zijn dingen die moeten gebeuren voordat de code eigenlijk begint. In het begin is er geen verschil tussen initialiseren en setup, maar later wordt hier wel onderscheid in gemaakt.

Functies

Waarom functies gebruiken?

Hoewel je functies theoretisch gezien niet nodig hebt voor een programma is het wel slim om functies te gebruiken.

Dit is omdat functies je code beter leesbaar maken en er voor zorgen dat de code veel korter word.

Een functie kunnen we zien als een groep instructies en die instructies voeren samen een specifieke taak uit.
We maken gebruik van deze functies om ons programma net en georganiseerd te houden en ook goed leesbaar te maken. Ook gebruiken we functies omdat we de opdracht of taak ergens anders opnieuw willen gebruiken.

Parameters

Om de robot opdrachten te laten uitvoeren kan je gebruik maken van functies bijvoorbeeld:

rotatieMotor()

Soms moet je functies meerdere keren aanroepen, afhankelijk van hoeveel rondjes je wilt dat de motor draait bijvoorbeeld 2 rondjes, dat geeft

rotatieMotor()

In plaats van verschillende functies voor het draaien van de motor te definiëren, kun je een parameter gebruiken om de gewenste hoeveelheid rondjes op te geven, bijvoorbeeld:

rotatieMotor(2), rotatieMotor(8) en rotatieMotor(14) (het getal tussen de haakjes staat nu even voor hoe vaak het onder elkaar staat in de code) dit kan je ook zoals het volgende opschrijven

rotatieMotor(aantal rondjes: 2)

De getallen staan voor hoe vaak de motor een rondje draait, dus als je de functie aanroept is de 2 een argument die je doorgeeft waarmee de uitvoering van de functie wordt aangepast

Bijvoorbeeld als je een 6 invoert op de plek van de 2 dan draait de motor 6 rondjes.

Je kan ook meerdere parameters in een functie zetten, rotatieMotor(aantal rondjes: 6, richting: achteruit), nu draait de motor 6 rondjes achteruit, belangrijk dat je er een komma tussen zet om er 2 werkende parameters van te maken.

Variabelen

Moet je code iets opslaan om goed te werken? Dan heb je een variabel nodig, zie het als een contact in je telefoon en een telefoonnummer. Je moet een bepaald nummer opslaan, door het een naam te geven. Als je de naam in typt dan krijg je het telefoonnummer. Het unieke aan een variabel is dat het variabel kan zijn. Je kan het variabel ergens anders in de code veranderen.

Typen

Variabelen worden veel gebruikt door programmeurs.

Een variabele is een stukje informatie bijvoorbeeld een hoek en een snelheid waar je een waarde aan koppelt.

Om een nieuwe variabele aan te maken gebruik je “var” gevolgd door de variabelenaam en een waarde.

Bijvoorbeeld:

var angle = 15°

var speed = 10

Het = teken stelt de waarde van de variabele in.

Je kan variabelen veranderen door een nieuwe waarde achter het = teken te zetten

bijvoorbeeld

var angle = 15°

angle = 20°

nu is de hoek van 15 graden naar 20 graden gegaan, je hoeft niet meer 'var' er voor te zetten omdat de variabele al is aangemaakt.

Ook kan je gebruik maken van +(plus), -(min), *(keer) en /(delen door) om een nieuwe waarde aan de variabele te hangen, zoals:

speed = speed + 1 dit geeft speed = 11

speed = speed *2 dit geeft speed = 20

Logische operatoren

Je hebt wel eens eerder van een 'if-functie' gehoord, als dit dan dat. Om een if-functie te laten werken heb je logische operatoren nodig.

een operator is een symbool waarmee een bewerking wordt aangeduid.

Dan is een logische operator een manier om dingen met elkaar te vergelijken, je kan je code specifieker maken. Er zijn drie belangrijke logische operatoren.

AND, OR en NOT- operatoren. Hier is een overzicht van alle operatoren in C++.

Overzicht logische operatoren

Arrays

Wat is een Array?
Een array is een verzameling van variabelen die van hetzelfde type zijn en onder één naam gegroepeerd zijn.

In een array kan je dus makkelijk meerdere waarden opslaan en beheren.

Bijvoorbeeld een lijst van cijfers, tekens of andere dingen.

int mijnwaarden[4], dit is een array met 4 waarden die standaard zijn gedefinieerd.

int mijnwaarden[4] = {1, 2, 3, 4}, dit is een array die 4 waarden heeft en waar de 4 waarden door jou zijn gespecificeerd.

om een waarde uit een array te halen moet je het volgende doen:

x = mijnwaarden[?]

op de plek van het ? kom het getal van de plek waar je de waarde van wil hebben.

De plekken zijn als volgt genummerd, de eerste plek is 0, de tweede 1 enz, en de laatste het aantal elementen min 1 dus in dit geval 4-1 dus 3.

Let altijd goed op als je een waarde uit een array haalt, het begint met 0 en eindigt 1 onder het aantal elementen dat er in zit.

Hoofdstuk 2 - Oefenen in de emulator

Project 2.1 Knipperlicht

In dit project gaan we een knipperlicht maken, hiervoor heb je de volgende componenten nodig:

Arduino Uno
LED
1kΩ Weerstand

Het lampje heeft 2 metalen stokjes, een lange (+) en een kortere (-). Het lampje maak je vast aan een weerstand, als je dit niet doet loop je de kans dat het lampje doorbrand en kapot gaat. Of de weerstand voor of na het lampje is maakt niet uit omdat de componenten in serie zijn geschakeld. Je verbind je circuit GRD (grond) en met een digitale pin naar keuze, we verbinden met een digitale pin omdat we willen dat het lampje alleen aan of uit kan gaan. Als je het lampje verbind met een analoge pin kan het lampje meerdere standen hebben. Deze mogelijkheid valt buiten deze oefening.

Als je het goed hebt gedaan ziet het er zo uit.

Kleur maakt niet uit

Dan gaan we nu programmeren met text, hiervoor moet je wel de goede instelling hebben.

Setup kunnen we leeg laten omdat we niks hoeven initialiseren,
weet je niet wat dat betekend? kijk dan bij hoofdstuk 1.
Bedenkt je progrmma de hele tijd doet: bij void loop heb je 2 functies/ opdrachten die je moet verwerken.
1. Lampje aan
2. Lamje uit
Dit kan je programmeren doormiddel van de functie digitalWrite(#,#)
Deze functie heeft 2 parameters nodig (te zien aan de #) de eerste parameter is het pin-nummer waaraan het circuit is verbonden. (bij het voorbeeld nummer 13)
Het tweede parameter is bespeelt of het lampje aan of uit gaat, HIGH staat voor aan, LOW staat voor uit.
Als laatste moet er na elke functie een kleine pauze in het progamma zitten zodat het lampje nog een tijdje aan blijft staan dit doen we met de functie, delay(#) waarbij de parameter het aantal milliseconden pauze is.

Als je alle stappen goed hebt gevolgd heb je nu dit:

Voorbeeld progamma

Je kan dan nu je simulatie starten en als je goed kijkt zie je het lampje knipperen.

Project 2.2 Knoppenwerk

In dit project ga je een knop maken die het licht aan gaat zetten als je er op drukt. oftewel een momentschakelaar. Hiervoor heb je nodig

Led
1 kΩ weerstand
Arduino
10 kΩ weerstand
Knop

Uitleg knop:

Hoe werkt het:

Een drukknop bevat metalen contacten die samengedrukt worden wanneer de knop wordt ingedrukt, waardoor er elektrische stroom kan stromen. Deze drukknop heeft vier draden, waarvan er twee altijd intern zijn verbonden, en de twee sets raken elkaar wanneer de knop wordt ingedrukt.

Hoe je het moet verbinden:

Sluit de ene kant van de schakelaar aan op stroom, en de andere kant op de ingangspin van een microcontroller, en op de aarde via een grote weerstand. De weerstand is verbonden met de pin LOW, tenzij de knop wordt ingedrukt. Op dat moment kan de pin een HIGH-signaal detecteren wanneer deze wordt aangesloten op 5V.

De basis om een knop te laten werken ziet er zo uit:

Voorbeeld gebruik van een knop

We gaan nu beginnen met bouwen, maak je breadboard klaar door de plus en min kanten van de arduino te verbinden. Doe dit zo:

Voorbeeld standaardverbinding

Voorbeeld schematische weergave

Je weet welke componenten je nodig hebt, probeer nu zelf de componenten te verbinden,

het lampje moet verbonden zijn met een digitale pin op de Arduino en in serie geschakeld zijn met een weerstand en verbonden zijn met de -.
de knop moet verbonden zijn met een digitale pin en met de + en de - (kijk naar het voorbeeld van hoe een knop werkt hierboven)

lukt dat niet kijk dan eerst naar de schematische weergave (onthoud dat je deze pins niet hoeft te gebruiken, je mag ook andere gebruiken).

Kom je echt niet verder kijk dan naar het antwoord bij de antwoorden.

Laten we aan de slag gaan met programmeren!

Volg de stappen hieronder om de opdracht uit te voeren. Zorg ervoor dat je de knop als sensor gebruikt en niet als schakelaar. Dit betekent dat de knop een aparte stroomkring heeft, zodat het lampje blijft branden, zelfs als de stroomkring in de knop wordt doorbroken.

Stap 1: Initialiseer een variabele

Boven de setup() functie initialiseer je een variabele met de volgende code:

int status = 0;

De naam van de variabele is status, maar je kunt deze een andere naam geven als je wilt, zolang deze uit letters bestaat en geen speciale tekens bevat. Deze variabele zal de status van de knop opslaan.

Stap 2: Stel de pinnen in

In de setup() functie stel je in welke pinnen je gebruikt en of ze als INPUT of OUTPUT zijn ingesteld.

Voorbeeld:

void setup() {

pinMode(4, OUTPUT); // LED is verbonden met pin 4

pinMode(2, INPUT); // Knop is verbonden met pin 2

}

Stap 3: Lees de status van de knop

In de loop() functie gebruik je de functie digitalRead() om de status van de knop te lezen. Koppel de gelezen waarde aan de variabele status:

void loop() {

status = digitalRead(2); // Lees de status van de knop verbonden met pin 2

}

Stap 4: Stel een if-else structuur in

Gebruik een if-else-structuur om te bepalen wat er gebeurt op basis van de status van de knop:

if (status == 0) {

digitalWrite(4, HIGH); // Zet de LED aan

} else {

digitalWrite(4, LOW); // Zet de LED uit

}

Hier controleert if (status == 0) of de knop wordt ingedrukt (waarbij een waarde van 0 aangeeft dat de stroomkring is gesloten).

Werkt het niet?

Kijk in de antwoorden voor de oplossing

Veel succes!

Werkt het niet?

Kijk in de antwoorden voor de oplossing

Project 2.3 Licht sensors

In dit project gaan we leren hoe we een fotoweerstand, een lichtgevoelig type variabele weerstand, kunnen uitlezen met de analoge ingang van Arduino. Dit wordt ook wel een LDR (lichtafhankelijke weerstand) genoemd.

Tot nu toe heb je al geleerd hoe je LED’s kunt aansturen met de analoge uitgang van Arduino en hoe je een potentiometer kunt uitlezen, wat ook een type variabele weerstand is. We bouwen in dit project voort op die vaardigheid. Onthoud dat de analoge ingangen van Arduino (de pinnen gemarkeerd met A0-A6) een geleidelijk veranderend elektrisch signaal kunnen detecteren en dat signaal omzetten in een getal tussen 0 en 1023.

Je weet welke componenten je nodig hebt, probeer nu zelf de schakeling na te bouwen:

LED
220 ohm weestand
Licht gevoelige weerstand
4,7 kilo ohm weerstand

1. De fotoweerstand moet verbonden zijn met een analoge pin (in het voorbeeld A0) op de Arduino. De ene poot van de fotoweerstand wordt aangesloten op de 5V (+) en de andere op A0. Tussen die laatste poot en de - (GND) plaats je een weerstand van 4,7 kΩ.

2. De LED wordt aangesloten op een digitale pin (bijvoorbeeld pin 9) van de Arduino. De anode (de langere poot, +) van de LED wordt met pin 9 verbonden, terwijl de kathode (de kortere poot, -) in serie geschakeld is met een weerstand van 100 Ω tot 1 kΩ. Verbind de andere kant van de weerstand met de - (GND).

3. Het breadboard moet goed verbonden zijn met de Arduino. Sluit de + rail van het breadboard aan op de 5V van de Arduino en de - rail op de GND van de Arduino.

Kijk goed naar het voorbeeldcircuit om te zien hoe de componenten zijn verbonden. Je mag andere pinnen gebruiken als dat handiger is voor jouw schakeling.

Kom je er niet uit? Controleer de schematische weergave of kijk naar het voorbeeldcircuit voor hulp. Kun je het nog steeds niet oplossen? Bekijk dan het antwoord bij de oplossingen.

Schematische weergave

Open de code-editor en selecteer in het dropdownmenu links de optie “Blocks + Text” om de gegenereerde Arduino-code te bekijken. Volg mee terwijl we de code stap voor stap verkennen:

De variabele sensorValue

int sensorValue = 0;

Boven de setup() maken we een variabele aan om de waarde op te slaan die wordt uitgelezen van de fotoweerstand. Dit is een integer (int), wat betekent dat het een geheel getal is.

De setup() functie

void setup(){

pinMode(A0, INPUT);

pinMode(9, OUTPUT);

Serial.begin(9600);

}

In de setup() configureren we de pinnen met de functie pinMode().

• Pin A0 is ingesteld als INPUT zodat we het signaal van de fotoweerstand kunnen uitlezen.

• Pin 9 is ingesteld als OUTPUT om de LED aan te sturen.

• Met Serial.begin(9600) openen we een seriële communicatiekanaal, waarbij 9600 bits per seconde wordt gebruikt om berichten te verzenden.

De loop() functie

void loop(){

// Lees de waarde van de sensor

sensorValue = analogRead(A0);

// Print de sensorwaarde om het bereik te begrijpen

Serial.println(sensorValue);

In de hoofdlus lezen we met analogRead(A0) de waarde van pin A0 uit. Dit levert een getal op tussen 0 en 1023. Deze waarde wordt opgeslagen in sensorValue.

Met Serial.println(sensorValue) sturen we de sensorwaarde naar de seriële monitor, zodat je kunt zien hoe deze verandert.

De helderheid van de LED aanpassen

// Map de sensorwaarde naar een bereik voor de LED

analogWrite(9, map(sensorValue, 0, 1023, 0, 255));

delay(100); // Wacht 100 milliseconden

}

Hier gebruiken we de functie map() om de sensorwaarde van het bereik 0-1023 om te zetten naar 0-255, het bereik dat nodig is voor analogWrite().

• analogWrite(9, ...) stuurt de geschaalde waarde naar pin 9, wat de helderheid van de LED bepaalt.

• De delay(100) pauzeert de lus kort, zodat veranderingen in helderheid soepel verlopen.

Tips

• Commentaar in de code: Alles wat na // staat, is een uitleg voor mensen en wordt niet door de Arduino uitgevoerd.

• Test de code en experimenteer door bijvoorbeeld de pinnen of waarden aan te passen om te zien hoe dat de werking beïnvloedt.

Kom je er niet uit? kijk dan bij de antwoorden

Project 2.4 Spanning manipuleren

Laten we leren hoe we een potentiometer uitlezen met Arduino!

Een potentiometer is een draaibare variabele weerstand. In deze les maken we een eenvoudige schakeling met een soldeerloos breadboard en gebruiken we Arduino-code om een LED te besturen.

Wat je nu gaat leren

We gaan het geleidelijk veranderende elektrische signaal van een potentiometer uitlezen via de analoge ingangen van Arduino. Deze ingangen bevinden zich aan de andere kant van de Arduino, tegenover de digitale i/o-pinnen.

De analoge pinnen zijn verbonden met de ADC (Analog to Digital Converter) van de Arduino. Deze zet een analoog signaal (tussen 0V en 5V) om in een getal tussen 0 en 1023.

Bouw een Arduino-schakeling met een LED en een potentiometer

Volg deze instructies om de schakeling stap voor stap op te bouwen.

LED
220 ohm weerstand
250 kilo ohm potentiometer

Stap 1: Voeg de Arduino en het breadboard toe

1. Sleep een Arduino Uno en een breadboard naar het werkvlak vanuit het componentenpaneel.

Stap 2: Verbind de voedingsrails van het breadboard

1. Voedingsrails aansluiten:

• Verbind de positieve rail (+) van het breadboard met de 5V-pin van de Arduino met een rode draad.

• Verbind de negatieve rail (-) van het breadboard met de GND-pin van de Arduino met een zwarte draad.

2. Voedingsrails uitbreiden:

• Maak een verbinding tussen de linker- en rechterzijde van het breadboard:

• Gebruik een rode draad om de positieve rails (+) met elkaar te verbinden.

• Gebruik een zwarte draad om de negatieve rails (-) met elkaar te verbinden.

Stap 3: Verbind de LED en de weerstand

1. Plaats de LED:

• Plug de LED in het breadboard, zodat de pootjes in twee verschillende rijen zitten.

• Zorg ervoor dat de kathode (kortere poot, -) in de buurt van een weerstand wordt geplaatst.

2. Verbind de kathode met een weerstand:

• Sluit één kant van een weerstand (100 Ω tot 1 kΩ) aan op de kathode.

• Sluit de andere kant van de weerstand aan op de negatieve rail (-) van het breadboard.

3. Verbind de anode met Arduino pin 13:

• Sluit een draad aan tussen de anode (langere poot, +) van de LED en pin 13 van de Arduino.

Stap 4: Voeg de potentiometer toe

1. Plaats de potentiometer:

• Plug de drie pootjes van de potentiometer in drie verschillende rijen op het breadboard.

2. Verbind de potentiometer:

• Verbind één buitenste poot met de positieve rail (+) van het breadboard.

• Verbind de andere buitenste poot met de negatieve rail (-).

• Verbind de middelste poot van de potentiometer met A0 op de Arduino.

Tips

• LED Polariteit: Zorg dat de langere poot van de LED (anode, +) correct is aangesloten op Arduino pin 13.

• Weerstanden: Deze hebben geen polariteit, dus de oriëntatie maakt niet uit.

Met deze schakeling kun je nu analoge waarden lezen van de potentiometer en een LED aansturen.

Schematische weergave

Uitleg van de Arduino-code en hoe het werkt

Hieronder leggen we de verschillende delen van de code uit waarmee je een LED laat knipperen. De snelheid waarmee de LED knippert, wordt geregeld door de waarde van een potentiometer.

Stap 1: Variabele aanmaken

int sensorValue = 0;

• Wat doet dit?

Voordat de setup() begint, wordt een variabele sensorValue aangemaakt.

• Het datatype int betekent dat deze variabele hele getallen kan opslaan.

• De variabele wordt gebruikt om de waarde van de potentiometer op te slaan.

Stap 2: Instellen van de Arduino-pins

void setup()

{

pinMode(A0, INPUT);

pinMode(13, OUTPUT);

}

• Wat doet dit?

• pinMode(A0, INPUT);

• Pin A0 wordt ingesteld als een invoer (input). Deze leest de analoge waarde van de potentiometer.

• pinMode(13, OUTPUT);

• Pin 13 wordt ingesteld als een uitvoer (output). Hiermee wordt de LED aangestuurd.

Stap 3: De hoofdlus (loop)

De code in de loop() wordt continu uitgevoerd zolang de Arduino aanstaat.

Lees de waarde van de potentiometer

sensorValue = analogRead(A0);

• Wat doet dit?

• De functie analogRead(A0) leest de analoge spanning op pin A0.

• De waarde ligt tussen 0 (0V) en 1023 (5V).

• Deze waarde wordt opgeslagen in de variabele sensorValue.

LED aanzetten en pauzeren

digitalWrite(13, HIGH);

delay(sensorValue);

• Wat doet dit?

• digitalWrite(13, HIGH);

Zet de LED aan (5V op pin 13).

• delay(sensorValue);

Pauzeer het programma voor een aantal milliseconden gelijk aan de waarde van sensorValue.

LED uitzetten en pauzeren

digitalWrite(13, LOW);

delay(sensorValue);

• Wat doet dit?

• digitalWrite(13, LOW);

Zet de LED uit (0V op pin 13).

• delay(sensorValue);

Pauzeer opnieuw voor een aantal milliseconden gelijk aan sensorValue.

Hoe werkt de LED-knippering?

• Wanneer je de potentiometer draait, verandert de weerstand. Dit zorgt voor een andere analoge spanning die wordt gelezen door pin A0.

• De waarde van deze spanning (tussen 0-1023) bepaalt de duur van de pauze tijdens delay(sensorValue);.

• Hoe hoger de spanning, hoe langer de pauze en hoe langzamer de LED knippert.

Samenvatting van de functionaliteit

1. De potentiometer bepaalt de waarde van sensorValue (0-1023).

2. De LED knippert met een snelheid die afhankelijk is van de waarde van sensorValue.

• Hoge waarde → Langzame knippering.

• Lage waarde → Snelle knippering.

Test de code op een Arduino en draai aan de potentiometer om het knippertempo van de LED te veranderen!

Project 2.5 Servo motor

Alles over Servo’s: Compacte Nederlandse Uitleg

Wat is een servo?

Een servo is een speciale motor met een ingebouwde controller en meestal een feedback-potentiometer (zoals een volumeknop). Hierdoor kun je de positie nauwkeurig regelen. Servo’s zijn eenvoudig te bedienen met een microcontroller, zoals een Arduino.

Soorten servo’s

1. Standaard servo’s

• Grootte: Ongeveer 1.5” x 1.5” x 0.75”.

• Rotatie: 90°, 180° of soms continue rotatie.

• Constructie: Kunststof of metalen tandwielen (voor snelheid of kracht).

• Gebruik: Robotarmen, animatronics en precieze bewegingen.

2. Nano-servo’s

• Zeer klein, ter grootte van een munt.

• Gebruik: Kleine robots en mechanismen zoals knoppen indrukken.

3. Micro-servo’s

• Iets groter dan nano-servo’s, met meer kracht.

• Gebruik: Kleine constructies en modelbouw.

4. 1/4-schaal servo’s

• Groot en krachtig, vaak gebruikt in modelauto’s.

• Ideaal voor zware lasten, maar minder geschikt voor continue rotatie (tenzij aangepast).

Tandwielconstructie (Gearbox)

• Plastic tandwielen: Licht en goedkoop, maar breekbaar.

• Metalen tandwielen: Sterk en geschikt voor zware belasting.

• Koppel (Torque): Hoeveel kracht de motor kan leveren. Wordt gemeten in oz-in, kg-cm, of N-m.

Typen servo’s

1. Standaard servo’s

• Kunnen draaien tot een specifieke hoek (bijv. 112° van 180°).

• Beperkt door een potentiometer en een fysieke stop in de tandwielen.

• Ideaal voor robotarmen, grijpers en nauwkeurige posities.

2. Continue rotatie-servo’s

• Kunnen vrij draaien zonder beperking.

• Besturing: Richting en snelheid, geen positie.

• Geschikt voor aandrijfwielen van robots.

• Nadeel: Lage snelheid vanwege focus op koppel.

Voeding van een servo

Servo’s hebben drie draden:

• Signaal: Verbonden met een digitale pin op de Arduino.

• Voeding: 4.5V tot 6V.

• Aarde (Ground): Gedeeld met de Arduino.

Belangrijke tips bij voeding:

1. Gebruik niet de 5V-pin van de Arduino om de servo van stroom te voorzien (beperkte stroomsterkte, risico op schade door terugstroom).

2. Gebruik een aparte stroomvoorziening, zoals een 6V batterij.

3. Verbind de gronddraden (GND) van de Arduino en de batterij.

Samenvatting

• Servo’s zijn veelzijdige motoren voor precieze besturing.

• Kies de juiste servo voor jouw project: standaard, nano, micro of 1/4-schaal.

• Zorg voor een correcte voeding en deel de grond (GND) tussen componenten.

• Gebruik standaard servo’s voor posities en continue servo’s voor bewegingen.

Met deze kennis kun je eenvoudig servo’s gebruiken in je Arduino-projecten!!

We gaan nu bouwen,

de benodigde componenten zijn

Positioneel Mircoservo

Deze staat niet bij de standaard componenten, je moet in alle componenten zoeken, Maak de volgende afbeelding na

Juiste bekabeling van de servo

Initialiseren

We voegen de bibliotheek Servo.h toe met

#include <Servo.h>

we zetten het variabel positie op 0 met de code

int pos = 0;

Void setup

servo_9.attach(9, 500, 2500);

wordt gebruikt in Arduino-programmering om een servomotor aan een specifiek pin te koppelen en het bereik van de PWM (Pulse Width Modulation)-signalen te definiëren waar de servo op zal reageren.

Uitleg van de functie:

• servo_9: Dit is een instantie van de Servo-klasse, die gebruikt wordt om de servomotor te besturen.

• attach(9): Dit vertelt het programma dat de servo verbonden is met pin 9 op de Arduino. Deze pin zal nu de controle-signalen (PWM) naar de servomotor sturen.

• 500: Dit is de minimum pulsduur (in microseconden) die de servo zal accepteren. Het geeft de servo aan hoe kort de tijd is dat hij een puls moet ontvangen om de ene uiterste positie aan te geven (meestal 0 graden of volledig tegen de klok in).

• 2500: Dit is de maximum pulsduur (in microseconden) die de servo zal accepteren. Het vertelt de servo hoe lang de puls moet duren om de andere uiterste positie aan te geven (meestal 180 graden of volledig met de klok mee).

Wat gebeurt er:

• De 500 microseconde puls zal de servo naar zijn minimumpositie (0 graden) bewegen.

• De 2500 microseconde puls zal de servo naar zijn maximumpositie (180 graden) bewegen.

• De servo zal naar elke positie tussen de 0 en 180 graden bewegen, afhankelijk van de pulsduur binnen dit bereik (tussen 500 en 2500 microseconden).

Void loop

// beweeg de servo van 0 naar 180 graden in stappen // van 1 graad for (pos = 0; pos <= 180; pos += 1) { // geef de servo de opdracht naar de positie in de variabele 'pos' te gaan servo_9.write(pos); // wacht 15 ms totdat de servo de positie heeft bereikt delay(15); // Wacht 15 milliseconde(s) } for (pos = 180; pos >= 0; pos -= 1) { // geef de servo de opdracht naar de positie in de variabele 'pos' te gaan servo_9.write(pos); // wacht 15 ms totdat de servo de positie heeft bereikt delay(15); // Wacht 15 milliseconde(s) }

Project 2.6 Ultrasonische sensor

In dit project gaan we een ultrasone sensor gebruiken als afstand detector, hiervoor heb je nodig

3 x LED
3 X weerstand 220 ohm
Ultrasone sensor

Het LED-circuit

1. Start met de basisverbindingen:

• Plaats een Arduino Uno en een breadboard op je werkgebied.

• Verbind de 5V- en GND-pinnen van de Arduino met de voedings- (+) en grond- (-) rails van het breadboard met draden. Je kunt de draadkleuren aanpassen in de instellingen of met de toetsenbordnummers.

2. Plaats de LEDs:

• Voeg drie rode LEDs toe in rij E van het breadboard, met twee lege sockets tussen elke LED.

• Pas de LED-kleur aan via de instellingen als gewenst.

3. Voeg weerstanden toe:

• Verbind de kathode (korte poot, -) van elke LED met de grondrail (-) via een 220 Ohm weerstand.

• De waarde van de weerstand kan aangepast worden in het dropdownmenu.

4. Verbind de anodes:

• Sluit de anodes (lange poot, +) van de LEDs aan op digitale pinnen van de Arduino.

Sonarsensor

1. Selecteer de juiste sensor:

• In Tinkercad Circuits kun je kiezen tussen een driepinnige of vierpinnige ultrasone sensor., kies de vierpinnige sensor.

Verbind de sensor:

• Sluit de 5V-pin van de sensor aan op de 5V-rail van het breadboard.

• Verbind de GND-pin met de grondrail.

• TRIG-pin met Arduino.

• ECHO-pin met Arduino.

je kan de schematische weergave als voorbeeld gebruiken.

Schematische weergave

Voorbeeld onderdeel Long()

.

Programeren

Initialisatie

We stellen de Activatiegrens in op 350 doormiddel van int Activatiegrens = 320;
het variabele cm op 0 door int cm = 0;

Tot nu toe ben je bekend met setup() en loop(), maar in dit programma wordt de functie readUltrasonicDistance() gebruikt om de sensormetingen te beschrijven en gescheiden te houden van de hoofdcode van het programma.

Uitleg van de functie

• Teruggave van data: De functie begint met het aangeven van het type data dat het retourneert. In dit geval retourneert de functie een long, wat een decimaal getal met veel cijfers kan zijn.

• Naam van de functie: De naam van de functie (in dit geval readUltrasonicDistance()) kun je zelf kiezen.

• Argumenten:

• Binnen de haakjes staan de argumenten die de functie accepteert, in dit geval int triggerPin en int echoPin.

• Dit zijn variabele declaraties die de aansluitpinnen van de sensor specificeren.

• De pinwaarden worden doorgegeven aan de functie wanneer deze wordt aangeroepen in de hoofdcode (bijvoorbeeld in de loop()).

Wat doet de functie?

• Trigger-signaal sturen:

• De functie stelt de triggerPin in als uitgang (OUTPUT) en stuurt een kort signaal.

• Het signaal wordt gedurende 10 microseconden op HIGH gezet.

• Reistijd meten:

• De functie stelt de echoPin in als ingang (INPUT).

• Het meet de tijd die nodig is voor het signaal om terug te keren.

• Resultaat retourneren: De reistijd in microseconden wordt teruggestuurd naar de hoofdcode. Deze waarde kan vervolgens worden gebruikt om de afstand te berekenen.

Door de sensormetingen in een aparte functie te plaatsen, blijft de hoofdcode overzichtelijk en kun je dezelfde functie eenvoudig hergebruiken in andere delen van je programma.

Setup

In de setup, stel je doormiddel van pinMode() in, aan welke digitale pins je de LED's zijn verbonden. In de schematische weergave zijn dat pins 2, 3, & 4.

Loop

Dan kunnen we eindelijk beginnen met het echte programma,

Lees de Ultrasone sensor af en kopiër de waarde naar het variabele cm doormiddel van cm = 0.01723 * readUltrasonicDistance(#, #); Bij de eerste hashtag vul je het pinnumer in waarmee TRIG is verbonden en bij het tweede pinnummer vul je het nummer in waarmee ECHO is verbonden.

Dan heb je een overzicht nodig van alle combinaties die je wilt programmeren, neem als voorbeeld deze combinaties.

Stand	vanaf	tot	LED 1	LED 2	LED 3
0	320	*	UIT	UIT	UIT
1	250	320	AAN	UIT	UIT
2	100	250	AAN	AAN	UIT
3	*	100	AAN	AAN	AAN

het sterretje staat symbool voor geen detectie, de sensor heeft een minimum en maximum afstand, hiermee moet je rekening houden.

Gebruik nu je kennis over logische operatoren en voorwaardelijke code om de lampjes te laten branden.

Kom je er niet uit kijk bij de antwoorden.

Project 2.7 Thermometer

In dit project gaan we een temperatuurmeter aansluiten en afbeelden, gebruik hiervoor de setup van het vorige project, dat scheelt weer tijd.

De componenten die je nodig hebt zijn

Temperatuurmeter
3 X LED
3 X 220 ohm weerstand.

De temperatuurweerstand verbind je met + en - en de middelste 'poot' verbind je met een analoge pin.

Als je de LEDS nog in je project hebt zitten van vorige opgave kan je die laten staan.

Schematische Weergave

Dan kunnen we nu programeren

(De code lijkt heel erg op die van de vorige opdracht, probeer zelf de code te schrijven)

Initialisatie

Een basistemperatuur (vaste waarde)
een variabele waarin de metingen van de sensor kunnen worden opgeslagen

Setup

instellen met pinMode()

Analoge pin voor de sensorwaarden
3X digitale pin voor de LED

Loop

Eerst stel je de waarde van Celsius in doormiddel van celsius = map(((analogRead(A0) - 20) * 3.04), 0, 1023, -40, 125);
Daarna gebruik je de zelfde logica als met de ultrasone sensor en maak je een tabel met welke waarden wat moeten doen.

Als je er niet uitkomt kan je bij de antwoorden kijken.

Project 2.8 LCD

Als laatste gaan we een LCD installeren en programmeren, hiervoor heb je nodig

LCD
250 kilo ohm pot-meter
220 ohm weerstand

Zet de schakeling in elkaar volgens de schematische weergave.

Schematische Weergave

Dan kunnen we nu programmeren,

Initialisatie

#include <LiquidCrystal.h> (Bibliotheek)
Variabele die seconden telt
LiquidCrystal lcd_1(#, #, #, #, #, #);

Bij de tweede functie geef je aan met welke pins de LCD is verbonden, de punten zijn in het progamma Lings naar rechts.

Setup

lcd_1.begin(#, #);

Hierbij is de eerste hashtags het aantal kolommen en de tweede hashtag het aantal rijen op de LCD.

lcd_1.print("hello world!");

Nu hebben we de Hello World geprint op het display

Loop

lcd_1.setCursor(#, #);

Met deze functie stellen we de cursor in (waar de nieuwe text wordt veranderd/neergezet.) Voor de hashtags is weer de zelfde logica, eerst de kolom en dan de rij.

lcd_1.print(seconds);

De waarde van de variabele wordt nu afgebeeld.

delay(1000);

1 seconde wachten

seconds += 1

De variabele wordt met 1 verhoogt.

Als je er niet uit komt kan je in de antwoorden kijken.

Hoofdstuk 3 - Praktijk

Nu je verschillende circuits hebt geleerd en begrijpt hoe ze werken, is het tijd om deze kennis in de praktijk te brengen. Ga terug naar hoofdstuk 2 en bouw de projecten stap voor stap na, maar deze keer in het echt!

Tips voor het nabouwen:

1. Benodigdheden verzamelen:

verzamel eerst alle onderdelen die je nodig hebt en ga dan pas bouwen.
Twijfel je het het goede onderdeel is? Test het niet zomaar, vraag het aan iemand anders of zoek op het internet.
Soms zijn onderdelen echt kapot, hou er rekening mee.

2. Werk veilig:

Controleer de spanningen en sluit alles zorgvuldig aan om kortsluiting te voorkomen.
LET OP!!! WEERSTANDEN ALTIJD GEBRUIKEN
Zorg dat je Arduino correct is aangesloten op je computer of een externe voeding.

3. Test en kalibreer:

• Upload de bijbehorende code naar je Arduino.

• Controleer of de onderdelen, zoals LEDs of sensoren, werken zoals verwacht.

• Pas indien nodig de code aan om het gewenste effect te bereiken.

Waarom is dit belangrijk?

Door de circuits fysiek te bouwen, krijg je praktische ervaring met elektronica en versterk je wat je hebt geleerd. Het geeft je ook de kans om eventuele fouten te herkennen en op te lossen, wat een essentieel onderdeel is van het leren werken met hardware. En net als met je frans woordjes, is herhaling altijd goed.

Hoofdstuk 4 - Eigen ontwerp

Je hebt inmiddels geoefend met eenvoudige opdrachten en ontwerpen. De volgende opdrachten worden uitdagender en vragen om meer creativiteit en technische kennis. Je oefent hoe je verschillende onderdelen en technieken kunt combineren om een eindresultaat te maken.

Project 3.1 Thermostaat

Gebruik je kennis over LCD's en thermometers om een thermostaat te maken die de temperatuur op de LCD kan afbeelden.

Project 3.2 Afstand bepalen

Gebruik je kennis over LCD's en ultrasonische sensors om een afstandsmeter te maken die de afstand in centimeters afbeeld op de LCD.

Project 3.3 going crazy

Voor het eindproject “Going crazy” moet je 6 led’s om de beurt laten knipperen en de snelheid van dat knipperen moet je kunnen versnellen met f vertragen met een potmeter.

Hoofdstuk 5 - Eigen plan

Topper!!!!

Je hebt de lesmethode uitgelest, je hebt genoeg kennis om je eigen projecten te verzinnen en uit te werken. Gebruik alle kennis die deze lesmethode jou heeft geleerd om je eigen plannen te bedenken en uit te werken. Schrijf je ideeën en uitwerkingen op. Zo wordt alle kennis bewaard. Succes!

Atwoorden

Project 2.2

Voorbeeld goede schakeling

Juiste Code

Project 2.3

Foto juiste schakeling

Foto juiste Code

Project 2.4

Foto juiste schakeling

Foto juiste code

Project 2.5

Project 2.6

foto juiste schakeling

foto juiste Code

Project 2.6

Foto juiste schakeling

Foto juiste Code 1

Project 2.7

Foto juiste Code 2

Foto juiste schakeling

Foto juiste Code

Project 2.8

Foto juiste schakeling

Foto juiste code

Colofon
Het arrangement Arduino is gemaakt met Wikiwijs van Kennisnet. Wikiwijs is hét onderwijsplatform waar je leermiddelen zoekt, maakt en deelt.

Auteur

PWS: Website maken

Laatst gewijzigd

2025-01-30 11:28:29

Licentie

Dit lesmateriaal is gepubliceerd onder de Creative Commons Naamsvermelding-GelijkDelen 4.0 Internationale licentie. Dit houdt in dat je onder de voorwaarde van naamsvermelding en publicatie onder dezelfde licentie vrij bent om:

het werk te delen - te kopiëren, te verspreiden en door te geven via elk medium of bestandsformaat

het werk te bewerken - te remixen, te veranderen en afgeleide werken te maken

voor alle doeleinden, inclusief commerciële doeleinden.

Meer informatie over de CC Naamsvermelding-GelijkDelen 4.0 Internationale licentie.

Bij het maken van deze lesmethode is gebruik gemaakt van tinkercad en uitleg van instructables.

Geschreven door:

Max Rothkrantz & Taeke-Jan Siemensma

Aanvullende informatie over dit lesmateriaal

Van dit lesmateriaal is de volgende aanvullende informatie beschikbaar:

Toelichting

Les progamma voor de Arduino

Eindgebruiker

leerling/student

Moeilijkheidsgraad

gemiddeld

Arduino

nl

PWS: Website maken

2025-01-30 11:28:29

Les progamma voor de Arduino

leerling/student
Download
Downloaden

Het volledige arrangement is in de onderstaande formaten te downloaden.

pdf

json

IMSCP package

Metadata

Metadata overzicht (Excel)

LTI

Leeromgevingen die gebruik maken van LTI kunnen Wikiwijs arrangementen en toetsen afspelen en resultaten terugkoppelen. Hiervoor moet de leeromgeving wel bij Wikiwijs aangemeld zijn. Wil je gebruik maken van de LTI koppeling? Meld je aan via info@wikiwijs.nl met het verzoek om een LTI koppeling aan te gaan.

Maak je al gebruik van LTI? Gebruik dan de onderstaande Launch URL’s.

Arrangement

IMSCC package

Wil je de Launch URL’s niet los kopiëren, maar in één keer downloaden? Download dan de IMSCC package.

IMSCC package

Voor developers

Wikiwijs lesmateriaal kan worden gebruikt in een externe leeromgeving. Er kunnen koppelingen worden gemaakt en het lesmateriaal kan op verschillende manieren worden geëxporteerd. Meer informatie hierover kun je vinden op onze Developers Wiki.
Sluiten
Opties
Gebruik
Weergave
Wikiwijs is een dienst van