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();.

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ück geben 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 Kommentare zu „Methoden

  1. Hallo,

    ich vermute du meinst:

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

    Schönes Tutorial. Freue mich schon auf das Päckchen mit dem Arduino. :-)

    Grüße,
    calim

  2. Hallo,

    ichdenke:

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

    mich würde bei der Anleitung interessieren, od die Schleife nur ein Mal durchlaufen wird.
    Muss ich das mit Return erzwingen?

    Grüße,
    Jörg

  3. The backend part of your company supports these profit centers.
    Then consider yourself one of the few, true internet marketers.
    It’s probably some mix of the two, so I have to
    give him props for not going too far in either direction.

  4. Hallole,
    ich hatte mal ne Frage. Wie sieht das ganze aus wenn ich einen Paarmeter übergeben möchte und auch einen zurückbekommen möchte.
    Gruß
    Manfred

  5. Hallo Jörg
    void blinken(int thePin, int dauer){
    digitalWrite(thePin, HIGH);
    digitalWrite(dauer, LOW);
    }
    ist falsch, da du ja nicht den Pin (3000 haste ja eh nicht ) änder möchtest.

    und Manne
    Wenn du etwas übergeben und zurück bekommen möchtest dann versuch doch mal
    float( int Übergabe,float was)
    .
    .
    return ErgebnisZurück
    Habe leider keinen Aduino ( noch nicht )

  6. Also ich würde ja die nachfolgende Methode so ändern:

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

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

    ansonsten ist die delay Zeit dauerhaft 500ms.

    Ansonsten gutes Beispiel.

  7. Hallo,
    dieser Moment wenn man vier/fünf Stunden an einem Programm schreibt und dann einen von tausenden Befehlen nicht kennt. Ich hatte diesesmal vergessen, wie ich einen Void-Teil im Hauptprogramm öffne. Naja, dank dir weiß ichs wieder.
    Vielen Dank für das Tutorial.

    PS: Hab mehr gelernt als ich brauchte ;)

  8. Oder gibts eine bessere Lösung?
    Möchte daß LEDs an 3 Ausgängen blinken, bis ein Schalter – Eingang HIGH ist.
    Robert

  9. Danke, mal.
    Hier der Code:
    void setup() {
    #define LEDws 3
    #define Motor 4
    #define LEDor 5
    #define LEDbl 6
    #define LEDrt 7
    #define LEDgn 8
    #define Tstart 11
    #define Tspirale 12
    #define Tart 13

    Serial.begin (9600);
    pinMode(LEDws, OUTPUT);
    pinMode(Motor, OUTPUT);
    pinMode(LEDor, OUTPUT);
    pinMode(LEDbl, OUTPUT);
    pinMode(LEDrt, OUTPUT);
    pinMode(LEDgn, OUTPUT);
    digitalWrite(Tstart, INPUT);
    digitalWrite(Tspirale, INPUT);
    digitalWrite(Tart, INPUT);
    digitalWrite(Tstart, HIGH);
    digitalWrite(Tspirale, HIGH);
    digitalWrite(Tart, HIGH);
    }
    void starten(int a) {
    digitalWrite(LEDbl, HIGH);
    for (int a=0; a<1000; a++) {
    if (digitalRead(Tstart) == HIGH) { digitalWrite(LEDbl, LOW); return; }
    }
    digitalWrite(LEDbl, LOW);
    delay(1000);
    digitalWrite(LEDbl, HIGH);
    for (int a=0; a<5000; a++) {
    if (digitalRead(Tstart) == HIGH) { digitalWrite(LEDbl, LOW); return; }
    }
    digitalWrite(LEDbl, LOW);
    return;
    }

    void loop() {

    if (digitalRead (Tart)== HIGH)
    { // Taster Betrieb
    while (1) {
    digitalWrite(LEDor, HIGH);
    digitalWrite(LEDws, HIGH);
    starten(5);
    digitalWrite(Motor, HIGH);
    delay(1000);
    digitalWrite(Motor, LOW);
    delay(3000);
    } }
    Mit der Funktion habs mal geschafft, meinen eigentlichen Zweck noch nicht. Aber es muss glaub ich nur mit if Anweisung einfacher gehen. Oder gibts noch was einfacheres?

  10. 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 Kommentare sind geschlossen.