A seguir disponibilizo o capítulo 21 do livro AVR e Arduino: Técnicas de Projeto, utilizando o BRTOS para o ATmega328. Esse capítulo formaliza as definições e traz exemplos de uso da programação C com o ATMEL Studio.
DOWNLOAD AQUI -> RTOS
RTOS
Este post trata de uma importante ferramenta de programação para desenvolvimento de projetos de mais alto nível, os sistemas operacionais de tempo real - RTOS, compatíveis principalmente com arquiteturas de 32 bits. Entretanto, com o desenvolvimento de novos firmwares e com a maior disponibilidade de memória, os microcontroladores de 8 bits podem suportar sistemas operacionais mínimos e ainda apresentar desempenho satisfatório. A utilização de um RTOS se justifica pelas facilidade de programação, permitindo a solução de problemas complexos, difíceis de tratar com a programação convencional. Assim, com algum sacrifício de desempenho, pode-se utilizar um RTOS em um microcontrolador de 8 bits. O uso de um RTOS com esses microcontroladores não é usual dado a limitação da CPU. Todavia, é possível utilizar sistemas mínimos que podem produzir desempenho satisfatório dependendo dos tempos de acionamento e processamento necessários para uma determinada tarefa.
O Importantíssimo Trabalho com Bits
A programação de um microcontrolador exige o bom trabalho com bits. Dessa forma, a otimização do programa pode ser feita em qualquer acesso aos registradores de I/O (trabalho).
Quando se programa em C é fundamental conhecer como trabalhar com bits, assim estou disponibilizando o material básico que utilizo com meus alunos, parte do capítulo 4 do livro AVR e Arduino: Técnicas de Projeto, (O Importantíssimo Trabalho com Bits).
Em resumo são 4 macros: set_bit( ), clr_bit( ), cpl_bit( ) e tst_bit( ). O compilador GCC para o AVR faz um bom trabalho com elas e gera o menor número de instruções Assembly possível.
A programação microcontrolada também exige o uso direto de registradores com mascára de bits, conforme lógica de programação. Isto é visível nos programas disponibilizados no livro supracitado. Por exemplo: PORTD |= 0x0F preserva os 4 MSBs do PORTD e ativa somente os 4 LSBs. Ao contrário de PORTD &=0x0F, que limpa os 4 MSBs.
Dependendo da lógica necessária, podem ser necessárias várias funções lógicas para alterar um determinado bit/conjunto em um registrador/variável.
Teclado Matricial
Uma forma muito comum de entrada de dados em um sistema microcontrolado é através de teclas (botões ou chaves tácteis). Quando o número delas é pequeno, cada uma pode ser associada a um pino de I/O do microcontrolador. Entretanto, quando o seu número é grande, não é conveniente utilizar muitos pinos de I/O. Um teclado convencional emprega 3 × 4 teclas (12) ou 4 × 4 teclas (16) (fig. 1). Ao invés de se empregar 12 ou 16 pinos para a leitura desses teclados, empregam-se 7 ou 8 pinos, respectivamente.
Fig. 1 – Teclado matricial hexadecimal: 4 × 4.
Fig. 2 – Teclados com resistores de pull-up (a) e pull-down (b)
para as entradas do sistema de controle. A varredura é feita nas colunas.
Nos microcontroladores ATmega, a conexão de um
teclado é facilmente obtida, pois existem resistores de pull-up
habilitáveis em todos os pinos de I/O. Assim, um possível circuito para o
trabalho com um teclado é apresentado na fig. 3. Um código exemplo de uma
função para leitura desse teclado pode ser encontrado nos programas do meu
livro (aqui neste post).
Fig. 3 – Teclado 4 × 4 controlado pelo ATmega328.
Fonte Analógica de Tensão
Este é o projeto de um fonte linear simples, baseada em circuitos integrados reguladores para uma corrente máxima de 1A. São empregados os CIs 7805, 7812, 7912 e LM317, para as tensões respectivas de: 5V, 12V, -12V e variável. Na montagem da PCI os reguladores podem ser empregados conforme conveniência, por exemplo, se desejado, a fonte pode ter somente uma saída de tensão ajustável. Nesse caso, é necessário utilizar os componentes para essa regulagem de tensão.
Downloads: circuito, lista de componentes, PCI_botton (pdf), PCI_silk (pdf) e PCI_completa (gerber).
As fotografias da montagem podem ser vistas abaixo. Foi complicado colocar todos os componentes na caixa patola, principalmente os dissipadores de calor. A furação e adequação da caixa aos diferentes componentes também foi bastante trabalhosa.
Deve-se tomar cuidado na montagem dos dissipadores, pois os reguladores 7912 e LM317 não possuem sua carcaça metálica ligada ao terra, o que exige o uso de isoladores entre eles e o dissipador de calor.
Para evitar torções desnecessárias e possível quebra, na montagem é interessante realizar a solda dos fios na posição que ficarão dentro da caixa. O uso de "espaguete" termo retrátil ajuda na organização da fiação.
Utilizei um galvanômetro para a visualização da tensão variável. Para limitar a corrente do galvanômetro empreguei uma resistência de 30kOhms em série com um dos seus terminais. Foi necessário desenhar a escala conforme posição do potenciômetro de ajuste.
Montagem da PCI com detalhe dos dissipadores.
Vista áerea do cabeamento do transformador.
PCI, chave ON/OFF e conectores 12V e -12V.
PCI fixada.
Vista do cabeamento, abaixo da PCI.
Ligação dos terminais frontais (5V e variável).
Já com o LED sinalizador montado.
Com o porta fusível.
Com o galvanômetro.
Gran Finale.
Faltaram os pézinhos de silicone e os rótulos das tensões. Fica para segunda-feira.
Programação C para Arduino
Na data de 26/05/2013 fiz uma breve introdução à programação C para Arduino no The Developer´s Conference (TDC2013), aqui em Florianópolis. A apresentação é apenas um indicativo do que foi falado. Download na figura abaixo.
uGame
Este
projeto foi desenvolvido para a programação básica de jogos, foi baseado em um
projeto que encontrei em um site japones
(http://nicotak.com/avr/ledgame.html). O hardware emprega 4 matrizes de 8x8 LEDs
(pixel quadrado) e o 74HC595 para a expansão de I/O, o circuito pode ser visto
aqui. Infelizmente a placa de circuito impresso foi
desenvolvida com um erro na posição das matrizes de LEDs (tenho certa culpa no
processo). Dessa forma, necessitei fazer uma placa de correção. Assim, não
estou disponibilizando o seu desenho (se alguém o desejar, é só me escrever).
Fiz um
programa básico onde realizo a varredura da matriz de LEDs dentro de uma
interrupção do timer do ATmega328 (microcontrolador utilizado), o que
resultou em torno de 750 bytes de programação.
A matriz de LEDs é mapeada no programa por
um vetor de 16 posições com 16 bits cada (unsigned int), o que permite a
qualquer momento escrever em qualquer pixel da matriz. Por incrível que possa
parecer, dada a estrutura da matriz, utilizar variáveis de 16 bits em
detrimento as de 8 bits (no caso do ATmega), resultou em um código mais
eficiente.
Também fiz algumas rotinas de som, o que
permite tocar algumas notas músicais de forma simples.
Como gosto de aproveitar o hardware, acabei
incluindo um sensor de tempertura (LM35). Dessa forma, utilizo um filtro de
média móvel de 64 amostras para a suavização da leitura.
O programa demo é quase uma pintura, pelo
menos nas funcionalidades básicas, vale a pena analisá-lo (download aqui).
Desenvolvi o jogo da cobra, adaptação
daquele antigo jogo de celular onde uma cobrinha vai comento os pixels e
aumentado de tamanho. Nessa parte da programação, a coisa já ficou mais confusa
e menos otimizada. Criei um vetor que armazena as coodenadas XY da cabeça da
cobra a cada passo e permite aumentar e movimentar a cobra. No vídeo
abaixo é possível ver a funcionalidade do jogo.
Em resumo, a necessidade de desenvolver
algoritmos diferentes de acordo com o jogo é bem desafiadora, e sem dúvida, é
necessário um bom projeto para um jogo bem programado.
Um aprendizado dessa brincadeira: quanto
mais elegante forem as funcões desenvolvidas, mais fácil é criar o
restante da programação, a lógica do jogo.
Filtro de Média Móvel
Muitas vezes, para eliminar ou diminuir algum ruído indesejável em um sinal, é necessário filtrá-lo. Isso é comum quando se trabalha com sinais provenientes do ADC. Essa filtragem é, então, feita através da programação. O problema é que a teoria sobre filtros digitais é complexa e o programador a evita sempre que possível. Todavia, pode-se utilizar um filtro bem simples, chamado de média móvel, que pode resolver o problema do ruído.
O filtro de média móvel é obtido
calculando-se a média de um conjunto de valores, sempre se adicionando um novo
valor ao conjunto e se descartando o mais velho. Não é apenas uma média de um
conjunto isolado de valores. O filtro de média móvel é representado por:
onde
n é o tempo
atual (é o índice dos vetores utilizados), N +1 é o número
de amostras utilizadas para a filtragem, y[n] é o sinal filtrado e x[n-k]
representa o conjunto dos valores a serem somados. A equação acima pode ser
representada pelo diagrama da figura 1, com os valores de b0,b1...bN iguais a
1/(N+1).
Fig.
1 - Diagrama de um filtro digital não recursivo.
O diagrama da fig. 1 representa um filtro
chamado não recursivo, pois o sinal de saída y[n] depende somente do sinal de
entrada x[n]. Caso o sinal de saída dependesse de valores passados da saída, o
filtro seria chamada recursivo. No projeto de um filtro digital, determinam-se
os coeficientes de multiplicação para as amostras, no caso b0,
b1, ... bN para o diagrama citado. Esses coeficientes podem ser
determinados com o uso de alguma ferramenta computacional como o MATLAB®
ou MATCAD®, e o programador apenas necessita realizar as somas e
multiplicações nas amostras certas. A qualidade do filtro e o tipo de filtro
(passa baixa, passa alta, passa faixa) vai depender do número de coeficientes
utilizados (quantidade de amostras) e dos seus valores.
Ao utilizar coeficientes fixos, o filtro
de média móvel produz um filtro passa baixa suave, reduzindo os sinais de alta
frequência. Caso se deseje outro tipo de filtragem, será necessário a
multiplicação com valores fracionários, o que exigirá o uso de ponto flutuante
no programa. Isso pode ser um problema para microcontroladores de 8 bits pelo
consumo maior de memória e da limitada capacidade de processamento da CPU.
Na fig. 2, é apresentada a resposta em
frequência de um filtro de média móvel para 16 amostras. O eixo horizontal é a
frequência em Hertz, o número 1 representa a frequência de amostragem do sinal
dividida por 2. Desta forma, supondo uma frequência de amostragem 20 kHz,
cada linha vertical do gráfico corresponderia a 1 kHz.
Fig.
2 – Resposta em frequência de um filtro de média móvel de 16 amostras.
A resposta apresentada na fig. 2 mostra
que o desempenho de um filtro de média móvel é razoável, estando a atenuação
dos sinais indesejados na faixa de
aproximadamente -20 dB (90 %).
A seguir, é apresentado um exemplo para a
programação de um filtro de média móvel de 16 amostras para os valores
convertidos pelo ADC do ATmega (deve-se observar o tamanho das variáveis
declaradas para não ocorrer estouro na contagem).
Obs.: havia um erro no algoritmo abaixo, faltava inicializar com zero o valor media antes do somatório das amostras, o que aumentava um pouco a média.
Obs.: havia um erro no algoritmo abaixo, faltava inicializar com zero o valor media antes do somatório das amostras, o que aumentava um pouco a média.
//---------------------------------------------------------------------
// Filtro de média móvel com 16 amostras para o sinal do ADC
//---------------------------------------------------------------------
unsigned int filtro[16], media,
unsigned char k=0;
. . .
ISR(ADC_vect)
{
unsigned char j;
// Filtro de média móvel com 16 amostras para o sinal do ADC
//---------------------------------------------------------------------
unsigned int filtro[16], media,
unsigned char k=0;
. . .
ISR(ADC_vect)
{
unsigned char j;
filtro[k] = ADC; //valor do ADC entra no filtro, na amostra mais antiga
k++; if(k==16) k=0;
media = 0;
for(j=0; j<16; j++)
media += filtro[j]; //somatório das amostras
media /=16; //média dos valores
}
//----------------------------------------------------------------------
Obs.: Este material faz parte do capítulo 19 do livro AVR e Arduino:
Técnicas de Projeto. O
programa é diferente no livro, aconselho comparação.
Assinar:
Postagens (Atom)