Semaphores in Nucleus SE: Überblick, Konfiguration und API Essentials

View the RTOS Revealed series

Semaphores sind ein fundamentaler Mechanismus zur Synchronisierung von Zugriff auf Shared Resources in Embedded Systems. Sie erlauben Tasks, sicher Control über eine Resource zu erhalten und freizugeben, ohne Konflikte.

Semaphores nutzen

In Nucleus SE wird Semaphore Support während des Build Prozesses enabled. Eine einzelne Applikation kann bis zu 16 Semaphores konfigurieren. Wenn Sie auf Semaphores verzichten, werden die zugehörigen Data Structures und API Code vom finalen Binary excluded, was Footprint reduziert.

Ein Semaphore ist einfach ein 8-Bit Counter, dessen Wert so geschützt ist, dass multiple Tasks ihn sicher manipulieren können. Tasks rufen Obtain auf, um den Counter zu dekrementieren, und Release, um ihn zu inkrementieren. Wenn ein Task versucht, einen Semaphore zu obtain, dessen Counter Null ist, hängt das Outcome von API Optionen und System Konfiguration ab: Der Call kann einen Error returnen oder den Task suspenden, bis der Semaphore verfügbar wird.

Semaphores konfigurieren

Anzahl Semaphores

Semaphores werden via #define Statements in nuse_config.h definiert. Der Schlüssel Macro ist NUSE_SEMAPHORE_NUMBER, der spezifiziert, wie viele Semaphore Slots die Applikation nutzen wird. Der Default Wert ist 0, was keinen Semaphore Support bedeutet. Gültige Werte reichen von 0 bis 16. Ein invalid Wert triggert einen Compile-Time Error generiert von nuse_config_check.h (inkludiert durch nuse_config.c).

Das Setzen von NUSE_SEMAPHORE_NUMBER auf einen Non-Zero Wert aktiviert das Semaphore Subsystem: Data Structures werden entsprechend gesized, und API Enabling Symbols werden verarbeitet.

API Enables

Jeder Nucleus SE API Call wird durch ein dediziertes Enabling Macro in nuse_config.h guarded. Für Semaphores sind die relevanten Symbole:

• NUSE_SEMAPHORE_OBTAIN
• NUSE_SEMAPHORE_RELEASE
• NUSE_SEMAPHORE_RESET
• NUSE_SEMAPHORE_INFORMATION
• NUSE_SEMAPHORE_COUNT

Standardmäßig sind alle diese Macros auf FALSE gesetzt, was die entsprechenden Service Calls disabled und ihre Implementation vom Build excluded. Um ein particular API zu enablen, setzen Sie sein Macro auf TRUE.

Unten ein Snippet aus dem Default nuse_config.h File:

#define NUSE_SEMAPHORE_NUMBER 0 /* Number of semaphores in the system – 0‑16 */ #define NUSE_SEMAPHORE_OBTAIN FALSE /* Service call enabler */ #define NUSE_SEMAPHORE_RELEASE FALSE /* Service call enabler */ #define NUSE_SEMAPHORE_RESET FALSE /* Service call enabler */ #define NUSE_SEMAPHORE_INFORMATION FALSE /* Service call enabler */ #define NUSE_SEMAPHORE_COUNT FALSE /* Service call enabler */

Enablen eines API Calls ohne konfigurierte Semaphores (außer NUSE_Semaphore_Count(), das immer verfügbar ist) resultiert in einem Compile-Time Error. Wenn Sie ein API aufrufen, das nicht enabled wurde, tritt ein Link-Time Error auf, weil die Implementation omitted wurde.

Semaphore Service Calls

Nucleus SE bietet acht Semaphore-bezogene Service Calls. Die ersten fünf sind voll implementiert; die verbleibenden drei sind Placeholder für zukünftige Extensions.

• Obtain – NUSE_Semaphore_Obtain()
• Release – NUSE_Semaphore_Release()
• Reset – NUSE_Semaphore_Reset()
• Information – NUSE_Semaphore_Information()
• Count – NUSE_Semaphore_Count()
• Create – nicht implementiert in Nucleus SE
• Delete – nicht implementiert in Nucleus SE
• List All – nicht implementiert in Nucleus SE

Obtain und Release Operationen

Die Kern Semaphore Operationen sind Obtaining (Decrementing) und Releasing (Incrementing). Nucleus RTOS bietet ein flexibles Obtain API mit optionaler Suspension und Timeouts. Nucleus SE spiegelt dieses Verhalten wider, though Task Suspension optional ist und Timeouts nicht supported sind.

Nucleus RTOS Obtain API

Prototype:

STATUS NU_Obtain_Semaphore(NU_SEMAPHORE *semaphore, UNSIGNED suspend);

Parameter:

semaphore – Pointer zum Semaphore Control Block.

suspend – kann NU_NO_SUSPEND, NU_SUSPEND, oder ein Timeout Wert sein.

Return Values:

NU_SUCCESS – Operation succeeded.

NU_UNAVAILABLE – Semaphore Wert war Null.

NU_INVALID_SEMAPHORE – Invalid Semaphore Pointer.

NU_INVALID_SUSPEND – Suspend attempted from Non-Task Context.

NU_SEMAPHORE_WAS_RESET – Semaphore reset während Task suspended war.

Nucleus SE Obtain API

Prototype:

STATUS NUSE_Semaphore_Obtain(NUSE_SEMAPHORE semaphore, U8 suspend);

Parameter:

semaphore – der Semaphore Index.

suspend – kann NUSE_NO_SUSPEND oder NUSE_SUSPEND sein.

Return Values:

NUSE_SUCCESS – Operation succeeded.

NUSE_UNAVAILABLE – Semaphore Wert war Null.

NUSE_INVALID_SEMAPHORE – Invalid Semaphore Index.

NUSE_INVALID_SUSPEND – Suspend attempted from Non-Task oder Blocking APIs disabled.

NUSE_SEMAPHORE_WAS_RESET – Semaphore reset während Suspension.

Implementation Highlights

Wenn Blocking disabled ist, checkt die Implementation einfach, ob der Counter non-zero ist, dekrementiert ihn, und returned NUSE_SUCCESS. Wenn der Counter Null ist, returned sie NUSE_UNAVAILABLE.

if (NUSE_Semaphore_Counter[semaphore] != 0) { NUSE_Semaphore_Counter[semaphore]--; return_value = NUSE_SUCCESS; } else { return_value = NUSE_UNAVAILABLE; }

Wenn Blocking enabled ist, enteret die Routine einen do…while Loop, der versucht, den Semaphore zu erwerben. Wenn der Counter Null ist und suspend NUSE_SUSPEND ist, wird der Task blocked. Bei Release wird der erste wartende Task geweckt und der Loop retried den Erwerb.

do { if (NUSE_Semaphore_Counter[semaphore] != 0) { NUSE_Semaphore_Counter[semaphore]--; return_value = NUSE_SUCCESS; suspend = NUSE_NO_SUSPEND; } else { if (suspend == NUSE_NO_SUSPEND) { return_value = NUSE_UNAVAILABLE; } else { NUSE_Semaphore_Blocking_Count[semaphore]++; NUSE_Suspend_Task(NUSE_Task_Active, semaphore << 4 | NUSE_SEMAPHORE_SUSPEND); return_value = NUSE_Task_Blocking_Return[NUSE_Task_Active]; if (return_value != NUSE_SUCCESS) { suspend = NUSE_NO_SUSPEND; } } } } while (suspend == NUSE_SUSPEND);

Nucleus RTOS Release API

Prototype:

STATUS NU_Release_Semaphore(NU_SEMAPHORE *semaphore);

Parameter:

semaphore – Pointer zum Semaphore Control Block.

Return Values:

NU_SUCCESS – Operation succeeded.

NU_INVALID_SEMAPHORE – Invalid Semaphore Pointer.

Nucleus SE Release API

Prototype:

STATUS NUSE_Semaphore_Release(NUSE_SEMAPHORE semaphore);

Parameter:

semaphore – der Semaphore Index.

Return Values:

NUSE_SUCCESS – Operation succeeded.

NUSE_INVALID_SEMAPHORE – Invalid Semaphore Index.

NUSE_UNAVAILABLE – Counter bereits bei 255; kann nicht inkrementieren.

Implementation Highlights

Die Release Routine prüft zuerst, ob der Counter unter seinem Maximum (255) ist. Wenn ja, inkrementiert sie den Counter. Wenn Blocking enabled ist und Tasks auf diesem Semaphore warten, wird der erste geweckt.

NUSE_CS_Enter(); if (NUSE_Semaphore_Counter[semaphore] < 255) { NUSE_Semaphore_Counter[semaphore]++; return_value = NUSE_SUCCESS; #if NUSE_BLOCKING_ENABLE if (NUSE_Semaphore_Blocking_Count[semaphore] != 0) { NUSE_Semaphore_Blocking_Count[semaphore]--; for (U8 index = 0; index < NUSE_TASK_NUMBER; index++) { if ((LONIB(NUSE_Task_Status[index]) == NUSE_SEMAPHORE_SUSPEND) && (HINIB(NUSE_Task_Status[index]) == semaphore)) { NUSE_Task_Blocking_Return[index] = NUSE_SUCCESS; NUSE_Wake_Task(index); break; } } } #endif } else { return_value = NUSE_UNAVAILABLE; } NUSE_CS_Exit(); return return_value;

Wenn Tasks auf einem Semaphore suspended sind, weckt das Releasen den ersten wartenden Task, erlaubend ihm, Execution fortzusetzen.

Der nächste Artikel wird Event Flag Groups und ihre zugehörigen Data Structures erkunden.

---

Colin Walls hat über dreißig Jahre Erfahrung in der Elektronik Industrie, primär fokussiert auf Embedded Software. Er präsentiert häufig auf Conferences, schreibt technische Artikel, und authored zwei Bücher über Embedded Software. Colin ist Embedded Software Technologist mit Mentor Embedded (der Mentor Graphics Embedded Software Division) und basiert in UK. Sein Blog ist bei https://blogs.mentor.com/colinwalls. Erreichen Sie ihn per Email an colin_walls@mentor.com.