gerador de funÇÕes microcontrolado com … · 2.4 quantizaÇÃo ... seu uso também esta...
TRANSCRIPT
UNIVERSIDADE POSITIVO
NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS
ENGENHARIA ELÉTRICA
GERADOR DE FUNÇÕES MICROCONTROLADO COM INTERFACE WIRELESS NO COMPUTADOR
Curitiba, 2008.
Felipe Ehlke Anastacio
Marcos Martinez
GERADOR DE FUNÇÕES MICROCONTROLADO COM INTERFACE WIRELESS
NO COMPUTADOR
Trabalho de Conclusão de Curso apresentado ao Curso de Engenharia Elétrica da Universidade Positivo, para obtenção de avaliação parcial da disciplina de Trabalho de Conclusão de Curso (TCC), como requisito à obtenção do grau de Engenheiro Eletricista, sob a orientação do Prof. Mauricio Perreto.
Curitiba, 2008.
AGRADECIMENTOS
Agradecemos aos nossos mestres e colegas de turma por sempre nos incentivarem e nos ajudarem em todas as difi-culdades que tivemos durante a criação e implementação. A Universidade Positivo por sempre nos fornecer os mate-riais e livros necessários para o embasamento teórico e prático para a construção desse projeto. A todos que par-ticiparam de várias formas da continuidade, do aprimo-ramento desse projeto ou que contribuíram para a reali-zação deste trabalho. Ao Prof. Mauricio Perretto, orien-tador e amigo que participou conosco em todos os mo-mentos críticos da criação desse produto.
“Os cientistas estudam o mundo como ele é, os engenhei-ros criam um mundo como ele nunca havia sido.” - Theodore von Karman
RESUMO
O gerador de funções é um instrumento eletrônico desenvolvido para gerar sinais
elétricos, em formas de onda, com variadas freqüências (de Hz até Mhz) e amplitudes. Sua
vasta aplicação no campo da Engenharia Elétrica cria uma necessidade de um maior grau de
liberdade quanto as suas funções (formas de onda) possíveis de serem geradas. Esse projeto
consiste exatamente em possibilitar ao usuário, através de um software, desenhar o sinal que
será fornecido pelo gerador. A comunicação entre PC (personal computer) e o hardware será
através de uma interface sem fio, devido a sua larga utilização na comunicação de instrumen-
tos eletrônicos e praticidade de uso.
Palavras-chave: Gerador de funções, ondas personalizadas, comunicação sem fio.
SUMÁRIO
1 INTRODUÇÃO...............................................................................................................1 1.1 PROBLEMA ..................................................................................................................1 1.2 JUSTIFICATIVA .............................................................................................................1 1.3 OBJETIVOS ESPECÍFICOS..............................................................................................2
1.3.1 Divisão do Trabalho ...............................................................................................2 2 FUNDAMENTAÇÃO TEÓRICA .................................................................................3
2.1 SINAIS BÁSICOS DE UM GERADOR................................................................................3 2.2 SISTEMAS DIGITAIS ....................................................................................................5 2.3 AMOSTRAGEM.............................................................................................................6 2.4 QUANTIZAÇÃO .............................................................................................................7 2.5 COMUNICAÇÃO SEM FIO...............................................................................................8 2.6 MICROCONTROLADOR.................................................................................................9
2.6.1 Arquitetura genérica de microcontrolador............................................................11 3 ESPECIFICAÇÃO TÉCNICA ....................................................................................14
3.1 ESPECIFICAÇÃO GERAL..............................................................................................14 3.2 ESPECIFICAÇÃO FIRMWARE........................................................................................15 3.3 COMUNICADOR SEM FIO............................................................................................17
3.3.1 Modo Transparente...............................................................................................20 3.3.2 Modo API (Application Programming Interface) ................................................21
3.4 ESPECIFICAÇÃO DO HARDWARE...................................................................................21 3.4.1 Memória Interna ...................................................................................................21 3.4.2 Ajustes ..................................................................................................................23 3.4.3 Microcontroladores...............................................................................................23
3.5 SOFTWARE..................................................................................................................24 4 IMPLEMENTAÇÃO....................................................................................................27
4.1 SOFTWARE.................................................................................................................27 4.1.1 Interpolação ..........................................................................................................28 4.1.2 Importação e Exportação de Arquivos .................................................................29
4.2 HARDWARE ...............................................................................................................29 4.2.1 Circuito do Microcontrolador DsPic 30F4011 .....................................................30 4.2.2 Circuito de Ajuste de Amplitude e Offset.............................................................31 4.2.3 Circuito do Módulo XBee ....................................................................................34 4.2.4 Circuito do Display LCD......................................................................................35 4.2.5 Circuito dos Botões ..............................................................................................36 4.2.6 Circuito de Alimentação.......................................................................................36 4.2.7 Montagens em protoboard...................................................................................38 4.2.8 Diagrama Esquemático Completo do Circuito.....................................................39
5 RESULTADOS..............................................................................................................40 5.1 MEMÓRIA EXTERNA ..................................................................................................40 5.2 MEMÓRIA INTERNA ...................................................................................................40 5.3 USO DO PLL (PHASE LOCKED LOOP) ............................................................................41 5.4 VETOR COM OS VALORES DO SOFTWARE....................................................................42 5.5 SALVAR E ABRIR ONDAS ............................................................................................43
5.6 PROTOCOLO DE COMUNICAÇÃO.................................................................................44 5.7 ONDA PROJETADA E RESULTADO FINAL.....................................................................45
6 CONCLUSÕES .............................................................................................................47 6.1 ANÁLISE DOS OBJETIVOS...........................................................................................47 6.2 CONCLUSÕES GERAIS.................................................................................................47 6.3 TRABALHOS FUTUROS................................................................................................48
REFERÊNCIAS .....................................................................................................................49 APÊNDICE A – CÓDIGO DO DSPIC 30F4011 .................................................................50 APÊNDICE B – CÓDIGO DO PIC 16F877A......................................................................52 APÊNDICE C – CÓDIGO DO SOFTWARE .......................................................................55 ANEXO A – MOD_LCD.H ...................................................................................................59 ANEXO B – MANARQUIVO.CPP ......................................................................................61 ANEXO C – CPORTA.H.......................................................................................................62
LISTA DE FIGURAS
Figura 1 – Onda senoidal...........................................................................................................3 Figura 2 – Onda quadrada.........................................................................................................4 Figura 3 – Onda triangular........................................................................................................4 Figura 4 – Quantização..............................................................................................................5 Figura 5 – Exemplo de Aliasing.................................................................................................7 Figura 6 – Nível de quantização................................................................................................8 Figura 7 – Microcontrolador com os seus elementos básicos e ligações internas..................10 Figura 8 – Unidade de entrada/saída que fornece comunicação com o mundo exterior........11 Figura 9 – Arquitetura Harvard...............................................................................................12 Figura 10 – Blocos do Projeto.................................................................................................15 Figura 11 – Fluxograma do Firmware....................................................................................16 Figura 12 – Placa CON-USBBEE...........................................................................................17 Figura 13 – Módulo XBee-Pro™ com placa CON-USBBEE em uso.....................................18 Figura 14 – Módulo XBee-Pro™ XBP24-AWI-001.................................................................18 Figura 15 – Tela do programa X-CTU....................................................................................19 Figura 16 – Frame de dado padrão RS232 (8-N-1).................................................................20 Figura 17 – Estrutura do Frame de dados no modo API.........................................................21 Figura 18 – Espaço de programação para o mapa de memória do Dspic 30F4011..............22 Figura 19 – Interface do software............................................................................................25 Figura 20 – Fluxograma do software......................................................................................25 Figura 21 – Software em uso....................................................................................................26 Figura 22 – Tela Inicial...........................................................................................................27 Figura 23 – Software em uso....................................................................................................28 Figura 24 – Diagrama Esquemático do DsPIC 30F4011........................................................30 Figura 25 – Diagrama Esquemático do PIC 16F877A............................................................31 Figura 26 – Sinal obtido com Conversor Digital para Analógico...........................................32 Figura 27 – Configuração Somador Inversor com ajuste de Offset........................................33 Figura 28 – Sinal obtido com Amplificador Operacional........................................................34 Figura 29 – Diagrama Esquemático do Módulo XBee............................................................35 Figura 30 – Diagrama Esquemático do Display LCD.............................................................35 Figura 31 – Diagrama Esquemático dos Botões.....................................................................36 Figura 32 – Diagrama Esquemático da Alimentação do Circuito ..........................................37 Figura 33 – Montagem do circuito em protoboard..................................................................38 Figura 34 – Diagrama Esquemático Completo.......................................................................39 Figura 35 – Onda com PLL (a) e onda sem PLL (b)...............................................................42 Figura 36 – Relação Ponto X Desenho....................................................................................42 Figura 38 – Onda Desenhada..................................................................................................43 Figura 39 – Onda Aberta a partir do arquivo em .csv.............................................................44 Figura 39 – Protocolo de Comunicação..................................................................................45 Figura 40 – Onda desenhada no software...............................................................................45 Figura 41 – Onda Reproduzida no Hardware.........................................................................46
LISTA DE TABELAS
Tabela 1 – Tabela de Quantização.............................................................................................8 Tabela 2 – Características Risc...............................................................................................13 Tabela 3 – Descrição dos pinos dos módulos XBee/XBee-Pro™............................................19
LISTA DE SÍMBOLOS/ABREVIATURAS/SIGLAS
Hertz (Hz) - Unidade de freqüência. Volts (V) - Unidade de tensão. Km/s - Unidade de Velocidade. M/s - Unidade de Velocidade. PC - Personal Computer. PWM - Pulse Width Modulation (Modulação por Largura de Pulso). CPU - Central Processing Unit (Unidade Central de Processamento). ULA - Unidade Lógica Aritmética. OPCODE - Código de operação. Tx - Transmissor Rx - Receptor DsPIC - Processador Digital de Sinais da Microchip LDO - Low Drop-Out (Regulador de Tensão) LED - Light Emitting Diode (Diodo Emissor de Luz) USB - Universal Serial Bus (Barramento Serial Universal)
1 INTRODUÇÃO
O gerador de funções é um instrumento técnico fundamental na área da Engenha-
ria Elétrica. Ele abrange uma grande variedade de utilização, devido a ser um gerador de três
sinais básicos, que são usados frequentemente. Sendo, o maior exemplo o sinal senoidal, que
é utilizado na rede elétrica aberta. Seu uso também esta intimamente ligado a geração de si-
nais quadrados, sendo sua aplicação na área da eletrônica digital. Outra aplicação é a onda
triangular, sendo usada na resposta de circuitos que necessitem de excitação de sinais lineares.
Junto com os sinais, o gerador possui uma vasta possibilidade de ajustes de controle, para a
forma de onda escolhida, desde a freqüência, amplitude, duty cycle, offset, entre outros.
1.1 PROBLEMA
O gerador, mesmo sendo um instrumento de amplo uso, não permite ao seu usuá-
rio a criação de sinais próprios, para experimentos que possuam aplicações mais específicas,
como a resposta de capacitores e circuitos ressonantes a diferentes tipos de sinais de entrada.
Com a geração de apenas três tipos de sinais, o usuário necessita de tempo para harmonizá-lo
com o circuito ao qual irá testar, para evitar que haja alguma avaria nos componentes. Ou não
se consiga o resultado esperado.
1.2 JUSTIFICATIVA
O projeto tem como objetivo suprir a necessidade de um maior número de sinais.
Para isso, através de uma interface no PC, na qual o usuário gere sinais discretos, através do
uso de um mouse, tenha a possibilidade de selecionar a amplitude das amostras da forma de
onda desejada, marcando os pontos no gráfico por onde ela deva passar e, essa onda seja ge-
2
rada na saída. A comunicação entre PC e hardware é feita por dois módulos de comunicação
sem fio, permitindo que o usuário não necessite mais do computador. Podendo levar o hard-
ware para uma bancada ou para o campo, permitindo assim o início do uso.
1.3 OBJETIVOS ESPECÍFICOS
Uma boa aplicação é na área de ensino didático. No qual com os sinais fornecidos
pode-se ver a reação de diferentes componentes. Assim como criar modulações para esses
sinais, verificar período, continuidade, respostas transitórias e permanentes de sistemas.
Os limites de operação para o gerador são de 20 a 100 KHz nos sinais amostrados
e com uma amplitude de -10 V até +10 V.
A decisão de usar um sistema sem fio deve-se ao fato de que a comunicação wire-
less vem sendo mais comum a todos os equipamentos eletrônicos que necessitam de transmis-
são de dados. Tornando assim o gerador um equipamento possível de comunicação com ou-
tros instrumentos e até mesmo com computadores portáteis.
1.3.1 Divisão do Trabalho
O trabalho apresentado está dividido em capítulos. Primeiramente vem a funda-
mentação teórica, onde é descrito a base do tratamento de sinais, os três tipos de ondas co-
muns, a comunicação sem fio usada e o uso do microcontrolador, além da definição de alguns
possíveis empecilhos nesse projeto como a parte de quantização e aliasing. Logo após há a
especificação técnica. Onde é abordada a idéia geral do projeto, divisão em blocos, especifi-
cação do software e seu fluxograma, assim como especificação do hardware e sua montagem.
3
2 FUNDAMENTAÇÃO TEÓRICA
Neste capitulo é apresentado o embasamento teórico e fundamentos necessários
ao desenvolvimento desse trabalho.
2.1 SINAIS BÁSICOS DE UM GERADOR
O gerador de funções gera três ondas analógicas; senoidal, triangular e retangular.
Um sinal continuo é aquele que possui um número infinito de valores em um determinado
intervalo de tempo. Matematicamente, todo sinal é uma função que toma um valor em Cada
ponto do espaço em que está definida. A amplitude do sinal varia com o seu deslocamento no
tempo. Como exemplo, a tensão disponível na rede elétrica brasileira, varia senoidalmente do
seu mínimo para seu máximo e novamente para seu mínimo sessenta vezes por segundo. Isso
é devido a sua freqüência de 60 Hz, a figura 1 exemplifica o sinal dito.
Figura 1 – Onda senoidal – Fonte própria
Outro modelo de sinal contínuo que é usado frequentemente é o sinal retangular.
Essencialmente usado na eletrônica digital, onde ocorre uma variação brusca e instantânea de
valores, criando assim os sinais “quadrados” como mostra a figura 2.
4
Figura 2 – Onda quadrada – Fonte própria
O terceiro sinal fornecido é o triangular, utilizado em sistemas que necessitam de
variação linear. Ele também é usado para fazer modulações. O sinal é mostrado na figura 3.
Figura 3 – Onda triangular – Fonte própria
A eletrônica analógica com sua enorme quantidade de variáveis, cria uma difícil
precisão na busca de resultados em experimentos. Para contornar isso, utilizamos uma técnica
chamada de conversão digital, onde os sinais são representados através de pulsos finitos, per-
mitindo uma maior exatidão e uma maior alocação de informações em um mesmo espaço de
banda.
5
2.2 SISTEMAS DIGITAIS
Sistemas digitais possuem muitas vantagens sobre os sistemas analógicos. Estes
últimos são circuitos construídos a partir de componentes de hardware, cujas propriedades
podem variar consideravelmente dentro da especificação dos fabricantes. Elas também podem
variar com a temperatura, alterando o comportamento do circuito. Em contra partida, o com-
portamento digital é previsível. Sendo que não é afetado por esses problemas, porque é majo-
ritariamente feito por software. Pelas mesmas razões, os sistemas digitais são bem menos afe-
tados por ruídos que os analógicos, além de consumirem muito menos energia. Os sistemas
digitais são perfeitos para tratamento de sinal por sua exatidão, por isso serão utilizados no
projeto para conferir uma maior precisão na passagem das informações do gráfico para o
hardware pelo módulo wireless.
Um sinal digital é composto por um somatório de impulsos que representam a-
mostras do sinal analógico escolhido para ser digitalizado. Esse processo chama-se quantiza-
ção é o processo de atribuição de valores discretos para um sinal cuja amplitude varia entre
infinitos valores, como apresenta a figura 4. Esse processo é realizado através da amostragem.
(a) (b)
Figura 4 – Quantização – [Roland – 2008]
6
2.3 AMOSTRAGEM
Um sinal analógico, para ser representado de forma digital, necessitaria ser dividi-
do em um número infinito de pontos de informação. O processamento digital de sinais utiliza
um computador, ou um microprocessador. Esses elementos, computadores e microprocessa-
dores, não podem armazenar infinitas informações, sendo necessário o processo de amostra-
gem. A amostragem reduz o número de pontos para um nível aceitável, sem que a forma do
sinal original seja perdido.
A freqüência de amostragem necessária para que se capture um número suficiente
de pontos obedece a Teoria de Amostragem de Nyquist [VAN DE VEGTE – 2002], onde ele
diz que a freqüência de amostragem deve ser no mínimo o dobro da freqüência do sinal a ser
amostrado. Como exemplo, se um sinal que contém uma freqüência de 20 kHz, deve ser a-
mostrado 40.000 vezes por segundo, ou seja, a uma freqüência de 40 kHz. Caso contrário,
com uma freqüência de amostragem muito baixa, há a possibilidade de ocorrer um erro cha-
mado aliasing.
A figura 5 mostra os efeitos de uma baixa amostragem. Nele um sinal de 40 kHz é
usado para amostrar um grupo de sinais, de 10 kHz até 80 kHz. Os pontos de amostragem,
iguais para todos os sinais, são representados em linhas tracejadas verticalmente. De acordo
com a teoria de Nyquist, somente sinais de até 20 kHz poderiam ser amostrados usando uma
taxa de amostragem de 40 kHz. O sinal de 30 kHz, mostrado na terceira janela da figura 4(a),
tende a parecer como 10 kHz devido a insuficiência de pontos. E sinais de freqüências superi-
ores, tendem a parecer freqüências na faixa de 0 Hz a 20 kHz pelo mesmo motivo.
7
(a) (b)
Figura 5 – Exemplo de Aliasing – [VAN DE VEGTE – 2002]
Esse erro é chamado aliasing. A maioria das pessoas pode percebê-lo quando as-
siste a um filme e tem a ilusão das rodas de um carro parecendo estar rodando para trás. Isso é
um resultado direto de que o número de quadros do filme não foram gravados suficientemente
rápidos para capturar a rotação correta das rodas.
Outro detalhe do processamento digital é a quantização.
2.4 QUANTIZAÇÃO
Como já mencionado, sinais analógicos possuem duas características que os tor-
nam inviáveis para o processamento computacional. Primeiro, sinais analógicos são definidos
em todos os pontos do tempo. A amostragem resolve isso reduzindo o número de pontos para
um número finito. Segundo, esses sinais podem ter qualquer amplitude entre seus valores mí-
nimos e máximos físicos. Computadores usam grupo de bits para representar as amplitudes.
Por exemplo, se dois bits são usados, haverá somente quatro valores digitais – 00, 01, 10, 11-
cada um para representar um valor de amplitude. Uma amostra analógica é codificada esco-
lhendo o valor mais próximo de quantização, logo erros sempre existirão quando o número de
bits for finito. Quando N bits são utilizados, 2N valores possíveis podem ser representados
pelo PC. Quanto maior o número de bits, mais próximo o valor digital se torna do analógico,
8
mas em compensação, é maior o tempo para o processamento do sinal. A tabela 1 e a figura 6
mostram exemplos de quantização.
Tabela 1 – Tabela de Quantização – [VAN DE VEGTE – 2002]
CÓDIGO DIGITAL
NÍVEL QUANTIZAÇÃO(V)
ALCANCE DE ENTRADA ANALÓGICAS PARA ESSE CÓDIGO DIGITAL (V)
000 0,0 0,0 ≤ x < 0,275 001 0,375 0,275 ≤ x < 0,5625 010 0,75 0,5625 ≤ x < 0,9375 011 1,125 0,9375 ≤ x < 1,3125 100 1,5 1,3125 ≤ x < 1,6875 101 1,875 1,6875 ≤ x < 2,0625 110 2,25 2,0625 ≤ x < 2,4375 111 2,625 2,4375 ≤ x < 3
Figura 6 – Nível de quantização – [VAN DE VEGTE – 2002]
2.5 COMUNICAÇÃO SEM FIO
Sistemas de comunicação sem fio utilizam dispositivos chamados transmissores
para criar ondas de rádio. Os sinais a serem transmitidos, como voz e dados, são convertidos
em pulsos eletrônicos. Os transmissores modulam os sinais de rádio, a fim de que estes pos-
9
sam carregar os dados e então transmitem os sinais de rádio modulados para áreas distantes.
Os receptores de rádio captam esses sinais, decodificando-os para obter o conteúdo original.
[HAYKIN - 2001], [LATHI - 1998].
A freqüência a ser utilizada na transmissão influência inversamente no alcance e
no comprimento de onda do sinal. Esta relação é apresentada na equação 1.
(1)
onde:
λ = comprimento de onda de uma onda sonora ou onda eletromagnética;
c = velocidade da luz no váculo = 300.000 km/s = 300.000.000 m/s;
f = frequência da onda = Hz.
Para que a transmissão de dados neste sistema tenha êxito é importante que certos
requisitos sejam respeitados. São estes os requisitos:
• Potência de transmissão;
• Mínima distorção na propagação do sinal;
• As condições anteriores devem ser mantidas dentro de parâmetros suficientes para ga-rantir a integridade dos dados transmitidos.
2.6 MICROCONTROLADOR
Pode-se definir um microcontrolador, como o mostrado na figura 7, sendo um pe-
queno componente eletrônico, dotado de uma “inteligência” programável, utilizado no contro-
le de processos lógicos. Esses processos devem ser entendidos como controles de periféricos,
tais como led´s, botões, display´s de 7 segmentos, display´s de cristal líquido (LCD), resistên-
cias, relês, sensores diversos (pressão, temperatura, etc) e muitos outros.
Os controles lógicos são chamados assim, pois suas ações são baseadas no estado
dos periféricos de entrada e saída. A inteligência do componente está associada à Unidade
Lógica Aritmética (ULA), pois é nessa unidade que todas as operações matemáticas e lógicas
10
são executadas. Quanto mais poderosa a ULA do componente, maior a sua capacidade de
processar informações.
Ele é considerado pequeno porque em uma única pastilha de silício, temos todos
os componentes necessários ao controle de um processo, ou seja, o microcontrolador está pro-
vido internamente de memória de programa, memória de dados, porta de entrada, e saída pa-
ralela, timer´s, contadores, comunicação serial, PWM´s, conversores analógicos–digitais, etc.
[RANGEL - 2008]
Figura 7 – Microcontrolador com os seus elementos básicos e ligações internas –
[RANGEL – 2008]
11
2.6.1 Arquitetura genérica de microcontrolador
Todo microcontrolador possui em sua arquitetura as partes descritas a seguir:
Memória de programa - Nesta fica as instruções que um microcontrolador deve
executar, ou seja, as linhas de programação foram digitadas em um PC.
Memória de dados - É a parte do controlador que permite ao programador escre-
ver ou ler um determinado dado sempre que necessário.
ULA - Chamada de Unidade Lógica Aritmética, esta parte do microcontrolador é
responsável por todos os cálculos e a lógica matemática para tomada de decisão das tarefas a
serem realizadas.
I/O’s - São os “braços” dos microcontroladores, mostrado na figura 8. É por eles
que consegue inserir e receber dados dos chips, bem como controlar dispositivos mecânicos e
elétricos. Em outras palavras são os caminhos que fazem a interligação do microcontrolador
com o mundo externo.
Figura 8 – Unidade de entrada/saída que fornece comunicação com o mundo exterior – [RANGEL - 2008]
CPU - Conhecida como Unidade Central de Processamento esta parte do micro-
controlador é responsável por todo processamento de dados da unidade. É ela que interpreta
os comandos e ativa os dispositivos de entrada e saída. [RANGEL - 2008].
12
Unidade de Temporização - Tendo a unidade de comunicação série implementa-
da, pode-se receber, enviar e processar dados. Contudo, para ser capaz de utilizar isto na in-
dústria precisa-se ainda de mais alguns blocos. Um deles é o bloco de temporização que inte-
ressa bastante porque pode dar informações acerca da hora, duração, protocolo, etc. A unidade
básica do temporizador é um contador que é na realidade um registro cujo conteúdo aumenta
de uma unidade num intervalo de tempo fixo, assim, anotando o seu valor durante os instantes
de tempo T1 e T2 e calculando a sua diferença, obtêm-se a quantidade de tempo decorrida.
Esta é uma parte muito importante do microcontrolador, cujo domínio requer muita da aten-
ção.
RISC CPU - Na arquitetura Harvard existem dois barramentos, sendo um de da-
dos e outro de instruções no caso dos microcontroladores PIC, o barramentos de dados é sem-
pre de 8 bits e o de instruções podem ser de 12, 14, 16 bits dependendo do microcontrolador.
Este tipo de arquitetura permite que enquanto uma instrução é executada outra seja buscada
na memória, o que torna o processo mais rápido. Além disso, como o barramento de instru-
ções é maior que 8 bits, o OPCODE (Código de Operação) da instrução já inclui o dado e o
local onde ele vai operar (quando necessário), significa que apenas uma posição de memória é
utilizada por instrução, economizando muita memória de programa. A arquitetura Harvard
também possui um repertório com menos instruções que a de Von-Neumann, e essas são exe-
cutadas apenas num único ciclo de relógio.
Os microcontroladores com arquitetura Havard, são também designados por “mi-
crocontroladores RISC” (Computador com Conjunto Reduzido de Instruções). A tabela 2
mostra a diferença entre Risc e Cisc. A figura 9 mostra as arquiteturas Harvard versus Von
Neumann. [MIKRO - 2008].
Figura 9 – Arquitetura Harvard - [MIKRO - 2008]
13
Tabela 2 – Características Risc – [VEIGA – 2008]
CARACTERISTICAS RISC Risc
Instruções simples levando um ciclo Apenas loads/setores referenciam a memória
Altamente pipeline Instruções executada pelo hardware
Poucas instruções e, mais de end. A complexidade está no compilador Múltiplos conjuntos de registradores
14
3 ESPECIFICAÇÃO TÉCNICA
Este capítulo tem como objetivo descrever as especificações dos componentes que
serão utilizados para o desenvolvimento do projeto.
3.1 ESPECIFICAÇÃO GERAL
Nesta fase pode-se ver o projeto como um todo no diagrama em bloco apresentado
na figura 10. No bloco PC está localizado o software, onde é realizado o desenho da forma de
onda desejada. O hardware não depende do programa para gerar as formas de ondas: senoi-
dal, triangular e quadrada. Caso queira desenhar uma outra forma de onda, ele deverá utilizar
o software para realizar o desenho e a gravação. Após realizar esse procedimento, o usuário
está livre do computador para fornecer a onda na saída.
Quando essa forma de onda é enviada, ela vai para o bloco Tx, onde é realizada a
transmissão wireless. O bloco Rx recebe essa forma de onda, que mandará imediatamente
para o bloco Microcontrolador. Esse bloco faz o armazenamento da onda dentro de sua pró-
pria memória EEPROM. Para se realizar a geração de algum dos quatro sinais, é feito a sele-
ção através do bloco Botões. Nesse bloco é escolhida a forma de onda e é feito o ajuste da
freqüência. Após definir esses dois parâmetros, o Microcontrolador busca em sua memória os
dados referentes a onda que é enviada para o bloco D/A, onde é feita a conversão do sinal
digital para o analógico. Em seguida, o sinal irá para o bloco Ajustes onde é feito os ajustes de
amplitude e offset.
15
Figura 10 – Blocos do Projeto – Fonte própria
Com esse gerador de funções, será possível obter sinais com uma freqüência de 20
à 100 kHz e uma amplitude variando de no mínimo -10V até o máximo de +10V. Podendo ser
realizado qualquer ajuste dentro desses intervalos.
3.2 ESPECIFICAÇÃO FIRMWARE
A figura 11 mostra o fluxograma do Firmware. No início é feito a seleção da for-
ma de onda desejada. Caso a onda senoidal seja selecionada, ele irá gerar essa onda, indo para
o ajuste da freqüência, ocorrendo o mesmo para a onda triangular e quadrada. Caso deseje
receber uma nova onda proveniente do software, será habilitado o receptor fazendo seu arma-
zenamento na memória através do microcontrolador. Caso a onda aleatória seja selecionada,
ele irá gerar a última forma de onda gravada, indo para o ajuste da freqüência. Se nenhuma
forma de onda foi selecionada, o hardware não irá gerar sinal, retornando para seu menu ini-
cial.
16
Figura 11 – Fluxograma do Firmware – Fonte própria
17
3.3 COMUNICADOR SEM FIO
A comunicação é feita por dois módulos de comunicação sem fio, um deles insta-
lado no hardware e o outro conectado ao PC através de um emulador de portas USB/Serial,
chamado CON-USBBEE. [MESSIAS – 2008]
A placa CON-USBBEE, mostrada na figura 12, usa um chip conversor
USB/Serial; regulador de tensão LDO (baixa queda de tensão), comparador de tensão conec-
tado aos LEDs (RSSI) que simulam a força do sinal de radio freqüência; LEDs indicadores de
TX, RX, módulo ligado (ASS), e um microbotão para “resetar” o módulo de comunicação.
Figura 12 – Placa CON-USBBEE – [MESSIAS - 2008]
Ao instalar no computador o driver USB que acompanha a placa, é criada no Win-
dows uma porta COMx virtual quando a placa CON-USBBEE é ‘plugada’. Assim, é possível
através de um programa, no caso o C/C++Builder, se comunicar com a placa como se fosse
uma comunicação serial padrão RS232. A figura 13 mostra o módulo em uso em um laptop.
18
Figura 13 – Módulo XBee-Pro™ com placa CON-USBBEE em uso – [MESSIAS
- 2008]
A comunicação entre o software e o hardware será realizada pelo sistema wire-
less. O módulo aqui utilizado é o XBee-Pro™ XBP24-AWI-001 (antena fio) da ZigBee/IEEE
802.15.4, mostrado na figura 14. É através dele que o hardware será gravado com a nova
forma de onda desenhada pelo usuário através do software.
Figura 14 – Módulo XBee-Pro™ XBP24-AWI-001 – [MESSIAS - 2008]
Na tabela 3 está descrito o significado de cada pino dos módulos XBee-Pro™,
como podemos ver, há pinos que podem exercer diferentes funções como, entrada analógica,
entrada/saída digital, controle de fluxo e PWM. A maneira mais fácil para configurar a função
de um determinado pino do módulo ou mesmo outros parâmetros, é através do programa X-
CTU, representado na figura 15.
19
Tabela 3 – Descrição dos pinos dos módulos XBee/XBee-Pro™ - [MESSIAS - 2008]
Pino # Nome Direção Descrição 1 VCC - Alimentação 3,3v 2 DOUT Saída Saída de dados da UART 3 DIN / CONFIG Entrada Entrada de dados da UART 4 DO8* Saída Saída digital 8 5 RESET Entrada Inicializa módulo (um pulso nível 0 de pelo menos 200ms) 6 PWM0 / RSSI Saída Saída do PWM 0 / Indicador de Força do sinal de RF (RX) 7 PWM1 Saída Saída do PWM 1 8 (Reservado) - Ainda não tem uma função definida (futura implementação) 9 DRT/ SLEEP_IRQ / DI8 Entrada Linha de Controle da Função Sleep ou Entrada digital 8 10 GND - Terra 11 AD4 / DIO4 Entrada/Saída Só Entrada Analógica 4 ou Entrada/Saída Digital 4 12 CTS/ DIO7 Entrada/Saída Controle de Fluxo CTS ou Entrada/Saída Digital 7 13 ON / SLEEP Saída Indicador de Estado do Módulo 14 VREF Entrada Tensão de Referência para as Entradas A/D
15 Associação / AD5 /
DIO5 Entrada/Saída
Indicador de Associação, só Entrada Analógica 5 ou Entra-da/Saída Digital 5
16 RTS/ AD6 / DIO6 Entrada/Saída Controle de Fluxo RTS, só Entrada Analógica 6 ou
Entrada/Saída Digital 6 17 AD3 / DIO3 Entrada/Saída Só Entrada Analógica 3 ou Entrada/Saída Digital 3 18 AD2 / DIO2 Entrada/Saída Só Entrada Analógica 2 ou Entrada/Saída Digital 2 19 AD1 / DIO1 Entrada/Saída Só Entrada Analógica 1 ou Entrada/Saída Digital 1 20 AD0 /DIO0 Entrada/Saída Só Entrada Analógica 0 ou Entrada/Saída Digital 0
Figura 15 – Tela do programa X-CTU – [MAXSTREAM - 2008]
20
Basicamente os módulos XBee-Pro já vêm de fábrica configurados para serem u-
sados diretamente, o mínimo que precisamos fazer para estabelecer um link de comunicação é
alimentar os módulos corretamente com uma tensão de 3,3V.
A comunicação entre os módulos pode ser realizada de dois modos diferentes:
Modo Transparente e Modo API.
3.3.1 Modo Transparente
Os dados recebidos da UART pelo pino DI(RX) são colocados na fila para trans-
missão via RF. Já os dados recebidos do canal de RF, são transmitidos através do pino
DO(TX).
No modo transparente os dados são transmitidos e recebidos da mesma forma que
uma comunicação Serial RS232 padrão, como mostra a figura 16. Os módulos dispõem de
buffers de transmissão e recepção para um melhor desempenho na comunicação serial.
Figura 16 – Frame de dado padrão RS232 (8-N-1) – [MESSIAS - 2008]
21
3.3.2 Modo API (Application Programming Interface)
Esse modo de operação é uma alternativa ao modo de operação Transparente pa-
drão. O modo API é baseado em frame e assim estende o nível para o qual uma aplicação de
Host pode interagir com as capacidades de rede do módulo, mostrado na figura 17.
No modo API os dados transmitidos e recebidos estão contidos em frames, que de-
finem operações ou eventos dentro do módulo. Através desse modo de operação é possível
um determinado módulo enviar endereço fonte, endereço destino, nome de um determinado
nó, sinal RSSI, estado, e muito mais. [MESSIAS - 2008]
Figura 17 – Estrutura do Frame de dados no modo API - [MESSIAS - 2008]
3.4 ESPECIFICAÇÃO DO HARDWARE
Este capítulo tem como objetivo descrever os dispositivos utilizados na composi-
ção do hardware.
3.4.1 Memória Interna
O Dspic 30F4011 possui uma memória interna de 1 Kbytes, seu endereçamento é
localizado no datasheet do componente. Como mostra a figura 18.
22
.
Figura 18 – Espaço de programação para o mapa de memória do Dspic 30F4011 – Fonte Própria.
Como mostrado na figura 18, o primeiro endereço da memória EEPROM interna
começa em 7FFC00 e vai até 7FFFFE. Como o número de ondas a serem gravadas são quatro
e cada uma possui 128 (bytes), chega-se a um total de 512 posições de memória para todas as
ondas. O endereçamento é feito em hexadecimal, logo o uso dos endereços irá de 7FFC00 até
7FFE00, sendo que as 384 primeiras posições são fixas contendo os valores das ondas senói-
de, triangular e quadrada. O único trecho que é variado é da onda aleatória, que receberá os
valores do módulo.
23
3.4.2 Ajustes
No bloco Ajustes, são realizados dois ajustes: offset e amplitude. O primeiro será
feito com o auxílio de um amplificador operacional, o LM318. Será feito a configuração do
somador inversor, onde será somada uma tensão negativa na entrada do amplificador opera-
cional, sendo ajustado o seu valor de tensão através de um potenciômetro, realizando assim o
ajuste de offset. O ajuste de amplitude será feito através de um potenciômetro no resistor de
ganho do amplificador. Sendo o sinal novamente enviado a um amplificador com a configura-
ção inversor para desinverter o sinal à sua posição de origem.
3.4.3 Microcontroladores
Os microcontroladores terão um papel fundamental no projeto, será utilizado um
DsPIC 30F4011 e um PIC 16F877A.
O primeiro é utilizado por causa da alta velocidade de trabalho. Ele é a ponte de
ligação entre o software e a saída do hardware, responsável por receber os dados da comuni-
cação sem fio. Uma de suas saídas será conectada diretamente em um pino de ativação do
módulo, fazendo com que o módulo receptivo seja habilitado para receber dados da transmis-
são. Enviando-os a sua memória e através de seus botões será feita a seleção das ondas através
da leitura e rápida repetição dos valores dos dados dando assim a impressão de ser criada uma
onda continua no tempo e sendo repetida infinitamente. Além da seleção da onda a ser usada,
seu maior papel o ajuste da freqüência a ser gerada na saída.
Já o segundo tem como função controlar a exibição dos textos do LCD e o valor
da freqüência.
24
3.5 SOFTWARE
O software terá uma interface bastante simples para o usuário. Um menu de op-
ções como salvar, abrir arquivos, ajuda, nova tela e outra opções será fornecido para dar me-
nos trabalho na hora de iniciar uma nova geração de onda, sendo que a opção de salvar a onda
criada gerará um arquivo em formato Excel para simplificar o entendimento de como funcio-
na a criação dos dados a partir da onda desenhada.
Ao abrir o programa, o usuário ficará de frente com uma interface que possui um
gráfico [STEEMA - 2000], dois botões, duas editbox e uma listbox, onde o primeiro terá seus
dois eixos variando de 0 a 127 valores cada um, mostrado na figura 19. Após desenhar as re-
tas que formarão as ondas com cliques de mouse, a qual deverá obrigatoriamente começar no
valor (0;0), o usuário deverá clicar no botão “compila” para que seja feita uma verificação de
obediência das condições pré estabelecidas adiante para se montar a onda. Após a compilação,
o botão “enviar” se tornará disponível para ser selecionado, começando assim o enlace de
transmissão entre o PC e o hardware, caso contrário uma mensagem irá aparecer na tela di-
zendo que a forma de onda não é aceitável, mostrado no fluxograma da figura 20. A listbox
terá como função marcar os pontos e valores clicados no gráfico para conhecimento do usuá-
rio e também para registro na hora do envio das informações para o hardware. Outra possível
demarcação de pontos no gráfico é numericamente, através das duas editbox que possibilitam
uma maior precisão na escolha dos pontos, já que isso acontece através de valores exatos lá
digitados.
25
Figura 19 – Interface do software – Fonte Própria
Figura 20 – Fluxograma do software – Fonte Própria
26
Após a onda ser desenhada como na figura 21 e o botão de “Compilar” pressiona-
do, o programa irá fazer uma varredura no desenho, procurando por erros no desenho e procu-
rando ver se as condições necessárias para enviar a onda foram seguidas, como:
- O início da onda deve ser obrigatoriamente no ponto (0;0) do gráfico e o fim o-
brigatoriamente no ponto (127;0).
- A onda deve ser continua durante todo o trajeto.
- Não deve haver mais de um valor em Y para cada valor em X.
Figura 21 – Software em uso – Fonte Própria
O programa dividirá o eixo das abscissas em 127 pontos de informação, onde cada
um desses pontos terá 7 bits de possíveis valores que será representado pelo eixo das ordena-
das. Após isso o programa salvará apenas os pontos aonde há informação, ou seja, aonde a
linha do gráfico foi encontrada. Enviando essas informações para o módulo sem fio para co-
meçar a transmissão.
27
4 IMPLEMENTAÇÃO
Neste capítulo, será descrita a implementação do projeto, incluindo montagens,
diagramas esquemáticos, software, testes.
4.1 SOFTWARE
Na tela inicial do form foi inserido o elemento do gráfico, o TChart, ele é o prin-
cipal componente do programa. Para ajustar os pontos do gráfico para estarem sincronizados
com a posição do mouse é necessário fazer um cálculo interno já que as posições (X;Y) do
gráfico não são os mesmos valores de posições existentes nas coordenadas do form. Após isso
deve-se implementar os comandos que vão garantir que o desenho no gráfico começe em
(0;0) e terminar em (127;0), para possibilitar a continuidade do período da onda desenhada.
Através de uma ListBox são armazenados os valores das posições selecionadas com o mouse
para o cálculo da interpolação das retas intermediárias. Para uma melhor precisão no desenho,
é possível a inserção numérica de valores no gráfico através de duas EditBox representando os
valores X e Y do ponto desejado. Por fim, um menu localizado no canto esquerdo superior
possibilita a gravação dos pontos selecionados em um arquivo “.csv” e a importação do arqui-
vo já gerado. A tela principal do software é apresentada na figura 22.
Figura 22 – Tela Inicial – Fonte Própria
28
4.1.1 Interpolação
Uma das necessidades do projeto é de uma interpolação linear no gráfico, já que
após o desenho do sinal apenas os pontos selecionados tiveram suas coordenadas marcadas,
sendo necessário o cálculo dos outros pontos, intermediários as retas desenvolvidas, como
mostra a figura 23.
Figura 23 – Software em uso – Fonte Própria
Após a escolha de todos os pontos da forma de onda, o botão “Compilar” fará a
captura dos pontos registrados no ListBox e com eles calculará a interpolação dos valores dos
pontos intermediários. Após esse cálculo, o botão “Enviar” será habilitado e quando pressio-
nado criará um vetor com os valores das amplitudes de cada ponto em sua devida posição
entre os 128 pontos e começará a transmissão.
A onda criada no gráfico nada mais é do que vários trechos de retas que juntas
formam o desenho desejado. A interpolação necessita do ponto inicial e final para que for-
mem as retas a serem conferidas para calcular os outros pontos. Através dos dois pontos de
cada reta e da equação básica de uma reta (y = ax + b) [SWOKOWSKI - 1994] é possível
29
conferir valores a a e b. Com a substituição de x por seus 127 valores, surgem seus iguais
para y.
As equações abaixo mostram os pontos (x2;y2) e (x1;y1). Subtraindo a equação (2)
da equação (1), temos o cancelamento da variável b (3), com isso pode-se isolar a e descobrir
seu valor. Substituindo depois na equação original é possível achar o valor de b, completando
assim a equação.
4.1.2 Importação e Exportação de Arquivos
Um recurso do programa é salvar os dados da onda desenhada em arquivo .CSV
(comma-separated values). Os valores ficam salvos em duas colunas, cada uma representando
um eixo de coordenadas. Quando o usuário quiser reproduzir uma onda já criada, basta abrir o
arquivo já salvo.
4.2 HARDWARE
Neste item, serão tratadas as implementações que contemplam o hardware do sis-
tema.
bxay += 22 .
).(.
1212
11
xxayy
bxay
−=−+=
)1()2(
)3(
30
4.2.1 Circuito do Microcontrolador DsPic 30F4011
Um dos microcontroladores utilizado é o DsPIC 30F4011, devido sua velocidade
de processamento. A figura 24 mostra uma configuração básica para o respectivo componen-
te.
Figura 24 – Diagrama Esquemático do DsPIC 30F4011 – Fonte Própria
31
O outro PIC utilizado é o 16F877A, utilizado na configuração do LCD, mostrado
na figura 25.
Figura 25 – Diagrama Esquemático do PIC 16F877A – Fonte Própria
4.2.2 Circuito de Ajuste de Amplitude e Offset
Os dados referentes ao sinal da onda selecionada sairão do DsPIC em 7 bits, sen-
do enviados para um conversor digital/analógico. A configuração do conversor foi montada e
nela realizado alguns testes. Com a utilização desse dispositivo o sinal é obtido na saída com
distorções como mostra a figura 26.
32
Figura 26 – Sinal obtido com Conversor Digital para Analógico – Fonte Própria
Devido a estas distorções, foram realizados testes utilizando um amplificador ope-
racional, configurando como somador inversor, como mostra a figura 27.
Nesta configuração é realizado o ajuste de offset através do potenciômetro R19,
onde há um divisor resistivo na entrada não inversora do amplificador operacional. Variando
o valor dessa resistência, varia o valor da tensão de entrada no amplificador, realizando desta
forma o ajuste de offset. O ajuste de amplitude é realizado diretamente no resistor de ganho do
amplificador (R18). O sinal invertido sai do primeiro amplificador operacional sendo inverti-
do novamente no segundo.
33
Figura 27 – Configuração Somador Inversor com ajuste de Offset – Fonte Própria
34
Após a realização de testes com esta configuração somador inversor [PERTENCE
- 1996], foi obtido um sinal livre das distorções apresentadas com a utilização do conversor de
digital para analógico. A figura 28 mostra o sinal obtido com o somador inversor.
Figura 28 – Sinal obtido com Amplificador Operacional – Fonte Própria
4.2.3 Circuito do Módulo XBee
O módulo XBEE é responsável pela comunicação entre o software e o hardware,
o diagrama esquemático dele é apresentado na figura 29. O pino 2 representado por f2 é o
transmissor e o pino 3 onde é feito um divisor resistivo porque o DsPIC opera em 5V, en-
quanto o módulo opera em 3,3V, representado por f3 é o receptor do módulo.
35
Figura 29 – Diagrama Esquemático do Módulo XBee – Fonte Própria
4.2.4 Circuito do Display LCD
O display LCD é usado para mostrar a interface do hardware para o usuário e exi-
bir o valor da freqüência. A figura 30 mostra o diagrama esquemático do display de LCD.
Nos pino 1 e 2 é feita a alimentação. No pino 3 há um trimpot para fazer o ajuste do contraste.
Os pinos 6, 8, 13, 14, 15 e 16 são conectados ao PIC 16F877A, sendo pinos de controle e da-
dos.
Figura 30 – Diagrama Esquemático do Display LCD – Fonte Própria
36
4.2.5 Circuito dos Botões
A seleção da forma de onda é feita através de botões. O diagrama esquemático é
apresentado na figura 31. Para os botões é usado o port D e port C do DsPIC e também é usa-
do o port A do PIC 16F877A.
Figura 31 – Diagrama Esquemático dos Botões – Fonte Própria
4.2.6 Circuito de Alimentação
A alimentação do circuito é feita através de um transformador com saída 15 +
15V de 500mA. As saídas do transformador são ligadas em uma ponte retificadora e conecta-
da em 2 reguladores de tensão. Um é o LM7812 que irá regular a tensão para +12V e o outro
é o LM7912 que irá regular a tensão para -12V. Essa alimentação é usada pelo amplificador
operacional. Na saída do regulador LM7812 é ligado um LM7805 para regular a tensão para
5V para alimentar o DsPIC, Display LCD. Na saída do regulador LM7805 é ligado o LM7833
37
que regula a tensão para 3,3V para alimentar o Módulo XBee. O diagrama esquemático da
alimentação é mostrado na figura 32.
Figura 32 – Diagrama Esquemático da Alimentação do Circuito – Fonte Própria
38
4.2.7 Montagens em protoboard
Os circuitos foram implementados em estágios, testados e ensaiados individual-
mente, em seguida foram montados no protoboard. Na figura 33, está a montagem completa.
Figura 33 – Montagem do circuito em protoboard – Fonte Própria
39
4.2.8 Diagrama Esquemático Completo do Circuito
Na figura 34 está o esquemático completo do circuito, contendo todos os estágios
utilizados no hardware.
Figura 34 – Diagrama Esquemático Completo – Fonte Própria
40
5 RESULTADOS
Este capítulo tem como objetivo descrever os resultados obtidos através dos testes
realizados durante a produção deste projeto:
- Uso de memória externa.
- Uso de memória interna.
- Uso de PLL (Phase Locked Loop)
- Teste dos valores de compilação
- Abertura e fechamento de arquivos de ondas
- Protocolo de comunicação
- Onda projetado
- Resultado final
5.1 MEMÓRIA EXTERNA
Iniciamente, durante a elaboração do projeto foi considerada a idéia de ter uma
memória externa modelo 24LC256, para armazenar os valores das ondas. Mas devido a alta
velocidade do DsPic e a baixa velocidade de resposta do componente de memória, não estava
sendo possivel fazer o armazenamento, pois os valores que chegavam pelo módulo eram mui-
to rapidamente enviados para a memória sem ela ter tempo de salvá-los. Devido a esse motivo
foi utilizada a memória EEPROM interna ao 30F4011, já que sua capacidade era suficiente
pra armazenar as quatros ondas e ao mesmo tempo possuia uma resposta rapida tanto para
gravação quanto para leitura.
5.2 MEMÓRIA INTERNA
O DsPIC 30F4011 possui uma memória interna de 1 Kbytes, seu endereçamento é
localizado no datasheet do componente.
41
O primeiro endereço da memória EEPROM interna começa em 7FFC00 e vai até
7FFFFE. Como o número de ondas a serem gravadas são quatro e cada uma possui cento e
vinte e oito valores (bytes). Chega-se a um total de quinhentos e doze posições de memória
para todas as ondas. O endereçamento é feito em hexadecimal, logo o uso dos endereços irá
de 7FFC00 até 7FFE00, sendo que as trezentas e oitenta e quatro primeiras posições são fixas
contendo os valores das ondas senóide, triangular e quadrada. O único trecho que é variado é
da onda aleatória, que receberá os valores do módulo.
5.3 USO DO PLL (PHASE LOCKED LOOP)
Devido ao uso de várias instruções dentro do microcontrolador, houve uma queda
significativa de freqüência para próximo de 20 kHz. O objetivo de utilizar o PLL para um
alcance maior de freqüência não foi alcançado, já que se manteve constante tanto com seu uso
quanto sem, o que não possibilitou o alcance de 100 kHz. Sendo o único responsável pela
freqüência o crystal de 20 MHz.
Acredita-se que sua disfunção tenha ocorrido devido a estruturação interna do Ds-
PIC 30F4011, ou seja, os blocos dos timers não são interligados ao bloco do PLL, surtindo
nenhum efeito na freqüência. A figura 35 mostra uma comparação de um mesmo tipo de onda
com o PLL ativado e sem ele. Nota-se que nada foi alterado.
42
(a) (b)
Figura 35 – Onda com PLL (a) e onda sem PLL (b) – Fonte Própria
5.4 VETOR COM OS VALORES DO SOFTWARE
Toda a lógica usada dentro do software serve a para um único propósito, a criação
de um vetor final com os 128 valores digitais para serem reproduzidos no hardware. Com uma
lógica de posicionamento dos valores e outra de interpolação, é possível ver na listbox ao
pressionar o botão ‘compila’ que os valores são automaticamente gerados e já assumem sua
posição no vetor em relação a sua posição no gráfico como mostra a figura 36.
Figura 36 – Relação Ponto X Desenho – Fonte Própria
43
5.5 SALVAR E ABRIR ONDAS
No momento em que é solicitado no programa para salvar a onda desenhada em
um arquivo .csv através do comando ‘salvar como’. Os valores que se encontram na listbox
são automaticamente enviados para uma tabela formada por duas colunas e 128 linhas, onde a
primeira coluna indica a posição do ponto e a segunda coluna indica o valor do ponto. Ao se
recuperar a onda no software através do comando ‘abrir’, o processo inverso é feito, os valo-
res são enviados ao listbox e a partir de lá são recriados no gráfico. Devido a serem valores
lidos, ao ser recriada, a onda pode sofrer um pequeno erro de quantização, pois quando foi
desenhada seus valores no trabalho de interpolação foram criados como inteiros, havendo um
arredondamento dos valores reais do gráfico. Um exemplo esta sendo mostrado nas figuras 39
(onda desenhada) e 40 (onda aberta a partir do arquivo salvo).
Figura 37 – Onda Desenhada – Fonte Própria
44
Figura 38 – Onda Aberta a partir do arquivo em .csv – Fonte Própria
Esse erro de quantização é amortecido pelo próprio hardware, através da passa-
gem de digital para analógico no final do processamento dos valores.
5.6 PROTOCOLO DE COMUNICAÇÃO
Com o uso do osciloscópio, é possível ver a transmissão dos dados de handshake
que garantem o sincronismo e o encaminhamento dos dados. Eles obedecem a seguinte ins-
trução, mostrada na figura 39.
45
Figura 39 – Protocolo de Comunicação – Fonte Própria
5.7 ONDA PROJETADA E RESULTADO FINAL
Após a conclusão do tratamento do sinal, pode-se comparar a forma desenhada no
software com a forma na saída do hardware. As figuras 40 e 41 mostram o resultado.
Figura 40 – Onda desenhada no software – Fonte Própria
46
Figura 41 – Onda Reproduzida no Hardware – Fonte Própria
47
6 CONCLUSÕES
Aqui são discutidos os resultados obtidos durante todas as fases do projeto. Desde
as variáveis controladas até aquelas que podem ter uma influência externa no trabalho. Tam-
bém serão comentados os benefícios do projeto em relação aos objetivos especificados em seu
inicio.
6.1 ANÁLISE DOS OBJETIVOS
O principal objetivo de construir ondas com formas variadas de uma maneira fácil
e simples foi alcançado com os valores de amplitude variando de -10V até +10V e com um
ajuste de offset. A comunicação sem fio funcionou perfeitamente dentro dos parâmetros dos
componentes.
O objetivo de alcançar a freqüência máxima de 100kHz é atingindo apenas quan-
do os timers são desativados, mas como sendo eles de uso essencial no projeto, a freqüência
máxima ficou limitada ao crystal de 20 MHz utilizado, já que o PLL não faz efeito sobre os
timers.
6.2 CONCLUSÕES GERAIS
Com esse projeto, há uma facilidade quanto ao uso de sinais elétricos para diver-
sos meios e áreas, como computação, sonorização, construção de circuitos e outros. Ele é uma
forma inovadora de tratar sinais elétricos digitalmente, pois com ele pode-se economizar uma
boa parte de hardware, tudo é tratado com programação, desde o reconhecimento dos pontos
no gráfico até o envio para o hardware. Esse projeto tende incrementar a evolução de equipa-
mentos de testes eletrônicos, que possuem reguladores analógicos para aferição dos sinais.
48
Esse projeto mostra como qualquer sinal analógico pode ser tratado digitalmente e
suas vantagens na hora do processamento e tratamento digitais. Com essa tecnologia pode-se
criar novos equipamentos que simplificarão ainda mais a vida de engenheiros de produção e
desenvolvedores.
6.3 TRABALHOS FUTUROS
Com esse projeto é possível seguir vários caminhos de desenvolvimento, foi pen-
sando nisso que foi utilizada a comunicação sem fio, permitindo assim uma maior compatibi-
lidade. Outra evolução seria na utilização de microcontroladores mais eficientes e rápidos a
medida que forem sendo desenvolvidos no mercado, permitindo assim uma maior freqüência
e exatidão já que será possível um maior número de bits na hora de amostrar os pontos. Outra
evolução seria outras interpolações além da linear usada neste projeto, permitindo assim on-
das mais variadas.
49
REFERÊNCIAS
VAN DE VEGTE, Joyce. Fundamentals of digital signal processing. Upper Saddle River, NJ: Prentice Hall, 2002. ROLAND, M. Zurmely. Quantização e Codificação. PY4ZBZ, Sete Lagoas, Minas Gerais, Abril 2008. Disponível em <http://paginas.terra.com.br/lazer/py4zbz/teoria/quantiz.htm>. Acesso em: 25 maio 2008. HAYKIN, Simon S. Communication systems . 4th. New York: J. Wiley & Sons, 2001. LATHI, B. P. (Bhagwandas Pannalal). Modern digital and analog communication systems. 3rd ed. -. New York: Oxford University Press, 1998. PERTENCE JUNIOR, Antonio. Amplificadores operacionais e filtros ativos : teoria, proje-tos, aplicações e laboratorio. 5.. ed. São Paulo: MAKRON, 1996. MESSIAS, Antonio Rogério. Controle remoto e aquisição de dados via XBee/ZigBee. Dis-ponível em: <http://www.rogercom.com >. Acesso em: 22 maio. 2008. RANGEL, Arthur. TCC. História dos microprocessadores, São Paulo .Disponível em: <http://www.dca.fee.unicamp.br/~rangel/tcc/tcc-2_corrigido.doc>. Acesso em: 21 de maio de 2008. MIKRO, Elektronika. Introdução aos Microcontroladores. Disponível em: < http://www.mikroe.com/pt/product/books/picbook/capitulo1.htm >. Acesso em: 15 de maio de 2008. MAXSTREAM, Data Radio Modems and Radio Modules. Disponível em: <http://www.maxstream.net/>. Acesso em: 3 de maio de 2008. VEIGA, Sérgio Luis. Microprocessadores e Microcontroladores. Introdução aos Microcon-troladores, Curitiba. Disponível em: < http://www.up.edu.br/ >. Acesso em: 5 de maio de 2008. STEEMA. Getting Started With TeeChart Pro VCL. EUA, 2000. Disponível em: <http://www.steema.com/products/teechart/getting_started_with_teechart_pr.htm>. Acesso em: 10 de abril de 2008.
50
APÊNDICE A – CÓDIGO DO DSPIC 30F4011
#include <30F4011.h> #fuses HS,NOWDT,NOPROTECT,NOBROWNOUT,NOMCLR #use delay(clock=160M,crystal=10M) #use rs232(BAUD=19200, XMIT=PIN_F5,RCV=PIN_F4,BITS=8,UART2) #include <input.c> #include <i2c.c> #define TAM 128 int8 x=0; int i=0; int tabela1[]= {127,127,127,126,125,123,120,117,113,109,105,100,94,88,83,76,70,64,58,52,45,40,34,28,23,19,15,11,8,5,3,1,0,0,0,1,3,5,8,11,15,19,23,28,34,40,45,52,58,64,70,76,83,88,94,100,105,109,113,117,120, 123,125,126}; int tabela2[]= {0,4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64,68,72,76,80,84,88,92,96,100,104,108,112,116,120,124,127,124,120,116,112,108,104,100,96,92,88,84,80,76,72,68,64,60,56,52,48,44,40,36,32,28,24,20,16,12,8,4,0}; int tabela3[]= {127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0}; int tabela4[128]; int8 estado, cont; int8 valores[TAM]; int t=0; int8 onda = 0; void lerSerial() { char lido; lido = getc(); if(estado == 0 && lido==0x55) { putc(0xAA); estado = 1; } else if(estado == 1 && lido==0xAA) { putc(0xAA); // com->EnviaDado(&val,1); estado = 2; cont = 0; } else if(estado == 2) { valores[cont] = lido; cont++; if(cont==TAM) { estado = 3; }
51
} else if(estado == 3 && lido==0xAA) { putc(0xAA); estado = 0; for(t=0;t<128;t++) { tabela4[t] = valores[t]; } } } void main() { estado = 0; while(true) { if(kbhit()) { lerSerial(); } if(!input(pin_d1)) onda = 1; if(!input(pin_d2)) onda = 2; if(!input(pin_d3)) onda = 3; if(!input(pin_d0)) onda = 4; if(onda==1) { for(i=0;i<128;i++) { output_b(tabela4[i]); delay_us(x); } } if(onda==4) { for(i=0;i<64;i++) { output_b(tabela1[i]); delay_us(x); } } if(onda==3) { for(i=0;i<64;i++) { output_b(tabela2[i]); delay_us(x); } } if(onda==2) { for(i=0;i<64;i++) { output_b(tabela3[i]); delay_us(x);
52
} } if(!input(pin_c13)) { delay_ms(1000); x=x+1; } if(!input(pin_c14)) { delay_ms(1000); x=x-1; } if(x<0) x=0; if(x>16 && !input(pin_c13)) { delay_ms(1000); x=x+1000; } if(x>16 && !input(pin_c14)) { delay_ms(1000); x=x-1000; } } }
APÊNDICE B – CÓDIGO DO PIC 16F877A
#include <16f877A.h> #fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT #use delay(clock=20M) #include <mod_lcd.c> #org 0x1F00, 0x1FFF void loader16F877(void) {} int i; void Tela1(); void Tela2(); void Tela3(); #int_timer1 void tempo() {
set_timer1(0); i++;
} void main() {
lcd_ini(); Tela1(); delay_ms(3000);
53
Tela2(); Tela3(); lcd_escreve("\f"); setup_timer_1 ( T1_EXTERNAL | T1_DIV_BY_1 ); enable_interrupts(GLOBAL); enable_interrupts(int_timer1); for(;;)
{ if (!input(pin_a1)) { while(input(pin_a2)&&input(pin_a3)&&input(pin_a4)) { float f; set_timer1(0); i=0; delay_ms(2000); f=((i * 65536) + get_timer1())/2; lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("Onda Senoidal "); lcd_pos_xy(1,2); printf(lcd_escreve,"F: %f Hz ",f); } } if (!input(pin_a2)) { while(input(pin_a1)&&input(pin_a3)&&input(pin_a4)) { float f; set_timer1(0); i=0; delay_ms(2000); f=((i * 65536) + get_timer1())/2; lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("Onda Triangular "); lcd_pos_xy(1,2); printf(lcd_escreve,"F: %f Hz ",f); } } if (!input(pin_a3)) { while(input(pin_a1)&&input(pin_a2)&&input(pin_a4)) { float f; set_timer1(0); i=0; delay_ms(2000); f=((i * 65536) + get_timer1())/2; lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("Onda Quadrada "); lcd_pos_xy(1,2); printf(lcd_escreve,"F: %f Hz ",f); }
54
} if (!input(pin_a4)) { while(input(pin_a1)&&input(pin_a2)&&input(pin_a3)) { float f; set_timer1(0); i=0; delay_ms(2000); f=((i * 65536) + get_timer1())/2; lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("Onda Aleatoria "); lcd_pos_xy(1,2); printf(lcd_escreve,"F: %f Hz ",f); } } } } void Tela1() {
lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("Felipe Anastacio"); lcd_pos_xy(1,2); lcd_escreve("Marcos Martinez ");
} void Tela2() {
lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve(" TCC - Gerador "); lcd_pos_xy(1,2); lcd_escreve(" de Funcoes "); delay_ms(3000); lcd_pos_xy(1,1); lcd_escreve("Microcontrolado "); lcd_pos_xy(1,2); lcd_escreve(" com Interface "); delay_ms(3000); lcd_pos_xy(1,1); lcd_escreve(" Wireless no "); lcd_pos_xy(1,2);
lcd_escreve(" Computador "); delay_ms(3000);
} void Tela3() {
lcd_escreve("\f"); lcd_pos_xy(1,1); lcd_escreve("S1 p/ Senoidal "); lcd_pos_xy(1,2); lcd_escreve("S2 p/ Triangular"); delay_ms(4000); lcd_pos_xy(1,1);
55
lcd_escreve("S3 p/ Quadrada "); lcd_pos_xy(1,2); lcd_escreve("S4 p/ Aleatoria "); delay_ms(4000);
}
APÊNDICE C – CÓDIGO DO SOFTWARE
//--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include "manArquivo.cpp" #include "unit1.h" #include "cPorta.h" //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; HANDLE arq; cPorta *com; unsigned char *xs, ys[128]; int final; //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {
Chart1->Series[0]->AddXY(0,0,"",clRed); // define ponto inicial (0;0). Chart1->Series[0]->AddXY(127,0,"",clRed); // define ponto final (127;0). ListBox1->Items->Add("0;0"); ListBox1->Items->Add("127;0"); com = new cPorta("COM2",19200,1,2,0); // define porta serial. } //--------------------------------------------------------------------------- void __fastcall TForm1::Chart1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { int x = (X - 47) / 4.816; // redefine o ponto x=0 como do gráfico e não do form. int y = (410 - Y) / 3.076; // redefine o ponto y=0 como do gráfico e não do form.
if(x>0 && x<128) //Não permite marcação de pontos em x fora da área de 0 a 256. { if(y>0 && y<128) // Não permite marcação de pontos em y fora de 0 a 256. { Chart1->Series[0]->AddXY(x,y,"",clRed); ListBox1->Items->Add(IntToStr(x)+";"+IntToStr(y)); } } else ShowMessage("Ponto não válido."); // Mensagem de alerta. } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender)
56
{ Chart1->Series[0]->AddXY(StrToInt(Edit1->Text),StrToInt(Edit2->Text),"",clRed); // Adiciona os pontos digitados no gráfico. ListBox1->Items->Add(Edit1->Text+";"+Edit2->Text); // Adiciona os pontos digitados no Listbox. Edit1->Text = ""; Edit2->Text = ""; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button4Click(TObject *Sender) ///////////////////////////Protocolo de Comunicação////////////////////////// { unsigned char *handshake, val; int qtde = 0; val = 0x55; com->EnviaDado(&val,1); Sleep(1); do { handshake = com->RecebeDado(qtde); }
while (qtde==0); if(handshake[0] == 0xAA) { val = 0xAA; com->EnviaDado(&val,1) ; delete handshake; qtde = 0; Sleep(1); do { handshake = com->RecebeDado(qtde); }
while (qtde==0); if(handshake[0] == 0xAA) { for(int i=0;i<128;i++) { com->EnviaDado(&ys[i],1); Sleep(20); } val = 0xAA; com->EnviaDado(&val,1); delete handshake; qtde = 0; Sleep(1); do { handshake = com->RecebeDado(qtde); }
while (qtde==0); if(handshake[0] == 0xAA) { ShowMessage("Transmissão concluida com sucesso"); }
57
} else ShowMessage("HandShake confirmado. Valor não confirmado"); } else ShowMessage("HandShake não confirmado."); } //--------------------------------------------------------------------------- void __fastcall TForm1::NovoClick(TObject *Sender) {
ListBox1->Clear(); Chart1->Series[0]->Clear(); ListBox1->Items->Add("0;0"); ListBox1->Items->Add("127;0"); Chart1->Series[0]->AddXY(0,0,"",clRed); Chart1->Series[0]->AddXY(127,0,"",clRed);
} //--------------------------------------------------------------------------- void __fastcall TForm1::Sobre1Click(TObject *Sender) {
ShowMessage("Software criado por Felipe Ehlke Anastacio e Marcos Martinez.\n Projeto de-senvolvido para trabalho de conclusão de curso.");
} //--------------------------------------------------------------------------- void __fastcall TForm1::SalvarComo1Click(TObject *Sender) { sd->Execute(); arq = abrirArquivo(sd->FileName); AnsiString linha = ListBox1->Items->GetText(); gravarArquivo(arq,linha.c_str(),linha.Length()); // Aonde será salvo o arquivo. } //--------------------------------------------------------------------------- void __fastcall TForm1::Abrir1Click(TObject *Sender) { OpenDialog1->Execute(); ListBox1->Items->Clear(); Chart1->Series[0]->Clear(); ListBox1->Items->LoadFromFile(OpenDialog1->FileName); for(int i=0;i<ListBox1->Items->Count;i++) { AnsiString texto = ListBox1->Items->Strings[i]; texto = texto.Delete(1,texto.AnsiPos(";")); int valor = StrToInt(texto); Chart1->Series[0]->Add(valor,"",clRed); } } //--------------------------------------------------------------------------- void __fastcall TForm1::Fechar1Click(TObject *Sender) {
Form1->Close(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) {
58
final = ListBox1->Items->Count; int cont = 0; memset(ys,0,128); //Seta as 128 posicoes do vetor ys para 0. xs = new unsigned char[final+1]; memset(xs,0,final); //Seta a qntd de posições alocada em "final" para 0. for(int i=0;i<final;i++) {
AnsiString linha = ListBox1->Items->Strings[i]; //envia para "linha" o valor locado na li-nha [i] do ListBox. AnsiString x = linha.SubString(1,linha.AnsiPos(";")-1); // Separa a informação x da s-tring (x;y). AnsiString y = linha.SubString(linha.AnsiPos(";")+1,3); // Separa a informação y da s-tring (x;y).
ys[StrToInt(x)] = StrToInt(y); // Salva o valor y na posicao x do vetor ys. xs[cont++] = StrToInt(x); // Salva em um vetor os valores de x. } for(int i=0;i<final;i++) for(int j=0;j<final-1;j++) if(xs[j]>xs[j+1]) { int temp = xs[j]; xs[j] = xs[j+1]; xs[j+1] = temp; } //////////////////////////INTERPOLAÇÃO////////////////////////////////////// int x1,x0,y1,y0,z; float a,b; for(int i=0;i<final-1;i++) { x0=xs[i]; y0=ys[xs[i]]; //Define os pontos limites das retas x1=xs[i+1]; y1=ys[xs[i +1]]; a=(float)(y1-y0)/(x1-x0); b=(float)y1-(a*x1); //Cálculo dos pontos intermediários da reta. for(z=x0+1;z<x1;z++) { ys[z]=(a*z+b); } } ////////////////////LISTAGEM DE PONTOS//////////////////////////////////////// ListBox1->Clear(); for(int i=0;i<128;i++) { ListBox1->Items->Add(IntToStr(i)+" ; "+IntToStr(ys[i])); } Button4->Enabled= true; } //---------------------------------------------------------------------------
59
ANEXO A – MOD_LCD.H
#ifndef lcd_enable #define lcd_enable pin_d3 // pino enable do LCD #define lcd_rs pin_d2 // pino rs do LCD #define lcd_d4 pin_d4 // pino de dados d4 do LCD #define lcd_d5 pin_d5 // pino de dados d5 do LCD #define lcd_d6 pin_d6 // pino de dados d6 do LCD #define lcd_d7 pin_d7 // pino de dados d7 do LCD #endif #define lcd_type 2 // 0=5x7, 1=5x10, 2=2 linhas #define lcd_seg_lin 0x40 // Endereço da segunda linha na RAM do LCD byte CONST INI_LCD[4] = {0x20 | (lcd_type << 2), 0xf, 1, 6}; byte lcd_le_byte() // lê um byte do LCD (somente com pino RW) { byte dado; // configura os pinos de dados como entradas input(lcd_d4); input(lcd_d5); input(lcd_d6); input(lcd_d7); // se o pino rw for utilizado, coloca em 1 #ifdef lcd_rw output_high(lcd_rw); #endif output_high(lcd_enable); // habilita display dado = 0; // zera a variável de leitura // lê os quatro bits mais significativos if (input(lcd_d7)) bit_set(dado,7); if (input(lcd_d6)) bit_set(dado,6); if (input(lcd_d5)) bit_set(dado,5); if (input(lcd_d4)) bit_set(dado,4); // dá um pulso na linha enable output_low(lcd_enable); output_high(lcd_enable); // lê os quatro bits menos significativos if (input(lcd_d7)) bit_set(dado,3); if (input(lcd_d6)) bit_set(dado,2); if (input(lcd_d5)) bit_set(dado,1); if (input(lcd_d4)) bit_set(dado,0); output_low(lcd_enable); // desabilita o display return dado; // retorna o byte lido } void lcd_envia_nibble( byte dado ) // envia um dado de quatro bits para o display { // coloca os quatro bits nas saidas output_bit(lcd_d4,bit_test(dado,0)); output_bit(lcd_d5,bit_test(dado,1));
60
output_bit(lcd_d6,bit_test(dado,2)); output_bit(lcd_d7,bit_test(dado,3)); // dá um pulso na linha enable output_high(lcd_enable); output_low(lcd_enable); } void lcd_envia_byte( boolean endereco, byte dado ) { // coloca a linha rs em 0 output_low(lcd_rs); // aguarda o display ficar desocupado //while ( bit_test(lcd_le_byte(),7) ) ; // configura a linha rs dependendo do modo selecionado output_bit(lcd_rs,endereco); delay_us(100); // aguarda 100 us // caso a linha rw esteja definida, coloca em 0 #ifdef lcd_rw output_low(lcd_rw); #endif // desativa linha enable output_low(lcd_enable); // envia a primeira parte do byte lcd_envia_nibble(dado >> 4); // envia a segunda parte do byte lcd_envia_nibble(dado & 0x0f); } void lcd_ini() // rotina de inicialização do display { byte conta; output_low(lcd_d4); output_low(lcd_d5); output_low(lcd_d6); output_low(lcd_d7); output_low(lcd_rs); #ifdef lcd_rw output_high(lcd_rw); #endif output_low(lcd_enable); delay_ms(15); // envia uma seqüência de 3 vezes 0x03 // e depois 0x02 para configurar o módulo // para modo de 4 bits for(conta=1;conta<=3;++conta) { lcd_envia_nibble(3); delay_ms(5); } lcd_envia_nibble(2); // envia string de inicialização do display for(conta=0;conta<=3;++conta) lcd_envia_byte(0,INI_LCD[conta]); } void lcd_pos_xy( byte x, byte y)
61
{ byte endereco; if(y!=1) endereco = lcd_seg_lin; else endereco = 0; endereco += x-1; lcd_envia_byte(0,0x80|endereco); } void lcd_escreve( char c) // envia caractere para o display { switch (c) { case '\f' : lcd_envia_byte(0,1); delay_ms(2); break; case '\n' : case '\r' : lcd_pos_xy(1,2); break; case '\b' : lcd_envia_byte(0,0x10); break; default : lcd_envia_byte(1,c); break; } } char lcd_le( byte x, byte y) // le caractere do display { char valor; // seleciona a posição do caractere lcd_pos_xy(x,y); // ativa rs output_high(lcd_rs); // lê o caractere valor = lcd_le_byte(); // desativa rs output_low(lcd_rs); // retorna o valor do caractere return valor; }
ANEXO B – MANARQUIVO.CPP
#include <vcl.h> HANDLE abrirArquivo(AnsiString nome) { HANDLE arq = CreateFile(nome.c_str(), GENERIC_READ | GENERIC_WRITE, 0,
62
NULL, OPEN_ALWAYS, 0, NULL); return arq; } //--------------------------------------------------------------------------- void gravarArquivo(HANDLE arq, char *texto, int num) { DWORD charsWritten; WriteFile(arq, texto, num, &charsWritten, NULL); } //--------------------------------------------------------------------------- unsigned char *lerArquivo(HANDLE arq, int &num) { DWORD dwLength; unsigned char *texto; texto = new char[num+1]; texto[num]='\0'; ReadFile( arq, texto, num, &dwLength, NULL); num = dwLength; return texto; } //--------------------------------------------------------------------------- void fecharArquivo(HANDLE arq) { CloseHandle(arq); } void inicioArquivo(HANDLE arq) { SetFilePointer(arq,0,0,FILE_BEGIN); } void fimArquivo(HANDLE arq) { SetFilePointer(arq,0,0,FILE_END); } void moverArquivo(HANDLE arq, int num) { SetFilePointer(arq,num,0,FILE_END); }
ANEXO C – CPORTA.H
//--------------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop
63
#include "cPorta.h" #include <stdio.h> //--------------------------------------------------------------------------- cPorta :: cPorta(char * Porta) { Erro = NO_ERRO; BaudRate = 2400; hComm = CreateFile(Porta,GENERIC_READ | GENE-RIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); // Tenta abrir a porta de comunicação. if(hComm == INVALID_HANDLE_VALUE) // Se houve um erro, verifica o que aconteceu. Erro = HANDLE_INV; fSucesso = GetCommState(hComm, &dcbStatus); // Le as configurações da porta recém aberta. if(!fSucesso){ ShowMessage("Não foi possível acessar a porta!"); CloseHandle(hComm); // Fecha a porta de comunicação. Erro = ESTADO_PORTA_INV; return; } dcbStatus.BaudRate = BaudRate; dcbStatus.ByteSize = 8; dcbStatus.Parity = NOPARITY; dcbStatus.StopBits = ONESTOPBIT; fSucesso = SetCommState(hComm, &dcbStatus); if(!fSucesso){ CloseHandle(hComm); // Fecha a porta de comunicação. Erro = ESTADO_PORTA_INV; return; } fSucesso = SetCommTimeouts(hComm, &Timeouts); if(!fSucesso){ CloseHandle(hComm); // Fecha a porta de comunicação. Erro = TIMEOUT_INV; return; } } cPorta::cPorta(char *Porta, int iBaud, int iDados, int iPar, int iStop) { Erro = NO_ERRO; hComm = CreateFile(Porta,GENERIC_READ | GENE-RIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL); // Tenta abrir a porta de comunicação. if(hComm == INVALID_HANDLE_VALUE) // Se houve um erro, verifica o que aconteceu. Erro = HANDLE_INV; fSucesso = GetCommState(hComm, &dcbStatus); // Le as configurações da porta recém aberta. if(!fSucesso){ ShowMessage("Não foi possível acessar a porta!"); CloseHandle(hComm); // Fecha a porta de comunicação. Erro = ESTADO_PORTA_INV; return; } dcbStatus.BaudRate = iBaud;
64
switch(iDados) { case 0: dcbStatus.ByteSize = 7; break; case 1: dcbStatus.ByteSize = 8; break; } switch(iPar) { case 0: dcbStatus.Parity = EVENPARITY; break; case 1: dcbStatus.Parity = ODDPARITY; break; case 2: dcbStatus.Parity = NOPARITY; break; } switch(iStop) { case 0: dcbStatus.StopBits = ONESTOPBIT; break; case 1: dcbStatus.StopBits = TWOSTOPBITS; break; } fSucesso = SetCommState(hComm, &dcbStatus); if(!fSucesso){ CloseHandle(hComm); // Fecha a porta de comunicação. Erro = ESTADO_PORTA_INV; return; } fSucesso = SetCommTimeouts(hComm, &Timeouts); if(!fSucesso){ CloseHandle(hComm); // Fecha a porta de comunicação. Erro = TIMEOUT_INV; return; } } cPorta :: ~cPorta() { if (!Erro) CloseHandle(hComm); } void cPorta::EnviaDado(char *Dado, int iNum) { // char *buffer = new char[iNum];
65
DWORD charsWritten = 0; Erro = NO_ERRO; /* for(int i=0;i<iNum;i++) *(buffer+iNum) = *(Dado+iNum);*/ if (!WriteFile((HANDLE(hComm)), Dado, iNum, &charsWritten, NULL)) Erro = HANDLE_INV; } char* cPorta::RecebeDado(int &iNum) { COMSTAT ComStat ; DWORD dwErrorFlags, dwLength, dwBytesLer; bool fReadStat; unsigned char* c = 0; fReadStat = ClearCommError(hComm, &dwErrorFlags, &ComStat ); // Comprova se há dados para serem recebidos. if(iNum!=0) dwBytesLer = iNum; else dwBytesLer = ComStat.cbInQue; if(dwBytesLer > 0) { c = new char[dwBytesLer+1]; memset(c,'\0',dwBytesLer+1); fReadStat = ReadFile( hComm, c, dwBytesLer, &dwLength, NULL); // Le um byte. if (!fReadStat) // Verifica se há erros. return NULL; iNum = dwLength; return c; // Se não há erros, retorna o caracter recebido. }else return NULL; } void cPorta::limpa(void){ PurgeComm(hComm, PURGE_RXCLEAR); Sleep(10); } #pragma package(smart_init)