Effiziente Inter-Task Communication mit Nucleus SE Signals

In dieser RTOS Revealed Serie erkunden wir Signals – die simpelste, Low-Cost Methode für Inter-Task Communication in Nucleus SE. Signals ermöglichen leichtgewichtiges, zuverlässiges Message Passing zwischen Tasks.

Signals nutzen

Anders als andere Kernel Objects sind Signals nicht autonom; sie sind intrinsisch an einen Task gebunden und existieren nur innerhalb jenes Task's Context. Wenn Signals in einer Applikation enabled sind, erhält jeder Task automatisch ein Set von acht binary Signal Flags.

Jeder Task kann die Signal Flags eines anderen Tasks setzen. Allerdings darf nur der owning Task diese Flags lesen und clearen – und Reading ist destruktiv, meaning die Flags werden während der Read Operation resetet. Kein anderer Task kann den Signal State eines Tasks inspizieren oder modifizieren.

Nucleus RTOS bietet eine Facility, die einem Task erlaubt, einen Callback zu nominieren, der läuft, wenn ein anderer Task einen seiner Signal Flags setzt. Dies ist analog zu einem Interrupt Service Routine. Leider ist dieses Feature in Nucleus SE nicht verfügbar; Tasks müssen ihre Signal Flags explizit polen.

Signals konfigurieren

Signals werden primär durch #define Direktiven in nuse_config.h konfiguriert. Der Schlüssel Macro ist NUSE_SIGNAL_SUPPORT, welches, wenn auf TRUE gesetzt, Signal Support across der gesamten Applikation aktiviert. Die Anzahl Signals per Task ist fixiert auf acht; keine zusätzliche Konfiguration ist required.

Enabling Signals erstellt die notwendigen Data Structures und aktiviert die relevanten API Calls. Jede API Funktion in Nucleus SE hat ihr eigenes Enabling Macro. Für Signals sind folgende Enables definiert:

NUSE_SIGNALS_SEND NUSE_SIGNALS_RECEIVE

Standardmäßig sind beide auf FALSE gesetzt, disabling die entsprechenden Service Calls und omitting jeglichen Implementation Code. Um Signals zu nutzen, setzen Sie die gewünschten Enables auf TRUE. Failure to enable das API während Using eines Calls resultiert in Compile-Time Error; Using eines unimplementierten APIs verursacht Link-Time Error.

Sample Auszug aus nuse_config.h:

#define NUSE_SIGNAL_SUPPORT FALSE /* Enables support for signals */ #define NUSE_SIGNALS_SEND FALSE /* Service call enabler */ #define NUSE_SIGNALS_RECEIVE FALSE /* Service call enabler */

Signals Service Calls

Nucleus SE bietet vier primäre Service Calls related zu Signals. Nur zwei sind in SE implementiert; die anderen sind reserved für RTOS aber nicht SE.

• Signals an spezifizierten Task senden – NUSE_Signals_Send()
• Signals empfangen – NUSE_Signals_Receive()
• Signal Handler registrieren – nicht implementiert in SE
• Signals enable/disable – nicht implementiert in SE

Send und Receive Operationen

Signal Flags sind Bits, am besten visualisiert als Binary Numbers. Da Standard C keine Binary Literals hat, inkludiert Nucleus SE nuse_binary.h, welches Macros wie b01010101 für alle 256 8-Bit Werte definiert.

#define b00000000 ((U8)0x00) #define b00000001 ((U8)0x01) #define b00000010 ((U8)0x02) #define b00000011 ((U8)0x03) #define b00000100 ((U8)0x04) #define b00000101 ((U8)0x05)

Signals senden

Jeder Task kann ein oder mehrere Signal Flags auf einem anderen Task via OR Operation setzen – zuvor gesetzte Flags bleiben unverändert.

Nucleus RTOS API Call

STATUS NU_Send_Signals(NU_TASK *task, UNSIGNED signals);

Parameter:

• task – Pointer zum Control Block des Target Tasks
• signals – Wert der zu setzenden Signal Flags

Returns:

• NU_SUCCESS – Call succeeded
• NU_INVALID_TASK – Invalid Task Pointer

Nucleus SE API Call

STATUS NUSE_Signals_Send(NUSE_TASK task, U8 signals);

Parameter:

• task – Task Index (ID) des Target Tasks
• signals – Wert der zu setzenden Signal Flags

Returns:

• NUSE_SUCCESS – Call succeeded
• NUSE_INVALID_TASK – Invalid Task Index

Implementation von NUSE_Signals_Send()

STATUS NUSE_Signals_Send(NUSE_TASK task, U8 signals){ #if NUSE_API_PARAMETER_CHECKING if (task >= NUSE_TASK_NUMBER){ return NUSE_INVALID_TASK; } #endif NUSE_CS_Enter(); NUSE_Task_Signal_Flags[task] |= signals; NUSE_CS_Exit(); return NUSE_SUCCESS; }

Signals empfangen

Ein Task kann nur seine eigenen Signal Flags lesen, und die Operation ist destruktiv – die Flags werden beim Read gecleart.

Nucleus RTOS API Call

UNSIGNED NU_Receive_Signals(VOID);

Returns den aktuellen Signal Flag Wert.

Nucleus SE API Call

U8 NUSE_Signals_Receive(void);

Returns den aktuellen Signal Flag Wert.

Implementation von NUSE_Signals_Receive()

U8 NUSE_Signals_Receive(void){ U8 signals; NUSE_CS_Enter(); signals = NUSE_Task_Signal_Flags[NUSE_Task_Active]; NUSE_Task_Signal_Flags[NUSE_Task_Active] = 0; NUSE_CS_Exit(); return signals; }

Diese straightforward Funktionen illustrieren, wie Nucleus SE Signals effizient managed ohne Task Blocking oder Scheduling zu affecten.