PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ
Engenharia Elétrica Ênfase em Telecomunicações
Microprocessadores e Arquitetura...
2
SUMÁRIO
1. Introdução..................................................................................... 3
1.1 O Proje...
3
1. Introdução
-Soluções em Informática estão cada vez mais abrangendo áreas em Sistemas
eletrônicos, e sistemas controla...
4
depuração. Na execução de instruções em um único ciclo de clock, o dispositivo
atinge a taxa de transferência aproximand...
5
A etapa seguinte foi o desenvolvimento do esquema gráfico da aplicação. Foi
Utilizado uma IDE para facilitar a inserção ...
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
mi...
7
correção de problemas de software que poderia ocorrer no andamento do projeto,
o que por fim facilitaria a procura de er...
8
1. Open: utilizado o comando serialport1.Open() para o método ser chamado,
Abre uma nova conexão de porta serial.
2. Clo...
9
computador e para isso deve-se de configurar a USART com as seguintes
funções:
1. Inicializa componente: define UBRRH, U...
10
Uma IDE pode tornar um trabalho muito mais simples, principalmente se a
linguagem conhecida pelo usuário for a mesma pa...
11
2. Solution Explorer – Este painel relaciona todos os arquivos presentes no
projeto. Para cada parte da aplicação deste...
12
neste projeto tem apenas um arquivo .hex, esta funcionalidade foi utilizada apenas
em um único botão do formulário. A s...
13
2. Abrir diretório com os drivers “USART DRIVER” e “usbasp-windriver”
para instalação caso seja necessário.
Exemplo 5
3...
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....
15
3.4 Funcionalidades
As funcionalidades implementadas nesta aplicação, pode se dividir em quatro
principais: Controle de...
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...
17
temperatura. Em resumo, as labels só serão atualizadas no camando on click do
botão atualizar. A seguir é colocado um e...
18
Entretanto antes de ser enviado o código que representa a freqüência, a aplicação
encaminhou um código para informar ao...
19
retornar ao estado inicial (função principal). A seguir um exemplo da
implementação:
3.6Microcontrolador ATMEGA16
3.6.1...
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 LE...
21
3.6.3 SENSOR DE TEMPERATURA
O sensor de temperatura utilizado possui resolução entre 9 e 12 bits e é capaz de
medir tem...
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 po...
23
4.Conclusão
Ao final do projeto, nota-se que com lógica simples e as ferramentas adequadas,
pode-se conseguir implement...
24
Referências
Suporte técnico Microsoft:
Informações técnicas utilizadas para montagem dos formulários
http://msdn.micros...
25
Apêndices
Código fonte gravado no AVR:
#include <avr/io.h>
#include <util/delay.h>
#include "serial.h"
#include <stdlib...
26
PORTD = 0x00;
DDRD = 0x80;
PORTB = 0xF0;
DDRB = 0x0;
DDRC = 0xFF; // DDRC é saída (LEDS)
PORTC = 0x00; // Saída em níve...
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
}
} //stop...
28
}// fecha do while
}//fecha do senoidal()
void triangular(){
while(tri!= '*'){
tri= uart_getchar ();
if(tri == '0') {tr...
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=...
30
void atualiza_led()
{
switch (x)
{
case 'a': //liga 1
PORTC |= (1<<0);
break;
case 'b': //desliga 1
PORTC &= ~(1<<0);
b...
31
PORTC &= ~(1<<7);
break;
}
}
void atualiza_display()
{//6
for(c1=0;c1<16;c1++) {//5
vetor[c1]= uart_getchar ();
lcd_got...
32
int main(){
while(1)
{//1
x='x';
PORTC = 0x00;
uart_init();
y= uart_getchar ();
switch (y)
{//2
//---------------------...
33
while(x!='$')
{
if(x!='$'){
atualiza_display();
}
else{
lcd_clear();
//PORTC=0x00;
}
_delay_ms(50);
}
break;
//--------...
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...
Próximos SlideShares
Carregando em…5
×

Gerenciador do atmega16

802 visualizações

Publicada em

  • Seja a primeira pessoa a gostar disto

Gerenciador do atmega16

  1. 1. 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. 2. 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. 3. 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. 4. 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.2Objetivo 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. 5. 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. 6. 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. 7. 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. 8. 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. 9. 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. 10. 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. 11. 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. 12. 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. 13. 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. 14. 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. 15. 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. 16. 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. 17. 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. 18. 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. 19. 19 retornar ao estado inicial (função principal). A seguir um exemplo da implementação: 3.6Microcontrolador 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. 20. 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. 21. 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. 22. 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. 23. 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. 24. 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. 25. 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. 26. 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. 27. 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. 28. 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. 29. 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. 30. 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. 31. 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. 32. 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. 33. 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. 34. 34 _delay_ms(500); } y= uart_getchar (); PORTC = 0x00; }//2 }//1 }
  35. 35. 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

×