Funktionen - Programmieren mit Arduino

Lesezeit: 9 Minuten

Inhalt

Erklärung
Funktionen mit Rückgabewert
Funktionen mit einer Abfolge von Befehlen ohne Rückgabewert
- Funktion ohne die Übergabe von Variablen
- Funktion mit Übergabe von Variablen
  - Variable vom Typ int
  - Übergabe eines Arrays

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(0)); 
}

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(0));
}

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.

String-Funktion - Anzeige im Seriellen Monitor

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

Array

Letzte Aktualisierung: 3. Aug 2023 @ 14:03

Erklä­rung

Funk­tio­nen mit Rückgabewert

int-Funk­ti­on

String-Funk­ti­on

bool-Funk­ti­on

Funk­tio­nen mit einer Abfol­ge von Befeh­len ohne Rückgabewert

Funk­ti­on ohne die Über­ga­be von Variablen

Funk­ti­on mit Über­ga­be von Variablen

Varia­ble vom Typ int

Über­ga­be eines Arrays