arduino schedule + materiaal

Author: simonpauw

Diff for: _schedules/1 Herfst/schedule.yml

@@ -21,3 +21,23 @@ Flask:
     "Versie 4 [Milestone]": /milestones/versie4
     Screencast: /milestones/screencast
     Presentatie: /milestones/presentation
+
+Arduino:
+  Basics:
+    Blink: /arduino/blink
+  Projectvoorstel (uiterlijk dinsdag 14 november):
+    Projectkeuze [Milestone]: /milestones/topic
+    Projectvoorstel [Milestone]: /milestones/proposal
+  Projectvalidatie (1 week):
+    Uitleg projectvalidatie: /milestones/validatie
+    Videocollege Git: /flask/lectures/git
+    Git opzetten [Milestone]: /milestones/git
+  Project (3 weken):
+    "Versie 1 [Milestone]": /milestones/versie1
+    "Versie 2 [Milestone]": /milestones/versie2
+    "Versie 3 [Milestone]": /milestones/versie3
+  Afronding (uiterlijk dinsdag 19 december):
+    "Review & Cleanup": /milestones/cleanup
+    "Versie 4 [Milestone]": /milestones/versie4
+    Screencast: /milestones/screencast
+    Presentatie: /milestones/presentation

Diff for: arduino/10 Blink/10 Blink.md

@@ -0,0 +1,56 @@
+# Blink
+
+## Getting started
+
+Download and install the Arduino environment ([download](https://www.arduino.cc/en/Main/Software)). Make sure to get the stand-alone version, not the web plugin.
+
+Start the environment you should see an empty program (called a sketch in Arduino world):
+
+![Emtpy Arduino sketch](empty.png "300px")
+
+You will notice the sketch already contains two function: `setup()` and `loop()`. These two functions are the minimal requirement for any Arduino sketch, like `main()` is for C-programs. The `setup()` function will run only once, directly after starting the Arduino. Once `setup()` finishes, `loop()` will be executed and repeated forever (well, until you turn the Arduino off).
+
+## Exercise
+
+Let’s write some code to make a LED blink. The Arduino language is essentially C++. If you know C, you will notice that a lot of it feels very familiar.
+
+In the `setup()` enter the following code:
+
+    pinMode(13, OUTPUT);
+
+As you might have guessed, this will tell pin 13 on the Arduino to operate as output pin. This means that we can use it to control, for example, a LED.
+
+Now, in the `loop()` enter the following code:
+
+    digitalWrite(13, HIGH);
+    delay(1000);           
+    digitalWrite(13, LOW);
+    delay(1000);     
+
+The line `digitalWrite(13, HIGH)` tells pin 13 to provide a high (5V) voltage, essentially turning the LED connected to pin 13 on. The line `digitalWrite(13, LOW)` sets the voltage to 0, turning the LED off. `delay(1000)` tells the program to do nothing for 1000 milliseconds (1 sec).
+
+Save your file under the name “blink”.
+
+### Compile & Upload
+
+To check if your program is (syntactically) correct, press the compile button:
+
+![Compile (verify)](compile.png "300px")
+
+Let’s upload this sketch. Make sure the Arduino is connected to a USB-port of your computer. Before you upload you have to check if the right *board* and *port* are selected:
+
+Go to Tools>Board and select your Arduino model (e.g. Arduino/Genuino Uno):
+
+![Select board](board.png "300px")
+
+Now, go to Tools>Serial Port and select the right port:
+
+![Select port](port.png "300px")
+
+Once you have done this, you’re ready to upload your sketch. Press the upload button:
+
+![Upload](upload.png "300px")
+
+During the programming, you’ll see a LED on your Arduino blinking erratically. If all is well, this will stop after a couple of seconds and you’ll see the LED turn on and off regularly with a period of two seconds.
+
+Congrats! You’ve written your first Arduino sketch.

Diff for: arduino/10 Blink/board.png

@@ -0,0 +1,23 @@
+# Connect your own LED
+
+In the previous exercise you learned to program the built-in LED of the Arduino. Now let’s try to do the same with an external LED.
+
+You’ll need a LED, a resistor (1kΩ will do), a breadboard and a couple of wires:
+
+![Components](images/Components-Blink.jpg "300px")
+
+## Exercise
+
+> **Before you get started unplug/turn off the Arduino!!!** You don't want to build a circuit when the Arduino is powered. You could short circuit it and break something.
+
+Build the following circuit:
+
+![LED hookup](images/BB-LED.png "300px")
+
+If you're not sure how to use a breadboard have a look here: \[[Breadboard wiring](index.php?dir=30+Background&file=00+Breadboard)\].
+
+> Note that a LED has a positive and negative pole, if you connect a LED the wrong way around, it doesn’t do anything. \[[More information](index.php?dir=30+Background&file=20+LED)\]
+
+If you turn the Arduino on and you connected the LED correctly, you should see the LED blinking.
+
+Congrats! You built your first circuit!

Diff for: arduino/10 Blink/compile.png

@@ -0,0 +1,17 @@
+# Fade
+
+Instead of turning the LED on and off abruptly, we’re going to make the LED fade slowly in and out. For this we can use the function `analogWrite()`. This function does not write a binary value `HIGH` or `LOW` to the pin, but a value between 0 and 255. Which allows us to write an “analog” value to the pin. If we would replace the line
+
+    digitalWrite(13, HIGH);
+
+with
+
+    analogWrite(13, 20);
+
+in the 'blink' program, we can see the LED blink all the same but at a much lower intensity. Note that `analogWrite(13, 0)` corresponds to `digitalWrite(13, LOW)` and `analogWrite(13, 255)` corresponds to `digitalWrite(13, HIGH)`.
+
+> Note: the function is called `analogWrite`, but the output is not really analog. It is a PWM output. \[[More information](index.php?dir=30+Background&file=30+PWM)\]
+
+## Exercise
+
+Write a program that lets a LED fade in and out slowly. Tip: you might need a `for` loop.

Diff for: arduino/10 Blink/empty.png

@@ -0,0 +1,33 @@
+# Hello, world! Hello, world! Hello, w…
+
+You might want to be able to do some debugging. Remember how useful `prinft` in C could be for that? Bad news, no `printf` for Arduino. One reason might be that the Arduino does not have a screen to print to. You can, however, send signals over the USB-connection to your computer. For this we need to setup a serial connection. This can be done by adding the line
+
+    Serial.begin(9600);
+
+to the setup function. This starts a connection with your PC at 9600 baud (don’t worry about the connection speed, 9600 is almost always fine).
+
+Now you can send messages to your computer using the command
+
+    Serial.print("Hello!");
+
+or
+
+    Serial.println("Hello!");
+
+The later prints a new-line at the end of the text.
+
+Where do these messages wind up? They’re sent over a virtual tty-modem to your computer. You can display these messages using the _Serial monitor_ in the Arduino IDE:
+
+![Serial monitor](images/serial.png "300px")
+
+## Exercise
+
+Write a program that displays the text “Hello, world!” endlessly (until the Arduino is turned off):
+
+    Hello, world!
+    Hello, world!
+    Hello, world!
+    Hello, world!
+    ...
+
+Make sure there is a pause of at least 200 milliseconds between every “Hello, world!”.

Diff for: arduino/10 Blink/port.png

@@ -0,0 +1,42 @@
+# Button
+
+Time for some input. We're going to connect a push button to our Arduino.
+
+## Getting started
+
+### Circuit
+
+First we need to build the circuit. For this we need a resistor (around 10kΩ) and, well, a push button:
+
+![Button](images/Components-Button.jpg "300px")
+
+Connect them like this:
+
+![Push button hookup](images/BB-Button.png "300px")
+
+### Code
+
+The following code prints the state of the push button to the Serial monitor.
+
+    void setup()
+    {
+      Serial.begin(9600);
+      pinMode(2, INPUT);
+    }
+
+    void loop()
+    {
+      int buttonState = digitalRead(2);
+      Serial.println(buttonState);
+      delay(20);
+    }
+
+The button pin is configured as input with `pinMode(2, INPUT)`. The state of the button (HIGH or LOW) is read with the function `digitalRead(2)`.
+
+Copy this sketch and save as `button`. Compile, upload and test this sketch.
+
+> What is printed when you press the button? What is printed when you release it?
+
+## Exercise
+
+Use a button to turn the LED on and off. When the button is pressed, the LED is on, otherwise it is off.

Diff for: arduino/10 Blink/upload.png

@@ -0,0 +1,19 @@
+# Debounce
+
+## Exercise
+
+Use a button to toggle the LED on and off. So when you press the button the LED turns on. The LED stays on until you press the button again.
+
+> Does it reliably turn on or off? What happens when you keep the button pressed?
+
+It is likely you will run into a problem that makes programming a bit more challenging (and more interesting) than the protected world of your computer: noise!
+
+The push button is a mechanical device. When you push it, the contact plates in the button touch. The problem is, they don’t do so cleanly. You would hope the input does something like this:
+
+![Idealized effect of the button on input voltage](images/bounce1.jpg "300px")
+
+However, in reality it goes more like this:
+
+![Actual effect push button on input voltage](images/bounce2.jpg "300px")
+
+The mechanical contacts in the button bounce, making the signal jump up and down for a couple of milliseconds after pressing or releasing the button. This is called _bouncing_. You will have to take this into account when programming the toggle button.

Diff for: arduino/11 Circuit/20 Circuit.md

@@ -0,0 +1,42 @@
+# Light sensor
+
+So far you have seen `digitalWrite` (to control a LED), `digitalRead` (to read a button state), `analogWrite` (to dim a LED). There is one function ostentatiously missing: `analogRead`. We're going to use that function to read out a _light dependent resistor_ (LDR).
+
+## Getting started
+
+### Circuit
+
+First we need to build the circuit. For this we need a resistor and an LDR:
+
+![LDR](images/Components-LDR.jpg "300px")
+
+Here below there is an example of how to connect them.
+
+![LDR hookup](images/BB-LDR.png "300px")
+
+### Code
+
+The code below shows how to use `analogRead` to read the LDR.
+
+    void setup()
+    {
+      Serial.begin(9600);
+      pinMode(A0, INPUT);
+    }
+    
+    void loop() 
+    {
+      int ldrValue = analogRead(A0);
+      Serial.println(ldrValue);
+      delay(20);
+    }
+
+Copy this sketch and save as `LDR`. Compile, upload and test.
+
+> Contrary to `analogWrite`, `analogRead` is actually analog. No PWM trickery here. The higher the voltage on pin `A0`, the higher the value `analogRead` returns. 
+
+> The value that `analogWrite` returns is a *10 bit* value, not 8 bits. This means that 5V corresponds to the value 1023 and 0V corresponds to 0. What would be the value of `analogRead(A0)` when the voltage on `A0` is 1V?
+
+## Exercise
+
+Make an automatic light switch: Use an LDR to control a LED. When it is dark enough, make the LED turn on and when it is lighter, the LED turns off.

Diff for: arduino/13 Serial/30 Fade.md

@@ -0,0 +1,54 @@
+# Servo
+
+One of the most fun things to do with the Arduino is to make robots. To make robots, we need to control motors. A type of motor commonly used in robots are servo motors.
+
+Servo motors do not rotate continuously (like normal DC motors do). You can set them to a specific angle, and they will maintain that angle until instructed otherwise.
+
+In this exercise you will discover how easy it is to connect a servo to the Arduino and program it.
+
+## Getting started
+
+### Circuit
+
+You will need a 9g micro servo:
+
+![Servo](images/servo.jpg "300px")
+
+This is how you connect it to the Arduino:
+
+![Servo hookup](images/BB-Servo.png "300px")
+
+> Pay attention to the color of the wires. Red goes to the power supply (5V), brown to ground (GND), and yellow is the signal wire (connect to pin 9).
+
+### Code
+
+The following code lets the angle of the servo alternate between 0 and 180 degrees.
+
+    #include <Servo.h>
+
+    Servo myservo;
+
+    void setup() {
+      myservo.attach(9);
+    }
+
+    void loop() {
+      myservo.write(0);             
+      delay(500);
+      myservo.write(180);             
+      delay(500);      
+    }
+
+As you can see, we include the library `Servo.h`. This library comes with the Arduino IDE. The protocol that we use to communicate with the servo is very timing sensitive. Fortunately the servo library takes care of that, so we don't have to worry about it now.
+
+Controlling the servo consists of three parts:
+
+1. We need to create a `Servo` variable called `myservo`.
+2. The line `myservo.attach(9)` activates the servo on pin 9.
+3. The line `myservo.write(0)` sets the angle of the servo to 0 degrees. The line `myservo.write(180)` sets it to 180 degrees.
+
+Copy the code above, and run it on the Arduino. Test to see if the servo is actually moving.
+
+## Exercise
+
+Use either the push button or the LDR to control the servo. Make the servo turn at the push of a button, or make it react to intensity of the light.

Diff for: arduino/13 Serial/40 Serial.md

@@ -0,0 +1,53 @@
+# Sonar
+
+Use a Sonar to measure distances. A sonar sends a sound pulse and measures the time it takes for the echo to return. This allows us to estimate the distance of obstacles. \[[More information](http://simonpauw.com/arduino/index.php?dir=30+Background&file=40+Sonar)\]
+
+## Getting started
+
+### Circuit
+
+You will need a HC-SR04 sonar sensor:
+
+![Servo](images/sonar.jpg "300px")
+
+This is how you connect it to the Arduino:
+
+![Sonar hookup](images/BB-Sonar.png "300px")
+
+> Pay attention to labels of the pins. VCC goes to the power supply (5V), GND to GND, 'trig' to pin 12, and 'echo' to pin 11.
+
+### Code
+
+Before you can start coding, you need to download the NewPing library ([dowload](http://playground.arduino.cc/Code/NewPing)---follow the instructions on the download page).
+
+Once you downloaded and installed the NewPing library, restart your Arduino IDE and enter the following code:
+
+    #include <NewPing.h>
+
+    #define TRIGGER_PIN  12
+    #define ECHO_PIN     11
+    #define MAX_DISTANCE 200
+
+    NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
+
+    void setup() {
+      Serial.begin(9600);
+    }
+
+    void loop() {
+      delay(2000);
+      Serial.print("Ping: ");
+      Serial.println(sonar.ping());
+    }
+
+The NewPing library takes care of the timing protocol. The function `sonar.ping()` returns the time between the trigger sound pulse and its echo in microseconds.
+
+## Exercise 1
+
+The function `sonar.ping()` essentially gives you the 'distance' to an object in microseconds. We, mortal humans prefer to think in centimeters (or inches if from _that_ corner of the world).
+
+Create a program that computes the distance to an object in centimeters rather than microseconds. Tip, have a look here: [https://en.wikipedia.org/wiki/Speed_of_sound](https://en.wikipedia.org/wiki/Speed_of_sound)
+
+## Exercsie 2
+
+Use to sonar to blink a LED when an object is getting very close (let's say closer than 10cm).

Diff for: arduino/14 Button/50 Button.md

@@ -0,0 +1,19 @@
+# Bike Light
+
+Create a bike light with a button and a LED: If you press the button once, the LED turns on; when you press it a second time, the LED starts blinking; when you press the button a third time, the LED turns off again.
+
+Hm… this might be trickier than it seems. You need to do multiple things at once. Blink a light and check for button input. How to deal with that?
+
+The function 'delay()' is getting in the way. Every time you call 'delay()' you block the Arduino. So you cannot use it for anything, not for checking a button state or anything else. This makes it hard to do multiple things at the same time.
+
+### Part 1: Blink
+
+Make a LED blink, but this time without using the function 'delay()'. Instead you can use the function 'millis()'. This function returns the amount of milliseconds that have passed since the Arduino was turned on.
+
+### Part 2: Button
+
+Write a program that checks a button every 200 milliseconds. Again, do this without using 'delay()'. When the button is pressed, toggle a LED. Make sure that when you keep the button pressed, it does not continue toggling the LED.
+
+### Part 3: Bike Light
+
+Now add a the third mode: blink. So when the button is pressed once, it simply turns the LED on. But when it is pressed a second time, the LED starts blinking. Press the button a third time and the LED turns off again. Again, don't use 'delay()'.