Drumfunctie: verschil tussen versies

Uit TrompBot
Naar navigatie springen Naar zoeken springen
 
(31 tussenliggende versies door 2 gebruikers niet weergegeven)
Regel 1: Regel 1:
Dit is een voorbeeld van een programma voor een drumstel met 3 trommels en twee servos.
{{Hoofdmenu}}
<br>
=Drumfunctie (voor 2 trommels en 1 stok)=
Dit is een voorbeeld van een programma voor een drumstel met 2 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.
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.
Dat komt omdat het programma gebruik maakt van '''functies'''. Met een functie kan je een stuk van je programma meerdere keren gebruiken.
Regel 5: Regel 8:
Dus: als de positie van je servos niet helemaal goed is, hoef je maar 1 getal in de functie te veranderen.
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.
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.
 
<br><br>
==Het Drumstel==
==Het Drumstel==
Dit is het drumstel wat we gaan gebruiken:
Dit is het drumstel wat we gaan gebruiken:
* 3 Trommels (rood, groen en paars)
* 2 Trommels (rood en groen)
* 1 Servo om de arm naar de trommels toe te bewegen (motor A)
* 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)
* 1 Servo om op de trommel te slaan (omlaag-omhoog) (motor B)<br><br>


[[Bestand:trommel-3.png|350px]]
[[Bestand:trommel-2a.png|250px]]
[[Bestand:trommel-2b.png|250px]]<br><br>


motor A willen we op 3 posities kunnen zetten:
motor A willen we op 2 posities kunnen zetten:
* Boven de rode trommel, links (in dit voorbeeld 30 graden)
* Boven de rode trommel, links (in dit voorbeeld 30 graden)
* Boven de groene trommel, in het midden (in dit voorbeeld 90 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:
Motor B willen we op 2 posities kunnen zetten:
Regel 25: Regel 28:
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.
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 ==
== 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. Hoe doen we dat nu? Welke functies (opdrachten) hebben we nodig?
Dit hebben we nodig:
* Beweeg naar rood
* Slag
* Beweeg naar groen
* Slag
* Nog een slag
 
 
Als we nu functies maken voor '''Slag''' en de verschillende '''Beweeg naar...''' opdrachten, dan wordt het programma makkelijk te lezen en makkelijker aan te passen. Hier een voorbeeld:
 


<syntaxhighlight>
<syntaxhighlight>
Regel 31: Regel 45:
  #include <Servo.h>    // zeg de computer dat we de servo functies willen gebruiken, anders kan hij die niet vinden
  #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 motorA;  // definieer een servo met de naam motorA (beweegt naar de trommel)
  Servo motorB;  // definieer een servo met de naam motorB  
  Servo motorB;  // definieer een servo met de naam motorB (maakt de slag)
   
   
  void setup()  
  void setup()  
Regel 39: Regel 53:
   motorB.attach(10); // vebind servo met aansluitpen 10
   motorB.attach(10); // vebind servo met aansluitpen 10
  }
  }
   
 
  void loop()  
// maak de functie "slag" deze opdrachten worden pas uitgevoerd als het woord "slag()" in het loop() gedeelte gebruikt wordt  
  void slag()
  {
  {
  // 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)
   motorB.write (20);        // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (10);        // beweeg slag servo naar om hoog (10 graden stand)
   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
   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
}


  // sla op de groene trommel
// 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)
   motorA.write(90);          // beweeg naar 90 graden stand (groen)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de groene 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
// Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
  motorA.write(120);        // beweeg naar 120 graden stand (paars)
void loop()  
   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)
   rood();                   // voer de functie "rood" uit
   delay(100);               // Wacht 0.1 seconden tot de arm naar beneden is
   slag();                   // voer de functie "slag" uit
   motorB.write (10);         // beweeg slag servo naar om hoog (10 graden stand)
   groen();                   // voer de functie "groen" uit
   delay(100);               // Wacht 0.1 seconden tot de arm weer naar boven is
   slag();                   // voer de functie "slag" uit
   slag();                   // voer de functie "slag" nog een keer uit
  }
  }
</syntaxhighlight>
</syntaxhighlight>


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?
== Aanpassingen ==
Nu moet je gaan uitzoeken waar jou posities van de trommel en de slag zijn. Begin met experimenteren waar bij jou de trommels zitten.
Gebruik het bovenstaande programma, sluit voorlopig alleen motorA aan en verander de waarden in de functies rood en groen net zo lang tot ze op de goede plek uitkomen. Daarna kun je motorB aansluiten en daar de waarden van de functie slag aanpassen.<br><br>
Dit programma 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.<br><br>


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.
= 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 oplossing met functies ==
De namen van functies kan je zelf verzinnen. Je moet alleen rekening houden met een aantal dingen:
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?
* De naam moet 1 woord zijn, '''zonder spaties'''
Het programma kunnen we uitleggen met de volgende woorden:
* De naam mag '''niet met een cijfer beginnen'''
* beweeg naar rood
* De meeste '''leestekens kan je niet gebruiken''' (dus GEEN *, !, @, # etc.) alleen de underscore (dat is het lage liggende streepje: _) mag wel
* Slag
* Je moet de naam '''exact hetzelfde''' zijn waar je de functie maakt en waar je hem gebruikt
* Beweeg naar groen
* '''HOOFDLETTERS''' en '''kleine letters''' worden verschillend gelezen door de computer. Dus: "Piet" is niet hetzelfde als "piet")
* 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?


Success met het maken van je eigen functies! <br><br><br><br>


=Meer voorbeelden van programma's met handige functies=
==2 trommels en 1 stok, met drukknop==


<syntaxhighlight>
<syntaxhighlight>
// drumstel.ino: Beweeg twee servos om op een drumstel te slaan
//twee_trommels_en_drukknop.ino
  #include <Servo.h>    // zeg de computer dat we de servo functies willen gebruiken, anders kan hij die niet vinden
  #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 motorA;  // definieer een servo met de naam motorA (beweegt naar de trommel)
  Servo motorB;  // definieer een servo met de naam motorB  
  Servo motorB;  // definieer een servo met de naam motorB (maakt de slag)
 
   
   
  void setup()  
  void setup()  
Regel 97: Regel 123:
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorB.attach(10); // vebind servo met aansluitpen 10
   motorB.attach(10); // vebind servo met aansluitpen 10
  }
  pinMode(5, INPUT_PULLUP); // drukknop, als input
 
  while ( digitalRead(5) == HIGH ) // zolang de schakelaar HOOG is (niet ingedrukt)
  {
    ; // doe niets (en doe de while loop nog een keer)
  }
}
   


  // maak de functie "slag" deze opdrachten worden pas uitgevoerd als het woord "slag()" in het loop() gedeelte gebruikt wordt   
  // maak de functie "slag" deze opdrachten worden pas uitgevoerd als het woord "slag()" in het loop() gedeelte gebruikt wordt   
Regel 119: Regel 152:
  {
  {
   motorA.write(90);          // beweeg naar 90 graden stand (groen)
   motorA.write(90);          // beweeg naar 90 graden stand (groen)
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de rode trommel staat
   delay(300);                // Wacht 0.3 seconden zodat de motor boven de groene 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
  }
  }


Regel 136: Regel 162:
   groen();                  // voer de functie "groen" 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" nog een keer uit
   slag();                    // voer de functie "slag" uit
  }
  }
</syntaxhighlight>
</syntaxhighlight>


== Aanpassingen ==
==2 trommels en 2 stokken, met drukknop==
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:
In dit voorbeeldje zijn er twee trommels en twee stokken. Ook hier moet je goed uitzoeken op welke positie de tik en de tok bij jouw trommel zitten.<br><br>
[[Bestand:tik-tok.png|350px]]
<br><br>
<syntaxhighlight>
<syntaxhighlight>
//twee_trommels_en_drukknop.ino
#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 (slaat op de rode trommel, tik)
Servo motorB;  // definieer een servo met de naam motorB (slaat op de groene trommel, tok)
void setup()
{               
  motorA.attach(13); // vebind servo met aansluitpen 13
  motorB.attach(10); // vebind servo met aansluitpen 10
  pinMode(5, INPUT_PULLUP); // drukknop, als input
  while ( digitalRead(5) == HIGH ) // zolang de schakelaar HOOG is (niet ingedrukt)
  {
    ; // doe niets (en doe de while loop nog een keer)
  }
}
// maak de functie "tik" deze opdrachten worden pas uitgevoerd als het woord "tik()" in het loop() gedeelte gebruikt wordt 
void tik()
{
  motorA.write (20);        // beweeg slag servo naar beneden (20 graden stand)
  delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
  motorA.write (60);        // beweeg slag servo naar omhoog (60 graden stand)
  delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
}
  // maak de functie "tok" deze opdrachten worden pas uitgevoerd als het woord "tok()" in het loop() gedeelte gebruikt wordt 
void tok()
{
  motorB.write (90);        // beweeg slag servo naar beneden (90 graden stand)
  delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
  motorB.write (30);        // beweeg slag servo naar omhoog (30 graden stand)
  delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
}
  // Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
  // Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
  void loop()  
  void loop()  
  {
  {
   rood();                    // voer de functie "rood" uit
   tik();                    // voer de functie "tik" uit
   slag();                    // voer de functie "slag" uit
   tik();                    // voer de functie "tik" uit
   slag();                   // voer de functie "slag" uit
   delay (500);               // Wacht 0.5 seconden
   groen();                  // voer de functie "groen" uit
   tok();                  // voer de functie "tok" uit
   slag();                    // voer de functie "slag" uit
   tok();                  // voer de functie "tok" uit
  slag();                    // voer de functie "slag" uit
   tik();                    // voer de functie "tik" uit
  paars();                  // voer de functie "paars" uit
   tok();                    // voer de functie "tok" nog een keer 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
  }
  }
</syntaxhighlight>
</syntaxhighlight>
 
Je moet nog wel op de startknop drukken!
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!

Huidige versie van 23 feb 2014 om 20:01

Beginnen | Hardware | Software | Voorbeeldprogramma | Inkscape & lasersnijden | Errors & Tips | Kekbot | [TrompBot Website] | Trompbots | Percussie & ritme | Fioretti programma



Drumfunctie (voor 2 trommels en 1 stok)

Dit is een voorbeeld van een programma voor een drumstel met 2 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:

  • 2 Trommels (rood en groen)
  • 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)

Trommel-2a.png Trommel-2b.png

motor A willen we op 2 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)

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.

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. Hoe doen we dat nu? Welke functies (opdrachten) hebben we nodig? Dit hebben we nodig:

  • Beweeg naar rood
  • Slag
  • Beweeg naar groen
  • Slag
  • Nog een slag


Als we nu functies maken voor Slag en de verschillende Beweeg naar... opdrachten, dan wordt het programma makkelijk te lezen en makkelijker aan te passen. Hier een voorbeeld:


 // 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 (beweegt naar de trommel)
 Servo motorB;  // definieer een servo met de naam motorB (maakt de slag)
 
 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 groene 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
   slag();                    // voer de functie "slag" nog een keer uit
 }

Aanpassingen

Nu moet je gaan uitzoeken waar jou posities van de trommel en de slag zijn. Begin met experimenteren waar bij jou de trommels zitten. Gebruik het bovenstaande programma, sluit voorlopig alleen motorA aan en verander de waarden in de functies rood en groen net zo lang tot ze op de goede plek uitkomen. Daarna kun je motorB aansluiten en daar de waarden van de functie slag aanpassen.

Dit programma 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.

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!



Meer voorbeelden van programma's met handige functies

2 trommels en 1 stok, met drukknop

//twee_trommels_en_drukknop.ino
 #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 (beweegt naar de trommel)
 Servo motorB;  // definieer een servo met de naam motorB (maakt de slag)

 
 void setup() 
 {                
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorB.attach(10); // vebind servo met aansluitpen 10
   pinMode(5, INPUT_PULLUP); // drukknop, als input
   
  while ( digitalRead(5) == HIGH ) // zolang de schakelaar HOOG is (niet ingedrukt)
  {
    ; // doe niets (en doe de while loop nog een keer)
  } 
}
 

 // 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 groene 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
   slag();                    // voer de functie "slag" nog een keer uit
 }

2 trommels en 2 stokken, met drukknop

In dit voorbeeldje zijn er twee trommels en twee stokken. Ook hier moet je goed uitzoeken op welke positie de tik en de tok bij jouw trommel zitten.

Tik-tok.png

//twee_trommels_en_drukknop.ino
 #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 (slaat op de rode trommel, tik)
 Servo motorB;  // definieer een servo met de naam motorB (slaat op de groene trommel, tok)
 
 
 void setup() 
 {                
   motorA.attach(13); // vebind servo met aansluitpen 13
   motorB.attach(10); // vebind servo met aansluitpen 10
   pinMode(5, INPUT_PULLUP); // drukknop, als input
 
  while ( digitalRead(5) == HIGH ) // zolang de schakelaar HOOG is (niet ingedrukt)
  {
    ; // doe niets (en doe de while loop nog een keer)
  } 
}
 
 
 // maak de functie "tik" deze opdrachten worden pas uitgevoerd als het woord "tik()" in het loop() gedeelte gebruikt wordt  
 void tik()
 {
   motorA.write (20);         // beweeg slag servo naar beneden (20 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorA.write (60);         // beweeg slag servo naar omhoog (60 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
 } 
  // maak de functie "tok" deze opdrachten worden pas uitgevoerd als het woord "tok()" in het loop() gedeelte gebruikt wordt  
 void tok()
 {
   motorB.write (90);         // beweeg slag servo naar beneden (90 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm naar beneden is
   motorB.write (30);         // beweeg slag servo naar omhoog (30 graden stand)
   delay(100);                // Wacht 0.1 seconden tot de arm weer naar boven is
 } 
 
 
 // Dit gedeelte wordt herhaald. Het gebruikt nu alleen functies
 void loop() 
 {
   tik();                    // voer de functie "tik" uit
   tik();                    // voer de functie "tik" uit
   delay (500);               // Wacht 0.5 seconden
   tok();                   // voer de functie "tok" uit
   tok();                   // voer de functie "tok" uit
   tik();                    // voer de functie "tik" uit
   tok();                    // voer de functie "tok" nog een keer uit
 }

Je moet nog wel op de startknop drukken!