Erklärung
Mit Funktionen können Programmteile erstellt werden, die eine bestimmte Aufgabe ausführen und dann zu der Stelle im Programm zurückkehren, von dem aus die Funktion aufgerufen wurde. Der Vorteil ist, dass häufig verwendete Programmteile nur einmal erstellt werden müssen. Sie können dann an beliebiger Stelle im Programm aufgerufen werden. Eine Funktion kann eine Folge von Befehlen ausführen und eine Variable an die Stelle zurückgeben (return), von der sie aufgerufen wurde oder lediglich eine Folge von Befehlen „abarbeiten“.
Funktionen mit Rückgabewert
Die Funktion mit einem Rückgabewert besteht aus der Deklaration des Typs der Variablen (int, float, bool, String), die zurückgegeben wird, optional einer oder mehrere durch Kommata getrennte Variablen, die der Funktion übergeben werden und den Anweisungen.
return gibt den Wert der Variablen an das Hauptprogramm zurück.
Jede Funktion muss außerhalb des setup- und des loop-Teils stehen.
int-Funktion
Das Programm erstellt auf Tastendruck Zufallszahlen zwischen 1 und 49 und zeigt sie an.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
int TASTER = 4; void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); pinMode(TASTER, INPUT_PULLUP); randomSeed(analogRead(A0)); } void loop() { int Minimum = 1; int Maximum = 50; int TasterStatus = digitalRead(TASTER); if (TasterStatus == LOW) { delay(200); // Aufruf der Funktion, Variable übergeben int Zahl = ZufallsZahl(Minimum, Maximum); Serial.print("Zufallszahl\t"); Serial.println(Zahl); } } // Funktion, der Typ der übergebenen Variable muss definiert werden int ZufallsZahl(int Minimum, int Maximum) { int Zahl = random(Minimum, Maximum); return Zahl; } |
Zufallszahlen nach Druck auf die Enter-Taste.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
int Minimum = 1; int Maximum = 50; void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); // Zufallsgenerator starten randomSeed(analogRead(A0)); } void loop() { // auf serielle Eingabe warten while (Serial.available() > 0) { // Eingabe im Seriellen Monitor lesen char Zeichen = Serial.read(); // Enter/Senden gedrückt if (Zeichen == '\n') { // Aufruf der Funktion int Zahl = ZufallsZahl(Minimum, Maximum); // \t = Tabulator Serial.print("Zufallszahl\t"); Serial.println(Zahl); } } } // Funktion, der Typ der übergebenen Variable muss definiert werden int ZufallsZahl(int Minimum, int Maximum) { int Zahl = random(Minimum, Maximum); return Zahl; } |
float-Funktion
Das Programm bildet aus zwei Zufallszahlen einen Quotienten.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
int Minimum = 10; int Maximum = 100; void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); // Zufallsgenerator starten randomSeed(analogRead(A0)); } void loop() { // auf serielle Eingabe warten while (Serial.available() > 0) { // Eingabe im Seriellen Monitor lesen char Zeichen = Serial.read(); // Enter/Senden gedrückt if (Zeichen == '\n') { // Aufruf der Funktion float Ergebnis = Quotient(Minimum, Maximum); Serial.println(Ergebnis); } } } // Funktion, der Typ der übergebenen Variable muss definiert werden float Quotient(int Minimum, int Maximum) { float Ergebnis; float Zahl1 = random(Minimum, Maximum); float Zahl2 = random(Minimum, Maximum); // keine Division durch 0 if (Zahl1 > 0 && Zahl2 > 0) Ergebnis = Zahl1 / Zahl2; return Ergebnis; } |
String-Funktion
Das Programm ersetzt in einem Text einen Vokal durch einen anderen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); Serial.println("Bitte Text eingeben:"); } void loop() { // auf serielle Eingabe warten while (Serial.available() > 0) { // solange lesen, bis return \n // eingegeben wurde String Eingabe = Serial.readStringUntil('\n'); // das letzte Zeichen ist return ⇒ soll entfernt werden Eingabe = Eingabe.substring(0, Eingabe.length() - 1); // Original-Text ausgeben Serial.println(Eingabe); Serial.println("-------------------------------------"); // Funktion aufrufen // Parameter: Eingabe, zu suchender Vokal, Ersatzvokal String VokalErsetzen = VokalZaehlen(Eingabe, 'a', 'i'); Serial.println("-------------------------------------"); Serial.print(VokalErsetzen); } } // String-Funktion String VokalZaehlen(String Eingabe, char Vokal, char VokalErsatz) { int AnzahlVokale = 0; for (int i = 0; i < Eingabe.length(); i++) { // wenn der Vokal gefunden wurde // -> durch den "Ersatzvokal" ersetzen // Anzahl der Ersetzungen zählen if (Eingabe[i] == Vokal) { Eingabe[i] = VokalErsatz; AnzahlVokale ++; } } // Anzahl der Ersetzungen anzeigen Serial.println(String(Vokal) + " " + String(AnzahlVokale) + "-mal ersetzt durch " + String(VokalErsatz)); return Eingabe; } |
bool-Funktion
Das Programm verwendet eine bool-Funktion, um die Teiler einer Zahl zu bestimmen und im Seriellen Monitor anzuzeigen.
Ist kein Teiler vorhanden, wird die Meldung ausgegeben, dass es sich um eine Primzahl handelt.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
// wenn es sich um eine Primzahl handelt -> Primzahl = true bool Primzahl; void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); Serial.println("Zahl eingeben:"); } void loop() { String Eingabe; while (Serial.available() > 0) { // solange lesen, bis return \n eingegeben wurde Eingabe = Serial.readStringUntil('\n'); // eingegebene Zahl zu int umwandeln int Zahl = Eingabe.toInt(); Serial.println("-----------------------------"); // Aufruf der Funktion DivisorSuchen bool Divisor = DivisorSuchen(Zahl); if (Primzahl) Serial.println(String(Zahl) + " ist eine Primzahl"); else Serial.println("Teiler von " + String(Zahl)); } } bool DivisorSuchen(int Zahl) { Primzahl = true; // nur bis zur Hälfte der Zahl prüfen for (int i = 2; i <= Zahl / 2; i++) { // wenn kein Rest ⇒ Zahl ist teilbar ⇒ aktuellen Divisor anzeigen if (Zahl %i == 0) { Serial.println(i); // Divisor vorhanden ⇒ keine Primzahl Primzahl = false; } } /* Wert von Primzahl wird an das Hauptprogramm zurückgegeben false = keine Primzahl true = Primzahl */ return Primzahl; } |
Das Programm berechnet die Fakultät der Zahlen bis 12.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); } void loop() { // auf serielle Eingabe warten while (Serial.available() > 0) { int Zahl = Serial.parseInt(); // Enter/Senden gedrückt if (Serial.read() == '\n') { /* die Variable unsigned long ist auf den Wert 4.294.967.295 beschränkt 13! = 6.227.020.800 -> größere Werte nicht möglich */ if (Zahl < 13) { unsigned long Fakultaet = FakultaetBerechnen(Zahl); Serial.println("Fakult\u00e4t von " + String(Zahl) + ": " + Fakultaet); Serial.println("-------------------------"); } else Serial.println("Die Zahl muss < 13 sein!"); } } } long FakultaetBerechnen(long Zahl) { unsigned long Ergebnis = 1; for (int i = 1; i <= Zahl; i++) { Ergebnis = Ergebnis * i; } return Ergebnis; } |
Funktionen ohne Rückgabewert
Soll die Funktion nur eine Abfolge von Befehlen erledigen, muss sie mit dem Schlüsselwort void eingeleitet werden.
Funktion ohne die Übergabe von Variablen
|
1 2 3 4 5 6 7 |
void LEDBlinken() { digitalWrite(LED, HIGH); delay(500); digitalWrite(LED, LOW); delay(500); } |
Die Funktion LEDBlinken kann jetzt beliebig oft im loop-Teil aufgerufeń werden.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
int LED = 7; void setup() { pinMode(LED, OUTPUT); } void loop() { LEDBlinken(); } void LEDBlinken() { digitalWrite(LED, HIGH); delay(500); digitalWrite(LED, LOW); delay(500); } |
Funktion mit Übergabe von Variablen
Variable vom Typ int
Beispiel Übergabe von Variablen vom Typ int:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/* LED -> ROT, GELB, GRUEN Leuchtdauer -> Einschalten/Ausschalten in Millisekunden AnzahlBlinken -> Anzahl der Blinkvorgänge */ void LEDBlinken(int LED, int LeuchtDauer, int AnzahlBlinken) { for (int i = 0; i < AnzahlBlinken; i++) { digitalWrite(LED, HIGH); delay(Leuchtdauer); digitalWrite(LED, LOW); delay(Leuchtdauer); } } |
Das Programm sieht dann so aus:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
int ROT = 7; int GELB = 8; int GRUEN = 9; int Leuchtdauer; int AnzahlBlinken; void setup() { pinMode(ROT, OUTPUT); pinMode(GELB, OUTPUT); pinMode(GRUEN, OUTPUT); } void loop() { /* LED -> ROT, GELB, GRUEN Leuchtdauer -> Einschalten/Ausschalten in Millisekunden AnzahlBlinken -> Anzahl der Blinkvorgänge */ LEDBlinken(ROT, 100, 3); LEDBlinken(GELB, 200, 4); LEDBlinken(GRUEN, 300, 5); } void LEDBlinken(int LED, int LeuchtDauer, int AnzahlBlinken) { for (int i = 0; i < AnzahlBlinken; i++) { digitalWrite(LED, HIGH); delay(Leuchtdauer); digitalWrite(LED, LOW); delay(Leuchtdauer); } } |
Übergabe eines Arrays
Das Programm erfragt eine Zahl und stellt die Vielfachen dieser Zahl im Zahlenraum bis 100 dar.
Das dazugehörige Programm:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
void setup() { Serial.begin(9600); // auf serielle Verbindung warten while (!Serial); Serial.println("Bitte eine Zahl eingeben:"); } void loop() { // Array erstellen int Zahlen[100]; // auf serielle Eingabe warten while (Serial.available() > 0) { int Divisor = Serial.parseInt(); // Enter/Senden gedrückt if (Serial.read() == '\n') { // Länge des Arrays Zaheln ermitteln int Laenge = sizeof(Zahlen) / sizeof(Zahlen[0]); // Array mit Zahlen füllen for (int i = 1; i <= Laenge; i++) { Zahlen[i] = i; } Serial.println("Die durch " + String(Divisor) + " teilbaren Zahlen im Zahlenraum bis " + String(Laenge) + " sind:"); Serial.println("---------------------------------------------------"); /* Ergebnisse mit der Funktion ErgebnisAnzeigen anzeigen übergebene Parameter: Array Zahlen Divisor Länge des Arrays */ ErgebnisAnzeigen(Zahlen, Divisor, Laenge); } } } void ErgebnisAnzeigen(int Zahlen[], int Divisor, int Laenge) { // mit Hilfe der Funktion modulo wird ermittelt, // ob die Zahl durch den Divisor teilbar ist for (int i = Divisor; i < Laenge; i++) { if (Zahlen[i] % Divisor == 0) Serial.print(String(Zahlen[i]) + ", "); } Serial.println(); Serial.println("---------------------------------------------------"); } |
Letzte Aktualisierung: