Atmel SAMD21 Kollision von Variablen

[Thomas K. (technomicro)]

Moin,
in Atmel Studio für SAMD21 beobachte ich eine Kollision von Variablen:

In einem Modul ist ein

struct at25dfx_chip_module    at25dfx_chip;

die boolsche Variable:

&((((at25dfx_chip).spi))->locked)

Die Adresse von at25dfx_chip.spi ist 0x20007500.

In einem anderen Modul:

int intToStr(int x, char str[], int d)
{  int i=0;
  while (x)
  {  str[i++] = (x%10) + '0';
    x = x/10;
  }

  while (i < d){str[i++] = '0';}
  reverse(str, i);
  str[i] = '\0';
  return i;
}

i ist im Watch definiert als:
int(a variable at frame base reg $r7 offset 40+-20.
wobei R7= 0x200074F0.

Nun verändert sich at25dfx_chip.spi->locked mit der lokalen i der 
Funktion intToStr().  Siehe Bild.
Der boolsche Wert "locked" nimmt also die Werte von i=0..1..2..3 usw an, 
wenn intToStr() durchläuft.

Kann es sein, dass der Stack in den Heap crashed?
Eine Verkleinerung anderer Arrays gab keine Veränderung.

Hat jemand eine Idee?
mny tnx!

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         0002728c  00000000  00000000  00010000  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .ARM.exidx    000001a8  0002728c  0002728c  0003728c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  2 .relocate     00000ad4  20000000  00027434  00040000  2**3
                  CONTENTS, ALLOC, LOAD, DATA
  3 .bss          00004ad4  20000ad4  00027f08  00040ad4  2**2
                  ALLOC
  4 .stack        00002000  200055a8  0002c9dc  00040ad4  2**0
                  ALLOC
  5 .ARM.attributes 00000028  00000000  00000000  00040ad4  2**0
                  CONTENTS, READONLY
  6 .comment      00000059  00000000  00000000  00040afc  2**0
                  CONTENTS, READONLY
  7 .debug_info   0006bf48  00000000  00000000  00040b55  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_abbrev 00008c68  00000000  00000000  000aca9d  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_loc    00009c5b  00000000  00000000  000b5705  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_aranges 00001ae8  00000000  00000000  000bf360  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 00001858  00000000  00000000  000c0e48  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_macro  00010c7d  00000000  00000000  000c26a0  2**0
                  CONTENTS, READONLY, DEBUGGING
 13 .debug_line   00022963  00000000  00000000  000d331d  2**0
                  CONTENTS, READONLY, DEBUGGING
 14 .debug_str    0009ef75  00000000  00000000  000f5c80  2**0
                  CONTENTS, READONLY, DEBUGGING
 15 .debug_frame  00008888  00000000  00000000  00194bf8  2**2
                  CONTENTS, READONLY, DEBUGGING

//intToStr________________________________________
int intToStr(int x, char str[], int d)
{  int i;
    2494:  b590        push  {r4, r7, lr}
    2496:  b087        sub  sp, #28
    2498:  af00        add  r7, sp, #0
    249a:  60f8        str  r0, [r7, #12]
    249c:  60b9        str  r1, [r7, #8]
    249e:  607a        str  r2, [r7, #4]
  i=0;
    24a0:  2300        movs  r3, #0
    24a2:  617b        str  r3, [r7, #20]

[Thomas K. (technomicro)]

Wenn die structs nicht lokal sondern global definiert werden, geht es.
Habe ich da etwas übersehen?

struct at25dfx_chip_config    v_at25dfx_chip_config;
struct spi_config        v_at25dfx_spi_config;
struct spi_module        v_at25dfx_spi_module;

void EM_configure_spi_master(void)
{   //struct at25dfx_chip_config    v_at25dfx_chip_config;
    //struct spi_config        v_at25dfx_spi_config;
    //struct spi_module        v_at25dfx_spi_module;

     at25dfx_spi_get_config_defaults(&v_at25dfx_spi_config);
  v_at25dfx_spi_config.mode_specific.master.baudrate = CONF_masterbaudrate;
  v_at25dfx_spi_config.mux_setting = CONF_mux_setting;  
  v_at25dfx_spi_config.pinmux_pad0 = CONF_pinmux_pad0;
  v_at25dfx_spi_config.pinmux_pad1 = CONF_pinmux_pad1;
  v_at25dfx_spi_config.pinmux_pad2 = CONF_pinmux_pad2;
  v_at25dfx_spi_config.pinmux_pad3 = CONF_pinmux_pad3;

  spi_init(&v_at25dfx_spi_module, v_EM_spiNumber, &v_at25dfx_spi_config);
  spi_enable(&v_at25dfx_spi_module);
  v_at25dfx_chip_config.type = CONF_type;
  v_at25dfx_chip_config.cs_pin = CONF_pinmux_cs_pin;
  at25dfx_chip_init(&v_at25dfx_chip, &v_at25dfx_spi_module, &v_at25dfx_chip_config);
  at25dfx_chip_sleep(&v_at25dfx_chip);
}

[Fabian F. (fabian_f55)]

Ich würde mal vermuten der Stack und der Heap kollidieren?
Deine Funkion hat keine Ahnung wie viel Speicher für str[] benötigt 
wird.
Versuch doch mal mit malloc() ob du überhaupt genug Speicher reservieren 
kannst.

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

Thomas K. schrieb:
> Die Adresse von at25dfx_chip.spi ist 0x20007500.

> int(a variable at frame base reg $r7 offset 40+-20.
> wobei R7= 0x200074F0.

Da 0x200074F0 kleiner als 0x20007500 ist, ist der Stack wohl nicht
in den Heap, sondern in den statischen Datenbereich hinein geraten.

Die Atmel-Linkerscripte und der zugehörige Startup-Code reservieren
explizit Platz für den Stack, statt ihn einfach vom Ende des RAMs
nach unten wachsen zu lassen (und damit den statischen Bereich und
den Stack maximal voneinander zu trennen).  Damit muss man eine
ausreichende Menge an Stack dort reservieren.  Da du offenbar das Atmel
Studio benutzt, musst du mal schauen, wo man das im Projekt einstellt.

[Zweig (Gast)]

Laut lss ist der Stack 0x2000 also 8kbyte groß. Eher denke sich das ein 
Pointer von einer lokalen Struktur zurück geben wird. Das wäre so ein 
typischer Fehler. Leider ist ja nichr der komplette Quelltext sichtbar