Share

Em Leitura de sinais usando Raspberry PI, veremos um exemplo de software que pode ser usado para fazer leitura e medição de sinais e que pode ser usado em várias aplicações. Além de conceitos de tempo real em Linux.

I/O de propósito geral

raspberry-pi-rev2-gpio-pinout

A placa de desenvolvimento Raspberry Pi dispõe de oito pinos de GPIO para uso geral. E existem diversas bibliotecas em praticamente qualquer linguagem de programação usada atualmente. Nesse artigo, usaremos a biblioteca WiringPi.

WiringPI é a biblioteca de acesso a GPIO escrita em linguagem C para o processador BCM2835, usado na Raspberry Pi. É liberada sob a licença GNU LGPLv3 e pode ser usada em códigos C e C++, além de muitas outras linguagens com as devidas adequações. Foi projetada para ser compatível com a nomenclatura de funções usadas no Arduino.

A Raspberry PI tem um conector GPIO de 26 pinos e este contém GPIOs e alguns barramentos. Existem 8 pinos que funcionam apenas como GPIOs e podem ser configurados como entradas ou saídas digitais. Um dos pinos pode ser configurado como PWM. Adicionalmente existe uma interface I2C, uma interface SPI e uma UART.

As interfaces I2C, SPI e UART pode também ser usadas como I/O de proposito geral quando não forem usadas em modo de barramento, dando um total de 8 + 2 + 5 + 2 = 17 pinos de I/O no conector P1.

Suporte a Tempo Real no Linux

A definição de Sistema de Tempo Real dado por Donald Gillies em Realtime Computing FAQ:
Um sistema em tempo real é aquele no qual a exatidão dos cálculos não só depende da precisão lógica desses cálculos, como também do tempo em que se produz o resultado. Se as restrições de tempo do sistema não são atendidas, dizemos que houve falha no sistema.

O Linux não é um sistema operacional de tempo real. Para que as leituras dos sinais sejam feitas com o máximo de acuracidade possível sob o Linux, nós precisamos usar um dos patches que transformam o Linux em um sistema de tempo real. Existem muitas opções para isso. Mas a escolha do patch vai depender dos requisitos de tempo do projeto em questão. Exemplos de patches para Linux: RTLinux, RTAI, Xenomai, Preempt_rt.

O sistemas de tempo real podem ser classificados de acordo com as perdas de prazo: Hard Real-time, Firm Real-time e Soft Real-time. No Hard Real-time, na perda de um prazo ocasiona um falha total do sistema. No Firm Real-time, perdas de prazo esporádicas são toleráveis, mas pode degradar a qualidade do sistema. A utilidade de um resultado é zero após o prazo. No Soft Real-time, a utilidade de um resultado degrada após o prazo. Mas algumas falhas são ainda toleradas.

Os principais parâmetros que devem ser determinados é a latência do sistema no pior caso e o prazo de uma determinada tarefa.  Para leitura de sinais de infravermelho de um controle remote, por exemplo, uma latência de sistema de 100 a 200 microssegundos é suficiente.  Mas um atraso ou latência maior que 400 microssegundos nos faria perder um bit de informação, já que tipicamente os tempos de sinais de infravermelho estão entre 400 microssegundos e 2 milissegundos. Portanto, nesse caso, devemos usar uma arquitetura Firm Real-Time.

Assim, o objetivo de um sistema Hard Real-time é garantir que todos os prazos sejam cumpridos, mas para sistemas Soft Real-time, o objetivo torna-se conhecer um determinado subconjunto de prazos, a fim de otimizar alguns critérios específicos do aplicativo.

Preempt_rt na Raspberry PI

Nas versões atuais do kernel Linux usado na Raspberry PI, o patch PREEMPT_RT já é habilitado por padrão. O PREEMPT_RT não poderia ser usado para tarefas criticas como um controlador de voo de um avião, mas é bom o suficiente para a robótica, bolsas de valores, e para computadores que tenham a interface com o software em “Hard” real-time. Ele tem sido usado em computadores que são enviados para o espaço também.

A grande vantagem de PREEMPT_RT sobre outras implementações para tempo real é que o PREEMPT_RT transforma o Linux em tempo real sem precisar usar uma API especial, enquanto que os outros geralmente criam um pequeno micro kernel que funciona como um supervisor e o Linux é executado como uma tarefa. Isso não é realmente Linux. Suas tarefas em tempo real devem ser modificadas para se comunicar com o micro kernel. O Xenomai usa esse esquema de micro kernel. Se seu software roda no kernel oficial(stock kernel), ele também roda no kernel com PREEMPT_RT sem nenhuma alteração. Mas o Xenomai, por exemplo, tem uma API especial. O que significa que você precisa usar essa API  para criar as tarefas de tempo real.

Um dos problemas do PREEMPT_RT são as latências de 100 a 300 microssegundos, se você precisa de tempos menores que esses. Mas como valores com precisão em microssegundos são com frequência usados em sistemas embarcados, o PREEMPT_RT pode não ser suficiente para muitas aplicações. Como dito antes, você precisa determinar a latência máxima aceitável para sua aplicação. Já o Xenomai pode produzir latências entre 8 a 10 microssegundos e até 30 microssegundos para o pior caso, tornando-o uma ótima escolha para muitas aplicações. O Xenomai é uma ótima alternativa para ler sinais na ordem de microssegundos, pois pode produzir uma base de tempo com alta confiabilidade e muita precisa.

Desabilitando recursos desnecessários

Para diminuir a latência do pior caso do sistema e para obter um comportamento mais determinístico você pode desabilitar recursos e serviços que não estão sendo utilizados no sistema. Para desabilitar serviços no Raspbian digite:

Pode pode também desabilitar os módulos do kernel que não estão em uso:

Leitura de sinais usando Raspberry PI

gpioir

Na figura acima, é mostrado uma ligação de um sensor de infravermelho. Podemos usar o exemplo de código abaixo, para fazer leituras desse sensor.

Agora vamos dar um exemplo de software para fazer leituras de sinais em geral. Iremos usar a biblioteca de manipulação de GPIO, wiringPI, citada no artigo anterior. Este código pode ser usado para ler pulsos de nível alto ou pulsos de nível baixo. No entanto, os resultados não são muito acurados para sinais curtos de 500us, por exemplo. Para uma leitura mais precisa e de sinais mais curtos, a melhor maneira é usando o Xenomai para gerar uma base de tempo mais precisa, sendo possível fazer a leitura de sinais com mais acuracidade.

A compilação do código pode ser feita com o seguinte comando na própria Raspberry:

Referências:

http://www.ibm.com/developerworks/br/library/l-real-time-linux/

http://en.wikipedia.org/wiki/Real-time_computing

Translate »