Array Index ATMEGA

[Adam (Gast)]

Hallo zusammen,

Vielleicht habe ich heute ein Brett vor
m Kopf, aber ich komme hier gerade nicht weiter.
Folgendes Beispiel:

-unsigned char command_value[] = {1,2,3,4};
-unsigned char idx = 0;
-
- idx++;
- if (idx > 3) { idx = 0; }
-idx=1;                          <<<< WIRD Überschreiben
-send_num(idx); uart_putc(58);
-send_num(command_value[idx]); uart_putc(58);
-uart_putc(13);uart_putc(10);

funktioniert einwandfrei und liefert:

000000:000004:
000000:000004:
..usw

Wenn ich das Überschreiben weglasse (idx wird nicht 1 gesetzt sondern 
gerechnet) kommt folgendes raus:

000000:000032:
000001:000032:
000002:000032:
... usw.


Die komplette Funktion auf dem ATMEGA168 schaut so aus:

int main (void) {
  unsigned char command_value[] = {4,7,8,9};
  unsigned char idx = 0;

  Init_UART(9600); // for DEBUG Purpose
  idx = 0;
  while (1) {

     
       send_num(idx); uart_putc(58);
    send_num(command_value[idx]); uart_putc(58);
    uart_putc(13);uart_putc(10);


    idx++;
    if (idx > 3) { idx = 0; }
  }

}

Der Index (IDX) verlässt NICHT den Wertebereich - wie auch in der Debug 
Anzeige zu sehen. Was übersehe ich gerade???


Danke und Gruß,
 Adam

[Adam (Gast)]

Sorry,kleine Korrektur - der erste teil liefert
000001:000002

[annalyser (Gast)]

Die Funktion send_num () wäre schon noch wichtig.

[Adam (Gast)]

Hallo,

unten habe ich mal send_num() angefügt - allerdings sollte diese das 
Array nicht verändern. Es gibt immer nur Ärger sobald ich die 
Index-Variable ändere.

Folgendes Beispiel:

int main (void) {

  unsigned int n;
  unsigned int test;
  unsigned int command_value[4] = {4,7,8,9};

  Init_UART(9600); // for DEBUG Purpose

  n = 0;

  while (1) {
          test = (int)command_value[n];

       send_num(n);    uart_putc(58);
    send_num(test); uart_putc(58);
    send_num(test); uart_putc(58);
    uart_putc(13);  uart_putc(10);

    _delay_ms(500);
    n++;

    if ( n > 2 ) {  n = 0;  }
  }
}

Ausgabe:

000000:000004:000004:
000001:008224:008224:
000002:024672:024672:
000000:024672:024672:

Erster Index ( n=0; ) funktioniert, schon das erste n++ klappt aber 
nicht mehr...

// --------------------------------------------------------------------------------------
void send_num(uint16_t num) {
  int zahl;
  char str_zahl[5];
  unsigned char i;

  zahl = num;

  // Convert Number to Characters
  for (i=0; i<6; i++) {
    str_zahl[i] = zahl % 10;
    zahl /= 10;
  }

  // Send Characters in reverse order
  for (i=6; i>0; i--) {
    uart_putc(48+str_zahl[i-1]);
  }

}
// --------------------------------------------------------------------------------------

[Peter II (Gast)]

str_zahl[5];

for (i=0; i<6; i++) {
    str_zahl[i]

damit wird

str_zahl[5] geschrieben, was nicht sehr gut ist.

[Karl H. (kbuchegg)]

Ein Array, welches du mit einer Länge von 5 definierst

void send_num(uint16_t num) {
  int zahl;
  char str_zahl[5];

hat als gültige Indizes
0, 1, 2, 3, 4

zähl nach. Sind 5 Stück.
Ein Array Element mit dem Index 5 existiert nicht

d.h. hier

  for (i=0; i<6; i++) {
    str_zahl[i] = zahl % 10;

hast du einen Array Overflow. i nimmt als letzten Wert den Wert 5 an. 
Ein str_zahl[5] existiert aber nicht.

[Adam (Gast)]

Leute, Super!!!!

Man das war doof...
Erstaunlich das sich gerde die Variablen überschrieben haben.

Vielen Dank für das entfernen meiner Tomaten (vor den Augen) ;-)

[Karl H. (kbuchegg)]

Jetzt weißt du auch, warum man bei solchen Sachen mit Makros arbeitet

#define NR_DIGITS  6   // darf nicht kleiner als 6 sein. Kann aber größer sein

void send_num(uint16_t num) {
  int zahl;
  char str_zahl[NR_DIGITS];
  unsigned char i;

  zahl = num;

  // Convert Number to Characters
  for (i=0; i<NR_DIGITS; i++) {
    str_zahl[i] = zahl % 10;
    zahl /= 10;
  }

  // Send Characters in reverse order
  for (i=NR_DIGITS; i>0; i--) {
    uart_putc('0' + str_zahl[i-1]);
  }
}

jetzt stimmt die Array Größe IMMER mit der Anzahl an auszugebenden 
Digits überein.

[Adam (Gast)]

Ja, so ist's halt wenn das Kind schreit und Papa glaubt wie früher mal 
kurz eben was zu coden... und dann noch eine kleine Funktion zum 
debuggen, die ist ja eh egal ... argh.

Das Umkopieren dürfte sich jetzt auch erledigt haben, ist ja eine Werte 
und keine Referenzübergabe:

#define NR_DIGITS  6   // darf nicht kleiner als 6 sein. Kann aber 
größer sein
void send_num(uint16_t num) {
  char str_zahl[NR_DIGITS];
  unsigned char i;

  // Convert Number to Characters
  for (i=0; i<NR_DIGITS; i++) {
    str_zahl[i] = num % 10;
    num /= 10;
  }

  // Send Characters in reverse order
  for (i=NR_DIGITS; i>0; i--) {
    uart_putc('0' + str_zahl[i-1]);
  }
}