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 einen Befehl 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 der Variablen, die zurückgegeben wird, optional einer oder mehrere durch Komma getrennt 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.
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.
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;
}String-Funktion
Das Programm ersetzt in einem Text einen Vokal durch einen anderen.
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.
// 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.
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 mit einer Abfolge von Befehlen 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
Beispiel:
void LEDBlinken()
{
digitalWrite(LED, HIGH);
delay(500);
digitalWrite(LED, LOW);
delay(500);
}Die Funktion LEDBlinken kann jetzt beliebig oft im loop-Teil aufgerufeń werden.
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:
/*
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:
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
Beispiel
Das Programm erfragt eine Zahl und stellt die Vielfachen dieser Zahl im Zahlenraum bis 100 dar.
Das dazugehörige Programm:
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("---------------------------------------------------");
}
Variable ArrayLetzte Aktualisierung: