Überlauf bei int32_t trotz Satuierungsversuch?

[J. W. (jw-lighting)]

Hallo,

ich habe hier Probleme mit einem Codeschnipsel (für einen ATmega644P @ 
16MHz).
Damit ihr euch einen Überblick verschaffen könnt, was der Schnipsel 
bewirken soll, erstmal eine kurze Erläuterung.


Ich möchte mehrere 8-Bit Werte (effektiv) innerhalb einer beliebigen, 
durch den Wert von fadeFaktor bestimmten Zeit ansteigen oder absinken 
lassen, bis ein Zielwert erreicht ist.
Da der Codeschnippsel ~ mit 100Hz aufgerufen wird und auch Zeiten > 2,55 
Sekunden möglich sein sollen, führe ich die Berechnung mit 16-Bit Werten 
durch, von denen im weiteren Programmverlauf (siehe unten im Code) dann 
jeweils nur die oberen 8-bit verwendet werden (daher effektiv 8-bit) - 
die unteren dienen dazu, den Ablauf zeitlich strecken zu können.

Die 8-bit Zielwerte sind in PresetTargetValues[] gespeichert, die 16-bit 
Berechnungswerte in PresetValues.

Da der Zielwert nicht überschritten werden soll berechne ich zunächst in 
einem int32_t und entscheide dann a posterori, ob der Zielwert erreicht 
ist (und setze diesen) oder benutze den berechneten Wert. Ein Überlauf 
sollte daher ja eigentlich nicht auftreten.

Trotzdem kommt es dann (und nur dann) wenn der Zielwert 255 ist und eine 
nicht natürliche Anzahl von Berechnungen notwendig ist um den Zielwert 
zu erreichen zu einem Überlauf - zumindest springt der Wert in 
PresetValues auf 0 zurück und bleibt nicht beim oberen Zielwert 255, 
sodass sich der Vorgang (mehrfach) wiederholt.


Ich habe jetzt mehrfach drübergeschaut und versucht einen Fehler zu 
finden, bin aber bisher ratlos geblieben. Liegts am großen int32_t oder 
habe ich ein Brett vorm Kopf?


Würde mich freuen, wenn ihr Rat wüsstet.

LG :)

(Dass dies nicht unbedingt der effizienteste Weg ist ist mir bewusst, 
soll aber nicht weiter Thema sein)

uint16_t fadeFaktor;

  // ...

uint8_t i;
int32_t tmp; // signed 32bit !!
for(i=0; i<CHANNEL_TO_TX; i++){
  
  if(PresetTargetValues[i] > ((uint8_t)(PresetValues[i] >> 8))){
    
    tmp = PresetValues[i] + fadeFaktor;
    
    if(tmp > ((uint16_t)(PresetTargetValues[i] << 8))){
      
      PresetValues[i] = (uint16_t) PresetTargetValues[i] << 8);
      
    }
    else{
      
      PresetValues[i] = (uint16_t) (tmp & 0xFFFF);
      
    }
    
  }
  else if(PresetTargetValues[i] < ((uint8_t)(PresetValues[i] >> 8))){
      
    tmp = PresetValues[i] - fadeFaktor;
      
    if(tmp < ((uint16_t)(PresetTargetValues[i] << 8))){
        
      PresetValues[i] = (uint16_t) (PresetTargetValues[i] << 8);
        
    }
    else{
        
      PresetValues[i] = (uint16_t) (tmp & 0xFFFF);
        
    }
      
  }
    
  DmxTx.values[i] = (uint8_t) (( ( (uint8_t)(PresetValues[i] >> 8) ) * masterChannel ) / 255);
    
}

[(prx) A. K. (prx)]

> tmp = PresetValues[i] + fadeFaktor;

Wird in 16 Bits gerechnet und erst anschliessend nach 32 Bits 
konvertiert. Lies es als
  tmp = (PresetValues[i] + fadeFaktor);

[J. W. (jw-lighting)]

A. K. schrieb:
> Wird in 16 Bits gerechnet und erst anschliessend nach 32 Bits
> konvertiert.

Hilft mir dann ein

 tmp = ((int32_t) PresetValues[i] + fadeFaktor);

weiter?

LG und dickes Dankeschön! :)

[(prx) A. K. (prx)]

Ja.

[J. W. (jw-lighting)]

Super, danke!

Wenn jetzt noch jemand Ideen hat, die Sache effizienter zu erledigen, 
immer her damit ;)

LG :)

[Peter D. (peda)]

Hier mal meine Begrenzerroutine:

uint16_t min_max( uint16_t val, int8_t delta )  // unsigned limitaion
{
  val += delta;
  if( val >= delta ){
    if( delta < 0 )
      val = 0;
  }else{
    if( delta > 0 )
      val = 65535;
  }
  return val;
}

Peter