AVR Freaks

char a1[] = "Menu1";
char a2[] = "Menu2";
char a3[] = "Menu3";
char a4[] = "Menu4";
char a5[] = "Menu5";
char a6[] = "Menu6";
char a7[] = "Menu7";
char a8[] = "Menu8";
char a9[] = "Menu9";

char * menu[] = {a1, a2, a3, a4, a5, a6, a7, a8, a9};

volatile uint8_t menuIndex;

#define SIZE_A (sizeof(menu) / sizeof(char *))

int16_t EncoderMovement(void);  // defined elsewhere

void ProcessMenu(void) {
  int16_t tmp;

  tmp = EncoderMovement();
  tmp = menuIndex + tmp;
  tmp = tmp % SIZE_A;
  if (tmp < 0) tmp = tmp + SIZE_A;
  menuIndex = tmp;
  DisplayMenu(tmp);
}

When Menu1 is displayed and I move the encoder one tick backwards, it jumps onto Menu6; moving it further backwards it goes nicely to Menu5-Menu4...Menu1 when it jumps again to Menu6; moving it forward goes as supposed to Menu7 (then Menu8-Menu9-Menu1-Menu2...

I supposedly should be ashamed for this kind of error:

This can be a certain view on the problem but IMHO the root cause is different.

tmp = tmp % (int16_t) SIZE_A;

Michael wrote:

Quote:

This can be a certain view on the problem but IMHO the root cause is different.How do you define "unsigned modulo"? In C, (a/b)*b + a% b = a, thus -1/9 = 0 and -1% 9 = -1.

In C, -1 % 9 != -1 % 9U, even if -1 % 9 is positive.

In C, -1 % 9 is not positive,

Just for some extra fun, I tried the following:

// comments added by skeeve
#include 
#include 
int main(void) {
  printf("%d %d %d %d  \n %d %d %d %d  \n %d %d %d %d  \n %d %d %d %d",
         (int8_t)-1 % (uint8_t)9, // -1, -1
         (int8_t)-1 % (uint16_t)9, // -1, bad
         (int8_t)-1 % (uint32_t)9, // bad, bad
         (int8_t)-1 % (uint64_t)9, // bad, bad

         (int16_t)-1 % (uint8_t)9, // -1, -1
         (int16_t)-1 % (uint16_t)9, // -1, bad
         (int16_t)-1 % (uint32_t)9, // bad, bad
         (int16_t)-1 % (uint64_t)9, // bad, bad

         (int32_t)-1 % (uint8_t)9, // -1, -1
         (int32_t)-1 % (uint16_t)9, // -1, -1
         (int32_t)-1 % (uint32_t)9, // bad, bad
         (int32_t)-1 % (uint64_t)9, // bad, bad

         (int64_t)-1 % (uint8_t)9, // -1, -1
         (int64_t)-1 % (uint16_t)9, // -1, -1
         (int64_t)-1 % (uint32_t)9, // -1, -1
         (int64_t)-1 % (uint64_t)9  // bad, bad
);
  exit(0);
}

Try (without cheating) to predict the results for a 32-bit compiler and for a 16-bit compiler. Very enlightening.