Zähler auf ab

Michel Gast #3010950
Lesenswert?
• ▲
▼ 
ich habe mal eine Frage und zwar möchte ich eine Begrenzung beim 
aufwärts und Abwärts Zählen aber das haut nich so hin wie ichs mir 
vorstelle.

Beim Aufwärts Zählen in der Begrenzung ist der Wert mal 23 mal 24

Beim Runter Zählen in der Begrenzung wenn der Wert 0 erreicht hat
und es wird weiter runter gezählt gehts dann von 255 abwärts.

vielleicht könnte mir einer weiterhelfen.
1
 hour ++;                           // um eine Stunde erhöhen

2
   if (hour > 24)                   // wenn Überlauf

3
   {

4
    hour = 23;                      // Stunde auf 23 setzen

5
   }

6


7
***************************************

8
  hour --;                          // um eine Stunde verringern

9
    if (hour < 1)                   // wenn Überlauf

10
    {

11
     hour = 0;                      // Stunde auf 0 setzen

12
    }
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Michel Gast #3010989
Lesenswert?
• ▲
▼ 
Es läuft erstma nur in einer Endlos schleife

1
for (;;)

2
{

3


4
   if ( get_key_short( 1<<taste1 )){

5
        hour ++;                           // um eine Stunde erhöhen

6
        if (hour > 24)                     // wenn Überlauf

7
         {

8
           hour = 23;                      // Stunde auf 23 setzen

9
         }

10
   }

11


12
   if ( get_key_short( 1<<taste2 )){

13
        hour --;                          // um eine Stunde verringern

14
        if (hour < 1)                     // wenn Überlauf

15
         {

16
           hour = 0;                      // Stunde auf 0 setzen

17
         }    

18
   }

19


20
lcd_time(10,10,hour);                     // Ausgabe Stunde

21
 }

22
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Karl H. #3011130
Lesenswert?
• ▲
▼ 
Michel schrieb:

Um auf die Ursprungsfrage zurückzukommen:
Setz einfach mal in Gedanken konkrete Zahlen ein


Nimm mal an, hour wäre 23

>         hour ++;                           // um eine Stunde erhöhen

Jetzt ist es 24

>         if (hour > 24)                     // wenn Überlauf

Ist 24 größer als 24?
Nein. Also passiert das hier
>          {
>            hour = 23;                      // Stunde auf 23 setzen
>          }

nicht.


Jetzt das ganze nochmal mit den inzwischen 24 in hour

>       hour ++;                           // um eine Stunde erhöhen

Jetzt ist hour 25

>        if (hour > 24)                     // wenn Überlauf

ist 25 größer als 24?
Ja. Also wird das hier
>         {
>           hour = 23;                      // Stunde auf 23 setzen
>         }

ausgeführt.

Hä? Wenn hour von 23 auf 24 erhöht wird, machst du nichts. Wenn aber 
dann hour von 24 auf 25 erhöht wird, setzt du es zurück auf 23.

Das ist nicht wirklich logisch :-)
Denn jetzt kannst du ja hour wiederrum von 23 auf 24 erhöhen .. und 
nichts weiter passiert. Bei der nächsten Erhöhung gehts dann wieder zur 
25, woraufhin du es sofort wieder auf 23 zurücksetzen lässt. Drückst du 
also dauernd auf 'Raufzählen, dann zählt hour im Endeffekt dauernd 23, 
24, 23, 24, 23, 24, 23, 24, ....


Zum andern Fall.
Nimm mal an hour wäre jetzt 1

>         hour --;                          // um eine Stunde verringern

Jetzt ist es 0

>         if (hour < 1)                     // wenn Überlauf

Ist das der Fall? Ist 0 kleiner als 1?
Ja, das ist es. Also wird das hier
>          {
>            hour = 0;                      // Stunde auf 0 setzen
>          }
ausgeführt und hour auf 0 gesetzt. hour war zwar schon 0, aber was 
solls. Doppelt hält besser.

Denn jetzt wird es trickreich. Da hour bei dir offenbar eine unsigned 
Variable ist, kann sie per Definition nie negativ werden.
Also: hour sei 0

>       hour --;                          // um eine Stunde verringern

Welchen Wert hat hour jetzt?
Nein, nicht -1. hour kann nicht negativ werden! Es erfolgt ein Unterlauf 
und hour ist jetzt 255, weil es eine unsigned Variable mit 8 Bit ist. 
Die nächst 'größere' Zahl nach 255 ist die 0, und die nächst 'kleinere' 
Zahl vor der 0 ist die 255. Wie bei einer Uhr. Nach der Sekunde 59 kommt 
die Sekunde 0. Und die Sekunde vor der Sekunde 0 ist die sekunde 59. Bei 
einer Uhr passiert dieser Übergang bei 60 Sekunden. Bei 8 Bit unsigned 
Variablen bei 256. Aber das Prinzip ist genau das gleiche.

>        if (hour < 1)                     // wenn Überlauf

Ist 255 kleiner als 1?
Nein, ist es nicht.
d.h. dieser Teil hier
>         {
>           hour = 0;                      // Stunde auf 0 setzen
>         }
findet nie statt.

Aber: hour ist jetzt 255. Beim nächsten mal runterzählen ist es dann 
254, 253, 252 usw. usw.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren