Zum Inhalt springen

Methoden

    Methoden sind Programmanweisungsblöcke. Wiederkehrende Abfolgen von Befehlen können in Methoden sinnvoll strukturiert werden. Parameter können an Methoden übergeben und Werte zurückgeliefert werden.

    Eine einfache Methode könnte so aussehen:

    void blinken(){  // Anweisungsblock Start
      digitalWrite(ledPin, HIGH);
      delay(500);
      digitalWrite(ledPin, LOW);
      delay(500);
      // Anweisungsblock Ende
    }

    Nun kann man die Methode z.B. aus dem void loop() aufrufen mit blinken();.


    Sieh dir jetzt meinen neuen Arduino-Videokurs an: Jetzt ansehen!


    Parameter lassen sich auch an Methoden übergeben. Die Struktur sieht so aus:

    void blinken(int thePin, int dauer){
      digitalWrite(thePin, HIGH);
      delay(500);
      digitalWrite(thePin, LOW);
      delay(500);
    }

    Hierbei wird der Parameter thePin und Dauer übergeben. Der Aufruf kann dann so erfolgen: blinken(3,1000);.

    Man kann auch einen Wert von der Methode zurückgeben lassen. Dafür verwendet man anstelle von void den Variablentyp, den das Ergebnis haben wird und liefert es am Ende des Anweisungsblockes mit dem Schlüsselwort return an die Methode.

    float quadrat(float x){
      float ergebnis = x*x;
      return ergebnis;
    }

    Der Aufruf wäre z.B.:

    wert = quadrat(12.3);

    12 Gedanken zu „Methoden“

    1. Hi

      Hätte diese ‘Dinger’ eher Funktionen genannt, habe Diese auch so benannt kennen gelernt.
      Aber warum nicht, jedem Tierchen, Sein Pläsierchen.

      @Alex
      Die ‘Methode’ muß dem Programm bekannt sein, BEVOR Diese aufgerufen wird.
      Das kannst Du hinbekommen, indem Du Diese VOR setup() schreibst – lässt Dich aber den Überblick über das eigentliche Programm vollkommen verlieren.

      Deshalb meine Variante:
      VOR setup() kommt eine Art Bekanntmachung:
      void meine_methode(int a, intb);
      Durch den Strichpunkt ist die ‘Methode’ nur bekannt gemacht und wird vom Compiler in den Tiefen Deines Quelltextes gesucht, irgendwo findet Der dann:
      void meine_methode[int a, int b){
      Also mit öffnender Klammer – hier wird die Methode ‘ganz normal’ geschrieben, da void (also OHNE Rückgabewert) muß Da auch kein return rein.
      Wenn Du statt Dessen einen Wert zurück haben willst, dann mit return.
      Kleines Beispiel:

      int plus(byte a, byte b); //Funktion bekannt machen
      byte wert_A=0;wert_B=0; //Variablen erstellen

      void setup(){
      … setupcode … //Setup-Zeug
      Serial.begin(9600);
      }

      void loop(){
      wert_A++;
      wert_B++;
      int ergebnis=plus(wert_A, wert_B);
      Serial.print(wert_A);
      Serial.print(“+”);
      Serial.print(wert_B);
      Serial.print(“=”);
      Serial.println(ergebnis);
      }

      int plus(byte a, byte b){ //Funktion definieren
      … Zeug machen, wofür die Funktion gedacht ist …
      return (a+b);
      }

      Das sollte so lauffähig sein.
      Float sollte man, wenn nicht unbedingt benötigt, vermeiden – solange der Code aber in den µC rein passt und tut, was Er soll – passt’s.

    Die Kommentarfunktion ist deaktiviert.