Der Sketch den noiasca gepostet hat ist ganz gut. Teilweise tradiert er aber die schlechten Angewohnheiten die man in ganz vielen Programmen antrifft.
Das hat in gewisser Weise etwas gutes weil man dadurch lernt was diese schlechten Angewohnheiten bedeuten. Was ich an diesen Angewohnheiten schlecht finde ist, dass sie es Anfängern erschweren den Code zu verstehen.
Ich behaupte:
Die Codeversion die ich geschrieben habe macht das besser weil für Anfänger leichter verständlich.
Ich nenne das TiC Tutorial intergrated Coding
Ausnahmslos JEDER Experte wird meine Codeversion mit der gleichen Geschwindigkeit verstehen wie die mit den schlechten Angewohnheiten.
Unterschied: meine ist für Anfänger leichter verständlich.
Also ihr lieben Experten WO ist das Problem?
Meine Antwort: Bequemlichkeit sich nicht die Zeit zu nehmen besser selbsterklärende Namen zu finden und mit für Experten überflüssigen Kommentaren zu ergänzen.
Wenn jetzt jemand antworten wollte "das ist aber schlechter Programmierstil so viele Kommentare reinzuschreiben!"
Das macht das Programm unübersichtlich!
Meine Antwort: "Ach Du armer Experte mut du dich durch Kommentare durchwühlen die du eh verstehst? ooch das ist aber anspruchsvoll!
Das ist ja viiiel schwieriger als wenn ein Anfänger sich durch sehr ähnlich lautende und doch nicht wirklich selbsterklärende Namen durchkämpfen muss!
Werde einfach ein noch besserer Experte der
- konsequent immer wirklich gut selbsterklärende Namen verwendet
- seinen Lesestil trainiert, um für Experten "überflüssige" Kommentare ganz schnell zu erfassen und zu überspringen.
constexpr byte gruenPin {5};
constexpr byte gelbPin {6};
constexpr byte rotPin {13};
const unsigned long PhasenDauer = 2000; // zeit in ms
unsigned long PhasenStartZeitpunkt; // Merker wann zuletzt eine Ampelphase begann
unsigned long aktuelleZeit;
enum AmpelPhasenMENGE {rot, rotgelb, gruen, gelb}; // mögliche Zustände der Ampel
// definiert eine Variable mit Namen "AmpelPhase"
// diese Variable hat den Typ "AmpelPhasenMENGE"
AmpelPhasenMENGE AmpelPhase = rot; // weise am Anfang der Variable das Element "rot" zu
// LEDs haben eine gemeinsame Anode
// Kathodenanschluss auf LOW schalten bedeutet
// Anode +5V Kathode am IO-pin LOW = 0V SpannungsUNTERschied
// => Strom fließt => LED leuchtet
// Anode +5V Kathode am IO-pin HIGH = +5V KEIN Spannungsunterschied
// => KEIN Strom fließt LED ist aus
void red() { // je nach Funktion werden die LED's gelöscht und gesetzt
digitalWrite(rotPin, LOW);
digitalWrite(gelbPin, HIGH);
digitalWrite(gruenPin, HIGH);
}
void redYellow(){
digitalWrite(rotPin, LOW);
digitalWrite(gelbPin, LOW);
digitalWrite(gruenPin, HIGH);
}
void green() {
digitalWrite(rotPin, HIGH);
digitalWrite(gelbPin, HIGH);
digitalWrite(gruenPin, LOW);
}
void yellow() {
digitalWrite(rotPin, HIGH);
digitalWrite(gelbPin, LOW);
digitalWrite(gruenPin, HIGH);
}
void setup() {
Serial.begin(115200);
Serial.println(F("setup Start"));
pinMode(rotPin, OUTPUT);
pinMode(gelbPin, OUTPUT);
pinMode(gruenPin, OUTPUT);
}
// Definition einer function mit Namen "naechstePhase"
// die Werte vom Typ AmpelPhasenMENGE zurückgibt
// man übergibt der function die momentan aktuelle Ampelphase
// und die function gibt die nächste Ampelphase als Rückgabewert zurück
AmpelPhasenMENGE naechstePhase(AmpelPhasenMENGE jetzigePhase) {
// Der Parameter hat den Namen "jetzigePhase"
// und ist ebenfalls vom Variablentyp AmpelPhasenMENGE
switch (jetzigePhase) { // wenn die Variable "jetzigePhase"
case rot: // den Wert "rot" hat
return rotgelb; // beende function mit Rückgabewert rotgelb
case rotgelb: // den Wert "rotgelb" hat
return gruen; // beende function mit Rückgabewert gruen
case gruen: // den Wert "gruen" hat
return gelb; // beende function mit Rückgabewert gelb
case gelb: // den Wert "gelb" hat
return rot; // beende function mit Rückgabewert rot
}
// wenn ein Wert übergeben wurde der KEINEM der obigen vier Werte
// entpsricht
return gelb; // beende functiom mit Rückgabewert gelb
}
void loop() {
// function millis() liefert die aktuelle "Uhrzeit"
// im Sinne von Anzahl Millisekunden seit Programmstart
aktuelleZeit = millis();
// berechne die vergangene Zeit seit PhasenStartZeitpunkt
// und vergleiche ob größer / gleich PhasenDauer
if (aktuelleZeit - PhasenStartZeitpunkt >= PhasenDauer) {
// wenn mehr Millisekunden als in Variable "PhasenDauer"
// angegeben sind, vergangen sind
PhasenStartZeitpunkt = aktuelleZeit; // speichere die aktuelle Zeit
// ermittle aus der momentanen Ampelphase die nächste Phase
AmpelPhase = naechstePhase(AmpelPhase);
// schalte die LEDs abhängig von der aktuellen Phase
switch (AmpelPhase) { // Je Zustand verzweigen
case rot:
red();
break; // springe SOFORT ans ENDE-SWITCH-CASE
case rotgelb:
redYellow();
break; // springe SOFORT ans ENDE-SWITCH-CASE
case gruen:
green();
break; // springe SOFORT ans ENDE-SWITCH-CASE
case gelb:
yellow();
break; // springe SOFORT ans ENDE-SWITCH-CASE
} //ENDE-SWITCH-CASE
}
}
vgs
jetzt hatte ich mir überlegt, eine alte FALLER-Ampel über den Arduino anzusteuern - vielleicht kennt jemand noch die FALLER AMS-Rennbahn aus den 60ern... Die Ampel hat drei Kabel in den jeweiligen "Ampelphasenfarben" und ein weißes (minus?)-Kabel.
