Sobald euer Programm eine gewisse Größe erreicht, wird es schnell unübersichtlich. Außerdem werdet ihr bemerken, dass ihr bestimmte Teile eures Codes immer wieder verwendet, so dass ein großer Teil eures Programms aus redundantem Copy&Paste besteht.

Ein typisches Beispiel dafür wäre z.B. ein Programmteil, der dafür sorgt, dass der Roboter eine bestimmte Strecke nach vorne fährt.

Was liegt also näher, als diese Teile eures Programms in wiederverwendbaren Modulen zu verpacken, die ihr immer dort, wo ihr sie braucht, mit einem einzelnen Wort aufrufen könnt?

Genau dabei helfen euch Funktionen.

Funktionen sind kleine „Unterprogramme“. Sie können (optional) Eingabedaten entgegennehmen („Parameter“), in einem Programmabschnitt etwas damit machen, und dann (optional) ein Ergebnis an den Programmteil, der sie aufgerufen hat, zurückgeben („Rückgabewert“).

Auch die meisten Befehle von Arduino sind als Funktionen programmiert - so z.B. analogRead, digitalWrite usw.

Um eine Funktion zu erstellen, müsst ihr sie in eurem Programm „deklarieren“. Die Deklaration enthält folgende Angaben:

• Einem Namen, unter dem ihr die Funktion aufrufen könnt (vor den Runden Klammern)
• Optional Parameter, die ihnen beim Aufruf übergeben werden. (in den runden Klammern
• Einen Rückgabetypen, also eine Angabe darüber, was für einen Variablentypen das „Ergebnis“ der Funktion hat (wenn nichts zurückgegeben wird, steht da void
• Einen Codeabschnitt „Body“, der ausgeführt wird, wenn die Funktion aufgerufen wird.

Das Ganze sieht dann in etwa so aus:

rückgabeTyp funktionsName(parameter1Typ parameter1Name, ...){
 code;
}

Falls ihr euch wundert: Ja - auch „setup“ und „loop“ sind Funktionen…

Hier ein Beispiel für eine Funktion, die ein „S“ auf der LED morst, wenn sie aufgerufen wird. Sie braucht dafür keine Parameter und Rückgabe.

void setup(){
  pinMode (13, OUTPUT);  // schalte den LED-Pin auf "Ausgang"
}
 
void loop(){
  morseS();    // rufe die Funktion "morseS" auf.
  delay(1000); //warte etwas 
}
 
// Hier versprochene die Funktion:
// Die Funktion gibt nichts zurück (deshalb "void")
// Die Funktion hat den Namen "morseS"
// die Funktion hat keine Parameter (deshalb nichts in den Klammern)
void morseS(){
  //die Funktion macht dreimal kurz das Licht an, wenn sie aufgerufen wird.
  digitalWrite(13,HIGH);
  delay(200);
  digitalWrite(13,LOW);
  delay(200);
 
  digitalWrite(13,HIGH);
  delay(200);
  digitalWrite(13,LOW);
  delay(200);
 
  digitalWrite(13,HIGH);
  delay(200);
  digitalWrite(13,LOW);
}

Etwas mehr Flexibiliät gewinnen wir, wenn wir die Funktion so schreiben, dass sie den Pin und die Geschwindigkeit als Parameter entgegen nimmt.

Dazu Schreiben wir diese beiden Parameter mit ihren Typen in die runden Klammern der Funktionsdeklaration, so wie wenn wir eine Variable deklarieren würden.

...
 
// neu: die parameter "zeit" und "pin"
void morseS(int pin, int zeit){
  //In diesem Programmteil sind die beiden Parameter als Variablen verfügbar.
  digitalWrite(pin, HIGH);
  delay(zeit);
  ...
}
...

Die Werte, die in die Variablen eingesetzt (übergeben) werden sollen, werden beim Aufruf in die Klammern hineingeschrieben. Das Programm erkennt an der Reihenfolge, mit der sie in den Klammern stehen, welcher Wert in welche Variable soll:

...
void loop(){
  morseS(10, 250); // Blinke diesmal auf Pin 10 und etwas langsamer...
}
...

In vielen Fällen wollen wir, dass ein wiederverwendbarer Programmteil

Wenn in der Informatik bestimmte Abschnitte an verschiedenen Stellen gleich sind, werden sie oft in Methoden ausgelagert, damit das Programm übersichtlicher bleibt. Diese Methoden können dann an diesen Stellen aufgerufen werden.
Außerdem hat man die Möglichkeit einer Methode Werte in Form von sogenannten Parametern zu übergeben. Diese können dann in der Methode verwendet werden. Auch kann die Methode etwas zurück geben, diese Werte heißen dann Rückgabewerte.
Die Arduino-Plattform bringt schon viele Methoden/Funktionen mit, die benutzt werden können und nicht erst selbst geschrieben werden müssen. Der Vorteil einer Methode ist es, dass man kleine Einheiten hat, die getestet werden können, wenn man einen Fehler hat. Zusätzlich bleibt der Programmcode übersichtlicher und der Code ist auch nicht doppelt geschrieben. Wenn ein Fehler gefunden wurde, muss er so nur an einer Stelle behoben werden.
Ein Beispiel für eine Methode ohne Parameter und Rückgabewert:

void doSomething()
{
	 Serial.println ("Hallo");
}

Dabei steht das „void“ dafür, dass keine Rückgabe erwartet wird.
Immer wenn die Methode mit dem Methodennamen

doSomething();

im Programm aufgerufen wird, schreibt dieses „Hallo\“ in den Serialmonitor.
Nun ein Beispiel für eine Parameterübergabe und einen Rückgabewert:

int sum(int k) //Parameter k vom Typ Integer
{
	int summe = 0
	for (i=0; i<=k; i++)
	 {
	 	summe = summe + i;
	 }
	 return summe
} //das Pragramm berechnet die Summe von 1 bis k

Hier sind gleich mehrere Sachen zu sehen. Als erstes zum Parameter k, der hier ein Integer ist. Innerhalb dieser Methode ist nun k der Wert, der übergeben wurde. Außerhalb der Methode ist k jedoch nicht bekannt! Dann sehen wir, dass diesmal nicht „void“ vor dem Methodennamen steht, sondern „int“. Das bedeutet, dass hier ein Rückgabewert vom Typ Integer erwartet wird. Dieser wird dann mit „return“ zurück gegeben. Diese Methode kann im Programm mit dem Methodennamen und einem Wert für k aufgerufen werden:

int sum;
sum = sum(5); //Parameter k=5

Nach dieser Zeile ist dann $sum=15$.
In den Klammern können auch Ausdrücke stehen, die erst noch berechnet werden müssen oder andere Methoden aufgerufen werden, die einen entsprechenden Typen zurückgeben:

sum = sum(2+3); //Parameter k=5
sum = sum(2+sum(2));