Außerdem steht eine if einfach so im Raum ohne in einer Funktion zu sein.
Das Einrücken und die Position der Klammern könnte man verbessern, sonst ist der Punkt behoben 
So bleibt nur das triviale 'change' was not declared übrig.
Und das Problem mit dem fehlenden Entprellen natürlich.
Und dass es hier laut Überschrift explizit um 8 Taster geht. Da ist eine Lösung per 8-fach paste & edit nicht mehr in der Kategorie "Musterlösung à la jurs", für meinen Geschmack.
Hallo,
ich bin mal so frei und gebe dazu einen Democode raus. Nutzt die Anfänger freundliche Bounce2 Lib. Ich hoffe Hitmare kann das nachvollziehen, dann dürfte eine Erweiterung auf 8 Taster/Schalter keine Probleme bereiten.
/*
Doc_Arduino - german Arduino Forum
IDE 1.8.3
Arduino Mega2560
31.08.2017
2 Taster mit Tastfunktion
2 Taster mit Schaltfunktion
*/
#include <Bounce2.h>
const byte Taster_1_Pin = 2; // Taster
const byte Taster_2_Pin = 3; //
const byte Taster_3_Pin = 4; //
const byte Taster_4_Pin = 5; //
const byte LED_1_Pin = 30;
const byte LED_2_Pin = 31;
const byte LED_3_Pin = 32;
const byte LED_4_Pin = 33;
byte stateTaster1 = HIGH; // Ausgangszustand
byte stateTaster2 = HIGH; //
byte stateTaster3 = LOW; //
byte stateTaster4 = LOW; //
Bounce debouncer1 = Bounce(); // Instantiate a Bounce object 1
Bounce debouncer2 = Bounce(); //
Bounce debouncer3 = Bounce(); //
Bounce debouncer4 = Bounce(); //
void setup() {
pinMode(Taster_1_Pin, INPUT_PULLUP);
pinMode(Taster_2_Pin, INPUT_PULLUP);
pinMode(Taster_3_Pin, INPUT_PULLUP);
pinMode(Taster_4_Pin, INPUT_PULLUP);
debouncer1.attach(Taster_1_Pin); debouncer1.interval(30); // setup der Bounce Instanzen
debouncer2.attach(Taster_2_Pin); debouncer2.interval(30);
debouncer3.attach(Taster_3_Pin); debouncer3.interval(30);
debouncer4.attach(Taster_4_Pin); debouncer4.interval(30);
pinMode(LED_1_Pin, OUTPUT);
pinMode(LED_2_Pin, OUTPUT);
pinMode(LED_3_Pin, OUTPUT);
pinMode(LED_4_Pin, OUTPUT);
}
void loop() {
update_Inputs();
update_Outputs();
} // loop Ende
// ****** Funktionen ******* //
void update_Inputs ()
{
debouncer1.update();
debouncer2.update();
debouncer3.update();
debouncer4.update();
// Taster 1
stateTaster1 = debouncer1.read();
// Taster 2
stateTaster2 = debouncer2.read();
// Schalter 3
if ( debouncer3.fell() ) {
stateTaster3 = !stateTaster3; // toggle state
}
// Schalter 4
if ( debouncer4.fell() ) {
stateTaster4 = !stateTaster4; // toggle state
}
}
void update_Outputs ()
{
digitalWrite(LED_1_Pin, !stateTaster1);
digitalWrite(LED_2_Pin, !stateTaster2);
digitalWrite(LED_3_Pin, stateTaster3);
digitalWrite(LED_4_Pin, stateTaster4);
}
Bei aller Liebe - aber geht's bitteschön noch umständlicher? Diese Lib verbrennt für jeden Taster 8! der auf den AtMegas kostbaren RAM-Bytes. Es reicht völlig aus, am Anfang des loops alle Tastereingänge in ihre Statusvariablen einzulesen, und per millis() dafür zu sorgen, dass das nur alle 10-20ms (= Entprellzeit) gemacht wird.
const unsigned long prellZeit = 20;
unsigned long lastUpdate ;
bool stateTaster1, stateTaster2;
const byte taster1Pin = 4;
const byte taster2Pin = 5;
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
// Taster 1
stateTaster1 = digitalRead( taster1Pin );
// Taster 2
stateTaster2 = digitalRead( taster2Pin );
}
// Taster verarbeiten
}
Bei vielen Tastern empfiehlt sich - wie hier schon erwähnt, das ganz über Arrays und eine Forschleife zu machen.
Ihr alle hehrt klammheimich das EEprom untern Teppich.
Ok, das ist 'ne andere Baustelle. Aber Du hattest ihm dich eigentlich schon geschrieben, dass es, so wie er es macht, überflüssig ist das im EEPROM zu speichern.
uwefed:
Das kannst Du nicht mit einer Pause realisieren. Da mußt Du kontrollieren ob der Zustand des Pins sich ändert und dann ein bzw Ausschalten.
Da die while schleife nur dann aktiv ist wenn der Knopf gedrückt ist , läuft der code doch normal weiter wenn der knopf wieder losgelassen wird
uwefed:
Arbeite mit indizierten Variablen (arrays) und For schleifen. Ein solcher Spaghetticode ist ein Grauß.
Arrays statt EEPROM kann ich versuchen. Erste versuche haben aber weniger erfolg erzielt als der EEPROM
Und ich wüsste nicht inwiefern die for schleife mir helfen soll? Da sehe ich die while schleife doch als hilfreicher
zb
while ( taster1 = LOW) {
// code zum abarbeiten
}
uwefed:
Wie schon beschrieben ist der Fehler daß du 2 Byte ins EEProm schreibst aber die Adresse nur um 1 Byte verschiebst. Nimm entweder die Funktion, die 1 Byte ins EEprom schreibt, Lösche die Eepromsache ganz oder verwende Adressen die um 2Byte außeinanderliegen.
Vieleicht solltest Du die Basisgrundlagen lernen.
Wenn der Zustand denn abgespeichert würde. Beim Einschalten wird das EEprom ja als erstes gelöscht.Grüße Uwe
Das stimmt so nicht, es sei denn eine 0 bzw eine 1 belegt 2 bytes. im change() wird nämlich auf die gegebene adresse entweder die 1 oder die 0 geschrieben. so sollte eigentlich immer 1 byte belegt werden
Um den Sinn der Projektes vielleicht etwas verständlicher zu machen:
Wenn man einen Taster drückt soll sich der Status der LED ändern ( von an zu aus und umgekehrt) und eine Serielle information übermittelt werden.
Um den akuellen status zu speichern habe ich eben den EEPROM genutzt um zu speichern ob der Status gerade an oder aus ist (1 und 0 die abwechselnd gespeichert werden)
change() ist hierfür meine Wechselschaltung die eben aus dem EEPROM den gepeicherten Zustand ausliest und umändert, die LED umschaltet und das Passende Serielle signal aussendet
Doc_Arduino:
Hallo,ich bin mal so frei und gebe dazu einen Democode raus. Nutzt die Anfänger freundliche Bounce2 Lib. Ich hoffe Hitmare kann das nachvollziehen, dann dürfte eine Erweiterung auf 8 Taster/Schalter keine Probleme bereiten.
GitHub - thomasfredericks/Bounce2: Debouncing library for Arduino and Wiring
/*
Doc_Arduino - german Arduino Forum
IDE 1.8.3
Arduino Mega2560
31.08.2017
2 Taster mit Tastfunktion
2 Taster mit Schaltfunktion
*/
#include <Bounce2.h>
const byte Taster_1_Pin = 2; // Taster
const byte Taster_2_Pin = 3; //
const byte Taster_3_Pin = 4; //
const byte Taster_4_Pin = 5; //
const byte LED_1_Pin = 30;
const byte LED_2_Pin = 31;
const byte LED_3_Pin = 32;
const byte LED_4_Pin = 33;
byte stateTaster1 = HIGH; // Ausgangszustand
byte stateTaster2 = HIGH; //
byte stateTaster3 = LOW; //
byte stateTaster4 = LOW; //
Bounce debouncer1 = Bounce(); // Instantiate a Bounce object 1
Bounce debouncer2 = Bounce(); //
Bounce debouncer3 = Bounce(); //
Bounce debouncer4 = Bounce(); //
void setup() {
pinMode(Taster_1_Pin, INPUT_PULLUP);
pinMode(Taster_2_Pin, INPUT_PULLUP);
pinMode(Taster_3_Pin, INPUT_PULLUP);
pinMode(Taster_4_Pin, INPUT_PULLUP);
debouncer1.attach(Taster_1_Pin); debouncer1.interval(30); // setup der Bounce Instanzen
debouncer2.attach(Taster_2_Pin); debouncer2.interval(30);
debouncer3.attach(Taster_3_Pin); debouncer3.interval(30);
debouncer4.attach(Taster_4_Pin); debouncer4.interval(30);
pinMode(LED_1_Pin, OUTPUT);
pinMode(LED_2_Pin, OUTPUT);
pinMode(LED_3_Pin, OUTPUT);
pinMode(LED_4_Pin, OUTPUT);
}
void loop() {
update_Inputs();
update_Outputs();
} // loop Ende
// ****** Funktionen ******* //
void update_Inputs ()
{
debouncer1.update();
debouncer2.update();
debouncer3.update();
debouncer4.update();
// Taster 1
stateTaster1 = debouncer1.read();
// Taster 2
stateTaster2 = debouncer2.read();
// Schalter 3
if ( debouncer3.fell() ) {
stateTaster3 = !stateTaster3; // toggle state
}
// Schalter 4
if ( debouncer4.fell() ) {
stateTaster4 = !stateTaster4; // toggle state
}
}
void update_Outputs ()
{
digitalWrite(LED_1_Pin, !stateTaster1);
digitalWrite(LED_2_Pin, !stateTaster2);
digitalWrite(LED_3_Pin, stateTaster3);
digitalWrite(LED_4_Pin, stateTaster4);
}
Leider versteh ich nicht wie mir die Bounce Bibliothek helfen soll, noch wie sie funktioniert und anwendbar ist
GitHub - thomasfredericks/Bounce2: Debouncing library for Arduino and Wiring <- Das hier ist auch nicht wirklich hilfreich für mich
MicroBahner:
Bei aller Liebe - aber geht's bitteschön noch umständlicher? Diese Lib verbrennt für jeden Taster 8! der auf den AtMegas kostbaren RAM-Bytes. Es reicht völlig aus, am Anfang des loops alle Tastereingänge in ihre Statusvariablen einzulesen, und per millis() dafür zu sorgen, dass das nur alle 10-20ms (= Entprellzeit) gemacht wird.const unsigned long prellZeit = 20;
unsigned long lastUpdate ;
bool stateTaster1, stateTaster2;
const byte taster1Pin = 4;
const byte taster2Pin = 5;
void setup() {
// put your setup code here, to run once:
}
void loop() {
// put your main code here, to run repeatedly:
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
// Taster 1
stateTaster1 = digitalRead( taster1Pin );
// Taster 2
stateTaster2 = digitalRead( taster2Pin );
}
// Taster verarbeiten
}
Bei vielen Tastern empfiehlt sich - wie hier schon erwähnt, das ganz über Arrays und eine Forschleife zu machen.
Hab die Variante versucht anstatt der while schleife und leider funktioniert es nicht wie gewollt. Die Schaltung "flattert" bei 20ms wartezeit (schaltet die LED ein und aus bei der drückzeit). Werde es man mit dem Zehnfachen oder mehr versuchen
Ich habe nun folgendes im Chip und es scheint problemlos zu funktionieren
const unsigned long prellZeit = 100;
unsigned long lastUpdate ;
int state[11];
void setup() {
// put your setup code here, to run once:
pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP);
pinMode(4, INPUT_PULLUP);
pinMode(5, INPUT_PULLUP);
pinMode(6, INPUT_PULLUP);
pinMode(7, INPUT_PULLUP);
pinMode(8, INPUT_PULLUP);
pinMode(9, INPUT_PULLUP);
pinMode(A0, OUTPUT);
pinMode(A1, OUTPUT);
pinMode(A2, OUTPUT);
pinMode(A3, OUTPUT);
pinMode(A4, OUTPUT);
pinMode(A5, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
Serial.begin(115200);
}
void loop() {
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
if (digitalRead(2) == LOW) {
change(2);
}
if (digitalRead(3) == LOW) {
change(3);
}
if (digitalRead(4) == LOW) {
change(4);
}
if (digitalRead(5) == LOW) {
change(5);
}
if (digitalRead(6) == LOW) {
change(6);
}
if (digitalRead(7) == LOW) {
change(7);
}
if (digitalRead(8) == LOW) {
change(8);
}
if (digitalRead(9) == LOW) {
change(9);
}
}
}
void change(int port) {
if (state[port] == 0 || state[port] == "" ) {
Serial.print(port);
Serial.print("0");
analogpin(port, 0);
state[port] = 1;
while (digitalRead(port) == LOW) { delay(2); }
//delayMicroseconds(20);
return;
}
if (state[port] == 1) {
Serial.print(port);
Serial.print("1");
analogpin(port, 1);
state[port] = 0;
while (digitalRead(port) == LOW) { delay(2); }
//delayMicroseconds(20);
return;
}
}
void analogpin(int analog, int val) {
if ( analog == 2 && val == 0 ) { digitalWrite(11, HIGH);}
if ( analog == 2 && val == 1 ) { digitalWrite(11, LOW); }
if ( analog == 3 && val == 0 ) { digitalWrite(10, HIGH); }
if ( analog == 3 && val == 1 ) { digitalWrite(10, LOW); }
if ( analog == 4 && val == 0 ) { digitalWrite(A5, HIGH); }
if ( analog == 4 && val == 1 ) { digitalWrite(A5, LOW); }
if ( analog == 5 && val == 0 ) { digitalWrite(A4, HIGH); }
if ( analog == 5 && val == 1 ) { digitalWrite(A4, LOW); }
if ( analog == 6 && val == 0 ) { digitalWrite(A3, HIGH); }
if ( analog == 6 && val == 1 ) { digitalWrite(A3, LOW); }
if ( analog == 7 && val == 0 ) { digitalWrite(A2, HIGH); }
if ( analog == 7 && val == 1 ) { digitalWrite(A2, LOW); }
if ( analog == 8 && val == 0 ) { digitalWrite(A1, HIGH); }
if ( analog == 8 && val == 1 ) { digitalWrite(A1, LOW); }
if ( analog == 9 && val == 0 ) { digitalWrite(A0, HIGH); }
if ( analog == 9 && val == 1 ) { digitalWrite(A0, LOW); }
}
Hitmare:
Und ich wüsste nicht inwiefern die for schleife mir helfen soll? Da sehe ich die while schleife doch als hilfreicher
Die for-Schleife ist nicht für einen Taster. Sondern für alle. Statt den gleichen Code 8 mal zu schreiben kann man alle 8 Taster in einer Schleife abfragen:
const byte taster[] = { ... };
for (byte i = 0; i < sizeof(taster); i++)
{
if (digitalRead(taster[i] == LOW)
{
}
}
Kürzer, übersichtlicher, weniger fehleranfällig und leichter erweiterbar
Geht mit LEDs genauso. Die LED Pins in ein Array. Dann kann man darüber iterieren und alle Pins auf OUTPUT setzen
Noch schöner wird es mit structs wenn man alle Variablen/Konstanten die zu einem Taster gehören in einer Datenstruktur zusammenfasst. Und dann ein Array aus structs hat:
http://forum.arduino.cc/index.php?topic=496453.msg3387242#msg3387242
So ist alles zusammen was zusammen gehört und man hat nicht mehrere unabhängige Arrays
Grundsatzfrage: Muss der Status der LED über ein Ausschalten hinaus erhalten bleiben?
Ja = dauerhafter Speicher, z.B. EEPROM (Schreibzyklen beachten), Nein = kein EEPROM
Ansonsten würde ich Dir empfehlen erst mal einen Taster und 1 LED so zu bauen, dass die Funktion Deinen Vorstellungen entspricht und danei die Grundlagen zu erlernen.
Dann das 2. Paar hinzufügen und evtl. den Ablauf noch mal umbauen, weil die delay() stören könnten.
Dann hast Du einen funktionierenden und von Dir verstandenen Ablauf, den Du beliebig erweitern kannst.
Gruß Tommy
Wie Serenifly schon schrieb, hast Du die verschiedenen Tipps etwas durcheinandergebracht.
Zugegebenermaßen haben die auch nicht alle direkt mit deiner Frage zu tun gehabt, sondern sollten dir zeigen, dass man das auch deutlich einfacher und kürzer lösen kann.
Wenn Du dir alten und neuen Status der Taster merkst, brauchst Du überhaupt keine while-Schleifen oder delays in deinem Sketch. Du machst immer nur etwas, wenn sich der Taster von 'nichtgedrückt' auf 'gedrückt' ändert.
So könnte das aussehen:
const unsigned long prellZeit = 20;
unsigned long lastUpdate ;
byte tasterPin[] = {2,3,4,5,6,7,8,9};
byte ledPin[] = {A0,A1,A2,A3,A4,A5,10,11};
const byte tasterZahl = sizeof(tasterPin);
bool tasterState[tasterZahl]; // aktueller Status des Tasters
bool oldTasterState[tasterZahl]; // vorhergehender Status ( zur Flankenerkennung )
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
for ( byte i=0; i<tasterZahl; i++ ) {
pinMode( tasterPin[i], INPUT_PULLUP );
pinMode( ledPin[i], OUTPUT );
}
}
void loop() {
// Tasterinputs entprellt einlesen
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
for( byte i=0; i<tasterZahl; i++ ) {
tasterState[i] = ! digitalRead( tasterPin[i] ) ; // neg.Logik wg. Pullup
}
}
//Taster auswerten
for( byte i=0; i<tasterZahl; i++ ) {
if ( oldTasterState[i] == false && tasterState[i] == true ) {
// Taster wurde gedrückt, led umschalten und serielle Ausgabe
digitalWrite( ledPin[i], !digitalRead(ledPin[i]) );
Serial.print(ledPin[i]);
Serial.println(digitalRead(ledPin[i]) );
}
oldTasterState[i] = tasterState[i]; // Status merken für nächsten Durchlauf
}
}
Structs habe ich jetzt mal nicht genutzt, schau dir erstmal an, wie man die Arrays für sowas einsetzt.
MicroBahner:
Wie Serenifly schon schrieb, hast Du die verschiedenen Tipps etwas durcheinandergebracht.
Zugegebenermaßen haben die auch nicht alle direkt mit deiner Frage zu tun gehabt, sondern sollten dir zeigen, dass man das auch deutlich einfacher und kürzer lösen kann.Wenn Du dir alten und neuen Status der Taster merkst, brauchst Du überhaupt keine while-Schleifen oder delays in deinem Sketch. Du machst immer nur etwas, wenn sich der Taster von 'nichtgedrückt' auf 'gedrückt' ändert.
So könnte das aussehen:const unsigned long prellZeit = 20;
unsigned long lastUpdate ;
byte tasterPin[] = {2,3,4,5,6,7,8,9};
byte ledPin[] = {A0,A1,A2,A3,A4,A5,10,11};
const byte tasterZahl = sizeof(tasterPin);
bool tasterState[tasterZahl]; // aktueller Status des Tasters
bool oldTasterState[tasterZahl]; // vorhergehender Status ( zur Flankenerkennung )
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
for ( byte i=0; i<tasterZahl; i++ ) {
pinMode( tasterPin[i], INPUT_PULLUP );
pinMode( ledPin[i], OUTPUT );
}
}
void loop() {
// Tasterinputs entprellt einlesen
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
for( byte i=0; i<tasterZahl; i++ ) {
tasterState[i] = ! digitalRead( tasterPin[i] ) ; // neg.Logik wg. Pullup
}
}
//Taster auswerten
for( byte i=0; i<tasterZahl; i++ ) {
if ( oldTasterState[i] == false && tasterState[i] == true ) {
// Taster wurde gedrückt, led umschalten und serielle Ausgabe
digitalWrite( ledPin[i], !digitalRead(ledPin[i]) );
Serial.print(ledPin[i]);
Serial.println(digitalRead(ledPin[i]) );
}
oldTasterState[i] = tasterState[i]; // Status merken für nächsten Durchlauf
}
}
Structs habe ich jetzt mal nicht genutzt, schau dir erstmal an, wie man die Arrays für sowas einsetzt.
Hallo
Danke für den Code. Hab ihn noch etwas angepasst damit er auch so funktioniert wie er soll ^^
const unsigned long prellZeit = 100;
unsigned long lastUpdate ;
byte tasterPin[] = {2,3,4,5,6,7,8,9};
byte ledPin[] = {11,10,A5,A4,A3,A2,A1,A0};
const byte tasterZahl = sizeof(tasterPin);
bool tasterState[tasterZahl]; // aktueller Status des Tasters
bool oldTasterState[tasterZahl]; // vorhergehender Status ( zur Flankenerkennung )
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
for ( byte i=0; i<tasterZahl; i++ ) {
pinMode( tasterPin[i], INPUT_PULLUP );
pinMode( ledPin[i], OUTPUT );
}
}
void loop() {
// Tasterinputs entprellt einlesen
if ( millis() - lastUpdate > prellZeit ) {
lastUpdate = millis();
for( byte i=0; i<tasterZahl; i++ ) {
tasterState[i] = ! digitalRead( tasterPin[i] ) ; // neg.Logik wg. Pullup
}
}
//Taster auswerten
for( byte i=0; i<tasterZahl; i++ ) {
if ( oldTasterState[i] == false && tasterState[i] == true ) {
// Taster wurde gedrückt, led umschalten und serielle Ausgabe
digitalWrite( ledPin[i], !digitalRead(ledPin[i]) );
Serial.print(tasterPin[i]);
Serial.print(!digitalRead(ledPin[i]) );
}
oldTasterState[i] = tasterState[i]; // Status merken für nächsten Durchlauf
}
}
Die Structs werde ich mir mal beizeiten ansehen. Momentan blick ich da nicht durch was so ein struct macht oder wie ich ein solches einsetzen kann.
Bin froh das ich die Funktionen kapiert hab ^^
Werde mir hoffentlich für die Zukunft den Tipp bezüglich der for schleife im Bezug der PIN Zuweisung merken.
Hallo,
die Übungen dienten alle zur Tasterentprellung und zur Vermeidung das EEprom zuverwenden. Mehr nicht.
Das mit der Bounce ist vielleicht Overkill gewesen in Bezug auf Programmumfang, wollte aber ein Bsp. mit der Lib zeigen.
Du weißt aber nicht wie man eine Lib "installiert", deswegen funktionierte das bei dir nicht.
Die andere Methode ist eh besser und kommt ohne extra Lib aus.
Hitmare:
Das stimmt so nicht, es sei denn eine 0 bzw eine 1 belegt 2 bytes. im change() wird nämlich auf die gegebene adresse entweder die 1 oder die 0 geschrieben. so sollte eigentlich immer 1 byte belegt werden
Glaubst Du ich schreibe das um Dich zu ärgern oder eine Spaß aus Dir zu machen?
Lerne was ein "int" ist
und was "eepromWriteInt(port, 1);" macht.
Lerne die Grundlagen!!
Dann reden wir weiter.
Grüße Uwe
Doc_Arduino:
Hallo,die Übungen dienten alle zur Tasterentprellung und zur Vermeidung das EEprom zuverwenden. Mehr nicht.
Das mit der Bounce ist vielleicht Overkill gewesen in Bezug auf Programmumfang, wollte aber ein Bsp. mit der Lib zeigen.
Du weißt aber nicht wie man eine Lib "installiert", deswegen funktionierte das bei dir nicht.
Die andere Methode ist eh besser und kommt ohne extra Lib aus.
Ich denke schon das ich weis wie man eine Lib installiert, hab mir die Bounce2 Lib sogar nachinstalliert. Nur den Code habe ich nicht so ganz verstanden. Getestet habe ich jetzt auch nicht.
uwefed:
Glaubst Du ich schreibe das um Dich zu ärgern oder eine Spaß aus Dir zu machen?Lerne was ein "int" ist
int() - Arduino Reference
und was "eepromWriteInt(port, 1);" macht.
Eine Integer Zahl in das Arduino EEPROM schreiben und wieder lesen | Shelvin – Elektronik ausprobiert und erläutertLerne die Grundlagen!!
Dann reden wir weiter.Grüße Uwe
Ok Entschuldigung. Das ein INT 2 Bytes groß ist wusste ich vorher nicht.
Das meiste was ich mir an wissen angeeignet hab war bisher Learning-by-doing
Ich denke schon das ich weis wie man eine Lib installiert, hab mir die Bounce2 Lib sogar nachinstalliert. Nur den Code habe ich nicht so ganz verstanden. Getestet habe ich jetzt auch nicht.
aber du siehst doch welche Wirkung die Tasterbetätigung auf die LEDs haben? Naja, ist nun eh egal.