gerenciador do atmega16
TRANSCRIPT
PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ Engenharia Elétrica Ênfase em Telecomunicações
Microprocessadores e Arquitetura de Computadores II
Aplicativo gerenciador do Atmega16
Professor: Vilson Rodrigo Mognon
Alunos: Flávio Cezario Côrrea
Gabriel Lançoni de Oliveira Lima
02/12/2011
2
SUMÁRIO
1. Introdução ..................................................................................... 3 1.1 O Projeto..................................................................................................................... 3 1.2 Objetivo ................................................................................................................. 4
2. Metodologia ................................................................................ 4 2.1 Planejamento e Pesquisa. ...................................................................................... 5 2.2 Código gravado na Memória Flash. ....................................................................... 6 2.3 Hardware .................................................................................................................... 6
3. Desenvolvimento do Projeto e Planejamento........................ 6 3.1 Planejamento ............................................................................................................. 6 3.2 Comunicação Serial.................................................................................................. 7
3.2.1 Comunicação Serial (Computador)................................................................. 7 3.2.2 Comunicação Serial (AVR) .............................................................................. 8
3.3. Software..................................................................................................................... 9 3.3.1 Ambiente integrado de desenvolvimento....................................................... 9 3.3.2 Visual Studio..................................................................................................... 10 3.3.3 AVR Studio ....................................................................................................... 11 3.3.4 AVR DUDE ....................................................................................................... 11 3.3.5 Scripts de Execução........................................................................................ 12 3.3.6 Windows Form ................................................................................................. 13
3.4 Funcionalidades ...................................................................................................... 15 3.4.1 Controle de LEDS ............................................................................................ 15 3.4.2 Escrita no Display LCD....................................................................................... 16 3.4.3 Captura de Temperatura ................................................................................ 16 3.4.4 Gerador de Ondas. .......................................................................................... 17
3.5 Máquina de estados. ............................................................................................... 18 3.6 Microcontrolador ATMEGA16 .......................................................................... 19
3.6.1 CIRCUITO BÁSICO DO MICROCONTROLADOR .................................... 19 3.6.2 LEDS.................................................................................................................. 20 3.6.3 SENSOR DE TEMPERATURA ..................................................................... 21 3.6.4 DISPLAY LCD .................................................................................................. 21 3.6.5 DAC................................................................................................................... 21
4.Conclusão.................................................................................... 23
Referências .................................................................................... 24
Apêndices ......................................................................................... 25
Código fonte gravado no AVR: ....................................................... 25
Informações estatísticas .............................................................. 35
3
1. Introdução -Soluções em Informática estão cada vez mais abrangendo áreas em Sistemas
eletrônicos, e sistemas controladores existem nas mais variadas aplicações,
desde um simples jogo que roda em aparelhos celulares até caixas eletrônicos de
bancos, salas de controle de tráfego de metrô e avião. A sociedade tem
demandado cada vez mais sistemas que têm natureza distribuída e complexa em
ambientes heterogêneos.
1.1 O Projeto
Trata-se de uma aplicação, executado em ambiente Windows, desenvolvido em
linguagem C#. O Software tem caráter educacional, pois através de um painel de
controle é possível programar o micro-controlador para executar múltiplas tarefas
sem ter conhecimento de eletrônica ou programação, baseado nisso o usuário irá
interagir com o equipamento e conhecer todas as possíveis funções de um micro-
controlador, alterando entre suas implementações em tempo real.
O software terá um menu com as opções para escolher qual parte do ATMEGA16
interagir. Um exemplo básico dentre suas funcionalidades está a interação com
os leds. Seria possível acender uma combinação de leds do micro-controlador
marcando as respectivas check-box incluso no ambiente gráfico do software. O
usuário poderá navegar através dos menus e em poucos segundos interagir com
qualquer parte do microcontrolador.
O Software Gráfico, desenvolvido com o auxílio de uma IDE (Integrated
Development Environment ou ambiente integrado para desenvolvimento de
software) .
O AVR utilizado no projeto é o ATMEGA16, um microcontrolador RISC de chip
único com uma arquitetura Harvard modificada de 8-bit (µC), desenvolvido pela
Atmel. Ele combina 16KB de memória flash programável, 1KB SRAM, 512B
EEPROM, 8-channel 10-bit A/D converter, e JTAG interface de gravação e
4
depuração. Na execução de instruções em um único ciclo de clock, o dispositivo
atinge a taxa de transferência aproximando 1 MIPS por MHz, consumo de energia
de equilíbrio e velocidade de processamento.
A lógica codificada utilizada no desenvolvimento da aplicação, trata-se de envios
de códigos pela porta serial. Os códigos recebidos são guardados em variáveis
declaradas no código do AVR. Esse código transforma a lógica do AVR
semelhante a uma máquina de estados.
1.2 Objetivo
O Objetivo deste projeto é desenvolver uma aplicação em ambiente gráfico, de
fácil acessibilidade para o usuário, e faço entendimento das funcionalidades
disponíveis, sem a utilização de re-gravação na memória flash do
microcontrolador. Baseado nisso, o requisito principal desse aplicativo é após
gravado o código na memória flas, utilizar apenas o cabo USB para a troca de
informações PC - AVR.
2. Metodologia
Para o desenvolvimento do projeto, inicialmente foi elaborado dezenas de códigos
internos do AVR para interar sobre as funcionalidades disponíveis no chip. Os
códigos em formato c# foram inseridos junto aos diretórios que compões a
aplicação. Cada um desses códigos representam uma parte de uma
funcionalidade do sistema, por exemplo um código único para acender um led.
Com base no material disponível, a próxima etapa do método a ser implementado
é inserir com o auxílio de script de execução (arquivo .bat) uma conexão do
AVRDUDE com a aplicação. Nota-se que o AVRDUDE é uma ferramenta
executada em ambiente “DOS” – “Disk Operating System”, o que facilitou a
conexão.
5
A etapa seguinte foi o desenvolvimento do esquema gráfico da aplicação. Foi
Utilizado uma IDE para facilitar a inserção de buttons, checkbox, textbox e demais
ferramentas de apoio gráfico disponíveis na Toolbox da IDE.
Após inserir todos os códigos nos comandos “click button” – clique do mouse no
botão, o método final a ser executado era diminuir a quantidade de arquivos
separados . Foi visto que ao utilizar máquina de estados, existia a possibilidade de
fazer uma junção de todos os códigos que estavam em arquivos separados em
apenas um. Baseado em estudos de máquina de estados, foi elaborado uma
metodologia para adaptar todos os arquivos em “cases” em apenas uma arquivo
.c.
Quanto a comunicação seria do AVR com o PC, o método utilizado foi uma classe
“serialport” disponível na IDE, o que facilitou a comunicação. Com isso foi possível
envia e capturar caracteres. A máquina de estados, muda de estados de acordo
com o caractere enviado para o AVR.
2.1 Planejamento e Pesquisa.
Antes da decisão de iniciar o projeto, foi feito uma pesquisa sobre todas as
possibilidades de comunicação entre a AVR com o PC, com o fato de o AVR
possuir porta serial USB, a pesquisa teve como escopo a comunicação USB do
PC, baseado em seu principio de funcionamento, a etapa seguinte de pesquisa foi
encontrar métodos facilitados e eficientes de criar a comunicação. Com isso o
escopo neste momento foi a pesquisa baseada nas IDEs do mercado. Viu-se que
o Visual Studio 2010 Express Version trata-se de uma ferramenta gratuita e
licenciada para desenvolvimento de aplicação Windows, com todas as
possibilidades de comunicação pesquisadas neste projeto.
6
2.2 Código gravado na Memória Flash.
Para a interpretação e geração do arquivo .hex a ser gravado na memória flash do
microcontrolador, foi utilizado o AVR Studio 4, ferramenta desenvolvida pela
Atmel.
O código desenvolvido depende de arquivos anexados ao projeto, o arquivo pode
ser em formato .c e .h. Dependendo da situação do “case” da máquina de
estados, pode se iniciado componentes do microcontrolador ou ser chamado
funções dentro destes arquivos anexos. No corpo do arquivo principal (“main”) foi
inserido o “case” que fica aguardando contato pela porta serial e outras funções
que controlam os componentes da placa.
2.3 Hardware
Utilizou-se neste experimento uma placa com microcontrolador ATMEGA16,
uma placa gravadora, e um osciloscópio para análise de ondas
Para se utilizar o software desenvolvido para controlar a placa atmega16 e
necessário conectar o gravador a placa e realizar a gravação do arquivo hex na
placa atmega16. Depois desta primeira gravação se utilizará somente um cabo
serial para realizar a comunicação entre o software e a placa microcontroladora.
Para se observar as formas de onda geradas pelo software deve-se
conectar um osciloscópio na placa e em seguida realizar as configurações
necessárias para uma perfeita visualização das ondas no mesmo.
3. Desenvolvimento do Projeto e Planejamento
3.1 Planejamento
Após decisão do que seria o foco principal do projeto e reunião para tratar de
assuntos de cronograma e divisão de etapas, o desenvolvimento do projeto
iniciou-se no laboratório de Engenharia Elétrica da PUC-PR, onde foram testadas
todas as funções do microcontrolador para evitar confusão entre problemas de
hardware e software. Uma vez a placa testada e habilitada 100%, dependeria da
7
correção de problemas de software que poderia ocorrer no andamento do projeto,
o que por fim facilitaria a procura de erros.
3.2 Comunicação Serial
A comunicação serial são é muito usada como forma de controle de equipamentos
eletromecânicos e eletrônicos e você pode ser utilizado a linguagem de
programação C para criar a interface que possibilite interagir com os mesmos.
O Envio de seqüências de caracteres pela porta serial assume que o computador
está utilizando COMX; sendo X o número da porta identificada automaticamente
pelo computador, e para maior flexibilidade, o código deveria permitir ao usuário
que selecionasse a porta serial desejada em uma lista de portas disponíveis.
No presente projeto, a comunicação serial pode ser dividida em duas etapas
diferentes, a primeira trata-se da codificação desenvolvida para que o computador
possa interpretar, receber e enviar dados, e a segunda é por parte de
microcontrolador receber e enviar dados. Em ambos os casos foi utilizado a
linguagem C# este desenvolvimento.
3.2.1 Comunicação Serial (Computador)
Na primeira situação, foi necessário gerar uma classe denominada “serialport1” no
qual possui as seguintes propriedades:
1. Baud Rate: Declarada como serialport1.baudrate, define a velocidade ou
taxa de transmissão de dados.
2. Databits: Declarada como serialport1.databits, Obtém ou define o
comprimento padrão de bits de dados por byte.
3. Portname: Declarada como serialport1.portname, Obtém ou define a porta
de comunicação, no qual esse nome é gerado automaticamente ao
conectar um dispositivo USB mo computador.
Possui os seguintes métodos:
8
1. Open: utilizado o comando serialport1.Open() para o método ser chamado,
Abre uma nova conexão de porta serial.
2. Close: utilizado o comando serialport1.Close() para o método ser chamado,
Fecha a conexão, é recomendável ser chamada após cada intervalo de
comunicação.
3. ReadChar: utilizado o comando serialport1.ReadChar() para o método ser
chamado, sincronicamente lê um caractere a partir de SerialPort buffer de
entrada.
4. Write: utilizado o comando serialPort1.Write("0"); para o método ser
chamado e enviado o caractere “0” como exemplo.
O exemplo de código a seguir demonstra o uso de SerialPort classe para permitir
que o computador entre em comunicação com o microcontrolador, ambos
separados e conectados por um cabo USB. Neste exemplo, o dispositivos envia
dados para o microcontrolador, na seção seguinte que trata da comunicação serial
por parte do AVR, será colocado o código de recebimento. Os dois dispositivos
devem executar o programa concomitamente para obter funcionalidade completa.
exemplo 1:
3.2.2 Comunicação Serial (AVR)
A USART é um módulo de hardware que compõe o chip do ATMEGA,o mesmo
permite que o ATMEGA se comunique com outros dispositivos usando um
protocolo serial, o USART essencial para a comunicação serial com o
xx== uuaarrtt__ggeettcchhaarr (());; sswwiittcchh ((xx)) {{ ccaassee ''aa'':: ffuunnccaaoo__DDAACC(());; bbrreeaakk }}
9
computador e para isso deve-se de configurar a USART com as seguintes
funções:
1. Inicializa componente: define UBRRH, UBRRL, UCSRA, UCSRB, UCSRC.
Que são registros que definem situações e parâmetros em que deve estar a
comunicação serial.
2. Escreve byte: encaminha byte pela porta serial
3. Escreve String: Função que encaminha seqüência de caracteres pela porta
serial.
4. Lê byte: Recebe caractere.
Neste exemplo, após ser encaminhado um caractere (vide exemplo 1) a função no qual guarda o caractere recebido em uma variável. Exemplo 2:
3.3. Software
Neste projeto, o software é um dos componente principais e o diferencial do
projeto. Como foi citado anteriormente, aplicativos de controle de hardware estão
cada vez mais essenciais e para ter uma boa aplicação de suas implementações
deve-se ter conhecimento do que existe e suas possibilidades, nos tópicos a
seguir desta seção, será descrito o que foi utilizado.
3.3.1 Ambiente integrado de desenvolvimento
xx== uuaarrtt__ggeettcchhaarr (());; sswwiittcchh ((xx)) {{ ccaassee ''aa'':: ffuunnccaaoo__DDAACC(());; bbrreeaakk }}
10
Uma IDE pode tornar um trabalho muito mais simples, principalmente se a
linguagem conhecida pelo usuário for a mesma para todas as IDE utilizadas no
projeto, o que foi o caso deste projeto.. Ademais estes ambientes nos permitem
muito mais versatilidade para depurar nossos programas visto que têm debbugers
muito mais avançados. O Presente projeto contou com o Visual Studio 2010
express version para criar o ambiente gráfico utilizando a tecnologia Windows
Form, e a plataforma de desenvolvimento .NET Framework 4.0, a mais avançada
da Microsoft.
Também foi utilizado o AVR Studio 4 para fácil entendimento do que o compilador
interpreta. Através do painel I/O view, pode-se ter uma visão precisa do que
acontece no microcontrolador sem ter o mesmo conectado.
3.3.2 Visual Studio
O Visual Studio 2010 Express version é uma ferramenta de desenvolvimento
gratuita, a mesma pode ser baixada em formato imagem ou instalador no próprio
site da Microsoft. A Empresa permite a utilização desta versão para efeitos até
mesmo comerciais.
Ao ser aberto o programa, foi criado um novo projeto do tipo Windows form,
baseado em linguagem C#. A IDE conta com várias ferramentas de auxílio. É
importante saber que elas apenas criam o ambiente gráfico.
A seguir será relacionado as ferramentas utilizadas neste projeto:
1. Toolbox - É uma caixa de ferramenta, com ela pode-se arrastar
ferramentas para dentro do formulário. Como foi descrito nesta seção, as
ferramentas do toolbox apenas criam o ambiente gráfico, por isso é necessário dar
dois cliques em cima das ferramentas inseridas no formulários e inserir os códigos
referentes a cada ferramenta. As ferramentas mais utilizadas neste projeto foram a
textbox, serialport, combobox, label, panel. Ao ser inseridos ela apenas cria as
classes das respectivas ferramentas.
11
2. Solution Explorer – Este painel relaciona todos os arquivos presentes no
projeto. Para cada parte da aplicação deste projeto foi necessário criar um
formulário, e os mesmos ficam relacionados neste painel.
3. Properties – Um dos mais importantes em termos de acessibilidade.
Neste projeto pode-se citar como exemplo os parâmetros da porta serial. Após
arrastar a ferramenta serialport da ToolBox, pode-se declarar os parâmetros da
porta serial através deste painel entitulado “properties”.
3.3.3 AVR Studio
O AVR Studio é um ambiente Windows para programação e simulação dos
microcontroladores da família AVR (RISC) da Atmel. Neste projeto o mesmo foi
essencial para o desenvolvimento. Toda a codificação gravada na memória flash
do microcontrolador foi baseado nas informações geradas por esta IDE.
A linguagem utilizada foi a C#, por isso foi necessário instalar a biblioteca GCC.
No painel da esquerda está relacionado todas as pastas e arquivos presente neste
projeto. Foi criado uma arquivo “main” (principal) e arquivos anexos .c e .h que são
parte integrante do projeto. No painel da direita a ferramenta “I/O view” foi
bastante utilizada para verificar a situação do código. O Maior problema
encontrado foi opção “build e run”, a qual não foi possível utilizar o (“Step Over”),
pois na função uart_getchar, o compilador não avança de estado até receber um
dado pela porta serial, e como não existe integração entre o AVR Studio e Visual
Studio, esta função não foi utilizada. Porém recomenda-se para todas as demais
situações que não utilize-se o aguardo de dados pela porta serial.
3.3.4 AVR DUDE
O AVRDude é uma aplicação de código aberto para gravar programas na Flash de
processadores AVR. Por se tratar de código aberto, foi de fácil integração com o
Windows Form criado pelo visual Studio. O mesmo foi adaptado para efetuar o
método de gravação do arquivo .hex na memória flash. Lembrando que como
12
neste projeto tem apenas um arquivo .hex, esta funcionalidade foi utilizada apenas
em um único botão do formulário. A seguir será colocado como exemplo o código
de gravação utilizado no projeto.
Exemplo 3
No exemplo 3, o chamado o arquivo avrdude.conf que relaciona os parametros de
diversos microcontroladores. Este arquivo contém dados de configuração usado
pelo avrdude que descreve
a programação de hardware e pinouts e também fornece definições das partes.
O "-C" é a opção de linha de comando que especifica a localização do
arquivo de configuração. O "-c" é a configuração do programador
que deve corresponder a uma da entrada do "id" de parâmetro. O "-p" Identifica
quais partes do avrdude vai ser a programação e deve corresponder
a umma das partes '"id" de parâmetro. A descrição mais aprofundade deste código
pode ser visto abrindo este arquivo com o notepad do Windows.
3.3.5 Scripts de Execução
Para a execução de algumas tarefas, foi utilizado arquivos .bat para facilitar
chamadas de procedimentos no projeto, a seguir será relacionado as duas
chamadas presentes neste projeto.
1. Localizar nome da porta serial conforme exemplo a seguir, o procedimento
abre o gerenciador de dispositivos para rápida visualização do nome da
porta.
Exemplo 4
avrdude -C avrdude.conf -c usbasp -p m16 -U flash:w:"atmega_ger.hex":a -q
mmc devmgmt.msc exit
13
2. Abrir diretório com os drivers “USART DRIVER” e “usbasp-windriver”
para instalação caso seja necessário.
Exemplo 5
3. Gravar arquivo .hex imediatamente na placa, sem precisar a sua
configuração. O arquivo de execução é o mesmo do exemplo 3.
3.3.6 Windows Form
Talvez o grande diferencial deste projeto, o Windows form é uma tecnologia
empregada por diversas IDE, neste projeto ele tem como foco facilitar a interação
do usuário com a aplicação. A tecnologia empregada nos formulários é a .NET
Framework 4.0 foi desenvolvida pela Microsoft.
A seguir será relacionado as caixas de texto, labels, combobox, abas e demais
acessibilidades inclusas neste projeto.
Abas: Utilizado no projeto para
viabilidade na navegação entre as
funcionalidades, e forma visual de
fácil interpretação.
Botões: Não trata-se apenas do
visual, por trás dele, contém a
função on-click que executa a função
inserida em cada botão.
explorer drivers exit
14
Labels e Caixas de Texto: As labels
e as caixas de textos são textos que
são guardadas em variáveis
chamadas de label1.Text ou
textbox1.Text, na qual foi utilizada
em demais métodos da aplicação.
CheckBox – As check Box foram
utilizadas no projeto para definir
estado dos leds, uma vez marcados,
ele encaminha “on change” caractere
pela porta serial.
Painéis – Os painéis foram utilizados
neste projeto para surgir e ocultar ao
dar o clique no botão avançar, isso
facilita a navegação e melhora o
design do projeto.
15
3.4 Funcionalidades
As funcionalidades implementadas nesta aplicação, pode se dividir em quatro
principais: Controle de LEDs, escrita no Display LCD, captura de temperatura e
gerador de ondas. Nas subseções a seguir será apresentado o desenvolvimento
destas funcionalidades.
3.4.1 Controle de LEDS
Superficialmente o controle de leds é feito acionando os leds através de um check
na checkbox, porém por trás disto existe uma codificação que compara através da
lógica de if´s e elses´s em qual condição está a checkbox. Pra cada uma das
check Box existem dois estados (marcado ou desmarcado) assim como pra cada
led existem dois estados (ligado ou desligado). A lógica utilizada trata-se do envio
de um código pela porta serial, que leva consigo a informação da situação da
checkbox. Ao receber a informação (código), o AVR compara esse código entre
várias situações e define o estado do led. A seguir será colocado um exemplo da
lógica utilizada.
Exemplo 6. Código da aplicação Exemplo 7 Código do AVR
//Se a checkbox 1 estiver marcada,
//enviar o caracter “a” pela porta serial
if (checkBox1.Checked == true)
{
serialPort1.Write("a");
}
case 'a':
PORTC |= (1<<0);
break;
16
3.4.2 Escrita no Display LCD
É inserido no projeto um campo de texto (TextBox) e um botão para o envio do
caracter. Com o comando serialPort1.Write(message_textbox.Text) a aplicação
encaminha pela porta serial todo o conteúdo digital naa caixa. A maior
complexidade do código ocorre no recebimento da informação por parte do AVR.
Ao receber o código o avr utiliza um vetor com tamanho 16 para guardar a
informação na primeira linha, caso a informação passe de 16 caracteres ele cria
uma condição que habilita um segundo vetor para os próximos 16 caracteres. Em
seguida é utilizado a função lcd_putchar para enviar os caracteres para a PORT
do LCD. Abaixo está o trecho do código utilizado.
Exemplo 8
3.4.3 Captura de Temperatura
Nesta funcionalidade é criada duas checkbox para definir a unidade de
temperatura, entre Celsius e Fahrenheit. Ao clicar em atualizar o código compara
pra verificar qual das checkbox está selecionada, e dentro desta condição a
aplicação guarda dentro de várias labels cada caracter enviado pelo AVR. Ao
mesmo tempo, o código do AVR encaminha a todo tempo a atualização da
for(c1=0;c1<16;c1++) {//5
vetor[c1]= uart_getchar ();
lcd_gotoxy(c1,0);
lcd_putchar(vetor[c1]);
if(c1==15){//3
for(c2=0;c2<16;c2++){//2
vetor[c2]= uart_getchar ();
lcd_gotoxy(c2,1);
lcd_putchar(vetor[c2]);}}}
17
temperatura. Em resumo, as labels só serão atualizadas no camando on click do
botão atualizar. A seguir é colocado um exemplo da aplicação.
Exemplo 9
3.4.4 Gerador de Ondas.
A Implementação do gerador de ondas, teve como principal dificuldade a
configuração do Stopwatch do AVR. Isto é, a freqüência depende do tempo que a
onda demora para completar um ciclo. A aplicação conta com 10 níveis de
freqüência para cada forma de onda. Existe um formato padrão de codificação
para cada onda, só alterando a variável n, componente da função delay do AVR, e
o vetor que guarda a forma de onda.
Basicamente o código funciona da seguinte forma, ao selecionar a freqüência e
clicar em enviar, a aplicação encaminha um código para o AVR, o AVR utiliza esse
código para vincular o tempo de atraso na variável n do delay, então, para cada
alteração de freqüência é encaminhado ou código diferente o que torna o tempo
de atraso da onda diferente.
for (int i = 0; i < 15; i++) { //guarda a informação recebida pela porta serial numa variável char message = Convert.ToChar(serialPort1.ReadChar()); listBox1.Items.Add(message.ToString()); }
//ao clicar em atualizar executa a seguinte função if (checkBox1.Checked == true) { label3.Text = listBox1.Items[0].ToString(); label4.Text = listBox1.Items[1].ToString(); label5.Text = listBox1.Items[2].ToString(); label6.Text = listBox1.Items[3].ToString(); label7.Text = listBox1.Items[4].ToString(); label8.Text = listBox1.Items[5].ToString(); label9.Text = listBox1.Items[6].ToString(); label10.Text = ""; label11.Text = ""; label13.Text = ""; serialPort1.Close(); }
18
Entretanto antes de ser enviado o código que representa a freqüência, a aplicação
encaminhou um código para informar ao AVR qual tipo de onda deve ser gerada.
Com base nessa informação a função que gera a onda escolhe um vetor diferente
para encaminhar a porta do DAC. A seguir um exemplo da situação descrita
acima.
Exemplo 10 Exemplo 11
3.5 Máquina de estados.
A máquina de estados que foi desenvolvida nesta aplicação, trata-se de seqüência
de códigos encaminhada pela aplicação a cada clique que o usuário acionar. Por
exemplo, se o usuário clicou na opção de acionar os leds, a aplicação encaminha
um caractere para o AVR. No mesmo momento, o AVR está na função principal
aguardando o recebimento desse caractere. E por fim dependendo do valor do
caractere o código através de um case interpreta qual função seguir. O código
ficará em looping até receber um sinal de cancelar da aplicação, no qual faz ele
//envio de código pela aplicação if (comboBox1.Text == "10 Hz") { serialPort1.Write("a"); }
while (!(UCSRA & (1 << RXC)) && den!='*' ){ //enquanto não receber sinal da serial if(den=='a'){n=9442;} //10.08 if(den=='b'){n=1888;} //50 if(den=='c'){n=944;} //100 if(den=='d'){n=472;} //200 if(den=='e'){n=188;}//500 if(den=='f'){n=93;}//1000 if(den=='g'){n=45;}//2000 if(den=='h'){n=29;}//3000 if(den=='i'){n=16;}//5000 if(den=='j'){n=13;}//6060 while (!(UCSRA & (1 << RXC))){ for(i=0; i<21; i++) { //encaminha valor do vetor para portC PORTC= dente[i]; ...
19
retornar ao estado inicial (função principal). A seguir um exemplo da
implementação:
3.6 Microcontrolador ATMEGA16
3.6.1 CIRCUITO BÁSICO DO MICROCONTROLADOR
Circuito esquemático contendo os componentes básicos para funcionamento do
microcontrolador atmega16:
SWITCH
CASE: 1 DAC
CASE: 2 LEDs
CASE: 3 DISPLAY
LCD
CASE: 4 Sensor
sseerriiaallPPoorrtt11..PPoorrttNNaammee ==
ccoommbboobbooxx11..tteexxtt;;
sseerriiaallPPoorrtt11..BBaauuddRRaattee ==
99660000;;
sseerriiaallPPoorrtt11..OOppeenn(());;
sseerriiaallPPoorrtt11..WWrriittee((““aa""));;
sseerriiaallPPoorrtt11..CClloossee(());;
xx== uuaarrtt__ggeettcchhaarr (());;
sswwiittcchh ((xx))
{{
ccaassee ''aa''::
ffuunnccaaoo__DDAACC(());;
bbrreeaakk
}}
20
3.6.2 LEDS
Utilizou-se no projeto LEDS SMD. Uma das vantagens do led SMD é que
eles são muito mais brilhantes que os LEDS comuns (Round, Superflux, etc) e
conseguem uma maior luminosidade. São indicados para aplicações que exigem
alta luminosidade e visibilidade.
SMD é uma nova tecnologia que tem por objetivo reduzir o espaço ocupado
pelos tradicionais componentes (resistências, diodos, transistores e CI's) em
certas placas, como as de computadores e outros aparelhos que precisam ser
complexos, porém ocupar pouco espaço.
SMD significa dispositivos montados em superfície.
O LED SMD possui alto brilho, com menor consumo de energia do que um
LED normal
21
3.6.3 SENSOR DE TEMPERATURA
O sensor de temperatura utilizado possui resolução entre 9 e 12 bits e é capaz de
medir temperaturas variando de -55 à 125ºC. Opera com uma corrente quiescente
na faixa de 45uA, sendo alimentado com uma tensão de 2,7V a 5,5V.
Sua comunicação com o microcontrolador e realizada através de barramento
serial padrãoI2C [8] .
3.6.4 DISPLAY LCD
Um LCD Alfanumérico HD44780 é um padrão da indústria de displays de cristal
líquido (LCD) dispositivo de visualização projetado para interface com sistemas
embarcados. Estes LCDs podem vir com ou sem luz de fundo (backlights), que
podem ser LEDs, fluorescentes, ou eletroluminecentes.
Os LCDs usam um padrão de 14 pinos e os LCDs que tem backlight de 16 pinos.
A tensão nominal do backlight é de cerca de 4.2V a 25˚C, utilizando uma
alimentação VDD de 5V.
Os LCDs podem operar em 4 bits ou no modo de 8 bits. No modo de 4 bits, os
pinos 7 a 10 não são usados e todo o byte é enviado para a tela usando os pinos
de 11 a 14 através do envio de 4 bits (nibble) de cada vez.
3.6.5 DAC
O conversor analógico-digital (freqüentemente abreviado por conversor A/D ou
ADC) é um dispositivo eletrônico capaz de gerar uma representação digital a partir
de uma grandeza analógica, normalmente um sinal representado por um nível de
tensão ou intensidade de corrente elétrica.
Os ADCs são muito úteis na interface entre dispositivos digitais
(microprocessadores, microcontroladores, DSPs, etc) e dispositivos analógicos e
são utilizados em aplicações como leitura de sensores, digitalização de áudio e
vídeo.
22
Por exemplo, um conversor A/D de 10 bits, preparado para um sinal de entrada
analógica de tensão variável de 0V a 5V pode assumir os valores binários de 0
(0000000000) a 1023 (1111111111), ou seja, é capaz de capturar 1024 níveis
discretos de um determinado sinal. Se o sinal de entrada do suposto conversor
A/D estiver em 2,5V, por exemplo, o valor binário gerado será 512.
23
4.Conclusão
Ao final do projeto, nota-se que com lógica simples e as ferramentas adequadas,
pode-se conseguir implementar qualquer funcionalidade no AVR, com controle
feito através de uma aplicação Windows. Também chega-se a conclusão que com
uma codificação bem elaborada pode juntar todas as funções da placa em um
único arquivo. A máquina de estados nesta situação foi utilizado para definir em
qual função da codificação do AVR irá agir, porém com essa mesma lógica é
possível criar outros tipos de aplicações, como por exemplo uma máquina de
estados que gera níveis de ondas a cada intervalo de tempo. Essa máquina de
estados caberia perfeitamente neste projeto, porém demandaria um pouco mais
de tempo.
As IDE´s utilizadas no projeto também foram de bastante utilidade e aumentou o
nível de conhecimento em áreas diferentes do foco deste projeto, o que abriu
possibilidades para no futuro implementar novas funcionalidades junto com o kit
ATMEGA16.
24
Referências
Suporte técnico Microsoft:
Informações técnicas utilizadas para montagem dos formulários
http://msdn.microsoft.com/pt-br/library/kx37x362%28v=VS.90%29.aspx
Informações técnicas utilizadas para conexão porta serial:
http://msdn.microsoft.com/pt-br/library/system.io.ports.serialport.aspx
Informações técnicas utilizadas para implementação de funções em linguagem c#
http://msdn.microsoft.com/pt-br/library/52f3sw5c%28v=VS.90%29.aspx
Suporte AVR
Informações utilizadas para aprofundar conhecimento da linguagem C# para AVR
Apostila AVR GCC Tutorial (WinAVR) By takashi
Informações utilizadas para conhecimento das funções do chip ATMEGA16
Datasheet atmega16:
http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf
Informações complementares
http://pt.wikipedia.org/wiki/Conversor_anal%C3%B3gico-digital
25
Apêndices
Código fonte gravado no AVR:
#include <avr/io.h> #include <util/delay.h> #include "serial.h" #include <stdlib.h> #include "lcd.h" unsigned int i; char x,y,seno, qua, tri, den; int n; char vetor[15]; int c1,c2; #include "i2c.h" //sensor temperatura unsigned char b1, b2; //variaveis auxiliares do sensor de temp. int z = 1; //variável do sensor de temp. int m,p; void tmp100_init() { // configuração de 12bits i2c_start(); i2c_write(0x94); i2c_write(0x01); i2c_write(0x60); i2c_stop(); } void tmp100_read() { i2c_start(); i2c_write(0x94); i2c_write(0x00); i2c_start(); i2c_write(0x95); b1 = i2c_read(0x01); b2 = i2c_read(0x01); i2c_stop(); } void dac_io() { PORTD = 0x00; DDRD = 0x80; PORTB = 0xF0; DDRB = 0x0; DDRC = 0xFF; // DDRC é saída, ligar flat cable do PORTC para DAC PORTC = 0x00; // Saída em nível baixo. } void leds_io() {
26
PORTD = 0x00; DDRD = 0x80; PORTB = 0xF0; DDRB = 0x0; DDRC = 0xFF; // DDRC é saída (LEDS) PORTC = 0x00; // Saída em nível baixo. } void lcd_io() { PORTD = 0x00; DDRD = 0x80; PORTB = 0xF0; DDRB = 0x0; } int sen[38] = {127.5, 106.5191953, 86.11041743, 66.83009722, 49.20389898, 33.71238852, 20.77793091, 10.75317499, 3.911438633, 0.439256941, 0.431296488, 3.887774311, 10.71445199, 20.72520499, 33.6470972, 49.1278224, 66.74530955, 86.01923035, 106.424095, 127.4035792, 148.3856923, 168.7983718, 188.0850804, 205.7199797, 221.2222665, 234.1692821, 244.2080352, 251.0648264, 254.5527099, 254.5765913, 251.1358193, 244.3242042, 234.3274599, 221.4181404, 205.9482094, 188.3394434, 169.071933, 148.6709933 }; char quad[20] = {0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255}; char trian[40] = {0,12.75,25.5,38.25,51,63.75,76.5,89.25,102,114.75,127.5,140.25,153,165.75,178.5,191.25,204,216.75,229.5,242.25,255,242.25,229.5,216.75,204,191.25,178.5,165.75,153,140.25,127.5,114.75,102,89.25,76.5,63.75,51,38.25,25.5,12.75}; char dente[21] = {0,12.75,25.5,38.25,51,63.75,76.5,89.25,102,114.75,127.5,140.25,153,165.75,178.5,191.25,204,216.75,229.5,242.25,255}; void senoidal(){ while(seno!= '*'){ //na primeira passagem seno = 0; seno= uart_getchar (); //escolha do número de frequência. //se apertar voltar ele manda * e sai da função seno. if(seno == '0') {seno = '*'; x='0';} //o usuário clicou no fechar(X), serial //encaminhou um 0 pra fechar o form da onda. while (!(UCSRA & (1 << RXC)) && seno!='*' ){ if(seno=='a'){n=5254;} //10Hz if(seno=='b'){n=1050;}// 50 if(seno=='c'){n=525;} //100 if(seno=='d'){n=260;}//200 if(seno=='e'){n=102;}//495 if(seno=='f'){n=50; } //1000 if(seno=='g'){n=23;} //2000 if(seno=='h'){n=15;}//3000 if(seno=='i'){n=8;} //5k if(seno=='j'){n=6;} //6k voltar 6 while (!(UCSRA & (1 << RXC))){ for(i=0; i<38; i++) {
27
PORTC= sen[i]; for(m=0;m<n;m++) { asm("nop"); } } //quero 10 hz então T = 0.1 // stopwatch X 38 (size) = 0.1 } } //stopwatch = 2631us ////F medida = }// fecha do while }//fecha do senoidal() void quadrada(){ while(qua!= '*'){ qua= uart_getchar (); if(qua == '0') {qua = '*'; x='0';} //o usuário clicou no fechar(X), serial //encaminhou um 0 pra fechar o form da onda. while (!(UCSRA & (1 << RXC)) && qua!='*' ){ if(qua=='a'){n=10000;} //10Hz if(qua=='b'){n=2000;} //50Hz if(qua=='c'){n=1000;}//100Hz if(qua=='d'){n=500;} //200hz if(qua=='e'){n=197;}//500Hz if(qua=='f'){n=97;}//1000 if(qua=='g'){n=47;}//2010 if(qua=='h'){n=31;}//3000 if(qua=='i'){n=17;}//5000 if(qua=='j'){n=14;}//6000 while (!(UCSRA & (1 << RXC))){ for(i=0; i<20; i++) { PORTC= quad[i]; for(m=0;m<n;m++) { asm("nop"); } //quero 10 hz então T = 0.1 } // stopwatch X 20 (size) = 0.1 } } //stopwatch = 5000us ////F medida =
28
}// fecha do while }//fecha do senoidal() void triangular(){ while(tri!= '*'){ tri= uart_getchar (); if(tri == '0') {tri = '*'; x='0';} //o usuário clicou no fechar(X), serial //encaminhou um 0 pra fechar o form da onda. while (!(UCSRA & (1 << RXC)) && tri!='*' ){ if(tri=='a'){n=5000;}//10 if(tri=='b'){n=1000;}//50 if(tri=='c'){n=498;}//100 if(tri=='d'){n=248;}//200 if(tri=='e'){n=97;}//500 if(tri=='f'){n=47;}//1000 if(tri=='g'){n=22;}//2000 if(tri=='h'){n=14;}//3000 if(tri=='i'){n=7;}//5100 if(tri=='j'){n=5;}//6400 excluir o 6 do programa. while (!(UCSRA & (1 << RXC))){ for(i=0; i<40; i++) { PORTC= trian[i]; for(m=0;m<n;m++) { asm("nop"); } //quero 10 hz então T = 0.1 } // stopwatch X 20 (size) = 0.1 } } //stopwatch = 5000us ////F medida = }// fecha do while }//fecha do senoidal() void dente_serra(){ while(den!= '*'){ den= uart_getchar (); if(den == '0') {den = '*'; x='0';} //o usuário clicou no fechar(X), serial //encaminhou um 0 pra fechar o form da onda. while (!(UCSRA & (1 << RXC)) && den!='*' ){ //enquanto não receber sinal da serial if(den=='a'){n=9442;} //10.08 if(den=='b'){n=1888;} //50 if(den=='c'){n=944;} //100 if(den=='d'){n=472;} //200
29
if(den=='e'){n=188;}//500 if(den=='f'){n=93;}//1000 if(den=='g'){n=45;}//2000 if(den=='h'){n=29;}//3000 if(den=='i'){n=16;}//5000 if(den=='j'){n=13;}//6060 while (!(UCSRA & (1 << RXC))){ for(i=0; i<21; i++) { PORTC= dente[i]; for(m=0;m<n;m++) { asm("nop"); } //qu } // stopwatch X 21 (size) = 0.1 } } //stopwatch = 4761us ////F medida = }// fecha do while }//fecha do senoidal() void atualiza_onda(){ switch (x) { case 'a': //onda senoidal senoidal(); break; case 'b': //onda quadrada quadrada(); break; case 'c': //onda triangular triangular(); break; case 'd': //onda dente de serra dente_serra(); break; case '0': //o usuário clicou no botão fechar e o serial encaminhou 0 x='0'; break; } }
30
void atualiza_led() { switch (x) { case 'a': //liga 1 PORTC |= (1<<0); break; case 'b': //desliga 1 PORTC &= ~(1<<0); break; case 'c': //liga 2 PORTC |= (1<<1); break; case 'd': //desliga 2 PORTC &= ~(1<<1); break; case 'e': //liga 3 PORTC |= (1<<2); break; case 'f': //desliga 3 PORTC &= ~(1<<2); break; case 'g': //liga 4 PORTC |= (1<<3); break; case 'h': //desliga 4 PORTC &= ~(1<<3); break; case 'i': //liga 5 PORTC |= (1<<4); break; case 'j': //desliga 5 PORTC &= ~(1<<4); break; case 'k': //liga 6 PORTC |= (1<<5); break; case 'l': //desliga 6 PORTC &= ~(1<<5); break; case 'm': //liga 7 PORTC |= (1<<6); break; case 'n': //desliga 7 PORTC &= ~(1<<6); break; case 'o': //liga 8 PORTC |= (1<<7); break; case 'p': //desliga 8
31
PORTC &= ~(1<<7); break; } } void atualiza_display() {//6 for(c1=0;c1<16;c1++) {//5 vetor[c1]= uart_getchar (); lcd_gotoxy(c1,0); lcd_putchar(vetor[c1]); if(c1==15){//3 for(c2=0;c2<16;c2++){//2 vetor[c2]= uart_getchar (); lcd_gotoxy(c2,1); lcd_putchar(vetor[c2]); if(vetor[c2] == '*') //apaga caracteres do LCD {lcd_clear();//1 c1=16; c2=16; }//1 if(vetor[c2] == '$')//foi clicado voltar {lcd_clear();//4 c1=16; c2=16; x='$'; }//4 }//2 }//3 if(vetor[c1] == '*') //apaga caracteres do LCD {lcd_clear();//4 c1=16; c2=16; }//4 if(vetor[c1] == '$')//foi clicado voltar {lcd_clear();//4 c1=16; c2=16; x='$'; }//4 }//5 }//6 //------------------------------------------------------------------------- //-------------------laço principal----------------------------------------
32
int main(){ while(1) {//1 x='x'; PORTC = 0x00; uart_init(); y= uart_getchar (); switch (y) {//2 //------------------------------------DAC------------------------------ case '1': //aciona dac dac_io(); //habilita portas para o DAC uart_init(); //inicia comunicação serial while(x!='0'){//3 seno='0'; //zera os caracteres de condição para inserir valor do n qua='0'; tri='0'; den='0'; PORTC=0x00; //zera dac x= uart_getchar (); //aguarda sinal da porta serial, x é a forma da onda. //se receber o caracter 0, retorna para main if(x!='0'){ atualiza_onda(); //chama a função para definir forma de onda. } }//3 break; //------------------------------------LEDS------------------------------ case '2': leds_io(); //habilita portas para os leds uart_init(); //inicia comunicação serial while(x!='0') { x= uart_getchar (); if(x!='0'){ atualiza_led(); _delay_ms(50); } else{ PORTC=0x00;} } break; //------------------------------------DISPLAY LCD------------------------------ case '3': lcd_io(); lcd_init(); uart_init();
33
while(x!='$') { if(x!='$'){ atualiza_display(); } else{ lcd_clear(); //PORTC=0x00; } _delay_ms(50); } break; //----------------------------------Sensor Temperatura------------------------------ case '4': i2c_init(); tmp100_init(); uart_init(); // PORTB = 0xF0; // DDRB = 0; int c, f, b3; while (!(UCSRA & (1 << RXC))) //enquando não enviar sinal da serial. { c =(int)(b1*256)+b2; f = ((((long) 180*c)/256)+3200); tmp100_read(); PORTD = 0x20; uart_putchar((b1/100)+'0'); uart_putchar(((b1/10)%10)+'0'); uart_putchar((b1%10)+'0'); uart_putchar(','); b3 = (unsigned int) ((b2*100)/256); uart_putchar((b3/10)+'0'); uart_putchar(((b3)%10)+'0'); uart_putchar('C'); uart_putchar(' '); tmp100_read(); uart_putchar((f/10000)+'0'); uart_putchar(((f/1000)%10)+'0'); uart_putchar(((f/100)%10)+'0'); uart_putchar(','); uart_putchar(((f/10)%10)+'0'); uart_putchar(((f)%10)+'0'); uart_putchar('F'); uart_putchar(' '); uart_putchar(13);
34
_delay_ms(500); } y= uart_getchar (); PORTC = 0x00; }//2 }//1 }
35
Informações estatísticas
Versão da Aplicação: 1.0 de 02/12/2011
Quantidade de memória da aplicação
Formulários: 18.1 MB
Imagens: 788 KB
Aplicações Externas: 2.87MB
Arquivos AVR: 205 KB
Outros arquivos: 837 KB
Quantidade de memória gravada na memória flash:
AVR Memory Usage
----------------
Device: atmega16
Program: 3456 bytes (21.1% Full)
(.text + .data + .bootloader)
Data: 197 bytes (19.2% Full)
(.data + .bss + .noinit)
Total Geral da Aplicação: 22,8 MB