Ir ao conteúdo
  • Cadastre-se
Lucas Pereira de Souza

PIC RESOLVIDO calcular defasagem de sinal no pic18f4550

Recommended Posts

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:
5abfeabf41e81_Semttulo23.png.223790ca04428899c999703454e69c02.png

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:

5abfec6a90936_Semttulo24.png.81868f0559b46aa0d010a5c4ece9f4ca.png

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:5abfefcb827ad_Semttulo25.thumb.png.efe286cc5d07330e523a96f1373f6d45.png
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

Compartilhar este post


Link para o post
Compartilhar em outros sites
#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;
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

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

Compartilhar este post


Link para o post
Compartilhar em outros sites
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;
}

5ac1f82d64dc0_Semttulo.thumb.png.6eade81a5f5ee96c3bdb4b3cb1b2f979.png

Compartilhar este post


Link para o post
Compartilhar em outros sites

Considere sua imagem

Sem título24.png

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.

 

 

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 02/04/2018 às 08:13, Isadora Ferraz disse:

Considere sua imagem

Sem título24.png

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;
  }

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
8 minutos atrás, Lucas Pereira de Souza disse:

No fim

... tudo dá certo. Se não deu certo ainda é porquê não é o fim.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×