Zähler auf ab

[Michel (Gast)]

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.

 hour ++;                           // um eine Stunde erhöhen
   if (hour > 24)                   // wenn Überlauf
   {
    hour = 23;                      // Stunde auf 23 setzen
   }

***************************************
  hour --;                          // um eine Stunde verringern
    if (hour < 1)                   // wenn Überlauf
    {
     hour = 0;                      // Stunde auf 0 setzen
    }

[Peter II (Gast)]

Michel schrieb:
> vielleicht könnte mir einer weiterhelfen.

nicht wirklich weil man nicht sieht wie die beiden blöcke aufgerufen 
werden.

[Lötlackl *. (pappnase)]

Wie wäre es mit folgendem Ansatz?

if (hour < 24)
{
  hour++;
}

if (hour)
{
  hour--;
}

[Michel (Gast)]

Es läuft erstma nur in einer Endlos schleife

for (;;)
{

   if ( get_key_short( 1<<taste1 )){
        hour ++;                           // um eine Stunde erhöhen
        if (hour > 24)                     // wenn Überlauf
         {
           hour = 23;                      // Stunde auf 23 setzen
         }
   }

   if ( get_key_short( 1<<taste2 )){
        hour --;                          // um eine Stunde verringern
        if (hour < 1)                     // wenn Überlauf
         {
           hour = 0;                      // Stunde auf 0 setzen
         }    
   }

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

[Michel (Gast)]

** Lötlackl schrieb:
> Wie wäre es mit folgendem Ansatz?if (hour < 24)
> {
>   hour++;
> }
>
> if (hour)
> {
>   hour--;
> }


Vielen dank

Da stand ich irgendwie aufn Schlauch

[Karl H. (kbuchegg)]

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.