time between two edges pic 18f4550

Question

I would like to calculate the time interval between two rising edges of two different signals using the two CCP modules from pic 18f4550. The idea of ​​calculation is illustrated in the following figures.

The simulation works fine, but my electrical circuit is not. I don't know if there is something wrong with my code. If anyone has an answer or a clue to fix this, I will be grateful! And if you have any questions, please feel free to ask.

#pragma config FOSC = INTOSC_EC
#define _XTAL_FREQ 8000000

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "LCD_8bit_file.h"
#include <string.h>

unsigned long comtage, capt0, x;
char DEPHASAGE[20];
char pulse[20];
float period, dephTempo, deph, phi;

void main()
{
    IRCF0 = 1;     /* set internal clock to 8MHz */
    IRCF1 = 1;
    IRCF2 = 1;  
    
    LCD_Init();
    
    LCD_String_xy(0, 1, "Dephasage[rad]"); 
 
    T3CONbits.RD16 = 1;  
    T3CKPS0 = 0;
    T3CKPS1 = 0;
    TMR3CS = 0;
    
    TMR3IF = 0; 
      
    while (1)        
    {    
        CCP2CON         = 0b00000101;
        CCP1CON         = 0b00000101;
        PIR2bits.CCP2IF = 0;
        PIR1bits.CCP1IF = 0;
        TMR3ON          = 0; 
        TMR3            = 0;

        if (PIR1bits.CCP1IF == 1) {
            TMR3ON          = 1; 
    
            while (!PIR2bits.CCP2IF); 
            comtage = TMR3; 
            dephTempo = (((float)comtage / 30.518) / 65536); 
    
            sprintf(pulse,"%.3f  ", dephTempo);
            LCD_String_xy(0, 0, "Dephasage : ");
            LCD_String_xy(2, 9, pulse);
        }
    }
}                              

Answer 1

When you test a schematic using a real circuit, other issues will appear, like capacitive and resistive parasitics and that will after the timings. Also, can have jitter noise. If you a have an oscilloscope, try to figure out if there is too much noise. Try do add a pull-down/pull-up on those lines, make sure you have good ground connection. But after looking for your code, you should take an approach similar to CTC: You make fast samples of your input signal and then you check your sampled array, if there is more one than zeros, you caught an edge trigger.

Answer 2

I have a better scenario for your application to implement. But first let's talk about the bad practices in your code.

1. In your main while loop you setup the CCP modules:

   CCP2CON         = 0b00000101;
   CCP1CON         = 0b00000101;
   PIR2bits.CCP2IF = 0;
   PIR1bits.CCP1IF = 0;
   TMR3ON          = 0; 
   TMR3            = 0;
   

   You better do this before the program enters to the infinite while loop.

2. You handle the timer reads directly while the CCP module captures its value in which the edge you configured it to capture.

   comtage = TMR3;
   

3. I don't see that you configure the CCP pins as inputs. You have to configure them as inputs by setting the corresponding TRIS bits in order to have them working properly.

So the structure of my recommended scenario would be something like this:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "LCD_8bit_file.h"
#include <string.h>

unsigned long comtage, capt0, x;
char DEPHASAGE[20];
char pulse[20];
float period, dephTempo, deph, phi;


/******************** Utility funcs ********************/
void setupSysClock() {
    IRCF0 = 1;     /* set internal clock to 8MHz */
    IRCF1 = 1;
    IRCF2 = 1;
}

void setupCCP1withTMR1() {
    CCP1CON         = 0b00000101;
    PIR1bits.CCP1IF = 0;
    TRISCbits.TRISC2 = 1; // set CCP1 pin as input
}

void setupCCP2withTMR3() {
    CCP2CON         = 0b00000101;
    PIR2bits.CCP2IF = 0;
    
    // T3 goes for CCP2 and CCP1, PS 1:1, internal CS
    T3CON = (1 << T3CCP2) | (0 << T3CKPS1) | (0 << T3CKPS0) | (1 << T3CCP1) | (0 << TMR3CS);
    TMR3 = 0;
    
    // In config bits you must choose RC1 pin for the CCP2 if necessary although it so by default
    TRISCbits.TRISC1 = 1 // set CCP2 pin as input
}

void rearm() {
    CCP1CON = 0x5
    CCP2CON = 0x5
    PIR1bits.CCP1IF = 0;
    PIR2bits.CCP2IF = 0;
    TMR3 = 0;
    TMR3ON = 1;
}

void suspend() {
    CCP1CON = 0;
    CCP2CON = 0;
}


void main()
{
    setupSysClock(); // setu internal clock
    
    setupCCP1withTMR1(); // setup CCP1 for capture mode 
    
    setupCCP2withTMR3(); // setup CCP1 for capture mode with TMR3
    
    LCD_Init();
    
    LCD_String_xy(0, 1, "Dephasage[rad]"); 
 
    
    while (1)        
    {   
        while(!CCP2IF); // Wait for the second rising edge
        // Event has occured process, first make sure that the CCP1 rised first
        if(!CCP1F) {
            // An invalid sequence occured ignore and rearm. Note that the sequence of signals is important.
            rearm();
            continue;
        }
        /* The sequence is correct let's process the event. Here you will have
        two captured value in CCPR1 and CCPR2 registers. First one is the captured value of the T3 when the first rising event occured. Second one is the captured value of the T3 when the second rising event occured. You have to get the delta of the two captured values first. This delta value is the elapsed ticks between the two discrete rising input signals. This is what the capture hardware is made for ;)
        Now first we shuld suspend the CCP modules to avoid unwanted captures
        while we process the previous value. Because if another capture occures
        before we process the previous value, the new capture value will be
        overwritten over the old value that we need for computation.
        */
        suspend(); // suspend the CCP modules while processing
        uint16_t timeDelta = CCPR2 - CCPR1; // Calculate the difference
        
        dephTempo = (((float)timeDelta / 30.518) / 65536); 

        sprintf(pulse,"%.3f  ", dephTempo);
        LCD_String_xy(0, 0, "Dephasage : ");
        LCD_String_xy(2, 9, pulse);
        
        // Now that we finished processing we can rearm the CCP for new captures
        rearm();
    }
}                              

I wrote this code in an editor and haven't compiled in MPLAB. So you must compile and test the code. You can give me a feedback for me to help further.

One important thing to note: If the amount of time between two signals is large, you must either increment the prescaler of Timer3 or you must use a complementary variable for TMR3 register in case it overflows.