RTOS para sistemas embarcados

Eu já vi muitos artigos que me dizem que eu deveria usar o RTOS para gerenciamento de tempo e gerenciamento de recursos. Meu tempo não permitiu minha própria pesquisa, por isso venho pedir conselhos à chiphacker.

Eu uso microcontroladores de baixo recurso (MSP430, PIC) e estava procurando por RTOSs que eu possa usar.

Ao ponto:

1. Custo de recurso do sistema
2. Vantagens do sistema
3. Desvantagens do sistema
4. Truques de implementação
5. Situações em que o RTOS deve / não deve ser usado.

Eu não uso sistemas como o arduino, os projetos com os quais trabalho não podem suportar o custo desse sistema.

Não tive muita experiência pessoal com os RTOS além do QNX (o que é ótimo no geral, mas não é barato, e tive uma péssima experiência com um fornecedor de placas específico e com a atitude de não nos importarmos com outros sistemas do que o mais comum), que é muito grande para PICs e MSP430.

Onde você se beneficiará de um RTOS é em áreas como

• gerenciamento / programação de encadeamentos
• comunicações inter-thread + sincronização
• E / S em sistemas com stdin / stdout / stderr ou portas seriais ou suporte a Ethernet ou um sistema de arquivos (não um MSP430 ou PIC na maioria das vezes, exceto as portas seriais)

Para periféricos de um PIC ou MSP430: para portas seriais, eu usaria um buffer de anel + interrompe ... algo que escrevo uma vez por sistema e apenas reutilizo; outros periféricos, acho que você não encontrará muito suporte de um RTOS, pois eles são tão específicos de cada fornecedor.

Se você precisar de um tempo sólido para o microssegundo, um RTOS provavelmente não ajudará - os RTOS têm tempo limitado, mas normalmente têm tremulação de tempo em sua programação devido a atrasos na alternância de contexto ... O QNX executado em um PXA270 tinha jitter nas dezenas de microssegundos típicos, máximo de 100-200us, então eu não o usaria para coisas que precisam correr mais rápido que cerca de 100Hz ou que precisam de um tempo muito mais preciso que 500us. Para esse tipo de coisa, você provavelmente precisará implementar seu próprio tratamento de interrupção. Alguns RTOS jogarão bem com isso, e outros tornarão uma dor real: seu tempo e o tempo deles podem não ser capazes de coexistir bem.

Se o cronograma / programação não for muito complexo, é melhor usar uma máquina de estado bem projetada. Eu recomendo a leitura Prático Statecharts em C / C ++, se você ainda não o fez. Usamos essa abordagem em alguns de nossos projetos em que trabalho, e há algumas vantagens reais em relação às máquinas de estado tradicionais para gerenciar a complexidade ... que é realmente a única razão pela qual você precisa de um RTOS.

Você já experimentou o FreeRTOS ? É gratuito (sujeito a T&C) e foi portado para o MSP430 e vários tipos de PIC.

É pequeno em comparação com outros, mas isso também facilita o aprendizado, principalmente se você nunca usou um RTOS.

Está disponível uma licença comercial (não gratuita) e uma versão IEC 61508 / SIL 3.

Acabei de descobrir sobre o NuttX RTOS, que pode até funcionar em um sistema 8052 (8 bits). Não tem muitas portas, mas parece interessante. O POSIX pode ser uma vantagem, porque pode tornar seu código um pouco mais portátil se você mudar para um processador mais robusto e quiser executar o linux ou QNX em tempo real.

Eu não tenho nenhuma experiência com RTOS comerciais, mas eu uso caseiras há anos! Eles são ótimos para ajudá-lo a dividir seu desenvolvimento de código entre muitos programadores, porque eles podem essencialmente obter uma "tarefa" ou "thread" para trabalhar da parte deles. Você ainda precisa coordenar e alguém deve supervisionar todo o projeto para garantir que cada tarefa cumpra seu prazo.

Também recomendo que você pesquise Análise Monotônica de Taxa ou RMA ao usar um RTOS. Isso ajudará a garantir que suas tarefas críticas cumpram os prazos.

Também examinaria a estrutura de programação orientada a eventos QP-nano do Miro Samek que pode funcionar com ou sem um RTOS e ainda oferecer capacidade em tempo real. Com isso, você está dividindo seu design em máquinas de estados hierárquicas, em vez de tarefas tradicionais. Jason S mencionou o livro de Miro em seu post. Uma excelente leitura!

Uma coisa que achei útil em várias máquinas é um simples comutador de pilhas. Na verdade, eu não escrevi um para o PIC, mas espero que a abordagem funcione bem no PIC18 se ambos / todos os segmentos usarem um total de 31 ou menos níveis de pilha. No 8051, a rotina principal é:

_taskswitch:
  xch a, SP
  xch a, _altSP
  xch a, SP
  ret

No PIC, esqueço o nome do ponteiro da pilha, mas a rotina seria algo como:

_taskswitch:
  movlb _altSP >> 8
  movf _altSP, w, b
  movff _STKPTR, altSP 
  movwf _STKPTR, c
  Retorna

No início do seu programa, chame uma rotina task2 () que carregue altSP com o endereço da pilha alternativa (16 provavelmente funcionaria bem para um PIC18Fxx) e execute o loop task2; essa rotina nunca deve retornar, senão as coisas sofrerão uma morte dolorosa. Em vez disso, deve chamar _taskswitch sempre que desejar gerar controle para a tarefa principal; a tarefa principal deve chamar _taskswitch sempre que desejar render à tarefa secundária. Muitas vezes, você terá rotinas fofinhas como:

void delay_t1 (valor curto não assinado)
{
  Faz
    comutador de tarefas ();
  while ((sem sinal abreviado) (milissegundo_clock - val)> 0xFF00);  
}

Observe que o alternador de tarefas não tem meios de executar qualquer 'espera pela condição'; tudo o que suporta é um spinwait. Por outro lado, a alternância de tarefas é tão rápida que uma tentativa de alternar tarefas () enquanto a outra tarefa aguarda a expiração do cronômetro mudará para a outra tarefa, verificará o cronômetro e voltará mais rapidamente do que um alternador de tarefas determinaria que ele não precisa alternar entre tarefas.

Observe que a multitarefa cooperativa tem algumas limitações, mas evita a necessidade de muitos códigos relacionados a mutex e bloqueio nos casos em que invariantes temporariamente perturbados podem ser restabelecidos rapidamente.

(Editar): Algumas advertências sobre variáveis ​​automáticas e outras:

1. se uma rotina que usa alternância de tarefas for chamada de ambos os threads, geralmente será necessário compilar duas cópias da rotina (possivelmente #incluindo o mesmo arquivo de origem duas vezes, com instruções #define diferentes). Qualquer arquivo de origem contém código para apenas um segmento ou outro código que será compilado duas vezes - uma vez para cada segmento - para que eu possa usar macros como "#define delay (x) delay_t1 (x)" ou #define delay (x) delay_tx (x) "dependendo do segmento que estou usando.
2. Acredito que os compiladores PIC que não podem "ver" uma função sendo chamada assumirão que essa função pode eliminar todos e quaisquer registros de CPU, evitando assim a necessidade de salvar quaisquer registros na rotina de troca de tarefas [um bom benefício em comparação com multitarefa preemptiva]. Qualquer pessoa que considere um alternador de tarefas semelhante para qualquer outra CPU precisa estar ciente das convenções de registro em uso. Pressionar os registros antes de uma tarefa alternar e pop-los depois é uma maneira fácil de cuidar das coisas, assumindo que existe um espaço de pilha adequado.

A multitarefa cooperativa não permite escapar completamente de questões de bloqueio, mas realmente simplifica bastante as coisas. Em um RTOS preventivo com um coletor de lixo compactador, por exemplo, é necessário permitir que os objetos sejam fixados. Ao usar um comutador cooperativo, isso não é necessário, desde que o código pressuponha que os objetos do GC possam se mover a qualquer momento em que o taskwitch () for chamado. Um coletor de compactação que não precisa se preocupar com objetos fixados pode ser muito mais simples do que um que faz.

Eu usei Salvo no MSP430. Isso ficou muito claro nos recursos do processador e, desde que você obedeça às regras de implementação, seja muito fácil de usar e confiável. Este é um sistema operacional cooperativo e requer que as alternâncias de tarefas sejam executadas no nível da chamada de função externa das funções de tarefa. Essa restrição permite que o sistema operacional trabalhe em dispositivos de memória muito pequenos sem usar grandes quantidades de espaço na pilha, mantendo os contextos das tarefas.

No AVR32, estou usando o FreeRTOS. Mais uma vez, muito confiável até agora, mas tive algumas discrepâncias de configuração / versão entre a versão que o FreeRTOS publica e a versão fornecida com a estrutura Atmel. No entanto, isso tem a vantagem de ser gratuito!

A edição de dezembro da Everyday Practical Electronics possui a parte 3 de uma série de sistemas operacionais em tempo real para PICs (na coluna PIC n 'Mix) e apresenta detalhes da configuração do FreeRTOS com MPLAB e um PICKit 2. Os dois artigos anteriores (que eu não vi) parecem ter discutido os méritos de vários RTOS e se estabelecido no FreeRTOS. Depois que o artigo atual configura o ambiente de desenvolvimento, eles começam a projetar um relógio digital binário. Parece que há pelo menos mais uma parte sobre este tópico.

Não sei ao certo como a EPE está disponível nos EUA, mas parece que existe uma loja nos EUA vinculada ao site e pode haver cópias eletrônicas disponíveis.

O compilador CCS para o PIC vem com um RTOS simples. Eu não tentei, mas se você tiver esse compilador, seria fácil experimentar.

Pergunta intimamente relacionada: https://stackoverflow.com/questions/1624237/multithreading-using-c-on-pic18

Você não falou muito sobre sua inscrição. A utilização de um RTOS depende muito do que você precisa fazer no PIC. A menos que você esteja fazendo várias coisas assíncronas, que exigem prazos estritos ou que tenham vários threads em execução, um RTOS pode ser um exagero.

Existem várias maneiras de organizar o tempo em um microcontrolador, dependendo do que é mais importante:

1. Taxa de quadros constante: para um PIC executando um servocontrolador que deve funcionar a 1000Hz, por exemplo. Se o algoritmo PID demorar menos de 1ms para ser executado, você poderá usar o restante do milissegundo para realizar outras tarefas, como verificar o barramento CAN, ler os sensores etc.

2. Todas as interrupções: tudo o que acontece no PIC é acionado por uma interrupção. As interrupções podem ser priorizadas de acordo com a importância do evento.

3. Coloque-o em um loop e faça tudo o mais rápido possível. Você pode achar que isso fornece limites de tempo adequados.