Índice Motivação Introdução Ferramentas de Desenvolvimento Hardware Programador Circuito de Teste Teste ao hardware SoftwareMotivação
Bom, já vi que o pessoal por aqui, e pelo que percebi mesmo em Portugal, é mais adepto do PIC. Eu como gosto muito do AVR e o considero uma tecnologia bastante superior ao PIC, resolvi então iniciar este tutorial para ajudar a dar os primeiros passos a quem quiser experimentar um AVR. Por falta de tempo vou ter que ir escrevendo aos pedaços, mas espero que ainda assim o tutorial fique completo rapidamente. Também posso vir a re-escrever o texto; se virem isto mudar completamente não se assustem, estou a usar o próprio fórum como folha de rascunho. Mas comecemos.
Introdução
"AVR" é o nome de uma familia de microcontroladores de 8 bits comercializada pela ATMEL. A arquitectura do AVR foi desenvolvida por 2 estudantes de doutoramento noruegueses em 1992 e depois proposta à ATMEL para comercialização. Para quem souber inglês, podem ver uma pequeno video sobre os AVR aqui:
http://www.avrtv.com/2007/09/09/avrtv-special-005/.
O AVR consiste, tal como um PIC e outros microcontroladores, num processador (o "core"), memórias voláteis e não-voláteis e periféricos. Ao contrário do PIC, o core do AVR foi muito bem pensado e implementado desde o inicio, e o core que é usado nos chips desenhados hoje é o mesmo que saiu no 1º AVR há mais de 10 anos (o PIC teve "dores de crescimento" e o tamanho das instruções aumentou algumas vezes ao longo do tempo de forma a suportar mais funcionalidade).
Assim de uma forma rápida podemos resumir a arquitectura do AVR nos seguintes pontos:
- Consiste num core de processamento, memória de programa (não volátil, FLASH), memória volátil (RAM estática, SRAM), memória de dados persistentes (não volátil, EEPROM) e bits fuse/lock (permitem configurar alguns parametros especiais do AVR).
- Arquitectura de memória Harvard (memória de programa e memória de dados separadas)
- A memória volátil (SRAM) é contínua
- A maior parte das instruções têm 16 bits de tamanho, e é este o tamanho de cada palavra na memória de programa (FLASH).
- Execução de 1 instrução por ciclo de relógio para a maior parte das instruções.
- Existem 32 registos de 8 bits disponiveis e há poucas limitações ao que se pode fazer com cada um.
- Os registos do processador e os de configuração dos periféricos estão mapeados (são acessiveis) na SRAM.
- Existe um vector de interrupção diferente por cada fonte de interrupção.
- Existem instruções com modos de endereçamento complexo, como base + deslocamento seguido de auto-incremento/decremento do endereço.
- O conjunto de instruções foi pensado para melhorar a conversão de código C em assembly.
Para facilitar a vida a todos, a mim e a voccês, vou centrar o tutorial apenas num modelo específico de AVR, o ATtiny26, e em programação C, já que o assembly é muito
hardcore para uma introdução. Mais tarde não será difícil extender o descrito neste tutorial para mais 1 ou 2 modelos de AVR sem grandes alterações. Este ATtiny26 apesar de ser pequeno não é dos modelos mais básicos, e na minha opinião consegue um excelente equilibrio preço/funcionalidade; tem ADC, contadores/timers, hardware que facilita a construção de interfaces SPI/I2C/UART, velocidade de relógio até 16MHz (um PIC para ter a mesma velocidade precisava de ter um clock de 64MHz), entre outras coisas.
Ferramentas de desenvolvimento
Vamos precisar das seguintes ferramentas, todas software de utilização livre:
- AVRStudio 4.13 (73MB) - Ambiente de desenvolvimento gratuito da ATMEL para toda a linha AVR. Consiste num editor, assembler, programador e simulador. Vamos usá-lo como simulador.
- WinAVR (23MB) - Ambiente de desenvolvimento OpenSource para AVRs. Consiste num editor, compilador C/C++, linker, debugger, simulador e programador. Vamos usar apenas as aplicações para compilação de C e o programador.
Se a tua ligação à Internet for lenta, podes deixar o download do AVRStudio para mais tarde, eu digo-te quando na altura (na verdade ele não é essencial para desenvolver programas para AVR, mas ajuda
imeeeeenso).
Após a instalação do WinAVR, vamos ter que adicionar uma descrição do nosso hardware programador ao ficheiro de configuração do
avrdude, que é a aplicação do WinAVR que trata da programação dos AVRs. Portanto abram o ficheiro
<directoria-de-instalação>\WinAVR\bin\avrdude.conf e procurem pelo comentário de texto
# Parallel port programmers.Este comentário marca o inicio da zona de configuração de programadores de porta paralela, e logo aí vamos inserir a descrição do (hardware) programador que vamos usar e que está descrito na próxima secção:
# AVR Tutorial programmer at www.electronicapt.com
programmer
id = "avrpt";
desc = "AVR Tutorial at ElectronicaPt.com";
type = par;
reset = 6;
sck = 8;
mosi = 7;
miso = 10;
;
O
avrdude é um programa muito flexível e não se limita a aceitar apenas um ou alguns tipos de programadores; ele lê do ficheiro
avrdude.conf a configuração de programadores e usa-a para utilizar o programador de hardware que estejamos a usar. Assim podemos utilizar muitos tipos diferentes de programadores sem ter que alterar o código do
avrdude; inteligente, não
? E ele faz o mesmo para os AVRs. Cada AVR tem memórias de tamanhos diferentes e toda essa informação está no ficheiro de configuração. Mas não é preciso mexer em mais nada
.
O programador de AVRs que vamos usar é de ligar à porta paralela do PC, o que quer dizer que o teu PC terá que ter uma LPT. Existem uns conversores de USB para LPT, mas normalmente não funcionam, tem que ser uma porta LPT "pura". Também terás que ter direitos de administração no teu PC para instalar um driver de porta paralela.Agora vamos tratar do hardware.
Hardware
ProgramadorPrecisamos de ter um circuito programador para gravar os nossos programas no AVR. O AVR tem 2 modos de programação: o paralelo/alta voltagem e o série/baixa voltagem. Estes modos permitem ler e escrever nas suas memórias não voláteis e nos bits fuse/lock. O circuito abaixo é um programador de modo série, que vamos utilizar.
Este circuito tem que ser montado dentro da caixa da ficha que liga à porta paralela do PC, e é essencial que fique ali mesmo à saída da porta paralela (mais perto do que dentro da ficha que lá liga, impossível):
(do outro lado)Vamos montar numa matriz de contactos o circuito abaixo. Este pode ser alimentado por qualquer tensão entre 2.7V e 5V, pelo que pode ser usado por exemplo um par de pilhas AA ou AAA de 1.5V, ou uma pilha de lítio tipo "botão" de 3V.
Nesta placa temos apenas 1 LED como dispositivo externo sobre o qual o AVR pode actuar, mas depois deste tutorial vocês irão certamente ser criativos e ligar muitas outras coisas
.
Vou usar um suporte de 2 pilhas AA de 1.5V para alimentar o circuito:
Se já tentaste enfiar uma ponte de terminais (as peças dos pinos dourados) numa matriz de contactos, reparaste que eles não prendem lá, porque são demasiado curtos. Para resolver isso pega num alicate e empurra devagar os pinos 1 ou 2mm, usando a base de plástico como apoio para uma das pontas do alicate, assim:
Agora já se conseguem prender as pontes à matriz.
Eu usei pontes de terminais, mas também poderia ter usado fichas macho do tipo das brancas do programador e do suporte de pilhas que podes ver nas fotos. Esses até são um pouco melhores, porque são polarizados, isto é, só permitem que ligues as fichas numa das 2 posições possíveis, o que é importante (especialmente a fichas das pilhas!). Essas fichas são baratas e encontram-se com facilidade cá em Portugal.
Teste ao hardwareBom, antes de começarmos a fazer programas para o AVR, temos que verificar se o hardware (programador e circuito de teste) estão a funcionar. E vamos fazê-lo verificando se o software programador, o
avrdude, é capaz de falar com o nosso AVR.
Para começar tens que instalar um driver no teu PC que irá permitir ao
avrdude ter acesso à porta paralela. Para isso vai ao menu
Iniciar do Windows e escolhe
Executar; aí dá o comando
runas /user:administrador cmdadministrador é o nome de um utilizador no teu PC que tenha direitos de administração, e este comando abre uma
Linha de Comando onde os comandos que deres se executarão como se fosses esse utilizador. Se o utilizador que usas habitualmente já tem direitos de administração, então basta-te abrir uma Linha de Comando directamente.
Na Linha de Comando então aberta, vai para a directoria
...\WinAVR\bin\ e corre o ficheiro
install_giveio.bat para instalar o driver, como no exemplo:
Verifica se a instalação correu bem, deves ver as mesmas mensagens que na imagem acima. Em princípio só deves precisar de fazer isto uma vez, pois o driver fica instalado como serviço do Windows, de arranque automático. Já podes fechar a Linha de Comando e abrir uma nova, desta vez normal (Iniciar -> Executar -> escrever "cmd" e ENTER). Cria uma directoria de trabalho para este tutorial, por exemplo
c:\tutorial e muda-te (
cd ...) para lá.
Liga o programador à porta paralela e ao circuito de teste.
Tem atenção à posição da ficha branca. Depois liga as pilhas ao circuito de teste e vamos verificar se o
avrdude consegue "falar" com o nosso AVR, dando mais um comando:
C:\tutorial> avrdude -c avrpt -p t26 -i 50
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e9109
avrdude: safemode: Fuses OK
avrdude done. Thank you.
C:\tutorial>
O texto a
laranja (ele não aparece laranja, fui eu que o pintei!) é uma boa indicação de que a conversa foi bem sucedida, uma vez que o
avrdude conseguiu ler a assinatura do AVR, que é um código que identifica o modelo de AVR. Se houver mensagens de erro vais perceber... e aí tens que verificar se o cabo está bem montado, bem ligado, o circuito bem montado, se ligaste as pilhas, etc. Enquanto não vires a assinatura do AVR neste pequeno teste, não vais conseguir programá-lo.
Com o hardware a funcionar, vamos então começar a olhar para o software.
Software
Se tiveste a coragem de chegar a este ponto, estás (se não estás, devias estar
) em pulgas para programar o teu 1º AVR
. Vamos primeiro ver como é que se compila e grava um programa no AVR, e só depois vamos à explicação dos detalhes.
Vamos fazer o programa que é o sonho de qualquer iniciante
, pôr um LED a piscar. Copia o seguinte para um ficheiro e grava-o com o nome
pisca_led.c.
#include <avr/io.h>
#include <util/delay.h>
int main (void)
{
DDRA = 0x01; // Configurar pino PA0 como output
do { // inicio de ciclo
PORTA = 0x01; // Acender o LED
_delay_ms(500); // Esperar 500ms...
PORTA = 0x00; // Apagar o LED
_delay_ms(500); // Esperar 500ms...
}
while (1); // Saltar para o inicio do ciclo
}
E para compilar este programa vamos dar os comandos:
C:\tutorial> avr-gcc -mmcu=attiny26 -DF_CPU=1000000UL -g -O1 -o pisca_led.elf pisca_led.c
C:\tutorial> avr-objcopy -j .text -j .data -O binary pisca_led.elf pisca_led.bin
C:\tutorial>
Finalmente, para programar o AVR damos agora o último comando e observamos, com espanto
, o AVR ser programado:
C:\tutorial> avrdude -c avrpt -p t26 -i 50 -U flash:w:pisca_led.bin:r
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e9109
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "pisca_led.bin"
avrdude: writing flash (108 bytes):
Writing | ################################################## | 100% 0.38s
avrdude: 108 bytes of flash written
avrdude: verifying flash memory against pisca_led.bin:
avrdude: load data flash data from input file pisca_led.bin:
avrdude: input file pisca_led.bin contains 108 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.35s
avrdude: verifying ...
avrdude: 108 bytes of flash verified
avrdude: safemode: Fuses OK
avrdude done. Thank you.
C:\tutorial>
Assim que termina a execução deste comando, e se for bem sucedido tal como no exemplo acima, terás diante dos teus olhos um LED a piscar
. Parabéns
!!!
Continua numa próxima oportunidade... entretanto podem ir enviando as vossas dúvidas/sugestões.
