Sinais

Neste RTOS Revelado, irei olhar para os sinais, que são o método mais simples de comunicação entre tarefas suportado pelo Nucleus SE. Eles fornecem um meio de custo muito baixo de passar mensagens simples entre tarefas.

Usando sinais

Os sinais são diferentes de todos os outros tipos de objeto do kernel porque não são autônomos - os sinais são associados a tarefas e não têm existência independente. Se os sinais forem configurados para uma aplicação, cada tarefa terá um conjunto de oito sinalizadores.

Qualquer tarefa pode definir os sinais de outra tarefa. Apenas a tarefa do proprietário pode ler os sinais. A leitura é destrutiva - ou seja, os sinais são limpos pelo processo de leitura. Nenhuma outra tarefa pode ler ou limpar os sinais de uma tarefa.

Há um recurso no Nucleus RTOS que permite a uma tarefa nomear uma função que é executada quando outra tarefa define um ou mais de seus sinalizadores. Isso é um tanto análogo a uma rotina de serviço de interrupção. Este recurso não é compatível com o Nucleus SE; as tarefas precisam interrogar seus sinalizadores explicitamente.

Configuração de sinais

Tal como acontece com a maioria dos aspectos do Nucleus SE, a configuração dos sinais é controlada principalmente por #define declarações em nuse_config.h . A configuração principal é NUSE_SIGNAL_SUPPORT , que ativa o recurso (para todas as tarefas no aplicativo). Não há questão de especificar o número de sinais - há simplesmente um conjunto de oito sinalizadores para cada tarefa no aplicativo.

Definir este parâmetro de habilitação é “habilitar mestre” para sinais. Isso faz com que uma estrutura de dados seja definida e dimensionada de acordo, o que veremos mais adiante neste artigo. Ele também ativa as configurações de ativação da API.

Ativa API

Cada função de API (chamada de serviço) no Nucleus SE tem um #define de ativação símbolo em nuse_config.h . Para sinais, são:

  NUSE_SIGNALS_SENDNUSE_SIGNALS_RECEIVE  

Por padrão, ambos são definidos como FALSO , desabilitando cada chamada de serviço e inibindo a inclusão de qualquer código de implementação. Para configurar sinais para um aplicativo, você precisa selecionar as chamadas de API que deseja usar e definir seus símbolos de ativação para TRUE .

Aqui está um trecho do padrão nuse_config.h Arquivo:

  #define NUSE_SIGNAL_SUPPORT FALSE / * Ativa o suporte para sinais * / # define NUSE_SIGNALS_SEND FALSE / * Ativador de chamada de serviço * / # define NUSE_SIGNALS_RECEIVE FALSE / * Ativador de chamada de serviço * /  

Um erro de tempo de compilação ocorrerá se uma função API de sinais estiver habilitada e o recurso de sinais não tiver sido habilitado. Se o seu código usar uma chamada de API, que não foi habilitada, ocorrerá um erro de tempo de link, pois nenhum código de implementação terá sido incluído no aplicativo. Claro, a habilitação das duas funções API é um tanto redundante, pois não haveria nenhum ponto em habilitar o suporte a sinais e não ter essas APIs disponíveis. As habilitações são incluídas para compatibilidade com outros recursos do Nucleus SE.

Chamadas de serviço de sinais

O Nucleus RTOS suporta quatro chamadas de serviço que pertencem aos sinais, que fornecem a seguinte funcionalidade:

• Envie sinais para uma tarefa especificada. Implementado por NUSE_Signals_Send () no Núcleo SE.
  

• Receber sinais. Implementado por NUSE_Signals_Receive () no Núcleo SE.
  

• Registre um manipulador de sinal. Não implementado no Nucleus SE.
  

• Ativar / desativar (controlar) sinais. Não implementado no Nucleus SE.
  

A implementação de cada uma dessas chamadas de serviço é examinada em detalhes.

Serviços de envio e recebimento de sinais

As operações fundamentais, que podem ser realizadas no conjunto de sinais de uma tarefa, são o envio de dados a ela (o que pode ser feito por qualquer tarefa) e a leitura de dados a partir dela (e assim limpar os dados, o que só pode ser feito pelo proprietário) . O Nucleus RTOS e o Nucleus SE fornecem, cada um, duas chamadas API básicas para essas operações, que serão discutidas aqui.

Como os sinalizadores de sinais são bits, eles são mais bem visualizados como números binários. Como o padrão C não suporta historicamente uma representação de constantes binárias (apenas octal e hexadecimal), a distribuição do Nucleus SE inclui um arquivo de cabeçalho útil - nuse_binary.h - que contém #define símbolos da forma b01010101 para todos os 256 valores de 8 bits. Aqui está um trecho de nuse_binary.h Arquivo:

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

Enviando sinais

Qualquer tarefa pode enviar sinais para qualquer outra tarefa no aplicativo. O envio de sinais envolve a configuração de um ou mais sinalizadores. Esta é uma operação OR que não tem efeito sobre os sinalizadores definidos anteriormente.

Chamada de Nucleus RTOS API para envio de sinais

Protótipo de chamada de serviço:

STATUS NU_Send_Signals (tarefa NU_TASK *, sinais UNSIGNED);

Parâmetros:

tarefa - ponteiro para controlar o bloco da tarefa que possui os sinalizadores a serem definidos

sinais - o valor dos sinalizadores a serem definidos

Retorna:

NU_SUCCESS - a chamada foi completada com sucesso

NU_INVALID_TASK - o ponteiro da tarefa é inválido

Chamada de Nucleus SE API para envio de sinais

Esta chamada de API oferece suporte à funcionalidade principal da API Nucleus RTOS.

Protótipo de chamada de serviço:

STATUS NUSE_Signals_Send (tarefa NUSE_TASK, sinais U8);

Parâmetros:

tarefa - o índice (ID) da tarefa que possui os sinalizadores a serem definidos

sinais - o valor dos sinalizadores a serem definidos

Retorna:

NUSE_SUCCESS - a chamada foi completada com sucesso

NUSE_INVALID_TASK - o índice da tarefa é inválido

Implementação Nucleus SE de Sinais de Envio

Aqui está o código completo para o NUSE_Signals_Send () função:

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

O código é muito simples. Depois de qualquer verificação de parâmetro, os valores do sinal são ligados aos sinalizadores da tarefa especificada. O bloqueio de tarefas não é relevante para sinais.

Recebendo sinais

Uma tarefa só pode ler seu próprio conjunto de sinalizadores. O processo de lê-los é destrutivo; ou seja, também resulta na eliminação dos sinalizadores.

Chamada da API Nucleus RTOS para receber sinais

Protótipo de chamada de serviço:

NÃO ASSINADO NU_Receive_Signals (VOID);

Parâmetros:nenhum

Retorna:o valor dos sinalizadores

Chamada de API do Nucleus SE para receber sinais

Esta chamada de API oferece suporte à funcionalidade principal da API Nucleus RTOS.

Protótipo de chamada de serviço:

U8 NUSE_Signals_Receive (vazio);

Parâmetros:nenhum

Retorna:o sinal sinaliza o valor

Implementação do Nucleus SE de sinais de recepção

Aqui está o código completo para o NUSE_Signals_Receive () função:

  U8 NUSE_Signals_Receive (void) {sinais U8; NUSE_CS_Enter (); sinais =NUSE_Task_Signal_Flags [NUSE_Task_Active]; NUSE_Task_Signal_Flags [NUSE_Task_Active] =0; NUSE_CS_Exit (); sinais de retorno;}  

O código é muito simples. O valor dos sinalizadores é copiado, o valor original limpo e a cópia retornada pela função API. O bloqueio de tarefas não é relevante para sinais.