Arduino Forum

International => Deutsch => Topic started by: 4711 on Jun 15, 2019, 06:38 pm

Title: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 15, 2019, 06:38 pm
Hallo Gemeinde,

mich beschäftigt gerade das verhindern von Signalflattern. D.h. ein Näherungsschalter schaltet unkontrolliert.

Ich möchte den Eingang mit einem Delay belegen, was ein und aus betrifft.

100ms ein = ein, 100ms aus = aus, Schaltzustände dazwischen ignorieren.

Geht das nur über milis() oder gibt es einen einfacheren Weg?

Danke! BG
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: ElEspanol on Jun 15, 2019, 06:43 pm
nein. geht am einfachsten mit millis
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: agmue on Jun 15, 2019, 07:26 pm
Geht das nur über milis() oder gibt es einen einfacheren Weg?
Ein Beispiel in diesem Thema (https://forum.arduino.cc/index.php?topic=615447.msg4171475#msg4171475) am Anfang von loop().
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: michael_x on Jun 15, 2019, 09:34 pm
Wenn es sonst keine Gründe gibt,  warum loop() schneller als alle paar ms sein sollte, kannst du auch mit delay(5) einfach entprellen.
Quote
ein Näherungsschalter schaltet unkontrolliert
Evtl. auch eher ein Fall für eine Hysterese. Hängt wohl auch von deinem "unkontrolliert" ab.
Wenn du wirklich rauskriegen willst,  dass ein Signal x msec unverändert bleibt, ist
if (millis()-prev > x)
das einfachste.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 15, 2019, 09:37 pm
Quote
Geht das nur über milis()
Ja, oder eine beliebige andere Zeitbasis.

Quote
oder gibt es einen einfacheren Weg?
Das ist ein einfacher Weg.
Der einfachste.

Gib übrigens einige Libs, welche sowas abhandeln.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 16, 2019, 10:59 am
OK, danke für euren Input!!

Welche Libs wären das?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 16, 2019, 11:40 am
Welche Libs wären das?
z.B. meine
Hier mal ein Entprellbeispiel mit 20ms Zeitfenster. (https://forum.arduino.cc/index.php?topic=542332.msg3716132#msg3716132)

Für andere Libs mache ich keine Werbung.

Aber du kannst ja selber suchen, denn du bist ja nicht der/die/das Erste mit einem solchen Problem.
Suchtipp: "Arduino debounce"
Oder: "Arduino entprellen"
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: noiasca on Jun 16, 2019, 12:07 pm
oder ohne Library, einfach gem. Beispiel in der IDE:

02 Digital | Debounce


Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 16, 2019, 05:29 pm
Danke für die Infos, aber mit höherer Programmiersprache stehe ich auf Kriegsfuß.
D.h. das Beispiel kann ich nicht lesen.

was nun "02 Digital | Debounce" bedeutet, erschließt sich mir auch nicht ??

Debounce und Google bringen mich zu https://github.com/thomasfredericks/Bounce2/wiki
mal sehen ob ich das kapiere.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Tommy56 on Jun 16, 2019, 05:36 pm
was nun "02 Digital | Debounce" bedeutet, erschließt sich mir auch nicht ??
Einfach komplett lesen und durchklicken.

In der IDE: File/Datei --> Examples/Beispiele --> 02. Digital --> Debounce

Gruß Tommy
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: noiasca on Jun 16, 2019, 06:03 pm
In der IDE: File/Datei --> Examples/Beispiele --> 02. Digital --> Debounce
Gefunden?
Verstanden?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 16, 2019, 06:06 pm
Quote
Danke für die Infos, aber mit höherer Programmiersprache stehe ich auf Kriegsfuß.
Es ist die Sprache, in der du deine Programme sowieso schon schreibst.
C++
OK, ein anderer Blickwinkel, aber doch die gleiche Sprache.


Quote
D.h. das Beispiel kann ich nicht lesen.
Das könntest du ändern.
Wenn du denn willst.
Würde dir einiges erleichtern, viele Türen öffnen.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 16, 2019, 06:39 pm
OK, kapiert was ihr meint, muss ich mir dann ansehen!

Viele Türen, ja, aber.... ich komm mit dem was ich will nicht weiter, außer wieder viele Türen und die damit verbundene Zeit zu öffnen. Solange ich mit den Basics auskommen kann, soll es dabei sein. Wenn ich Zeit finde, kann ich die nächste Türe öffen, aber in meiner mom. Situation wäre zuviel einfach zu viel.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Tommy56 on Jun 16, 2019, 07:10 pm
Wenn ich Zeit finde, kann ich die nächste Türe öffen, aber in meiner mom. Situation wäre zuviel einfach zu viel.
Das kann auch bedeuten: Erst mit der nächsten (oder weiteren) Tür(en) kannst Du Dein Problem lösen.

Gruß Tommy
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 16, 2019, 07:21 pm
Schon klar.

Ich habe mir das Debounce Beispiel angesehen, viel Code. Da komme ich mit meiner Maschine wohl schon in Speicherprobleme, jetzt schon 25% verbraucht und das nur mit dem Referenzieren... k.A. ob das noch zu einem Problem wird.
Bei mehreren Eingängen wohl als Array zu programmieren. Da fehlt mir noch das Wissen, das fehlerfrei umzusetzen.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Tommy56 on Jun 16, 2019, 07:27 pm
Bei mehreren Eingängen wohl als Array zu programmieren. Da fehlt mir noch das Wissen, das fehlerfrei umzusetzen.
Da hilft nur lernen, aber nicht alles auf einmal, sondern schrittweise. Erst mal einen Sensor sauber verarbeiten.

Gruß Tommy
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: ElEspanol on Jun 16, 2019, 08:35 pm
Aber das eigentliche Problem besteht noch?
Du wolltest doch einen Eingang einlesen, an dem das Signal jeweils länger als 100ms durchgehend angelegen sein muss, bevor du die entsprechende bool variable änderst?

Oder hat sich da mit den vielen Türen die Problemstellung geändert?

Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 17, 2019, 12:59 pm
Nein, das Problem besteht noch, verschwindet leider nicht von selbst.
Nur mit C++ kann ich jetzt nicht anfangen und die Bounced Beispiele kann ich akt. nicht umsetzen, da fehlt mir noch zuviel Knowhow.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 17, 2019, 01:11 pm
Nein, das Problem besteht noch, verschwindet leider nicht von selbst.
Nur mit C++ kann ich jetzt nicht anfangen und die Bounced Beispiele kann ich akt. nicht umsetzen, da fehlt mir noch zuviel Knowhow.
Das ist eine unangenehme Zwickmühle....

Wie kann ich dir helfen diesem Teufelskreis zu entrinnen?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 17, 2019, 01:30 pm
Helfen würde mir ein Beispiel, dass in standard Arduino Sprache (ich weiß, klingt blöd) geschrieben wurde und einfach einen (oder mehrere) Eingänge entprellt. Unabhängig von Schalter und LED usw. und eff.(weniger Speicher braucht) und sauber programmiert ist.
:)
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Tommy56 on Jun 17, 2019, 01:32 pm
Na das Beispiel in der IDE wurde Dir doch bereits mehrfach genannt. Noch einfacher geht es nicht.

Gruß Tommy
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: HotSystems on Jun 17, 2019, 02:06 pm
Helfen würde mir ein Beispiel, dass in standard Arduino Sprache (ich weiß, klingt blöd) geschrieben wurde und einfach einen (oder mehrere) Eingänge entprellt. Unabhängig von Schalter und LED usw. und eff.(weniger Speicher braucht) und sauber programmiert ist.
:)
Was nützt dir ein Beispiel, das in C++ (Standard Arduino Sprache) geschrieben ist, wenn du es nicht verstehst.
Du solltest einfach mal die vorhandenen Beispiele verwenden und damit üben, dann lernst du auch daran.

Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 17, 2019, 02:22 pm
Helfen würde mir ein Beispiel, dass in standard Arduino Sprache (ich weiß, klingt blöd) geschrieben wurde und einfach einen (oder mehrere) Eingänge entprellt. Unabhängig von Schalter und LED usw. und eff.(weniger Speicher braucht) und sauber programmiert ist.
:)
Ja, das klingt etwas blöd.... (sorry)
Denn die "standard Arduino Sprache" ist C++.

Und alle bisher gezeigten Beispiel sind in C++.
Auch wohl alle im Internet findbaren.
Selbst die in Büchern und Köpfen versteckten.

Ich sehe nur einen Weg dir zu helfen: Eine Buchempfehlung (http://www.cppbuch.de/)

Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 17, 2019, 03:14 pm
so, hier mal mein erster Entwurf, hab ihn noch nicht getestet
Code: [Select]
// DEBOUNCE ------------------------------------------
  unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
  unsigned long debounceDelay = 50;    // the debounce time; increase if the output flickers
  unsigned int iSensor1State;          // aktueller Zustand vom Eingang
  unsigned int ilastSensor1State = LOW; // letzter Zustand vom Eingang

void Debounce() {
  int ireadingSensor1 = digitalRead(I_Sensor1);
  if (ireadingSensor1 != ilastSensor1State) {
    lastDebounceTime = millis();
  }
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (ireadingSensor1 != iSensor1State) {
      bSensor1 = ireadingSensor1;
      if (iSensor1State == HIGH) {
        bSensor1 = !bSensor1;
      }
    }
  }
  ilastSensor1State = ireadingSensor1;
}

Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: ElEspanol on Jun 17, 2019, 03:57 pm
Dann teste mal. wenn du einen lauffähigen Sketch hast, der kompiliert, kannst du ihn mal posten
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: postmaster-ino on Jun 17, 2019, 11:22 pm
Code: [Select]

/*
 * Der Sketch verwendet 1874 Bytes (5%) des Programmspeicherplatzes. Das Maximum sind 32256 Bytes.
 * Globale Variablen verwenden 232 Bytes (11%) des dynamischen Speichers, 1816 Bytes für lokale Variablen verbleiben. Das Maximum sind 2048 Bytes.
 *
 * Kompiliert ohne Warnungen auf Uno/Nano
 *
 * Sensoren entprellen, Forenbeitrag
 * https://forum.arduino.cc/index.php?topic=621568.msg4213625#msg4213625
 */

typedef struct {
  byte pin;                     //Pin des Sensor
  uint32_t prellzeit;       //wie lange soll auf ein gültiges Signal gewartet werden?
  uint32_t lastseen;       //wann wurde der letzte Zustand eingelesen
  boolean lastread;        //HIGH oder LOW
  boolean state;            //'sicherer' Zustand HIGH/LOW
} SENSOR;

SENSOR mySensor[] {
  {2, 50, 0, 0, 0},
  {3, 20, 0, 0, 0},
  {5, 50, 0, 0, 0},
  {A0, 10, 0, 0, 0}, //das letzte Komma stört nicht
};
const byte anzahlSensoren = sizeof(mySensor) / sizeof(mySensor[0]);

void setup() {
  for (byte t = 0; t < anzahlSensoren; t++) {
    pinMode(mySensor[t].pin, INPUT_PULLUP);
  }
}

void loop() {
  for (byte t = 0; t < anzahlSensoren; t++) {
    boolean zustand = digitalRead(mySensor[t].pin);
    if (zustand != mySensor[t].lastread) {
      //Zustand hat sich geändert
      mySensor[t].lastread = zustand;
      mySensor[t].lastseen = millis();
    } else {
      //der Zustand hält an
      if (mySensor[t].state != zustand && millis() - mySensor[t].lastseen >= mySensor[t].prellzeit) {
        mySensor[t].state = zustand;
      }
    }
  }
  //.....
  for (byte t = 0; t << anzahlSensoren; t++) {
    Serial.print(mySensor[t].state == 1 ? 'x' : '-'); //Ausgabe aller entprellten Sensoren-Werte
    Serial.print('\t');  //müsste TAB sein
  }
  Serial.println();  //neue Zeile
}


Sketch kompiliert ohne Warnungen ect.
Geht bestimmt eleganter - so weit bin ich aber noch nicht :/

Ungetestet!! - Vll. hilft'S ja trotzdem

MfG
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 19, 2019, 05:31 pm
Cool, danke, muss ich mir ansehen!
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Doc_Arduino on Jun 19, 2019, 08:23 pm
Hallo,

100ms ein = ein,
100ms aus = aus,
Schaltzustände dazwischen ignorieren

Nochmal zum Verständnis. Eingangssignal soll nur "ein" sein wenn der Sensor mindestens ununterbrochen 100ms lang high liefert und umgekehrt 100ms lang low dann "aus"?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 07:58 am
Ja richtig.
Damit braucht es wohl eine Änderung von "wie lange soll auf ein gültiges Signal gewartet werden?" zu "wie lange muss das Signal high/low anstehen".
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: postmaster-ino on Jun 20, 2019, 08:24 am
Hi

Äääh ... Nein?
Ggf. meinen Versuch da Oben Mal ansehen?
Bei JEDER Pegel-Änderung wird diese Zeit als Startzeit hinterlegt.
ERST, wenn die Prellzeit vorbei ist, wird dieser Status übernommen.

Dar 'riecht' doch schon durch, daß Da in beiden Richtungen die 100ms (oder was sonst) das Signal sauber anliegen muß - wenn nicht, wird ja die Startzeit neu gesetzt und schon ist's Essig mit der Prellzeit.

MfG
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 08:25 am
OK, sorry, das hab ich dann nicht kapiert. Dann is ja gut! Danke!
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 20, 2019, 08:34 am
Quote
Ggf. meinen Versuch da Oben Mal ansehen?
Hach...
Ich habe ihm auch meine schönste und einfachste Entprellung angeboten.
Aber: Schmeckte nicht!
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 08:51 am
Hach...
Ich habe ihm auch meine schönster und einfachste Entprellung angeboten.
Aber: Schmeckte nicht!
Hmm, dein Beispiel kann ich da nur schwerlich lesen, mit den Libs und dem C++ Style.
Einen einfachen habe ich ja nachgebaut, das Array ging noch ab.
Oder kapier ich was nicht ?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: ElEspanol on Jun 20, 2019, 10:25 am
Ich habe ihm auch meine schönster und einfachste Entprellung angeboten.
Aber: Schmeckte nicht!
Das kommt noch. Warte mal so 5 Jahre und 4000 postings.

P.S. Um alle Kommentaren vorzubeugen, ich beziehe mich nicht im entferntesten auf die Intelligenz/Interesse/Lust des TE, sondern auf die Programmierkenntnisse von combie.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 11:22 am
So ist es, meine Programmierkenntnisse sind jetzt ein paar Tage jung ;)
Ich möchte auch kein Profi werden, die Umsetzung meiner Interessen mit eurer Hilfe reicht mir völlig.
Und so wie sich das alles abzeichnet, wird das auch klappen.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: postmaster-ino on Jun 20, 2019, 12:37 pm
Hi

Das ist allerdings schade, daß Du nicht darauf zielst, dem Steinchen das Maximum entlocken zu wollen.
(wobei combie in einer gaaanz anderen Liga spielt - wobei - in Ligen, in Denen ich kaum als Zuschauer erlaubt bin, spielen hier Einige ;) )
Wenn ich aber so weit bin, werde ich den ganzen Kram schamlos abkupfern ... versprochen!

MfG
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 20, 2019, 02:37 pm
Herzlichen Dank für die Blumen!

Ja, ein bisschen fachliche Kompetenz habe ich mir wohl erarbeitet.
Mit C++ bin ich allerdings erst hier, mit Arduino, angefangen.

Was die CombieTimer Lib betrifft, folgt sie einigen Mantras, welche ich mir auch schon vor meiner C++ Zeit ins Hirn gebrannt habe:

> Wenn du irgendwas drei mal auf eine bestimmte Art gemacht hast,
> dann mach eine Funktion oder Klasse draus.

> Wenn du eine Funktion/Klasse baust, sorge für eine möglich simple Schnittstelle
> Damit das Ding von jedem benutzt werden kann.

> Bedingungen und Blockschachtelungen:
> 1 Ebene, schön. 2 Ebenen, ok geht noch. 3 Ebenen, muss das? 4 Ebenen, igitt!


Der EntprellTimer meiner Lib ist ganz einfach zu benutzen.
Ok, von innen mag er etwas kompliziert aussehen, aber da muss man ja nicht hinschauen.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 03:18 pm
Klein anfangen, groß werden. Ja nicht den Spaß an der Sache verlieren, darum die Ziele in griffweite halten.
Heute noch ist das Interesse, dass es einfach nur funktioniert. Morgen, wer weiß ;)

Ist es das?
Code: [Select]
#include <CombieTimer.h>
using Combie::Timer::EntprellTimer;

const byte taster =  2; // taster gegen GND schaltend

EntprellTimer entprellen(200);   // in der Praxis wird man wohl eher 20ms verwenden

void setup()
{
 pinMode(LED_BUILTIN,OUTPUT);   
 pinMode(taster,INPUT_PULLUP);
}

void loop()
{
  // die LED zeigt das, vom prellen bereinigte, Signal
  digitalWrite(LED_BUILTIN,entprellen(!digitalRead(taster)));  // invers, wg. pullup
}


das ist das Kunststück richtig ?
Code: [Select]
entprellen(!digitalRead(taster))

damit müsste ich meinen Merkerzuweisungen nur das entprellen( ) hinzufügen ?
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 20, 2019, 03:36 pm
Quote
damit müsste ich meinen Merkerzuweisungen nur das entprellen( ) hinzufügen ?
Ja, denke schon...



Code: [Select]

// oder so
bool merker = entprellen = not digitalRead(taster);


Natürlich benötigt jede Taste seinen eigenen Entpreller.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 03:44 pm
Also, wenn man es denn verstanden hat, ist es die einfachste Möglichkeit! Danke.
Lib einfügen
entprellen Aufruf zu jedem Pin-Lesen
fertig

könnte man verm. auch in eine Schleife packen, weniger Zeilen...
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: combie on Jun 20, 2019, 04:27 pm
Quote
ist es die einfachste Möglichkeit
Ist es!

Und, wie du siehst, ist es nicht C++, oder die Komplexität des Entprellers, welche dich erst davon abgehalten hat, ihn zu nutzen, sonder eher ein innerer Widerstand.
Und diese, kann nur der Eigentümer der Widerstände bearbeiten.
Was du ja jetzt wohl erfolgreich gemeistert hast.

Von außen, kommt man/ich da nicht ran.....
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: 4711 on Jun 20, 2019, 04:54 pm
Ja schon, aber wenn man das Wissen nicht hat, wie sollst das erkennen geschweige verstehen.
Man kann einfach nicht auf ein galoppierendes Pferd aufspringen, ich zumindest nicht.
Ich muss es häppchenweise machen und ohne die richtungsweisende Führung, bist halt im Wald.

Ich hab grad das Gefühl, dass ich auf einen Schnellzug aufspringe ;)
So lange ihr mir nicht abspringt, fährt der Zug!

C++ steht auf der Todo, aber so schnell geht das nicht, das wird seine Zeit brauchen.
Aktuell möchte ich nur nicht die Lust und Laune verlieren und mal das gesetzte Ziel schaffen.

Die Schleife fehlt mir noch, dann würde ich meinen wäre diese Aufgabenstellung gelöst.
Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Doc_Arduino on Jun 20, 2019, 05:15 pm
Hallo,

habe mich heute auch rangesetzt. Ergebnis ist ähnlich wie das von postmaster. Wenn es mehrere Eingänge sein sollen, würde ich auch ein struct array erstellen und alles in einer for erschlagen. Im Endeffekt wirds dann recht zügig zu einer Klasse.

Code: [Select]
const byte pin_Taster = 2;
const byte pin_Led = 13;

void setup(void) {
  pinMode(pin_Taster, INPUT_PULLUP);
  pinMode(pin_Led, OUTPUT);
}

void loop(void) {
  
  bool var = update_Taster(pin_Taster, 100);
  digitalWrite(pin_Led, var);

}


// ****** Funktionen ******

bool update_Taster (const byte pin, const byte zeit)                        
{
  static unsigned long last_ms = 0;
  static bool last_state = true;
  static bool new_state = true;
  
  unsigned long ms = millis();

  bool state = digitalRead(pin);    // pin einlesen

  if (state != last_state) {        // Hat sich Eingangspegel geändert?
    last_ms = ms;                   // Wenn ja aktuelle Zeit
    last_state = state;             // und diesen Zustand merken
  }
  
  if (ms - last_ms >= zeit) {       // Blieb letzter Zustand für x ms stabil ?
    new_state = state;              // Wenn ja aktuellen Zustand merken
  }

  return new_state;                 // und zurückgeben
}


Title: Re: Zeitverzögerte Auswertung von Eingängen?
Post by: Doc_Arduino on Jun 20, 2019, 06:39 pm
... und die Klasse ist fertig   ;)

Code: [Select]

// https://forum.arduino.cc/index.php?topic=621568.0

class Sensor
{
  private:
    const byte pin;
    bool last_state;
    bool new_state;
    const byte debounce;    // max. 255ms, ansonsten auf unsigned int/long ändern
    unsigned long last_ms;

  public:
    // Konstruktor
    Sensor (byte p, unsigned long deb) :
      // Initialisierungsliste
      pin(p),
      last_state(true),
      new_state(true),
      debounce(deb),
      last_ms(0)
    {}

    // Methoden
    void init()
    {
      pinMode(pin, INPUT_PULLUP);
    }

    void entflattern ()
    {
      unsigned long ms = millis();
      bool state = digitalRead(pin);    // pin einlesen

      if (state != last_state) {        // Hat sich Eingangspegel geändert?
        last_ms = ms;                   // Wenn ja aktuelle Zeit
        last_state = state;             // und diesen Zustand merken
      }

      if (ms - last_ms >= debounce) {   // Blieb letzter Zustand für x ms stabil ?
        new_state = state;              // Wenn ja aktuellen Zustand merken
      }
    }

    bool get_state() { return new_state; }
};

Sensor sensoren[] = {
      {2, 100},   // pin, Entprellzeit
      {3, 90},
      {4, 110},
      {5, 80}
}; 


void setup()
{
  Serial.begin(9600);
     
  for (Sensor & s : sensoren)
  {
    s.init();
  }

}

void loop()
{
  for (Sensor &s : sensoren)
  {
    s.entflattern();
  }

  serieller_Monitor (500);      // nur zum sichtbar machen
}


void serieller_Monitor (const unsigned int INTERVALL)
{
  static unsigned long last_ms = 0;
  unsigned long ms = millis();

  if (ms - last_ms > INTERVALL)
  {
    last_ms = ms;
    for (Sensor &s : sensoren)
    {
      Serial.print(s.get_state() );
      Serial.print('\t');
    }
    Serial.println();
  }
}