Ein einfacher Code-Schnipsel für eine FlipFlop-Schaltung mit Hold-Funktion

Hi, ich wollte hier mal einen Code-Schnipsel für Anfänger hinterlassen, da ich bei der Suche nach "Arduino FlipFlop" nichts einfaches für Anfänger(inkl. mir) finden konnte habe ich diesen hier geschrieben und möchte es mit der Allgemeinheit teilen.

Kurz zu mir da ich hier neu bin: ... ich bin voll in Ordnung und komm jetzt öfter! ;-)

--> Ich bin brandneu in der Arduino-Welt, aber als Webentwickler(PHP, ähnlich C++) konnte ich mich auf Anhieb gut in der Entwicklungsumgebung zurechtfinden und hoffe auf eine gute und lehrreiche Zeit mit meinen verschiedenen Arduino's. Ich habe kein konkretes Ziel oder Projekt, ich möchte einfach zum Hobby meine Programmiererfahrung stärker in die Hardware-Welt bringen und dabei viel lernen.

Das hier ist eine FlipFlop-Schaltung mit einer Hold-Funktion:

  if (taster == HIGH) {
    if (status == 0) {
      if (flipflopposition == 0) {
        flipflopposition = 1;
        status = 1;
      } else {
        flipflopposition = 0;
        status = 1;
      }
    } ++holdzaehler;
    if (holdzaehler > 100) {
      holdfunktion = 0;
      status = 1;
    }
  } else {
    status = 0;
    holdzaehler = 0;
  }

... dieser Code schaltet nicht nur um! Wenn mann den Taster länger als ca. 1,5sek. hält, wird die Funktion "holdfunktion = 0;" ausgeführt.

Hier nochmal der Code OHNE Holdfunktion:

  if (taster == HIGH) {
    if (status == 0) {
      if (flipflopposition == 0) {
        flipflopposition = 1;
        status = 1;
      } else {
        flipflopposition = 0;
        status = 1;
      }
    } 
  } else {
    status = 0;
  }

Hi Herzlich willkommen hier!

Ich habe versucht deine Konstruktion zu verstehen.

Ist nicht ganz leicht.... z.B. kann ich gar nicht erkennen, wie die 1,5 Sekunden zustande kommen sollen...

Auch haben alle FlipFlop, welche ich kenne, eindeutigen Ein- und Ausgänge. Das vermisse ich hier etwas.

Hab's nur mal überflogen - sieht mir nach Toggle-Funktion mit einem Taster aus.

Der Ansatz, solche Schnipsel hier zu zeigen ist löblich, aber für Anfänger sollte dann noch ein wenig mehr dazu.

Deklaration der Variablen z.B. oder noch besser ein kompletter Sketch, der die Funktion komplett zeigt. Wie halt bei den IDE-Beispielen. Das hilft anderen Anfängern sicher besser weiter als nur ein Schnipsel.

Und natürlich: willkommen im Forum!

Ich weiß nicht, was ein "Flip-Flop mit Hold-Funktion" sein soll. Meinst Du ein Monoflop (monostabiler Multivibrator)?

Ein FlipFlop schaltet man normalerweise ganz einfach um mit

 FlipFlop = !FlipFlop;

Hi, vielen Dank für das Herzliche Willkommen. :slight_smile:

Ich hab jetzt einen komplett funktionstüchtigen Spiel- und Test-Skript zusammen gebastelt und kommentiert.

Das ist noch nötig:

  • Dein verwendetes LCD einrichten inkl. Library falls nötig
  • Einen EnCoder positiv geschaltet anschließen

Noch ein Hinweis zum EnCoder.
Ich habe das EnCoder-Modul von V-Keyes und das ist negativ geschaltet und bei mir fehlten bei beiden (ich habe 2) die 10K-Widerstände um den Taster auf LOW zu ziehen. Diese habe ich einfach nachgelötet.
–>Um dieses Modul auf positiv zu wechseln kann man einfach entgegen der Bedruckung, “+” und “GND” vertauschen.

Jetzt zum Skript:

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int enpressPin = 7;       //Pin für den Taster im EnCoder
int enturn1Pin = 10;      //PinA am EnCoder ... es kann möglich sein, dass man diese Pins vertauschen muss
int enturn2Pin = 8;       //PinB am EnCoder ... falls sich der Wert beim links drehen erhöht
int enpress = LOW;
int enturn1 = LOW;
int enturn2 = LOW;
int encount = 0;
int enstate = 0;
int enflag = 0;
int enscale = 1;
int enpushstate = 0;
int enpushcounter = 0;


void setup() {

  lcd.begin(20, 4);

  pinMode(enpressPin, INPUT);
  pinMode(enturn1Pin, INPUT);
  pinMode(enturn2Pin, INPUT);

}

void loop() {
  enpress = digitalRead(enpressPin);
  enturn1 = digitalRead(enturn1Pin);
  enturn2 = digitalRead(enturn2Pin);

 
  if (enpress == HIGH) {         //AB HIER FlipFlop-Schaltung - - - 
    if (enpushstate == 0) {      //diese Abfrage verhindert ein hin und her springen
      if (enscale == 1) {
        enscale = 10;
        enpushstate = 1;
      } else {
        enscale = 1;
        enpushstate = 1;
      }                           //BIS HIER FlipFlop-Schaltung - - -
    } ++enpushcounter;            //AB HIER Hold-Funktion (Taste lange drücken) * * *
    if (enpushcounter == 100) {   //wenn der Zähler 100 erreicht (bei mir ca. 1,5 sek.)
      if (enscale == 1) {         //diese if-Anweisung stellt den vorherigen Wert nach der Hold-Funktion wieder her
        enscale = 10;              //dieser Wert verändert die Auflösung des EnCoder 0=x1 1=x10
      } else {
        enscale = 1;
      } encount = 0; 
      enpushstate = 1;
    }                              //BIS HIER Hold-Funktion (Taste lange drücken) * * *
  } else {
    enpushstate = 0;               //Zurücksetzen der Werte für, das verhindern des hin und her springen
    enpushcounter = 0;             //und der Zähler für die Hold-Funktion
  }

                                                                //VON HIER Auswertung EnCoder # # #
  if (enpress == LOW) {                                         //Diese Abfrage verhindert ein versehentliches Drehen beim drücken des EnCoders (Taste)
    if (enturn1 == HIGH && enturn2 == HIGH) {
      enstate = 1;
    }
    if (enturn1 == LOW && enturn2 == LOW) {
      enstate = 0;
    }

    if (enstate == 1 && enturn1 == LOW ) {
      enflag = 3;
    }
    if (enstate == 1 && enturn2 == LOW ) {
      enflag = 4;
    }
    if (enstate == 0 && enturn1 == HIGH ) {
      enflag = 3;
    }
    if (enstate == 0 && enturn2 == HIGH ) {
      enflag = 4;
    }

    if (enturn1 == HIGH && enturn2 == HIGH && enflag == 4) {
      encount = encount + enscale;
      enflag = 0;
    }
    if (enturn1 == HIGH && enturn2 == HIGH && enflag == 3) {
      encount = encount - enscale;
      enflag = 0;
    }
    if (enturn1 == LOW && enturn2 == LOW  && enflag == 4) {
      encount = encount + enscale;
      enflag = 0;
    }
    if (enturn1 == LOW && enturn2 == LOW  && enflag == 3) {
      encount = encount - enscale;
      enflag = 0;
    }
  }                                                             //BIS HIER Auswertung EnCoder # # #

  lcd.setCursor(5, 0);          //AB HIER Testwerte ausgeben + + +
  lcd.print(encount);
  lcd.write("      ");          //Diese angehängten Leerzeichen verhindern dass alte Anzeigen stehen bleiben
  lcd.setCursor(5, 1);
  lcd.print(enscale);           //So sieht die Anzeige zu Beginn aus
  lcd.print("///");             // |    0              | Dieser Wert wird über den EnCoder hoch oder runter gedreht
  lcd.print(enpress);           // |    1///0///0      | 1.Wert=Multiplikator (1 / 10) /// 2.Wert=EnCoder-Taste gedrückt (0=LOW / 1=HIGH) /// 3.Wert=Zähler bei gedrückter Taste
  lcd.print("///");
  lcd.print(enpushcounter);
  lcd.write("      ");          //BIS HIER Testwerte ausgeben + + +
}

Es wäre interessant zu wissen, was Dein Code machen soll, und warum Du ihn hier vorstellst.

Hi, einfach nur als Hilfestellung für Anfänger usw. ...

Wie ganz oben beschrieben bin ich ganz neu in der Arduino-Welt und experimentiere im Moment sehr viel ;-) Als ich meine EnCoder-Module bekommen habe wollte ich damit etwas anfangen, habe das Funktionsprizip untersucht und bin auf Skriptsuche gegangen aber nichts zufriedenstellendes gefunden.

Jeden EnCoder-Skript den ich finden konnte hatte zur Folge, das nur zu jeder zweiten Raste ein Wert erhöht wurde ... ALSO frisch ans Werk und einen eigenen für mich funktionierenden Skript geschrieben. Keine Ahnung was ich mit den anderen Skripten falsch gemacht habe ... evtl. liegt es auch an meinen EnCodern?!?!

... so nun lief der Encoder und ich dachte wie coll währe es wenn ich per FlipFlop die Auflösung verändern kann. Also jede Raste Wert+1 Taster einmal drücken und jede Raste Wert+10 und wieder zurück ...

Und dann war der Ball am rollen ... was könnte man noch machen?! Den Wert resetten über lange(Hold) gedrückt halten.

DER PROGRAMMABLAUF:

  1. Start mit dem Multiplikator 1 (enscale).

  2. Wird der EnCoder gedreht, wird ein Wert(encount) um 1 hoch bzw. runter gezählt.

  3. Wird auf den EnCoder-Taster gedrückt, schaltet der Multiplikator(enscale) von 1 auf 10.

  4. Wird der EnCoder gedreht wird ein Wert(encount) um 10 hoch bzw. runter gezählt.

  5. Wird auf den EnCoder-Taster gedrückt, schaltet der Multiplikator(enscale) wieder von 10 auf 1 usw..

  6. Hält man den EnCoder-Taster länger 1,5 sek. gedrückt(enpushcounter zählt bis 100), wird der Zähler(encount) auf null gesetzt und der vorherige Zustand des Multiplikators(enscale) wiederhergestellt.

    enscale=1 >> Taste drücken und halten, enscale=10 >> Timer(enpushcounter) läuft bis 100 >> encount=0 und wieder enscale=1

!!! Des weiteren wird solange der EnCoder-Taster gedrückt wird, die Lese-Funktion für den Dreh-EnCoder deaktiviert damit man keine Fehleingaben beim drücken macht !!!