Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
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

Editado por Lucas Pereira de Souza

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
Postado (editado)
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

Editado por Lucas Pereira de Souza

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






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

×