
English: 
Welcome to this introduction to 
Arduino Programming
I will assume that you currently
have zero experience with programming
so if you've used Arduinos before,
you might want to skip this one
To get started go to create.arduino.cc,
and select Web Editor
Register a new account, 
or login if you already have one
You might have to do some additional steps 
to install some software
I’ve put a link to a full guide in the description
You’ll see this screen
This is the editor
It helpfully provides us with the minimum for a valid 
Arduino program: a setup-, and a loop function
These functions are blocks of instructions, 
telling the Arduino what to do.
The setup function runs only once, 
when the Arduino powers up.
It executes the instructions 
in between its curly brackets.
When the setup function is completed, 
the Arduino moves on to the loop function.
It will keep performing the instructions
in that function over and over again.
Arduino Uno’s have a light you can control:
This little LED. 
Let’s play with it for a bit.
The LED is connected to pin 13
so to turn it on 
we have to tell the arduino to power that pin. 
We do that by marking the pin as an output, 
and then writing a HIGH value to it. 

Dutch: 
Welkom bij deze introductie
Arduino's programmeren
Ik ga er vanuit dat je geen ervaring 
hebt met programmeren
dus als je al eens met Arduino's gewerkt hebt,
dan wil je deze misschien overslaan
Ga naar create.arduino.cc,
en klik op de knop Web Editor
Registreer een nieuwe account, 
of log in als je er al eentje hebt
Je moet misschien wat extra stappen doen,
om wat software te installeren
Ik heb een link naar een handleiding 
 in de beschrijving gezet
Je komt op dit scherm terecht
Dit is de editor
Het geeft ons de basis voor een minimaal 
Arduino-programma: een setup- en loop functie
Deze functies zijn blokken van instructies,
die de Arduino vertellen wat er moet gebeuren
De setup wordt één keer uitgevoerd,
zodra de Arduino opstart
Het voert de instructies tussen de accolades uit
Zodra de setup afgerond is,
gaat de Arduino verder met de loop functie
Deze instructies blijft de Arduino 
keer op keer uitvoeren
Arduino Uno’s hebben een lampje die je 
kunt gebruiken: deze kleine LED
Laten we daar eens mee spelen
De LED is verbonden met pin 13
dus om 'm aan te zetten moeten we de Arduino 
vertellen dat pin 13 stroom moet krijgen.
Dat doen we door de pin te markeren als output,
en een HIGH-waarde weg te schrijven

Dutch: 
De pin blijft dan stroom krijgen tot we
de Arduino vertellen 'm weer uit te zetten
Omdat we dit maar één keer hoeven te doen,
zetten we dit in de setup-functie
Nu kunnen we het programma uitvoeren,
en voila: de LED gaat aan
De volgende stap is de LED laten knipperen
Om dit te doen, moeten we pin 13 
herhaaldelijk aan en uit zetten
dus we verplaatsen het aanzet-gedeelte naar
het herhalende deel: de loop-functie.
We voegen ook een uitzet-gedeelte toe, dat werkt
hetzelfde als aanzetten, maar we schrijven LOW
De pin als output markeren 
hoeft nog steeds maar één keer
dus dat laten we in de setup-functie staan
Als we dit programma uitvoeren,
dan doet het technisch gezien wat we willen
De LED knippert wel, maar veel te snel
Het gaat duizenden keren per seconde
aan en weer uit
Omdat het half de tijd aan
en half de tijd uit staat,
lijkt het net alsof de LED op
halve helderheid aanstaat
We fixen ons programma door de Arduino te vertellen
dat hij moet wachten tussen het aan en uitzetten
Een seconde zou genoeg moeten zijn
We schrijven 1000, omdat de delay-functie een getal
in milliseconden verwacht in plaats van seconden
Dat kun je zelf nakijken in de documentatie
op de Arduino website
Nu werkt het:
de LED knippert zoals de bedoeling was

English: 
That pin will then be on 
until we tell the Arduino to turn it off again. 
Since we only have to do it once, 
we’ll put this in the setup function. 
Now we can run the program, 
and voila, the LED turns on.
Our next step is making the LED blink
To do this, we need to repeatedly turn 
pin 13 on and off again
so we’re moving the turning-on code 
to the repeating part: the loop-function.
We also add a turning off part: it’s the same 
as turning it on, except we write LOW.
Marking the pin as an output still 
only needs to happen once,
so we’ll leave that in the setup function.
When we run this program,
it will technically do what we want.
It will blink the LED, but way too fast.
It’s turning on and off many 
thousands of times per second. 
Since it’s on half the time and off half the time,
to the human eye it looks like 
the LED is just on at half brightness.
Let’s fix our example by telling the Arduino 
to wait between turning the LED on and off. 
A delay of a second should do it. 
We write 1000, because the delay function expects 
a number in milliseconds instead of seconds. 
You can check this out yourself in 
the documentation on the Arduino website.
Now it’s working as intended: 
the LED is blinking as we wanted.

English: 
Let’s take this further by having the LED 
start off blinking rapidly,
and then gradually slowing it down. 
We could do this by repeating
the digitalWrite statements 
and creating a long list of instructions 
where the delays get bigger and bigger, 
but we can do better than that. 
We can keep track of the delay,
and have it increase over and over. 
We’ll start out defining the starting value 
of the delay at the top of the program.
To define a variable 
you start by saying what the type is first. 
This can be text, a number, a true/false value, 
or even more complex structures. 
For now we’ll use int, short for integer, 
which is a number that can’t contain a decimal point. 
So 5 is example of an integer, 
-2 is an integer, but 4.3 is not. 
Next up is the name of the variable, 
let’s call that toggleDelay. 
Then we use an equals sign to set 
the value of the variable. 
Let’s put that at 250 milliseconds to start off with.
Now instead of writing a number, 
we can just use the name of the variable instead. 
When we decide we want to have 
the LED blink faster or slower
we now only have to change it in one place.
We can also have the Arduino change 
the value of toggleDelay for us. 

Dutch: 
Laten we een stap verder gaan door 
de LED snel te laten knipperen aan het begin,
en het dan langzaam te laten vertragen.
Dit zouden we kunnen doen door de 
digitalWrite statements te herhalen
en daardoor een lange lijst instructies 
met steeds grotere vertragingen te maken,
maar dat kan beter!
We kunnen de vertraging bijhouden,
en het steeds groter laten worden
We beginnen met de startwaarde 
bovenaan het programma
Om een variabele aan te maken, 
begin je met het type uit te schrijven
Dit kan tekst zijn, een getal, waar/onwaar,
of complexere structuren.
Voor nu gebruiken we int, afkorting van integer,
dat is een geheel getal (zonder komma).
Dus 5 is een voorbeeld van een integer,
-2 is een integer, maar 4,3 niet.
Daarna typen we de naam van de variabele,
die noemen we toggleDelay
Dan gebruiken we een is-gelijk-teken om
een waarde toe te wijzen aan de variable
Die zetten we op 250 milliseconden
om mee te beginnen
Nu kunnen we in plaats van een getal,
de naam van de variabele gebruiken
Als we de LED sneller of langzamer
willen laten knipperen
hoeven we nu de vertraging
maar op één plek aan te passen.
De Arduino kan ook automatisch voor ons 
de waarde van toggleDelay aanpassen

English: 
If we write toggleDelay = toggleDelay + 100
at the end of the loop, 
after each blink, the value of toggleDelay 
will be increased with 100, 
and the next blink will be slower.
Now that our LED is blinking slower and slower, 
let’s build a reset functionality, 
so when the delay becomes more than 
a second it starts blinking fast again.
We do that by checking the toggleDelay variable. 
We can say it’s either true or false that the toggleDelay 
variable is bigger than 1000 milliseconds. 
Such a true/false value is called a boolean. 
So we create a boolean-typed variable again,
and give it a descriptive name,
such as delayTooLong. 
Because we don’t really want to 
keep track of a value over time, 
but just care about calculating a value right now 
we don’t need to create it outside of that loop.
It’ll just be recreated every time 
the loop-function runs, which is fine.
Then to set that boolean, 
we do a comparison with the toggleDelay value:
toggleDelay bigger than 1000. 
So when that toggleDelay becomes bigger than 
1000 milliseconds, the variable will be true.
Now we have the check in place, 
but we aren’t resetting the toggleDelay time back 
to 250 milliseconds based on that value. 
For this to work we have to write an if-statement.

Dutch: 
Als we toggleDelay = toggleDelay + 100 typen
aan het einde van loop, 
dan wordt na elke keer knipperen 
toggleDelay met 100ms opgehoogd,
en dus de volgende knipper trager.
Nu onze LED trager en trager knippert,
gaan we een reset-functionaliteit bouwen
zodat als de vertraging langer wordt dan een seconde, 
de LED weer snel gaat knipperen
Daarvoor moeten we de toggleDelay
variabele checken
We kunnen zeggen dat het waar of onwaar is
dat toggleDelay groter is dan 1000 milliseconden
Zo'n waar/onwaar waarde heet
een boolean.
Dus we maken een variabele met type boolean, 
en geven het een beschrijvende naam,
zoals delayTooLong. 
Omdat we geen waarde willen bewaren
over langere tijd,
maar alleen in de waarde van nu geïnteresseerd zijn,
hoeven we 'm niet buiten de loop
aan te maken
De variabele wordt dan opnieuw aangemaakt
elke keer dat de loop-functie uitgevoerd wordt.
Om de boolean dan een waarde te geven,
gaan we vergelijken met toggleDelay:
toggleDelay groter dan 1000. 
Zodat als toggleDelay groter wordt dan 
1000 milliseconden, de variabele waar wordt.
Nu hebben we de check,
maar we resetten toggleDelay nog niet naar 
250 milliseconden op basis van die waarde.
Hiervoor moeten we een if-statement schrijven

English: 
 If-statements work like this: if the boolean value 
between the parentheses is true, 
then it will execute the block of code 
between the curly brackets. 
Otherwise it will just skip over it. 
So in our case we’ll structure 
the if-statement like this.
Between the curly brackets we’ll set 
the toggleDelay value back to 250.
Since the variable already existed before 
we don’t need to respecify it’s an integer here.
There is one last part we need to talk about: functions. 
Just like the setup and loop-function, 
we can create our own functions. 
As the program grows, it will become harder to 
keep track of which piece is doing what, 
so it can help to name the pieces,
and structure them into functions.
We can separate the toggling of the LED
out in it’s own function for example. 
We start off by defining what 
the function will give as a result. 
In our case that’s nothing, so we tell it ‘void’. 
Then we give it a name of blinkLedOnce, 
parenthesis, and curly brackets. 
Do you see that the structure now matches 
the one of setup and loop exactly? 
The only thing we now need to do is move
the digitalWrite and delay bits 
from the loop function into the blinkLedOnce function,
and make sure that function is called where
the code used to be in the loop function.

Dutch: 
If-statements werken zo: 
als de boolean tussen de haakjes waar is,
dan wordt de code tussen de accolades uitgevoerd.
Anders springt de Arduino er overheen.
Dus in ons geval structureren
we de if-statement op deze manier.
Tussen de accolades zetten we toggleDelay
terug op 250 milliseconden.
Omdat de variabele al bestond, hoeven we hier 
niet opnieuw te zeggen dat het een integer is.
Het laatste deel waar we het 
over moeten hebben zijn functies.
Net zoals de setup- en loop,
kunnen we onze eigen functies maken.
Naarmate het programma groeit wordt het
lastiger om bij te houden welk deel wat doet
Het helpt dan de delen een naam te geven,
en het in functies op te delen
Zo kunnen we het knipperen van de LED
in een eigen functie indelen
We beginnen met het resultaat van de functie
In ons geval niets, dus schrijven we 'void'
Dan geven we het een naam
van blinkLedOnce, haakjes, en accolades
Zie je dat de structuur nu precies matcht
met setup en loop?
Nu moeten we alleen nog de 
digitalWrite- en delay-statements verplaatsen
vanuit de loop-functie 
naar de blinkLedOnce-functie
en zorgen dat blinkLedOnce wordt aangeroepen,
waar die code net in de loop stond

Dutch: 
Dit zijn de basics die je nodig hebt
om een Arduino te programmeren
Er komen meer videos aan,
en er zijn veel voorbeelden online te
vinden om je verder te ontwikkelen.
Tot de volgende video, en veel plezier
met Arduino verder ontdekken!
[overdreven jazzy achtergrondmuziekje]

English: 
Those are the basics 
you need to know to program an Arduino. 
There will be more videos in this series, 
and there are many examples you can 
find online to advance yourself further.
See you for the next video, until then, 
have fun exploring the Arduino further!
[needlessly jazzy background music]
