Go Down

Topic: Anleitung Ein Endlicher Automat entsteht (Read 12929 times) previous topic - next topic

agmue

Jul 11, 2015, 12:17 pm Last Edit: Jul 12, 2015, 11:28 am by agmue
Idee: Im Forum taucht immer wieder der Rat auf: „Das kann man mit einem Endlichen Automaten lösen." Hier ein Beispiel, wie einer entsteht.

Zielgruppe: Anfänger, die noch nie einen Endlichen Automaten programmiert haben, oder jene, die es getan haben, aber nicht wussten.

Motivation: Mit einem Endlichen Automaten kann ich Sketche realisieren, an die ich mich vorher nicht getraut hätte.

Aufgabenstellung: Ein Kohlekran auf einer Eisenbahnanlage soll Kohle von einem Kohlehaufen in einen Eisenbahnwagen verladen.

Material: Neben einem Arduino, ich verwende einen UNO, drei LEDs mit je einem Vorwiderstand und ein Schrittmotor, wobei die Ansteuerung des Schrittmotors nebensächlich ist.

Quellen: Viele nette Menschen, die ihr Wissen im Internet zur Verfügung stellen so wie in diesem Forum.
Tabelle für die Schrittmotoransteuerung


1. Schritt: Konzept der Ablaufsteuerung
Vor meinem geistigen Auge befindet sich ein Kohlehaufen und ein zu beladener Wagen. Die Anfangsposition sei beim Kohlehaufen, die Schaufel geöffnet.
  • Kran dreht zum Taster für den Nullpunkt (links von Kohlehaufen)
  • Kran dreht auf Startposition beim Kohlehaufen
  • am Kohlehaufen, Schaufel runter
  • am Kohlehaufen, Schaufel schließen
  • am Kohlehaufen, Schaufel rauf
  • Kran dreht zum Wagen
  • am Wagen, Schaufel runter
  • am Wagen, Schaufel öffnen
  • am Wagen, Schaufel rauf
  • Kran dreht zum Kohlehaufen

Die Punkte 1 und 2 werden nur am Anfang durchlaufen, die Punkte 3 bis 10 wiederholt.

2. Schritt: Konzept testen
Um zu sehen, ob die Logik stimmt, nutzen wir den seriellen Monitor der IDE.
Code: [Select]

enum ZUSTAENDE {SucheNull, Anfangsposition, KSrunter, KSschliessen, KSrauf, WKdrehen, WSrunter, WSoeffnen, WSrauf, KKdrehen};
byte zustand = SucheNull;

void setup() {
  Serial.begin(9600);
  Serial.println("Programmstart");
}

void loop() {
  switch (zustand) {
    case SucheNull:
      if (MilliVerzoegerung(1000)) {
        Serial.println("1. Kran dreht zum Taster fuer den Nullpunkt (links von Kohlehaufen)");
        zustand = Anfangsposition;
      }
      break;
    case Anfangsposition:
      if (MilliVerzoegerung(1000)) {
        Serial.println("2. Kran dreht auf Startposition beim Kohlehaufen");
        zustand = KSrunter;
      }
      break;
    case KSrunter:
      if (MilliVerzoegerung(2000)) {
        Serial.println("3. am Kohlehaufen, Schaufel runter");
        zustand = KSschliessen;
      }
      break;
    case KSschliessen:
      if (MilliVerzoegerung(2000)) {
        Serial.println("4. am Kohlehaufen, Schaufel schliessen");
        zustand = KSrauf;
      }
      break;
    case KSrauf:
      if (MilliVerzoegerung(2000)) {
        Serial.println("5. am Kohlehaufen, Schaufel rauf");
        zustand = WKdrehen;
      }
      break;
    case WKdrehen:
      if (MilliVerzoegerung(2000)) {
        Serial.println("6. Kran dreht zum Wagen");
        zustand = WSrunter;
      }
      break;
    case WSrunter:
      if (MilliVerzoegerung(2000)) {
        Serial.println("7. am Wagen, Schaufel runter");
        zustand = WSoeffnen;
      }
      break;
    case WSoeffnen:
      if (MilliVerzoegerung(2000)) {
        Serial.println("8. am Wagen, Schaufel oeffnen");
        zustand = WSrauf;
      }
      break;
    case WSrauf:
      if (MilliVerzoegerung(2000)) {
        Serial.println("9. am Wagen, Schaufel rauf");
        zustand = KKdrehen;
      }
      break;
    case KKdrehen:
      if (MilliVerzoegerung(2000)) {
        Serial.println("10. Kran dreht zum Kohlehaufen");
        zustand = KSrunter;
      }
      break;
  }
}

bool MilliVerzoegerung(unsigned long millisIntervall) {  // Während die Zeit läuft, darf diese Funktion wegen der static-Variablen nicht ein zweites Mal aufgerufen werden!
  static unsigned long intervall = 0;
  static unsigned long prevMillis;
  unsigned long aktMillis = millis();
  if (intervall == 0) {
    intervall = millisIntervall;
    prevMillis = aktMillis;
  }
  if (aktMillis - prevMillis >=  intervall) {
    intervall = 0;
    return true;
  }
  return false;
}


Die Funktion MilliVerzoegerung() wartet die angegebenen Millisekunden, bis sie den Zustand true zurückgibt, wodurch die Befehle innerhalb der Bedingung ausgeführt werden. Anders als delay() ist diese Funktion nicht blockierend, was den wesentlichen Unterschied ausmacht. Allerdings darf diese Funktion wegen der static-Variablen nicht ein zweites Mal aufgerufen werden, während eine Zeit läuft!

Damit ist der Endliche Automat fertig.
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

agmue

#1
Jul 11, 2015, 12:17 pm Last Edit: Nov 07, 2016, 11:22 am by agmue
3. Schritt: Funktionalität ergänzen
Was folgt ist die Definition der Ein- und Ausgänge, die Ansteuerung des Kranmotors und der Schaufel. Die Nutzung des seriellen Monitors muss leider entfallen, da sie zu langsam ist!

Für die Kranbewegung nutze ich das „Schrittmotor-Set S-SPSM-5V" mit Getriebe. Um die Massenträgheit des Krans zu simulieren, wird die Bewegung beschleunigt und verzögert. Ein Servo bewegt die Schaufel auf (170 Grad) und ab (10 Grad).

Derzeitiger Zwischenstand des Sketches:

Code: [Select]
#include <Servo.h>
Servo servoblau;       // Erzeugt ein Objekt
const byte pinFreigabe = 2;  // LOW=dreht; HIGH=stopp
const byte pinNullTaster = 3;  // HIGH-LOW-Flanke=Start; LOW-HIGH-Flanke =Stopp
const byte pinMotor[] = {4, 5, 6, 7};  // IN1, IN2, IN3, IN4 des Boards S-SPSM-5V von Pollin
const byte pinSchaufelaufzu = 8;
const byte pinServoSchaufel = 9;
const unsigned int SchrittZeitNullTaster = 7777; // Verzoegerungszeit im Millisekunden für Geschwindigkeit
const unsigned int SchrittZeitKranDrehen = 5555; // Verzoegerungszeit im Millisekunden für Geschwindigkeit
const unsigned int AnfangspositionKran = 480; // Schritte (4096 entspricht 360 Grad)
const unsigned int WagenpositionKran = 1024; // Schritte (4096 entspricht 360 Grad)
const unsigned int BeschlSchritte = 100;
const unsigned int BeschlIntervall = 50;
const unsigned int VerzSchritte = 100;
const unsigned int VerzIntervall = 50;
enum ZUSTAENDE {InitSchaufelRauf, SucheNull, Anfangsposition, KSrunter, KSschliessen, KSrauf, KdrehenW, WSrunter, WSoeffnen, WSrauf, KdrehenK};
byte zustand = InitSchaufelRauf;
const int verzZeitServoSchaufel = 40;
const byte posServoSchaufelOben = 165;
const byte posServoSchaufelUntenKohle = 10;
const byte posServoSchaufelUntenWagen = 30;
enum ZUSTAENDESERVO {Initialisierung, Bewegung};
byte zustandServo = Initialisierung;

void setup() {
  servoblau.attach(pinServoSchaufel);              // gibt den Pin an wo das Servo 1 angeschlossen ist
  for (byte i = 0; i < sizeof(pinMotor); i++) {
    pinMode(pinMotor[i], OUTPUT);
  }
  pinMode(pinSchaufelaufzu, OUTPUT);
  pinMode(pinServoSchaufel, OUTPUT);
  pinMode(pinFreigabe, INPUT_PULLUP);
  pinMode(pinNullTaster, INPUT_PULLUP);
}

void loop() {
  if (digitalRead(pinFreigabe) == LOW) {
    switch (zustand) {         // hier beginnt der endliche Automat
      case InitSchaufelRauf:
        if (servoSchaufel(posServoSchaufelOben)) { // Schaufel rauf fahren
          zustand = SucheNull;
        }
        break;
      case SucheNull:
        if (digitalRead(pinNullTaster) == HIGH) {
          schrittMotor(-4096, SchrittZeitNullTaster, 0, 0, 0, 100);  // 4096 entspricht 360 Grad Drehung
        } else {
          schrittMotor(0, SchrittZeitNullTaster, 0, 0, 0, 100);
          zustand = Anfangsposition;
        }
        break;
      case Anfangsposition:
        if (schrittMotor(AnfangspositionKran, SchrittZeitNullTaster, 0, 0, 0, 100)) {
          zustand = KSrunter;
        }
        break;
      case KSrunter:
        if (servoSchaufel(posServoSchaufelUntenKohle)) { // Schaufel runter fahren
          zustand = KSschliessen;
        }
        break;
      case KSschliessen:
        digitalWrite(pinSchaufelaufzu, HIGH);   // Schaufel schließen
        if (MilliVerzoegerung(2000)) {
          zustand = KSrauf;
        }
        break;
      case KSrauf:
        if (servoSchaufel(posServoSchaufelOben)) { // Schaufel rauf fahren
          zustand = KdrehenW;
        }
        break;
      case KdrehenW:
        if (schrittMotor(WagenpositionKran, SchrittZeitKranDrehen, BeschlSchritte, BeschlIntervall, VerzSchritte, VerzIntervall)) {
          zustand = WSrunter;
        }
        break;
      case WSrunter:
        if (servoSchaufel(posServoSchaufelUntenWagen)) { // Schaufel runter fahren
          zustand = WSoeffnen;
        }
        break;
      case WSoeffnen:
        digitalWrite(pinSchaufelaufzu, LOW);   // Schaufel oeffnen
        if (MilliVerzoegerung(2000)) {
          zustand = WSrauf;
        }
        break;
      case WSrauf:
        if (servoSchaufel(posServoSchaufelOben)) { // Schaufel rauf fahren
          zustand = KdrehenK;
        }
        break;
      case KdrehenK:
        if (schrittMotor(-WagenpositionKran, SchrittZeitKranDrehen, BeschlSchritte, BeschlIntervall, VerzSchritte, VerzIntervall)) {
          zustand = KSrunter;
        }
        break;
    }
  } else {
    off();
  }
}

void off() {
  for (byte i = 0; i < sizeof(pinMotor); i++) {
    digitalWrite(pinMotor[i], LOW);
  }
  digitalWrite(pinSchaufelaufzu, LOW);
  zustand = InitSchaufelRauf;
}

bool MicroVerzoegerung(unsigned long microsIntervall) {  // Während die Zeit läuft, darf diese Funktion wegen der static-Variablen nicht ein zweites Mal aufgerufen werden!
  static unsigned long intervall = 0;
  static unsigned long prevMicros;
  unsigned long aktMicros = micros();
  if (intervall == 0) {
    intervall = microsIntervall;
    prevMicros = aktMicros;
  }
  if (aktMicros - prevMicros >=  intervall) {
    intervall = 0;
    return true;
  }
  return false;
}

bool MilliVerzoegerung(unsigned long millisIntervall) {  // Während die Zeit läuft, darf diese Funktion wegen der static-Variablen nicht ein zweites Mal aufgerufen werden!
  static unsigned long intervall = 0;
  static unsigned long prevMillis;
  unsigned long aktMillis = millis();
  if (intervall == 0) {
    intervall = millisIntervall;
    prevMillis = aktMillis;
  }
  if (aktMillis - prevMillis >=  intervall) {
    intervall = 0;
    return true;
  }
  return false;
}

bool servoSchaufel(byte sollPosition) {
  static byte istPosition;
  int zeit = verzZeitServoSchaufel;
  switch (zustandServo) {
    case Initialisierung:
      istPosition = servoblau.read();
      zustandServo = Bewegung;
      break;
    case Bewegung:
      if (sollPosition == istPosition) {
        zustandServo = Initialisierung;
        return true;
      } else {
        if (MilliVerzoegerung(zeit)) {
          if (sollPosition > istPosition) {
            istPosition++;
          } else {
            istPosition--;
          }
          servoblau.write(istPosition);
        }
      }
      break;
  }
  return false;
}

bool schrittMotor(int sollSchritte, unsigned int sollIntervall, unsigned int beschleunigungSchritte, unsigned int beschleunigungIntervall, unsigned int verzoegerungSchritte, unsigned int verzoegerungIntervall) {
  // const byte schrittfolge[] = {B1000, B0100, B0010, B0001};  // Vollschritt eine Phase
  // const byte schrittfolge[] = {B1001, B1010, B0110, B0101};  // Vollschritt zwei Phasen
  const byte schrittfolge[] = {B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001};  // Halbschritt
  static unsigned int schrittZaehler;
  static unsigned long zeit;
  static byte schritt = 0;
  byte bitfolge = 0;
  if (schrittZaehler == 0 || sollSchritte == 0) {
    schrittZaehler = abs(sollSchritte);  // 360° = 64 * 64 = 4096
    zeit = sollIntervall + beschleunigungIntervall * beschleunigungSchritte;
  }
  if (MicroVerzoegerung(zeit)) {
    bitfolge = schrittfolge[schritt];
    for (byte j = 0; j < sizeof(pinMotor); j++) {
      digitalWrite(pinMotor[j], (bitfolge >> j) & 1);
    }
    if (abs(sollSchritte) - schrittZaehler < beschleunigungSchritte && beschleunigungSchritte > 0) {
      zeit -= beschleunigungIntervall;
    }
    if (schrittZaehler < verzoegerungSchritte) {
      zeit += verzoegerungIntervall;
    }
    if (schrittZaehler > 0) {
      schrittZaehler--;
    }
    if (sollSchritte > 0) {
      schritt--;
    }
    if (sollSchritte < 0) {
      schritt++;
    }
    if (schritt < 0) {
      schritt = sizeof(schrittfolge);
    } else {
      schritt = schritt % sizeof(schrittfolge);
    }
  }
  if (schrittZaehler == 0) {
    for (byte i = 0; i < sizeof(pinMotor); i++) {
      digitalWrite(pinMotor[i], LOW);
    }
    return true;
  }
  return false;
}



Ähnliche Themen:

Anleitung Endlicher Automat mit millis()

BlinkwithoutDelay - Die Nachtwächtererklärung

millis() Überlauf umgehen einschließlich Definition einer Klasse

Zustandsautomaten für Fortgeschrittene

Fußgängerampel Erweiterung mit den Vorschlägen von jurs unter Verwendung der FSM-Library SM.h!

Ein Automat ohne delay()

Zur Anschauung ein Bild des Kohlekranfunktionsmodells (Januar 2016):
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Serenifly

Da sieht man auch schön wie unübersichtlich die switch/case Variante ist :)

Für kleine Dinge ok, aber es wird irgendwann problematisch, da der ganze Code an einer Stelle steht.

agmue

Jeder Sketch ist zu was nütze, und sei es als abschreckendes Beispiel  ;)
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

udoklein

#4
Jul 12, 2015, 09:26 am Last Edit: Jul 12, 2015, 09:28 am by Udo Klein
Ich glaube nicht, daß switch-case das Problem ist. Das Problem ist, daß er den Code für die Zustände in die Case Zweige packt statt sie in Funktionen auszulagern.

Den Switch Case durch den Aufruf von Funktionspointern zu ersetzen macht den Code nur vordergründig übersichtlicher. Wenn man das tut, dann sieht man nicht mehr welche Funktionen gerufen werden sondern nur noch wie die Signaturen aussehen. Ob das soviel besser ist wage ich zu bezweifeln. Andererseits ist es damit (also CPS) sehr viel leichter die Zustände zu erweitern. Es hängt also wie immer vom Kontext ab was besser ist.

Schlimmer finde ich die Verzögerungsfunktionen. Die sind Singletons. Das kracht gewaltig wenn man mehr als einen Automaten abarbeiten will. Sowas muß man als Instanzen anlegen und korrekt verwalten.
Check out my experiments http://blog.blinkenlight.net

guntherb

Ach Leute, nun lasst mal die Kirche im Dorf.

agmue ist angetreten um zu erklären, wie man mittels Zustandsautomat ein System programmieren kann.
Und ich finde, das ist ihm sehr gut gelungen. Respekt!

Dass man im Code (wie in jedem Code) Sachen besser oder anders machen kann ist klar.
Aber das ist kein C-Tutorial, sondern eben nur eine Beschreibung, was ein Zustandsautomat  ist und wie man ihn nutzen kann.

ich finde, solche Beiträge sollten ins Tutorial wandern.

Grüße
Gunther

combie

#6
Jul 12, 2015, 11:57 am Last Edit: Sep 13, 2016, 06:07 pm by combie
Quote
agmue ist angetreten um zu erklären, wie man mittels Zustandsautomat ein System programmieren kann.
Und ich finde, das ist ihm sehr gut gelungen. Respekt!
Yes!
Und, ich glaube, er möchte auch Rückkopplung... ;-)


Dieses "endliche Automaten" Dingen ist ein Thema, über das wir hier im Forum noch tausende Male sprechen. Es wird in tausenden Varianten in Software gegossen werden.

Quote
Die sind Singletons.
Singletons sind böse.
Globale Variablen sind böse.
Überhaupt, alles was globale Räume verstopft und Seiteneffekte produzieren kann, ist böse. Und doch wird man sich mit bösen Dingen arrangieren müssen. Unsere begrenzen Systeme lassen einfach keine weit gehende Abstraktion und Dynamik zu. Jedes mal, wenn man sowas einsetzt, darf man denken: "Das könnte mich mal zum stolpern bringen."


Also reden!
Immer wieder, über Modelle und ihre Vor- und Nachteile.
Optimieren kann man nur in eine Richtung.
Es wird immer wieder auf Kompromisse hinaus laufen.
Man sollte keine Dummheit zweimal begehen, die Auswahl ist schließlich groß genug.
Quelle: Jean-Paul Sartre

agmue

#7
Jul 12, 2015, 12:00 pm Last Edit: Jul 12, 2015, 12:18 pm by agmue
Ich freue mich immer über freundliche Reaktionen wie diese  :)
Schlimmer finde ich die Verzögerungsfunktionen. Die sind Singletons. Das kracht gewaltig wenn man mehr als einen Automaten abarbeiten will. Sowas muß man als Instanzen anlegen und korrekt verwalten.
Danke für den Hinweis! Den habe ich jetzt sowohl im Kommentar als auch im Text ergänzt. Das ist wichtig zu berücksichtigen!

Instanzen gehören wohl zu OOP und wären daher für die Zielgruppe m. E. nicht geeignet. Aber wie ich schon Serenifly geantwortet habe: Wenn man mit den bekannten Möglichkeiten an Grenzen stößt, ist dies eine prima Motivation, sich neues Wissen anzueignen, um die Grenzen zu überwinden. Für mich habe ich mir das auf jeden Fall schon mal vorgemerkt!
agmue ist angetreten um zu erklären, wie man mittels Zustandsautomat ein System programmieren kann.
Und das für Änfänger! Danke, da fängt der Tag gut an  :)  :)  :)

Besonders Stolz, auch wenn es mit dem Thema nichts zu tun hat, bin ich auf die Beschleunigungs- und verzögerungsrampe. Der Kran scheint zu ächzen, um von der Haft- in die Gleitreibung zu kommen, obwohl der Motor - ich habe es versehendlich probiert - die Kranmasse locker herumwirbeln kann. Der Kran ist aber nur ein Funktionsmodell, um die Vor- und Nachteile von Servo, Schritt- und DC-Motor mit dem Modellbahner, der das dann auf seiner Anlage realisiert, zu besprechen.
Yes!
Und, ich glaube, er möchte auch Rückkopplung... ;-)
Stimmt! Denn so habe ich durch Dich den Endlichen Automaten für mich entdeckt, Danke!

Und Serenifly hatte bei einem anderen Thema vorgeschlagen, die Zeitverzögerung in eine Funktion zu verlagern, was ich nun erstmals realisiert habe. Daß er mich zu bösem Code verleitet hat, wurde mir erst beim Schreiben bewußt, also bin ich jetzt ein :smiley-evil: Macht auch mal Spaß!
Die Vorstellungskraft ist wichtiger als Wissen, denn Wissen ist begrenzt. (Albert Einstein)

Serenifly

#8
Jul 12, 2015, 12:27 pm Last Edit: Jul 12, 2015, 12:36 pm by Serenifly
Wenn man das tut, dann sieht man nicht mehr welche Funktionen gerufen werden sondern nur noch wie die Signaturen aussehen
Stimmt. Aber wirklichen Überblick über alle Zustandsübergänge hat man sowieso nur durch ein Diagramm. Rein aus dem Code den Ablauf schnell zu verstehen geht mit keiner Variante gut.

Quote
Und Serenifly hatte bei einem anderen Thema vorgeschlagen, die Zeitverzögerung in eine Funktion zu verlagern, was ich nun erstmals realisiert habe
Ich habe hier bisher auch niemanden gesehen der mehrere Automaten gleichzeitig wollte. Jurs hatte es mal bei der Ampelschaltung kurz vorgeschlagen, falls man mehrere Ampeln möchte. Aber wenn man mal soweit ist, dann kann man sich auch mal damit auseinandersetzen eine kleine Klasse zu programmieren. Es reicht ja die eine Funktion in eine Klasse zu verpacken. Da gibt es auch noch ein anderes Stichwort: function object

udoklein

#9
Jul 12, 2015, 01:37 pm Last Edit: Jul 12, 2015, 01:42 pm by Udo Klein
Entweder in ein Objekt oder in eine Klasse. Beides geht. Objekte haben den Vorteil weniger Code zu erzeugen und damit Flash zu sparen. (Template) Klassen haben den Vorteil, daß man sie statisch mehrfach instanziieren kann. Das kostet zwar mehr Flash spart dann aber SRAM. Je nachdem was knapper ist, ist der eine oder der andere Weg besser.

Und dann wären da noch Koroutinen: http://blog.blinkenlight.net/experiments/dcf77/goto-considered-helpful/. Man beachte die Verwendung von Goto Statements um ein Yield Makro zu bekommen :)

@Serenify: das ist auch ein Beispiel bei dem jemand mehr als einen Automaten braucht.
- Automat für den Parser
- Automat für die Zeitschaltuhr
- Automaten für Dekodergruppen / den Demodulator
- Automat für die lokale Uhr
- Automat für die Autosync Option

Die nächste Version wird noch mehr Automaten brauchen.

Sobald man anfängt mit Objekten zu arbeiten die mindestens ein Flag beinhalten, dann stellt sich sowieso die Frage wo die Grenze zum Automaten ist. D.h. ich habe bisher fast nie Software gesehen die nur einen Automaten beinhaltet.
Check out my experiments http://blog.blinkenlight.net

Serenifly

#10
Jul 12, 2015, 02:13 pm Last Edit: Jul 12, 2015, 02:18 pm by Serenifly
Deine Software bewegt sich auch auf einem ganz anderen Level als das was die Leute machen die hier mit Fragen kommen. Da gibt es sehr vieles was sich mit einem einzelnen Automaten lösen lässt. Meistens geht es darum einen einzelnen Motor steuern oder ein paar LEDs mit einem Taster in einer bestimmten Reihenfolge leuchten lassen. Das sind eigentlich ganz einfache Sachen.

Bei derartigen Projekten bräuchte man dann mehrere Automaten wenn man mehrere unabhängige Motoren hat oder mehrere Ampeln mit unterschiedlichen Leuchtzeiten.

Dies sind auch meistens absolute Anfänger, die das erste mal von millis() hören. Da muss man nicht noch gleich Klassen/Objekte dazupacken wenn es nicht wirklich nötig ist. Das kann man ja problemlos erweitern. Wenn man mal eine nicht-blockierende Delay Funktion verstanden hat ist es auch kein so großer Schritt mehr mehrere Instanzen davon zu haben.

combie

#11
Jul 12, 2015, 06:40 pm Last Edit: Jul 12, 2015, 06:42 pm by combie
Dies sind auch meistens absolute Anfänger, die das erste mal von millis() hören. Da muss man nicht noch gleich Klassen/Objekte dazupacken wenn es nicht wirklich nötig ist. Das kann man ja problemlos erweitern. Wenn man mal eine nicht-blockierende Delay Funktion verstanden hat ist es auch kein so großer Schritt mehr mehrere Instanzen davon zu haben.
Hooo...

Naja..
Ich sehe das etwas anders.
Man kann Menschen nicht unterstützen, beschützen, helfen, in dem man ihnen Wissen vor enthält.
Jeder Mensch lernt in seiner eigenen Geschwindigkeit. Zuviel Wissen wird automatisch ausgeblendet. Ein Aspekt der selektiven Wahrnehmung. Jeder von uns tut das so.

Wissen zurückhalten...
Sollte man mit Kindern ja auch nicht tun.
Sicherlich können sie nicht alles sofort und beim ersten mal vollständig verarbeiten. Aber davon gehört zu haben, bereitet den Boden für die nächste Saat.

Manchmal ist es unglaublich schwieriger falsch gelerntes wieder zu korrigieren, als gleich das richtige zu lernen. Denn das falsche übt sich fest.

Das Gefühl "Da ist noch was!" erzeugt Interesse.
Das Gefühl "Der hält Wissen zurück!" irritiert.
Man ist dann fix bei Macht und Machtlosigkeit.
Man sollte keine Dummheit zweimal begehen, die Auswahl ist schließlich groß genug.
Quelle: Jean-Paul Sartre

Serenifly

Manchmal ist es unglaublich schwieriger falsch gelerntes wieder zu korrigieren, als gleich das richtige zu lernen. Denn das falsche übt sich fest.
Das ist aber keine Sache von falsch oder richtig. Es funktioniert beides. Eine einzelne Funktion halt mit Einschränkungen.

Und ich habe hier schon leider gesehen dass manche Leute damit überfordert sind eine ganz einfache Klasse mit einer Variablen und einre einzelnen Methode zu haben. Und nicht nur absolute Anfängern, sondern auch Leute die schon etwas weiter sind und mit einfacher prozedurale Programmierung klar kommen. Andere tun OOP als ungeeignet für den Arduino ab, anscheinend nicht wissend wie viel OOP in der Arduino Software steckt.
Wenn jemand programmieren kann, ja dann kann man etwas weiter ausholen. Aber einem Anfänger würde ich nicht zu viel auf einmal vor die Füße werfen. Die haben oft schon Probleme den einfachen Code zu verstehen.

Kommt halt auf den Zweck und die Zielgruppe an. In einem Tutorial kann man das mit Ausbau-Stufen erledigen. Man fängt erst mal mit der einfachsten Variante an und weist auf die Einschränkungen hin. In einem weiteren Teil kann man das dann ausbauen und verbessern.
Aber wenn jemand mit einem konkreten Problem kommt reicht auch erst mal nur die einfachere Version.

guntherb

Schlimmer finde ich die Verzögerungsfunktionen. Die sind Singletons. Das kracht gewaltig wenn man mehr als einen Automaten abarbeiten will. Sowas muß man als Instanzen anlegen und korrekt verwalten.
Gibt es denn irgendwo ein Beispiel, wie man das in OOP löst?
Bei mit ist das schon zu lange her, und ich habe keine Lust, mich komplett in OOP einzuarbeiten, nur eine "delay-Ersatzfunktion" in OOP schreiben zu können.
Grüße
Gunther

combie

#14
Jul 20, 2015, 12:58 pm Last Edit: Jul 20, 2015, 01:02 pm by combie
Nagut...
Obs dir hilft....


Hier mal der Code für einen Dimmer.
Inputs sind hier die analogen Pins, welche digital ausgewertet werden.
Taster über Pullups angeschlossen, also negative Logik

Code: [Select]


class Handler
{
  protected:
  static Handler* first;
  Handler* next = NULL;
  Handler()
  {
    if(first) next = first;
    first = this;
  }
 
  virtual void update() = 0;
 
  public:
  static void handle()
  {
      Handler* temp = first;
      while(temp)
      {
        temp->update();
        temp = temp->next;
      }
  }
};

Handler* Handler::first = NULL;

class Dim2Taster : public Handler
{
  protected:
  const byte upPin;
  const byte downPin;
  const byte pwmPin;
  int pwm;
  int dimDelay;
  unsigned long lastHit;
  void update()
  {
     if(millis() - lastHit > dimDelay)
     {
       int newPwm = pwm;
       if(!digitalRead(upPin))
       {
         newPwm++;
       }else if(!digitalRead(downPin))
       {
         newPwm--;
       }
       newPwm = constrain(newPwm,0,255);
       if(pwm != newPwm)
       {
         analogWrite(pwmPin,pwm=newPwm);
         lastHit = millis();
         Serial.print(pwmPin);
         Serial.print(" ");
         Serial.println(pwm);
       }
    }
  }

 
  public:
  Dim2Taster(int upPin, int downPin, int pwmPin, int dimDelay = 20) :upPin(upPin), downPin(downPin), pwmPin(pwmPin), pwm(0), dimDelay(dimDelay)
  {
    pinMode(upPin,INPUT_PULLUP);
    pinMode(downPin,INPUT_PULLUP);
    analogWrite(pwmPin,pwm=0);
    lastHit = millis();
  }
};



Dim2Taster LED1(A0,A1, 9);
Dim2Taster LED2(A2,A3,10);
Dim2Taster LED3(A4,A5,11);


void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Handler::handle();
}
Man sollte keine Dummheit zweimal begehen, die Auswahl ist schließlich groß genug.
Quelle: Jean-Paul Sartre

Go Up