Hier möchte ich euch meinen INTERVAL Ersatzstoff vorstellen.
Wer gar nicht weiß, worum es sich dreht, sollte dieses lesen:
Blink Without Delay
Der Wachmann
Hält man sich an die dort vorgeschlagenen Wege, was auch gut und richtig ist, dann wird der Quellcode mit solchen Statements geflutet:
if(millis() - gemerkteZeit >= wunschLaufzeit)
{
// tuwas
gemerkteZeit = millis();
}
Die Wurst ist total korrekt.
Aber dennoch unangenehm, da mit viel Schreibarbeit verbunden.
Es schleichen sich schnell Copy+Paste Fehler ein.
Der Quellcode des Projektes wird recht unübersichtlich. Um so schlimmer, je öfter das Konstrukt darin vorkommt.
Hier die von mir erstellten Abstraktionen des Problems:
Multitasking Macros
Intervall Macro
An dieser Stelle ein herzliches Danke, an die Spender der (in den Threads versteckten) Anregungen.
Im folgenden habe ich versucht sie weitestgehend aufzunehmen.
Zum "WARUM?" bei mir ein Ersatzstoff, für INTERVAL und die TaskMakros, her muss:
Eigentlich funktionieren diese Dinge prächtig!
Sind aber gewissen Einschränkungen unterworfen, was hauptsächlich an der Verwendung der statischen Daten liegt. Diese verhindern eine Mehrfachverwendung der erstellten Funktionen. Ich nenne solche Funktionen "Wegwerf Funktionen". Denn sie sind nur einmal pro Projekt nutzbar. Braucht man z.B. drei unabhängige Wechselblinker, dann muss man die Funktion kopieren, so dass man, im schlimmsten Fall, 3 vollständig identische Kopien in einem Programm hat.
Ebenso verhält es sich wenn man diese Makros in Klassen einbaut, dann ist nur eine Instanz nutzbar. Mehrere Instanzen führen zu Fehlverhalten. Eine "Wegwerf Klasse".
Was im prozeduralen Umfeld gerade noch erträglich erscheint, macht im OOP Umfeld die wichtigsten OO Möglichkeiten kaputt.
Dabei ist doch gerade die Wiederverwendbarkeit eins der vordringlichsten Ziele der OOP.
Ist klar geworden, wo der Hase im Pfeffer liegt?
Hier jetzt der neue Ansatz, um das BlinkWithoutDelay Problem zu erschlagen:
BlinkWithSimpleTimer.ino
#include "CombieTimer.h"
Combie::SimpleTimer timer; // timer Instanz anlegen
void setup()
{
pinMode(LED_BUILTIN,OUTPUT);
// timer.start();
}
void loop()
{
if(timer(1000)) // wenn abgelaufen
{
digitalWrite(LED_BUILTIN,!digitalRead(LED_BUILTIN));
timer.start();
}
}
Ich nutze NameSpaces, da es schon eine SimpleTimer Lib gibt, und ich damit nicht kollidieren möchte. Wenn man sich den Code anschaut, dann ist mein SimpleTimer deutlich simpler, als der fremde SimpleTimer.
Daraus leite ich, für mich, das moralische Recht ab meinen SimpleTimer auch so zu nennen.
Erklärung:
Der SimpleTimer startet immer im abgelaufenen Zustand. Er wird also bei der ersten Nutzung true liefen. Will man das nicht, sollte man in setup() ein timer.start() notieren, so wie es im Beispiel vorbereitet ist.
Vergleichbares hier nochmal in einer abgewandelten Version:
BlinkWithPulsator.ino
#include "CombieTimer.h"
Combie::Pulsator puls(1000); // liefert alle 1000 ms einmal true sonst false
void setup()
{
pinMode(LED_BUILTIN,OUTPUT);
puls.start(); // dank des start(), beginnt puls mit Pause
}
void loop()
{
if(puls) digitalWrite(LED_BUILTIN,!digitalRead(LED_BUILTIN));
}
Eine Entprelleinrichtung, basierend auf dem SimpleTimer:
TasterEntprellen.ino
#include "CombieTimer.h"
using Combie::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
}
Und zum Abschluss noch eine Aufgabe um ein Signal zu formen:
Schaltsequenz.ino
/**
* Ablaufdiagramm - Zeitdiagramm
*
* S1 _----------_____ Schalterstellung
* OUT1 _-------------__ Verzoegertes abschalten
* OUT2 ____-------_____ Verzoegertes einschalten
*
*/
#include "CombieTimer.h"
using namespace Combie;
const byte S1 = 2; // Schalter Pin
const byte OUT1 = 3; // Ausgang
const byte OUT2 = 4; // Ausgang
EntprellTimer entprell(20); // Schalter entprellen
RisingEdgeTimer ton(500); // steigende Flanke wird verzoegert
FallingEdgeTimer toff(500); // abfallende Flanke wird verzoegert
void setup(void)
{
pinMode(S1,INPUT_PULLUP);
pinMode(OUT1,OUTPUT);
pinMode(OUT2,OUTPUT);
}
void loop(void)
{
bool schalter = entprell(!digitalRead(S1)); // invers wg. pullup
digitalWrite(OUT1, toff(schalter));
digitalWrite(OUT2, ton(schalter));
}
Zu guter Letzt noch die CombieTimer.h in welcher die ganze Magie steckt:
#pragma once
namespace Combie
{
class SimpleTimer
{
private:
unsigned long timeStamp = 0;
bool abgelaufen = true; // default Status: timer abgelaufen
public:
void start()
{
timeStamp = millis();
abgelaufen = false;
}
bool operator()(const unsigned long ablaufZeit)
{
if(!abgelaufen) abgelaufen = millis() - timeStamp >= ablaufZeit;
return abgelaufen;
}
};
class Pulsator // liefert alle X ms einen HIGH Impuls
{
protected:
SimpleTimer timer;
unsigned long interval;
public:
Pulsator(unsigned long interval):interval(interval){}
void setInterval(const unsigned long _interval)
{
interval = _interval;
}
void start()
{
timer.start();
}
operator bool()
{
bool result = false;
if(timer(interval))
{
result = true;
timer.start();
}
return result;
}
};
class EdgeTimer // Die abstakte Mutter der Flankenverzoegerer
{
protected:
SimpleTimer timer;
unsigned long laufzeit = 0;
public:
explicit EdgeTimer(const unsigned long laufzeit):laufzeit(laufzeit){}
virtual bool operator()(const bool trigger) = 0;
void setLaufzeit(const unsigned long _laufzeit)
{
laufzeit = _laufzeit;
}
};
class FallingEdgeTimer: public EdgeTimer // abfallende Flanke wird verzoegert
{
public:
using EdgeTimer::EdgeTimer;
virtual bool operator()(const bool trigger)
{
if(trigger) timer.start();
return !timer(laufzeit);
}
};
class RisingEdgeTimer: public EdgeTimer // steigende Flanke wird verzoegert
{
public:
using EdgeTimer::EdgeTimer;
virtual bool operator()(const bool trigger)
{
if(!trigger) timer.start();
return timer(laufzeit);
}
};
class EntprellTimer
{
private:
SimpleTimer timer;
bool merker = false; // zustand
const unsigned long entprellzeit;
public:
explicit EntprellTimer(const unsigned long entprellzeit) : entprellzeit(entprellzeit) {}
bool operator()(const bool trigger)
{
if(merker == trigger) timer.start();
if(timer(entprellzeit)) merker = !merker;
return merker;
}
};
}
Die CombieTimer.h kann man einfach mit ins Projektverzeichnis werfen und wird dann von Arduino in einem Tab angezeigt.
Vorschläge?
Ansichten?
Kritik?
Würde mich freuen!
