[gelöst] Countdown mit Operator

Hallo,
bei meinem Projekt möchte ich einen Countdown laufen lassen. Diesen möchte ich mit Operator machen.
An einer anderen Stelle im Projekt lasse ich eine Uhr bereits vorwärts laufen und das funktioniert einwandfrei.
Die Countdown Startzeit stelle ich bereits auf meinem TFT Display mit Hilfe von Buttons inkl. Start / Stop / Reset ein. Habe wegen der Einfachkeit die betreffenden Zeilen mal zusammenkopiert und gebe daher die Startzeit über den Datentyp Int vor.

// Uhr
int stunde_start = 1, minute_start = 5, sekunde_start = 30;
int stundelo = 0, minutelo = 0, sekundelo = 0;


sekundelo = (sekunde_start - (millis() / 1000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
minutelo = (minute_start - (millis() / 60000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
stundelo = (stunde_start - (millis() / 3600000) % 24);// Das Zeichen: "%" ist der Modulo-Operator


myGLCD.printNumI(stundelo, RIGHT - 262, 150, 2, '0');
myGLCD.print(":", RIGHT - 230, 150);
myGLCD.printNumI(minutelo, RIGHT - 214, 150, 2, '0');
myGLCD.print(":", RIGHT - 182, 150);
myGLCD.printNumI(sekundelo, RIGHT - 166, 150, 2, '0');

Im Prinzip würde er bei 23h 59min 59sek korrekt runterzählen, jedoch zählt er von den vorgegebenen 30sek durch den Operator 60sek nach unten. Das bedeutet wiederum, das er bis -30 zählt, bevor die Minuten eins runtergeht.

Wie könnte die Lösung aussehen??

Danke

Hallo,

ich habe Dein Problem noch nicht erkannt, würde das aber anders machen.

Du gibst Deine countdown zeit in stunden, minuten, sekunden ein. Die rechnest Du in Sekunden um, das ist dann dein eigendlicher countdown Zähler,den Du mit einem Sekundentakt aus millis() gebildet runter zählst.

Zur Anzeige rechnest Du den aktuellen Zählerstand wieder in werte für Stunden, Minuten , Sekunden um das geht mit modulo recht einfach.

Heinz

codeschnipsel

uint32_t counter 
...
...

// umrechnen 
byte h = (counter / 3600UL) % 24; 
byte m = (counter / 60UL) % 60;
byte s = counter % 60;

jedoch zählt er von den vorgegebenen 30sek durch den Operator 60sek nach unten. Das bedeutet wiederum, das er bis -30 zählt

Ich nehme einfach mal an, wenn ich das nicht verstehe, ist es dein Problem :slight_smile:
Auch weiß ich nicht genau, was du mit Operator meinst…

Du willst doch sicher jede Sekunde deines Countdowns anzeigen?
Dann würdest du doch schon merken, wenn du von 0 eins subtrahierst, und da sinnvollerweise den Minuten-Überlauf machen?

Wobei Rentners Vorschlag natürlich einfacher=besser ist.

Der Fehler steckt m. E. im fehlenden Übertrag von Stunde zu Minute zu Sekunde. Nur mal zum Verständnis:

int stunde_start = 1, minute_start = 5, sekunde_start = 30;

void setup() {
  Serial.begin(115200);
  Serial.println(F("Los geht's"));
}

void loop() {
  // Uhr
  uint32_t jetzt = millis();
  if (jetzt % 1000 == 0) {
    int sekundelo = (sekunde_start - (jetzt / 1000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
    int minutelo = (minute_start - (jetzt / 60000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
    int stundelo = (stunde_start - (jetzt / 3600000) % 24);// Das Zeichen: "%" ist der Modulo-Operator

    Serial.print(stundelo); Serial.print('\t');
    Serial.print(minutelo); Serial.print('\t');
    Serial.print(sekundelo); Serial.print('\t');
    Serial.print(jetzt); Serial.print('\n');
    if (minutelo == 0) {
      minute_start += 60;
      stunde_start--;
    }
    if (sekundelo == 0) {
      sekunde_start += 60;
      minute_start--;
    }
    delay(900);
  }
}

Die Lösung von Heinz in #1 ist aber vorzuziehen.

EDIT: Das Programm läuft leider in dieselbe Falle!

Danke Euch für die Antworten. Werde heute Nacht mal versuchen es umzusetzen.
Zu einer Eieruhr/Stopuhr gibt es ja Unmengen von Beispielen. Habe darin nichts brauchbares (für mich) gefunden.

agmue:
Der Fehler steckt m. E. im fehlenden Übertrag von Stunde zu Minute zu Sekunde. Nur mal zum Verständnis:

int stunde_start = 1, minute_start = 5, sekunde_start = 30;

void setup() {
 Serial.begin(115200);
 Serial.println(F(“Los geht’s”));
}

void loop() {
 // Uhr
 uint32_t jetzt = millis();
 if (jetzt % 1000 == 0) {
   int sekundelo = (sekunde_start - (jetzt / 1000) % 60);// Das Zeichen: “%” ist der Modulo-Operator
   int minutelo = (minute_start - (jetzt / 60000) % 60);// Das Zeichen: “%” ist der Modulo-Operator
   int stundelo = (stunde_start - (jetzt / 3600000) % 24);// Das Zeichen: “%” ist der Modulo-Operator

Serial.print(stundelo); Serial.print(’\t’);
   Serial.print(minutelo); Serial.print(’\t’);
   Serial.print(sekundelo); Serial.print(’\t’);
   Serial.print(jetzt); Serial.print(’\n’);
   if (minutelo == 0) {
     minute_start += 60;
     stunde_start–;
   }
   if (sekundelo == 0) {
     sekunde_start += 60;
     minute_start–;
   }
   delay(900);
 }
}



Die Lösung von Heinz in #1 ist aber vorzuziehen.

Habe den Code 1:1 laufen lassen und mir auf dem seriellen Monitor angeschaut. Du hast im Prinzip das gleiche Problem wie ich vorher schon hatte, nur an einer anderen Stelle. Nach 01 : 04 : 31 springt er auf 01 : 03 : 90.
Das passiert jedesmal, wenn er von 31 auf 30 sek runterzählen will.

babba110:
Danke Euch für die Antworten. Werde heute Nacht mal versuchen es umzusetzen.
Zu einer Eieruhr/Stopuhr gibt es ja Unmengen von Beispielen. Habe darin nichts brauchbares (für mich) gefunden.

Wiso Eieruhr ist doch genau das was Du willst, oder hab ich was falsch verstanden. Es könnte natürlich sein das das mit Deinem "operator" zusammen hängt. "opeator" engl. Bediener :wink: . Aber Du hast uns ja nicht verraten was Du damit meinst.

Heinz

Die “_start” - Zeit wird nachträglich verändert. Aber nicht regelmäßig, sondern nur bei Überläufen.

Das macht es mir sehr schwer, den Sinn zu verstehen.

Und wenn es für mich zu schwer zu verstehen ist, ist es falsch. Weiter brauch ich dann gar nicht zu überlegen.

Wenn du unbedingt in der Nähe deiner Lösung bleiben willst, verändere doch

int stunde_start = 1, minute_start = 5, sekunde_start = 30;

jede Sekunde. Wäre dann die Rest-Zeit, nicht die Start-Zeit.

void loop() {
  // Uhr
  if (stunde_start < 0) { fertig(); return; }
  uint32_t jetzt = millis();
  if (jetzt % 1000 == 0) {
    sekunde_start --;
    if (sekude_start < 0) {
       sekunde_start = 59;
       minute_start --;
    } 
    if (minute_start < 0) {
      minute_start =59;
      stunde_start --;
    }
    if (stunde_start >= 0) 
       display(stunde_start, minute_start, sekunde_start);

    delay(990);
  } // auf nächsten Sekundenwechsel warten
}

Ich verstehe da einiges! (nicht)

Grundsätzlich würde ich da 2 Repräsentation der Daten unterscheiden.

  1. Die interne, die mit der gerechnet wird
  2. Die externe, das was der Betrachter zu sehen bekommt.

Der Grund:
Was interessiert den interne Ablauf, die Minuten und Stunden?
Gar nicht!
Die Zeit marschiert linear von Anfang, bis Ende.

Klar, der Betrachter möchte auch mal Minuten usw. sehen… darf er ja auch …
Aber das heißt doch nicht, dass die Uhr auch intern damit rechnen/vergleichen muss.

int stunde_start = 1, minute_start = 5, sekunde_start = 30;

Das würde bei mir irgendwie so aussehen:

Millis interval {1_hr + 5_min + 30_sec};

babba110:
möchte ich einen Countdown laufen lassen.

// Uhr

int stunde_start = 1, minute_start = 5, sekunde_start = 30;
int stundelo = 0, minutelo = 0, sekundelo = 0;

sekundelo = (sekunde_start - (millis() / 1000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
minutelo = (minute_start - (millis() / 60000) % 60);// Das Zeichen: "%" ist der Modulo-Operator
stundelo = (stunde_start - (millis() / 3600000) % 24);// Das Zeichen: "%" ist der Modulo-Operator




Das bedeutet wiederum, das er bis -30 zählt, bevor die Minuten eins runtergeht.

Wie könnte die Lösung aussehen??

Wenn Du keine negativen Zahlen erwartest, unsigned.
Der Codeschnipsel fragt wiederholt millis() ab, was dazu führt, das die Berechnung von sekundelo auf einer anderen Basis als minutelo und die auf einer anderen Basis als stundelo

Du kommst um eine Variable nicht rum.
Ich hab Dir was zusammengebaut.

// Forumsketch https://forum.arduino.cc/index.php?topic=717416.msg4821667#msg4821667
// Countdown 
unsigned int stunde_start = 1, minute_start = 5, sekunde_start = 30;
unsigned int stundelo = 0, minutelo = 0, sekundelo = 0;
long counter; // der soll ins Minus gehen daher kein Unsigned
void setup()
{
  Serial.begin(115200);
  // erstmal prüfen, ob das überhaupt so geht
  if ((stunde_start > 23) || (minute_start > 59) || (sekunde_start > 59))
  {
    Serial.println(F("ABBRUCH - Wertüberlauf!"));
    while(1);
  }
  counter = (stunde_start *3600L + minute_start * 60 + sekunde_start); // das L wird gebraucht, weil sonst im int gerechnet wird.
}
void loop()
{
  if (!(millis() % 10)) // damit es schneller geht ;)
  {
    if (counter >= 0)
    {
      sekundelo = (counter % 60);
      minutelo = ((counter % 3600) / 60);
      stundelo = (counter / 3600);
      Serial.print(stundelo);
      Serial.print(F(" : "));
      Serial.print(minutelo);
      Serial.print(F(" : "));
      Serial.println(sekundelo);      delay(10);
      counter--;
    }
    else
    {
      Serial.println(counter);
    }
  }
}

Habe mir nun was zusammengebastelt. Die Hauptsache dabei ist, es funktioniert. Wie schon am Anfang geschrieben, es ist/war ein Auszug aus einem langen Teil. Hier mal ein größerer Schnipsel. Ich muss es noch auskommentieren und etwas aufräumen. Ich habe alles in Sekunden gerechnet, wie mir auch vorgeschlagen wurde.
Auf meinem TFT sind oben die Buttons für START STOP und RESET. Darunter befindet sich eine voreingestellte Zeit, die ich mit 2 weiterem Buttons um je 5 Sekunden anheben bzw reduzieren kann. Darunter befindet sich die Restcountdownzeit. Ich kann mit den Buttons START und STOP anhalten und neu starten, sowie mit Reset die Zeit auf den ursprünglichen Wert zurücksetzen. Desweiteren springt die Contdownzeit nach Ablauf wieder auf die eingestellte Zeit und wartet auf auf ein Button.

// Futterpause
int Start_Futterpause_sekunde_gesamt = 90;
int var_Futterpause = 0;
int var_Futterpause_Aufloesung;

int Soll_Futterpause;
int Soll_Futterpause_Stunde;
int Soll_Futterpause_Minute;
int Soll_Futterpause_Sekunde;

int Rest_Futterpause;
int Rest_Futterpause_Stunde;
int Rest_Futterpause_Minute;
int Rest_Futterpause_Sekunde;

int Futterpause_start = 0;
int Futterpause_stop = 1;
int Futterpause_reset = 0;
int counter_Futterpause;

long previousMillis = 0;
unsigned long currentMillis;
long interval = 1;


void Futterpause(unsigned int Futterpause) {
  // Kopfzeile welches Menu
  const char aktuelles_Menu[] = "Futterpause";
  // Zusatzbutton fuer Ruecksprung ins Hauptmenu und aktuell geklickter Button
  unsigned int main_but99, main_but98, m_press_4;

  do {
    Menustatus = 1;
    if (Menustatus == HIGH) var_Menustatus++;
    // Buttons des Hauptmenu loeschen
    myButtons.deleteAllButtons();
    myGLCD.clrScr(); // LCD leeren

    //Text welches Menu
    myGLCD.setColor(VGA_WHITE);
    myGLCD.setFont(SmallFont);
    myGLCD.print(aktuelles_Menu, LEFT + 10, 10);

    // Je nach Auswahl Submenu neue Buttons setzen
    main_but1 = myButtons.addButton(LEFT + 10, 25, 90, 30, "Start");
    main_but2 = myButtons.addButton(LEFT + 115, 25, 90, 30, "Stop");
    main_but3 = myButtons.addButton(LEFT + 220, 25, 90, 30, "Reset");
    main_but4 = myButtons.addButton(50, 83, 30, 30, "<");
    main_but5 = myButtons.addButton(240, 83, 30, 30, ">");

    // Zurueck-Button setzen
    main_but99 = myButtons.addButton (LEFT + 185, 200, 125, 30, "zurueck");


    // Buttons anzeigen
    myButtons.drawButtons();

    // Warte auf Button und prüfe
    while (!myTouch.dataAvailable()) {

      var_Futterpause_Aufloesung = var_Futterpause * 5;
      Soll_Futterpause = Start_Futterpause_sekunde_gesamt + var_Futterpause_Aufloesung;
      Soll_Futterpause_Stunde = (Soll_Futterpause / 3600UL) % 24;
      Soll_Futterpause_Minute = (Soll_Futterpause / 60UL) % 60;
      Soll_Futterpause_Sekunde = Soll_Futterpause % 60;

      Rest_Futterpause = Soll_Futterpause - counter_Futterpause;
      Rest_Futterpause_Stunde = (Rest_Futterpause / 3600UL) % 24;
      Rest_Futterpause_Minute = (Rest_Futterpause / 60UL) % 60;
      Rest_Futterpause_Sekunde = Rest_Futterpause % 60;

      // Funktion Futterpause

      currentMillis = millis() / 500;

      if (Futterpause_start == 1) {
        if (Rest_Futterpause > 0) {
          if (currentMillis - previousMillis > interval) {
            previousMillis = currentMillis;
            counter_Futterpause++;
          }
        }
      }
      if (Rest_Futterpause == 0) Futterpause_reset = 1;

      if (Futterpause_reset == 1) {
        counter_Futterpause = 0; Futterpause_start = 0; Futterpause_stop = 1;
      }

      // Button für Fehlermeldung anzeigen
      if ((var_Wasser_zu_kalt + var_Wasser_zu_warm + var_pH_Wert_zu_niedrig + var_pH_Wert_zu_hoch + var_Leitwert_zu_hoch + var_Leitwert_zu_niedrig + var_Fuellstand_zu_hoch + var_Fuellstand_zu_niedrig + var_Filterleistung_zu_niedrig) > 0) Meldung_Fehler = 1;
      if ((var_Wasser_zu_kalt + var_Wasser_zu_warm + var_pH_Wert_zu_niedrig + var_pH_Wert_zu_hoch + var_Leitwert_zu_hoch + var_Leitwert_zu_niedrig + var_Fuellstand_zu_hoch + var_Fuellstand_zu_niedrig + var_Filterleistung_zu_niedrig) == 0) Meldung_Fehler = 0;

      if (((Meldung_Fehler_statisch == LOW) && (Meldung_Fehler == HIGH)) || ((var_Menustatus == HIGH) && (Meldung_Fehler == HIGH))) {
        myButtons.setButtonColors(VGA_WHITE, VGA_GRAY, VGA_WHITE, VGA_RED, VGA_RED);
        main_but98 = myButtons.addButton (LEFT + 10, 200, 125, 30, "Meldung");
        myButtons.drawButton(main_but98);
        myButtons.setButtonColors(VGA_WHITE, VGA_GRAY, VGA_WHITE, VGA_RED, VGA_BLUE);
        Meldung_Fehler_statisch = 1;
      }
      if (Meldung_Fehler_statisch == LOW) myButtons.deleteButton(main_but98);
      var_Menustatus = 0;

      // Aufruf der Funktionen zu den Submenubuttons
      if (m_press_4 == main_but1) {
        if (main_but1 = HIGH)Futterpause_start = 1, Futterpause_stop = 0, Futterpause_reset = 0;
      }
      if (m_press_4 == main_but2) {
        if (main_but2 = HIGH)Futterpause_start = 0, Futterpause_stop = 1, Futterpause_reset = 0;
      }
      if (m_press_4 == main_but3) {
        if (main_but3 = HIGH)Futterpause_start = 1, Futterpause_stop = 1, Futterpause_reset = 1;
      }
      if (m_press_4 == main_but4) {
        if (main_but4 = HIGH)
          var_Futterpause--;
      }
      if (m_press_4 == main_but5) {
        if (main_but5 = HIGH)
          var_Futterpause++;
      }

      // Text Futterpause Menu
      myGLCD.setColor(VGA_WHITE);
      myGLCD.setFont(BigFont);
      myGLCD.printNumI(Soll_Futterpause_Stunde, 104, 90, 2, '0');
      myGLCD.print(":", 132, 90);
      myGLCD.printNumI(Soll_Futterpause_Minute, 144, 90, 2, '0');
      myGLCD.print(":", 172, 90);
      myGLCD.printNumI(Soll_Futterpause_Sekunde, 184, 90, 2, '0');

      myGLCD.printNumI(Rest_Futterpause_Stunde, 104, 140, 2, '0');
      myGLCD.print(":", 132, 140);
      myGLCD.printNumI(Rest_Futterpause_Minute, 144, 140, 2, '0');
      myGLCD.print(":", 172, 140);
      myGLCD.printNumI(Rest_Futterpause_Sekunde, 184, 140, 2, '0');


      if (counter_Futterpause > 0) myGLCD.print("  Der Filter ist aus  ", CENTER, 175);
      if (counter_Futterpause == 0) myGLCD.print("  Der Filter ist an  ", CENTER, 175);
    }

    m_press_4 = myButtons.checkButtons();
    if (m_press_4 == main_but98) visuelle_Warnung(1);
  } while (m_press_4 != main_but99);

  // Buttons loeschen
  myButtons.deleteAllButtons();
  myGLCD.clrScr(); // LCD leeren
}

Das ganze gehört zu einer komplizierteren Aquariumsteuerung, wo ich mit Hilfe der “Stopuhr” den Filter und die Pumpen abschalten möchte, so das bei der Fütterung keine Strömung im Becken ist.
Wie man auch sehen kann, geht das ganze auch über mehrere Menüebenen. Ich arbeite im Programm auch über einen Interrupt, der dann Messungen ausführen soll.
Das einzige was mir nicht einleuchtet, ist die Zeile

  currentMillis = millis() / 500;

So komisch wie es sich im ersten Moment anhört, aber so komme ich auf etwa 1 Sek beim runterzählen. Mit 1000 zähle ich alle 2 Sekunden nur eine runter. Da muss ich mir nochmal Gedanken machen warum das so ist.
Danke für eure Hilfe. Ein Meister ist noch nicht vom Himmel gefallen.

Das einzige was mir nicht einleuchtet, ist die Zeile

  currentMillis = millis() / 500;

So komisch wie es sich im ersten Moment anhört, aber so komme ich auf etwa 1 Sek beim runterzählen.

Dann teste doch mal am Standard - Blink Beispiel, ob delay(1000); eine oder zwei Sekunden dauert. Und dann dasselbe mit BlinkWithoutDelay.

Man kann einen Arduino mit 8 statt 16 MHz betreiben, und an allen Ecken und Enden drüber stolpern, wenn man versucht, das durch empirische millis()/500 = 1 Sekunde zu lösen.

michael_x:
Das einzige was mir nicht einleuchtet, ist die Zeile

  currentMillis = millis() / 500;

So komisch wie es sich im ersten Moment anhört, aber so komme ich auf etwa 1 Sek beim runterzählen.

Dann teste doch mal am Standard - Blink Beispiel, ob delay(1000); eine oder zwei Sekunden dauert. Und dann dasselbe mit BlinkWithoutDelay.

Man kann einen Arduino mit 8 statt 16 MHz betreiben, und an allen Ecken und Enden drüber stolpern, wenn man versucht, das durch empirische millis()/500 = 1 Sekunde zu lösen.

Werde ich ausprobieren.
Das wird bei mir so einiges erklären...... Am Aquarium habe ich auch einen Durchflusswächter angeschlossen. Dort zähle ich die Impulse pro sek und rechne das dann in Liter pro Stunde um. Mein Filter hat eine angegebene Leistung von etwa 2000l/h. Ich messe aber nur etwa 850l/h. Denke, das ich mir dort auch ein Feld auf dem Display mache und dies blinken lasse. Vielleicht blinkt es ja auch nicht im Sekundentakt.....

Danke für die Anregung.

Ich beschäftige mich noch nicht so lang mit dem Arduino, sauge aber jeden Tag Infos und Anregungen auf.
Als nächstes kommt noch eine Füllstandsanzeige auf mein Display, danach kommt das Projet "Speicher beschreiben und auslesen" dazu. Ich möchte ja nicht meine eingestellten Werte nach jedem Neustart neu einstellen. Als letztes dann die Speicherkarte für Bilder, die ich auf dem Display anzeigen lassen möchte. Mein Weihnachtsprogramm steht :slight_smile:

DANKE

Hallo,

warum bildest Du denn den 1s Takt auf so seltsame Weise, da bekommst Du doch möglicher Weise Rundungsfehler mit rein, bin mit auch nicht sicher was beim Überlauf von millis pasiert .

kann sein das Dein controller mit der falschen Frequenz läuft. Bagger mal sowas in der Art drauf dann sollte der in einer minute auf 60 kommen.

Heinz

unsigned long altzeit;
unsigned long intervall = 1000;
int count;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  if (millis() - altzeit >= intervall) {
    altzeit = millis();
    // tut was jede sekunde genau einmal
    Serial.println(count);
    count++;
  }
}

Nachtrag

Dein controller läuft mit der richtigen Frequenz , habe deinen Sketch mal getestet , Du könntest Deine Abfage auf >= ändern. Bei > ist die Bedingung nut alle 2 s erfüllt. Darum musst Du durch 500 teilen :slight_smile:

Rentner:

  if (millis() - altzeit >= intervall) {

altzeit = millis();
    // tut was jede sekunde genau einmal

Ich habe da in Erinnerung, wer einen Timer baut, zieht sich mit dieser Lösung bei jedem Umlauf eine Ungenauigkeit addierend.

Du hast mit unsigned long intervall = 1000; eine Variable, die Du fortlaufend verändern kannst.
also bei jedem Umlauf nicht die aktuellen millis mit aufaddierendem Fehler, sondern die Zeit wann wieder die Bedingung erfülllt sein soll:

// alt:
   //  altzeit = millis();
// neu:
  intervall=intervall+1000; // Zeit in ms

Egal was sonst noch so läuft, selbst wenn aus irgendwelchen Gründen mal 1500ms irgendwo stecken bleiben, wird es irgendwann wieder annähernd “syncron”.

Hallo,

ja das ist fast richtig, bei meiner einfachen vorgeschlagenen Lösung kann ein Fehler entstehen weil zwischen der Abfrage von millis und dem setzen von altzeit eine endliche Zeit vergeht und millis derweil weiter läuft. Die Zeit , hier eine Sekunde wird also in Wirklichkeit um diese Laufzeit grösser sein. Damit ist dann jede Sekunde eigendlich ein bischen länger. Das kann insbesondere wenn ein Interrupt dazwischen funkt eine grössere Rolle spielen. Aus Diesem Grunde ist die sonst übliche Verwendung einer Hilsvariablen "aktuelleZeit" richtig. Bei der Varianten wird dann millis nur einmal abgefragt.
Wenn ich jetzt davon ausgehe das die systemfrequenz nicht von einem Quarz kommt , so what... Wer es dennoch genau haben will sollte eine Uhr einsetzen.

Deine Variante mit intervall=intervall+1000; // Zeit in ms finde ich aber auch recht seltsam. Was passiert da beim Überlauf ?

Richtig sollte das dann so sein, dabei kann meiner Meinung nach kein Fehler mehr auftreten.

unsigned long altzeit, aktuelleZeit;
unsigned long const intervall = 1000;
int count;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:
  aktuelleZeit=millis();
  if (aktuelleZeit - altzeit >= intervall) {
    altzeit = aktuelleZeit;
    // tut was jede sekunde genau einmal
    Serial.println(count);
    count++;
  }
}

Rentner:
Richtig sollte das dann so sein, dabei kann meiner Meinung nach kein Fehler mehr auftreten.

Dieser Meinung schließe ich mich an und stellt die von mir bevorzugte Variante dar!

Hallo,

wegen der "Syncronität" ich würde es so machen

  if (millis() - altzeit >= intervall) {
    altzeit = altzeit + intervall;
    ...
  {

Hierbei erhöht sich in erster Linie permanent das Intervall selbst

intervall=intervall+1000; // Zeit in ms

Hallo,

ich habe mal gerade die Variante mit intervall = intervall + 1000 probiert , allerdings habe ich um es abzukürzen , die Variable intervall als unsigned int festgelegt, aber das sollte ja egal sein. Der Scetch klappt nicht .

Ich denke das war so gemeint

SO NICHT VERWENDEN

unsigned int  intervall;
int count;
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {
  // put your main code here, to run repeatedly:

  if (millis() >= intervall) {
    intervall = intervall + 1000;
    // tut was jede sekunde genau einmal
    Serial.print(count);
    Serial.println(intervall);
    count++;
  }
}

Rentner:
ich habe mal gerade die Variante mit intervall = intervall + 1000 probiert , allerdings habe ich um es abzukürzen , die Variable intervall als unsigned int festgelegt, aber das sollte ja egal sein. Der Scetch klappt nicht .

Was kürzt man damit ab? 1 Buchstabe weniger?

Gruß Tommy