Engenharia Eletrotécnica e de Computadores

Trabalho Prático 2

AVR Butterfly
Microprocessadores e Microcontroladores

18-11-2014
Instituto Politécnico do Cávado e do Ave
-Tiago Valente nº 4422 - José Ruão nº 6790
 AVR Butterfly

1-Resumo

O Objectivo deste trabalho prático passa pela a aplicação de alguns conceitos de programação de
microcontroladores do tipo AVR ATMega169, desse modo foi desenvolvido um programa em linguagem
C, para ser executado num kit de desenvolvimento AVR Butterfly. Neste caso o objectivo passa pela
implementação de um relógio digital e a sua visualização no display LCD do kit, sendo que o programa
deverá respeitar os seguintes requisitos:

 A visualização das horas minutos e segundos deverá ser feita através do LCD no formato
hh:mm:ss. O valor dos segundos, minutos e horas deverá ser incrementado, respeitando os
requisitos temporais de um relógio digital comum, nomeadamente, a incrementação dos
segundos deverá ser feita com intervalos regulares de um segundo, a incrementação dos
minutos deverá ser feita de 60 em 60 segundos e a incrementação das horas deverá ser feita de
60 em 60 minutos. Deverá ser usado um timer devidamente configurado para o efeito.

 De segundo em segundo o caracter “:” existente no LCD deverá ser activado/desactivado, de

modo a ter uma aparência intermitente. O período da intermitência deverá ser de 2 segundos.

 Deverá ser possível acertar o relógio (horas, minutos e segundos) através do joystick. A activação
do modo de acerto deverá ser feita através da pressão do botão central do joystick. Empurrando
o joystick para a esquerda e para a direita deverá ser possível mudar o acerto entre horas
minutos e segundos. Empurrando o joystick para cima e para baixo deverá ser possível aumentar
e diminuir o valor das horas, minutos ou segundos, consoante o valor que esteja em modo de
acerto. O valor que esteja em modo de acerto (horas, minutos ou segundos) deverá alternar, a
cada segundo, entre o valor actual e espaços.

Tiago Valente e José Ruão 2

 AVR Butterfly

Índice

1-Resumo ......................................................................................................................................................................2
2-Introdução .................................................................................................................................................................5
3-Desenvolvimento.......................................................................................................................................................6
3.1- Justificação do Código ...................................................................................................................................6
3.1.1-Bibliotecas ...................................................................................................................................................6
3.1.2- Variáveis utilizadas: ....................................................................................................................................6
3.1.3- Função Main: ..............................................................................................................................................7
3.1.3.1-Configuração do Relógio ......................................................................................................................7
3.1.3.2-Configuração do Joystick ......................................................................................................................8
3.1.4-Atendimento a Interrupções: ....................................................................................................................10
3.1.4.1-Temporizador .....................................................................................................................................10
3.1.4.2-Botões.................................................................................................................................................11
3.1.5-Função MostrarLCD(): ...............................................................................................................................11
3.1.6-Acertar: ......................................................................................................................................................12
3.1.6.1-Acertar SEGUNDOS.............................................................................................................................12
3.1.6.2-Acertar MINUTOS ...............................................................................................................................13
3.1.6.3-Acertar HORAS ...................................................................................................................................15
4 - Conclusão ..............................................................................................................................................................16
5 - Bibliografia .............................................................................................................................................................17

Tiago Valente e José Ruão 3

 AVR Butterfly

Índice de Figuras

Figura 1 – Prescaçer 1/128 ...........................................................................................................................................8

Figura 2 – Botões Joystick .............................................................................................................................................9

Tiago Valente e José Ruão 4

 AVR Butterfly

2-Introdução

Neste trabalho pretende-se implementar um relógio digital, onde num LCD deverão aparecer as Horas,
minutos e segundos. Para tal, este programa devera ser implementado em C e executado no Kit AVR
Butterfly.

O AVR é um microcontrolador RISC de chip único com uma arquitectura Harvard modificada de 8-bit,
desenvolvido em 1996 pela Atmel Noruega, por dois estudantes fundadores da subsidiária naquele país,
venderam a tecnologia para a Atmel como RISC (Micro RISC). Foi um dos primeiros da família de
microcontroladores a utilizar uma memória flash com o intuito de armazenar a programação,
diferentemente de seus concorrentes da época, que utilizavam memórias do tipo PROM, EPROM ou
EEPROM. A arquitectura Harvard modificada do AVR tem o programa e os dados armazenados em
sistemas de memória física separados, que aparecem em diferentes espaços de endereços, mas possui a
capacidade de ler os itens da memória do programa usando instruções especiais. A Flash, EEPROM e
SRAM são todos integrados em um único chip, fora o necessário pelas memórias externas nas maiorias
das aplicações.

O AVR Butterfly possui o tamanho aproximado de um cartão de crédito, e é um microcontrolador auto-

suficiente alimentado a bateria. A placa inclui :

 Microcontrolador ATmega169 AVR ;

 Mostrador LCD;
 4Mbit Dataflash;
 Oscillator externo de 32kHz ;
 Joystick;
 Resistência sensível a luminosidade (LDR):
 Sensor de temperatura (NTC);
 Altifalante;
 Acesso aos portos do microcontrolador;
 RS-232 Level Converter;
 Bateria;
 Porta série;
 Memória flash interna.

A forma adotada de programar este dispositivo nas nossas aulas, foi utilizando o módulo WinAVR que
foi acrescentado ao AVR Stúdio. Este módulo é composto de um compilador para Linguagem C, que
inclui o compilador GCC GNU, para a família dos microcontroladores AVR ATMEL. Desta forma podemos
programar os microcontroladores AVR com linguagem C que será de mais alto nível do que a linguagem
assembly que utilizámos para programar o PIC e o primeiro da família AVR que introduzimos na aula, o
AT8515.

Tiago Valente e José Ruão 5

 AVR Butterfly

3-Desenvolvimento

Para o desenvolvimento deste trabalho prático foi necessário conhecer e entender os princípios de
funcionamento do AVR ATMega16. Após esta fase estar concluída iniciou-se então o desenvolvimento
de um código para o programa em linguagem C.
Trata-se de um programa que apesar de ser construído em linguagem C, há certos parâmetros que nos
familiariza-mos com a linguagem Assembly, pois há certos registos que tivemos de ter em conta para a
utilização de alguns recursos do microcontrolador. Como exemplo, utilizamos o Timer2 presente no
ATMega169 para a incrementação dos segundos, e fizemos a configuração dos registos do joystick do
AVR Butterfly. Desse modo o programa tem a capacidade de actuar nos registos de um PIC, enviando e
recebendo informações.

3.1- Justificação do Código

3.1.1-Bibliotecas

Tal como na linguagem C, a primeira parte do código são os ‘includes’ das bibliotecas para que ao
utilizamos esta linguagem os respectivos comandos sejam reconhecidos.

3.1.2- Variáveis utilizadas:

Estas vão ser as nossas variáveis ao longo de todo o código desenvolvido. O “unsigned char”, não
permite armazenar valores negativos e portanto representa assim números de apenas 1byte num
intervalo que vai de 0 até 255.

Tiago Valente e José Ruão 6

 AVR Butterfly

3.1.3- Função Main:

Na função Principal do nosso programa indicamos as portas que os registos vão utilizar, activando os
enables e as flags.
Foi adicionada ao nosso código uma função para que seja possível interagir com as definições do LCD
Butterfly. A Função ‘LCD_Init()’ está inserida num ficheiro fonte do nosso projecto.
A função “sei()” é um enable que vai permite utilizar qualquer tipo de interrupção no nosso programa.
Por utlimo é chamada a função ‘MostrarLCD()’, que será abordada mais adiante.

3.1.3.1-Configuração do Relógio

Esta função permite configurar um temporizador que funcione com uma frequência de 1Hz, de modo
que a incrementação dos segundos sejam reais. Para isso é feita a configuração dos portos para a
utilização do clock interno de 32KHz com um dos prescaler disponíveis (prescaler de 1/128). Então
usamos o Timer 2 pois é o único que permite este tipo de clock. Para se calcular de quanto em quanto
tempo ocorria overflow no temporizador 2 utilizou-se a seguinte formula.

32.768kHz
𝑇𝑂𝑉𝑐𝑘 = = 1𝑠
256 ∗ 128

Tiago Valente e José Ruão 7

 AVR Butterfly

Na figura 1 podemos observar o prescaler com a devida configuração dos pinos.

Figura 1 – Prescaçer 1/128

Para habilitar-mos o temporizador em modo overflow acedeu-se ao registo TIMSK2 e fez-se set do bit
TOIE2. Foi ainda feita a configuração do registo ASSR, fazendo set do bit AS2 para que dessa forma seja
possível por o timer como um clock assíncrono e através do TCNT2 definiu-se o valor inicial de
contagem, neste caso igual a 0.

3.1.3.2-Configuração do Joystick

O registo EIMSK vai ativar o enable para os dois registos do portB e do portE. Então colocamos os bits
PCIE1 e PCIE0 a 1, dizendo ao microcontrolador que vamos usar este tipo de interrupções.
O registo EIFR permite ter acesso á flag que será ativada quando ocorrer uma variação nas portas B e E
definidas no código seguinte. Para tal, colocamos os respectivos bits PCIF1 e PCIF0 a 1.

No registo PCMSK1 indicamos os pinos PCINT12, PCINT14, PCINT15 (pinos do portB) que serão utilizados
para a interrupção PIN CHANGE INTERRUPT1. Assim sempre que ocorrer uma variação nestes pinos será
activada a respectiva flag (PCIF1).
De igual modo, indicamos no registo PCMSK0 os pinos PCINT2 e PCINT3, mas neste caso para o portE,
onde é activada a flag PCIF0.

Tiago Valente e José Ruão 8

 AVR Butterfly

Após configurados os registos dos botões e respectivas interrupções externas, para se poder usa-los foi
necessário especificar qual a direcção dos pinos, isto é, se correspondem a uma entrada ou a uma saída.
Foi então com os registos DDR que especificamos os respectivos botões colocando-os no estado LOW
para que desse modo ao pressionar no botão passe do estado HIGH para LOW.
Na figura 2 podemos observar os pinos que usamos como interrupções do pin-change.

Figura 2 – Botões Joystick

Tiago Valente e José Ruão 9

 AVR Butterfly

3.1.4-Atendimento a Interrupções:

3.1.4.1-Temporizador

Para a interrupção de overflow do timer2 utilizou-se a função ‘ISR(TIMER2_OVF_vect)’. É aqui que

vamos incrementar o nosso tempo de 1 segundo devido ao overflow definido no timer2, que se
encontra na função main. Assim a cada 1 segundo vai ocorrer uma interrupção, e é a partir daqui que
vamos programar o nosso relógio.
Foi necessário utilizar um conjunto de ‘if`s’ tendo em conta o limite de um relógio (23:59:59), passando
de imediato para a posição inicial (00:00:00). De seguida guardou-se numa string de 6 caracteres no
formato HH:MM:SS, para mostrar o valor no display das variáveis que iam sendo incrementadas.
Foi necessário colocar em cada posição da string o valor correto, uma vez que o modo de enviar dados
ao display é feito caracter a caracter e como a função de mostrar só recebe dados da tabela ASCCI
sumamos-lhe o valor 48 que corresponde ao valor 0. A divisão por 10 e o resto da divisão por 10 foi um
“truque” utilizado para que fosse visível os números nas 2 casas correspondentes ao valor lido. Por
exemplo, em 21 segundos, quando fazemos a divisão por 10 obtemos 2.1, mas para a respectiva posição
da string só lhe enviamos o valor 2 , e quando lhe fazemos o resto da divisão enviamos-lhe o valor 1
para a posição seguinte.
Foi também nesta função que determinamos os “:” do LCD , em que estão ligados num segundo e
desligados no segundo seguinte.

Tiago Valente e José Ruão 10

 AVR Butterfly

3.1.4.2-Botões

Aqui é feito o atendimento a interrupções de uma porta externa proveniente do

PIN_CHANGE_INTERRUPT_1. Assim quando existir uma interrupção devida a um botão externo do
joystick, que neste caso vai ser o do pin 4 do portB, o programa salta para esta função. Dentro dela
colocamos a variável botão a 1, que vai fazer com que o programa salte da função ‘MostrarLCD()’ para a
função ‘AcertarS()’.
Foi também necessário configurar o registo EIFR colocando o bit PCIF1 a 1 para activação da flag do
PortB do AVR.

3.1.5-Função MostrarLCD():

Na função main depois de indicarmos as portas que os registos vão utilizar, e após ter sido definido o
timer que utilizamos de 1 segundo chama-mos a função ‘MostrarLCD()’.
Nesta função podemos observar que no ciclo ‘While(1)’ temos tudo o que é necessário para mostrar no
LCD da butterfly, onde a variável testString que começa em 0 vai sendo incrementada na respectiva
posição do array.
Ainda inserido nela, temos um ‘if botao=1’, que nos vai permitir fazer o acerto dos segundos, minutos e
horas mais adiante. Dentro deste ‘if’ a primeira função que é chamada é a função ‘AcertarS’. Sendo
assim o primeiro parâmetro a ser acertado quando pressiona-mos o PINB4 são os segundos.

Tiago Valente e José Ruão 11

 AVR Butterfly

3.1.6-Acertar:

Nas três funções seguintes, vamos poder acertar o relógio primindo os botões do joystick, seta para
cima para aumentar o tempo, seta para baixo para diminuir o tempo, seta para o lado esquerdo e lado
direito para deslocarmos a posição que queremos acertar.
As funções são idênticas, cada uma com a sua logica por isso, vamos falar apenas da função
‘AcertarM()’, por se tratar da função que mais condições possui. As funções’ AcertarS()’ e ‘AcertarH()’
seguem o mesmo principio de funcionamento, apenas com configurações diferentes.

3.1.6.1-Acertar SEGUNDOS

Tiago Valente e José Ruão 12

 AVR Butterfly

3.1.6.2-Acertar MINUTOS

A função de acertar os minutos, é chamada quando na função acertar segundos o PINE2 = 0 ( joystick
para o lado esquerdo). Dentro desta função encontramos um ciclo infinito ‘While(1)' que vai estar
sempre a mostrar a testString para garantir que os segundos vão sendo incrementados mesmo em
modo de acerto.

O conjunto de ‘if`s’ vai nos permitir configurar os sentidos do joystick. Por exemplo, quando PINB6 se
encontra no estado LOW vão sendo incrementados os minutos com a condição de não passar os 59min.
O mesmo acontece para o PIN7, mas neste caso para decrementar.

Neste extrato de código dentro do ciclo ‘for’ fazemos corresponder as posiçoes corretas do array para
acertar os minutos. Neste caso são as posiçoes 3 e 4 do array.

Foi mostrado ainda uma variavel string com 6 espaços para que no sitio dos minutos desse um efeito de
“piscar”.

Tiago Valente e José Ruão 13

 AVR Butterfly

Continuando com os ‘if`s’, quando o PINB4 ( botao central do joystick ) for pressionado, ou seja, passa
do estado HIGH para o estado LOW voltamos á função ‘MostrarLCD()’ com os respetivos minutos já
acertados.

O PINE3 e o PINE2 permitem fazer a deslocação do acerto. Um vai permitir saltar para a função acertar
segundos e o outro para a função acertar as horas.

Tiago Valente e José Ruão 14

 AVR Butterfly

3.1.6.3-Acertar HORAS

Tiago Valente e José Ruão 15

 AVR Butterfly

4 - Conclusão

A montagem do trabalho pratico 2 foi concluído com sucesso. Neste projecto os requisitos do enunciado
foram satisfatórios. O relógio funciona bem, o incremento dos segundos é real, bem como o piscar dos
“:”, as limitações de um relógio também funcionam como na realidade e o joystick está de acordo com o
requisitado.

Com a realização deste projecto ficamos a conhecer mais um novo microcontrolador desta vez o
ATMega169. Com a utilização da linguagem C para a sua programação tornou-se mais intuitiva a
percepção do que se ia desenvolvendo.

De referir que foi importantíssimo a utilização do software Proteus pelo facto de podermos simular o
nosso código. Assim fomos desenvolvendo e testando o nosso relógio bem como os botões do joystick.

No final deste trabalho, ficámos com as noções de como utilizar um AVR Butterfly, utilizando
interruptores internos e o seu Display.

Tiago Valente e José Ruão 16

 AVR Butterfly

5 - Bibliografia

 Datasheet do ATMega169

 Datasheet do AVR Butterfly

 http://en.wikipedia.org/wiki/AVR_Butterfly
 http://pt.wikipedia.org/wiki/Atmel_AVR

Tiago Valente e José Ruão 17