Luftklappensteuerung für Gasbrenner

    Du willst eine Luftklappe auf 25%, 50%, 75%, und 100% vom Arduino gesteuert öffnen und den Zustand über LEDs anzeigen lassen. Dazu brauchst Du die Nockenschalter nicht. Der Arduino kann nach der Spannung am Analogeingang die LEDs mit ansteuern.

    Der Zusammenhang mit der SPS ist mir nicht klar, entweder steuert der Arduino die Klappe mit 5VDC oder die SPS mit einem 10VDC Analogeingang. Aus den 10VDC irgendwie mit einem Spannungsteiler die 5VDC für den Arduino zu gewinnen halte ich für kritisch. Wenn da ein Fehler auftritt wird der Arduino gegrillt.

    Die analoge Steuerung hat den Vorteil, dass Du bei der Brennereinstellung die Öffnung der Klappe einfach durch Anpassung der Zahlenwerte justieren kannst.

    Hast Du eine permanente Abgasmessung im Einsatz oder willst Du einfach die Brennerleistung regulieren?

    Wenn ich Schuhe und Strümpfe ausziehe, kann ich bis 20 zählen. ;)

    Zitat

    Meinst du jetzt damit ich muss in die [ANZAHL_NOCKEN] eine Zahl einfügen?

    NEIN. Bei constexpr byte ANZAHL_NOCKEN {2}; muss der Wert von 2 auf die gewünschte Anzahl Nocken geändert. Z.b. 4 also constexpr byte ANZAHL_NOCKEN {4};


    enum Nocken : byte {nocke1, nocke2}; kann auf enum Nocken : byte {nocke1, nocke2, steuernocke, schlussnocke}; geändert werden.


    Dann können weitere Nockendaten definiert werden:


    Code
    1. struct Nocke nocken[ANZAHL_NOCKEN] {
    2. {145,150,12,{2,3,4}}, // Init Struktur Nocke 1 mit unterer-, oberer Grenzwert, zugehörige Lese- und Led Pins
    3. {705,716,13,{5,6,7}}, // Init Struktur Nocke 2 mit unterer-, oberer Grenzwert, zugehörige Lese- und Led Pins
    4. {500,520,A0,{8,9,10}},
    5. {300,330,A1,{11,A2,A3}}
    6. };


    Auf die Werte von Nocke 3 kann dann mit nocken[steuernocke], auf die Werte von Nocke 4 mit nocken[schlussnocke] zugegriffen werden.


    Die Bezeichnungen "steuernocke" und "schlussnocke" habe ich mir jetzt mal ausgedacht, um noch einmal klarzumachen, wofür das enum Konstrukt verwendet wird.


    Wenn man beispielsweise ein Array mit Pinnummern hat leds[3] {7,9,1}; und an dem Pin 7 ist eine grüne, an Pin 9 eine gelbe und an Pin 1 eine blaue LED angeschlossen, kann man dank enum LedName : byte {gruen, gelb, blau}; mit Namen statt Zahlen arbeiten.


    Eine Anweisung wie digitalWrite{LedName::blau, HIGH}; ist im Programmverlauf wesentlich besser zu lesen und zu verstehen als digitalWrite(1,HIGH);. Man muss nicht mehr überlegen, welche LED an welchem Pin angeschlossen ist. Sollte sich mit der Zeit etwas an der Pinbelegung ändern, muss ausschließlich das Array angepasst werden. Ändert sich die Reihenfolge der LED Farben, passt man die entsprechende Enum Definition an. Sonst nichts! Analog ist das im vorliegenden Code für die Nocken und die in der Nockenstruktur deklarierten LedPins gemacht worden.


    Es geht immer darum, dass man bei Änderungen nicht den gesamten Code durchsuchen muss um direkt eingetragene Zahlen, die auf zig Anweisungen über den gesamten Code verstreut sind, ändern muss und dass Code lesbarer wird.



    Zitat

    Die andere Frage die sich mir stellt. Benötige ich für die Nocken noch einen PULLUP /PULLDOWN Befehl damit der eindeutig wird? Wiederstände sind keine mit verbaut an den Schaltern. Und wo würde man jetzt solche Funktionen bei dieser Schreib Art mit einbauen?


    Im Prinzip kannst Du das mache wie Du lustig bist. Wichtig ist, dass Du dir keinen Kurzschluss baust. Im Folgenden siehst Du anhand der Grafik wie Du was schalten kannst:


    pullup-pulldown.jpeg


    Da Du keine Widerstände verbaut hast, ist wohl "Grün" (S3) Deine Option. Allerdings musst Du dann den Code dahingehend ändern, dass der Pinmode für die readPins auf INPUT_PULLUP gesetzt wird und bei der Abfrage muss if (digitalRead(nk.readPin) == HIGH && (wert >= nk.untererGrenzwert && wert <= nk.obererGrenzwert)) { auf LOW statt auf HIGH abgefragt werden, weil, solange der Schalter nicht geschlossen ist, ein HIGH Signal am entsprechenden readPin anliegt.


    Weil Du in Deinem Beispielcode auf HIGH abgefragt hast, habe ich in der Simulation die Schalter halt so angeschlossen, dass ein HIGH Signal anliegt, wenn sie geschlossen werden.


    Aber nachdem du jetzt ja schon den Lötkolben schwingst und Pullups „einbaust“, ist der Käse ja eh gegessen….

    Dein Code macht nicht nur da gleiche was ich mir Gedacht hab, sondern er funktioniert auch noch.


    Meine Frage an der Stelle, du schreibst ich könnte jederzeit weitere Nocken einfügen durch ändern Wert ANZAHL_NOCKEN. Meinst du jetzt damit ich muss in die [ANZAHL_NOCKEN] eine Zahl einfügen? oder muss ich so wie ich das verstehen würde {Wert unten,Wert oben,Pin nocke,{ausgabe Pin,..} diese Liste erweitern?


    So weit ich das jetzt verstehe hab ich in dieser Auflistung alle Werte stehen die man benötigt. Hat sich erledigt hab ich gefunden.


    Die andere Frage die sich mir stellt. Benötige ich für die Nocken noch einen PULLUP /PULLDOWN Befehl damit der eindeutig wird? Wiederstände sind keine mit verbaut an den Schaltern. Und wo würde man jetzt solche Funktionen bei dieser Schreib Art mit einbauen?

    Danke KaiR für die Erläuterrungen. ich werde mich, damit dann nochmal auseinandersetzen, weil so ganz kapiert hab ich es noch nicht. Aber das leigt weniger an deiner Erklärung, sondern eher daran das ich das jetzt einfach mal einsetzen muss. Um zu sehen wann es in die Hose geht.

    @Pius:


    for (auto &nocke : nocken) {} enthält zwei "Spezialitäten".


    auto ist ein Schlüsselwort dafür, dass man die Typzuweisung zu einer Variablen dem Compiler überlässt.


    Man hätte auch for (struct Nocke &nocke : nocken) {} schreiben können. Das Konstrukt auto kann überall dort eingesetzt werden, wo eine Variable mit einem Ausdruck initialisiert wird. Der Compiler erkennt den Typ des Initialisierungsausdrucks und legt diesen Typ für eine Variable fest.


    Das "for" Konstrukt (bereichsbasierte for-Schleife) ist eine kurzschreibweise für

    Code
    1. for (auto it = begin(nocken); it != end(nocken); ++it) {
    2. auto wert = *it;
    3. […]
    4. }


    In C++ gibt es ja die Containerklassen (z.B. array, vetctor) die ihre eigene Größe kennen. Beim C++ des Arduino Frameworks ist das abgespeckt für Arrays in der Form implementiert, dass die Kurzschreibweise möglich ist.


    Leider nur, solange ein Array nicht als Funktionsparameter übergeben wird. In dem Fall ist ein Array dann auch nur noch, wie in C, ein Pointer ohne Größeninformation auf einen Datenbereich. Die Größe muss extra übergeben werden, oder man muss mit einem Template template <size_t MAX> arbeiten.


    Wird ein Template für eine Funktion  template <size_t MAX> void testNocke (struct Nocke (&)[MAX]) angelegt, wird die Arraygröße mitgeliefert:


    Vielen Dank Kai


    Das von Dir gelieferte Beispiel mit den Erläuterungen ist sehr hilfreich und hat auch mir, der auf einem Wissensstand von C++ seit 2010 sich kaum mehr weiter gebildet hat und im Mikrocontroller Umfeld immer eher auf C setzte, als auf C++. Zu dieser Zeit war constexpr noch nicht geboren.


    Auch das Statement:

    for (auto &nocke : nocken) {}


    scheint auch mit C++ 11 eingeführt worden zu sein und ist mir demnach (noch) nicht geläufig, nehme aber an, dass das «auto» an dieser Stelle eine Vereinfachung eines for() Schleife mitteilt und zum einen die Allokation eines Schleifenzählers, das Abbruchkriterium und auch die Anzahl der Durchläufe aus der Grösse der Tabelle nocke ermittelt wird.

    &nocke:nocken der Zeiger auf die Tabelle und dem anschliessenden Typen der Struktur

    nocke ist der Bezeichner des Schlaufenzählers, nocken der Inhalt des angegebenen Arrays, in diesem Beispiel zwei Strukturen nocken.

    Natürlich, ich muss dies selber nachlesen *g* Aber liege ich so in etwa richtig?

    Wenn dem so ist, dann erspart es einem die Schreibarbeit und beim Anlegen der Tabelle muss man sich jeweils nicht Gedanken darüber machen, den Compiler damit zu beauftragen, die Anzahl Einträge in der Tabelle bestimmen zu müssen. Damit werden einige Punkte, die gerne zu Fehlern führen, in einem Zug verhindert.


    Zu Deinem Kommentar in Post 23

    «Es ist mir ein Rätsel, warum auch in den Beispielen sehr häufig int verwendet wird. Ich habe noch keinen Controller mit mehr als 256 Pins gesehen. Schon gar keinen mit negativen Pin-Werten. Das soll aber erst mal nebensächlich sein, (int) stört die Funktion des Programmes nicht.»


    Per Definition ist ein int in der Grösse undefiniert und wird vom Compiler, abhängig von der Registergrösse der Ziel CPU, bestimmt.
    Nun passt dies aber bei einem Arduino mit einer 8-Bit CPU schon mal nicht zusammen, weil da nimmt der Compiler für int (wie Du korrekt geschrieben hast), 16 Bits. Ich weiss es nicht, vermute aber, dass man damit neuen Problemen ausweichen wollte, die man sich damit geschaffen hätte und definierte die 16Bit’s. Ich arbeitete mit C erst ab den 16 bit CPU’s (int war 16bit), dann mit den 32bit (int = 32bit) und heute sind es eben meist 64bit’s.


    Ich habe mir den Vortrag von Herb Sutter noch nicht ganz angehört, werde dies aber noch tun und vermutlich reicht einmal Anhören auch nicht.


    ich hoffe Du bleibst dem Forum noch lange treu, VIELEN DANK

    Pius

    Folgender Code macht das gleiche wie Dein Code aus #19 zu tun beabsichtigt, nur ist er wesentlich kürzer und vor allem sehr einfach erweiterbar.



    Die Werte habe ich aus Deinem Code übernommen. Allerdings sind sie falsch. Die Prozentwerte passen nicht zu den Kommentaren.


    Hier kannst Du gucken wie der Code arbeitet (https://wokwi.com/projects/349691761525785170). Da kannst Du herumspielen den Code auch ändern und für dich Abspeichern. Musst Dir nur die nach dem ersten Speichern neu erzeugte URL sichern. Die zwei Schiebeschalter simulieren die Nocken. Draufklicken schaltet die Nocken dann an (Schalterstellung links) oder aus (Schalterstellung rechts)...


    Anhand der Simulation wird klar, dass Du evtl. auf die LED OK verzichten kannst. Bei zwei LEDs pro Nocke wäre der Code:

    • keine LED brennt, der Wert passt
    • LedDown leuchtet, der Wert ist zu tief
    • LedUp leuchet, der Wert ist zu hoch

    Falls aus irgend einem Grund die Pins knapp werden sollten, wäre das auch noch eine Möglichkeit.

    Zitat


    Dieses Array hab ich noch nicht verstanden. Genau so wie deinen Programm Teil deshalb hab ich das nicht.


    Code so wie es oft gemacht wird, was aber uneffektiv ist:


    Und wie man es effektiver machen kann. Folgender Code ist mit obigem äquivalent:


    Was ist ein "Array" ? https://de.wikibooks.org/wiki/…ere_Grundelemente/_Felder


    Was ist ein "enum" ? https://de.wikibooks.org/wiki/…emente/_Aufz%C3%A4hlungen



    Oder mit einem mehrdimensionalen Array. Hier werden unterschiedliche Nocken definiert. Der Name für die drei LEDs kann aber bei allen vier Nocken identisch sein, weil der Index auf die entsprechende Nocke das Unterscheidungsmerkmal ist:



    Wenn Du dir die zwei Links mal in Ruhe anschaust und dann die Beispielcodes hier vergleichst, wird Dir die Funktionsweise von Arrays vielleicht klar.

    Ich hab die Schaltung bzw. den Aufbau jetzt im laufe des ganzen angepasst. und geändert das ist richtig.


    Am Anfang war ich noch euphorisch und wollte alle 4 Nockenschalter abfragen und mir ausgeben lassen wo diese stehen. Frei nach dem Motto was kosten schon 6 LED mehr.


    Im Verlauf hab ich dan feststellen müssen, das mich diese 6 LED einen haufen Code kosten. Den ich nicht brauche. Also weg damit.


    Dieses Array hab ich noch nicht verstanden. Genau so wie deinen Programm Teil deshalb hab ich das nicht.


    Da das mein erstes Projekt ist wollte ich es jetzt so einfach als möglich halten. Und das was ich da mit eurer Hilfe schreibe und verstanden haben. Blind zusammen kopieren ist das eine, das kapieren das andere.


    Den Poti teil hab ich seit dem er da drin ist und mal funktioniert hat nicht wieder angefasst. Da ich aber wenn das Ding mal fertig ist, diese ganze Serielle Ausgabe nicht mehr brauche. Werde ich da dann das ganze zusammen kürzen.


    Erstmal wollte ich wie gesagt das ganze Verstehen und zum laufen bekommen. Dann kann man ads ganze optimieren.



    Ich hoffe für das erste Mal ist es nicht zu Wirr geworden.

    Du widersprichst Dir permanent selber. Im ersten Code sind die Nocken noch an Analog-Pins geklemmt, im zweiten Code an Digitalpins, an denen vorher noch LEDs geschaltet waren.


    Im übrigen ist der Datentyp int für die Definition von Pin Konstanten überflüssig weil byte bzw. uint8_t ausreicht. Das verbraucht nur die Hälfte an Speicherplatz. Sämtliche Anweisungen wie digitalRead, digitalWrite, pinMode erwarten als Parameter einen Datentyp uint8_t (entspricht byte in der Arduino Welt) .


    Es ist mir ein Rätsel, warum auch in den Beispielen sehr häufig int verwendet wird. Ich habe noch keinen Controller mit mehr als 256 Pins gesehen. Schon gar keinen mit negativen Pin-Werten. Das soll aber erst mal nebensächlich sein, (int) stört die Funktion des Programmes nicht.


    Leider verwendest Du kein Array für die Pin Definitionen. Das bläst den Code auf und du hast zig Wiederholungen im Code.

    Mit Schleife und Array wäre z.B. nur eine einzige pinMode Anweisung in der setup() Funktion erforderlich.


    Evtl. wäre in Deinem Fall ein zweidimensionales Array (Nocken, dazugehörige LEDs) sinnvoll, oder ein Array mit einer struct pro Nocke inkl. der dazugehörigen Datenwerte. Das habe ich aber noch nicht so durchdacht.


    Du scheinst die map Anweisung aus irgend einem Grund in deinHerz geschlossen zu haben. Was soll map(val, 0,1023,0,0); bringen?


    Um ein vernünftiges Programm zu schreiben braucht man Ordnung, kein Durcheinander.


    Magic Numbers (siehe magische Zahlen in Code) sind sehr ungünstig und sorgen schnell für Fehler im Code..

    Also bei 145-150 muss der Nocken mit an sein. Drüber und drunter ist der nocken egal.


    Nachdem ich das 5er Posting dann noch zig mal durchgedacht hab, ist mir aufgefallen das die LED ja nur anzeigen wo das Poti steht wenn der Nocken geschalten hat.


    Sinniger ist das ich sehe ob es zu hoch oder zu nieder steht egal was der Nocken sagt.


    Daher diese Änderung Sorry.

    Zitat

    in meinem Kopf steht da , Wenn die Nocke AN ist UND der Poti Wert zwischen 145 und 150 liegt. Dann...


    wenn nicht ( der nocken gefragt wird) und der Poti wert nur unterhalb 144 liegt. Dann LED...


    wenn nicht ( der nocken gefragt wird) und der Poti wwert oberhalbt 151 liegt. DannLED...

    Was möchtest Du denn jetzt? In Posting fünf #5 steht noch etwas anderes.


    Willst Du jetzt, dass es bei Werten die NICHT zwischen 145 und 150 (sagen wir nicht im Toleranzbereich) liegen egal ist, ob die Nocke an oder aus ist, oder soll sie bei allen Werten (wie in #5 beschrieben) an sein?

    Aber wenn ich das so schreibe mit der Nocke..

    Warum wird dann nichts mehr ausgeführt


    in meinem Kopf steht da , Wenn die Nocke AN ist UND der Poti Wert zwischen 145 und 150 liegt. Dann...


    wenn nicht ( der nocken gefragt wird) und der Poti wert nur unterhalb 144 liegt. Dann LED...


    wenn nicht ( der nocken gefragt wird) und der Poti wwert oberhalbt 151 liegt. DannLED...

    const int LedOk = 2; //Grüne LED
    const int LedUp = 3; //Rote LED für zu niedrig
    const int LedDown = 4; //Rote LED für zu hoch

    const int LedOk2 = 5; //Grüne LED
    const int LedUp2 = 6; //Rote LED für zu niedrig
    const int LedDown2 = 7; //Rote LED für zu hoch

    const int Poti = A0; //Eingang vom Poti
    const int Nocke2 = 12; //Nockenschalter 2 Soll Wert 25% +-2%
    const int Nocke3 = 13; //Nockenschalter 3 Soll Wert 70% +-2%

    void setup() {
      Serial.begin(9600); //Ausgabe im Monitor
      pinMode(LedOk, OUTPUT); //Grüne LED Poti und Nockenschalter in der Richtigen Position
      pinMode(LedUp, OUTPUT); //Rote LED Nockenschalter kommt zu Früh
      pinMode(LedDown, OUTPUT); //Rote LED Nockenschalter kommt zu Spät
     
      pinMode(LedOk2, OUTPUT); //Grüne LED Poti und Nockenschalter in der Richtigen Position
      pinMode(LedUp2, OUTPUT); //Rote LED Nockenschalter kommt zu Früh
      pinMode(LedDown2, OUTPUT); //Rote LED Nockenschalter kommt zu Spät
     
      pinMode(Nocke2, INPUT);
      pinMode(Nocke3, INPUT);

    }

    int PotiWert() { //Poti Wert ermitteln und in Digital Auswerten
      static int oldVal = 0;
      int val = analogRead(Poti);
      if (val != oldVal) {
        int volt = map(val, 0, 1023, 0, 00);
        Serial.print(val);
        Serial.print(", ");
        Serial.print(volt / 100.0);
        Serial.println(" V");
    oldVal = val;
      }
      return oldVal;
    }

    void loop() {
          int value = PotiWert();
    if (digitalRead(Nocke2) == true && value <= 145 && value >= 150) { //Wenn der Poti Wert 20% erreicht +-2% und der Schalter 2 EIN ist
          digitalWrite(LedOk, HIGH); //Dann leuchtet die grüne LED
          digitalWrite(LedDown, LOW); //leuchtet die Rote LED Down nicht
          digitalWrite(LedUp, LOW); //leuchtet die Rode LED Up nicht
        }

    else if (value < 144) { //Ist das nicht der Fall und der Poti Wert unter 20% liegt
          digitalWrite(LedOk, LOW); //Dann leuchtet die grüne LED nicht
          digitalWrite(LedDown, HIGH); //leuchtet die Rote LED Down
          digitalWrite(LedUp, LOW); //leuchtet die Rote LED Up nicht
        }

    else if (value > 151) { //Ist das nicht der Fall und der Poti Wert über 20% liegt
          digitalWrite(LedOk, LOW); //Dann leuchtet die grüne LED nicht
          digitalWrite(LedDown, LOW); //leuchtet die Rote LED Down nicht
          digitalWrite(LedUp, HIGH); //leuchtet die Rote LED Up
        } 
    if (digitalRead(Nocke3) == true && value <= 705 && value >= 716) { //Wenn der Poti Wert 20% erreicht +-2% und der Schalter 2 EIN ist
          digitalWrite(LedOk2, HIGH); //Dann leuchtet die grüne LED
          digitalWrite(LedDown2, LOW); //leuchtet die Rote LED Down nicht
          digitalWrite(LedUp2, LOW); //leuchtet die Rode LED Up nicht
        }

    else if (value < 704) { //Ist das nicht der Fall und der Poti Wert unter 20% liegt
          digitalWrite(LedOk2, LOW); //Dann leuchtet die grüne LED nicht
          digitalWrite(LedDown2, HIGH); //leuchtet die Rote LED Down
          digitalWrite(LedUp2, LOW); //leuchtet die Rote LED Up nicht
        }

    else if (value > 717) { //Ist das nicht der Fall und der Poti Wert über 20% liegt
          digitalWrite(LedOk2, LOW); //Dann leuchtet die grüne LED nicht
          digitalWrite(LedDown2, LOW); //leuchtet die Rote LED Down nicht
          digitalWrite(LedUp2, HIGH); //leuchtet die Rote LED Up
        }
    }



    So hab ich mir das Gesamte Werk jetzt gerad mal zusammen Gedacht. Und hab wenn ich das jetzt nicht völlig falsch sehe eure Verbesserungen einfliesen lassen.

    Ja ich bin gerade etwas verwirrt.. ich versuche das mal eben nochmal in klar und deutlich zu Formulieren.

    Ich hab deinen Code nicht verwendet, weil ich den nicht Verstanden hab.


    Ok wie es scheint hab ich meinen eigenen nicht viel besser Verstanden. ( ich hab es zumindest geglaubt gehabt.. )

    Sorry, aber den Code durchschaue ich nicht.


    ein paar Hinweise:

    lösche Zeilen 25, 29, 33, 37 die sind alle doppelt gemoppelt


    Zeile 61 ist sicher falsch

    if (digitalRead(Nocke1) == HIGH, value <= 239 && value >= 284)

    ich vermute Du meinst

    if (digitalRead(Nocke1) == HIGH && value <= 239 && value >= 284)

    damit kommst Du aber kaum in den Block Zeile 66 weil value < 239 ist ja auch in der Zeile 61 bereits abgehandelt ausser Nocke1 ist FALSE


    Wenn Nocke1 FALSE ist passiert gar nichts. Dies kann zwar richtig sein, aber wenn zuvor Nocke1 HIGH war, dann wird nichst ausgeschaltet oder eingeschaltet.


    Ein Rat, folge der Logik im Kopf und schreibe diese in C so auf.

    Beispiel:


    // Wenn der Poti Wert 20% erreicht +-2% und der Schalter 2 EIN ist

    if (value <= 239 && value >= 284 && digitalRead(Nocke1) == HIGH ) {


    }

    Wenn nur Nocke1 FALSE ist wird kein Code mehr ausgeführt

    Vieleicht geht es leichter wenn Du die Logik am Anfang nicht verschachtelst:


    if(digitalRead(Nocke1) {


    if(value <= 239 && value >= 284 ) {

    ...

    }

    else {

    ...

    }


    }

    else {

    if(value <= 239 && value >= 284 ) {

    ...


    }

    else {

    ...


    }

    }


    Gruss

    Pius

    Das liegt daran, dass deine IF Bedingungen falsch sind. Der Verkettungsoperator "," hat in der Bedingung nicht s zu suchen. Außerdem ist der Bereich if (digitalRead(Nocke1) == HIGH, value <= 239 && value >= 284) falsch.


    if (value >= 239 && value <= 284) wäre passender.


    Deine Nockenabfrage bezieht sich nur auf das erste IF und nicht auf die ELSE Zweige.


    Ich verstehe nicht, warum du untenstehende Lösung nicht einfach übernommen hast. Die hat doch funktioniert.


    Außerdem würde ich Dir empfehlen ein Array für die Pin- Definitionen zu verwenden. Das lässt sich leicher in Funktionen verwenden.

    Ich hab das inzwischen mal zusammen gefummelt. Aber irgendwie funktioniert das nochnicht so wie es soll. Die Grüne LED kommt ( etwa zur richtigen Zeit) die Roten hingegen kommen erst die zu niedrig, und dann die zu hoch . UNd dann gehts auf Grün für richtige Position.


    Und der Nockenschalter ist der Schaltung egal.. Grün wird es immer egal ob der Schalter betätigt ist oder nicht.