Tastenentprellung +++ Fehlerhaft

[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.

[Moppi]

Ich verstehe Deine Einwände und kann das nachvollziehen. Kann Dir aber aus Erfahrung sagen, dass das nachträgliche Umstricken von Code, in eine andere Form u.U. nicht ganz trivial ist. Ich habe Deinen Code gesehen und Dir einen Vorschlag unterbreitet, der eigentlich eine super Sache ist. Weil Du brauchst irgendein Programmgerüst - setup() + loop() ist keines in dem Sinn. Du musst den Code in eine gescheite Form bringen, damit der gut wartbar ist und weiterzuverwenden. Und damit man gut durchblickt. War eigentlich nur als Abkürzung für Dich gedacht. Aber Du kannst das machen, wie Du möchtest. Erfahrung muss man selber sammeln. Kann Dir nur einen Rat noch mit auf den Weg geben: wenn Du den Code aufbaust, probiere ihn aus, immer und immer wieder, ob er funktioniert. So erkennst Du frühzeitig, wenn etwas nicht funktioniert und kannst stark einkreisen, in welchem Programmabschnitt sich ein Problem befindet. Übung macht hier den Meister, im wahrsten Sinn des Wortes. Zahlreiche Verstrickungen, um Ecken (Variablen in einer Funktion definieren, dann aber als statisch, um am Ende dann über Zeiger/Verweise die Variable an weitere Funktionen zu übergeben, usw.) macht es nicht gerade einfacher einen Fehler zu finden, auch wenn der Code nicht so groß ist. Deswegen bin ich auch kein großer Anhänger von Kompilerdirektiven.

Freundlichen Gruß

[frabe]

...Kompilerdirektiven

Habe ich die benutzt?

Du hast vollkommen Recht - werde ich auch machen, brauche aber noch allgemeingültige/universelle Vereinbarungen für mich selber.
Z.B. bin ich mir nicht sicher, ob die Entprellzeit im den Globalvariablen-Bereich

const int EntprellZeit = 30;   // [ms], Entprellzeit (typ.Prellzeit 0,1-30ms)

oder besser (kontrollierter, leserlicher) in der Funktion Entprell() aufgehoben ist

static int EntprellZeit = 30;   // [ms], Entprellzeit (typ.Prellzeit 0,1-30ms)

Mit meinem derzeitigen code bin ich schon sehr zufrieden - gibt 3 Zustände zurück - 0..LOW, 1...HIGH, 2...in Entprellung

//==========MAIN==========//
void loop() {
  static int AusgImpuls = 0;                // Ausg-AusgImpuls [ms]
  AusgTakt(AusgImpuls, 1000);               // Taktdauer [ms], Intervall [ms]
  
  static int TasteLiZustand = 0;            // akt. Zustand 0/1 der Taste

  if(Entprell(TasteLiPin) == 1) {           // sobald Taste HIGH und entprellt
    AusgImpuls = 900;                       // Ausg-AusgImpuls bei Taste HIGH
    TasteLiZustand = 1;                     // speichert das Taste "1" ist
  }
  else if(Entprell(TasteLiPin) == 0) {      // sobald Taste LOW und entprellt
    AusgImpuls = 10;                        // Ausg-AusgImpuls bei Taste LOW
    TasteLiZustand = 0;                     // speichert das Taste LOW ist
  }
  else
    TZ("Medlung: Kontakt derzeit in Entprellung");
}

//----------STANDARD-FUNKTIONEN----------//
//Kontaktentprellung durchführen, Zustand zurück geben
//Rückgabe 3 Zustände; "0"...LOW+Kontakt entprellt / "1"...HIGH+Kontakt entprellt / "2"...Zustand unbekannt, in Entprellung 
int Entprell(int Pin) { 
  static int KontaktStatusNeu = 0;              // akt.Zustand
  static int KontaktStatusAlt = 0;              // vorheriger Zustand
  static unsigned long KontaktStartZeit = 0;    // Startzeit der ersten Kontaktzustandsänderung

  KontaktStatusNeu = digitalRead(Pin);          // speichert akt. Kontaktzustand
  if(KontaktStatusNeu != KontaktStatusAlt) {    // wenn sich Kontaktzustand ändert
    KontaktStartZeit = millis();                // speichert aktualisierte Startzeit
    KontaktStatusAlt = KontaktStatusNeu;        // geänderter Zustand gespeichert
  }
  if(KontaktStatusNeu == 0 && (millis() >= KontaktStartZeit + EntprellZeit)) // wenn Entprellzeit überschritten und Kontakt LOW
    return 0;                                   // "0" zuück, Kontakt LOW und entprellt
  else
    if(KontaktStatusNeu == 1 && (millis() >= KontaktStartZeit + EntprellZeit)) // wenn Entprellzeit überschritten und Kontakt HIGH
      return 1;                                 // "1" zurück, Kontakt HIGH und entprellt
  else
    return 2;                                   // "2" zurück, noch nicht entpellt, Kontaktzustand unbekannt
}

Fehlt nur noch, dass mehrer Taster/Kontakt gleichzeitig entprellt werden können.
Danach werde ich die Zustands- und Entprellgeschichte in eine Bibliothek (*.h, *.cpp) einrichten.

- - - Aktualisiert - - -

...ETWAS SPÄTER:

Habe derzeit das Problem, dass innerhalb einer Entprellphase, keine andere Entprellung erfolge kann.
Solang eine Entprellung läuft, werden alle anderen Kontakte/Tasten "verschluckt".
Ursache ist, dass die Funktion Entprellung() eine Startzeit speichert und diese berechnet.

Können diese 30ms-Überlappungen in der Praxis vernachlässigt werden?
Oder sollte/muss ich für jede Taste/Kontakt eine eigene Funktion vorhalten, in der die Entprell-Startzeit gespeichert wird?