bis 2E23 hochzählen, in 3 Bytes

OP #411838
Lesenswert?

Hi

Ich muss einen Wert von 0 bis 2^23 kontinuiertlich hochzählen. Dazu
habe ich gedacht, benutze ich 3 Byte die ich zusammengehängt
betrachte.
Byte0,
Byte1,
Byte2

Ich müsste dann eine Funktion ausführen (bei jedem Interrupt) die immer
eins inkrementiert.
//interrupt-fkt
if (++byte0 < 255)
{
 byte0=0;
 if (++byte1 < 255)
 {
  byte1=0;
  if (++byte2 < 255)
  {
   byte2=0;
  }
 }
}

Gibt es noch eine andere Möglichkeit, evtl per
uint24_t byteX;
Dann bräuchte ich keine 3 if-Schleifen.
?
Gast #411840
Lesenswert?

>if-Schleifen.

Kann man die irgendwo kaufen?

Übrigens produziert deine "Berechnung" ziemlichen Quark.
1. Mit drei Bytes kann man bis 2^24-1 zählen
2. if (++byte0 < 255) byte0 = 0; (abgekürzt)
Sorgt dafür, dass byte0 zwischen 0 und 1 hin- und hergestossen wird.

Wenn dann sollte das heissen:

if (++byte0 == 0)
  if (++byte1 == 0)
   ++byte2;

Noch kürzer:

if (!(++byte0))
  if (!(++byte1)
   ++byte2;
Gast #411841
Lesenswert?

Ich brauche nach dem Hochzählen dann aber 3 separate Bytes.
Byte0..Byte2

Wie kann ich die dann trennen? Ich hätte so versucht:


0: seconds & 0xFF;
1: (seconds >> 8) & 0xFF;
2: (seconds >> 16) & 0xFF;

Kommt aber nur Müll bei raus.
Gast #411842
Lesenswert?

Da gibt's eine elegante Methode mit Unions.  Du kanst z.B. einen
uint32_t und einen array von 4 Bytes übereinander definieren und dann
wahlweise auf den 32 Bit Integer oder ein einzelnes Byte zugreifen...

Mach Dich mal schlau bezüglich Unions via folgendem Link:

http://www.phim.unibe.ch/comp_doc/c_manual/C/SYNTAX/union.html

Leider hat diese Methode einen Nachteil, der eventuell störend ist: Sie
ist nicht portierbar bzw. abhängig davon, ob ne CPU im Big-Endian oder
Little-Endian Modus rechnet...

MfG  Peter

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren