Große Zahl aus drei Variablen

[Gast (Gast)]

Hallo

Timer2 löst einen Interrupt aus, wenn er überläuft. um auf die enlos 
lange zeit von 72h zu kommen, soll das ereignis erst nach dem 3955080 
ten mal erfolgen.

welchen code schreibe ich dazu in den interrupt?

ich habe nur 8 bit breite char variablen also mit drei chars werde ich 
auskommen (255*255*255 ist mehr als 3,9 Milionen)


in der interrupt routine:

if(TMR2IF)    //bei overflow interrupt
{
   ? ? ? hier welcher code ? ? ?
}

Danke schon mal leute!

[Benedikt K. (benedikt)]

Du hast die Frage doch schon selbst beantwortet:
Ein Zähler der zählt, und bei 3955080 das Ereignis auslöst.

[Torben (Gast)]

Zaehler 1 (8bit) hochzählen und bei überlauf den zweiten zaehler 
hochzaehlen usw

[Random .. (thorstendb)]

was kommt denn raus, wenn du den prescaler schon mal hochschraubst?

Ansonsten empfehle ich das Prinzip aller Zahlensysteme: Wenn der eine 
Überläuft überträgst du das auf den nächsten und fängst bei null wieder 
an.

Was ist mit einem 16Bit TC? Auf jeden Fall kannste ja nen (int) 
verwenden, das sind schon mal 16Bit. Dann gibtz glaub ich noch (long) 
...


VG,
/r.

[Johnny Maxwell (Gast)]

Was spricht gegen einen 32bit großen int?

[Gast (Gast)]

dagegen spricht mein cc5x compiler als free version
der will nur bis 16bit

das reicht leider nicht aus :(

also ich wollte nur mal fragen, ob jemand von euch cracks(ich bin leider 
nur n greenhorn) fährig ist, den c-code mit ifs aufzustellen




Im Interrupt:

if(TMR2IF)   //Überlauf Timer 2
{
    ***** C O D E *****
}

zb mit char zaehl0, zaehl1, zaehl2(sind dann 8Bit)

Danke im Voraus für Code...

[Johnny Maxwell (Gast)]

Komm schon, das ist so einfach, das kriegst du leicht auch selber hin. 
Überleg dir einfach was passieren soll, wenn zahl0 gerade 255 war und 
nun um eins weitergezählt werden soll. Analog für zahl1.

Im Übrigen passen in 3 8bit Variablen (24bit insg.) Werte bis 256^3 - 1 
= 2^24 - 1 und nicht nur bis 255^3.

[gast (Gast)]

etwa so?

if(TMR2if)   // Interrupt bei overflow alle 65,5ms
{

  zaehl0 ++;
  if(zaehl0 == 255){zaehl1++;}
  if(zaehl1 == 255){zaehl2++;}

  if(zaehl2 == 60){**SLEEP-MODUS**}
}

mein denken: wenn die erste variable bis 255 gezählt hat, ist die zweite 
variable 1. Wenn die zweite variable bis 255 gezählt hat(also die erste 
255*255) dann wird die dritte variable inkrementiert.

so müsste das "sleep-Modus" jedes mal passieren, wenn der timer 2 
(255*255*60)-mal übergelaufen ist.

stimmts? bin halt noch neu, was das programmieren angeht

[Läubi .. (laeubi)]

Du solltest nach dem Sleepmodus noch alles auf 0 setzen, ansosnten 
könnte das in erster näherung klappen, auch wenn man eigentlich den 
überlauf detektieren sollte, hab aber keine Ahnung wie das in C genau 
geht :)

[harrald (Gast)]

genau wie in asm auch! einfach status register abfragen da gibt es doch 
carry und overflow bits!!

[Mike R. (thesealion)]

Der Code sieht für mich schon fast gut aus.
Ein Fehler passiert noch, wenn

zaehler0 = 254
zaehler1 = 254
zaehler2 = x

am ende des Interrupts sieht es dann so aus:

zaehler0 = 255
zaehler1 = 255
zaehler2 = 1 (hier nur als Beispiel)

beim nächsten Interrupt passiert folgenden:

  zaehl0 ++;                    -> zaehl0 = 0
  if(zaehl0 == 255){zaehl1++;}  -> FALSE
  if(zaehl1 == 255){zaehl2++;}  -> TRUE, da zaehl1 nicht geändert wurde

Geschickter ist es die Variablen explizit auf 0 zu setzen. Und dann erst 
einmal genau überlegen, welche bis wo zählen muß.

Was harrald sagt ist der einzige Weg, soweit ich weiß unterstützt C für 
sich kein Overflowbit. Geht also nur über den "Umweg" über das 
Statusregister.

[Karl H. (kbuchegg)]

gast wrote:
> etwa so?
>
> if(TMR2if)   // Interrupt bei overflow alle 65,5ms
> {
>
>   zaehl0 ++;
>   if(zaehl0 == 255){zaehl1++;}
>   if(zaehl1 == 255){zaehl2++;}
>
>   if(zaehl2 == 60){**SLEEP-MODUS**}
> }
>
> mein denken: wenn die erste variable bis 255 gezählt hat, ist die zweite
> variable 1. Wenn die zweite variable bis 255 gezählt hat(also die erste
> 255*255) dann wird die dritte variable inkrementiert.

Fast

Die Abfrage ob zahl1 gleich 255 ist, darf nicht jedesmal erfolgen.
Es genügt völlig, wenn dies passiert, nachdem zaehl0 seinen
Vergleich auf 255 positiv erledigt hat und zaehl1 inkrementiert
hat

  zaehl0++;

  if( zaehl0 == 255 ) {
    zaehl1++;

    if( zaehl1 == 255 ) {
      zaehl2++;

      if( zaehl2 == 60 ) {
        // Sleep Modus !

        zaehl0 = zaehl1 = zaehl2 = 0;
      }
    }
  }


> so müsste das "sleep-Modus" jedes mal passieren, wenn der timer 2
> (255*255*60)-mal übergelaufen ist.

In deiner Version nicht ganz. Der Zaehler zaehl2 zaehlt falsch.
Bei dir sind es nur
  255 + 255 + 60
Overflow Aufrufe, bis der Sleep kommt

(Hinweis: Überleg dir was weiter passiert, wenn zaehl1 den Wert
255 erreicht hat. Was passiert dann im nächsten Overflow? Und
im Überächsten?

[Johnny Maxwell (Gast)]

Warum zählt Ihr eigentlich alle bis zahl0 = 255, zahl1 = 255, zahl2 = 
60?
Es ging "Gast" doch darum bis 3955080 zu zählen, d.h. bis zahl0 = 136, 
zahl1 = 89, zahl2 = 60.

[Karl H. (kbuchegg)]

Johnny Maxwell wrote:
> Warum zählt Ihr eigentlich alle bis zahl0 = 255, zahl1 = 255, zahl2 =
> 60?
> Es ging "Gast" doch darum bis 3955080 zu zählen, d.h. bis zahl0 = 136,
> zahl1 = 89, zahl2 = 60.

Ein bischen was muss für ihn ja auch noch zu tun übrig bleiben :-)

[Εrnst B. (ernst)]

Warum fragt ihr alle auf 255 ab?
Der überlauf passiert doch, wenn der wert wieder auf 0 springt...

void timer() {
  uint8_t zaehl0,zaehl1,zaehl2;

  zaehl0++;

  if( !zaehl0 ) {
    zaehl1++;

    if( !zaehl1 ) {
      zaehl2++;

    }
  }
  if( zaehl0 == 136 && zaehl1 == 89 && zaehl2 == 60 ) {
    // Sleep Modus !

        zaehl0 = zaehl1 = zaehl2 = 0;
  }
}

[Gast (Gast)]

Danke leure, das reicht mir!


also besten dank für eure antworten!! ich liebe dieses forum....

[Stefan E. (sternst)]

Nimm den Code von Ernst Bachmann, den ganzen anderen Quatsch kannst du 
vergessen. Er hat allerdings ein "static" vergessen:

static uint8_t zaehl0,zaehl1,zaehl2;