Signed integer overflow

[Walter T. (nicolas)]

Guten Abend zusammen,
ich sehe gerade wieder den Wald vor lauter Bäumen nicht mehr. Ich habe 
von einer Peripherie (TMC222) einen Zähler (16Bit, Zweierkomplement), 
bei dem der Überlauf spezifiziert ist. Da mir der Zählbereich nicht 
ausreicht, wird er regelmäßig gepollt und in einer 24-Bit-Zählvariablen 
mitgeschrieben. Und so sieht der Quelltext aus:

static int24_t stepact;   // Schrittvariable
static int16_t pos_last = 0; // Hilfsvariable
void tmc222_poll(void) {
  int16_t pos_act =  tmc222_GetPosition();
  int16_t diff;
  
  if (pos_act <0 ) {
    if (pos_last < 0) diff = pos_act-pos_last;  // kein Overflow
    else              diff = (pos_act-INT_MIN)-(pos_last-INT_MAX);
  }
  else {
   if (pos_last < 0)  diff = (pos_act-INT_MAX)-(pos_last-INT_MIN);
   else               diff = pos_act-pos_last;  // kein Overflow
  }
  
  pos_last = pos_act;
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    stepact += diff;
  }    
}

Ich bin mir momentan nur nicht sicher, ob ich den Integer-Overflow so 
richtig berücksichtigt habe.

Viele Grüße
W.T.

[Hans (Gast)]

Walter Tarpan schrieb:
> Ich bin mir momentan nur nicht sicher, ob ich den Integer-Overflow so
> richtig berücksichtigt habe.

Nein, hast Du nicht. Beispiel: Der Zähler springt um einen Schritt von 
32767 auf -32768. Die Differenz sollte 1 sein.

Also:
pos_last = 32767
pos_act = -32768
diff = (pos_act-INT_MIN)-(pos_last-INT_MAX)
diff = (-32768-(-32768))-(32767-32767) = 0

Schon mal falsch.

Ansonsten noch ein paar Unsauberkeiten bei der Implementierung:
- Statt INT_MIN und INT_MAX solltest Du INT16_MIN und INT16_MAX nehmen, 
sonst funktioniert der Code auf einer 32-Bit-Plattform nicht.
- int24_t ist kein Standarddatentyp. Für bessere Portabilität wäre 
int32_t zu empfehlen.
- Das Verhalten beim Signed-Überlauf ist vom C-Standard nicht 
festgelegt. Der Ausdruck -(-32768) passt nicht in 16 Bit und kann daher 
theoretisch alles mögliche ergeben. Deshalb sollte da für die Berechnung 
ein Cast auf int24_t oder int32_t rein.

[Jörg W. (dl8dtl) (Moderator)]

Hans schrieb:
> Das Verhalten beim Signed-Überlauf ist vom C-Standard nicht festgelegt.

Genauer: er erzeugt undefiniertes Verhalten.  Man kann sich also auf
nichts dabei verlassen.

Wenn man mit Überlauf arbeiten will, dann unsigned, da ist das alles
wohl definiert.  Ggf. danach auf signed der gleichen Größe casten.

[Fabian O. (xfr)]

Jörg Wunsch schrieb:
> Wenn man mit Überlauf arbeiten will, dann unsigned, da ist das alles
> wohl definiert.  Ggf. danach auf signed der gleichen Größe casten.

Das dürfte die einfachste Lösung sein. Funktioniert dann halt "nur" auf 
Prozessoren, die mit 2er-Komplement rechnen, aber das ist wohl zu 
verkraften. ;-)

static int24_t  stepact;      // Schrittvariable
static uint16_t pos_last = 0; // Hilfsvariable

void tmc222_poll(void) {
  uint16_t pos_act = tmc222_GetPosition();
  uint16_t diff = pos_act - pos_last;  
  pos_last = pos_act;
  
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    stepact += (int16_t) diff;
  }
}

[Walter T. (nicolas)]

Guten Abend,
naja, der Überlauf kommt ja von einem Stück Peripherie, wo genau dieser 
im Datenblatt steht.

Und GCC soll ihn ja nur detektieren. Soweit paßt also schon alles.

Jörg Wunsch schrieb:
> Wenn man mit Überlauf arbeiten will, dann unsigned

Ich habe auch schon überlegt, ob ich nicht erst das Ganze + (-INT_MIN) 
nehme und in einen signed integer caste. Probiere ich morgen doch direkt 
mal aus. Ich weiß auch nicht mehr genau, warum mir das nicht gefiel. 
Wahrscheinlich weil dann noch eine 24-Bit-Variable mehr mit im Spiel 
ist.

Viele Grüße
W.T.

[Fabian O. (xfr)]

Sehe gerade, man braucht den Cast nicht mal:

static int24_t  stepact;      // Schrittvariable
static uint16_t pos_last = 0; // Hilfsvariable

void tmc222_poll(void) {
  uint16_t pos_act = tmc222_GetPosition();
  int16_t diff = pos_act - pos_last;  
  pos_last = pos_act;
  
  ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    stepact += diff;
  }
}

[Rolf Magnus (Gast)]

Jörg Wunsch schrieb:
> Wenn man mit Überlauf arbeiten will, dann unsigned, da ist das alles
> wohl definiert.  Ggf. danach auf signed der gleichen Größe casten.

Noch eine Korinthe für zwischendurch: Laut ISO C ist das 
Überlaufverhalten bei unsigned, daß es keinen Überlauf gibt. Stattdessen 
wird immer modulo Maximalwert+1 gerechnet.

[Johann L. (gjlayde)]

Dieses Verhalten kann man mit GCC auch für signed bekommen, indem man 
-fwrapv setzt.