mikrocontroller.net

Forum: Projekte & Code Cmsis RTOS RTX: Stack Kontrolle


Autor: Mehmet Kendi (mkmk)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Servus allerseits

Ich benutze hin und wieder CMSIS-RTOS RTX; nicht aber Keil.
Waehrend man in uVision den Stack-Zustand sehr bequem kontrollieren 
kann, zappelt man ohne diese IDE wie ein Fisch auf dem Lande.
Zumindest erging es mir so.
Mit Hilfe von http://www.keil.com/support/docs/3735.htm habe ich mir 
eine Notlösung zusammengeschustert.

Die Grundsteine bilden
typedef enum _task_id_pool_t
{
    MAIN_TASK = 0,
    SCAN_TASK,
    BTN_TASK,
    BTN_SHUTDOWN_TASK,
    LED_TASK,
    ADC_TASK,
    SHT21_TASK,
    MHZ19_TASK,
    ANZ_TASKS,
} task_id_pool_t ;
--
struct stru_task_id_pool
{
    osThreadId  id_nr;
    const char *name;
    uint16_t   stk_size;
    uint16_t   stk_used;
    uint16_t   stk_left;
    uint16_t   proz_used;
} ;

und
stru_task_id_pool task_id_pool[ANZ_TASKS];

Einen Thread muss man nach Erschaffung in diesen pool eintragen. Z.Bsp.:
    button_id  = osThreadCreate(osThread(ButtonTask), NULL);
    task_id_pool[BTN_TASK].id_nr = button_id;
    task_id_pool[BTN_TASK].name  = "BTN_TASK";

In main() wird alle 500ms die Funktion CheckThreadStacks() aufgerufen.
Desweiteren füge ich überall dort, wo ich eine expliziete Kontrolle 
durchfühen will, diese Zeilen ein:
#if defined(DEBUG)
        CheckThreadStacks(ANZ_TASKS, (uint8_t *)&task_id_pool);
#endif

Hat mir mein Leben um einiges erleichert.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo!
Vielen Dank für Deinen Code!
Ich habe genau das gleiche Problem und habe den Code implementiert.
Es sollte vielleicht erwähnt werden dass in RTX_Conf_CM.c die Option 
"OS_STKINIT" auf 1 stehen muss.
Der Code in main.cpp nach osKernelStart() wird nicht ausgeführt.
Dieser sollte ggf. in einem anderen Task stattfinden.

Eine Sache verstehe ich aber nicht ganz:

Das Programm erzeugt drei Tasks, einer davon wird aber nie bearbeitet:

TASK1: 0%
TASK2: 76%
TASK3: 60%

Bei TASK1 wird immer 0% stack usage angezeigt.

Irgendeine Idee?

Grüße,
Bernhard

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn ich 4 Tasks prüfen lasse obwohl nur 3 in der Liste sind, klappt 
auch die Anzeige des TASK1.
Kann es sein dass der Idle-Task irgendwo noch in die Quere kommt?

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe in stack_check.c die Zeile

for (tcb_idx = 0; tcb_idx < max_tasks; tcb_idx++)

in

for (tcb_idx = 1; tcb_idx < max_tasks+1; tcb_idx++)

abgeändert.
[0] ist der Idle-Task und der interessiert uns nicht.

Jetzt siehts aus als würde es klappen.
Wie siehst Du das?

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Zuerst einmal ein kleiner Bug-Report, den ich, weil sich für den Code 
bis heute niemand interessiert hat, nicht nachgereicht habe, um kein 
unnötiges Rauschen im Forum zu erzeugen:

Zeile 51:
*stk_used =  (size - ((virgin + 1))) * sizeof(stk);

sollte lauten:
*stk_used =  (size - virgin) * sizeof(stk);


Das mit dem Idle-Task hat mir am Anfang auch sehr viel Kopfzerbrechen 
bereitet. Aber nachdem was ich so gelesen habe und selbst ausprobiert 
habe, scheint Idle nicht analysiert zu werden.
task_id_pool[0].name ist bei mir stets die MAIN_TASK; also der erste 
Eintrag im task_id_pool_t.
Desweiteren setze ich das Array immer grösser als in Wirklichkeit 
gebraucht.
z.Zt. habe ich 18 Task; gesetzt habe ich aber extern stru_task_id_pool 
task_id_pool[20]
Erstens, weil es nicht schadet; und zweitens, weil ich im Eifer des 
Gefechts bei einem neuen Task dazu neige, das korrekte Nachzuführen 
dieses Array zu vergessen.

Deshalb kann Deine Beanstandung
for (tcb_idx = 1; tcb_idx < max_tasks+1; tcb_idx++)
durchaus richtig sein; weil Du ja das Array immer korrekt Deinem 
tatsaechlichen Bedarf anpassen tust.
Werde es mal in den kommendan Tagen in Ruhe nochmals durchgen und Dir 
Bescheid geben.

Danke für Dein Feedback.

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bernhard schrieb:
> Der Code in main.cpp nach osKernelStart() wird nicht ausgeführt.
> Dieser sollte ggf. in einem anderen Task stattfinden.

Bei mir ist das aber kein Problem. Normalerweise kommt ja nach 
osKernelStart() ein osDelay(osWaitForever), oder, wie in diesem Fall, 
ein Endlos-Loop.
Kannst Du mal Dein main() mal hier posten?

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für den Patch, den habe ich gerade implementiert!

Die for-Schleife die ich änderte betraf nicht die Struktur 
task_id_pool_t sondern die Task-Control-Blocks (TCB) des RTOS.
task_id_pool_t wird korrekt von 0 an ausgelesen (siehe Schleife in 
InsertValues) nur bei den TCBs ist TCB[0] offensichtlich der Idle-Task 
der uns ja nicht interessiert.
Jeder Task im System beginnt ab Index 1. Daher ist nach der Änderung 
auch die Ausgabe korrekt.

osKernelStart() initiiert das Task-Scheduling und kehrt nie zurück.

Trotzdem hier mein main()
int main(void)
{

  osKernelInitialize();

  // Init Hardware
  SYS_CPU_INIT();

  // Init debug UART
  dbg_init();


  // Init RTOS primitives
  TWI_RTOS_init();
  SSP_RTOS_init();

  // Create tasks
  diag_task_id = osThreadCreate(osThread(diag_task), NULL);
  ssp_task_id = osThreadCreate(osThread(ssp_task), NULL);
  main_task_id = osThreadCreate(osThread(main_task), NULL);

  task_id_pool[0].id_nr = main_task_id;
  task_id_pool[0].name  = "MAIN_TASK";

  task_id_pool[1].id_nr = ssp_task_id;
  task_id_pool[1].name  = "SSP_TASK";

  task_id_pool[2].id_nr = diag_task_id;
  task_id_pool[2].name  = "DIAG_TASK";

  // Start RTOS
  osKernelStart();

  for (;;);
}

Was die Größe der Arrays angeht: Ja, man kann bei genug RAM sicherlich 
gleich 10 oder mehr Einträge vorsehen. Das Problem dabei ist nur das 
wenn man sich um den Stack sorgen macht, meistens auch der RAM des 
Controllers reich befüllt ist.
Daher gehe ich auf Nummer sicher und definiere nur das was ich wirklich 
brauche.
Notfalls kann man ja auch mit einem

assert(max_tasks == (sizeof(task_id_pool)/sizeof(task_id_pool[0]));

schwerwiegende Fehler abfangen.

Autor: Bernhard (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Beiliegend meine aktuelle Arbeitskopie.

In main.c trägt man noch das ein, Beispiel für drei Tasks:
#include "stack_check.h"

task_id_pool_t task_id_pool[3];

int main(void)
{
 osKernelInitialize();

 task1_id = osThreadCreate(osThread(task1), NULL);
 task2_id = osThreadCreate(osThread(task2), NULL);
 task3_id = osThreadCreate(osThread(task3), NULL);

 task_id_pool[0].id_nr = task1_id;
 task_id_pool[0].name  = "TASK1";

 task_id_pool[1].id_nr = task2_id;
 task_id_pool[1].name  = "TASK2";

 task_id_pool[2].id_nr = task3_id;
 task_id_pool[2].name  = "TASK3";

 // Start RTOS
 osKernelStart();

 for (;;);
}

An beliebiger Stelle der Software veranlasst man die Prüfungen:
 CheckThreadStacks(3, task_id_pool);

Die Auslastung kann man sich hiermit anzeigen lassen:
 for (i = 0; i < 3; i++)
   printf("%s: %d%%\n", task_id_pool[i].name, task_id_pool[i].perc_used);

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bernhard schrieb:
> osKernelStart() initiiert das Task-Scheduling und kehrt nie zurück.

Aus dem CMSIS-RTOS RTX  Version 4.80 Reference Manual:
https://www.keil.com/pack/doc/CMSIS/RTX/html/group...

Returns
    status code that indicates the execution status of the function.

Start the RTOS Kernel and (...). The main thread will continue executing 
after osKernelStart.

Status and Error Codes
    osOK: the RTOS kernel has been successfully started.
    osErrorISR: osKernelStart cannot be called from interrupt service 
routines.

Also wenn bei Dir osKernelStart() nicht mehr zurückkehrt, muss irgendwas 
fehlgeschlagen haben.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
@Mehmet: Danke für den Hinweis, wird geprüft. Kann sein dass ich hier 
was verwechselt habe da ich mehrere unterschiedliche RTOS nutze. Ich 
dies zu entschuldigen.

Könnte man den Code noch erweitern dass man den sonstigen noch freien 
Speicherplatz im RAM angezeigt bekommt?

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Soweit ich es verstanden habe, wird in RTX_Conf_CM.c der RAM-Bedarf für 
das RTOS bekanntgegeben - und das wird dann beim Linken bereitgestellt. 
Was die MCU sonst noch an RAM hat, interessiert das RTOS nicht.
Auch ist natürlich zu hinterfragen, welches RAM man eruieren will: 
Stack? Heap?

Mit Stack ist es realiv einfach: man ruft eine Funktion auf, in der man 
die Adresse einer lokalen Variablen sich anschaut.
Beim Heap ist es etwas komplizierter. Die nachfolgende Funktion ist 
übrigens nicht auf meinem Mist gewachsen; ich glaube stammt von meiner 
Arbeit mit ChibiOS/RT, als ich Probleme mit dem Heap hatte.
//========================
// CheckHeapSize
//========================
void CheckHeapSize(void)
{
    extern uint8_t __heap_base__[];
    extern uint8_t __heap_end__[];
    const uint32_t MIN_HEAP_SIZE = 4 * 4096;

    static uint8_t *nextmem;
    static uint8_t *endmem;


    nextmem = (uint8_t *)MEM_ALIGN_NEXT(__heap_base__);
    endmem  = (uint8_t *)MEM_ALIGN_PREV(__heap_end__);
    //lint -e{732}    Loss of sign (assignment) (int to unsigned long)
    App.heap_size = endmem - nextmem;

    assert_param(App.heap_size > MIN_HEAP_SIZE);
    if (App.heap_size < MIN_HEAP_SIZE)
    while(1)
    {
        ;
    }
}

heap_base und heap_end müssen im Linker-File definiert werden.

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bernhard schrieb:
> Was die Größe der Arrays angeht: Ja, man kann bei genug RAM sicherlich
> gleich 10 oder mehr Einträge vorsehen. Das Problem dabei ist nur das
> wenn man sich um den Stack sorgen macht, meistens auch der RAM des
> Controllers reich befüllt ist.

Ich finde das keine so gute Idee. Wenn ich ein Projekt anwerfe, bei dem 
ich mir sicher bin, dass mir eine MCU mit 20kB RAM ausreicht, so löte 
ich auf die PCB, mit der ich meine Software entwickle, nichtsdestotrotz 
einen mit der max. erhaeltlichen Speichergrösse drauf.
Insbesondere bei Applikationen mir RTOS macht es echt keinen Spass, wenn 
man mit RAM geizig umgehen muss. Da sollte man schon mit der grossen 
Kelle ausschenken. Erst dann, wenn alles mehr oder weniger sauber 
laeuft, kann man dazu übergehen sich darüber Gedanken zu machen, wo ein 
Kaviarlöffel angebrachter waere.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn ich ein Projekt selbst in der Hand hätte, dann würde ich auch einen 
Controller mit viel RAM nutzen.

Anders wenn man für eine vorgegebene Hardware eine Software entwickeln 
soll.
Derzeit hat mein Controller 8kB RAM. Andere pincompatible Controller mit 
mehr RAM gibts leider nicht.

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
In der Tat kann man da nicht mit der Kelle hantieren :)
Noch ein Tipp: alles was nicht einer Task gehört, gehört der Main-Task. 
Wenn Du also waehend der Entwicklung noch RAM zu vergeben hast, dann 
vergebe es der Main-Task.
Das hatte ich anfaenglich nicht beachtet.


Eine Frage: ist es Dir gelungen in RTX_Conf_CM.c den Wert von OS_STKSIZE 
zu aendern? Da kann ich machen was ich will; es bleibt stur bei 200 
Bytes.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der Wert von OS_STKSIZE steht bei mir fest auf 50.
Defaultwert sind 200 Words, also 400 Bytes.
Das funktioniert einwandfrei.

Gerade habe ich nochmal nachgeprüft, nach dem Aufruf von 
osKernelStart(); kehrt die Funktion definitiv nicht zurück.

Meine main() Funktion hatte ich oben schon gepostet.
Geprüft habe ich das folgendermaßen:
// Start RTOS
osKernelStart();

for (;;) {
 osDelay(500);
 CheckThreadStacks(3, task_id_pool);
}

Die Werte im task_id_pool stehen auch nach Minuten immernoch auf 0. Hier 
wird nichts berechnet.
Wenn ich die Funktion CheckThreadStacks in eine andere Task setze, dann 
klappts einwandfrei.

Ich kann übrigens auch ein NVIC_SystemReset(); nach dem osKernelStart(); 
setzen, das System läuft ohne Unterbrechung weiter...

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bernhard schrieb:
> Der Wert von OS_STKSIZE steht bei mir fest auf 50.

Schon klar; ich wollte nur wissen, ob Du diesen Standartwert aendern 
kannst. Ich konnte es naemlich nicht.

Wenn Du aus dem osKernelStart() nicht mehr zurückkehrtst ... hast Du 
möglicherweise Tasks mit höherer Prioritaeten? In diesem Fall musst Du 
aber schon dafür sorgen, dass auch Tasks mit niedrigen Prioritaeten zum 
Zug kommen.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>Schon klar; ich wollte nur wissen, ob Du diesen Standartwert aendern
>kannst. Ich konnte es naemlich nicht.

Ja, den konnte ich ändern, funktioniert einwandfrei.
Umgebung: gcc auf Konsole :)

>Wenn Du aus dem osKernelStart() nicht mehr zurückkehrtst ... hast Du
>möglicherweise Tasks mit höherer Prioritaeten?

Die Tasks haben alle osPriorityNormal.

main() selbst ist bei mir kein eigener Task, das wäre nur bei z.B. Keil 
mit der Microlib so. Siehe RTX_CM_lib.h ab Zeile 254 (RTX v4.80)

Autor: Pic Tech (pic)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wieviel tasks sowie welche IPC brauchst du? Eventuell habe ich was 
kleineres.

Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Eigentlich brauche ich nur 2 Tasks, ein Main-Task und ein Task als 
Treiber für einen Kommunikationschip. Als IPC nutze ich nur 
SendMessage/GetMessage

Im Grunde würde ein einfacher Task-Scheduler ohne Prioritätem schon 
reichen, CMSIS RTX war bisher die erste Wahl da gut dokumentiert, frei 
verwendbar und einfach zu implementieren.

Autor: Mehmet Kendi (mkmk)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Bei 2 Tasks würde ich persönlich Protothreads benutzen.

Autor: Pic Tech (pic)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich bin noch 1 woche in Urlaub, errinnere mich eventuell wenn ich 
vergesse den code sowie die RAM Analyse zu posten, rtx MIT cmsis glue .h 
file

Autor: Random ... (thorstendb) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,

ich hab ähnliches beim alten RTX gemacht. Mich interessierte aber nur 
die maximale Stack Auslastung zwecks Optimierung.

Dazu einfach die Stacks (User defined Stacks bei mir) vor der OS 
Initialisierung (im CMSIS RTOS in der SystemInit() bzw. pre-main) per 
memset auf 0xcc setzen und dann zur Laufzeit mit einen Memory Window 
beobachten.

: Bearbeitet durch User
Autor: Bernhard (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Protothreads ist leider nicht verwendbar.
Ich brauche ein richtiges OS mit getrennt voneinander laufenden Tasks.
CMSIS RTX macht das eigentlich schon ganz gut, auch hinsichtlich 
Resourcenverbrauch.
Wenn jemand was anderes kennt bin ich gerne Interessiert.

Autor: LTC1043 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
scmrtos ist ganz schön schlank :-) und vile Details elegant gelöst.

http://scmrtos.sourceforge.net/ScmRTOS
https://github.com/scmrtos/scmrtos

Cheers

Autor: Andi (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich nutze:

RTX 5.0.0
CMSIS-RTOS2  Version 2.1.1

gibt es hier auch eine Möglichkeit die Stack Kontrolle zu 
implementieren?

bei mir scheitert es daran das os_Stackinfo und os_active_TCB ( beide 
jeweils in der RTX_CM_lib.h definiert) unbekannt sind -->RTX_CM_lib.h 
gibts nicht bei der V2)

hat das schon mal jemand probiert?

Nutzt jemand die V2.1.1 und hat eine Lösung parat die proz. sich 
anzeigen zu lassen?

für die Stacksize gibt es ja eine implementierte Funktion.

Grüße

Andi

Autor: Andreas H. (Firma: Infineon) (andreas11)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Andi schrieb:
> Hallo,
>
> ich nutze:
>
> RTX 5.0.0
> CMSIS-RTOS2  Version 2.1.1
>
> gibt es hier auch eine Möglichkeit die Stack Kontrolle zu
> implementieren?
>
> bei mir scheitert es daran das os_Stackinfo und os_active_TCB ( beide
> jeweils in der RTX_CM_lib.h definiert) unbekannt sind -->RTX_CM_lib.h
> gibts nicht bei der V2)
>
> hat das schon mal jemand probiert?
>
> Nutzt jemand die V2.1.1 und hat eine Lösung parat die proz. sich
> anzeigen zu lassen?
>
> für die Stacksize gibt es ja eine implementierte Funktion.
>
> Grüße
>
> Andi

Hallo,

bitte obigen Beitrag ignorieren. Ich hatte einen Denkfehler:) Hat sich 
alles geklärt...

Grüße

Andi

Autor: Nop (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mehmet K. schrieb:

> In main() wird alle 500ms die Funktion CheckThreadStacks() aufgerufen.

Ich sehe nicht so recht, wozu das überhaupt gut sein sein soll. Man muß 
sowieso auf maximale Stack Usage auslegen, und die durch Ausprobieren 
ermitteln zu wollen, ist grober Pfusch. Das ermittelt man durch den Call 
Graph.

Autor: Andreas H. (Firma: Infineon) (andreas11)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nop schrieb:
> Das ermittelt man durch den Call
> Graph.

und das soll wie genau funktionieren? Kannst du das bitte genauer 
erklären?

Autor: Nop (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Andreas H. schrieb:

> und das soll wie genau funktionieren? Kannst du das bitte genauer
> erklären?

Mit Keil drückt man auf "build project" und guckt sich dann den Call 
Graph an. Der wirft einem automatisch die maximale Stacktiefe jeder 
Funktion mit Unteraufrufen aus. Der Bedarf eines Tasks ist dann die 
Tiefe der Entry-Funktion. Plus noch Sicherheitsspielraum, damit man 
nicht bei jeder kleinen Code-Änderung erneut gucken muß.

Beim GCC ist das etwas hakeliger. Man gibt -fstack-usage mit, bekommt 
dann aber nur pro Funktion den Bedarf ohne Aufrufe. Hab aber mal im Netz 
dazu ein Perl-Script gesehen, was das aufaddieren kann, solange man 
keine Rekursion verwendet. Oder, solange es ein überschaubares Projekt 
ist, kann man das von Hand machen. Muß man dann aber pro Aufruf noch ein 
paar Bytes extra einrechnen, das hängt von der Plattform und der 
verwendeten calling convention ab.

Mit reinem Testen wäre das nur dann akzeptabel, wenn man gleichzeitig 
100% Code-Coverage bekommt, denn sonst weiß man doch gar nicht, ob der 
Zweig mit der schlimmsten Tiefe überhaupt durchlaufen wurde (speziell, 
wenn es dabei um Fehlerbehandlung geht), und die Maximal-Zahl ist von 
fragwürdiger Bedeutung.

Ob der Stackbedarf für Interrupts auf die Task-Stacks addiert werden muß 
oder nicht, hängt davon ab, ob man keinen separaten Interrupt-Stack hat 
(dann ja) oder doch - dann nein, aber der dedizierte Interrupt-Stack muß 
groß genug sein für das worst-case-nesting. Jedenfalls darf man die 
nicht bei der Betrachtung vergessen.

Übrigens kann es hier fatal wirken, wenn man im Debug-Build brav testet 
und dann beim Release sich wundert, wieso es knallt. Na weil im 
Debug-Build mit O0 nicht ge-inlined wird, im Release mit O2 aber schon. 
Der Effekt kann der sein, daß zwei Stack-intensive Funktionen, die 
vorher nacheinander aufgerufen werden, dann in dieselbe Funktion 
rutschen. Je nachdem, was der Compiler dann macht, kann sich deren 
Stackbedarf dann addieren.

Das ist speziell wahrscheinlich, wenn man genau deswegen stackintensives 
Zeugs in eine eigene Funktion ausgelagert hat, die aber nur einmal 
aufgerufen wird. Abhilfe kann dann durchaus sein, an den richtigen 
Stellen mit noinline-Attributen das Inlining zu verhindern. Dazu muß man 
sich halt  den Call Graph bei der relevanten Optimierungsstufe angucken.

Autor: Nop (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nachtrag: das funktioniert natürlich nicht mehr, wenn man innerhalb der 
Tasks mit Funktionspointern arbeitet, die erst zur Laufzeit bestimmt 
werden. Was auch der Grund ist, wieso man das nach MISRA nicht darf, und 
dann muß man halt 100% Coverage hinbekommen. Oder man macht's nach dem 
Prinzip Hoffnung, wenn es letztlich egal ist, wie zuverlässig das Gerät 
am Ende arbeitet.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.