Tastenentprellung +++ Fehlerhaft

[frabe]

Erst einmal möchte ich euch für eure Gedanken danken!

Da es sich scheinbar nicht um einen einfachen Logik/Flüchtigkeitsfehler handeln, wird es DER falsche Weg zu sein.
Mal wieder wollte ich duzende von Fliegen mit einer Funktion erschlagen - Tastenentprellung+Tasetendruck-Zeitmessung+beliebig viele Eingänge, etc.
Daher werde ich eine andere Linie verfolgen - einfacher, leicht nachvollziehbar. Ich melde mich später sobald ich einen akzeptableren Ansatz habe.

[Moppi]

Vielleicht fängst Du einfach an. Als Beispiel habe ich gestern schnell was zusammengebastelt. Ohne großen Plan, lang ist das Programm nicht. Ob es funktioniert habe ich nicht probiert, müsste aber.
Zumindest wird der Ansatz klar. Ausbauen kann man das im Nachhinein immer. Aber alles Stück um Stück, eins nach dem andern. Dann wird es mit der Fehlersuche einfacher.

//öffentliche Variablen
const int Pin = 9;
const int pDelay = 250;
int ButState;


//funktionsinterne Variablen
int pState = -1;
unsigned long pMillis = millis();


void setup(){
}
void loop(){
        checkButton();
}
void checkButton(){
        if (pMillis <= millis()) {
                ButState = pState;
                pInit();
        }else if (digitalRead(Pin) != pState) pInit();
}
void pInit(){
        pMillis = millis() + pDelay;
        pState = digitalRead(Pin);
}

Der Code enthält loop() und setup(), damit das mit der Arduino IDE einfach kompiliert werden kann. Den Code würde ich auch in ein Objekt in Methoden packen, dann kann man den später als LIB einfügen. Das macht das dann für zukünftige Projekte einfacher.


MfG

[frabe]

Jou, meine Lösung sieht folgend aus - DAS verstehe ich auch...

void loop() {
  AusgSekTakt(); // Sek.Takt-Anzeige

  static unsigned long TasteGedrueckt = 0; 
  static int TasteLiZustand = 0; 

  if(Entprell(TasteLiPin) == 1) {
    if(TasteLiZustand == 0) { 
      TasteLiZustand = 1;  
      TasteGedrueckt = millis();
    }
  TZ3("Taste gedrueckt+entprellt seit ", millis() - TasteGedrueckt, " ms"); 
  }
  else TasteLiZustand = 0;
}

//Tastenentprellung
int Entprell(int pin){
  static int TastenStatusNeu = 0; 
  static int TastenStatusAlt = 0;
  static unsigned long TastStartZeit = 0;
  
  TastenStatusNeu = digitalRead(pin);
  if(TastenStatusNeu != TastenStatusAlt) {
    TastenStatusAlt = TastenStatusNeu;
    if(TastenStatusNeu == 1) { 
      TastStartZeit = millis();
    }
  }
  if((millis() >= TastStartZeit + EntprellZeit) && TastenStatusNeu == 1)
    return 1;
  else
    return 0;
}

Frage:
1. Hat es irgend welche Vor/Nachteile, ob "TasteGedrueckt", "TasteLiZustand " als static- oder global-Variable deklariert werden? Ohne static funktioniert der loop nicht.
2. Seht ihr irgend wo einen Fehler oder code-Unsauberkeiten?


Meine nächsten Baustellen;
Schritt 01: Rückgabe von 5 Zustands-Peaks; 0=LOW, 1= HIGH, 2=Flanke steigend, 3=Flanke fallend, 5=unbekannt
Schritt 02: Beliebig viele Tasten/Schalteingänge, teils zeitgleich innerhalb von [ms], entprellen.

[Moppi]

Mal ne ganz ... Frage: warum steht "AusgSekTakt();" zusammen mit Variablendefinitionen UND dem eigentlichen Code alles in loop()?
Diesen Code kannst Du nie so in ein anderes Programm exportieren später - Probleme vorprogrammiert.
Es gibt so was wie einen Programmierstil. Ordnung ist hier die halbe Zeit, der Fehlersuche.



MfG

[frabe]

Mal ne ganz ... Frage: warum steht "AusgSekTakt();" zusammen mit Variablendefinitionen UND dem eigentlichen Code alles in loop()?

Hallo.
AusgSekTakt() ... ist eine Funktion, die sekündlich tickt+leuchtet und eine Sekundenanzeige im Seriellen Monitor anzeigt - ursprünglich mal als Test-bimbam.
die static Var. im loop() sind zur schnelleren Übersicht (da wo sie gebraucht werden), als in glob.Var.-Bereich ganz oben im Haeder.
Stilbruch?
Wie gehts besser?

[Moppi]

Ich denke mal, wissen tu ich es ja nicht, dass Du diese Geschichte später woanders einsetzen willst, sprich, das muss alles ausgelagert werden, dass es später eingebunden werden kann. Da fängt man wohl mit einem Programmgerüst dafür an, würde ich jetzt so machen. Ich mache ein Beispiel. Dauert etwas ...

Programmierst Du auch mit Arduino IDE ?

MfG

- - - Aktualisiert - - -

Es gibt bei Klassen Methoden und Varibalen, die nach außen nutzbar sein sollen und damit "sichtbar" sind, also aufgerufen werden können und es gibt das Gegenteil, Methoden und Variablen, die nur innerhalb der Klasse verwendet werden und damit "privat" sind, also nicht nach außen sichtbar.

Folgende Dateien könnten im Verzeichnis "libraries" im Arduino-Ordner gespeichert werden (dann dort Verzeichnis "MeinCode" und darin beide Dateien, *.h und *.cpp), damit sie in anderem Arduino-Code eingebunden werden können.


Beispiel für "MeinCode.h"

#ifndef MeinCode_h


#define MeinCode_h
#include <Arduino.h>


class MeinCode    //Klasse "MeinCode"
{
  //Alle öffentlichen Variablen und Methoden hier bekanntgeben
  public:
    byte val1, val2;                     //Variablen
    MeinCode(unsigned long bps);  //Methode "MeinCode" - Hauptkonstruktor ... wird beim Instanziieren automatisch mit der Klasse aufgerufen
    boolean SendRequest(void);    //Methode von "MeinCode"
    
  //alle nicht öffentlichen Variablen und Methoden hier bekanntgeben
  private:
    void    ClearRBuffer(void);     //Methode
    boolean get2Chars(void);       //Methode
    int a;                                 //Variable
    unsigned long lastMillis;        //Variable
    byte tv1, tv2;                      //Variablen
};


#endif

Beispiel für "MeinCode.cpp"

#include <Arduino.h>
#include <MeinCode.h>

//-----------------------------------------------------
//Hauptkonstruktor
//-----------------------------------------------------
MeinCode::MeinCode(unsigned long bps)

{
   .....
}
//-----------------------------------------------------
boolean MeinCode::SendRequest(void)
{
  ClearRBuffer();
  ....
  return ...;
}
//-----------------------------------------------------
void MeinCode::ClearRBuffer(void)
{
  ....
}
//-----------------------------------------------------
boolean MeinCode::get2Chars(void)
{
   ....
   return ....;
}

Eingebunden und verwendet wird das später, dann z.B. so.

#include <MeinCode.h>


MeinCode meineInstanz();   //Hauptkonstruktor aufrufen, Instanz erzeugen (initialisieren von irgendwas im Code der Klasse "MeinCode")


void setup() {


}


void loop() { 


    //Methoden (Funktionen) der Klasse "MeinCode" können über meine Instanz angesprochen werden
    if(meineInstanz.SendRequest()){
       . ...
    }

    //Variablen können wie Methoden meiner Instanz angesprochen werden
   Serial.print(meineInstanz.val1);


}

Für mehr Informationen siehe hier z.B. (da gibts noch zahlreiche andere Links im Netz) http://www.mintgruen.tu-berlin.de/ro...n:objektorient



MfG

[frabe]

GM Moppi.
Vielen Dank für deine Ausführungen!

Tatsächlich beschäftige ich mir hier erst einmal mit Grundlagen, wie Kontaktentprellungen, Mittelwerte, Analogein-/ausgänge, etc.
Diese werde ich dann in universelle und "griffige" Funktionen stecken, um sie dann später in diversen Programmen nach belieben zu verwenden.
Hierbei hatte ich daran gedacht, die Funktionen irgend wie in eine Bibliothek zu fassen um via Copy/Paste die Funktionen einzubinden.
Die von dir beschriebene Methode klingt da irgendwie "flexibler" und professioneller...
Aber erst wenn die Funktionen super stabil laufen - dauert bei mir also noch etwas.

Ja, ich programmiere den Teensy 3.2 über Arduino 1.8.5/Teensyduino 1.47.