ASM51

#include<18F4553.h>           //Inclui arquivo header do PIC 18F4553
#device ADC = 12              //Define 12 bits para o resultado da conversão AD
#use delay (clock=20000000)    /*Definição da frequência do cristal para cálculo 
                              ..dos delays*/
#fuses HS, NOWDT, PUT,BROWNOUT, NOLVP  //Configuração dos bits de controle

//Definições para a comunicação serial
#use RS232 (Baud=9600, enable = PIN_C5, xmit = PIN_C6, rcv = PIN_C7)
#include <2432.c>
#include <DS1307.c>
//#include <RS485.c>

//variáveis para armazenamento da conversão

int32 AN;            // AN
int32 AN1;           // AN1
int32 AN4;           // AN4
int32 AN5;           // AN5
int32 AN6;           // AN6
int32 AN7;           // AN7
int32 AN8;           // AN8

int display = 0;              //variáveis de controle para o display de leds

/******************************************************************************
variáveis de controle:
temperatura;
agua;
cont = controle de índice para recepção serial;
tempo = informação de tempo em 2 segundos
*******************************************************************************/
int temperatura = 0, agua=0, cont=0, tempo=0;

int1 tmp = 0;     /*variável de controle de tempo em 2 segundos para
                    alterarção das informações no LCD*/
int rec[5];       //Variável de recepção de dados pela serial

#INT_RDA          //Diretiva de identficação p/ int. pela recepção serial
void rec_serial() //Funçõa de tratamento da recepção de dados
{
rec[cont] = getc();     /*Lê o dado vindo pela serial e o armazena em
                          rec na posição (índice) informado por cont*/ 

if (rec[cont] == 0x0D)  //Verifica se o dado recebido é igual a CR (0x0D)
   {
   //Liga O Display de Leds   
   if (rec[0]=='L')  //Verifica se os primeiros caracteres são 'L'
      {
         display = 1;                     //controle do display de leds = 1
         output_bit(PIN_D0,display);      //Liga o display conectado ao pino RD0      
      }
      
   //Desliga o display de Leds
   if (rec[0]=='D')  //Verifica se os primeiros caracteres são 'D'
      {
         display = 0;                     //controle do display de leds = 0
         output_bit(PIN_D0,Display);      //Desliga o display conectado ao pino RD0       
      } 
      
   /*Após recebido todos os dados da serial, faz a limpeza de toda a
   variável rec e retorna o controle de índices cont em 0*/
   for(cont = 0; cont < 5; cont++) rec[cont] = '\0'; 
   cont = 0;  
   }
else
   /*Se ainda não foram recebidos todos os dados de controle, incrementa
   a variável de índice cont*/
    cont++;   
}

#INT_TIMER0       //Diretiva de indetificação da int. do Timer 0

void PiscaLED()
{
   static boolean PiscaLed; //para piscar o led.
   static int contador; //para contar o tempo de 1/2 segundo.
   set_timer0(61-get_timer0());
   contador++;
   if(contador == 64) //Se contou 64 (1/2 segundo).
   {
      contador=0; //zera contagem.
      PiscaLed = !PiscaLed; //Inverte bit;
      output_bit(pin_C0, PiscaLed); //Liga/desliga LED.
   }
}

void Trata_t0()   //Função para tratamento do Timer 0
{
tempo++;          //Incrementa a variável tempo a cada 25ms
if (tempo >= 80)  //Se tempo >= 80 <=> 2 segundos?
    {
    tmp = 1;      //Variável de controle de tempo 2 seg vai para 1
    tempo = 0;    //Retorna a variável tempo em 0
    }
SET_TIMER0(61);   //Retorna o valor inicial ao Timer 0
}

//Formato do protocolo = AN0:0000:TMP:0000:00000000
void escreve_serial()               //Função de envio do protocolo para a serial
{
printf("AN0:%04lu",AN * 5000/4095);      //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN1:%04lu",AN1 * 5000/4095);     //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN4:%04lu",AN4 * 5000/4095);     //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN5:%04lu",AN5 * 5000/4095);     //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN6:%04lu",AN6 * 5000/4095);     //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN7:%04lu",AN7 * 24000/4095);    //Envia dados de conversão A/D
printf(":");                             //Controle do protocolo
printf("AN8:%04lu",AN8 * 5000/4095);     //Envia dados de conversão A/D 
printf(":");                             //Controle do protocolo
/******************************************************************************
Envia dados referentes ao circuito de aquecimento, ventoinha e leds
0: desligado
1: ligado
******************************************************************************/
printf("%d%d00%d\r\n",agua, temperatura, display); 

}
 
void main()                       //Função principal 
{
//Configura as entradas analógicas AN0 a AN8
SETUP_ADC_PORTS(AN0_TO_AN8|VREF_VREF);  //Utiliza o clock interno para tempo de aquisição
//Utiliza o clock externo para tempo de aquisição 
SETUP_ADC(ADC_CLOCK_DIV_32);
//Habilita interrupção global
Enable_Interrupts(GLOBAL);
//Habilita interrupção por recepção de dados na serial
Enable_Interrupts(INT_RDA);
//Habilita interrupção pelo overflow do Timer 0
ENABLE_INTERRUPTS(INT_TIMER0);
/*Configura Timer 0 para incremento pelo ciclo de máquina
Prescaler de 1:256 e modo de operação em 8 bits*/
SETUP_TIMER_0(RTCC_INTERNAL | RTCC_DIV_256 | RTCC_8_BIT);
//Inicia o Timer 0 com o valor 61 - Interrupção a cada 25ms
SET_TIMER0(61);
                  

output_D(0x00);                  //Faz toda a porta D = 0

display = input_state(PIN_D0);   //armazena em display o estado do pino RD0

/*Faz a limpeza de toda a variável rec e faz o controle de índices cont em 0*/
for(cont = 0; cont < 5; cont++) rec[cont] = '\0'; 
cont = 0;

while(true)                      //Loop principal
   { 
   if (!input(PIN_B4))           //Se chave conectada ao pino RB3 for pressionada 
      {
      agua = 1;                  //Faz controle da detecção de água = 1
      }
      else
      {
      agua = 0;                  //Faz controle da detecção de água = 0
      }
  
   SET_ADC_CHANNEL(0);           //Configura o canal de leitura 0
   delay_us(100);                //Tempo de ajuste do canal (necessário) 
   AN = READ_ADC();              //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(1);           //Configura o canal de leitura 1
   delay_us(100);                //Tempo de ajuste do canal (necessário) 
   AN1 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(4);           //Configura o canal de leitura 4
   delay_us(100);                //Tempo de ajuste do canal (necessário) 
   AN4 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(5);           //Configura o canal de leitura 5
   delay_us(100);                //Tempo de ajuste do canal (necessário) 
   AN5 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(6);           //Configura o canal de leitura 6
   delay_us(100);                //Tempo de ajuste do canal (necessário) 
   AN6 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(7);           //Configura o canal de leitura 7
   delay_us(20);                 //Tempo de ajuste do canal (necessário) 
   AN7 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   SET_ADC_CHANNEL(8);           //Configura o canal de leitura 8
   delay_us(20);                 //Tempo de ajuste do canal (necessário) 
   AN8 = READ_ADC();             //Faz a conversão AD e a salva na variável ad0
   
   
   if (AN4>=200)                 //Se tempint >= 200 (aprox. 25 graus)
   {
      temperatura = 1;           //Faz controle da temperatura = 1
   }
   
   if (AN4<=170)                 //Se tempint <= 170 (aprox. 20 graus)
   {
      temperatura = 0;           //Faz controle da temperatura = 0;
   }
      
   escreve_serial();             //Envia dados pela serial
                   
   delay_ms(300);                //Atraso de 100ms
   }
}

rosiley escreveu:... apesar de estar utilizando um processador de 12 bits...

Código: Selecionar todos

(AN*5000)/4095;

Código: Selecionar todos

AN * 5000/4095

ze escreveu:chutar pode?
chute 1...
experimente fazer

Código: Selecionar todos

(AN*5000)/4095;

onde está

Código: Selecionar todos

AN * 5000/4095

a não ser que int32 seja o mesmo que float

chute 2...
Com relação ao hyperterminal, pode ser que a interrupt do led esteja zoando o barraco

Agora sério... para ad de 12 bis e medir sinal bem baixo, suas referências (+5, gnd) deve ter um layout bem feito além de ter boa estabilidade e precisão. P.ex. não aconselho usar o +5 da alimentação do mc e etc. Mas isso vc ainda vai sentir na pele. Por hora nada a ver com seu problema...

Código: Selecionar todos

#include <18F4520.h>
#device adc=10

float Media,sinal,sinal2,OFFSET=1.71;

float conversao(){

   Media = 0;
   for(y=0;y<=38;y++){
            delay_us(100);
            Media = Media + read_adc();         
       }
   sinal = (media / 38);     
   sinal2 = (sinal*5.0)/1023;
   return ((sinal2-OFFSET)*8);


Código: Selecionar todos

unsigned int conversao()
{
unsigned char y;
unsigned int media=0;
for (y=0;y<32;y++) {media+=adcread();delay(xxx);}
return media/32;
}


Código: Selecionar todos

float sinal2;
sinal2 = (conversao()*5.0)/1023;