Todd Danko

28 de janeiro de 2004

Tutorial Atmel AVR

Introdução
O objetivo deste tutorial é descrever passo a passo o processo de codificação, compilação,
e carregando programas para microcontroladores Atmel AVR.

O que é necessário?
Antes de começar, vários itens são necessários:

Descrição Identificador de Parte Fonte Preço

Placa de desenvolvimento O MegaAVR-Dev [Link] R$ 56
com ATMega32 com/ATMega32
microcontrolador
Programador de Chip O CableAVR ISP [Link] R$99
Software e Programador
Hardware
AVR Integrado CodeVisionAVR [Link] Grátis
Desenvolvimento Avaliação
Ambiente
Cabo Serial (RS- 26-117 [Link]$14,49
232C)
Fonte de Alimentação* 273-1776 [Link]$16,99
Livro Didático Programação C [Link] R$67,95
e o Atmel AVR
* A fonte de alimentação pode ser comprada, mas qualquer conversor de CA para CC que forneça 8
até 38 Volts DC, e maior que 1 Amp (1000mA) pode ser recuperado de não utilizado
aparelhos domésticos (gravador de mensagens, modem, etc).

Especificações do Microcontrolador e da Placa de Desenvolvimento

Page 1 of 11
O microcontrolador ATMega32 AVR é um processador RISC de 16 bits. Quando combinado com
a placa de desenvolvimento, muitos recursos são oferecidos:
• 4, 8 bits Portas de I/O Digital (PORTA, PORTB, PORTC, PORTD)
• Comunicações RS232 através de:
o9-Pino D-Shell
Terminais de rosca
cabeçalho do Jumper
• 32K de memória FLASH programável em sistema
• 1K de EEPROM
• 1K de RAM Interna
• Entradas Analógicas de 8 e 10 bits
Ou tensão de referência interna ou externa
• 9 LEDs controlados por I/O
o8 LEDs são selecionáveis por jumper.
• Cristal de relógio de 32KHz
• Tomada de relógio universal com cristal de 6MHz
• Cabeçalhos centralizados de 0,1"
• Conectores ISP e JTAG polarizados de 10 pinos
• Requer uma fonte de alimentação de 8-38VDC

Visão Geral do Sistema

O processo geral para programar um microcontrolador AVR é o seguinte:
1. Defina seu objetivo tendo em mente como você usará hardware e software
2. Decida qual hardware será usado e em qual configuração
3. Escreva um software que manipule seu hardware de maneira apropriada
4. Compilar / Montar software
5. Conectar computador ao chip
6. Chip de programa
7. Anexe hardware ao chip se necessário
8. Execute isso!

Por onde começar...

Começaremos realizando três tarefas. A primeira tarefa será tão simples quanto possível.
e cada tarefa subsequente adicionará complexidade.

1. Acenda um LED na placa de desenvolvimento.

2. Lê uma palavra digital de um array de oito chaves dip e acende o correspondente
LEDs em uma matriz de oito LEDs.
3. Acenda os LEDs para contar de 0 a 255 em binário, fazendo uma pausa de dois segundos entre cada contagem.
cada passo.

TAREFA 1:
Para a primeira tarefa, usaremos um LED que está conectado à placa de desenvolvimento. Defina o
jumpers para o PORTC para que conectem o PORTC à matriz de LEDs (circundados em vermelho)

Page 2 of 11
 Observe a posição
desses pulôveres.
Nesta posição, o
8 LEDs para a direita
estão conectados a
PORTC

A configuração da placa de desenvolvimento é tal que +5 volts está conectado através de um

resistor a uma perna de cada LED, e o terra de cada LED está conectado a um pino em
PORTC. Isso significa que quando um pino no PORTC é configurado como alto (+5 volts), não há corrente
fluindo através do LED e o LED está desligado. Quando um pino no PORTC é definido como baixo (terra),
a corrente flui através do LED, e o LED está aceso. Assim, para esta configuração, desligar um pino,
liga o LED.

Então, como fazemos o microcontrolador desligar um pino do PORTC (assim desligando um único
LED ligado)? Uma porta pode ser considerada como uma variável de oito bits. Quando você atribui um valor
entre 0 e 255 para esta variável de oito bits, cada pino será definido como ligado ou desligado (+5 V
ou Terra). O +5V corresponde a um 1 e a terra corresponde a um 0. Então, se nós
quero fazer um LED acender, e os outros permanecerem apagados, queremos enviar o número 254 para
PORTC. O número 254 em binário é 01111111, então o pino 0 no PORTC será terra, e
pin1 - pin7 serão +5 V. Isso significa que o LED conectado ao pin0 estará aceso, e o
o resto estará desligado.

Vamos começar:
• Abra o CodeVisionAVR no seu PC.
• Clique no ícone "Novo Projeto" para criar um novo projeto.

Page 3 of 11
 • Quando a caixa de diálogo "Criar Novo Arquivo" aparecer, clique em "Projeto" e depois em "OK."
New Project

• Uma caixa de diálogo intitulada "Confirmar" aparecerá perguntando se você gostaria de usar
"CodeWizardAVR." Esta é uma ferramenta útil, mas é importante aprender a programar.
sem este assistente primeiro. Clique em "Não."

• Salve o projeto com um nome de arquivo apropriado quando solicitado

• Clique no ícone "Novo Projeto" novamente
• Desta vez, verifique 'Fonte' e depois clique em 'OK'
• Insira seu código na janela do código-fonte:
/*********************************************
led_on
Comentários: Este programa acende o LED ligado ao pino0 ou PORTC
*********************************************/
#include <mega32.h>

voidmain(void)
{
PORTC=0xFF; //Defina todos os pinos do PORTC como saída (p.87 no livro didático)
0xFF //Definir valores iniciais para PORTC como alto

enquanto(1)

Page 4 of 11
 {
PORTC = 254; //pin0, PORTC = 0 (LED LIGADO), pin1-7=1 (LEDs DESLIGADOS)
};
}

• Na barra de ferramentas, clique em "Arquivo" e depois em "Salvar" para salvar seu código fonte. Salve seu
código-fonte para um nome de arquivo apropriado.
• O código-fonte deve agora estar associado ao projeto:
Clique em "Projeto" e depois em "Configurar"

Clique em Adicionar na janela 'Configurar Projeto'

Selecione seu código-fonte e clique em abrir.
Agora, clique na segunda aba (Compilador C) do “Configurar Projeto”
janela

Selecione o tipo de chip e a velocidade do clock que são apropriados para o seu chip.
Clique em OK
• Agora compile e monte seu código clicando no botão "Montar".

Page 5 of 11
 Assemble

• Uma caixa de diálogo aparece. Certifique-se de que a mensagem diz "Sem erros", caso contrário,
volte para o seu código e corrija os erros.

• Se não houver erros na compilação, é hora de programar o chip.

Programando o chip
Existem várias ferramentas disponíveis para programar seu chip AVR. Uma das mais confiáveis
e ferramentas fáceis de usar é "TheCableAVR ISP Programmer."

Usando "O Programador ISP CableAVR:"

• Compile e monte seu código usando o CodeVisionAVR. Pelo menos dois arquivos irão
ser criado:
programa oFlash (.hex)
oEEPROM (.eep)
• Conecte a ferramenta cableAVR a uma porta COM aberta no seu PC através de uma serial
cabo.
• Conecte a ferramenta cableAVR à sua placa de desenvolvimento através da porta ISP.

Page 6 of 11
 Programador
Anexado a
ISP Port

TheCableAVR
ISP
Programmer

Cabo Serial
(Outro Lado
Conectado ao PC

• Ligue sua placa de desenvolvimento.

• Abra a ferramenta "TheCableAVR".
• Clique em "Detectar Tipo de Dispositivo Automaticamente." Isso detecta o tipo de chip, e
preenche automaticamente os valores específicos do chip.

Page 7 of 11
 • Clique em "Opções Especiais" e certifique-se de que a caixa "Habilitar JTAG" não está marcada.
verificado. Clique em "Escrever" e depois em "Fechar"

• Clique em "Procurar" em "Área Flash (Programa)" e selecione seu arquivo montado (.hex)
arquivo
• Clique em "Procurar" sob "Área EEPROM" e selecione seu arquivo EEPROM (.eep)
• Clique em “Programar” para programar seu chip
O chip agora está programado

Uma vez que o chip esteja programado, você verá que o LED conectado ao pino0 no PORTC está
ligado. O resto dos LEDs no PORTC está desligado.

TAREFA 2:
A próxima tarefa é ler um dipswitch de oito bits a partir do PORTA e acender.
LEDs correspondentes em um arranjo de oito LEDs.

Devemos construir um circuito de dipswitch seguindo o esquema abaixo:

+5V

GND

Page 8 of 11
Este circuito de dip switch funciona de maneira semelhante aos LEDs na placa de desenvolvimento. Quando um
o dipswitch está fechado, o pino correspondente no PORTA é levado a um nível baixo. Quando um dipswitch
está aberto, o pino correspondente no PORTA é ativado. Se escrevermos um programa que
mapeia o valor de PORTA para PORTC, teremos um circuito onde fechar um interruptor
ligado ao PORTA acende o LED correspondente ligado ao PORTC.

O código para fazer isso é o seguinte:

/*********************************************
dip_led
Comentários: Este programa lê uma palavra digital de oito bits do PORTA e grava
a palavra digital para PORTC.
*********************************************/

#include <mega32.h>

voidmain(void)
{

0x00 // Defina todos os pinos do PORTA como entrada

0x00; // Defina os valores iniciais para PORTA como baixo

PORTC=0xFF; //Defina todos os pinos do PORTC como saída

DDRC=0xFF; //Defina os valores iniciais para PORTC como alto

enquanto(1)
{
PORTC = PINA; //A entrada do PORTA é saída para o PORTC
};
}
Monte este código e programe seu chip assim como no programa led_on. Anexar
sua placa de interruptores DIP para a PORTA na sua placa de desenvolvimento e veja o que acontece quando
você alterna os interruptores de palanca.

Fita de 8 Condutores
Conexão de Cabo
Circuito de dipswitch para
PORTA

Cabo de 2 Condutores
Conectando Dipswitch Circuito Dipswitch
Circuito de +5V e GND
para a Placa de Desenvolvimento
+5V

Page 9 of 11
 TAREFA 3:
A tarefa final é um pouco mais complexa. O objetivo é contar de 0 a 255 em binário.
através das luzes LED na placa de desenvolvimento. O contador deve operar de forma que
a contagem é incrementada uma vez a cada dois segundos.

Usaremos o array de oito LEDs na placa de desenvolvimento como uma saída para este projeto.
Tenha em mente que definir um pino do PORTC como alto desliga o LED correspondente, então para
faça parecer que os LEDs estão contando de 0 a 255, nós faremos a palavra digital
contagem regressiva de 255 a 0.

Como você pode cronometrar algo tão longo quanto dois segundos quando o relógio do seu chip está funcionando a
6MHz? A maneira simples seria ter um contador que incrementa uma vez por ciclo.
Uma vez que a contagem atinge 12.000.000, você pode assumir que dois segundos se passaram.
Claro, se você fizer isso, não poderá realmente usar seu processador para mais nada.
Você também precisaria contar até 12.000.000. O ATMega32 armazena variáveis em 16 bits
espaço dificultando o armazenamento de números maiores que 65.525.

Felizmente, o chip ATMega32 AVR possui três temporizadores embutidos. O primeiro temporizador
(timer0) é usado neste exemplo.

Parte da funcionalidade embutida do timer0 é um pré-divisor selecionável pelo usuário. Este pré-divisor
essencialmente conta o número de ciclos que o processador atravessa e permite um sinal para
ser enviado a cada 1024, 512, 256, 128 (etc) ciclos. Eu escolhi definir o divisor para 1024. Isso
significa que um sinal é enviado a cada 6Mhz / 1024 ciclos ou a uma taxa de 5859Hz. 1/5859Hz
dá-nos 0.000171 segundos entre cada sinal.

Então, o que fazemos com esses sinais? O Timer0 tem um recurso interessante onde o temporizador
conta internamente os sinais escalonados. O contador utilizado é um contador de oito bits, portanto possui um
varia de 0 a 255. Uma vez que 255 é alcançado, o próximo valor de contagem volta para 0. Isso
o evento é chamado de "rollover". Sempre que um rollover ocorre, um sinal de interrupção é enviado.
Quando um sinal de interrupção é enviado, um contador conta quantas interrupções ocorreram.
Se o contador interno do timer for permitido contar de 0 a 255 (256 etapas), haverá
um atraso de 0,000171 * 256 = 0,0438 segundos entre cada interrupção. Isso não é muito
período de tempo útil. Felizmente, podemos escolher qual número usar para iniciar o tempo interno do cronômetro.
contador ligado. No código, você notará que o contador interno do cronômetro começa em 110, então,
contando de 110 a 255 nos dá 146 contagens entre cada interrupção. Isso é 0,000171 *
146 = 0,025 segundos entre cada interrupção. Este é um valor bastante conveniente para
medindo um período de dois segundos.

Agora que temos um interrupção sendo transmitida a cada 0,025 segundos, só precisamos de
conte 80 desses interrupções para saber que dois segundos se passaram. Isso é exatamente o que
"timecount" faz.

Para mais informações sobre temporizadores, consulte a página 105 do livro didático.

Page 10 of 11
/*********************************************
contagem_de_LED
Comentários: Este programa conta de 0 a 255 em binário com LEDs. Existe um
pausa de dois segundos entre cada contagem.
*********************************************/

#include <mega32.h>

unsigned int timecount = 0; // Contador de timer global

unsigned int contador = 255; // Contador global definido

// Quando o Timer 0 transbordar, conduza esta rotina

interrupção [TIM0_OVF]voidtimer0_ovf_isr(void)
{
110; // 146 ciclos de clock equivalem a 0,025 segundos. Configurando
// o contador do relógio para 110 permite 146 ciclos de relógio
// (256-146=110)

se(++timecount == 80) // 80 250us ticks em dois segundos

{
PORTC = --contador; // Subtrair um do contador e enviar para
// PORTC a cada dois segundos

// Nota: alto está desligado e baixo está ligado para cada LED

timecount =0; // Reiniciar contador de tempo

}
}

voidmain(void)
{

PORTC=0xFF; // Defina todos os oito bits do PORTC como saída

0xFF; // Defina todos os oito bits do PORTC como Alto

TCCR0=0x05; // Valor do relógio: 5.859 kHz (6MHz / 1024)

TCNT0=110; // Inicialização do Timer/Contador 0
0x01 // Inicialização de Interrupção do Timer

#asm("sei") // Habilitar interrupções globalmente

enquanto(1)
; // Não Fazer
} // Fim do principal

Monte este código e programe seu chip. A contagem deve começar assim que
a programação está completa.

Pressione o botão de reset na placa de desenvolvimento para reiniciar a contagem e iniciar um cronômetro
ver quanto tempo leva para contar até 255. Você descobrirá que esse tipo de cronômetro é muito
preciso.

Page 11 of 11