AVR verhalten bei min und max von Werten

[Phillip H. (philharmony)]

Ich hänge gerade ein bisschen fest. Habe mehrere Dreh-Encoder, die je 
einen Wert hoch bzw runter-regeln sollen. Die Werte haben einen Minimal- 
und einen Maximalwert und verhalten sich unterschiedlich bei erreichen 
dieser Werte.
Manche sollen bei "Überlauf" einfach am entsprechenden oberen oder 
unteren Ende des Wertebereichs "festgehalten" werden, andere sollen eine 
Art modulo haben und bei durchschreiten des einen Limits einfach ans 
andere ende Gesetzt werden.
Bsp:
1. +1 -> 1 2 3 4 5 6 6 6 6 6 6 6  -1 -> 5 4 3 2 1 1 1 1 1
2. +1 -> 1 2 3 4 5 6 1 2 3 4 5 6  -1 -> 5 4 3 2 1 6 5 4 3

Hier ein auszug aus dem Code

//graytab is static signed char, die codeaufschlüsselung funktioniert, es wird korrekt hoch bzw runtergezählt bis eben zum Überlauf

  {
    if ((*(device->mem->value) + ((device->increment) * graytab[graycode[i]])) < (device->min))
    {
      if (device->modulo)
      {
        *(device->mem->value) = (device->max);
      }
      else 
      {
        *(device->mem->value) = (device->min);
      }
    }
    else if ((*(device->mem->value) + ((device->increment) * graytab[graycode[i]])) > (device->max))
    {
      if (device->modulo)
      {
        *(device->mem->value) = (device->min);
      }
      else
      {
        *(device->mem->value) = (device->max);
      }
    }
    else
    {
      *(device->mem->value) = ((*(device->mem->value) + ((device->increment) * graytab[graycode[i]])));
    }

Das ganze funktioniert aber noch nicht so recht, zb ist min 0 und der 
Wert wird aber bis -1 runtergezählt und beim hochzählen geht er bis 19 
(max ist 20) und springt dann wieder auf -1.
Gibt es grundsätzlich für dieser Zweck elegantere Lösungen (abgesehen 
vom % Operator, der Funktioniert dafür auch nicht richtig weil 
0-Durchlauf beim runterzählen nicht erkannt wird)

[Phillip H. (philharmony)]

Grmpf, Sockenschuss, es funtkioniert, hatte ganz unten vergessen die 
alte Funktion rauszunehmen und hab das oben errechnete unten nochmal 
überschrieben.
Daher möchte ich die Frage Korrigieren: Geht das eleganter?

[Horst (Gast)]

aussagekräftigerName = *(device->mem->value) + ((device->increment) * 
graytab[graycode[i]]));

das dann vor dem ersten if
bei den ifs dann nur noch aussagekräftigerName verwenden

[Phillip H. (philharmony)]

Ok, stimmt ist dann besser lesbar. Geht das von der Struktur her auch 
noch besser, gibts vllt schon Funktionen die das können?

[Karl H. (kbuchegg)]

Phillip Hommel schrieb:
> Ok, stimmt ist dann besser lesbar. Geht das von der Struktur her auch
> noch besser, gibts vllt schon Funktionen die das können?

Wenn du dir eine schreibst, gibt es sie :-)

Aber ansonsten kann man auch an der Lesbarkeit noch feilen

  newValue = *(device->mem->value) + (device->increment) * graytab[graycode[i]];

  if( newValue > device->max )
    newValue = device->modulo ? device->min : device->max;
    
  if( newValue < device->min )
    newValue = device->modulo ? device->max : device->min;
    
  *(device->mem->value) = newValue;

[Phillip H. (philharmony)]

Die C-Cryptische ?: version der If-Abfrage mag ich persönlihc nicht so 
da sie für C-fremde Programierer erstmal total undurchsictig ist. Aber 
abgesehen davon ist die Version von Karl Heinz deutlich schöner und 
kürzer als meine.
Dankeschön

[Karl H. (kbuchegg)]

Phillip Hommel schrieb:
> Aber
> abgesehen davon ist die Version von Karl Heinz deutlich schöner und
> kürzer als meine.

Genau das ?: ist es, was diesen Code kurz macht.
Und manchmal gewinnt ein Code durch die kürzere Schreibweise, solange 
man es nicht übertreibt.

[Phillip H. (philharmony)]

Klar dagegen sage ich ja gar nichts. Habe deine Version auch direkt mal 
übernommen wenns ok ist ;)
In diesem Fall denke ich ist die durchschaubarkeit auch trotzdem 
gewährleistet.
Mein Projektchen nimmt übrigens schon ganz gut Form an, Eure Hilfe hier 
war wirklich Gold wert. Ich scheue mich auch nicht mehr vor Zeigern 
sondern habe sie echt zu schätzen gelernt ;)