FreeRTOS Task-Stack-Überlauf Problem

Question

Ich benutze einen Freertos-Port von Microblaze und ich habe einige einfache Code, blinkt ein Licht in einer Aufgabe, und ich bekomme einen "Task übergelaufen seinen Stack-Aufruf". Beachten Sie, dass die Fehlernachricht den Namen der Aufgabe nicht wirklich ausgibt, aber wenn ich bedenke, dass ich nur eine Aufgabe habe, denke ich, dass dort ein Problem liegen könnte.

Ich habe auch einen uart Interrupt feuern jedes Mal, wenn ein Zeichen empfangen wird, aber das funktioniert gut. In dem Linker-Skript, das ich angehängt habe, habe ich die Stack- und Heap-Größe erhöht, um ziemlich groß zu sein, und ich stoße immer noch auf dieses Problem. Wenn ich die main_task deaktiviere, bekomme ich keinen Stack-Overflow, was bedeutet, dass es etwas mit der Aufgabe zu tun hat? Ich sollte auch sagen, dass es normal funktioniert, aber wenn ich weiterhin in die uart klicke, die Interrupts ausgeben wird, bekomme ich schließlich diesen Fehler.

Jede Hilfe wäre wirklich hilfreich, da ich mit meinem Verstand hier Ende bin. Danke im Voraus.

void 
main_task() 
{ 
    int counter = 0; 
    while(1) 
    { 
     if ((counter++%2) == 0) 
     { 
     *(volatile unsigned int*)0x40000000 &= ~0x1; 
     } 
     else 
     { 
     *(volatile unsigned int*)0x40000000 |= 0x1; 
     } 
     vTaskDelay(200); 
    } 
} 

int main() 
{ 
    xTaskCreate((void(*)(void*)) main_task, "main_task", 4096, NULL, 3, &xCreatedTask); 
    vTaskStartScheduler(); 
} 

Dies ist der Linker-Skript Ich verwende:

STARTUP(crt0.o) 
ENTRY(_start) 

_STACK_SIZE = 0x4000; 
_HEAP_SIZE = 0x4000; 

MEMORY 
{ 
    mig_7series_0 : ORIGIN = 0x80000000, LENGTH = 0x10000000 
} 

SECTIONS 
{ 
.vectors.reset 0x0 : { 
    KEEP (*(.vectors.reset)) 
} 

.vectors.sw_exception 0x8 : { 
    KEEP (*(.vectors.sw_exception)) 
} 

.vectors.interrupt 0x10 : { 
    KEEP (*(.vectors.interrupt)) 
} 

.vectors.hw_exception 0x20 : { 
    KEEP (*(.vectors.hw_exception)) 
} 

.text : { 
    *(.text) 
    *(.text.*) 
    *(.gnu.linkonce.t.*) 
} > mig_7series_0 

.rodata : { 
    __rodata_start = .; 
    *(.rodata) 
    *(.rodata.*) 
    *(.gnu.linkonce.r.*) 
    __rodata_end = .; 
} > mig_7series_0 

.sdata2 : { 
    . = ALIGN(8); 
    __sdata2_start = .; 
    *(.sdata2) 
    *(.sdata2.*) 
    *(.gnu.linkonce.s2.*) 
    . = ALIGN(8); 
    __sdata2_end = .; 
} > mig_7series_0 

.sbss2 : { 
    __sbss2_start = .; 
    *(.sbss2) 
    *(.sbss2.*) 
    *(.gnu.linkonce.sb2.*) 
    __sbss2_end = .; 
} > mig_7series_0 

.data : { 
    . = ALIGN(4); 
    __data_start = .; 
    *(.data) 
    *(.data.*) 
    *(.gnu.linkonce.d.*) 
    __data_end = .; 
} > mig_7series_0 

.sdata : { 
    . = ALIGN(8); 
    __sdata_start = .; 
    *(.sdata) 
    *(.sdata.*) 
    *(.gnu.linkonce.s.*) 
    __sdata_end = .; 
} > mig_7series_0 

.sbss (NOLOAD) : { 
    . = ALIGN(4); 
    __sbss_start = .; 
    *(.sbss) 
    *(.sbss.*) 
    *(.gnu.linkonce.sb.*) 
    . = ALIGN(8); 
    __sbss_end = .; 
} > mig_7series_0 

.tdata : { 
    __tdata_start = .; 
    *(.tdata) 
    *(.tdata.*) 
    *(.gnu.linkonce.td.*) 
    __tdata_end = .; 
} > mig_7series_0 

.tbss : { 
    __tbss_start = .; 
    *(.tbss) 
    *(.tbss.*) 
    *(.gnu.linkonce.tb.*) 
    __tbss_end = .; 
} > mig_7series_0 

.bss (NOLOAD) : { 
    . = ALIGN(4); 
    __bss_start = .; 
    *(.bss) 
    *(.bss.*) 
    *(.gnu.linkonce.b.*) 
    *(COMMON) 
    . = ALIGN(4); 
    __bss_end = .; 
} > mig_7series_0 

_SDA_BASE_ = __sdata_start + ((__sbss_end - __sdata_start)/2); 

_SDA2_BASE_ = __sdata2_start + ((__sbss2_end - __sdata2_start)/2); 

/* Generate Stack and Heap definitions */ 

.heap (NOLOAD) : { 
    . = ALIGN(8); 
    _heap = .; 
    _heap_start = .; 
    . += _HEAP_SIZE; 
    _heap_end = .; 
} > mig_7series_0 

.stack (NOLOAD) : { 
    _stack_end = .; 
    . += _STACK_SIZE; 
    . = ALIGN(8); 
    _stack = .; 
    __stack = _stack; 
} > mig_7series_0 

_end = .; 
} 

Answer 1

Haben Sie configCHECK_FOR_STACK_OVERFLOW auf 1 oder 2? Wenn 2, dann überprüft die Stapelüberlaufprüfung das Ende des Aufgabenstapels, um zu sehen, ob ein Muster, das beim Erstellen der Aufgabe dort geschrieben wurde, überschrieben wurde. Daher ist es möglich, dass es nicht wirklich der Stapel der Task ist, der diesen Speicher überschreibt, sondern dass etwas anderes diesen Speicher beschädigt, indem er darüber schreibt. Das Problem, das Sie mit dem uart-Interrupt bei hoher Last beschreiben (indem Sie einen Schlüssel gedrückt halten), könnte ein Hinweis auf ein Problem in der Interrupt-Service-Routine sein.

Haben Sie configASSERT() definiert?