...und da ist sie wieder, die gute Reference... hätte ich ja gleich drauf kommen können...
ich sehe schon, ich muss mehr in der Reference stöbern gehen...
danke dir erst mal
...so wie angeraten, hab ich nun ein bisschen in der Reference gelesen und bin auch klar, was ich tun kann bzw. welche Methode hier die beste sein wird.
Da das schreiben in den EEprom endlich ist (100.000) und ich aber nur bei einer Veränderung der Einstellzeit "settTime" auch im EEprom speichern möchte habe ich die Methode EEprom.put gewählt.
Denke dass ich hierfür eure Zustimmung erhalte... 
Allerding habe ich sicherlich auch noch einen Fehler drin oder was vergessen.
Vielleicht könnt ihr mal drauf schauen und mir noch eine Tipp geben???
anbei der Code - noch nicht getestet!
/*
Arduino Nano V3
AlarmTasterTimer für LED Steuerung
per Tastendruck einen vordefinierten ZeitWert(distance 10)erhöhen oder senken.
mit Display 4-Digit / Einstellung von 10 bis 600 Sekunden.
*/
#include <TM1637Display.h> // Lib für Display einbinden
#include <EEPROM.h> // Lib für EEprom einbinden
// PINs des Displays:
const int CLK = 6; //Set the CLK pin connection to the display
const int DIO = 7; //Set the DIO pin connection to the display
// Display initialisieren:
TM1637Display display(CLK, DIO); //set up the 4-Digit Display.
// Noch Display-Zustände definieren:
uint8_t all_on[] = { 0xff, 0xff, 0xff, 0xff };
uint8_t all_off[] = { 0x00, 0x00, 0x00, 0x00 };
// Konstante Variablen
const byte alarmIn = A0;
const byte switchUpPin = A1; // Pin für Taster 1
const byte switchDownPin = A2; // Pin für Taster 2
const byte ledOut = A3; // Pin für Alarmausgang
// Variablen
int distance = 10; // Variable für die Distanz pro Tasterdruck des Zeit Wertes
//int settTime = 300, // Variable für die Timerfunktion Grundeinstellung
int runTime = 0; // Variable für die Timerfunktion Ablaufzeit
int settTime; // Variable EEprom Wert
int addEEprom = 0; // Variable SpeicherAdresse EEprom
int switchUpStatus = 0; // Variable zum speichern des Tasterstatus
int switchDownStatus = 0; // Variable zum speichern des Tasterstatus
void setup() {
// Setup des Displays:
display.setBrightness(0xb2); // set the diplay to (ca.70% 0xb2) (maximum 0xff) brightness
// Testweise 3mal alle Segmente kurz anzeigen:
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
EEPROM.put(addEEprom, settTime); // schreibt (updated) den Wert "settTime" in Speicherstelle "addEEprom"
Serial.begin(9600); // Setzt die Baudrate für die Ausgabe am Serial Monitor auf 9600
Serial.print("EEpromAdresse: "); Serial.print(addEEprom); // alles anzeigen
Serial.print("\t"); Serial.print("EEpromWert: "); Serial.print(settTime); Serial.println();
Serial.print("Grundeinstellung-Zeit/in Sek.: "); Serial.println(settTime); Serial.print(" \t\n");
Serial.print("Schrittweite 10Sek.: einstellbar von 10 bis 600 "); Serial.print(" \t\n");
pinMode(alarmIn, INPUT_PULLUP); // Setzt den Pin des alarmIn als Eingang mit Pullup-Widerstand
pinMode(switchUpPin, INPUT_PULLUP); // Setzt den Pin des switchUp als Eingang mit Pullup-Widerstand
pinMode(switchDownPin, INPUT_PULLUP); // Setzt den Pin des switchDown als Eingang mit Pullup-Widerstand
pinMode(ledOut, OUTPUT); // Setzt den Pin des Led-Relais als Ausgang
}
void loop () {
timer();
settingTimer();
}
void timer() {
static uint32_t previousMillis = 0;
if (digitalRead(alarmIn) == LOW) // mit Taster gegen GND
//if (digitalRead(alarmIn) == HIGH) // tatsächlicher AlarmIn (+3,3V=)
{
digitalWrite(ledOut, HIGH); //LOW-Level Trigger
//digitalWrite(ledOut, LOW); //HIGH-Level Trigger
previousMillis = millis();
}
if (millis() - previousMillis >= settTime * 1000UL && digitalRead(ledOut) == HIGH)
{
digitalWrite(ledOut, LOW); //LOW-Level Trigger
//digitalWrite(ledOut, HIGH); //HIGH-Level Trigger
}
if (digitalRead(ledOut) && (settTime - ((millis() - previousMillis) / 1000) != runTime))
{
runTime = settTime - ((millis() - previousMillis) / 1000);
Serial.print("(millis() - previousMillis) / 1000: "); Serial.print((millis() - previousMillis) / 1000);
Serial.print("\trunTime: "); Serial.println(runTime);
}
if (digitalRead(ledOut) == LOW) {
display.showNumberDec(settTime, false); //LOW-Level Trigger // Darstellung der eingestellten setTime in Sekunden
}
if (digitalRead(ledOut) == HIGH) {
display.showNumberDec(runTime, false); //LOW-Level Trigger // Darstellung der runTime (AblaufZeit) nach alarmIn, in Sekunden
}
}
void settingTimer()
{
const uint32_t bouncetime = 100;
static uint32_t lastmillis = 0;
bool switchUpStatus = false;
bool switchDownStatus = false;
if (millis() - lastmillis > bouncetime)
{
// Wenn Taster Up gedrückt wird, dass der Wert um die "Schrittweite" erhöht wird
if (!digitalRead(switchUpPin)) // TasterPinUp lesen und Status speichern
{
settTime = settTime + distance;
lastmillis = millis();
switchUpStatus = true;
}
// Wenn Taster Down gedrückt wird, dass der Wert um die "Schrittweite" gesenken wird
else if (!digitalRead(switchDownPin)) // TasterPinDown lesen und Status speichern
{
settTime = settTime - distance;
lastmillis = millis();
switchDownStatus = true;
}
}
// Die ausgegebene alarmTime wird auf den Bereich zwischen 10 bis 600 Sekunden begrenzt
if (settTime > 600)
{
settTime = 600;
}
else if (settTime < 10)
{
settTime = 10;
}
// einmalige Ausgabe
if (switchUpStatus || switchDownStatus)
{
Serial.print("Aktuell eingestellte Zeit: "); Serial.println(settTime);
switchUpStatus = false;
switchDownStatus = false;
}
}
...also, nun hab ich es mal getestet...
wie schon vermutet - läuft natürlich nicht so einfach... 
das Programm startet nach dem boot mit dem Einstellwert 10, da dies der niedrigste mögliche Wert ist. Wenn ich mir Up/Down etwas ändere wird der neue Wert aber nicht in EEprom übernommen!
Ratlosigkeit macht sich breit!!!
Nun, du schreibst genau einmal im setup() einen Wert ins EEPROM und zwar eine 0.
An der Stelle müsstest du eigentlich den Initialwert für settTime lesen. Sollte das -1 sein hast du noch nie geschrieben.
Wenn Du den Wert geändert hast solltest du den neuen Wert dann schreiben - wenn er sich geändert hat.
Die Zeile:
EEPROM.put(addEEprom, settTime); // schreibt (updated) den Wert "settTime" in Speicherstelle "addEEprom"macht nicht was Du willst - Der Kommentar löst das glücklicherweise auf. Dafür gibts nen Pluspunkt.
Bei jedem Neustart willst Du ein Update durchführen - das ist falsch.
Zwischenruf:
Deine Wartezeit ist ein int? Warum?
Du sollst Dein EEprom nur einmal im setup() beschreiben, wenn auf der Speicherzelle noch kein Wert enthalten ist. - also einmalig abfragen siehe @wno158 und dann sofort reinschreiben.
Davon abgesehen, das Dein void settingTimer() noch etwas aufgefrischt werden kann...
Am Ende
switchDownStatus = false;
}
// HIER wird verglichen, ob der Wert im EEprom != von settTime ist - Dann schreibe in das eeprom...
}erst mal guten Morgen...
also du meinst der Typ int ist hier falsch? Welcher Typ wäre deiner Meinung nach richtiger?
Ich steh da gerade auf dem Schlauch 
...also muss ich im setup grundsätzlich eine Wert schreiben? ...anfänglich steht hier dann sicherlich 0, aber sobald ich eine Einstellung vornehme, soll der neue Wert "updated" werden.
Ist heute Morgen noch etwas hoch ...
kannst du das mal in eine Code schreiben, dass ich die Schreibweise sehen kann und vielleicht verstehe was ich falsch mache?
du meinst die Stelle, zwischen
void settingTimer()
{
const uint32_t bouncetime = 100;
static uint32_t lastmillis = 0;
bool switchUpStatus = false;
bool switchDownStatus = false;
und - // hier soll dann der EEprom-Wert mit settTime verglichen werden?
if (millis() - lastmillis > bouncetime)
{
// Wenn Taster Up gedrückt wird, dass der Wert um die "Schrittweite" erhöht wird
if (!digitalRead(switchUpPin)) // TasterPinUp lesen und Status speichern
{
settTime = settTime + distance;
lastmillis = millis();
switchUpStatus = true;
}
// Wenn Taster Down gedrückt wird, dass der Wert um die "Schrittweite" gesenken wird
else if (!digitalRead(switchDownPin)) // TasterPinDown lesen und Status speichern
{
settTime = settTime - distance;
lastmillis = millis();
switchDownStatus = true;
}
}
ich sehe schon, dass mir noch einiges an Grundlagen fehlt und immer wieder an solchen Stellen hängen bleibe...
...wenn ich eine Code sehe, verstehe ich meistens was hier gemacht wird und passiert, aber aus der Aufgabe einen schreiben, tue ich mir noch richtig schwer...
Vielleicht kannst du mich ja hier ein wenig unterstützen, vor allem nicht nur den Code sondern auch warum es dann so geschrieben sein soll/muss...
Erstmal herzlichen Dank ich werde mal versuchen ein paar Dinge nachzulesen, um wenigstens ein kleines Schrittchen weiter zu kommen... 
Zum Nachlesen empfehle ich den EEPROM-Teil aus der Referenz (get und put) und die zugehörigen Beispiele aus der IDE.
Hier eine kleine Anregung - ist immer noch nicht schön, weil bei jedem Tick um +/-10 der Wert im EEPROM aktualisiert wird. Außerdem ist - falls das EEPROM schon mal benutzt wurde - auch ein zufällig vorhandener "krummer" Wert (z.B. 17) gültig und würde weiter verwendet.
...
// unsigned weil nur Werte von 10 bis 600 vorkommen sollen
// 16 bit breit, weil Werte oberhalb von 256, aber unter 65535 erwartet werden
uint16_t settTime;
// letzter im EEPROM abgespeicherter Wert
uint16_t lastSettTime;
// Adresse const weil die sich nicht ändert soll
const int addEEprom = 0;
...
void setup() {
...
EEPROM.get(addEEprom, lastSettTime); // lese letzten gespeicherten Wert aus dem EEPROM
// Bereichsbegrenzung wie unten beim Verändern des Werts
// hier wäre dann auch das Begradigen auf glatte 10er sinnvoll
if ((lastSettTime < 10) || (lastSettTime > 600))
{
// Dieser Teil sollte nur genau einmal durchlaufen werden wenn
// noch nie ins EEPROM an die Adresse für settTime geschrieben wurde
lastSettTime = 10;
// geänderten Wert schreiben
EEPROM.put(addEEprom, lastSettTime);
}
// gelesenen bzw. gerade eben neu erzeugten Wert verwenden
settTime = lastSettTime;
...
}
void settingTimer()
{
...
// einmalige Ausgabe
if (switchUpStatus || switchDownStatus)
{
Serial.print("Aktuell eingestellte Zeit: "); Serial.println(settTime);
switchUpStatus = false;
switchDownStatus = false;
}
// neuen Wert ins EEPROM schreiben wenn er sich geändert hat
if (settTime != lastSettTime)
{
EEPROM.put(addEEprom, settTime);
lastSettTime = settTime;
}
}
Gruß Walter
...hatte ich schon gelesen, aber nicht so ganz verstanden... die Beispiele in der IDE muss ich noch anschauen. Allerdings habe ich gerade nochmals die Reference nach Eeprom.put und .get durchsucht... .get ist leider nicht zu finden, obwohl ich am Forum schon gestern diese an anderer Stelle gelesen hatte. weis du warum das so ist? "fehlt das was in der Reference?"
ok, Datentyp ist klar und zusätzliche Variable macht natürlich Sinn.
auch die konstante Adresse ist verständlich.
Die Änderungen in "void setup" und "void settingTimer" werde ich nachher mal einbauen und testen was passiert.
dies verstehe ich noch nicht so ganz... wann sollte ich den den Wert ins EEprom speichern...
es geht doch nur der Zeitpunkt, wenn der Wert verändert wird... ich kann doch nicht wissen, wann z.B. Stromausfall ist und sollte den Wert zuvor gespeichert haben... oder gibt es da einen Trick?
Danke dir erst mal für die große Hilfe
Gruß Max
Die Referenz für get findet sich hier:
Mit dem Tick meine ich: Wenn du von 10 meinetwegen auf 60 hochstellst hast du ja fünf Änderungen, die alle einzeln gespeichert würden. Eigentlich ist aber dieser Einstellvorgang erst bei 60 beendet. Dies zu erkennen kommt aber in Deinem Code noch nicht vor. Ich war zu faul, das noch zu erfinden 
klar! darüber hatte ich mir auch schon Gedanken gemacht, da die 100.000ter-Grenze gegeben ist und zwischen 600 und 10 immer hin 60 Speicherungen liegen, obwohl ggf. nur eine oder zwei nötig sind.
Nebenbei hab ich die anderen Variablen auch noch auf uint16_t geändert, weil hier immer positive Ganzzahlen zwischen 10 und 600 stehen können.
Ist doch richtig?
bei der Variable distance würde vermutlich sogar ein (byte) uint8_t ausreichen?
// Variablen // unsigned weil nur Werte von 10 bis 600 vorkommen sollen
// 16 bit breit, weil Werte oberhalb von 256, aber unter 65535 erwartet werden
uint16_t distance = 10; // Variable für die Distanz pro Tasterdruck des Zeit Wertes
//uint16_t settTime = 300, // Variable für die Timerfunktion Grundeinstellung
uint16_t runTime = 0; // Variable für die Timerfunktion Ablaufzeit
uint16_t settTime; // Variable EEprom Wert
uint16_t lastSettTime; // Variable letzter im EEPROM abgespeicherter Wert
const int addEEprom = 0; // Variable SpeicherAdresse EEprom
beim Einstellen der Zeitwerte könnte ich mir vorstellen, dass man das mit einer Wartezeit (delay) ggf. realisieren kann... oder wie hattest du gedacht?
Gruß Max
"Wartezeit" ja, "delay" nein.
Also x Millisekunden nach der letzten Änderung ins EEPROM schreiben. Wenn man bei jeder Änderung eine Variable mit millis() aktualisiert, kann man an anderer Stelle überprüfen, ob die Differenz zwischen millis() und der Variablen größer als x Millisekunden ist, dann aktualisiert man das EEPROM. Zusätzlich benötigt man noch einen Merker, ob aktualisiert werden soll.
...upsss, genau so kompliziert hab ich mir das nun gewünscht... hab zwar soweit verstanden, was du meinst, aber ich glaube dass ich dieser Aufgabe nicht gewachsen bin...
Der zusätzlichen Merker ist mir unklar, warum ich den brauche...?
Wenn ich ein Programm sehen würde, könnte ich mein Glück versuchen
...na das ist ja nicht das Problem... die aktuellste Version
/*
Arduino Nano V3
AlarmTasterTimer für LED Steuerung
per Tastendruck einen vordefinierten ZeitWert(distance 10)erhöhen oder senken.
mit Display 4-Digit / Einstellung von 10 bis 600 Sekunden.
*/
#include <TM1637Display.h> // Lib für Display einbinden
#include <EEPROM.h> // Lib für EEprom einbinden
// PINs des Displays:
const int CLK = 6; //Set the CLK pin connection to the display
const int DIO = 7; //Set the DIO pin connection to the display
// Display initialisieren:
TM1637Display display(CLK, DIO); //set up the 4-Digit Display.
// Noch Display-Zustände definieren:
uint8_t all_on[] = { 0xff, 0xff, 0xff, 0xff };
uint8_t all_off[] = { 0x00, 0x00, 0x00, 0x00 };
// PINs für I/O
const byte alarmIn = A0; // Pin für AlarmIn
const byte switchUpPin = A1; // Pin für Taster 1
const byte switchDownPin = A2; // Pin für Taster 2
const byte ledOut = A3; // Pin für LedOut
// Variablen // unsigned weil nur Werte von 10 bis 600 vorkommen sollen
// 16 bit breit, weil Werte oberhalb von 256, aber unter 65535 erwartet werden
uint8_t distance = 10; // Variable für die Distanz pro Tasterdruck des Zeit Wertes
//uint16_t settTime = 300, // Variable für die Timerfunktion Grundeinstellung
uint16_t runTime = 0; // Variable für die Timerfunktion Ablaufzeit
uint16_t settTime; // Variable EEprom Wert
uint16_t lastSettTime; // Variable letzter im EEPROM abgespeicherter Wert
const int addEEprom = 0; // Variable SpeicherAdresse EEprom
uint8_t switchUpStatus = 0; // Variable zum speichern des Tasterstatus
uint8_t switchDownStatus = 0; // Variable zum speichern des Tasterstatus
void setup() {
// Setup des Displays:
display.setBrightness(0xb2); // set the diplay to (ca.70% 0xb2) (maximum 0xff) brightness
// Testweise 3mal alle Segmente kurz anzeigen:
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
display.setSegments(all_on);
delay(100);
display.setSegments(all_off);
delay(100);
EEPROM.get(addEEprom, lastSettTime); // lese letzten gespeicherten Wert aus dem EEPROM
// Bereichsbegrenzung wie unten beim Verändern des Werts
// hier wäre dann auch das Begradigen auf glatte 10er sinnvoll
if ((lastSettTime < 10) || (lastSettTime > 600))
{
// Dieser Teil sollte nur genau einmal durchlaufen werden wenn
// noch nie ins EEPROM an die Adresse für settTime geschrieben wurde
lastSettTime = 10;
// geänderten Wert schreiben
EEPROM.put(addEEprom, lastSettTime);
}
// gelesenen bzw. gerade eben neu erzeugten Wert verwenden
settTime = lastSettTime;
Serial.begin(9600); // Setzt die Baudrate für die Ausgabe am Serial Monitor auf 9600
Serial.print("EEpromAdresse: "); Serial.print(addEEprom); // alles anzeigen
Serial.print("\t"); Serial.print("EEpromWert: "); Serial.print(lastSettTime); Serial.println(); Serial.print(" \t\n");
Serial.print("Grundeinstellung-Zeit/in Sek.: "); Serial.println(settTime); Serial.print(" \t\n");
Serial.print("Schrittweite 10Sek.: einstellbar von 10 bis 600 "); Serial.print(" \t\n");
pinMode(alarmIn, INPUT_PULLUP); // Setzt den Pin des alarmIn als Eingang mit Pullup-Widerstand
pinMode(switchUpPin, INPUT_PULLUP); // Setzt den Pin des switchUp als Eingang mit Pullup-Widerstand
pinMode(switchDownPin, INPUT_PULLUP); // Setzt den Pin des switchDown als Eingang mit Pullup-Widerstand
pinMode(ledOut, OUTPUT); // Setzt den Pin des Led-Relais als Ausgang
}
void loop () {
timer();
settingTimer();
}
void timer() {
static uint32_t previousMillis = 0;
if (digitalRead(alarmIn) == LOW) // mit Taster gegen GND
//if (digitalRead(alarmIn) == HIGH) // tatsächlicher AlarmIn (+3,3V=)
{
digitalWrite(ledOut, HIGH); //LOW-Level Trigger
//digitalWrite(ledOut, LOW); //HIGH-Level Trigger
previousMillis = millis();
}
if (millis() - previousMillis >= settTime * 1000UL && digitalRead(ledOut) == HIGH)
{
digitalWrite(ledOut, LOW); //LOW-Level Trigger
//digitalWrite(ledOut, HIGH); //HIGH-Level Trigger
}
if (digitalRead(ledOut) && (settTime - ((millis() - previousMillis) / 1000) != runTime))
{
runTime = settTime - ((millis() - previousMillis) / 1000);
Serial.print("(millis() - previousMillis) / 1000: "); Serial.print((millis() - previousMillis) / 1000);
Serial.print("\trunTime: "); Serial.println(runTime);
}
if (digitalRead(ledOut) == LOW) {
display.showNumberDec(settTime, false); //LOW-Level Trigger // Darstellung der eingestellten setTime in Sekunden
}
if (digitalRead(ledOut) == HIGH) {
display.showNumberDec(runTime, false); //LOW-Level Trigger // Darstellung der runTime (AblaufZeit) nach alarmIn, in Sekunden
}
}
void settingTimer()
{
const uint32_t bouncetime = 100;
static uint32_t lastmillis = 0;
bool switchUpStatus = false;
bool switchDownStatus = false;
if (millis() - lastmillis > bouncetime)
{
// Wenn Taster Up gedrückt wird, dass der Wert um die "Schrittweite" erhöht wird
if (!digitalRead(switchUpPin)) // TasterPinUp lesen und Status speichern
{
settTime = settTime + distance;
lastmillis = millis();
switchUpStatus = true;
}
// Wenn Taster Down gedrückt wird, dass der Wert um die "Schrittweite" gesenken wird
else if (!digitalRead(switchDownPin)) // TasterPinDown lesen und Status speichern
{
settTime = settTime - distance;
lastmillis = millis();
switchDownStatus = true;
}
}
// Die ausgegebene alarmTime wird auf den Bereich zwischen 10 bis 600 Sekunden begrenzt
if (settTime > 600)
{
settTime = 600;
}
else if (settTime < 10)
{
settTime = 10;
}
// einmalige Ausgabe
if (switchUpStatus || switchDownStatus)
{
Serial.print("Aktuell eingestellte Zeit: "); Serial.println(settTime);
switchUpStatus = false;
switchDownStatus = false;
}
// neuen Wert ins EEPROM schreiben wenn er sich geändert hat
if (settTime != lastSettTime)
{
EEPROM.put(addEEprom, settTime);
lastSettTime = settTime;
}
}
P.S. @wno158
dein Vorschlag läuft perfekt, nur noch die häufige Speicherung beim Ändern des Zeitwertes muss gelöst werden.
Alternative zum Warten wäre eine zusätzliche "OK"-Taste. Wenn die betätigt wird heißt das "Eingabe fertig, bitte speichern".
Auch kompliziert: Langer Tastendruck auf eine der Einstelltasten zur Bestätigung.
...auch sehr gute Idee, wobei ich weder die Up noch die Down, lange drücken kann, da sonst die Einstellung Richtung 10 oder 600 läuft... daher wäre dann schon eine 3.te Bestätigungstaste sinnvoller... oder die Auto-Version über eine vorwählbare Zeit 5 - 10 Sek.
Ohne Anzeige, ungetestet:
#include <EEPROM.h> // Lib für EEprom einbinden
// PINs für I/O
const byte alarmIn = A0; // Pin für AlarmIn
const byte switchUpPin = A1; // Pin für Taster 1
const byte switchDownPin = A2; // Pin für Taster 2
const byte ledOut = A3; // Pin für LedOut
// Variablen // unsigned weil nur Werte von 10 bis 600 vorkommen sollen
// 16 bit breit, weil Werte oberhalb von 256, aber unter 65535 erwartet werden
uint8_t distance = 10; // Variable für die Distanz pro Tasterdruck des Zeit Wertes
//uint16_t settTime = 300, // Variable für die Timerfunktion Grundeinstellung
uint16_t runTime = 0; // Variable für die Timerfunktion Ablaufzeit
uint16_t settTime; // Variable EEprom Wert
uint16_t lastSettTime; // Variable letzter im EEPROM abgespeicherter Wert
const int addEEprom = 0; // Variable SpeicherAdresse EEprom
uint8_t switchUpStatus = 0; // Variable zum speichern des Tasterstatus
uint8_t switchDownStatus = 0; // Variable zum speichern des Tasterstatus
void setup() {
EEPROM.get(addEEprom, lastSettTime); // lese letzten gespeicherten Wert aus dem EEPROM
// Bereichsbegrenzung wie unten beim Verändern des Werts
// hier wäre dann auch das Begradigen auf glatte 10er sinnvoll
if ((lastSettTime < 10) || (lastSettTime > 600))
{
// Dieser Teil sollte nur genau einmal durchlaufen werden wenn
// noch nie ins EEPROM an die Adresse für settTime geschrieben wurde
lastSettTime = 10;
// geänderten Wert schreiben
EEPROM.put(addEEprom, lastSettTime);
}
// gelesenen bzw. gerade eben neu erzeugten Wert verwenden
settTime = lastSettTime;
Serial.begin(9600); // Setzt die Baudrate für die Ausgabe am Serial Monitor auf 9600
Serial.print("EEpromAdresse: "); Serial.print(addEEprom); // alles anzeigen
Serial.print("\t"); Serial.print("EEpromWert: "); Serial.print(lastSettTime); Serial.println(); Serial.print(" \t\n");
Serial.print("Grundeinstellung-Zeit/in Sek.: "); Serial.println(settTime); Serial.print(" \t\n");
Serial.print("Schrittweite 10Sek.: einstellbar von 10 bis 600 "); Serial.print(" \t\n");
pinMode(alarmIn, INPUT_PULLUP); // Setzt den Pin des alarmIn als Eingang mit Pullup-Widerstand
pinMode(switchUpPin, INPUT_PULLUP); // Setzt den Pin des switchUp als Eingang mit Pullup-Widerstand
pinMode(switchDownPin, INPUT_PULLUP); // Setzt den Pin des switchDown als Eingang mit Pullup-Widerstand
pinMode(ledOut, OUTPUT); // Setzt den Pin des Led-Relais als Ausgang
}
void loop () {
timer();
settingTimer();
}
void timer() {
static uint32_t previousMillis = 0;
if (digitalRead(alarmIn) == LOW) // mit Taster gegen GND
//if (digitalRead(alarmIn) == HIGH) // tatsächlicher AlarmIn (+3,3V=)
{
digitalWrite(ledOut, HIGH); //LOW-Level Trigger
//digitalWrite(ledOut, LOW); //HIGH-Level Trigger
previousMillis = millis();
}
if (millis() - previousMillis >= settTime * 1000UL && digitalRead(ledOut) == HIGH)
{
digitalWrite(ledOut, LOW); //LOW-Level Trigger
//digitalWrite(ledOut, HIGH); //HIGH-Level Trigger
}
if (digitalRead(ledOut) && (settTime - ((millis() - previousMillis) / 1000) != runTime))
{
runTime = settTime - ((millis() - previousMillis) / 1000);
Serial.print("(millis() - previousMillis) / 1000: "); Serial.print((millis() - previousMillis) / 1000);
Serial.print("\trunTime: "); Serial.println(runTime);
}
}
void settingTimer()
{
const uint32_t bouncetime = 100;
const uint32_t updatetime = 5000;
static uint32_t lastmillis = 0;
bool switchUpStatus = false;
bool switchDownStatus = false;
if (millis() - lastmillis > bouncetime)
{
// Wenn Taster Up gedrückt wird, dass der Wert um die "Schrittweite" erhöht wird
if (!digitalRead(switchUpPin)) // TasterPinUp lesen und Status speichern
{
settTime = settTime + distance;
lastmillis = millis();
switchUpStatus = true;
}
// Wenn Taster Down gedrückt wird, dass der Wert um die "Schrittweite" gesenken wird
else if (!digitalRead(switchDownPin)) // TasterPinDown lesen und Status speichern
{
settTime = settTime - distance;
lastmillis = millis();
switchDownStatus = true;
}
}
// Die ausgegebene alarmTime wird auf den Bereich zwischen 10 bis 600 Sekunden begrenzt
if (settTime > 600)
{
settTime = 600;
}
else if (settTime < 10)
{
settTime = 10;
}
// einmalige Ausgabe
if (switchUpStatus || switchDownStatus)
{
Serial.print("Aktuell eingestellte Zeit: "); Serial.println(settTime);
switchUpStatus = false;
switchDownStatus = false;
}
// neuen Wert ins EEPROM schreiben wenn er sich geändert hat
if ( (millis() - lastmillis > updatetime) && (settTime != lastSettTime) )
{
EEPROM.put(addEEprom, settTime);
lastSettTime = settTime;
Serial.print("Im EEPROM aktualisierte Zeit: "); Serial.println(settTime);
}
}
...Wirklich Geile Sache!!!
agmue, es funktioniert --- sogar mit der Anzeige...
Ich bin absolut Happy... endlich kann ich die Platine voll fertigstellen und einbauen...
...kleine Schönheitssache wäre da noch!
da ich ja im eingebauten Zustand keinen SM mehr habe und gerne irgendwo sehen würde, wann die updatetime abgelaufen ist und der EEprom updated wurde, könnte man doch den Doppelpunkt oder auch am ersten Digit ein "S" am TM1637 für die 5sek blinken oder auch nur leuchten lassen??? (Speichermodus)???
Meinst du das ist realisierbar???
...auch noch eine ganz andere Frage:
kann ich am EEprom auslesen, wie oft er schon beschrieben wurde...in diesem Fall nun die Addresse 0 ?
Gruß Max
Ja.
Nein, Du könntest aber mitzählen und bei mehr als x zur nächsten Speicherstelle wechseln.
ok, auch eine Idee...das heißt nach 100.000 auf Adresse 1 usw...
der Nano V3 hat 255 Adressen? also wären das 255 x 100.000 Updates?