PIC calcular defasagem de sinal no pic18f4550

Lucas Pereira de Souza · 31 de março de 2018

Tudo bem pessoal, atualmente estou trabalhando em um projetinho, onde você pode calcular o tempo de defasagem de dois sinal, eu implementei o timer0 como um temporizador para armazenar um tempo de um determinado evento, exemplo, quando o pino ra1 e ra2 do pic ficar em 1 o timer0 dispara e a contagem do evento ocorre em mili segundos, e quando um desses pulso sair dessa condição eu saberei o tempo de defasagem, sendo assim, eu posso calcular o ângulo entre a corrente e a tensão por exemplo, inclusive eu fiz a conta na mão e dava certo, sendo assim, para confirmar se o timer0 que configurei estava certo eu fiz o seguinte teste:

código para provar que o timer0 zero estava funcionando corretamente.

            t0conbits.tmr0on = 1;           // timer0 ligado
               __delay_ms(5);                          // delay para confirmar se o timer esta correto
                x = timer0_carga();                   // rotina de armazenamento de tempo
                comando_lcd(0xc0);    // escrever na segunda linha do lcd
                printf("%f ms",x);                       // escrever a variavel x

ate ai tudo bem, consegui realizar esse procedimento, depois desse processo eu fiz a seguinte implementação, eu resolvi medir os dois sinal que entra no pic e contar esses pulso de entrada, que no caso seria dois pulso defasados em 30 graus, veja:

nesse caso seria aproximadamente 15.20 - 8 = 7,2ms, ate ai tudo bem então resolvi colocar isso em pratica, eu implementei a seguinte lógica.

while(sinal_tensao && sinal_corrente == 1)
        {
         t0conbits.tmr0on = 1;           // timer0 ligado
        }

        x = timer0_carga();           // desliga o timer0 e faz a conta para ms

        comando_lcd(0xc0);
        printf("%fms",x);

e para minha surpresa o microcontrolador não fez a contagem correta, e isso que me preocupa. veja:
agora vou postar o código completo para vocês analisarem, desculpe algumas palavras não ter acento, meu teclado e padrão inglês .

#include
#include
#include
#include
#include

/*observacão: o port do lcd e configurado no portd como os pinos de dados,(d4 a d7 no pino d4 a d7 do uc, e os pinos de comando
esta localizado porte, rs no port re0 e pino en no port re1 */
/*escreve segunda linha comando_lcd(0xc0);, escreve primeira linha linha comando_lcd(0x80); printf("lucas %f",v); recebe tipo de variavel e imprime no lcd*/
//%u valor inteiro
// pic18f4550 configuration bit settings

// config1l
#pragma config plldiv = 1 // pll prescaler selection bits (no prescale (4 mhz oscillator input drives pll directly))

// config1h
#pragma config fosc = hs // oscillator selection bits (hs oscillator (hs))

// config2l
#pragma config pwrt = on // power-up timer enable bit (pwrt enabled)

// config2h
#pragma config wdt = off // watchdog timer enable bit (wdt disabled (control is placed on the swdten bit))

// config3h
#pragma config pbaden = off // portb a/d enable bit (portb<4:0> pins are configured as analog input channels on reset)
#pragma config mclre = on // mclr pin enable bit (mclr pin enabled; re3 input pin disabled)

// config4l
#pragma config lvp = off // single-supply icsp enable bit (single-supply icsp enabled)

// config6h
#pragma config wrtc = off       // configuration register write protection bit (configuration registers (300000-3000ffh) are not write-protected)
#pragma config wrtb = off       // boot block write protection bit (boot block (000000-0007ffh) is not write-protected)
#pragma config wrtd = off       // data eeprom write protection bit (data eeprom is not write-protected)

//defiines
#define _xtal_freq    20000000
#define led_test      portebits.re2
#define sinal_tensao   portabits.ra1
#define sinal_corrente portabits.ra1
//end define

//prototipos funcoes
void pic_start();
void lcd_iniciar();                     //prototipo para iniciar lcd
void comando_lcd(char comandos);        //prototipo para comando do lcd
void lcd_dado(char dados);              //prototipo para dados do lcd
void putch(char escrita);               //prototipo padrão c para criar mais de um caracter no lcd
void timer0_config();
float timer0_carga();
//end prot

void interrupt my_isr_high(void) // interrupção de alta prioridade
{
}

void interrupt low_priority my_isr_low(void) // interrupção de baixa prioridade
{
}

void main()
{
    pic_start();        // inicia config do pic
    lcd_iniciar();      // inicia lcd
    timer0_config();    // inicia config do timer0

    float x = 0;        // variavel global

    printf("fator potencia:");      //escreve no lcd



    while(1)
   {

        while(sinal_tensao && sinal_corrente == 1)
        {
         t0conbits.tmr0on = 1;           // timer0 ligado
        }

        x = timer0_carga();           // desliga o timer0 e faz a conta para ms

        comando_lcd(0xc0);
        printf("%fms",x);


   }

}

void lcd_iniciar()
{
    ///////////////////////////////////////////////////////////////////////////
    //config inicial
    trisd = 0x00;               //todos portd como saida
    ///////////////////////////////////////////////////////////////////////////
    //inicializacão
    __delay_ms(15);        //aguarda 15ms para inicar o lcd

    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us

    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us

    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us

    //modo de configuração em 4bits
    comando_lcd(0x02); //iniciliza em modo 4bits
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x28); //iniciliza em modo 4bits duas linhas
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x01); //limpa o lcd
    __delay_ms(2);    //aguarda 2ms
    comando_lcd(0x0c); //liga o lcd sem o cursor
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x06); //deslocamento para direita
    __delay_us(40);     //aguarda 40us
    ///////////////////////////////////////////////////////////////////////////
}

void comando_lcd(char comandos)
{
    portebits.re0 = 0;                      //habilita lcd para comando, pino rs
    __delay_us(100);                        //aguarda 100us
    portd = (comandos & 0b11110000);        //portd envia o comando para lcd, nible mais significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
    portd = (comandos << 4)& 0b11110000;    //portd envia o comando para lcd, nible menos significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
}

void lcd_dado(char dados)
{
    portebits.re0 = 1;                      //habilita lcd para dados, pino rs
    __delay_us(100);                        //aguarda 100us
    portd = (dados & 0b11110000);           //portd envia o caracter para lcd, nible mais significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
    portd = (dados << 4)& 0b11110000;       //portd envia o caracter para lcd, nible menos significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
}

void putch(char escrita)
{
lcd_dado(escrita);
}

void pic_start()
{
    trisebits.trise0 = 0;       //todos porte como saida, exceto mclr para o reset
    trisebits.trise1 = 0;       //todos porte como saida, exceto mclr para o reset
    trisebits.trise2 = 0;       //todos porte como saida, exceto mclr para o reset
    portebits.re0 = 0;          //porte em zero
    portebits.re1 = 0;          //porte em zero
    portebits.re2 = 0;          //porte em zero
    trisabits.trisa1 = 1;       //ra1 como entrada
    trisabits.trisa2 = 1;       //ra2 como entrada
    portabits.ra1 = 0;          //porta em zero
    portabits.ra1 = 0;          //porta em zero

    adcon1bits.pcfg0 = 1;       //configurando todas portas do uc como digitais
    adcon1bits.pcfg1 = 1;       //configurando todas portas do uc como digitais
    adcon1bits.pcfg2 = 1;       //configurando todas portas do uc como digitais
    adcon1bits.pcfg3 = 1;       //configurando todas portas do uc como digitais

}

void timer0_config()
{
intconbits.gie = 0;    // desabilita todas interrupcoes mascaradas
intconbits.gieh = 0;   // desabilita todas interrupcoes de alta prioridade
intconbits.peie = 0;   // desabilita todas interrupcoes perifericas
intconbits.giel = 0;   // desabilita todas interrupcoes de baixa prioridade
intconbits.tmr0ie = 0; // bit de overflow do timer0 desligado
intconbits.tmr0if = 0; // bit timer0 limpo

//registrador t0con

t0conbits.tmr0on = 0;    // timer0 desligado
t0conbits.t08bit = 1;     // timer0 configurado como 8bit
t0conbits.t0cs = 0;     // timer0 configurado como temporizador
t0conbits.psa = 0;      // o prescaler foi associado ao timer0

t0conbits.t0ps0 = 1; // prescaler do timer 1:256
t0conbits.t0ps1 = 1;
t0conbits.t0ps2 = 1;

// carga do timer0

tmr0l = 0x00;
}

float timer0_carga()
{
    float result;

     t0conbits.tmr0on = 0;           // timer0 desligado
     intconbits.tmr0if = 0;       // limpa flag do timer0

      result = tmr0l;             // absorve a carga do timer0 na variavel result

      result = result*13.1072;    // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms

      result = result/256.0;      // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms

      tmr0l = 0x00;               // limpa a carga do timer0


    return result;
}

adicionado 8 minutos depois

Para facilitar o entendimento aqui esta o código em PDF.

Codigo.pdf

Lucas Pereira de Souza · 31 de março de 2018

#include 
#include 
#include 
#include 
#include 

/*observacão: o port do lcd e configurado no portd como os pinos de dados,(d4 a d7 no pino d4 a d7 do uc, e os pinos de comando 
 esta localizado porte, rs no port re0 e pino en no port re1 */
/*escreve segunda linha comando_lcd(0xc0);, escreve primeira linha linha comando_lcd(0x80); printf("lucas %f",v); recebe tipo de variavel e imprime no lcd*/
//%u valor inteiro
// pic18f4550 configuration bit settings

// config1l
#pragma config plldiv = 1       // pll prescaler selection bits (no prescale (4 mhz oscillator input drives pll directly))

// config1h
#pragma config fosc = hs        // oscillator selection bits (hs oscillator (hs))

// config2l
#pragma config pwrt = on        // power-up timer enable bit (pwrt enabled)

// config2h
#pragma config wdt = off        // watchdog timer enable bit (wdt disabled (control is placed on the swdten bit))

// config3h
#pragma config pbaden = off      // portb a/d enable bit (portb pins are configured as analog input channels on reset)
#pragma config mclre = on        // mclr pin enable bit (mclr pin enabled; re3 input pin disabled)

// config4l
#pragma config lvp = off         // single-supply icsp enable bit (single-supply icsp enabled)

// config6h
#pragma config wrtc = off       // configuration register write protection bit (configuration registers (300000-3000ffh) are not write-protected)
#pragma config wrtb = off       // boot block write protection bit (boot block (000000-0007ffh) is not write-protected)
#pragma config wrtd = off       // data eeprom write protection bit (data eeprom is not write-protected)

//defiines
#define _xtal_freq    20000000
#define led_test      portebits.re2 
#define sinal_tensao   portabits.ra1 
#define sinal_corrente portabits.ra1 
//end define

//prototipos funcoes
void pic_start();
void lcd_iniciar();                     //prototipo para iniciar lcd
void comando_lcd(char comandos);        //prototipo para comando do lcd 
void lcd_dado(char dados);              //prototipo para dados do lcd 
void putch(char escrita);               //prototipo padrão c para criar mais de um caracter no lcd
void timer0_config();
float timer0_carga();
//end prot


void interrupt my_isr_high(void)                // interrupção de alta prioridade
{
}

void interrupt low_priority my_isr_low(void)    // interrupção de baixa prioridade
{
}


void main() 
{
    pic_start();        // inicia config do pic
    lcd_iniciar();      // inicia lcd
    timer0_config();    // inicia config do timer0
    
    float x = 0;        // variavel global
            
    printf("fator potencia:");      //escreve no lcd
    
    
    
    while(1)
   {
  
        while(sinal_tensao && sinal_corrente == 1)
        {  
         t0conbits.tmr0on = 1; 	      // timer0 ligado 
        }
       
        x = timer0_carga();           // desliga o timer0 e faz a conta para ms    
            
        comando_lcd(0xc0);
        printf("%fms",x);
        
                   
   }
    
} 

void lcd_iniciar()
{ 
    ///////////////////////////////////////////////////////////////////////////
    //config inicial
    trisd = 0x00;               //todos portd como saida
    ///////////////////////////////////////////////////////////////////////////
    //inicializacão
    __delay_ms(15);        //aguarda 15ms para inicar o lcd
    
    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us
    
    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us
    
    comando_lcd(0x30);
    __delay_ms(5);    //aguarda 5ms
    comando_lcd(0x30);
    __delay_us(100);    //aguarda 100us
    comando_lcd(0x30);
    __delay_us(40);    //aguarda 40us
    
    //modo de configuração em 4bits
    comando_lcd(0x02);  //iniciliza em modo 4bits
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x28);  //iniciliza em modo 4bits duas linhas
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x01);  //limpa o lcd
    __delay_ms(2);    //aguarda 2ms
    comando_lcd(0x0c);  //liga o lcd sem o cursor
    __delay_us(40);     //aguarda 40us
    comando_lcd(0x06);  //deslocamento para direita
    __delay_us(40);     //aguarda 40us
    ///////////////////////////////////////////////////////////////////////////
}

void comando_lcd(char comandos)
{
    portebits.re0 = 0;                      //habilita lcd para comando, pino rs
    __delay_us(100);                        //aguarda 100us
    portd = (comandos & 0b11110000);        //portd envia o comando para lcd, nible mais significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
    portd = (comandos  4)& 0b11110000;    //portd envia o comando para lcd, nible menos significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
}

void lcd_dado(char dados)
{
    portebits.re0 = 1;                      //habilita lcd para dados, pino rs
    __delay_us(100);                        //aguarda 100us
    portd = (dados & 0b11110000);           //portd envia o caracter para lcd, nible mais significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
    portd = (dados  4)& 0b11110000;       //portd envia o caracter para lcd, nible menos significativo
    portebits.re1 = 1;                      //habilita pino enable
    portebits.re1 = 0;                      //desabilita pino enable
    __delay_us(100);                        //aguarda 100us
}

void putch(char escrita)
{
    lcd_dado(escrita);
}

void pic_start()
{
    trisebits.trise0 = 0;       //todos porte como saida, exceto mclr para o reset
    trisebits.trise1 = 0;       //todos porte como saida, exceto mclr para o reset
    trisebits.trise2 = 0;       //todos porte como saida, exceto mclr para o reset
    portebits.re0 = 0;          //porte em zero
    portebits.re1 = 0;          //porte em zero
    portebits.re2 = 0;          //porte em zero
    trisabits.trisa1 = 1;       //ra1 como entrada
    trisabits.trisa2 = 1;       //ra2 como entrada 
    portabits.ra1 = 0;          //porta em zero
    portabits.ra1 = 0;          //porta em zero
    
    adcon1bits.pcfg0 = 1;       //configurando todas portas do uc como digitais  
    adcon1bits.pcfg1 = 1;       //configurando todas portas do uc como digitais  
    adcon1bits.pcfg2 = 1;       //configurando todas portas do uc como digitais  
    adcon1bits.pcfg3 = 1;       //configurando todas portas do uc como digitais      
       
}

void timer0_config()
{
intconbits.gie = 0;    // desabilita todas interrupcoes mascaradas
intconbits.gieh = 0;   // desabilita todas interrupcoes de alta prioridade
intconbits.peie = 0;   // desabilita todas interrupcoes perifericas
intconbits.giel = 0;   // desabilita todas interrupcoes de baixa prioridade
intconbits.tmr0ie = 0; // bit de overflow do timer0 desligado
intconbits.tmr0if = 0; // bit timer0 limpo

//registrador t0con

t0conbits.tmr0on = 0; 	// timer0 desligado
t0conbits.t08bit = 1;  	// timer0 configurado como 8bit
t0conbits.t0cs = 0;     // timer0 configurado como temporizador
t0conbits.psa = 0;      // o prescaler foi associado ao timer0

t0conbits.t0ps0 = 1; 	// prescaler do timer 1:256
t0conbits.t0ps1 = 1;
t0conbits.t0ps2 = 1;

// carga do timer0

tmr0l = 0x00;
}

float timer0_carga()
{
    float result;
    
     t0conbits.tmr0on = 0; 	      // timer0 desligado
     intconbits.tmr0if = 0;       // limpa flag do timer0   
     

      result = tmr0l;             // absorve a carga do timer0 na variavel result
       
      result = result*13.1072;    // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms
       
      result = result/256.0;      // conversão do resultado do timer0 para milisegundos para crystal 20mhz 13ms
               
      tmr0l = 0x00;               // limpa a carga do timer0
        
      
    return result;
}

.if · 1 de abril de 2018

Perdão não analisei o código. Que tal se algo minimalista como...

//programe o timer0 e prescaler pra fração de mSeg pra leitura direta em result
while(!RA1);
TIMER0=0;
while(!RA2);
result=TIMER0;

Mede o tempo entre 2 eventos de subida em 2 pinos

Lucas Pereira de Souza · 1 de abril de 2018

7 horas atrás, Isadora Ferraz disse:
Perdão não analisei o código. Que tal se algo minimalista como...
//programe o timer0 e prescaler pra fração de mSeg pra leitura direta em result
while(!RA1);
TIMER0=0;
while(!RA2);
result=TIMER0;
Mede o tempo entre 2 eventos de subida em 2 pinos

Eu tentei usar essa lógica veja:
while(!SINAL_CORRENTE)
        {
           T0CONbits.TMR0ON = 1;
        }

        while(!SINAL_TENSAO)
        {
           T0CONbits.TMR0ON = 0;
        }
           w = timer0_carga();           // DESLIGA O TIMER0 E FAZ A CONTA PARA MS

Mesmo assim não deu certo, ele ate mostra no lcd o tempo, ma não importa a defasagem dos pulso o tempo sempre e o mesmo, e em relação ao prescaler, eu já tinha usado veja lá na prototipo timer0_config();

veja:

t0conbits.t0ps0 = 1; // prescaler do timer 1:256

t0conbits.t0ps1 = 1;

t0conbits.t0ps2 = 1;

No meu caso, meu timer0 faz contagem ate 13ms já que o pulso que quero medir e no máximo 8.3ms já e o suficiente.

.if · 1 de abril de 2018

ok. Pense como se você fosse o mc. Entre na cabecinha dele. Um treco que quebra o maior galho é você usar break points. Mande rodar e ele para onde você programou pra analisar os registros. Tambem rode passo a passo

Lucas Pereira de Souza · 2 de abril de 2018

22 horas atrás, Isadora Ferraz disse:

ok. Pense como se você fosse o mc. Entre na cabecinha dele. Um treco que quebra o maior galho é você usar break points. Mande rodar e ele para onde você programou pra analisar os registros. Tambem rode passo a passo

Eu fiz o que você falou, me parece que ele fica preso no while(sinal_tensao && sinal_corrente == 1), mas e muito esquisito, isso não deveria ocorrer, sendo assim, resolvi fazer o projeto em outro compilador e o erro persistiu, então resolvi ao invés de usar duas entrada no uC, utilizei uma porta and para pegar os dois sinal de entrada e mandar apnes um sinal de saída para eu poder calcular o tempo sem a necessidade do uC comparar dois sinal, e o mesmo problema persistiu, sendo assim, só Jesus na causa. Veja o código feito no mikroC e a nova implementação .



 // LCD module connections
sbit LCD_RS at RE0_bit;
sbit LCD_EN at RE1_bit;
sbit LCD_D4 at RD4_bit;
sbit LCD_D5 at RD5_bit;
sbit LCD_D6 at RD6_bit;
sbit LCD_D7 at RD7_bit;

sbit LCD_RS_Direction at TRISE0_bit;
sbit LCD_EN_Direction at TRISE1_bit;
sbit LCD_D4_Direction at TRISD4_bit;
sbit LCD_D5_Direction at TRISD5_bit;
sbit LCD_D6_Direction at TRISD6_bit;
sbit LCD_D7_Direction at TRISD7_bit;
// End LCD module connections

#define SINC RA0_bit
#define LED_TEST RE2_bit

void  pic_start();
float timer0_carga();
float tempo;

float numero[13];
 
   int i;
    
void main()
{
     pic_start();
     Lcd_Out(1,1,"FATOR POTENCIA");                //ESCREVE NO LCD PRIMEIRA LINHA

     while(1)
     {
     
      while(SINC == 1)
      {
      TMR0ON_bit = 1;
      }

      tempo = timer0_carga();
      
      FloatToStr(tempo,numero);
      lcd_out(2,1,numero);


     }
}

void pic_start()
{
    TRISD = 0x00;                      // TODOS PORTD COMO SAIDA
    Lcd_Init();                        // Initialize LCD
    Lcd_Cmd(_LCD_CLEAR);               // Clear display
    Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off

    TRISE2_bit = 0;                    //TODOS PORTE COMO SAIDA, EXCETO MCLR PARA O RESET
    RE2_bit = 0;                       //PORTE EM ZERO
    TRISA0_bit = 1;                    //PORT RA0 COMO ENTRADA
    TRISA1_bit = 1;                    //PORT RA1 COMO ENTRADA

 
    PCFG0_bit = 1;                     //ALL PORTS DIGITAL
    PCFG1_bit = 1;                     //ALL PORTS DIGITAL
    PCFG2_bit = 1;                     //ALL PORTS DIGITAL
    PCFG3_bit = 1;                     //ALL PORTS DIGITAL
    
    GIE_bit = 0;                       // DESABILITA TODAS INTERRUPCOES MASCARADAS
    GIEH_bit = 0;                      // DESABILITA TODAS INTERRUPCOES DE ALTA PRIORIDADE
    PEIE_bit = 0;                      // DESABILITA TODAS INTERRUPCOES PERIFERICAS
    GIEL_bit = 0;                      // DESABILITA TODAS INTERRUPCOES DE BAIXA PRIORIDADE
    TMR0IE_bit = 0;                    // BIT DE OVERFLOW DO TIMER0 DESLIGADO
    TMR0IF_bit = 0;                    // BIT TIMER0 LIMPO

    TMR0ON_bit = 0;                        // TIMER0 DESLIGADO
    T08BIT_bit = 1;                         // TIMER0 CONFIGURADO COMO 8BIT
    T0CS_bit = 0;                      // TIMER0 CONFIGURADO COMO TEMPORIZADOR
    PSA_bit = 0;                       // O PRESCALER FOI ASSOCIADO AO TIMER0

    T0PS0_bit = 1;                        // PRESCALER DO TIMER 1:256
    T0PS1_bit = 1;
    T0PS2_bit = 1;

    TMR0L = 0x00;                      // CARGA DO TIMER0 EM ZERO
    

}

float timer0_carga()
{
     float result;

     TMR0ON_bit = 0;               // TIMER0 DESLIGADO
     TMR0IF_bit = 0;

     result = TMR0L;

     result = result*13.1072;

     result = result/256.0;

     TMR0L = 0x00;

     return result;
}

.if · 2 de abril de 2018

Considere sua imagem

Essencialmente você quer medir a diferença do tempo entre os 2 pulsos de subida "azul - vermelho". né isso? Pra mim isso é a diferença de fase. Algo como:

//deixe o timer0 rodando bobo.
signed char result;
while(!vermelho);
TMR0=0;
while(!azul);
result=TMR0;

Pra medir aquele tempo de 8mS, refaça a "análise temporal dos bits" (inventei isso agora)

Claro, vai travar na ausência de sinal. Implemente um timeout se achar que deve.

Lucas Pereira de Souza · 9 de abril de 2018

Em 02/04/2018 às 08:13, Isadora Ferraz disse:
Considere sua imagem

Essencialmente você quer medir a diferença do tempo entre os 2 pulsos de subida "azul - vermelho". né isso? Pra mim isso é a diferença de fase. Algo como:
//deixe o timer0 rodando bobo.
signed char result;
while(!vermelho);
TMR0=0;
while(!azul);
result=TMR0;
Pra medir aquele tempo de 8mS, refaça a "análise temporal dos bits" (inventei isso agora)

Claro, vai travar na ausência de sinal. Implemente um timeout se achar que deve.

No fim consegui fazer a leitura do sinal, utilizei o modo ccp em borda de subida de borda de descida, sendo assim o timer1 armazena o tempo do pulso na interrupção do modulo ccp, veja:

void interrupt()
{
//BORDA DE DESCIDA
if(CCP1IF_bit == 1 && CCP1M0_bit == 1 && CCP1M1_bit == 0 && CCP1M2_bit == 1 && CCP1M3_bit == 0)
{
CCP1IF_bit = 0;    // LIMPAR FLAG DE INTERRUPCÃO
CCP1IE_bit = 0;    // DESABILITAR INTERRUPCÃO

CCP1M0_bit = 0;    // CCP MODO DE EM BORDA DE DESCIDA
CCP1M1_bit = 0;
CCP1M2_bit = 1;
CCP1M3_bit = 0;

CCP1IE_bit = 1;    // HABILITAR INTERRUPCÃO

TMR1H = 0x00;
TMR1L = 0x00;

TMR1ON_bit = 1;    // LIGAR O TIMER1
}
//BORDA DE SUBIDA
else if(CCP1IF_bit == 1 && CCP1M0_bit == 0 && CCP1M1_bit == 0 && CCP1M2_bit == 1 && CCP1M3_bit == 0)
{
   CCP1IF_bit = 0;    // LIMPAR FLAG DE INTERRUPCÃO
   TMR1ON_bit = 0;    // TIMER1 DESLIGADO
   CCP1IE_bit = 0;    // DESABILITA INTERRUPCÃO

   CCP1M0_bit = 1;    // CCP MODO DE EM BORDA DE SUBIDA
   CCP1M1_bit = 0;
   CCP1M2_bit = 1;
   CCP1M3_bit = 0;

   CCP1IE_bit = 1;    // HABILITA INTERRUPCÃO

   tempo_H = CCPR1H;
   tempo_L = CCPR1L;
}