Erika Enterprise ist ein open source OSEK konformes Echtzeitbetriebssystem (RTOS), das den STM32F4-Discovery Controller unterstützt. Außerdem gibt es eine eclipse Integration, sodass es möglich ist, Software direkt in der IDE zu entwickeln. In Kombination mit dem GNU ARM Eclipse Plugin und dem stlink Debugger/Programmer, sowie den GNU Tools for ARM Embedded Processors, wird eclipse zu einer Entwicklungsumgebung, die neben der eigentlichen Entwicklung des Codes, auch das Flashen und Debuggen auf der Hardware (in-circuit-debugging) von ERIKA RTOS basierten Anwendugen für den STM32F4-Discovery Controller ermöglicht. ERIKA kann auf der Projektseite runtergeladen werden. Um weitere Informationen zu der Installation bzw. Einrichtung der Plugins oder ERIKA zu erhalten, schauen Sie bitte in die entsprechenden Wikis und Foren auf den verlinkten Seiten.ERIKA wird über ein oil-File konfiguriert, welches die Parameter für den Kernel enthält. In dieser Datei gibt es verschiedene Einstellungsmöglichkeiten, die das Verhalten des Kernels beeinflussen. Neben diesen werden aber auch Abhängigkeiten zu externen Bibliotheken, wie beispielsweise dem Microcontroller Software Interface Standard (CMSIS), festgelegt.
Der Kernel unterstützt verschiedene Klassen von tasks (basic und extended tasks). Im Vergleich zu den basic tasks, unterstützen die extended tasks eine eventgesteuerte Synchronisation. Mehr Informationen zu den Klassen gibt es in der offiziellen Dokumentation, an dieser Stelle soll nicht weiter auf die Unterschiede eingegangen werden.
Der folgende Abschnitt beschreibt die Verwendung von ERIKA Enterprise mit extended tasks, also einem eventgesteuerten Scheduling auf dem STM32F4 Controller. Um diese Kernelkonfiguration einzusetzten, gibt es ein paar Parameter, die in der Konfigrationsdatei (*.oil) gesetzt werden müssen. Eine entsprechende Konfiguration sieht wie folgt aus:
CPU mySystem {
OS myOs {
CPU_CLOCK = 168.0;
MODEL = M4;
APP_SRC = "src/code.c";
APP_SRC = "src/pwm.c";
COMPILER_TYPE = GNU;
MULTI_STACK = TRUE {
IRQ_STACK = TRUE {
SYS_SIZE = 512;
};
};
EE_OPT = "DEBUG";
CFLAGS = "-std=c99";
};
MCU_DATA = STM32 {
MODEL = STM32F4xx;
};
Der STM32F4-discovery verfügt über einen ARM Cortex-M4 Prozessor, welcher mit 168 MHz getaktet wird. Der genaue Takt hängt von dem verwendeten Modell ab, in diesem Beispiel wurde ein STM32F407VG verwendet. Der APP_SRC Paramter listet die *.c Dateien auf, die mit dem Kernel kompiliert werden sollen. Um mehrere Dateien anzugeben, dann der Parameter einfach wiederholt werden. Die Entwicklung basiert auf dem GNU ARM Compiler und Debugger, deshalb wird der Parameter COMPILER_TYPE für die GNU toolchain konfiguriert. Um extended tasks zu verwenden, muss ein sogenannter MULTI_STACK mit einer statischen Größe konfiguriert werden. Der letzte Block in dem Ausschnitt der Konfigurationsdatei setzt den Controller.
Die Konfigurationsdatei wird außerdem dazu verwendet externe Bibliotheken, wie beispielsweise den ARM spezifischen CMSIS, einzubinden. Der folgende Ausschnitt zeigt, wie diese Bibliotheken eingebunden werden:
EE_OPT = "__USE_CMSIS_ALL__";
EE_OPT = "__USE_SPD_ALL__";
EE_OPT = "__USE_SYSTICK__";
EE_OPT = "__ADD_LIBS__";
LIB = ENABLE {
NAME = "ST_CMSIS";
};
LIB = ENABLE {
NAME = "STM32F4XX_SPD";
STM32F4XX_SPD = ENABLE {
USETIM = TRUE;
USEI2C = TRUE;
USEMISC = TRUE;
USESPI = TRUE;
USEUSART = TRUE;
};
};
LIB = ENABLE {
NAME = "STM32F4_DISCOVERY";
};
Die Parameter sind spezifisch für den STM32F4 Controller. Als nächstes wird das Scheduling des ERIKA Kernels konfiguriert. Der Kernel unterstützt insgesamt vier Klassen, die das Scheduling beieinflussen, sogenannte conformance classes (ECC1, ECC2, BCC1, BCC2). Die BCC Klassen unterstützen basic tasks, während die ECC Klassen die extended tasks unterstützen. Extended tasks erweitern die basic tasks um die Eigenschaft, durch events aktiviert zu werden. Für weitere Informationen zu diesen Klassen, schauen Sie bitte in das ERIKA reference manual. Um in der Konfigurationsdatei eine conformance class zu definieren, wird der folgende Paramter gesetzt:
KERNEL_TYPE = ECC1;
Als nächstes werden events und tasks definiert. In diesem Beispiel wird ein task definiert, der über ein event aktiviert werden kann. Dieser Task wird setPwmTask heißen und auf ein pwmEvent reagieren. Generell können tasks auf mehrere events reagieren. Diese müssen nur entsprechend in der Konfigurationsdatei festgelegt werden. Eine entsprechende Konfiguration eines tasks mit einem event sieht wie folgt aus:
EVENT pwmEvent {
MASK = AUTO;
};
TASK setPwmTask {
PRIORITY = 0x03; /* lower priority */
AUTOSTART = FALSE;
STACK = PRIVATE {
SYS_SIZE = 512;
};
ACTIVATION = 1; /* only one pending activation */
SCHEDULE = FULL;
EVENT = pwmEvent;
};
Anschließend werden der task und das event in der Implementierung deklariert, damit der task durch die Software aktiviert werden kann:
DeclareTask(setPwmTask);
DeclareEvent(pwmEvent);
TASK( setPwmTask) {
EventMaskType current;
while (1) {
if(WaitEvent(pwmEvent) == E_OK){
/* error handling */
}
getEvent(setPwmTask, ¤t); /* save event */
ClearEvent(pwmEvent);
/* do some fancy task work */
}
TerminateTask(); // never reached
}
Der letzte Schritt ist die Initialisierung des Kernels. Wurde diese durchgeführt, kann das eventbasierte Scheduling verwendet werden. Der folgende Codeausschnitt zeigt wie die Initialisierung des Kernels und die periodische Aktivierung des setPwmTask durch das pwmEvent durchgeführt werden kann:
#include "ee_api.h"
#include "kernel/oo/inc/ee_oo_api.h"
int main(void) {
/* Initialize Erika related stuff */
EE_system_init();
while (1) {
SetEvent(setPwmTask, pwmEvent);
Delay(MILLISECONDS_TO_TICKS(100, SystemCoreClock));
}
}
Mit ERIKA Enterprise bekommt man ein sehr schönes open source Echtzeitbetriebssystem, welche direkt in die eclipse IDE integriert werden kann. Die STM32F4 Unterstützung bietet einem alle netten features eines RTOS auf diesem Controller.