APPENDIX D

Transcriptie

1 Intro ARDUINO

2 Table of Contents Spelen met een LED... 3 Spelen met meerdere LEDs... 6 Aansturen van een SERVO... 8 De POTENTIOMETER De LED- verklikker De SERVOcontroller De FLEXBEND sensor De TEMPERATUUR sensor De TEMPERATUUR controller De PUSHBUTTON APPENDIX D Circuit... 36

3 Spelen met een LED We starten onze kennismaking met Arduino via de meest eenvoudige schakeling waarmee we een LED 1 kunnen laten branden. Een LED - Light- Emitting Diode is een elektronische component die licht uitzendt wanneer er een zekere stroom doorloopt van de positieve naar de negatieve aansluiting. Neem een LED en check dat het ene beentje de positieve terminal langer is dan het andere, de stroom zal dus moeten lopen van het lange beentje door de LED naar het korte beentje. Hoeveel stroom er moet doorlopen hangt af van het type LED, typisch ligt dat in de buurt van 20mA. Om te voorkomen dat er teveel stroom door de LED zou vloeien waardoor die kan doorbranden en dus stuk gaat zal een LED steeds in combinatie met een weerstand aangesloten worden. Hier maken we gebruik van een weerstand met weerstandswaarde 330Ω, te herkennen aan de kleurcode 2 oranje- oranje- bruin. Bouw deze schakeling en laad in Arduino de sketch Blink die je hier terug kan vinden: File>Examples>01.Basics>Blink Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. In bovenstaande afbeelding kreeg je de breadboard view de schakeling zoals je ze kan nabouwen op een gaatjesbord. Daarnaast bestaat er ook zoiets als een logisch schema (zie hiernaast) waarin de componenten en onderlinge verbindingen symbolisch voorgesteld worden. Een logisch schema heeft het voordeel de essentie op een compacte manier voor te stellen, en is vlot leesbaar. Identificeer de symbolen voor de LED en de weerstand in het logisch schema. Merk op dat het pijltje in de LED aangeeft hoe de stroom door de LED moet vloeien. 1 Meer informatie over de LED vind je hier 2 Voor meer informatie over de kleurcode van weerstanden kan je terecht op

4 /* Blink Turns on an LED on for one second, then off for one second, repeatedly. This example code is in the public domain. */ // Pin 13 has an LED connected on most Arduino boards. // give it a name: int led = 13; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinmode(led, OUTPUT); // the loop routine runs over and over again forever: void loop() { digitalwrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalwrite(led, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second Een Arduino sketch zal altijd in drie stukken opgedeeld worden, in onderstaande wordt elk onderdeel toegelicht. int led = 13; void setup() { pinmode(led, OUTPUT); void loop() { digitalwrite(led, HIGH); delay(1000); digitalwrite(led, LOW); delay(1000); In het eerste gedeelte worden variabelen aangemaakt. Een variabele is een woord waar je een bepaalde betekenis aan geeft, en die een waarde bevat die later in de sketch gebruikt wordt. Er zijn ook verschillende types variabelen: gehele getallen, kommagetallen, karakters, Hier wordt een variabele led aangemaakt die de waarde 13 krijgt. Het type is hier int, wat een geheel getal voorstelt. In het tweede gedeelte de setup()- functie worden enkele vaste instellingen opgenomen die niet veranderen tijdens de sketch. Hier wordt pin 13 als uitgangspin geconfigureerd via de pinmode()- functie. Er had ook kunnen staan: pinmode(13, OUTPUT); maar dat is minder leesbaar, vooral in een grote sketch met veel code. Dankzij de variabele led die de waarde 13 bevat kunnen we dit meer leesbaar formuleren: pinmode(led, OUTPUT); In het derde en belangrijkste gedeelte wordt de logica van de sketch geformuleerd in de loop()- functie. Deze bevat de code die altijd opnieuw vandaar het woordje loop zal uitgevoerd worden. digitalwrite(led, HIGH); Hier wordt de pin waarmee de LED verbonden is pin 13 HOOG gemaakt. Dat betekent dat er 5V verschijnt op deze pin waardoor er stroom door de LED kan vloeien en de LED brandt. delay(1000); Nu wachten we 1000 milliseconden wat dus 1 seconde is.

5 digitalwrite(led, LOW); Vervolgens wordt de pin waarmee de LED verbonden is pin 13 LAAG gemaakt. Dat betekent dat er 0V verschijnt op deze pin waardoor er geen stroom door de LED kan vloeien en de LED dooft. delay(1000); Nu wachten we opnieuw 1000 milliseconden, en hernemen we de code van in het begin van de loop()- functie. Het resultaat is een knipperende LED die 1 seconde brandt, 1 seconde dooft en dat in een eindeloze lus.. Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Verander eens de waarden van de delay()- functie om de LED langer of korter te laten knipperen. 3. Voeg nu een LED en een weerstand toe, zodat beide LEDs knipperen. Besluit Proficiat, je hebt je eerste stappen in software en hardware gezet! Dit lijkt misschien nog beperkt, maar het principe van een LED aan te sturen kan meteen toegepast worden om andere dingen te kunnen aansturen: een motor, een elektrische schakelaar,

6 Spelen met meerdere LEDs We gaan nog even verder met onze LEDs. Bedoeling is dat je 2 LEDs aanstuurt via 2 verschillende pinnen, en ze elk afzonderlijk kan programmeren. Op die manier kan je bvb een knipperliht maken waarbij de rode en groene LED afwisselend oplichten. Bouw deze schakeling en laad in Arduino de sketch Blink die je hier terug kan vinden: File>Examples>01.Basics>Blink Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. In het logisch schema zie je nu 2 verschillende circuits, een voor de rode LED verbonden met pin 13 en een voor de groene LED verbonden met pin 12. Identificeer de symbolen voor de LED en de weerstand in het logisch schema. Merk op dat beide LEDs hun eigen weerstand nodig hebben. Weet je nog waarom?

7 /* Blink Turns on an LED on for one second, then off for one second, repeatedly. This example code is in the public domain. */ // Pin 13 has an LED connected on most Arduino boards. // give it a name: int led = 13; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinmode(led, OUTPUT); // the loop routine runs over and over again forever: void loop() { digitalwrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalwrite(led, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second Als je deze sketch uitvoert zal enkel de rode LED knipperen, dat is logisch want we hebben dezelfde sketch gebruikt als tijdens de vorige oefening. Je zal deze sketch dus moeten uitbreiden zodat ook de groen LED kan aangestuurd worden. Dat betekent dat er aanpassingen nodig zijn in de drie verschillende onderdelen van de sketch. Verander/breid de code uit volgens onderstaande instructies. int led = 13; We zullen geen gebruik maken van de int groeneled = 12; int rodeled = 13; variabele led, die regel code mag je verwijderen. We maken nu 2 variabelen aan: groeneled en rodeled die respectievelijk de waarde 12 en 13 void setup() { pinmode(led, OUTPUT); pinmode(groeneled, OUTPUT); pinmode(rodeled, OUTPUT); void loop() { digitalwrite(led, HIGH); digitalwrite(rodeled, HIGH); digitalwrite(groeneled, LOW); delay(1000); digitalwrite(led, LOW); digitalwrite(rodeled, LOW); digitalwrite(groeneled, HIGH); delay(1000); krijgen. De rode LED wordt verbonden met pin 13 en de groene LED met pin 12, beide moeten dus geconfigureerd worden als OUTPUT- pins. digitalwrite(rodeled, HIGH); digitalwrite(groeneled, LOW); We zetten de rode LED aan en de groene LED af en wachten dan 1 seconde. digitalwrite(rodeled, LOW); digitalwrite(groeneled, HIGH); Vervolgens zetten we de rode LED af en de groene LED aan en wachten opnieuw een seconde. Het resultaat is een afwisselend knipperende rode en groene LED. Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Voeg en derde LED toe, bvb een gele, en maak hiermee een stoplichtsequentie. Besluit Je hebt nu ervaring in het gebruik van LEDs. Deze worden niet alleen gebruikt als verlichtingselementen maar vervullen in de elektronica vaak de functie om status aan te geven. Bvb een LED die aanduidt of je TV- toestel of monitor aan of uit staat, een LED die gebruikt wordt om aan te geven of je webcam actief is,

8 Aansturen van een SERVO We hebben de LEDs achter de rug hoewel ze nog vaak zullen terug komen en gaan nu onze eerste actuator aansturen! Een actuator is een elektronisch toestel dat een bepaalde fysieke actie uitvoert, bijvoorbeeld een elektrische motor die draait wanneer er stroom door gestuurd wordt. Een SERVO is een actuator die heel mauwkeurig bepaalde hoekposities kan innemen, typisch varieert die hoekpositie in het interval [0, 180 ]. De SERVO die wij gebruiken heeft 3 aansluitingen, een voeding (5V) en massa (ground, 0V) en een signaaldraad. Bouw deze schakeling en laad in Arduino de sketch Sweep die je hier terug kan vinden: File>Examples>Servo>Sweep Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. De signaaldraad is verbonden met pin 9. Als je goed kijkt op het logisch schema staat naast pin 9 het woord PWM wat staat voor Pulse- Width Modulation 3 of pulsbreedtemodulatie. Kort gezegd komt het erop neer dat het signaal naar de SERVO een periodieke puls is waarvan de breedte varieert tussen [1.25ms, 1.75ms] overeenkomstig [0, 180 ]. Deze puls wordt typisch om de 20ms uitgezonden. Gelukkig hoeven we ons de interne werking van de signaalvorm niet aan te trekken, en kunnen we gebruik maken van een softwarebibliotheek waarmee de SERVO eenvoudig kan gepositioneerd worden. 3 zie

9 // Sweep // by BARRAGAN < // This example code is in the public domain. #include <Servo.h> Servo myservo; // create servo object to control a servo // a maximum of eight servo objects can be created int pos = 0; // variable to store the servo position void setup() { myservo.attach(9); // attaches the servo on pin 9 to the servo object void loop() { for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees { // in steps of 1 degree myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees { myservo.write(pos); // tell servo to go to position in variable 'pos' delay(15); // waits 15ms for the servo to reach the position Deze Arduino sketch laat de SERVO continue over een hoekinterval [0, 180 ] draaien. Hiervoor maken we gebruik van de functie write() waaraan we een getal meegeven tussen de 0 en de 180. Dit getal komt overeen met de positie die de SERVO zal innemen. #include <Servo.h> Om de SERVO write()- functie te kunnen gebruiken moeten we eerst de bibliotheek <Servo.h> inladen. Servo myservo; int pos = 0; Servo myservo; Om de SERVO te kunnen aansturen maken we eerst een myservo- variabele van het type Servo. void setup() { myservo.attach(9); void loop() { for(pos = 0; pos < 180; pos += 1) { myservo.write(pos); delay(15); for(pos = 180; pos>=1; pos-=1) { myservo.write(pos); delay(15); int pos = 0; De gewenste positie voor de SERVO wordt opgeslagen in een variabele pos. myservo.attach(9); De signaaldraad van onze SERVO is verbonden met pin 9. Hier krijgen we een belangrijk nieuw element: de FOR- loop. Hiermee kan je een stuk code een aantal keer herhalen. for(pos = 0; pos < 180; pos += 1) { myservo.write(pos); delay(15); Hier wordt het stuk code tussen de accolades { 180 keer uitgevoerd! Per keer wordt de variabele pos verhoogd met 1. myservo.write(pos); De SERVO krijgt de opdracht om in een bepaalde hoekpositie te staan, aangegeven door de variabele pos. delay(15); Vertraging van 15ms.

10 Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid deze schakeling uit met een LED die brandt wanneer de SERVO van 0 naar 180 draait. Besluit Allright, we hebben nu onze eerste stappen gezet in de wereld van de SERVO s, waarmee je allerhande dingen kan laten bewegen! SERVO s zijn essentieel in robotica, waar ze gebruikt worden om de beweging van gewrichten na te boosten.

11 De POTENTIOMETER Met een SERVO kan je coole projecten realiseren waarmee je iets kan laten bewegen, je zal ze zeker gebruiken binnen je eigen project. Een andere component die je vaak tegenkomt is de POTENTIOMETER, wat een regelbare weerstand is. Overal waar je draaiknoppen vindt op je stereoketen, een mengtafel heb je te maken met POTENTIOMETERs. Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. Een POTENTIOMETER heeft 3 aansluitingen: een voeding (hier 5V), een massa (0V) en dan nog een aftakking. Afhankelijk van de stand van de POTENTIOMETER zal op deze aftakking een spanning tussen [0V, 5V] te meten zijn. Het is deze spanning die we met de Arduino gaan meten. In de Arduino zit een ADC Analog Digital Convertor waarmee een spanning omgezet wordt in een getal. Bij ons wordt het bereik [0V, 5V] omgezet in een getal tussen [0, 1023]. Dus: 0V! 0 1V! 204 2,5V! 512 5V! 1023

12 // Potentiometer // by Stijn De Mil String resultaat = De POT-waarde is ; int potpin = A0; int potwaarde = 0; int vertraging = 100; // de aftakking van de POTENTIOMETER wordt verbonden met // de analoge ingangspin A0 void setup() { Serial.begin(9600); // initialiseer de seriele communicatie met de computer void loop() { potwaarde = analogread(potpin); // lees de huidige waarde van de POTENTIOMETER Serial.print(resultaat); // Schrijf de String resultaat naar de computer Serial.println(potWaarde); // Schrijf de huidige waarde van de POTENTIOMETER // naar de computer en print een nieuwe regel delay(vertraging); Deze Arduino sketch meet de spanning van de POTENTIOMETER via de analoge ingangspin en stuurt de waarde naar de seriele monitor van de computer. Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje String resultaat = De POT-waarde is ; Hier hebben te maken met een nieuwe variabele van het type String. Deze variabele wordt gebruikt om een stukje tekst op te int potpin = A0; int potwaarde = 0; int vertraging = 100; void setup() { Serial.begin(9600); potwaarde = analogread(potpin); Serial.print(resultaat); Serial.println(potWaarde); slagen in het geheugen van de Arduino. We maken gebruik van analoge ingangspin A0 Het resultaat van de meting komt terecht in de variabele potwaarde Om de Arduino te laten communiceren met de computer, moeten we eerst de seriele communicatie initialiseren. Die communicatie verloopt over de USB- aansluiting. De spanning van de POTENTIOMETER wordt gemeten dankzij de analogread()- functie We sturen eerst de zin die opgeslagen ligt in de variabele resultaat naar de seriele monitor met behulp van de Serial.print()- functie Vervolgens schrijven we de waarde van de meting opgeslagen in de variabele potwaarde naar het scherm. Hier gebruiken we de Serial.println()- functie, je spreekt dit uit als de printline- functie. Deze zorgt ervoor dat de cursor al naar de volgende regel springt, zodat alle regels mooi onder mekaar weergegeven worden. Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Meet de spanning op de aftakking van de POTENTIOMETER met een multimeter 3. Verander println in print, en kijk wat er nu gebeurt Besluit De POTENTIOMETER kom je in het dagelijkse leven vaak tegen, bvb de volumeknop op je stereo, de regelaar van een thermostaat, alle draaiknoppen op een mengpaneel, Daarnaast vind je ze heel vaak terug in allerhande elektronica, waar ze gebruikt worden om spanningen en weerstanden in te stellen. Bovendien is het concept van een variabele weerstand heel belangrijk omdat het je verder inzicht geeft bij het gebruik van sensoren zoals de lichtsensor, de temperatuursensor, Deze komen verder in de serie aan bod.

13 De LED- verklikker We breiden nu de vorige schakeling uit met een LED, waarmee we kunnen aangeven wanneer de spanning van de POTENTIOMETER zich binnen een bepaald bereik bevindt. Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten.

14 // LED-verklikker // by Stijn De Mil String resultaat = De POT-waarde is ; int potpin = A0; int ledpin = 13; int potwaarde = 0; int vertraging = 100; // de aftakking van de POTENTIOMETER wordt verbonden met // de analoge ingangspin A0 void setup() { Serial.begin(9600); // initialiseer de seriele communicatie met de computer pinmode(ledpin, OUTPUT); void loop() { potwaarde = analogread(potpin); // lees de huidige waarde van de POTENTIOMETER Serial.print(resultaat); // Schrijf de String resultaat naar de computer Serial.println(potWaarde); // Schrijf de huidige waarde van de POTENTIOMETER // naar de computer en print een nieuwe regel if(potwaarde > (1023*4/5)){ // als de potwaarde groter is dan 818 (wat digitalwrite(ledpin, HIGH); // overeenkomt met 4V) dan zal de LED branden else{ // en anders (dus wanneer de potwaarde niet groter digitalwrite(ledpin, LOW); // is dan 818), dan zal de LED niet branden delay(vertraging); Deze Arduino sketch meet de spanning van de POTENTIOMETER via de analoge ingangspin en stuurt de waarde naar de seriele monitor van de computer. Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje rechts bovenaan (afbeelding vergrootglas) String resultaat = De POT-waarde is ; int potpin = A0; int potwaarde = 0; int vertraging = 100; void setup() { Serial.begin(9600); potwaarde = analogread(potpin); Serial.print(resultaat); Serial.println(potWaarde); if(potwaarde > (1023*4/5)){ digitalwrite(ledpin, HIGH); else{ digitalwrite(ledpin, LOW); Hier hebben te maken met een nieuwe variabele van het type String. Deze variabele wordt gebruikt om een stukje tekst op te slagen in het geheugen van de Arduino. We maken gebruik van analoge ingangspin A0 Het resultaat van de meting komt terecht in de variabele potwaarde Om de Arduino te laten communiceren met de computer, moeten we eerst de seriele communicatie initialiseren. Die communicatie verloopt over de USB- aansluiting. De spanning van de POTENTIOMETER wordt gemeten dankzij de analogread()- functie We sturen eerst de zin die opgeslagen ligt in de variabele resultaat naar de seriele monitor met behulp van de Serial.print()- functie Vervolgens schrijven we de waarde van de meting opgeslagen in de variabele potwaarde naar het scherm. Hier gebruiken we de Serial.println()- functie, je spreekt dit uit als de printline- functie. Deze zorgt ervoor dat de cursor al naar de volgende regel springt, zodat alle regels mooi onder mekaar weergegeven worden. Hier gebeurt nu iets nieuws! Sommige stuken code moeten alleen worden uitgevoerd wanneer aan een bepaalde voorwaarde wordt voldaan. Hier zal de LED enkel branden indien de gemeten spanning groter is dan 4V. Dit testen we met een if- instructie

15 Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Verander het programma zodat de LED enkel brandt wanneer de spanning minder is dan 1V 3. Breid de schakeling uit met een groene LED, die enkel brandt wanneer de spanning lager is dan 2V. De rode LED brandt wanneer de spanning groter is dan 3V. 4. Breid de schakeling uit met een gele/oranje LED. Zorg ervoor dat de groene LED brandt wanneer de spanning lager is dan 2V, de gele/oranje LED brandt tussen 2V en 4V, en de rode LED brandt boven de 4V. Besluit Maak hiervoor gebruik van de volgende structuur: if(potwaarde > (1023*4/5)){ digitalwrite(rodeledpin, HIGH); digitalwrite(geleledpin, LOW); digitalwrite(groeneledpin, LOW); else if(potwaarde > (1023*2/5)){ // vul zelf in else{ // vul zelf in De belangrijkste les die we hier geleerd hebben heeft te maken met een super- belangrijk concept in de software- wereld: de if- instructie. De if- instructie is telkens als volgt opgebouwd: if(voorwaarde){ code De code zal enkel uitgevoerd worden wanneer voldaan is aan de voorwaarde.

16 De SERVOcontroller We starten nu met het combineren van enkele componenten die we in vorige oefeningen besproken hebben. In deze oefening zullen we de SERVO besturen door middel van een POTENTIOMETER. De stand van de POTENTIOMETER zal de positie van de SERVO bepalen. Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. De signaaldraad van de SERVO wordt verbonden met pin9 een digitale pin en de aftakking van de POTENTIOMETER sluiten we aan op A0 een analoge ingangspin.

17 // SERVO-controller // by Stijn De Mil #include <Servo.h> String resultaat = De POT-waarde is ; int potpin = A0; int servopin = 9; int potwaarde = 0; int servopositie = 0; int vertraging = 100; // de aftakking van de POTENTIOMETER wordt verbonden met // de analoge ingangspin A0 Servo myservo; // we maken een Servo-variabele om de Servo te kunnen aanspreken void setup() { myservo.attach(servopin); // verbind de servo met de servopin Serial.begin(9600); // initialiseer het serieel communicatiekanaal void loop() { potwaarde = analogread(potpin); // lees de huidige waarde van de POTENTIOMETER Serial.print(resultaat); // Schrijf de String resultaat naar de computer Serial.println(potWaarde); // Schrijf de huidige waarde van de POTENTIOMETER // naar de computer en print een nieuwe regel servopositie = map(potwaarde, 0, 1023, 0, 180); // map de potwaarde in het interval [0, 1023] op // het interval [0, 180] en sla dit op in servopositie myservo.write(servopositie); // schrijf de servopositie naar de SERVO delay(vertraging); Deze Arduino sketch meet de spanning van de POTENTIOMETER via de analoge ingangspin en stuurt de waarde naar de seriele monitor 4 van de computer. #include <Servo.h> We importeren de Servo- codebibliotheek om de SERVO te kunnen gebruiken. int potpin = A0; int servopin = 9; int potwaarde = 0; int servopositie = 0; int vertraging = 100; Servo myservo; void setup() { myservo.attach(servopin); Serial.begin(9600); potwaarde = analogread(potpin); servopositie = map(potwaarde, 0, 1023, 0, 180); myservo.write(servopositie); We maken gebruik van analoge ingangspin A0 Het resultaat van de meting komt terecht in de variabele potwaarde. De SERVO is verbonden met pin9, en de positie van de SERVO komt in servopositie. In de setup()- functie koppelen we de SERVO aan de servopin. Om de Arduino te laten communiceren met de computer, moeten we eerst de seriele communicatie initialiseren. De spanning van de POTENTIOMETER wordt gemeten dankzij de analogread()- functie Speciaal! Hier maken we gebruik van de map()- functie, waarmee we de variabele potwaarde in het interval [0, 1023] mappen (omzetten) in een waarde van het interval [0, 180]. Dit resultaat wordt opgeslagen in servopositie. We schrijven de waarde van de servopositie naar de SERVO. Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid de schakeling uit met een extra POTENTIOMETER en SERVO om een pan- tilt systeem te maken. Zoek meer info over zo n systeem via de zoektermen: pan tilt servo arduino 4 Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje rechts bovenaan (afbeelding vergrootglas)

18 Besluit De belangrijkste les die we hier geleerd hebben heeft te maken met het gebruik van de map()- functie 5. Zoek de werking van deze functie op in de Arduino Reference. 5 zie ook

19 De FLEXBEND sensor De FLEXBEND sensor is een flexibele weerstand waarvan de weerstandswaarde verandert afhankelijk van de doorbuiging van deze sensor. Opgelet, je mag deze sensor niet plat plooien! Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. De FLEXBEND- weerstand wordt in serie geplaatst met een weerstand van 10kΩ. Op die manier gedraagt deze schakeling zich een beetje zoals een potentiometer, ttz de aftakspanning zal variëren afhankelijk van de buiging van de FLEXBEND.

20 // FLEXBEND // by Stijn De Mil #include <Servo.h> String resultaat = De FLEXBEND-waarde is ; int flexpin = A0; // de aftakking van de POTENTIOMETER wordt verbonden met // de analoge ingangspin A0 int servopin = 9; int flexwaarde = 0; int servopositie = 0; int flexwaardegestrekt = 330; // aan te passen voor jouw sensor!! int flexwaardegebogen = 100; int vertraging = 100; // aan te passen voor jouw sensor!! Servo myservo; // we maken een Servo-variabele om de Servo te kunnen aanspreken void setup() { myservo.attach(servopin); // verbind de servo met de servopin Serial.begin(9600); // initialiseer het serieel communicatiekanaal void loop() { flexwaarde = analogread(flexpin);// lees de huidige waarde van de FLEXBEND Serial.print(resultaat); // Schrijf de String resultaat naar de computer Serial.println(flexWaarde); // Schrijf de huidige waarde van de FLEXBEND // naar de computer en print een nieuwe regel servopositie = map(flexwaarde, flexwaardegestrekt, flexwaardegebogen, 0, 180); // map de flexwaarde in het interval [flexwaardegestrekt, flexwaardegebogen] op // het interval [0, 180] en sla dit op in servopositie myservo.write(servopositie); // schrijf de servopositie naar de SERVO delay(vertraging); Deze Arduino sketch meet de spanning van de POTENTIOMETER via de analoge ingangspin en stuurt de waarde naar de seriele monitor 6 van de computer. int flexwaardegestrekt = 330; int flexwaardegebogen = 100; servopositie = map(flexwaarde, flexwaardegestrekt, flexwaardegebogen, 0, 180); Niet elke sensor zal steeds exact hetzelfde gedrag vertonen. Dit geldt in het bijzonder voor analoge sensoren zoals de FLEXBEND, een lichtsensor, Iedereen zal voor zijn sensor de waarden van de FLEXBEND moeten aanpassen, dit kan door de FLEXBEND- waarden te bekijken via de seriele monitor. Kijk welke waarden je krijgt wanneer de FLEXBEND gestrekt respectievelijk gebogen is, en pas de waarden in de code aan. Map de flexwaarde in het interval [flexwaardegestrekt, flexwaardegebogen] naar de servopositie in het interval [0, 180] Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid deze schakeling uit met een rode LED die aangeeft wanneer de sensor teveel gebogen wordt (ttz dicht in de buurt komt van de waarde van flexwaardegebogen) Besluit Met de combinatie van FLEXBEND en SERVO zou je een robotanimatie van een hand met 5 vingers kunnen maken, net zoals in het filmpje dat tijdens de intro werd getoond. 6 Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje rechts bovenaan (afbeelding vergrootglas)

21 De TEMPERATUUR sensor De TMP36 is een analoge temperatuursensor die een spanning genereert overeenkomstig een bepaalde temperatuur. Op die manier kan de Arduino de temperatuur berekenen adhv de gemeten spanning! Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. De TMP36 temperatuursensor is heel eenvoudig aan te sluiten maar je moet wel heel goed opletten: Bekijk de component goed en vergewis je ervan dat de referentie TMP36 op de behuizing gedrukt staat. Het is namelijk zo dat verschillende soorten componenten toch dezelfde behuizing hebben, wat voor problemen kan zorgen indien je niet de juiste component vast hebt. Deze component is heel klein, je zal je scherpste oog moeten bovenhalen! Kijk goed welk pootje de + is en welk pootje met de moet verbonden worden!

22 // TEMPERATUUR SENSOR // by Stijn De Mil String strtempcelcius = De temperatuur in graden Celcius is ; int temperaturepin = 0; // de analoge spanningsuitgang van de TMP36 is verbonden met // de analoge ingangspin 0 float temperaturevoltage = 0; float temperature = 0; void setup() { Serial.begin(9600); void loop() { temperaturevoltage = getvoltage(temperaturepin); temperature = gettemperature(temperaturevoltage); Serial.print(strTempCelcius); Serial.println(temperature); delay(1000); // getvoltage() berekent de waarde van de spanning op de analoge ingangspin float getvoltage(int pin){ return(analogread(pin) * ); //omzetting van de digitale waarden [0, 1023] //naar een analoge spanning [0, 5] // gettemperature() berekent de temperatuur in Celcius op basis van de spanning float gettemperature(float voltage){ //omzetting van spanning naar graden Celcius via //10mV per graad met een offset van 500mV return((voltage -.5) * 100); Deze Arduino sketch meet de spanning van de TEMPERATUURSENSOR via de analoge ingangspin en stuurt de waarde naar de seriele monitor 7 van de computer. float getvoltage(int pin){ return(analogread(pin) * ); Om de temperatuur te berekenen gaan we in 2 stappen te werk. Eerst bepalen we de spanning die aangeboden wordt door de TMP36. Hiervoor maken we gebruik van de analogread()- functie die een externe spanning in het interval [0V, 5V] omzet naar een getal in [0, 1023]. Nu willen we de spanning kennen, en dus moeten we als het ware de omgekeerde berekening maken van [0, 1023] naar [0, 5]. 7 Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje rechts bovenaan (afbeelding vergrootglas)

23 float gettemperature(float voltage){ return((voltage -.5) * 100); Dat gebeurt met de coëfficiënt 5/1023 = In de tweede stap bepalen we de temperatuur op basis van de gemeten spanning en rekening houdend met de karakteristiek van de sensor. De TMP36 geeft 10mV per graad Celcius uit, en heeft een offset van 500mV (dit betekent dat 0 C overeenkomt met 500mV) Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid deze schakeling uit met een rode LED die aangeeft wanneer de temperatuur meer wordt dan 30 C. 3. Maak een extra functie die de temperatuur van Celcius kan omzetten in Fahrenheit en print de temperatuur zowel in Celcius als in Faherenheit. Maak hiervoor gebruik van de volgende structuur: float getfahrenheit(float celcius){ // zelf in te vullen en de volgende formule: Fahrenheit = /5*Celcius Besluit Functies geven ons de mogelijkheid om bepaalde stukken code in een afzonderlijke eenheid onder te brengen, waarbij de implementatie en complexiteit wordt afgeschermd van het gebruik van functies. Dit verhoogt de leesbaarheid en herbruikbaarheid aanzienlijk!

24 De TEMPERATUUR controller We gaan nu verder met de TMP36 sensor aan de slag om een echte temperatuurregelaar te maken! Bedoeling is om een ventilator dat in onderstaande tekening als DC- motor is weergegeven te laten draaien wanneer de temperatuur te hoog wordt. Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten. De belangrijkste component die we hier aantreffen is de transistor (cfr symbool Q1), die we kunnen beschouwen als een schakelaar. Een transistor kan aangeschakeld worden, en dan geleidt hij stroom of hij kan uitgeschakeld worden en dan gaat er geen stroom door. De transistor zal in deze schakeling gebruikt worden om de ventilator aan en af te schakelen. Waarom verbinden we de ventilator niet rechtstreeks met een pin van de Arduino, zoals we dat bvb doen bij een LED? Wel, de Arduino kan maar een beperkte hoeveelheid stroom leveren, voldoende voor een LED (20mA) maar absoluut onvoldoende voor grotere gebruikers zoals motortjes. Daarom moeten we deze ventilator rechtstreeks met de voeding verbinden en schakelen via een transistor.

25 Hoe werkt nu zo n transistor? Dit type (NPN) transistor kan aangeschakeld worden wanneer er voldoende stroom door de basis (1) loopt. In dat geval is de transistor AAN en geleidt het stroompad van de collector (2) naar de emitter (3). Hiermee kan je dus een motortje laten draaien. Als er geen stroom in de basis loopt, dan staat de transistor UIT en kan er geen stroom vloeien van de collector naar de emitter. Hiermee kan je een motor terug uitschakelen. In deze schakeling is de basis van de transistor via een weerstand van 330Ω verbonden met pin9 van de Arduino. De emitter is verbonden met de GND, en de collector is verbonden met de motor. Naast de transistor is er nog een tweede nieuwe component die hier gebruikt wordt: de diode. Een LED is eigenlijk een lichtgevende diode, simpel gezegd laat een diode de stroom maar in 1 richting toe volgens de driehoek in het symbool (zie het lijntje dat dwars op de verpakking staat, dat is de min- kant). Wij gebruiken de diode in dit geval om de Arduino te beschermen tegen piekspanningen die kunnen optreden bij het in- en uitschakelen van motortjes, het is dus een vorm van beveiliging. Let er op dat je de diode op de juiste manier aansluit!

26 // TEMPERATUURCONTROLLER // by Stijn De Mil String strtempcelcius = De temperatuur in graden Celcius is ; int temperaturepin = 0; // de analoge spanningsuitgang van de TMP36 is verbonden met // de analoge ingangspin 0 float temperaturevoltage = 0; float temperature = 0; int ventilatorpin = 9; int maxtemperatuur = 30; int mintemperatuur = 24; void setup() { Serial.begin(9600); pinmode(ventilatorpin, OUTPUT); void loop() { temperaturevoltage = getvoltage(temperaturepin); temperature = gettemperature(temperaturevoltage); Serial.print(strTempCelcius); Serial.println(temperature); if(temperature > maxtemperature){ digitalwrite(ventilatorpin, HIGH); else if(temperature < mintemperature){ digitalwrite(ventilatorpin, LOW); delay(1000); // getvoltage() berekent de waarde van de spanning op de analoge ingangspin float getvoltage(int pin){ return(analogread(pin) * ); //omzetting van de digitale waarden [0, 1023] //naar een analoge spanning [0, 5] // gettemperature() berekent de temperatuur in Celcius op basis van de spanning float gettemperature(float voltage){ //omzetting van spanning naar graden Celcius via //10mV per graad met een offset van 500mV return((voltage -.5) * 100); Deze Arduino sketch meet de spanning van de TEMPERATUURSENSOR via de analoge ingangspin en stuurt de waarde naar de seriele monitor 8 van de computer. if(temperature > maxtemperature){ digitalwrite(ventilatorpin, HIGH); else if(temperature < mintemperature){ digitalwrite(ventilatorpin, LOW); We hebben de TEMPERATUURCONTROLLER zo geprogrammeerd dat de ventilator aangezet wordt wanneer de temperatuur meer is dan de ingestelde maximumwaarde. De ventilator wordt terug uitgeschakeld wanneer de temperatuur onder de minimumwaarde zakt. Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid deze schakeling uit met een rode LED die aangeeft wanneer de ventilator draait. Besluit Wanneer we actuatoren aansluiten die meer stroom verbruiken dan LEDS (typisch 10-20mA) dan moeten deze actuatoren gevoed worden vanuit de voedingslijnen (hier bvb 0V (GND) 5V) ipv rechtstreeks via de Arduino- pinnen. Hierin spelen transistoren een cruciale rol, zij worden gebruikt als elektronische schakelaar bediend via de Arduino- pinnen die de actuator met de externe voeding kan verbinden, of het contact kan verbreken. 8 Om de seriele monitor te activeren in Arduino ga je naar Tools>Serial Monitor of je klikt op het icoontje rechts bovenaan (afbeelding vergrootglas)

27 De PUSHBUTTON Een interessante component die we tot nog toe niet besproken hebben is heel eenvoudig een drukknop. Er bestaan verschillende soorten drukknoppen, de zogenoemde pushbutton die we hier gebruiken is een knop en geen schakelaar. Bouw deze schakeling en laad in Arduino de sketch die je hieronder terug kan vinden: Laat je schakeling nakijken door de coach vooraleer je de Arduino via USB aansluit, hiermee willen we voorkomen dat er een kortsluiting in je schakeling zou zitten.

28 // PUSHBUTTON const int buttonpin = 12; const int ledpin = 13; int buttonstate = 0; // the number of the pushbutton pin // the number of the LED pin // variable for reading the pushbutton status void setup() { pinmode(ledpin, OUTPUT); // initialize the LED pin as an output: pinmode(buttonpin, INPUT); // initialize the pushbutton pin as an input: void loop(){ // read the state of the pushbutton value: buttonstate = digitalread(buttonpin); // check if the pushbutton is pressed. // if it is, the buttonstate is LOW: if (buttonstate == LOW) { // turn LED on: digitalwrite(ledpin, HIGH); else { // turn LED off: digitalwrite(ledpin, LOW); Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 2. Breid deze sketch uit zodat de LED knippert wanneer de drukknop langer dan 2 seconden wordt ingedrukt. Besluit Maak hiervoor gebruik van de volgende elementen: long vertragingstijd = 2000; // 2000 ms long starttijd = 0; buttonstate = digitalread(buttonpin); if(buttonstate == LOW){ starttijd = millis(); // start timer if((millis()-starttijd) > vertragingstijd){ // schrijf hier de code Zoek de werking van de functie millis() op in de Arduino Reference!

29 De ULTRASOON- sensor en Installatie Softwarebibliotheek De ULTRASOON- sensor is een afstandssensor waarbij ultrasone geluidsgolven uitgezonden worden door de transmitter, terwijl de tijd gemeten wordt vooraleer gereflecteerde golven op de receiver invallen. Uit deze time- of- flight kan de afstand tot een object gemeten worden. Bouw dit circuit en laad de NewPingExample- sketch nadat je de NewPing library geïnstalleerd hebt: Eerst moet je de NewPing library 9 downloaden en (na unzippen) copieren naar je lokale /libraries- folder 10 van de Arduino folder. Vervolgens moet je Arduino heropstarten voor je met de nieuwe library kan werken. File>Examples>NewPing>NewPingExample Laat je circuit checken door de coach voor je de Arduino via USB met de computer verbindt, om zeker te zijn dat er geen kortsluitingen zijn. The ULTRASOON- sensor die we hier gebruiken type HC- SR04 heeft 4 aansluitingen: Vcc: power supply (5V) Trig: triggert een nieuwe geluidsgolf Echo: ontvangt een reflectiegolf Gnd: ground (0V) 9 download the NewPing library from (check Download section) 10 on Windows typically under the Program Files folder, for Mac check your Documents folder

30 // // Example NewPing library sketch that does a ping about 20 times per second. // #include <NewPing.h> #define TRIGGER_PIN 12 // Arduino pin tied to trigger pin on the ultrasonic sensor. #define ECHO_PIN 11 // Arduino pin tied to echo pin on the ultrasonic sensor. #define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). // Maximum sensor distance is rated at cm. NewPing sonar(trigger_pin, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance. void setup() { Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results. void loop() { delay(50); // Wait 50ms between pings (about 20 pings/sec). // 29ms should be the shortest delay between pings. unsigned int us = sonar.ping(); // Send ping, get ping time in microseconds (us). Serial.print("Ping: "); Serial.print(uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print // result (0 = outside set distance range) Serial.println("cm"); Deze Arduino sketch maakt gebruik van de NewPing bibliotheek om een NewPing- variabele te maken waarmee de afstand tot een object kan gemeten worden. #include <NewPing.h> Zorg ervoor dat je de NewPing bibliotheek geïnstalleerd hebt en in de juiste folder gezet. #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(50); unsigned int us = sonar.ping(); Serial.print("Ping: "); Serial.print(uS / US_ROUNDTRIP_CM); Serial.println("cm"); In plaats van gebruik te maken van variabelen is het meer efficient om labels te creëren, omdat deze gegevens toch niet wijzigen. Met #define creëer je een symbolisch label, dat in de Arduino- sketch tijdens de compilatie vervangen wordt door de toegewezen waarde. Hier wordt een NewPing- variabele sonar gemaakt of om correct te zijn: een sonar- object. Deze variabele krijgt meteen al een aantal configuratiewaarden mee: de aangesloten Triggerpin, de Receiverpin en de maximale afstand die kan gedetecteerd worden (in cm) De belangrijkste functie hier is sonar.ping(). Deze functie start het uitzenden van een geluidsgolf en meet hoe lang het duurt tot een reflectie ontvangen wordt. Een geluidsgolf heeft op zee- niveau een snelheid van 340m/s 11, of dus 34cm/ms of 0,34mm/µs. Het duurt dus ongeveer 30µs voor een geluidsgolf om 1cm af te leggen. Omdat we de tijd meten vanaf uitzenden, wordt eigenlijk de heen- en- terug afstand gemeten, daarom zal de tijd moeten gedeeld worden door 2*30µs = US_ROUNDTRIP_CM Opdrachten 1. Voer deze sketch uit en probeer voor jezelf te begrijpen wat er gebeurt tijdens de uitvoering van de code. 11

31 2. Breid deze sketch uit met een rode, oranje en groene LED zodat de rode LED brandt wanneer de afstand kleiner is dan 40cm. De oranje LED brandt bij een afstand tussen 40cm en 100cm, en de groene LED brandt wanneer de afstand groter is dan 100cm. Besluit In deze oefening leerde je hoe je een bibliotheek kan toevoegen aan je Arduino- installatie. Dit is vaak het geval wanneer je gebruik wil maken van componenten met een specifieke voor Arduino geschreven softwarebibliotheek.

32 Digitale RGB- LEDstrip en gebruik SPI communicatie De digitale RGB- LEDstrip is een LEDstrip waarbij de kleur van elke LED individueel kan ingesteld worden! Om elke LED individueel te kunnen aanspreken, wordt gebruik gemaakt van een SPI- interface waarmee elke LED ahw een apart adres krijgt. Bouw dit circuit (solderen!) en laad de strandtest- sketch nadat je de LPD8806 library geïnstalleerd hebt. Om effectief aan de slag te gaan met deze ledstrip zal je een extra library moeten installeren onder Arduino, je vindt deze op GitHub 12. Vervolgens moet je Arduino heropstarten voor je met de nieuwe library kan werken. File>Examples>LPD8806>strandtest Laat je circuit checken door de coach voor je de Arduino via USB met de computer verbindt, om zeker te zijn dat er geen kortsluitingen zijn. These LED strips are fun and glowy. There are 32 RGB LEDs per meter, and you can control each LED individually! Yes, that's right, this is the digitally- addressable type of LED strip. You can set the color of each LED's red, green and blue component with 7- bit PWM precision (so 21- bit color per pixel). The LEDs are controlled by shift- registers that are chained up down the strip so you can shorten or lengthen the strip. Only 2 digital output pins are required to send data down. The PWM is built into each chip so once you set the color you can stop talking to the strip and it will continue to PWM all the LEDs for you. The strip is made of flexible PCB material, and comes with a weatherproof sheathing. You can cut this stuff pretty easily with wire cutters, there are cut- lines every 2.5"/6.2cm (2 LEDs each). Solder to the 0.1" copper pads and you're good to go. Of course, you can also connect strips together to make them longer, just watch how much current you need! We have a 5V/2A supply that should be able to drive 1 or more meters (depending on use) and a 5V/10A supply that can drive 5 meters (or more, if you are not lighting up all the LEDs at once) You must use a 5V DC power supply to power these strips, do not use higher than 6V or you will destroy the entire strip 12

33 Connecting to Arduino Connect the Black Ground to any ground pin of the microcontroller (this is for data and power ground) Connect the Yellow Clock wire to digital Pin 3 (you can change this later) Connect the Green Data wire to digital Pin 2 (you can change this later) Connect the Red +5V power wire to your 5V power supply. Technical specs 32 LEDs per meter (16 segments) 2 common- anode RGB LEDs per segment, individually controllable Removable IP65 waterproof casing Maximum 120mA draw per 2.5" strip segment (all LEDs on full brightness) - about 2A per meter 16.5mm (0.65") wide (LPD8806), 4.5mm (0.18") thick with casing on, 62.5mm (2.45") long per segment LED wavelengths: 630nm/530nm/475nm Microcontroller required to control strip Installation To download the Arduino library, visit the repository on GitHub. Click the DOWNLOAD ZIP button near the upper left, extract the archive and then rename the uncompressed folder to LPD8806. Confirm that this folder contains the files LPD8806.cpp and LPD8806.h and the examples folder. Place the LPD8806 folder inside your Arduino libraries folder. You may need to create this folder if it does not yet exist. In Windows, this would be (home folder)\my Documents\Arduino\Libraries and for Mac or Linux is (home folder)/documents/arduino/libraries. We also have a tutorial on library installation. After installing the LPD8806 library, restart the Arduino IDE. You should now be able to access the sample code by navigating through menus in this order: File Sketchbook Libraries LPD8806 strandtest strandtest is written for a one meter LED strip attached to Arduino pins 2 and 3. If you're using a longer or shorter strip, you should change this line: Copy Code here LPD8806 strip = LPD8806(32, datapin, clockpin); so that the first argument to the object is the number of LEDs in your strip. Each meter has 32 LEDs so count them or do the math. Now upload it to your Arduino, your strip should start to perform a bunch of demonstration tests! (The 'longstrandtest' sketch already has this change made for a full 5 meter strip.) The other two example sketches LEDbeltKit and advancedledbeltkit are part of a kit based on a different controller board, and won t work on a standard Arduino without modification. This is just a matter of pin assignments if you re crafty you should be able to figure it out. #include "LPD8806.h" #include "SPI.h" // Example to control LPD8806-based RGB LED Modules in a strip /*****************************************************************************/ // Number of RGB LEDs in strand: int nleds = 32; // Chose 2 pins for output; can be any valid output pins: int datapin = 2; int clockpin = 3; // First parameter is the number of LEDs in the strand. The LED strips // are 32 LEDs per meter but you can extend or cut the strip. Next two // parameters are SPI data and clock pins: LPD8806 strip = LPD8806(nLEDs, datapin, clockpin); // You can optionally use hardware SPI for faster writes, just leave out // the data and clock pin parameters. But this does limit use to very // specific pins on the Arduino. For "classic" Arduinos (Uno, Duemilanove, // etc.), data = pin 11, clock = pin 13. For Arduino Mega, data = pin 51, // clock = pin 52. For 32u4 Breakout Board+ and Teensy, data = pin B2,

34 // clock = pin B1. For Leonardo, this can ONLY be done on the ICSP pins. //LPD8806 strip = LPD8806(nLEDs); void setup() { // Start up the LED strip strip.begin(); // Update the strip, to start they are all 'off' strip.show(); void loop() { // Send a simple pixel chase in... colorchase(strip.color(127, 127, 127), 50); // White colorchase(strip.color(127, 0, 0), 50); // Red colorchase(strip.color(127, 127, 0), 50); // Yellow colorchase(strip.color( 0, 127, 0), 50); // Green colorchase(strip.color( 0, 127, 127), 50); // Cyan colorchase(strip.color( 0, 0, 127), 50); // Blue colorchase(strip.color(127, 0, 127), 50); // Violet // Fill the entire strip with... colorwipe(strip.color(127, 0, 0), 50); // Red colorwipe(strip.color( 0, 127, 0), 50); // Green colorwipe(strip.color( 0, 0, 127), 50); // Blue rainbow(10); rainbowcycle(0); // make it go through the cycle fairly fast void rainbow(uint8_t wait) { int i, j; for (j=0; j < 384; j++) { // 3 cycles of all 384 colors in the wheel for (i=0; i < strip.numpixels(); i++) { strip.setpixelcolor(i, Wheel( (i + j) % 384)); strip.show(); // write all the pixels out delay(wait); // Slightly different, this one makes the rainbow wheel equally distributed // along the chain void rainbowcycle(uint8_t wait) { uint16_t i, j; for (j=0; j < 384 * 5; j++) { // 5 cycles of all 384 colors in the wheel for (i=0; i < strip.numpixels(); i++) { // tricky math! we use each pixel as a fraction of the full 384-color wheel // (thats the i / strip.numpixels() part) // Then add in j which makes the colors go around per pixel // the % 384 is to make the wheel cycle around strip.setpixelcolor(i, Wheel( ((i * 384 / strip.numpixels()) + j) % 384) ); strip.show(); // write all the pixels out delay(wait); // Fill the dots progressively along the strip. void colorwipe(uint32_t c, uint8_t wait) { int i; for (i=0; i < strip.numpixels(); i++) { strip.setpixelcolor(i, c); strip.show(); delay(wait);