Drumfunctie

Dit is een voorbeeld van een programma voor een drumstel met 3 trommels en twee servos. Je kan het aanpassen naar meer of minder trommels en je kan makkelijk de posities van de trommels en het ritme aanpassen. Dat komt omdat het programma gebruik maakt van functies. Met een functie kan je een stuk van je programma meerdere keren gebruiken. Als je dan iets moet veranderen dan hoeft dat alleen in de functie en niet op alle verschillende plekken in het programma. Dus: als de positie van je servos niet helemaal goed is, hoef je maar 1 getal in de functie te veranderen. Of: als je het ritme wilt aanpassen hoef je alleen de volgorde van het aanroepen van de functies te veranderen, en niet de wat er in de functie geschreven is.

Het Drumstel

Dit is het drumstel wat we gaan gebruiken:

• 3 Trommels (rood, groen en paars)
• 1 Servo om de arm naar de trommels toe te bewegen (motor A)
• 1 Servo om op de trommel te slaan (omlaag-omhoog) (motor B)

motor A willen we op 3 posities kunnen zetten:

• Boven de rode trommel, links (in dit voorbeeld 30 graden)
• Boven de groene trommel, in het midden (in dit voorbeeld 90 graden)
• Boven de paarse trommel, rechts (in dit voorbeeld 120 graden)

Motor B willen we op 2 posities kunnen zetten:

• Omhoog, boven de trommel (in dit voorbeeld 10 graden)
• Naar beneden, op de trommel (in dit voorbeeld 20 graden)

De exacte getallen voor de hoeken van de servos zijn natuurlijk voor iedere constructie anders (en daar komen we laten op terug) maar voor het voorbeeld gaan we nu eerst even uit van deze getallen.

Het programma

 // drumstel.ino: Beweeg twee servos om op een drumstel te slaan
 #include <Servo.h>    // zeg de computer dat we de servo functies willen gebruiken, anders kan hij die niet vinden

 Servo motorA;  // definieer een servo met de naam motorA 
 Servo motorB;  // definieer een servo met de naam motorB 
 
 void setup() 
 {                
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorB.attach(10); // vebind servo met aansluitpen 10
 }
 
 void loop() 
 {
   // sla op de rode trommel
   motorA.write(30);          // beweeg naar 30 graden stand (rood)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
   motorB.write (20);         // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (10);         // beweeg slag servo naar om hoog (10 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is

   // sla op de groene trommel
   motorA.write(90);          // beweeg naar 90 graden stand (groen)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
   motorB.write (20);         // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (10);         // beweeg slag servo naar om hoog (10 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is

   // sla op de paarse trommel
   motorA.write(120);         // beweeg naar 120 graden stand (paars)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
   motorB.write (20);         // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (10);         // beweeg slag servo naar om hoog (10 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
 }

Dit is een simpele beweging: sla op rood, groen, paars en ga weer naar rood. Hoewel dit programma prima werkt, en je het kan veranderen als jouw robot drumstel niet helemaal dezelfde posities heeft, of snelheid. Of als je een ander ritme wil: het kan allemaal. Maar je zal zien dat het programma snel heel lang wordt, en heel veel (bijna) dezelfde tekst bevat. Is dat erg?

Dit programma wordt lastig als het groter wordt: stel de positie van de rode trommel moet niet 30 zijn, maar 35! Dan moet je dat in het hele programma aanpassen. Of de hoogte van de drumslag: niet 20 maar 25: hetzelfde verhaal! Nu kunnen er fouten in het programma komen, omdat je ergens iets vergeet te veranderen. Of het programma wordt zo lang dat je het niet meer makkelijk kan lezen! In het ergste geval wordt het programma zo lang dat het niet meer in de microcontroller past.

De oplossing met functies

De oplossing is het gebruik van functies. Functies zijn kleine stukjes programma die je meerdere keren kan uitvoeren. Zo hoef je niet steeds hetzelfe in te typen. Je kunt een functie het beste vergelijken met een woord: als ik een nieuw woord verzin en jou uitleg wat dat woord betekend, kan ik in het vervolg dat woord gebruiken en weet jij wat ik bedoel zonder dat ik dat steeds met een heleboel zinnen hoef uit te leggen. Dat woord kan ik makkelijk vaker gebruiken. Hoe doen we dat nu? Welke woorden (opdrachten) zien we in het vorige programma terugkomen? Het programma kunnen we uitleggen met de volgende woorden:

• beweeg naar rood
• Slag
• Beweeg naar groen
• Slag
• Beweeg naar paars
• Slag

Als we nu functies maken voor Slag en de verschillende Beweeg naar... opdrachten, dan wordt het programma een stuk simpeler en makkelijker aan te passen. Hier is hetzelfe programma, maar nu met deze functies. Zie je de verschillen?

 // drumstel.ino: Beweeg twee servos om op een drumstel te slaan
 #include <Servo.h>    // zeg de computer dat we de servo functies willen gebruiken, anders kan hij die niet vinden

 Servo motorA;  // definieer een servo met de naam motorA 
 Servo motorB;  // definieer een servo met de naam motorB 
 
 void setup() 
 {                
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorB.attach(10); // vebind servo met aansluitpen 10
 }

 // maak de functie "slag" deze opdrachten worden pas uitgevoerd als het woord "slag()" in het loop() gedeelte gebruikt wordt  
 void slag()
 {
   motorB.write (20);         // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (10);         // beweeg slag servo naar om hoog (10 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
 } 

 // maak de functie "rood" deze opdrachten worden pas uitgevoerd als het woord "rood()" in het loop() gedeelte gebruikt wordt  
 void rood()
 {
   motorA.write(30);          // beweeg naar 30 graden stand (rood)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
 }

 // maak de functie "groen" deze opdrachten worden pas uitgevoerd als het woord "groen()" in het loop() gedeelte gebruikt wordt  
 void groen()
 {
   motorA.write(90);          // beweeg naar 90 graden stand (groen)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
 }

 // maak de functie "paars" deze opdrachten worden pas uitgevoerd als het woord "paars()" in het loop() gedeelte gebruikt wordt  
 void paars()
 {
   motorA.write(120);         // beweeg naar 120 graden stand (paars)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
 }

 // Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
 void loop() 
 {
   rood();                    // voer de functie "rood" uit
   slag();                    // voer de functie "slag" uit
   groen();                   // voer de functie "groen" uit
   slag();                    // voer de functie "slag" uit
   paars();                   // voer de functie "paars" uit
   slag();                    // voer de functie "slag" uit
 }

Aanpassingen

Hoewel het totale programma nu langer lijkt (door alle regels om de functies te maken, en ook door al het commentaar) is het gedeelte van de loop() veel korter en simpeler. Dat kan je ook makkelijker aanpassen om bijvoorbeeld een nieuw ritme te maken. Andersom: als de posities of tijd van de slag niet helemaal goed zijn, kan je dit op 1 plek (in de slag functie) aanpassen, en wordt dit op alle plekken waar je "slag" gebruikt ook veranderd.

Verander het loop() gedeelte bijvoorbeeld eens naar:

 // Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
 void loop() 
 {
   rood();                    // voer de functie "rood" uit
   slag();                    // voer de functie "slag" uit
   slag();                    // voer de functie "slag" uit
   groen();                   // voer de functie "groen" uit
   slag();                    // voer de functie "slag" uit
   slag();                    // voer de functie "slag" uit
   paars();                   // voer de functie "paars" uit
   slag();                    // voer de functie "slag" uit
   slag();                    // voer de functie "slag" uit
   slag();                    // voer de functie "slag" uit
   groen();                   // voer de functie "groen" uit
   slag();                    // voer de functie "slag" uit
 }

Je ziet: een heel ander ritme, met maar een paar regels extra. Het blijft makkelijk leesbaar en makkelijk te veranderen!

Zelf maken van functies

Nog een paar opmerking voordat je zelf functies gaat maken.

• Functies moeten aan het begin van jouw programma staan
• Een functie heeft bij het maken altijd de volgende onderdelen: void naam van jouw functie { jouw opdrachten }
• Je kan in je eigen functies ook weer andere functies gebuiken.

De namen van functies kan je zelf verzinnen. Je moet alleen rekening houden met een aantal dingen:

• De naam moet 1 woord zijn, zonder spaties
• De naam mag niet met een cijfer beginnen
• De meeste leestekens kan je niet gebruiken (dus GEEN *, !, @, # etc.) alleen de underscore (dat is het lage liggende streepje: _) mag wel
• Je moet de naam exact hetzelfde zijn waar je de functie maakt en waar je hem gebruikt
• HOOFDLETTERS en kleine letters worden verschillend gelezen door de computer. Dus: "Piet" is niet hetzelfde als "piet")

Success met het maken van je eigen functies!