Semáforos no Nucleus SE: Visão Geral, Configuração e APIs Essenciais

Veja a série RTOS Revealed

Semáforos são mecanismo fundamental para sincronizar acesso a recursos compartilhados em sistemas embarcados. Eles permitem que tarefas obtenham e liberem controle sobre recurso com segurança, sem conflitos.

Usando Semáforos

No Nucleus SE, suporte a semáforos é habilitado durante processo de build. Uma única aplicação pode configurar até 16 semáforos. Se optar por não usar semáforos, estruturas de dados e código API relacionados são excluídos do binário final, reduzindo footprint.

Um semáforo é simplesmente contador de 8 bits cujo valor é protegido para que múltiplas tarefas possam manipulá-lo com segurança. Tarefas chamam Obtain para decrementar contador e Release para incrementá-lo. Se tarefa tenta obter semáforo cujo contador é zero, resultado depende das opções da API e configuração do sistema: chamada pode retornar erro ou suspender tarefa até semáforo ficar disponível.

Configurando Semáforos

Número de Semáforos

Semáforos são definidos via declarações #define em nuse_config.h. Macro-chave é NUSE_SEMAPHORE_NUMBER, que especifica quantos slots de semáforo a aplicação usará. Valor padrão é 0, significando sem suporte a semáforo. Valores válidos variam de 0 a 16. Valor inválido dispara erro de compilação gerado por nuse_config_check.h (incluído através de nuse_config.c).

Definir NUSE_SEMAPHORE_NUMBER para valor não-zero ativa subsistema de semáforo: estruturas de dados são dimensionadas adequadamente, e símbolos de habilitação da API são processados.

Habilitações da API

Cada chamada de API Nucleus SE é guardada por macro de habilitação dedicada em nuse_config.h. Para semáforos, símbolos relevantes são:

• NUSE_SEMAPHORE_OBTAIN
• NUSE_SEMAPHORE_RELEASE
• NUSE_SEMAPHORE_RESET
• NUSE_SEMAPHORE_INFORMATION
• NUSE_SEMAPHORE_COUNT

Por padrão, todas macros são FALSE, desabilitando chamadas de serviço correspondentes e excluindo implementação do build. Para habilitar API particular, defina sua macro como TRUE.

Trecho do nuse_config.h padrão:

#define NUSE_SEMAPHORE_NUMBER 0 /* Número de semáforos no sistema – 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 */

Habilitar chamada de API sem configurar semáforos (exceto NUSE_Semaphore_Count(), sempre disponível) resulta em erro de compilação. Se chamar API não habilitada, erro de link ocorre porque implementação foi omitida.

Chamadas de Serviço de Semáforo

Nucleus SE oferece oito chamadas de serviço relacionadas a semáforos. As cinco primeiras são totalmente implementadas; as três restantes são placeholders para extensões futuras.

• Obtain – NUSE_Semaphore_Obtain()
• Release – NUSE_Semaphore_Release()
• Reset – NUSE_Semaphore_Reset()
• Information – NUSE_Semaphore_Information()
• Count – NUSE_Semaphore_Count()
• Create – não implementado no Nucleus SE
• Delete – não implementado no Nucleus SE
• List All – não implementado no Nucleus SE

Operações Obtain e Release

Operações centrais de semáforo são obter (decrementar) e liberar (incrementar). Nucleus RTOS fornece API obtain flexível com suspensão opcional e timeouts. Nucleus SE espelha esse comportamento, embora suspensão de tarefa seja opcional e timeouts não suportados.

API Obtain do Nucleus RTOS

Protótipo:

STATUS NU_Obtain_Semaphore(NU_SEMAPHORE *semaphore, UNSIGNED suspend);

Parâmetros:

semaphore – ponteiro para bloco de controle do semáforo.

suspend – pode ser NU_NO_SUSPEND, NU_SUSPEND, ou valor de timeout.

Valores de retorno:

NU_SUCCESS – operação sucedeu.

NU_UNAVAILABLE – valor do semáforo era zero.

NU_INVALID_SEMAPHORE – ponteiro de semáforo inválido.

NU_INVALID_SUSPEND – suspensão tentada de contexto non-task.

NU_SEMAPHORE_WAS_RESET – semáforo resetado enquanto tarefa suspensa.

API Obtain do Nucleus SE

Protótipo:

STATUS NUSE_Semaphore_Obtain(NUSE_SEMAPHORE semaphore, U8 suspend);

Parâmetros:

semaphore – índice do semáforo.

suspend – pode ser NUSE_NO_SUSPEND ou NUSE_SUSPEND.

Valores de retorno:

NUSE_SUCCESS – operação sucedeu.

NUSE_UNAVAILABLE – valor do semáforo era zero.

NUSE_INVALID_SEMAPHORE – índice de semáforo inválido.

NUSE_INVALID_SUSPEND – suspensão tentada de non-task ou blocking APIs desabilitadas.

NUSE_SEMAPHORE_WAS_RESET – semáforo resetado durante suspensão.

Destaques da Implementação

Quando blocking desabilitado, implementação simplesmente verifica se contador não-zero, decrementa e retorna NUSE_SUCCESS. Se contador zero, retorna NUSE_UNAVAILABLE.

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

Quando blocking habilitado, rotina entra em loop do…while que tenta adquirir semáforo. Se contador zero e suspend é NUSE_SUSPEND, tarefa é bloqueada. Após release, primeira tarefa esperando é acordada e loop retenta aquisição.

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

API Release do Nucleus RTOS

Protótipo:

STATUS NU_Release_Semaphore(NU_SEMAPHORE *semaphore);

Parâmetros:

semaphore – ponteiro para bloco de controle do semáforo.

Valores de retorno:

NU_SUCCESS – operação sucedeu.

NU_INVALID_SEMAPHORE – ponteiro de semáforo inválido.

API Release do Nucleus SE

Protótipo:

STATUS NUSE_Semaphore_Release(NUSE_SEMAPHORE semaphore);

Parâmetros:

semaphore – índice do semáforo.

Valores de retorno:

NUSE_SUCCESS – operação sucedeu.

NUSE_INVALID_SEMAPHORE – índice de semáforo inválido.

NUSE_UNAVAILABLE – contador já em 255; não pode incrementar.

Destaques da Implementação

Rotina de release primeiro verifica se contador abaixo do máximo (255). Se sim, incrementa contador. Se blocking habilitado e há tarefas esperando neste semáforo, a primeira é acordada.

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;

Quando tarefas estão suspensas em semáforo, liberá-lo acorda a primeira tarefa esperando, permitindo que continue execução.

O próximo artigo explorará event flag groups e suas estruturas de dados relacionadas.

---

Colin Walls tem mais de trinta anos de experiência na indústria eletrônica, focado principalmente em software embarcado. Frequentemente apresenta em conferências, escreve artigos técnicos, e autorou dois livros sobre software embarcado. Colin é tecnólogo de software embarcado na Mentor Embedded (Divisão de Software Embarcado da Mentor Graphics) e baseado no UK. Seu blog está em https://blogs.mentor.com/colinwalls. Contate-o em colin_walls@mentor.com.