Funk­tio­nen

Lese­zeit: 9 Minu­ten

---

Erklä­rung

Funk­tio­nen mit Rückgabewert

Die Funk­ti­on mit einem Rück­ga­be­wert besteht aus der Dekla­ra­ti­on der Varia­blen, die zurück­ge­ge­ben wird, optio­nal einer oder meh­re­re durch Kom­ma getrennt Varia­blen, die der Funk­ti­on über­ge­ben wer­den und den Anweisungen.

return gibt den Wert der Varia­blen an das Haupt­pro­gramm zurück.

Jede Funk­ti­on muss außer­halb des setup- und des loop-Teils stehen.

int-Funktion

Das Pro­gramm erstellt auf Tas­ten­druck Zufalls­zah­len zwi­schen 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; 
}

Zufalls­zah­len 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 Pro­gramm 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 Pro­gramm ver­wen­det eine bool-Funktion, um die Tei­ler einer Zahl zu bestim­men und im Seri­el­len Moni­tor anzuzeigen. 

Ist kein Tei­ler vor­han­den, wird die Mel­dung aus­ge­ge­ben, dass es sich um eine Prim­zahl 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");

    // das letzte Zeichen ist return  → soll entfernt werden
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // 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 Pro­gramm berech­net die Fakul­tät der Zah­len 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;
}

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

Soll die Funk­ti­on nur eine Abfol­ge von Befeh­len erle­di­gen, muss sie mit dem Schlüs­sel­wort void ein­ge­lei­tet werden.

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

Bei­spiel:

void LEDBlinken()  
{ 
   digitalWrite(LED, HIGH); 
   delay(500); 
   digitalWrite(LED, LOW); 
   delay(500);  
}

Die Funk­ti­on LED­Blin­ken kann jetzt belie­big oft im loop-Teil auf­ge­ru­feń werden.

int LED = 7;

void setup()
{
  pinMode(LED, OUTPUT);
}

void loop()
{
  LEDBlinken();
}

void LEDBlinken()  
{ 
   digitalWrite(LED, HIGH); 
   delay(500); 
   digitalWrite(LED, LOW); 
   delay(500);  
} 

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

Varia­ble vom Typ int

Bei­spiel Über­ga­be von Varia­blen 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 Pro­gramm 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);
   }
 } 

Über­ga­be eines Arrays

Bei­spiel

Das Pro­gramm erfragt eine Zahl und stellt die Viel­fa­chen die­ser Zahl im Zah­len­raum bis 100 dar.

Das dazu­ge­hö­ri­ge 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. Nov 2022 @ 7:19

Letzte Aktualisierung: 3. Nov 2022 @ 7:19