Strain Gage,Extensômetria, Deformação, eletrônica e códigos para microcontrolador.
Conversão A/D
No mundo físico parâmetros como temperatura, força, pressão, umidade, velocidade entre outros são sinais analógicos. Essas grandezas físicas são convertidas em sinais elétricos, para podermos trabalhar com esses dados com o auxilio de micro controladores, devemos converter esses sinais usando um conversor analógico digital (ADC) que é um componente eletrônico que converte sinais para uma forma discreta.
Os conversores analógicos digitais são os dispositivos mais usados no mundo para a aquisição de dados, o conversor usado neste projeto é o ADC0808 com uma resolução de 8 bits possuindo oito entradas de sinais analógicos com seu controle feito de maneira multiplexada.
O conversor analógico digital ADC0808 usa o método de aproximação sucessiva para transformar os sinais lidos em dados digitais.
O design do ADC0808 foi otimizado pela incorporação dos mais desejados aspectos vistos em outros conversores, o dispositivo oferece alta velocidade de conversão, precisão e dependência mínima em relação a mudanças na temperatura ambiente.
Principais Características.
1. Fácil interface com micro controladores.
2. Não necessita de ajuste de zero ou de fundo de escala.
4. Oito canais de entradas multiplexados.
5. Com alimentação de 5V os sinais de entrada podem variar de 0 a 5V.
6. Tensões de saída compatível com as especificações TTL.
Conforme Trietley (1986), os conversores A/D por aproximação sucessiva são os mais comuns entre os conversores A/D, permitem uma conversão rápida, proporcionando uma gama de 100.000 ou mais conversões por segundo.
Na técnica de aproximação sucessiva, é utilizada um algoritmo para converter a entrada analógica em digital.
Este algoritmo consiste em ajustar o MSB para 1 e todos os outros bits para 0. O comparador compara a saída do conversor D/A (Vd) com o sinal da entrada analógica (Ve). Se Vd > Ve, o 1 é removido do MSB e enviado para o próximo bit mais significativo. Se Ve > Vd, o MSB permanece como 1 e o próximo bit mais significativo também recebe 1. Assim o 1 é deslocado e testado em cada bit do decodificador D/A até o final do processo, para obter o valor binário equivalente.
Fluxograma da aproximação sucessiva, Tocci’s Digital Systems: Principles and Applications, 10th edition – Pearson Prentice Hall
Pinagem ADC0808
O ADC0808 possui oito entradas, para selecionar a que será usada para receber os sinais do extensômetro devemos enviar para o ADC 3 bits nos pinos 25,24,23.
Tabela de seleção de entradas National Semiconductor – Data sheet ADC0808 – Outubro de 1999
O sinal enviado pelo extensômetro depois de amplificado e tratado entrará no pino 26 (IN0), para selecionar esse canal é preciso enviar 3 bits 0 (zero), ou aterrar os 3 pinos do seletor, neste projeto os 3 pinos foram aterrados, o sinal analógico é convertido em um sinal digital com 8 bits de resolução que no nosso caso permite uma mudança de estado a cada 20mV.
De acordo com o diagrama de tempo do ADC podemos dizer quais os requisitos para realizar a leitura dos dados processados pelo ADC, e definir uma freqüência de operação para atualização.
De acordo com o data sheet as freqüências podem estar dentro da faixa de 10 a 1280 Khz, para gerar um clock dentro destas especificações foi usado um CI 555 e a freqüência estipulada foi de 320Khz.
No micro controlador a porta P0 recebe valores de 0x00 até 0xFF
que em decimal equivaleriam a 0 até 255 uma multiplicação simples por 2 nos permite trabalhar com números decimais de 1 a 510 sendo uma aproximação simples e efetiva dos 0 a 5kg que iremos exibir em nosso display, só nos restando fazer um jogo com casas decimais que foi facilmente implementado no código.
DisplayLCD, como inicializar sem uma biblioteca pronta.
Conforme visto em: http://www.electronica-pt.com/index.php/content/view/247/37/ (2009), os LCD são formados por material que se denomina cristal líquido. As moléculas desse material são distribuídas entre duas lâminas transparentes polarizadas. Essa polarização é orientada de maneira diferente nas duas lâminas, de forma que estas formem eixos polarizadores perpendiculares, como se formassem um ângulo de 90º. As moléculas de cristal líquido são capazes de orientar a luz.
A base da iluminação de um LCD é a luz fornecida por uma lâmpada CCFL ou um conjunto de LEDS. Nos LCD monocromáticos, cada ponto da tela corresponde a um ponto da imagem.
Um pixel é a menor unidade de uma imagem, o número de pixels no display determina a resolução do LCD.
Os LCDs são amplamente usados em conjunto com micro controladores para mostrar a informação visualmente, os LCDs possuem uma tabela de caracteres ASCII e símbolos matemáticos em sua memória.
*
Sinais Enviados para o LCD
O LCD requer três sinais de controle que devem ser enviados pelo micro controlador.
Enable (E) – Este sinal permite acessar o display através das instruções R/W e RS.
Quando enable tem nível lógico baixo o display ignora os sinais vindos de R/W e RS, quando enable tem nível lógico alto o display checa os estados desses dois controladores, e responde de acordo.
Read/Write (R/W) Ler e Escrever- Determina a direção em que os dados fluem entre o LCD e o micro controlador, quando R/W tem nível lógico baixo os dados enviados pelo micro controlador são escritos no LCD, quando R/W tem nível lógico alto os dados são lidos do LCD.
Register select (RS) Seletor de Registros – De acordo com os dados nesse controlador o LCD interpreta o tipo de dado que está sendo enviado pelo micro controlador.
Quando RS tem nível baixo uma instrução está sendo escrita no LCD, quando o nível é alto um caractere ou mais está sendo escrito.
E = 0 Acesso ao LCD desabilitado
= 1 Acesso ao LCD habilitado
R/W = 0 Escrevendo dados no LCD
= 1Lendo dados do LCD
RS= 0 Uma instrução foi enviada ao LCD
= 1 Um caractere foi enviado ao LCD
Escrevendo dados no LCD
Enviar dados para o LCD requer alguns passos:
1) Setar o bit R/W bit como 0 (zero).
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Enviar dados para as linhas de dado.
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
Lendo dados
1) Setar o bit R/W como 1 (um)
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Ler dados das linhas de dados
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
5.1.2.1 Pinagem do LCD
*
Display LCD 20×4 – descrição dos pinos. (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)
Inicialização do LCD
Antes de usar o display LCD para nosso objetivo, ele deve ser inicializado via reset interno ou pelo envio de um conjunto de instruções. Como nosso projeto foi concebido com a idéia de conectar o display a um micro controlador, escolhemos a inicialização por instruções.
Inicializar um display LCD com instruções é um processo simples, abaixo temos um fluxograma que indica todos os passos.
Fluxograma de inicialização por instruções do Display LCD (Ajay Bhargav – http://www.8051projects.net/)
De acordo com o fluxograma podemos observar que o display LCD é inicializado conforme a seguinte seqüência
1) Enviar o comando 0x30 – Usando a interface de 8 bits
2) Esperar 20ms
3) Enviar o comando 0x30 – Usando a interface de 8 bits
4) Esperar 20ms
5) Enviar o comando 0x30 – Usando a interface de 8 bits
6) Esperar 20ms
7) Enviar o conjunto de instruções.
8) Enviar o comando 0x01 para limpar o LCD
9) Definir o modo de incremento.
Teclados são dispositivos que realizam a interface homem máquina e os teclados matriciais como o usado neste projeto são os mais conhecidos devido sua arquitetura simples e sua fácil integração com micro controladores.
*
Lendo os dados enviados por um teclado
Existem vários métodos de se ler dados enviados por um teclado e eles basicamente se diferenciam pela maneira com que são conectados a um micro controlador, mas a lógica permanece a mesma.
No micro controlador as colunas são definidas como pinos de entrada e as linhas como pinos de saída.
|
Teclado matricial
Para detectar qual tecla foi pressionada todas as linhas recebem nível lógico baixo e todas as colunas recebem nível alto, o micro controlador espera alguma mudança de estado nas colunas, se uma tecla foi pressionada o nível baixo será enviado para a entrada do micro processador, pois as colunas foram definidas como pinos de entrada.
A linguagem C
De acordo com Aitken, Jones (2002), a linguagem C é poderosae flexível, o que você conseguirá programando em C será somente limitado por sua imaginação.
A linguagem C não restringe a criação, C é usado em projetos como sistemas operacionais, editores de texto, gráficos, tabelas e até mesmo compiladores para outras linguagens.
C é uma linguagem portável, portabilidade significa que um programa escrito em C para um sistema, por exemplo, um sistema IBM, pode ser compilado e funcionar em outro sistema com pouca ou nenhuma modificação.
C é modular, o código em C pode e deve ser escrito em rotinas chamadas funções, estas funções podem ser reusadas em outras aplicações ou programas.
De acordo com o data Sheet Atmel 8-bit Microcontroller with 8K Bytes In-System Programmable Flash, o AT89S52 é um integrado de baixo consumo e alta performance com 8 Kbytes de memória flash programável. O dispositivo é compatível com os padrões industriais de conjunto de instruções 80C51.
O AT89S52 possui 32 linhas de entrada e saída, Watchdog timer, dois ponteiros de dados, três contadores / temporizadores de 16 bits, porta serial com comunicação full duplex, oscilador integrado e suporte a dois modos de economia de energia.
Ao combinar uma CPU versátil de 8-bit com memória flash programável no sistema o Atmel AT89S52 é um micro controlador poderoso que fornece uma solução altamente flexível e de custo eficaz para muitas aplicações de controles incorporados.
Gostaríamos de citar a família ATMEGA da Atmel que possui funções muito pertinentes ao nosso trabalho como o ADC integrado e uma velocidade consideravelmente maior o que nos facilitaria em muito o desenvolvimento deste projeto, mas pelos motivos citados acima e por fins didáticos decidimos descartar o uso desta linha de micro controladores.
*
O que nos motivou a escolher o micro controlador AT89S52 foi a familiaridade que adquirimos com o mesmo durante o curso e para mostrar o poder da família 8051. Nosso intuito foi o de mostrar que as aulas de micro controladores nos deram embasamento suficiente para alçarmos vôos maiores.
O condicionador de sinal 1B31 da Analog Devices pode ser dividido em três partes, um amplificador de instrumentação com alta precisão, um ajustador de excitação da ponte e um conjunto de filtros.
O 1B31 pode ser usado em uma grande variedade de sensores como transdutores, medidores de força, torque e pressão. Ideal para aplicações industrias pois é pouco sensível a mudanças ambientais e a ruídos.
O 1B31 nos proporciona uma série de facilidades entre elas podemos citar:
· Ajuste de tensão de excitação da ponte.
· Ajuste de offset da saída
· Ajuste de ganho.
O ganho do nosso amplificador é ajustado seguindo a seguinte equação:
*
Onde RG é o resistor de ganho que vai conectado entre os pinos 3 e 4.
Com uma tensão de fundo de escala de 5,375 mV e com uma resolução de 0,2V e com 250 passos nossa tensão de saída ideal seria de 4,9 V, o que resulta em uma ganho de 907 usando uma resistência de 80 ohms.
Vídeo do projeto funcionado
Código fonte:
Original para 8051, podendo ser adaptado par arduino entre outros.
#include <REGX52.H> // Biblioteca do 8051
#include<intrins.h> // Usado por causa do _nop_();
#include<string.h>
/* The intrins.h include file contains prototypes for routines
that instruct the compiler to generate intrinsic code.
Mais Detalhes em http://www.keil.com/support/man/docs/c166/c166_intrins_h.htm */
#define ADC_data P0 // Porta P0 sera ligada ao barramento de dados do ADC
#define LCD_data P2 // Porta P2 sera ligada ao barramento de dados do LCD
#define LCD_rs P1_0 // RS=1 envia dados ; RS=0 Envia Instruções
#define LCD_rw P1_1 // RW=1 Faz leitura ; RS=0 Escreve
#define LCD_en P1_2 // On/Off *VIDE DATA SHEET*
#define ADC_start P1_3 // Inicia Conversão
#define ADC_eoc P1_4 // Termina a Conversão
#define ADC_oe P1_5 // Libera a Saída
#define ADC_ale P1_6 // Inicia Conversão
#define keyport P3 // Barramento de dados para o teclado
#define col1 P3_0 // Setamos aqui as colunas para fazer a varredura, col1 a col4
#define col2 P3_1
#define col3 P3_2
#define col4 P3_3
#define TRUE 1 // Define 1 como verdadeiro
#define FALSE 0 // Define 0 como falso
void LCD_poweron(void); // Delay de 15ms para inicialização do LCD (cristal de 11.0592)
void LCD_busy(void); // Delay para evitar Busy Flag
void LCD_instruction(unsigned char var); // Envio de Instruções ao LCD
void LCD_senddata(unsigned char var); // Envio de Dados ao LCD
void LCD_sendstring(unsigned char *var); // Envio de Dados ao LCD
void LCD_sendvariavel(int var); // Envio de Variavel ao LCD
void ADC_poweron(void); // Conjunto de Instruções para partida do ADC
void tec_inicio(void); // Inicializa porta P3 com os valores desejados
int le_tecla(void); // Função responsável pela leitura de dados do teclado
int teclado = 0;
signed int leitura1=0, leitura2=0, leitura3=0, leitura4=0, leitura5=0, leituras=0;
signed int leitura6=0, leitura7=0, leitura8=0, leitura9=0, leitura10=0;
signed int leitura1x=0, leitura2x=0, leitura3x=0, leitura4x=0, leitura5x=0, leiturasx=0;
signed int leitura6x=0, leitura7x=0, leitura8x=0, leitura9x=0, leitura10x=0;
signed int valor=0;
signed int temp_digito=0;
signed int temp_digito1=0;
signed int temp_tara=0;
signed int condicao=0;
signed int condicaox=0;
signed int temp=0;
signed int temp1=0;
signed int temp2=0;
signed int tempx=0;
signed int temp1x=0;
signed int temp2x=0;
signed int tara=0;
int x;
signed int tara_mestre1=0;
signed int tara_mestre2=0;
signed int unidade=0,dezena=0,centena=0,milhar=0;
signed int unidade2=0,dezena2=0,centena2,milhar2=0;
signed int unidadex=0,dezenax=0,centenax=0,milharx=0;
signed int unidade2x=0,dezena2x=0,centena2x,milhar2x=0;
void main(void)
{
inicio:
LCD_poweron(); // 15ms delay
LCD_poweron(); // 15ms delay
LCD_instruction(0x38); // Inicialização de display em 8 bits
LCD_instruction(0x38); // Inicialização de display em 8 bits
LCD_instruction(0x0F); // Modo de funcionamento
LCD_instruction(0x01); // Limpa a Tela do Display
LCD_instruction(0x06); // Tipo de Incremento
LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
LCD_sendstring(“ FIEL-TCC 2009 “); // texto a ser enviado
LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
LCD_sendstring(“——————–“); // texto a ser enviado
LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
LCD_sendstring(“1: LEITURA”); // texto a ser enviado
LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 4ª linha
LCD_sendstring(“2: LEITURA COM TARA”); // texto a ser enviado
/*
O endereço da 3ª e 4ª linhas
São continuações da 1ª e 2ª
os endereços de inicio são:
1ª:0x80
2ª:0xC0
3ª:0x94
4ª:0xD4
*/
tec_inicio(); // Inicialização do Teclado
while(1)
{
teclado = le_tecla();
switch (teclado)
{
// achar as posições fixas na tela para dar update de dados somente nos numeros e
// nao no texto todo.
case 1: // Se nao funcionar tentar diminuir o lcd_busy do sendvariavel
{
LCD_instruction(0x01); // Limpa a Tela do Display
x=0;
while(x<5)
{
LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
LCD_sendstring(“2:TARA”); // texto a ser enviado
//Iniciando o ADC
ADC_poweron();
// Código responsável por tirar uam média do valor lido para evitar discrepâncias
leitura1 = ADC_data;
leitura2 = ADC_data;
leitura3 = ADC_data;
leitura4 = ADC_data;
leitura5 = ADC_data;
leitura6 = ADC_data;
leitura7 = ADC_data;
leitura8 = ADC_data;
leitura9 = ADC_data;
leitura10 = ADC_data;
leituras = (leitura1 + leitura2 + leitura3 + leitura4 + leitura5 + leitura6 + leitura7 + leitura8 + leitura9 + leitura10);
temp_digito = (leituras/10);
temp = temp_digito*2;
temp2 = temp_digito*19.6; // Conversão para newton e exibição correta 9,8*2
// Separando o valor lido em 4 partes
unidade=temp%10;
dezena=(temp%100)/10;
centena=(temp/100)%10;
milhar=temp/1000;
tara_mestre1=((unidade) + (10*dezena) + (100*centena) + (1000*milhar));
unidade2=temp2%10;
dezena2=(temp2%100)/10;
centena2=(temp2/100)%10;
milhar2=temp2/1000;
// Somando 0x30h para cada variavel.
// 0x30h é o endereço onde começa o Número zero da tabela ASCII.
// Esta parte se refere aos valores em kg (MASSA)
milhar+=0x30;
centena+=0x30;
dezena+=0x30;
unidade+=0x30;
// Somando 0x30h para cada variavel
// Esta segunda parte se refere aos valores em Newton
milhar2+=0x30;
centena2+=0x30;
dezena2+=0x30;
unidade2+=0x30;
// Enviando cada trecho dos valores lidos ao LCD
LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
LCD_sendstring(“MASSA:”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milhar);
LCD_sendvariavel(centena);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezena);
LCD_sendvariavel(unidade);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (kg)”); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
// Enviando cada trecho dos valores lidos ao LCD
LCD_sendstring(“PESO:”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milhar2);
LCD_sendvariavel(centena2);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezena2);
LCD_sendvariavel(unidade2);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (N)”); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
tec_inicio();
//teclado=0;
//teclado=le_tecla();
//if((teclado=le_tecla())!=0);
x++;
}
break;
}
case 2:
{
// Temporario Para teste de direcionamento
// tarar antes de entra no case e continuar lendo dentro do case caso a pessoa queira continuar
// para pegar outrop valor de tara ela deve retonar ao menu principal
x=0;
LCD_instruction(0x01); // Limpa a Tela do Display
LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
LCD_sendstring(“2:TARA”); // texto a ser enviado
while(x<5)
{
condicaox=0;
tara_mestre2=0;
temp_digito=0;
ADC_poweron();
leitura1x = ADC_data;
leitura2x = ADC_data;
leitura3x = ADC_data;
leitura4x = ADC_data;
leitura5x = ADC_data;
leitura6x = ADC_data;
leitura7x = ADC_data;
leitura8x = ADC_data;
leitura9x = ADC_data;
leitura10x = ADC_data;
leiturasx = (leitura1x + leitura2x + leitura3x + leitura4x + leitura5x + leitura6x + leitura7x + leitura8x + leitura9x + leitura10x);
temp_tara=(leiturasx/10);
tempx = temp_tara*2;
temp2x = temp_tara*19.6; // Conversão para newton e exibição correta 9,8*2
// Separando o valor lido em 4 partes
unidadex=tempx%10;
dezenax=(tempx%100)/10;
centenax=(tempx/100)%10;
milharx=tempx/1000;
tara_mestre2=((unidadex) + (10*dezenax) + (100*centenax) + (1000*milharx));
unidade2x=tara_mestre2%10;
dezena2x=(tara_mestre2%100)/10;
centena2x=(tara_mestre2/100)%10;
milhar2x=tara_mestre2/1000;
milharx+=0x30;
centenax+=0x30;
dezenax+=0x30;
unidadex+=0x30;
// Somando 0x30h para cada variavel
// Esta segunda parte se refere aos valores em Newton
milhar2x+=0x30;
centena2x+=0x30;
dezena2x+=0x30;
unidade2x+=0x30;
condicaox = (tara_mestre2 – tara_mestre1);
if (condicaox >= 0)
{
//Iniciando o ADC
ADC_poweron();
// Código responsável por tirar uam média do valor lido para evitar discrepâncias
//temp_digito = condicao;
tempx = condicaox;
//temp = temp_digito*2;
temp2x = condicaox*9.8; // Conversão para newton e exibição correta 9,8*2
// Separando o valor lido em 4 partes
unidadex=tempx%10;
dezenax=(tempx%100)/10;
centenax=(tempx/100)%10;
milharx=tempx/1000;
unidade2x=temp2x%10;
dezena2x=(temp2x%100)/10;
centena2x=(temp2x/100)%10;
milhar2x=temp2x/1000;
// Somando 0x30h para cada variavel.
// 0x30h é o endereço onde começa o Número zero da tabela ASCII.
// Esta parte se refere aos valores em kg (MASSA)
milharx+=0x30;
centenax+=0x30;
dezenax+=0x30;
unidadex+=0x30;
// Somando 0x30h para cada variavel
// Esta segunda parte se refere aos valores em Newton
milhar2x+=0x30;
centena2x+=0x30;
dezena2x+=0x30;
unidade2x+=0x30;
// Enviando cada trecho dos valores lidos ao LCD
LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
LCD_sendstring(“MASSA: “); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milharx);
LCD_sendvariavel(centenax);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezenax);
LCD_sendvariavel(unidadex);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (kg) “); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
// Enviando cada trecho dos valores lidos ao LCD
LCD_sendstring(“PESO: “); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milhar2x);
LCD_sendvariavel(centena2x);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezena2x);
LCD_sendvariavel(unidade2x);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (N) “); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
tec_inicio();
//teclado=0;
//teclado=le_tecla();
//if((teclado=le_tecla())!=0);
x++;
}
//if (condicao < 0)
else
{
ADC_poweron();
// LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
// LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
// LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
// LCD_sendstring(“2:TARA”); // texto a ser enviado
// Código responsável por tirar uam média do valor lido para evitar discrepâncias
//temp_digito = condicao;
tempx = condicaox*(-1);
//temp = temp_digito*2;
temp2x = condicaox*(-9.8); // Conversão para newton e exibição correta 9,8*2
// Separando o valor lido em 4 partes
unidadex=tempx%10;
dezenax=(tempx%100)/10;
centenax=(tempx/100)%10;
milharx=tempx/1000;
unidade2x=temp2x%10;
dezena2x=(temp2x%100)/10;
centena2x=(temp2x/100)%10;
milhar2x=temp2x/1000;
// Somando 0x30h para cada variavel.
// 0x30h é o endereço onde começa o Número zero da tabela ASCII.
// Esta parte se refere aos valores em kg (MASSA)
milharx+=0x30;
centenax+=0x30;
dezenax+=0x30;
unidadex+=0x30;
// Somando 0x30h para cada variavel
// Esta segunda parte se refere aos valores em Newton
milhar2x+=0x30;
centena2x+=0x30;
dezena2x+=0x30;
unidade2x+=0x30;
// Enviando cada trecho dos valores lidos ao LCD
LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
LCD_sendstring(“MASSA: -“); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milharx);
LCD_sendvariavel(centenax);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezenax);
LCD_sendvariavel(unidadex);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (kg)”); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
// Enviando cada trecho dos valores lidos ao LCD
LCD_sendstring(“PESO: -“); // Envia uma string para detalhar a leitura
LCD_sendvariavel(milhar2x);
LCD_sendvariavel(centena2x);
LCD_sendstring(“.”); // Envia uma string para detalhar a leitura
LCD_sendvariavel(dezena2x);
LCD_sendvariavel(unidade2x);
LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
LCD_sendstring(” (N)”); // Envia uma string para detalhar a leitura
ADC_oe=0; // Desliga a leitura de dados
tec_inicio();
x++;
}
}
break;
}
case 3: // Temporario Para teste de direcionamento
{
goto inicio;
}
case 4: // Temporario Para teste de direcionamento
{
}
}
}
}
void LCD_busy()
{
unsigned char i,j;
for(i=0;i<50;i++)
for(j=0;j<255;j++);
}
void LCD_poweron()
{
unsigned int i;
for (i=0;i<22500; i++);
}
void LCD_instruction(unsigned char var)
{
LCD_data = var;
LCD_rs = 0;
LCD_rw = 0;
LCD_en = 1;
_nop_(); // Uma instrução que não faz nada só gasta 1 ciclo de máquina.
_nop_();
LCD_en = 0;
LCD_busy();
}
/* A sequnência de instruções LCD_instruction se refere ao envio de uma
sequência de 8 bits para o barramento de dados do LCD, essas instruções
são tabeladas e podem ser achados no Data Sheet do LCD.
A função acima passa as instruções para o LCD
LCD_command(0x01); */
void LCD_sendstring(unsigned char *var)
{
while(*var) //Enquanto os caracteres durarem
LCD_senddata(*var++); //Envia os caracteres um por um
LCD_busy();
}
/* A função acima passa caracter por caracter
para a função LCD_senddata
LCD_sendstring(“LCD Tutorial”); */
void LCD_sendvariavel(int var)
{
LCD_data = var;
LCD_rs = 1;
LCD_rw = 0;
LCD_en = 1;
_nop_();
_nop_();
LCD_en = 0;
LCD_busy();
}
/* A função acima passa as variáveis convertidas
após a leitura do ADC para o LCD
LCD_sendvariavel(centena); */
void LCD_senddata(unsigned char var)
{
LCD_data = var;
LCD_rs = 1;
LCD_rw = 0;
LCD_en = 1;
_nop_();
_nop_();
LCD_en = 0;
LCD_busy();
}
/* A função acima passa caracter por caracter
o texto para o LCD. */
// ****Inicio das funções referentes ao ADC****
void ADC_poweron(void)
{
ADC_data=0xFF; // Seta a porta P0 como INPUT
ADC_ale=0; // Começo do pulso LOW to HIGH
_nop_(); // Gasta um ciclo de máquina
ADC_start=0; // Começo do pulso LOW to HIGH
LCD_busy(); // Gasta tempo antes de mandar um Pulso High
ADC_ale=1; // Começo do pulso HIGH to LOW
_nop_();
ADC_start=1; // Começo do pulso HIGH to LOW
LCD_busy();
ADC_ale=0;
_nop_();
ADC_start=0;
LCD_busy();
ADC_oe=1; // Envia os dados amostrados para o uC
}
/* Para começar a ler os dados enviados pelo ADC devemos respeitar seu
diagrama de tempo por isso os pulsos em ADC_ale e ADC_start */
// ****Inicio das funções referentes ao teclado****
void tec_inicio()
{
keyport = 0x0F;
}
/* Definimos a porta P3 (keyport) como Saida para as linhas e
entrada para as colunas */
// Começamos agora o código para fazer a leitura do teclado
int le_tecla()
{
int i,k,tecla=0;
k=1;
for (i=0;i<4;i++)
{
keyport &=~(0x80>>i);
if (!col1)
{
tecla = k+0;
while(!col1);
return tecla;
}
if (!col2)
{
tecla = k+1;
while(!col2);
return tecla;
}
if (!col3)
{
tecla = k+2;
while(!col3);
return tecla;
}
if (!col4)
{
tecla = k+3;
while(!col4);
return tecla;
}
k+=4;
keyport |= 0x80>>i; // Torna as linhas Altas novamente.
}
return FALSE;
}
