Arduino Workshop
Inhoudsopgave
Inleiding
2
TkkrLab
2
De cursus
2
Wat is Arduino?
3
Looplicht
4
De hardware
5
Een looplicht
9
Een looplicht met for loops
10
Knipperende LEDS zonder delay
13
Servo motor
15
Seriële monitor
18
Relais
22
LCD scherm
25
37 in 1 sensor kit
30
Basiskennis elektronica
31
Schemas
31
Weerstanden in serie en parallel
36
De wet van Ohm
37
Een enkele weerstand
37
Spanningsdeler
38
Een LED aan een Arduino
39
APPENDIX
40
Naslag / Internet bronnen
40
Variabelen type & waarden
40
Arduino schema zelfbouw
41
Arduino cheat sheet met C commando’s
42
Arduino Pin layout
43
Deze handleiding is geschreven door Renze Nicolai, Marco Geels en Dave Borghuis
TkkrLab - Arduino Workshop - 1 / 46
Inleiding
Arduino is een open-source elektronisch prototyping platform gebaseerd op flexibele,
gemakkelijk te gebruiken hardware en software. De Arduino is bedoeld voor kunstenaars,
ontwerpers, hobbyisten en iedereen geïnteresseerd in het maken van interactieve objecten
en omgevingen.
Voordeel van open source is dat de beschikbare hard- en software geheel naar eigen wens
kan worden aangepast, de schema’s en broncode is beschikbaar.
Tevens is er een grote en levendige Arduino community die vele projecten als open source
publiceren. Indien je een specifiek Arduino project wil maken en je google op “Arduino” en
wat je wil maken is de kans groot dat er al iemand is die iets soortgelijks heeft gemaakt. Je
kunt dan zijn project overnemen en aanpassen naar je eigen wensen.
TkkrLab
TkkrLab (Tukkerlab) is een hobbyplek voor techneuten. Voor de een is dit software maken of
met electronica bezig zijn of een 3D printer bouwen. Voordeel om dit in een groep fysiek bij
elkaar te doen is dat er altijd wel iemand aanwezig is die je verder kan helpen en het
natuurlijk ook een stuk gezelliger is dan dit alleen op een zolderkamertje te doen.
Onze space heeft ook een eigen werkplaats waar je kan solderen en projecten in elkaar kan
bouwen. Tevens verzorgen wij ook workshops over onderwerpen zoals de Arduino, open
source software, privacy, security, elektronica etc.
TkkrLab is iedere dinsdagavond open voor iedereen, je bent dan altijd van harte welkom om
een kijkje bij ons te nemen.
In nederland zijn er meer hackerspaces zoals TkkrLab, zie op ​http://hackerspaces.nl​ voor
een overzicht van de spaces en hun activiteiten.
De cursus
Tijdens de cursus leren we je hoe je de Arduino soft- en hardware kunt gebruiken om zelf
slimme apparaten te maken.
We beginnen de cursus met basiskennis over elektronica. In dit eerste deel van de cursus
zullen vragen als “Hoe moet ik alles aansluiten?”, “Hoe bereken ik de benodigde waarde van
een weerstand uit?” en “Waar moet ik rekening mee houden als ik elektronica bouw?”
worden beantwoord.
Daarna wordt een introductie gegeven over het Arduino platform: het installeren van de
software, het aansluiten van de Arduino Uno op uw computer en het programmeren van het
knipperlicht voorbeeld. Direct daarna krijgt je de mogelijkheid de zojuist opgedane
basiskennis over elektronica in de praktijk te brengen, met het bouwen van een looplicht.
TkkrLab - Arduino Workshop - 2 / 46
Nadat je bekend bent geraakt met het Arduino platform laten we je de uitgebreide
mogelijkheden van het Arduino platform zien: het aansturen van servo motoren, LCD
schermpjes en het communiceren met de computer over de seriële poort.
Wat is Arduino?
Arduino is een open source platform bestaande uit een stukje hardware en een
computerprogramma. Grote voordeel van de Arduino is dat er voor iedere doel een
geschikte Arduino versie beschikbaar is en dat er een grote community aanwezig is.
Tijdens deze cursus gaan we werken met een Arduino UNO. Dat is een printplaatje dat een
“ATMEGA328P” microcontroller van Atmel bevat. Voor die microcontroller kan je met de
Arduino software zelf een besturingsprogramma maken.
Een microcontroller is een soort mini-computertje. De ATMEGA chip bevat een stukje
opslaggeheugen, RAM, een processor. Daarnaast bevat de chip hardware om met de
buitenwereld te communiceren: via generieke in/uitgangs pinnen, meerdere soorten seriële
poorten en een analoog naar digitaal omzetter.
Met de Arduino software kunt je uw eigen besturingsprogramma maken, waarmee je kunt
bepalen wat de chip doet. Er draait geen besturingssysteem op de chip zoals bij een
normale computer, alleen jouw programma. Daardoor kan je met een microcontroller
sommige taken met veel meer precisie (realtime) en stabiliteit uitvoeren met een normale
computer.
Raspberry Pi kunt je ook gebruiken voor het aansturen van elektronica, maar dit is in feite
een kleine computer met een volledige (linux) os. Hierdoor is een Pi ook minder geschikt
voor het aansturen van een stepper motor omdat je hiervoor realtime aansturing nodig hebt.
Het komt ook wel voor dat je combinaties ziet van een Raspberry Pi en een arduino, zo heb
je de beste van beide werelden.
TkkrLab - Arduino Workshop - 3 / 46
Looplicht
In dit hoofdstuk leert je hoe je een looplicht van LEDs kunt bouwen met een Arduino bord.
Eerst leert je hoe je een LED aansluit op de Arduino, waarna de programmacode voor het
realiseren van een looplicht wordt uitgelegd.
Voor het uitvoeren van de les in dit hoofdstuk heeft je de volgende onderdelen nodig:
8 LEDs
8 weerstanden
Waarde: 1000 Ω
Te herkennen aan de ringen “bruin zwart rood goud”
1 breadboard
10 breadboard draden
Een Arduino Uno
TkkrLab - Arduino Workshop - 4 / 46
De hardware
In deze les gaat je een schakeling opbouwen op een breadboard. Een breadboard bevat
gaatjes die in een patroon met elkaar verbonden zijn, waardoor je elektrische verbindingen
kunt maken tussen de verschillende componenten die je er in plaatst.
De gaatjes van een breadboard zijn op de volgende manier met elkaar verbonden:
De zwarte lijntjes worden meestal gebruikt om componenten aan te sluiten, terwijl de rode
en blauwe lijn als voedingsrails gebruikt worden.
We gaan met de aan het begin van dit hoofdstuk genoemde componenten een schakeling
bouwen. Het schema van de schakeling ziet er zo uit:
In het echt ziet de schakeling er zo uit:
TkkrLab - Arduino Workshop - 5 / 46
Omdat we een looplicht gaan bouwen is het nodig de schakeling meerdere keren op te
bouwen. Op een breadboard komt dat er als volgt uit te zien:
We beginnen met het monteren van de leds op het breadboard:
In een schema wordt een led als volgt getekend:
Hierbij zien we direct dat een led een positieve en een negatieve aansluiting
heeft.
TkkrLab - Arduino Workshop - 6 / 46
De lange poot van de led is de + en de korte poort is de - In onze tekening moet de + (lange
poot) van de led richting de weerstand staan en de – (korte poot) in de – aansluiting van het
breadboard (bovenkant).
Nu ga je de weerstanden monteren:
In een schema wordt een weerstand getekend zoals hiernaast:
Weerstanden hebben geen + of – dus het maakt niet uit hoe je
deze monteert op je bord.
Ons bord ziet er nu zo uit:
Nu pakken we de Arduino erbij:
Met de breadboard draden maken we de verbindingen tussen de arduino en je breadboard
zoals op deze tekening :
TkkrLab - Arduino Workshop - 7 / 46
Begin met de rode draden aan te sluiten volgens de tekening pin 2 van de arduino op de
rechter weerstand, pin 3 op de weerstand er naast tot je bij pin 9 bent.
Daarna de blauwe draad van pin GND van de arduino naar de – aansluiting van het
breadboard.
De laatste blauwe draad heb je nodig om de onderbreking van het breadboard in het midden
van de – baan door te verbinden.
Je schakeling is nu klaar.
Om de schakeling te testen heeft een van onze vrijwilligers al een programma in de arduino
geladen.
Dit programma laat elke ledje van links naar rechts 1 seconde oplichten.
Vraag een vrijwilliger van Tkkrlab om je schakeling te controleren voordat je de
Arduino aansluit op de voedingsspanning.
De arduino software
Arduino software (te downloaden op​ http://arduino.cc/en/Main/Software​)
Op de laptops van TkkrLab zijn deze programma’s al voorgeinstalleerd.
We beginnen met een simpel programma dat je zelf moet overtypen in de arduino software.
Alle text achter de // doet niets en staat er als informatie voor jezelf of anderen die dit
programma moeten gebruiken. Ik gebruik deze optie dan ook om uit te leggen wat het
programma doet.
void setup() //begin met setup parameters
{
pinMode(9, OUTPUT); //initialiseer pin 9
}
void loop() //Hier begint het programma te lopen
{
digitalWrite(9, HIGH); //zet de led op pen 9 aan
delay(1000); //wacht 1 seconde
digitalWrite(9, LOW); //zet de led op pen 9 uit
delay(1000); //wacht 1 seconde
}
Test dit programma met de compile button
Als je de tekst goed overgetypt hebt zou het scherm er zo uit moeten zien als hieronder.
Mocht dit niet zo zijn controleer dan je programma nog eens op typ fouten.
Mocht je er dan nog niet uitkomen vraag dan een vrijwilliger van TkkrLab om je te helpen.
TkkrLab - Arduino Workshop - 8 / 46
Nu gaan we je programma uploaden naar de arduino hardware.
Sluit de arduino aan met de usb kabel en druk op de upload button
De eerste keer dat je een nieuwe Arduino aansluit is het nodig de juiste seriële poort te
kiezen. Dit kan je doen door vanuit het “tools” menu het “Port” menu te openen en de juiste
poort aan te klikken.
Een looplicht
De simpelste manier om van het knipperlicht voorbeeld hierboven een looplicht te maken is
door het herhalen van de pinMode en digitalWrite commandos.
De code komt er dan als volgt uit te zien:
void setup()
pinMode(2,
pinMode(3,
pinMode(4,
...
}
{
OUTPUT);
OUTPUT);
OUTPUT);
void loop() {
digitalWrite(2,
delay(1000);
digitalWrite(2,
digitalWrite(3,
delay(1000);
digitalWrite(4,
...
}
HIGH);
LOW);
HIGH);
LOW);
TkkrLab - Arduino Workshop - 9 / 46
Een looplicht met for loops
In plaats van het herhalen van de gebruikte functies is het ook mogelijk om gebruik te maken
van een “for loop”. Een for loop zorgt er voor dat een sectie (of blokje) code herhaald wordt
zolang een bepaalde conditie waar is.
Om een for loop te kunnen gebruiken is het nodig een aantal verschillende concepten uit te
leggen.
Variabelen
In een Arduino zit werkgeheugen. Je kunt informatie opslaan in het werkgeheugen door
variabelen te declareren.
Een voorbeeld van een type variabele waarin een getal kan worden opgeslagen is de
“integer”. Een integer wordt in de programmeertaal C (die gebruikt wordt om Arduino te
programmeren) afgekort tot “int”.
Het declareren van een variabele doe je door “<type> <naam>;” of “<type> <naam> =
<initiële waarde>;” op te nemen in het programma. Bijvoorbeeld: “int test = 3;”
Er is maar een beperkte ruimte voor variabelen, daarom is het belangrijk altijd een type
variabele te kiezen dat zo klein mogelijk is maar toch voldoende ruimte biedt voor de
gegevens die je op wilt slaan.
Een deel van de typen variabelen die je kunt gebruiken zijn:
Arduino ondersteunt ook het werken met tekst. Dit werkt met behulp van het String object.
Het werken met strings is geen onderdeel van deze workshop, maar online kan je een hoop
informatie vinden over het String object.
TkkrLab - Arduino Workshop - 10 / 46
De for loop
Een for loop bestaat uit drie statements, omvat door for().
for( <initialisatie>; <vergelijking>; <toename> )
De initialisatie is het stukje code wat één keer uitgevoerd wordt op het moment dat de for
loop begint. Je kunt het veld leeg laten, een variabele initialiseren (bijvoorbeeld “i = 0”) of
een variabele declareren (int i = 0).
De vergelijking bepaald of de for loop opnieuw uitgevoerd zal gaan worden of dat het
programma verder gaat. Zolang de vergelijking waar is zal de for loop zich blijven herhalen.
Een voorbeeld is “i < 10”, waarbij de for loop zichzelf zal herhalen zolang “i” lager is dan 10.
De toename zorgt er voor dat er iedere iteratie van de for loop een variabele aangepast
wordt. Je kunt het veld leeg laten, maar normaal gesproken wordt het veld gebruikt voor het
verhogen van de teller (in ons voorbeeld “i”). Dit kan worden gedaan door “i = i + 1” of “i++”
in te vullen. “I++” is een verkorte vorm van “i = i + 1” en doet exact hetzelfde. “I--” bestaat
ook en is gelijk aan “i = i - 1”.
Namespaces (ofwel “blokken” code)
Het is je waarschijnlijk al opgevallen dat de code die in functies, zoals setup() en loop() staat
omsloten is met “{” en “}”. Deze haken geven een namespace aan.
Hoewel een namespace nodig is om aan te geven dat code onderdeel is van een functie
worden namespaces ook op andere plekken gebruikt, bijvoorbeeld in loops als “while” en
“for”, maar ook om keuzes te maken op basis van vergelijkingen, met een “if” statement.
Een belangrijke eigenschap van een namespace is het volgende: variabelen die binnen een
namespace gedeclareerd worden zullen worden verwijderd zodra het programma de
namespace verlaat.
In de praktijk betekent dit het volgende:
int i = 5;
{
i = 6;
}
int j = i;
J is hier gelijk aan 6;
TkkrLab - Arduino Workshop - 11 / 46
int i = 5;
{
int i = 6;
}
int j = i;
J is hier gelijk aan 5, want de variabele i binnen de namespace is hier niet gelijk aan de
variabele i buiten de namespace.
{
int i = 6;
}
int j = i;
Dit programma zal niet gebouwd kunnen worden, want variabele i bestaat niet buiten de
scope van de namespace waarin hij gedefinieerd is.
Het looplicht met for loops
Onderstaande programma doet precies hetzelfde als het eerder gegeven voorbeeld: pin 2
tot en met 4 output maken en vervolgens een looplicht van pin 2 tot en met pin 4 laten lopen.
void setup() {
for (int i = 2; i < 5; i++) {
pinMode(i, OUTPUT);
}
}
void loop() {
for (int i = 2; i < 5; i++) {
digitalWrite(i, HIGH);
delay(1000);
digitalWrite(i, LOW);
}
delay(1000):
}
TkkrLab - Arduino Workshop - 12 / 46
Knipperende LEDS zonder delay
In de vorige lessen hebben we vaak de functie delay gebruikt.
Deze functie is in sommige gevallen erg handig maar delay kan ook erg lastig zijn als je
bijvoorbeeld 2 dingen "tegelijk" wilt doen. Stel je voor dat je 1 led wilt laten knipperen met
een tussenpauze van 100ms en de andere met een tussenpauze van een seconde.
Wanneer je een delay gebruikt zal de arduino elke keer een seconde staan wachten en krijg
je de 2de led nooit op een snelheid van 100ms.
De Arduino beschikt ook over een interne klok, hiermee kunnen we dus vergelijken en
bepalen wanneer er een seconde voorbij en is wanneer er 100ms voorbij zijn.
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
TkkrLab - Arduino Workshop - 13 / 46
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over of kopieer deze naar de Arduino IDE:
// constants won't change. Used here to set a pin number:
const int ledPin = 12;// the number of the LED pin
// Variables will change:
int ledState = LOW;
// ledState used to set the LED
// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;
// will store last time LED was
updated
// constants won't change:
const long interval = 1000;
// interval at which to blink (milliseconds)
void setup() {
// set the digital pin as output:
pinMode(ledPin, OUTPUT);
}
void loop() {
// here is where you'd put code that needs to be running all the time.
// check to see if it's time to blink the LED; that is, if the difference
// between the curr time and last time you blinked the LED is bigger than
// the interval at which you want to blink the LED.
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
// set the LED with the ledState of the variable:
digitalWrite(ledPin, ledState);
}
}
Klik op de upload button.
We zien nu 1 led knipperen.
Opdracht: pas de code aan zodat je 2 leds met een verschillend interval kunt laten
knipperen.
TkkrLab - Arduino Workshop - 14 / 46
Servo motor
Dit is terug te vinden in de configuratie van je operating system
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
Start het Arduino programma en sluit de USB kabel aan.
Eerst gaan we testen of de servo werkt.
Typ de volgende code over of kopieer deze naar de arduino ide:
#include <Servo.h>
Servo myservo;
// create servo object to control a servo
void setup()
{
myservo.attach(9);
}
// attaches the servo on pin 9 to the servo object
void loop() {
myservo.write(0);
TkkrLab - Arduino Workshop - 15 / 46
delay(900);
myservo.write(90);
delay(900);
myservo.write(180);
delay(900);
}
Klik op de upload button.
De servo moet nu van 0 tot 90 graden draaien daar even wachten en dan door
draaien naar 180 graden.
Deel 2 :
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema :
We gaan de servo nu bedienen met een potmeter.
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over of kopieer deze naar de arduino ide:
#include <Servo.h>
TkkrLab - Arduino Workshop - 16 / 46
int servopin = 9;
int potmeterpin = A0;
Servo myservo; // create servo object to control a servo
int pos = 0;
// variable to store the servo position
void setup() {
Serial.begin(9600);
myservo.attach(servopin);
// attaches the servo on pin 9 to
// the servo object
}
void loop() {
int value = analogRead(potmeterpin);
pos = map(value, 0, 1023, 0, 160);
myservo.write(pos);
Serial.print("waarde potmeter = ");
Serial.print(value);
Serial.print("
Positie servo = ");
Serial.println(pos);
delay(10);
}
Klik op de upload button.
Wanneer je nu aan de potmeter draait zal de servo volgen.
TkkrLab - Arduino Workshop - 17 / 46
Seriële monitor
Dit is terug te vinden in de configuratie van je operating system
We hebben bij les 1 al gezien dat de arduino software beschikt over een serial
monitor.
Vandaag gaan we zien wat er met de serial monitor mogelijk is:
Deel 1:
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over:
int potmeterpin = A0; //set de pin waar de potmeter op aangesloten is.
int value = 0 ; //zet variabele waar we de waarde van de potmeter in kunnen
stoppen.
void setup() {
Serial.begin(9600);
}
void loop() {
value = analogRead(potmeterpin); //lees de waarde van de potmeter (A0)
Serial.println(value); //print de waarde value naar de serial monitor.
TkkrLab - Arduino Workshop - 18 / 46
}
Klik op de upload button.
Als de software klaar is met uploaden klik op de serial monitor button.
Als je nu aan de potmeter draait zul je zien dat de waarde in de serial monitor
veranderd. Dit kan er als volgt uitzien, bij jouw kunnen de waarden anders zijn.
10
23
56
109
63
42
Deel 2:
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over:
int potmeterpin = A0; //zet de pin war de potmeter op aangesloten is
int buttonpin = 2; //zet de pin waar de button op aangesloten is.
int value = 0; //zet een variabele waar we de waar van de potmeter is
kunnen stoppen
TkkrLab - Arduino Workshop - 19 / 46
void setup() {
Serial.begin(9600); //Start de serial monitor
pinMode(buttonpin,INPUT); //zet de buttonpin als input
digitalWrite(buttonpin,HIGH); //zet pin hoog
}
void loop() {
Serial.print("Potmeter = "); //print de text potmeter
value = analogRead(buttonpin); //lees de waarde van input pin potmeterpin
Serial.print(value); //print de waarde value naar de serial monitor
Serial.print("
"); //print aantal spaties
Serial.print("button = "); //print de tekst button
Serial.println(digitalRead(buttonpin)); //schrijf waarde van de button
}
Klik op de upload button.
Als de software klaar is met uploaden klik op de serial monitor button.
We hebben nu geleerd hoe om te gaan met de serial monitor, deze les is zeer
waardevol als je ooit een probleem hebt met een stukje hardware en je hebt geen
idee waar het fout gaat.
Lees alle waardes die binnen komen op het Arduino bordje uit en print ze naar de
monitor, je zult direct zien wat er binnen komt en of dat is wat je verwacht had.
Deel 3:
Je kunt ook waardes schrijven vanuit de serial monitor naar het arduino bord.
Bouw nogmaals de schakeling uit vorige les:
TkkrLab - Arduino Workshop - 20 / 46
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over:
int led1 = 13; //koppel led 1 aan pin 13
int led2 = 12; //koppel led 2 aan pin 12
String input = "";
void setup() {
Serial.setTimeout(10);
Serial.begin(9600);
pinMode(led1,OUTPUT); //set pin led1 als uitgang
pinMode(led2,OUTPUT); //set pin led2 als uitgang
}
Void handleSerialInput() {
if (input.startsWith("l")) {
digitalWrite(led1,HIGH);
delay(1000);
digitalWrite(led1,LOW);
}
if (input.startsWith("r")) {
digitalWrite(led2,HIGH);
delay(1000);
digitalWrite(led2,LOW);
}
input = "";
}
void loop() {
while (Serial.available() > 0) {
char c = Serial.read();
if (c == '\n') {
handleSerialInput();
} else if (c != '\r') {
Input += c;
}
}
}
Klik op de upload button.
Als de software klaar is met uploaden klik op de serial monitor button.
Als je nu een “l” typt in de serial monitor gevolgd door enter gaat de linker led 1
seconde branden.
Typ je een “r” gevolgd door enter dan gaat de rechter led 1 seconde branden.
TkkrLab - Arduino Workshop - 21 / 46
Relais
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
sluit de Arduino aan volgens onderstaand schema:
De gebruikte transistor is de NPN uitvoering (in ons setje een BC547).
TkkrLab - Arduino Workshop - 22 / 46
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over of kopieer deze naar de arduino ide:
int relais1 = 12; // koppel relais 1 aan pin 12
void setup() {
pinMode(relais1, OUTPUT); //set pin1 (12) als uitgang
}
void loop() {
digitalWrite(relais1, HIGH); //set de uitganspin van relais1 (12) hoog
delay(1000);
//wacht 1 seconde (1000 ms)
digitalWrite(relais1, LOW); //set de uitganspin van relais1 (12) laag
delay(1000);
//wacht 1 seconde (1000 ms)
}
Klik op de upload button.
Als je deze opdracht goed uitgevoerd hebt gaan de leds om en om knipperen en
hoor je het relais klikken.
Deel 2:
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
TkkrLab - Arduino Workshop - 23 / 46
sluit de Arduino aan volgens onderstaand schema:
Start het Arduino programma en sluit de USB kabel aan.
Typ de volgende code over of kopieer deze naar de arduino ide:
int relais1 = 12; // koppel relais 1 aan pin 12
int ldr1 = A0; // koppel ldr 1 aan pin A0
void setup() {
pinMode(relais1, OUTPUT); //set relais1 (pin 12) als uitgang
}
void loop() {
int value = analogRead(ldr1); //lees de waarde van LDR1
if (value < 300) digitalWrite(relais1, HIGH); //Als de waarde van
LDR1 lager is dan 300 set de uitganspin van relais1 (12) hoog
if (value > 400) digitalWrite(relais1, LOW); //Als de waarde van LDR1
hoger is dan 400 set de uitganspin van relais1 (12) laag
}
Klik op de upload button.
Als je deze opdracht goed uitgevoerd hebt gaat het relais schakelen als je je hand
over de LDR beweegt. We hebben hiermee een schemer-schakeling gebouw om
bijvoorbeeld je tuinverlichting te schakelen.
TkkrLab - Arduino Workshop - 24 / 46
LCD scherm
Zorg er voor dat je alle voedingsspanningen
los koppelt (usb niet aangesloten op de pc en
geen power adapter aangesloten op de
voedingsplug).
sluit de Arduino aan volgens onderstaand
schema:
Start het Arduino programma en sluit de USB kabel aan.
Vanaf nu gaan we de code niet meer overtypen:
selecteer onderstaande code en kopieer deze naar de arduino software:
#include <LiquidCrystal.h> //laad de bibliotheek lcd scherm
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); //stel de pinnen in
void setup() {
lcd.begin(16, 2); //vertel de arduino welk type scherm we gebruiken
lcd.setCursor(0, 0); //set de cursor op de eerste letter van de eerste
regel
lcd.print("Arduino workshop"); //print text
TkkrLab - Arduino Workshop - 25 / 46
lcd.setCursor(0, 1); //set de cursor op de eerste letter van de 2de regel
lcd.print("Tkkrlab"); //print text
}
void loop() {
}
Klik op de upload button.
Deel 2 :
We gebruiken hetzelfde ontwerp om een aantal opties uit te leggen.
#include <LiquidCrystal.h> //laad de bibliotheek voor het lcd scherm
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); //stel de pinnen in die we gebruiken voor het
scherm
void lcdprint(String line1, String line2) {
lcd.clear();
//maak het scherm leeg
lcd.print(line1);
//print text
lcd.setCursor(0, 1);
//set de cursor 2de regel
lcd.print(line2);
//print text
}
void setup() {
Serial.setTimeout(10);
Serial.begin(9600);
lcd.begin(16, 2);
//vertel de arduino welk type scherm we gebruiken
lcdprint("Arduino workshop", "TkkrLab"); //print text
delay(5000);
//wacht 5 seconden
lcdprint("hergebruik van", "dezelfde functie");//print text
delay(5000);
//wacht 5 seconden
lcdprint("type text:", "");
//print text
}
void loop() {
if (Serial.available() > 0) {
//kijk of er serial data binnen komt
String incoming_serial;
//maak een container voor de seriële data
incoming_serial=Serial.readString(); //stop de serial data in de container
lcdprint("type text:", incoming_serial); //print de text uit de container
}
}
In dit voorbeeld heb ik de aansturing van het scherm verwerkt in een functie, ook
gebruiken we hier de serial monitor functie uit les 3 om text op het lcd te schrijven.
Voordelen:
● je hoeft de code maar 1 keer in te typen.
● code beter leesbaar.
● code makkelijker aan te passen (alles op 1 plek in plaats van door het hele
programma).
● gebruikt minder flash geheugen van de arduino dus er is meer ruimte voor
andere code).
Deel 3:
TkkrLab - Arduino Workshop - 26 / 46
Zorg er voor dat je alle voedingsspanningen los koppelt (usb niet aangesloten op de
pc en geen power adapter aangesloten op de voedingsplug).
Voeg 2 drukknoppen toe aan het schema:
Start het Arduino programma en sluit de USB kabel aan.
Code kunt je ook downloaden op
https://www.tkkrlab.space/Tkkrlab_Arduino_Workshop.zip
#include <LiquidCrystal.h>
//laad de bibliotheek voor het lcd scherm
LiquidCrystal lcd(2, 3, 4, 5, 6, 7); //aansluit pinnen voor het lcd scherm
int button1 = A4;
//aansluitpin eerste button
int button2 = A5;
//aansluitpin 2de button
int button = 0;
//waarde van de button (dit kan 0, 1 of 2 zijn)
int buttoncounter = 0; //counter voor de buttons
int menuoption = 0;
//waarde voor het menu
long frequencyvalue = 144000; //waarde van de frequentie
int powervalue = 10; //waarde van het vermogen
int micgainvalue = 10; //waarde van de micgain
int ctcssvalue = 0;
//teller voor de ctcss waardes
float ctcssvaluearray[] = {71.9, 77.0, 82.5, 88.5}; //ctcss waardes
int shiftvalue = 0;
//teller voor de repeater shift
float shiftvaluearray[] = {0, 600, 1600, 7600, -600, -1600,7600}; //repeatershift
waarde
void readbuttons() {
if (digitalRead (button1) == LOW) {
commando's uit
buttoncounter ++;
//functie om de buttons uit te lezen
//als button 1 laag is voer de volgende
//tel 1 bij de buttoncounter op
TkkrLab - Arduino Workshop - 27 / 46
if (buttoncounter == 2) button = 1;//als de buttoncounter 2 is zet de waarde
button op 1
else button = 0;
//anders zet de waarde button op 0
}
if (digitalRead (button2) == LOW) { //als button 2 laag is voer de volgende
commando's uit
buttoncounter ++;
//tel 1 bij de buttoncounter op
if (buttoncounter == 2) button = 2;//als de buttoncounter 2 is zet de waarde
button op 2
else button = 0;
//anders zet de waarde button op 0
}
if (digitalRead (button1) == HIGH && digitalRead (button2) == HIGH) buttoncounter
= 0; //als beide buttons hoog zijn zet de waarde van de buttoncounter op 0
}
void clearlcd() {
lcd.setCursor(0, 0);
regel
lcd.print("
lcd.setCursor(0, 1);
regel
lcd.print("
}
//set de cursor op de eerste letter van de eerste
"); //maak de regel leeg
//set de cursor op de eerste letter van de 2de
"); //maak de regel leeg
void lcdprint(String line1, float line2, String line3) {
lcd.setCursor(0, 0);
//set de cursor op de eerste letter van de eerste
regel
lcd.print(line1);
//print text 1
lcd.setCursor(0, 1);
//set de cursor op de eerste letter van de 2de
regel
lcd.print(line2);
//print text 2
lcd.print(line3);
//print text 3
}
void menu() {
if (button == 1) {
//als de waarde button 1 is voer de
commando's uit
menuoption ++;
//tel 1 bij de menuoption op
clearlcd();
//maak het lcd scherm, leeg
}
if (menuoption == 0) frequency();
//als de waarde menuoption 0 is run
frequency
if (menuoption == 1) ctcsstone();
//als de waarde menuoption 1 is run
ctcsstone
if (menuoption == 2) power();
//als de waarde menuoption 2 is run
power
if (menuoption == 3) micgain();
//als de waarde menuoption 3 is run
micgain
if (menuoption == 4) repeatershift();//als de waarde menuoption 4 is run
repeatershift
if (menuoption == 5) menuoption = 0; //als de waarde menuoption 5 zet de
menuoption terug naar 0
}
void frequency() {
lcdprint("Frequency", frequencyvalue, " KHz");
posities op het scherm (naam, waarde, eenheid)
if (button == 2) frequencyvalue = frequencyvalue + 25;
ingedrukt word tel 25 bij de frequency op
TkkrLab - Arduino Workshop - 28 / 46
volgende
functie
functie
functie
functie
functie
waarde
//functie frequency
//lcd print 3
//als button 2
if (frequencyvalue == 146000) frequencyvalue = 144000;
hoog wordt ga terug naar de beginwaarde
}
//als de waarde to
void ctcsstone() {
//functie ctcsstone
lcdprint("CTCSS tone", ctcssvaluearray[ctcssvalue], " Hz"); //lcd print 3
posities op het scherm (naam, waarde, eenheid)
if (button == 2) ctcssvalue ++;
//als button 2
ingedrukt word tel 1 bij de ctcssvalue op
if (ctcssvalue == 4) ctcssvalue = 0;
//als de waarde to
hoog wordt ga terug naar de beginwaarde
}
void power() {
lcdprint("Power", powervalue, " Watt");
posities op het scherm (naam, waarde, eenheid)
if (button == 2) powervalue ++;
ingedrukt word tel 1 bij de powervalue op
if (powervalue == 11) {
hoog is voer de volgende commando's uit
powervalue = 1;
begin waarde
clearlcd();
}
}
//functie power
//lcd print 3
void micgain() {
lcdprint("Mic gain", micgainvalue, " dB");
posities op het scherm (naam, waarde, eenheid)
if (button == 2) micgainvalue = micgainvalue + 1;
ingedrukt word tel 1 bij de migainvalue op
if (micgainvalue == 11) {
hoog is voer de volgende commando's uit
micgainvalue = 0;
begin waarde
clearlcd();
}
}
//functie micgain
//lcd print 3
//als button 2
//als de waarde to
//ga terug naar de
//wis het lcd scherm
//als button 2
//als de waarde to
//ga terug naar de
//wis het lcd scherm
void repeatershift() {
//functie micgain
lcdprint("repeater shift", shiftvaluearray[shiftvalue], " KHz"); //lcd print 3
posities op het scherm (naam, waarde, eenheid)
if (button == 2) shiftvalue ++;
//als button 2
ingedrukt word tel 1 bij de migainvalue op
if (shiftvalue == 6) {
//als de waarde
to hoog is voer de volgende commando's uit
shiftvalue = 0;
//ga terug naar
de begin waarde
clearlcd();
//wis het lcd
scherm
}
}
void setup() {
//deze functie wordt 1 keer uitgevoerd bij het opstarten
lcd.begin(16, 2);
//vertel de arduino welk type scherm we gebruiken
pinMode (button1, INPUT);
//set de buttonpin als ingang
digitalWrite (button1, HIGH); //set de buttonpin hoog zodat we deze laag kunnen
trekken naar GND
pinMode (button2, INPUT);
//set de buttonpin als ingang
TkkrLab - Arduino Workshop - 29 / 46
digitalWrite (button2, HIGH);
kunnen trekken naar GND
}
void loop() {
readbuttons();
menu();
}
//set de buttonpin hoog zodat we deze laag
//start de functie readbuttons
//start de functie menu
In dit programma hebben we een hele set aan extra functies toegevoegd.
Ik zal deze tijdens de workshop 1 voor 1 doorlopen en uitleggen.
37 in 1 sensor kit
Online zijn er ook diverse sensoren waarmee je op een eenvoudige en snelle manier
met Arduino kan combineren. Deze sensoren hebben dan al de eventueel
benodigde weerstanden en andere componenten dus kun je meestal rechtstreeks
aansluiten op de Arduino.
Meer informatie over deze sensoren kun je onder andere vinden op :
https://tkkrlab.nl/wiki/Arduino_37_sensors
TkkrLab - Arduino Workshop - 30 / 46
Domotica
We gebruiken in onze workshop de nodeMCU maar er zijn vele alternatieve boards
beschikbaar.
CH340 chip (en driver)
https://liudr.wordpress.com/2015/10/08/arduino-board-install-problems/
Meestal wil je bijvoorbeeld met je telefoon een schakelaar aan of uit zetten, dit kan via IoT
sensoren en schakelaars. Zolang deze alleen beschikbaar zijn in je eigen netwerk hoef je
niet al te veel zorgen te maken over beveiliging, maar als deze voor de hele wereld te
bereiken is moet je deze wel goed beveiligen. We besteden hier geen specifieke aandacht
aan in onze workshop maar wees hier bewust van.
ESP8266
De ESP is een wifi chip ontwikkeld door expressive en erg populair in IoT projecten. In deze
chip zit een microprocessor met een Wifi functionaliteit die je op de Arduino manier kunt
programmeren.
ESP32
Opvolger van de ESP8266 met mogelijkheid om ook via microPython programma’s te
maken.
nodeMCU
Deze gebruiken we in onze workshop. De nodeMCU is een ‘dev’ board met een USB
aansluiting (makkelijk voor het programmeren) en een ESP8266 chip.
Je kunt deze nodeMCU programmeren vanuit de vertrouwde Arduino IDE maar hiervoor zul
je een aantal hulptools moeten installeren. Om de tools voor de nodeMCU binnen de
Arduino IDE beschikbaar te krijgen moeten we deze hardware toevoegen aan de ‘boards
manager’.
Open binnen de Arduino IDE de voorkeuren / preferences en vul bij “Additional Board
Manager URLs” de waarde
“http://arduino.esp8266.com/stable/package_esp8266com_index.json”​ in.
Ga vervolgens naar menu “Tools -> Board” en installeer de esp8266 platform. Hiermee
worden de benodigde extra tools geïnstalleerd in de Arduino IDE.
Specificaties :
1 Mb memory
Processor : ATmega16U2 op 3.3V
TkkrLab - Arduino Workshop - 31 / 46
Voorbeeld webserver met LED’s aan/uit en lezen analoge pinnen
https://gist.github.com/igrr/3b66292cf8708770f76b
TkkrLab - Arduino Workshop - 32 / 46
Basiskennis elektronica
Afhankelijk van uw achtergrond kan het zijn dat je delen van dit hoofdstuk over kunt slaan.
Eerst zal de basistheorie voor het lezen van een schema worden besproken, waarna
eigenschappen van de verschillende componenten worden besproken. Dit hoofdstuk eindigt
met uitleg over de wet van Ohm.
Schemas
Elektrische schakelingen worden in documentatie vaak in een schematische weergave
getoond, omdat een schema vaak veel duidelijker de verbindingen in een elektrisch circuit
kan laten zien dan een foto.
Een voorbeeld van een schema dat laat zien hoe je een dobbelsteen zou kunnen bouwen
met een ATtiny2313 microcontroller ziet er als volgt uit:
In het elektrische circuit dat hierboven staat afgebeeld zijn verschillende componenten
gebruikt: een condensator, een chip (microcontroller), weerstanden en LEDs (Light Emitting
Diodes).
TkkrLab - Arduino Workshop - 33 / 46
De weerstand
Een weerstand is een component dat elektrische stromen kan
beperken. Doordat de weerstand de stroom limiteert ontstaat er een
spanningsval over de weerstand. De wet van Ohm, die we later zullen
behandelen beschrijft het lineaire verband (de verhouding) tussen de
aangeleverde spanning en de stroom die door een weerstand vloeit.
In schema’s ziet een weerstand er uit als een blokje of als een
zigzaggende lijn. Het blokje is het Europese symbool voor een weerstand, terwijl in
Amerikaanse schema’s vaak het zigzaggende lijntje wordt gebruikt.
Weerstanden hebben geen polariteit: het maakt niet uit in welke richting een weerstand
aangesloten wordt.
Aan de hand van de kleuren op de weerstand kun je aflezen welke waarde deze heeft.
De diode
Een didode is een halfgeleidercomponent dat slechts in één richting stroom laat vloeien: van
de anode (+) naar de cathode (-). Het component werkt dus als een terugslagventiel voor
stroom.
TkkrLab - Arduino Workshop - 34 / 46
Er zijn meerdere soorten diodes, welke voor veel verschillende doelen gebruikt worden. Een
aantal voorbeelden van het gebruik van diodes zijn: het gelijkrichten van spanning, het
limiteren van spanning of als lichtbron: de Light Emitting Diode.
De LED
Een LED (of Light Emitting Diode) is een diode die licht uitstraalt wanneer er stroom
doorheen loopt.
Net als een normale diode werkt een LED alleen wanneer er stroom loopt van de anode (+)
naar de cathode (-).
Spanningsbronnen en “ground”
Een spanningsbron (bijvoorbeeld een batterij of een voedingsadapter) kan op meerdere
manieren worden aangeduid: als “kale” spanningsbron, als pijltje met een spanning of als
batterijsymbool. De polariteit staat meestal aangegeven bij het symbool.
Het referentiepunt dat als nulpunt voor spanningen binnen het schema wordt gebruikt heet
het “ground” punt. Deze referentiepunten kunnen met de volgende symbolen worden
aangeduid:
TkkrLab - Arduino Workshop - 35 / 46
Chips / Integrated Circuits (ICs)
In moderne schakelingen worden vrijwel altijd chips gebruikt. Chips
zijn componenten die van binnen bestaan uit een groot aantal
componenten als transistors, condensatoren, spoelen en diodes.
Een chip bevat vrijwel altijd een stukje silicium wafer waarop de
componenten geetst zijn.
Chips worden in veel verschillende verpakkingen gestopt: van
relatief grote through-hole packages zoals het DIL (Dual-In-Line)
formaat tot te kleinste BGA (Ball-Grid-Array) verpakkingen.
Ieder type chip is anders: daarom heeft een chip geen vaste vorm in
een schema. Chips worden meestal aangeduid als een blok met
een hoop aansluitingen. Bij de aansluitingen staat vrijwel altijd de
functie aangegeven.
Condensator
Condensatoren bestaan uit twee metalen plaatjes die door een met elektrolyt doordrenkt
membraan gescheiden worden. Een condensator werkt als een soort batterij en zal de
spanning op zijn aansluitingen constant proberen te houden. Condensatoren worden veel
gebruikt voor spanningsstabilisatie, als anti-dender bescherming bij knoppen en als
onderdeel van passieve hoog- of laag doorlaatfilters.
Condensatoren bestaan in verschillende typen, waarvan sommige wel en sommige geen
gedefinieerde polariteit hebben. Een elektrolytische condensator (links) heeft een witte rand
op de zijkant: die rand geeft aan welke aansluiting de cathode (of negatieve) aansluiting is.
Spoel
Spoelen zijn lange draden die rond een kern gewonden worden. Een spoel werkt als opslag
voor stroom. Een spoel zal proberen de lopende stroom door de spoel constant te houden
wanneer de spanning over de spoel varieert.
Het effect wat een spoel laat zien ontstaat doordat de stroom die door de spoel loopt een
elektrisch veld opwekt. Wanneer de stroom door de spoel positief veranderd zal dat
elektrische veld zichzelf omzetten in een magnetisch veld. Wanneer de stroom vervolgens
TkkrLab - Arduino Workshop - 36 / 46
negatief veranderd keert het proces zich om en veroorzaakt het ontstane magnetische veld
een elektrisch veld en dus een stroom door de spoel.
Hoewel er in deze cursus geen gebruik gemaakt zal worden van dit component is het goed
te weten dat het effect van een spoel ook optreed in langere draden en draden waarin op
hoge snelheid veranderende stromen lopen. Het is daarom verstandig om bij digitale
communicatie tussen componenten de draden niet langer te maken dan nodig is. Wanneer
het gebruik van lange draden noodzakelijk is is het verstandig filters in te bouwen in het
circuit.
TkkrLab - Arduino Workshop - 37 / 46
Weerstanden in serie en parallel
De totale weerstand van in serie geplaatste weerstanden is de som van alle individuele
weerstanden. je kunt de weerstandswaarden dus gewoon bij elkaar optellen.
De totale weerstand van parallel geplaatste weerstanden is iets ingewikkelder. De totale
weerstand van parallel geplaatste weerstanden is namelijk de inverse van de som van de
inverse van iedere individuele weerstandswaarde.
De formule voor twee parallel geplaatste weerstanden kan ook worden omgeschreven tot de
volgende alternatieve formule:
Voorbeeld
R1 = 10 Ohm
R2 = 15 Ohm
In serie is de totale weerstand 10 + 15 = 25 Ohm
Parallel geplaatst is de totale weerstand 1 / 10 + 1 / 15 = 6 Ohm
De totale weerstand van in serie geplaatste weerstanden wordt dus groter dan de individuele
weerstandswaardes terwijl bij parallel geplaatste weerstanden de totale weerstand lager is
dan de individuele weerstanden.
TkkrLab - Arduino Workshop - 38 / 46
De wet van Ohm
In deze cursus gaan we een LED aansluiten op een Arduino. Daarnaast gaan we werken
met een potentiometer (variabele weerstand).
Om de benodigde waarden van-, de stroom door- of de spanningsval over een weerstand te
kunnen bepalen is het nodig de “wet van Ohm” te gebruiken.
De wet van Ohm ziet er in formulevorm zo uit:
Zoals je ziet is dit drie maal dezelfde formule, die ons vertelt dat de weerstand in Ohm gelijk
is aan de spanning in Volt gedeeld door de stroom in Ampère.
R [Ω] = weerstand in Ohm
V [V] = spanning in Volt
I [A] = stroom in Ampere
In een elektrisch schema zien de spanning(V), stroom (I) en weerstand (R) er als volgt uit:
Een enkele weerstand
Stel de batterijspanning is 10 volt en de stroom door het circuit is 2 Ampere, dan is de
weerstand 10 / 2 = 5 Ohm
Stel de batterijspanning is 10 volt en de weerstand heeft een weerstand van 1000 Ohm, dan
is de stroom die door het circuit loopt 10 / 1000 = 0,01 Ampere of 10 mA (milli Ampere).
TkkrLab - Arduino Workshop - 39 / 46
Stel er loopt een stroom van 1 Ampere door het circuit heen en de weerstand is 10 Ohm,
dan is de spanning over de weerstand 1 * 10 = 10 Volt
Spanningsdeler
Een spanningsdeler bestaat uit twee in serie geplaatste weerstanden. De spanningsval over
R1 + R2 is Vin en de uitgang is aangesloten op het verbindingspunt tussen de twee
weerstanden in. In deze situatie bepaalt de verhouding tussen R1 en R2 de spanning op de
uitgang.
De uitgangsspanning kan bepaald worden met de volgende formule:
Die formule kan worden afgeleid uit de wet van Ohm:
V out = I · R2
I =
V in
R1 + R2
( V out is gelijk aan de stroom door het circuit vermenigvuldigd met de weerstand van R2 )
(De stroom door het circuit is gelijk aan V in gedeeld door de totale weerstand)
Hieruit volgt dat V out =
V in · R2
R1 + R2
, ofwel V out = V in ·
R2
R1 + R2
Een spanningsdeler met R1 = 680 Ohm en R2 = 1300 Ohm kan bijvoorbeeld werken als
level-converter om 5 volt om te zetten naar 3.3 volt in een communicatielijn tussen twee
chips.
De waarden in dit voorbeeld zijn zo gekozen dat de stroom door het circuit 2,5mA is. Bij het
zelf ontwerpen van een spanningsdeler kiest je eerst de stroom die je door de
spanningsdeler wilt laten lopen, dit bepaalt de totale weerstand in de spanningsdeler.
Waarna de verhouding tussen de twee weerstanden de uitgangsspanning bepaald.
[Note: een spanningsdeler is niet geschikt als regulator voor de voeding van andere circuits omdat de load aan
de uitgang, die parallel staat aan R2, de uitgangsspanning zal be​ï​nvloeden]
TkkrLab - Arduino Workshop - 40 / 46
Een LED aan een Arduino
In deze cursus gaan we een LED aansluiten op een Arduino. Daarbij functioneert een
uitgang van de Arduino als spanningsbron.
Een LED is een stroomgestuurd component. Dit betekent dat de hoeveelheid licht die een
LED uitstraalt samenhangt met de stroom door de LED en niet met de spanning over de
LED.
Een LED heeft net als een normale diode een vaste spanningsval. De exacte spanningsval
per type LED verschilt en is in de datasheet te vinden.
De gemiddelde spanningsval van veel gebruikte soorten LEDs is meestal een waarde in de
volgende richting: Rood/infrarood: 1,9 volt , Groen: 2,1 volt, Geel: 2 volt, Blauw/wit: 3,6 volt
Een uitgang op de Arduino is verbonden aan de ground (0 volt) wanneer de uitgang LAAG
(uit) is en aan de voedingsspanning (5 volt) wanneer de uitgang HOOG (aan) is.
Het probleem
Direct aansluiten van de uitgangs-pin van de Arduino aan een rode LED zorgt er voor dat er
5 volt over een diode wordt gezet die een spanningsval van 1,9 volt heeft. Dit betekent dat er
ergens 3,1 volt moet worden verloren, in het pad naar de LED toe. Hoewel in theorie de
interne weerstand in een Arduino en van de aansluitdraden 0 ohm is is dat in de praktijk niet
het geval. Gelukkig, want dan zou de hoeveelheid stroom door het circuit oneindig hoog
worden. Helaas is zelfs met de interne weerstand en draadweerstand meegenomen de
stroom door het circuit nog steeds veel hoger dan de maximale stroom die een Arduino mag
leveren en door de LED gestuurd mag worden. Het resultaat is een kapotte of beschadigde
LED en Arduino.
De oplossing
Door zelf extra weerstand toe te voegen aan het circuit kan de stroom door het circuit
worden teruggebracht naar de gewenste hoeveelheid. Het schema van een LED aan een
spanningsbron komt er daardoor als volgt uit te zien:
De spanningsval over de weerstand is in dit geval de voedingsspanning (5 volt) min de
spanningsval over de led (1,9 volt): 3,1 volt dus. Stel we willen een stroom van 10 mA door
3,1
het circuit laten lopen, dan hebben we een weerstand van 0,01 = 310 ohm nodig.
TkkrLab - Arduino Workshop - 41 / 46
APPENDIX
Naslag / Internet bronnen
Arduino
Arduino - ​http://arduino.cc
Voorbeeld projecten - ​https://playground.arduino.cc/Projects/Ideas
Arduino forum nederlands - ​http://arduinoforum.nl
TkkrLab documentatie - ​https://tkkrlab.nl/wiki/Arduino
Sensor kit ‘37 in one’ - ​https://tkkrlab.nl/wiki/Arduino_37_sensors
Hardware voor Arduino
Kiwi Electronics (ook Adafruit & Sparkfun componenten) - ​https://www.kiwi-electronics.nl/
Floris.cc - ​http://floris.cc
Iprototype - https://iprototype.n
Conrad - http://conrad.nl
Variabelen type & waarden
TkkrLab - Arduino Workshop - 42 / 46
Arduino schema zelfbouw
TkkrLab - Arduino Workshop - 43 / 46
Arduino cheat sheet met C commando’s
TkkrLab - Arduino Workshop - 44 / 46
Arduino Pin layout
TkkrLab - Arduino Workshop - 45 / 46