Hallo,
na dann zeige ich meinen auch. 
Für die Blinkerkontrollanzeige kann jeweils der gleiche Pin angegeben werden oder verschiedene wie im Auto. Wird ein Blinker spontan umgeschalten, weil vergessen auszuschalten etc., wird die alte Blinksequence erst beendet und danach der neue Blinker aktiviert.
Was ich noch anmerken möchte. Die Blinkfrequenz von 1,5Hz seitens @knifezange empfinde ich für zu schnell, weil das 333ms ein und 333ms aus sind. Das kann irgendwie nicht so ganz stimmen. So schnell blinkte es am Moped wenn die Batterie müde war. Ich würde max. 1Hz wählen bzw. noch etwas drunter.
DocTimer.zip (18,3 KB)
/*
https://forum.arduino.cc/t/hupe-blinker-fernlicht-steuern-fur-cafe-racer/913534
Doc_Arduino - german Arduino Forum
IDE 1.8.16
Arduino Mega2560
15.10.2021
>> originale Pin Belegung -- ggf. ab Zeile 236 ändern <<
tasterHupe 2
tasterBlinkerLinks 3
tasterBlinkerRechts 4
tasterFernlicht 5
outFernlichtKontrolle 7
outHupe 8
outBlinkerLinks 9
outBlinkerRechts 10
outFernlicht 11
outBlinkerKontrolle 12
*/
#include <DocTimer.h>
#include <TimeUnits.h>
using namespace TimeUnits;
constexpr bool DEBUG {true}; // Serielle Ausgaben ja/nein
class Taster
{
private:
const uint8_t pin;
const uint8_t debounceTime;
bool state {false};
bool oldRead {true};
uint32_t lastMillis {0};
bool updateDebounce() {
bool status {false};
if (millis() - lastMillis >= debounceTime) {
lastMillis += debounceTime;
status = true;
}
return status;
}
public:
Taster(uint8_t p, uint8_t dT) :
pin {p},
debounceTime {dT}
{}
void init (void) {
pinMode(pin, INPUT_PULLUP);
}
bool updateNoRetrigger (void)
{
state = false;
if (updateDebounce() )
{
const bool read = digitalRead(pin);
if (!read && oldRead ) {
state = true;
}
oldRead = read;
}
return state;
}
};
class Blinker
{
private:
Taster taster;
const uint8_t blinker;
const uint8_t kontrolle;
const uint32_t halbePeriode;
DocTimer timer;
bool schalter;
bool enableBlinker;
bool request;
enum class BlinkStatus : uint8_t {IDLE, ON, WAITON, OFF, WAITOFF} blinkStatus;
void readTaster (void)
{
if (taster.updateNoRetrigger() ) {
schalter = !schalter;
}
}
public:
Blinker(uint8_t pinT, uint8_t dT, uint8_t pinB, uint8_t pinK, uint32_t t) :
taster {pinT, dT},
blinker {pinB},
kontrolle {pinK},
halbePeriode {t/2},
schalter {false},
enableBlinker {false},
request {false},
blinkStatus {BlinkStatus::IDLE}
{}
void init (void)
{
taster.init();
pinMode(blinker, OUTPUT);
pinMode(kontrolle, OUTPUT);
timer.setTime(halbePeriode);
}
void switchControl (void)
{
readTaster();
if (schalter && (!enableBlinker)) {
request = true; // ohne !enableBlinker ansonsten immer wieder neu aktiviert
}
if (!schalter) {
request = false;
enableBlinker = false;
}
}
bool isThereRequest (void)
{
if (DEBUG) { if (request) Serial.println(F("isThereRequest true")); }
return request;
}
void switchOff (void)
{
schalter = false;
if (DEBUG) { Serial.println(F("switchOff")); }
}
// für
bool waitUntilOff (void)
{
// wenn komplette Blinksequence beendet -> 'true'
if (!schalter && (blinkStatus == BlinkStatus::IDLE) ) return true;
else return false;
}
void switchOn (void)
{
if (request) {
enableBlinker = true;
request = false;
}
if (DEBUG) { Serial.println(F("switchOn")); }
}
void blinkControl (void)
{
switch(blinkStatus)
{
case BlinkStatus::IDLE: if (enableBlinker) {
blinkStatus = BlinkStatus::ON;
if (DEBUG) Serial.println(F("ON"));
}
break;
case BlinkStatus::ON: digitalWrite(blinker, HIGH);
digitalWrite(kontrolle, HIGH);
timer.start();
blinkStatus = BlinkStatus::WAITON;
if (DEBUG) Serial.println(F("WAITON"));
break;
case BlinkStatus::WAITON: if (timer.expired() ) {
blinkStatus = BlinkStatus::OFF;
if (DEBUG) Serial.println(F("OFF"));
}
break;
case BlinkStatus::OFF: digitalWrite(blinker, LOW);
digitalWrite(kontrolle, LOW);
timer.start();
blinkStatus = BlinkStatus::WAITOFF;
if (DEBUG) Serial.println(F("WAITOFF"));
break;
case BlinkStatus::WAITOFF: if (timer.expired() ) {
blinkStatus = BlinkStatus::IDLE;
if (DEBUG) Serial.println(F("IDLE"));
}
break;
}
}
};
class Fernlicht
{
private:
Taster taster;
const uint8_t licht;
const uint8_t kontrolle;
bool schalter;
void readTaster (void)
{
if (taster.updateNoRetrigger() ) { schalter = !schalter; }
}
public:
Fernlicht(uint8_t pinT, uint8_t dT, uint8_t pinL, uint8_t pinK) :
taster {pinT, dT},
licht {pinL},
kontrolle {pinK},
schalter {false}
{}
void init (void)
{
taster.init();
pinMode(licht, OUTPUT);
pinMode(kontrolle, OUTPUT);
}
void control (void)
{
readTaster();
if (schalter) {
digitalWrite(licht, HIGH);
digitalWrite(kontrolle, HIGH);
}
else {
digitalWrite(licht, LOW);
digitalWrite(kontrolle, LOW);
}
}
};
// ###### KONFIGURATION ####################################
const byte tasterHupe {2};
const byte pinHupe {34};
/* Tasterpin
| Entprellzeit
| | Blinkerpin
| | | Kontrollpin
| | | | Periodendauer Blinkfrequenz
| | | | | */
Blinker blinkerLinks (3, 30, 28, 30, 666_ms);
Blinker blinkerRechts (4, 30, 29, 30, 666_ms);
/* Tasterpin
| Entprellzeit
| | Lichtpin
| | | Kontrollpin
| | | | */
Fernlicht fernlicht (5, 30, 31, 32);
// ###### GEHT LOS #########################################
void setup(void)
{
Serial.begin(9600);
Serial.println(F("\nuC RESET ### ### ###"));
pinMode(tasterHupe, INPUT_PULLUP);
pinMode(pinHupe, OUTPUT);
blinkerLinks.init();
blinkerRechts.init();
fernlicht.init();
}
void loop(void)
{
blinkerLinks.switchControl();
blinkerRechts.switchControl();
// Gibt es ein neue Blinkanforderung wird gepüft ob der Andere aus ist.
// Ist der Andere aktiv wird gewartet bis er aus.
// Erst dann wird der neue Blinker eingeschalten.
if (blinkerLinks.isThereRequest() )
{
blinkerRechts.switchOff();
if (blinkerRechts.waitUntilOff() ) {
blinkerLinks.switchOn();
if (DEBUG) { Serial.println(F("R off und L on")); }
}
}
if (blinkerRechts.isThereRequest() )
{
blinkerLinks.switchOff();
if (blinkerLinks.waitUntilOff() ) {
blinkerRechts.switchOn();
if (DEBUG) { Serial.println(F("L off und R on")); }
}
}
blinkerLinks.blinkControl();
blinkerRechts.blinkControl();
fernlicht.control();
hupe();
}
void hupe (void)
{
digitalWrite(pinHupe, !digitalRead(tasterHupe) );
}
Edit:
Ja ich weiß, mein Mischmasch deutsch englisch gefällt mir auch nicht richtig. 