Semaphores in Nucleus SE: Overzicht, Configuratie en API-Essenties

Semaphores zijn een fundamenteel mechanisme voor het synchroniseren van toegang tot gedeelde bronnen in embedded-systemen. Ze laten taken veilig controle over een bron verkrijgen en vrijgeven zonder conflicten.

Semaphores Gebruiken

In Nucleus SE wordt semaphore-ondersteuning ingeschakeld tijdens het build-proces. Een enkele applicatie kan maximaal 16 semaphores configureren. Als u ervoor kiest geen semaphores te gebruiken, worden de gerelateerde datastructuren en API-code uit de finale binary uitgesloten, wat de footprint reduceert.

Een semaphore is simpelweg een 8-bit counter wiens waarde beschermd is zodat meerdere taken het veilig kunnen manipuleren. Taken roepen Obtain aan om de counter te decrementeren en Release om het te incrementeren. Als een taak probeert een semaphore te obtainen wiens counter nul is, hangt het resultaat af van de API-opties en de systeemconfiguratie: de call kan een error returnen of de taak suspenderen totdat de semaphore beschikbaar wordt.

Semaphores Configureren

Aantal Semaphores

Semaphores worden gedefinieerd via #define statements in nuse_config.h. De sleutelmacro is NUSE_SEMAPHORE_NUMBER, wat specificatieert hoeveel semaphore-slots de applicatie zal gebruiken. De standaardwaarde is 0, wat geen semaphore-ondersteuning betekent. Geldige waarden lopen van 0 tot 16. Een ongeldige waarde triggert een compile-time error gegenereerd door nuse_config_check.h (ingeladen via nuse_config.c).

Het instellen van NUSE_SEMAPHORE_NUMBER op een non-zero waarde activeert het semaphore-subsysteem: datastructuren worden gesized, en API-enabling symbolen worden verwerkt.

API Enables

Elke Nucleus SE API-call wordt bewakt door een dedicated enabling-macro in nuse_config.h. Voor semaphores zijn de relevante symbolen:

• NUSE_SEMAPHORE_OBTAIN
• NUSE_SEMAPHORE_RELEASE
• NUSE_SEMAPHORE_RESET
• NUSE_SEMAPHORE_INFORMATION
• NUSE_SEMAPHORE_COUNT

Standaard zijn al deze macros ingesteld op FALSE, wat de corresponderende service-calls uitschakelt en hun implementatie uit de build uitsluit. Om een bepaalde API in te schakelen, stel de macro in op TRUE.

Hieronder een snippet uit het standaard nuse_config.h bestand:

#define NUSE_SEMAPHORE_NUMBER 0 /* Aantal semaphores in het systeem – 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 */

Een API-call inschakelen zonder semaphores geconfigureerd te hebben (behalve NUSE_Semaphore_Count(), wat altijd beschikbaar is) resulteert in een compile-time error. Als u een API aanroept die niet ingeschakeld is, treedt een link-time error op omdat de implementatie weggelaten werd.

Semaphore Service Calls

Nucleus SE biedt acht semaphore-gerelateerde service-calls. De eerste vijf zijn volledig geïmplementeerd; de overige drie zijn placeholders voor toekomstige uitbreidingen.

• Obtain – NUSE_Semaphore_Obtain()
• Release – NUSE_Semaphore_Release()
• Reset – NUSE_Semaphore_Reset()
• Information – NUSE_Semaphore_Information()
• Count – NUSE_Semaphore_Count()
• Create – niet geïmplementeerd in Nucleus SE
• Delete – niet geïmplementeerd in Nucleus SE
• List All – niet geïmplementeerd in Nucleus SE

Obtain en Release Operaties

De kern-semaphore-operaties zijn obtainen (decrementeren) en releasen (incrementeren). Nucleus RTOS biedt een flexibele obtain-API met optionele suspending en timeouts. Nucleus SE spiegelt dit gedrag, hoewel task-suspensie optioneel is en timeouts niet ondersteund worden.

Nucleus RTOS Obtain API

Prototype:

STATUS NU_Obtain_Semaphore(NU_SEMAPHORE *semaphore, UNSIGNED suspend);

Parameters:

semaphore – pointer naar het semaphore control block.

suspend – kan NU_NO_SUSPEND, NU_SUSPEND, of een timeout-waarde zijn.

Return-waarden:

NU_SUCCESS – operatie geslaagd.

NU_UNAVAILABLE – semaphore-waarde was nul.

NU_INVALID_SEMAPHORE – ongeldige semaphore-pointer.

NU_INVALID_SUSPEND – suspend geprobeerd vanuit non-task context.

NU_SEMAPHORE_WAS_RESET – semaphore gereset terwijl taak gesuspendeerd was.

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

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);

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;