CCS/MSP432P401R: Timer A - Capture Mode for ultrasonic sensor HC-SR04

If you're talking about the code at 

https://e2e.ti.com/support/microcontrollers/msp430/f/166/t/607119

It looks as though he hadn't quite finished with it.

Those values are in units of SMCLK ticks where SMCLK=3MHz (333nsec). meas1 isn't all that useful in itself, what's interesting is the pulse width, which is the difference ((meas2-meas1)&0xFFFF), which goes into a formula in the data sheet. I (vaguely) recall that formula needs usec, so you'll need to divide by 3.

Thank you, yes that is the code I was referring to. 

My problem now is that I am never detecting a falling edge so I don't enter the else loop and get a meas2. Is there something else I have to wire or code to detect P2IN&0x10? Here is the interrupt loop for reference:

> TIMER_A_CAPTUREMODE_RISING_EDGE,          // Rising Edge and falling

I suspect he intended:

> TIMER_A_CAPTUREMODE_RISING_AND_FALLING_EDGE, // Rising Edge and falling

With that fix I'm getting both rising and falling measurements. The data sheet has this conversion formula:

Test distance = (high level time×velocity of sound (340M/S) / 2,

I do the conversion in my code with these lines:

int diff=((meas2-meas1)&0xFFFF);
//int distCM=(diff/3000000)*340/2;
int distCM=(diff*170)/3000000;
printf("Distance: %i cm \n",distCM);

I am only getting values between 0-3cm whether I hold the sensor still or move it back and forth. The inconsistency in values holding it still make me believe my issue is not conversion. Also, there is a lot of lagging in the code and when I pause it, it's usually in the delay loop.

Here's and example what I get with holding still or moving the sensor:

Measure 2 19599

Distance: 1 cm

Measure 1 40528

Distance: 2 cm

Measure 2 32299

Distance: 3 cm

Measure 1 7705

Distance: 1 cm

Measure 2 29517

Distance: 1 cm

Measure 2 54117

Distance: 2 cm

Measure 1 9145

Distance: 2 cm

Measure 2 59060

Distance: 2 cm

Measure 1 32526

Distance: 1 cm

Measure 2 32498

Distance: 3 cm

Measure 1 22439

Distance: 0 cm

Measure 2 11283

Distance: 3 cm

Measure 1 59847

1) The first datasheet I found suggested the formula cm = usec/58, i.e. 1 cm is 58 usec. This is the same formula as you're using, but in a simpler form. Since each tick is 1/3 usec, it would be cm = ticks/3/58. I mention this since your formula is probably truncating based on the large (3M) divisor. I suggest you use the simpler formula for now.

2) Your code seems to produce a result after every capture, which doesn't look quite right. After you send the pulse, you should get two captures and only then can you produce a useful result. As a result I suspect you're getting very large (false)  differences which (just barely) make it through the truncation in (1). Where in the code did you insert the arithmetic?

3) The Delay function uses a for() loop for a delay, which is notoriously unreliable. I suggest you get rid of all the Delay calls and replace them with something like:

#define  HZ   24000000UL    // 24MHz from CS_DCO_FREQUENCY_24

__delay_cycles(HZ/2);     // delay for a half-second.

Thanks for helping me work through this. After implementing your three suggestions this is what my code looks like now:

#include "driverlib.h"
#include <stdint.h>

#define  HZ   24000000UL    // 24MHz from CS_DCO_FREQUENCY_24

/* Timer_A Continuous Mode Configuration Parameter */
const Timer_A_ContinuousModeConfig continuousModeConfig =
{
        TIMER_A_CLOCKSOURCE_SMCLK,           // SMCLK Clock Source
        TIMER_A_CLOCKSOURCE_DIVIDER_1,       // SMCLK/1 = 3MHz
        TIMER_A_TAIE_INTERRUPT_DISABLE,      // Disable Timer ISR
        TIMER_A_SKIP_CLEAR                   // Skup Clear Counter
};

/* Timer_A Capture Mode Configuration Parameter */
const Timer_A_CaptureModeConfig captureModeConfig =
{
        TIMER_A_CAPTURECOMPARE_REGISTER_1,        // CC Register 2
        TIMER_A_CAPTUREMODE_RISING_AND_FALLING_EDGE, // Rising Edge and falling TIMER_A_CAPTUREMODE_RISING_EDGE,          // Rising Edge and falling
        TIMER_A_CAPTURE_INPUTSELECT_CCIxA,        // CCIxA Input Select
        TIMER_A_CAPTURE_SYNCHRONOUS,              // Synchronized Capture
        TIMER_A_CAPTURECOMPARE_INTERRUPT_ENABLE,  // Enable interrupt
        TIMER_A_OUTPUTMODE_OUTBITVALUE            // Output bit value
};

int meas1 = 0;
int meas2 = 0;
int meas1Count=0;
int takeVal=0;

int main(void)
{
    /* Stop watchdog timer */
    MAP_WDT_A_holdTimer();

    CS_setDCOCenteredFrequency(CS_DCO_FREQUENCY_24);                    // 24000000 Hz

    CS_initClockSignal(CS_MCLK,  CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_1); // 24000000 Hz
    CS_initClockSignal(CS_SMCLK, CS_DCOCLK_SELECT, CS_CLOCK_DIVIDER_8); //  3000000 Hz

    /* Configuring P2.4 as peripheral input for capture */
    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P2, GPIO_PIN4, GPIO_PRIMARY_MODULE_FUNCTION);
    GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN5);

    /* Configuring Capture Mode */
    Timer_A_initCapture(TIMER_A0_BASE, &captureModeConfig);

    /* Configuring Continuous Mode */
    Timer_A_configureContinuousMode(TIMER_A0_BASE, &continuousModeConfig);

    /* Enabling interrupts */
    Interrupt_enableInterrupt(INT_TA0_N);
    Interrupt_enableMaster();

    /* Starting the Timer32 */
    Timer32_initModule(TIMER32_0_BASE, TIMER32_PRESCALER_1, TIMER32_32BIT, TIMER32_PERIODIC_MODE);
    Timer32_disableInterrupt(TIMER32_0_BASE);
    Timer32_setCount(TIMER32_0_BASE, 1);
    Timer32_startTimer(TIMER32_0_BASE, true);

    /* Starting the Timer_A0 in continuous mode */
    Timer_A_startCounter(TIMER_A0_BASE, TIMER_A_CONTINUOUS_MODE);
    while(1)
    {
        GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN5);
        Timer32_setCount(TIMER32_0_BASE, 24 * 10);
        while (Timer32_getValue(TIMER32_0_BASE) > 0); // Wait 10us
        GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN5);                //software delays
        __delay_cycles(HZ/2);     // delay for a half-second.
//        __delay_cycles(HZ/2);     // delay for a half-second.
//        __delay_cycles(HZ/2);     // delay for a half-second.
//        __delay_cycles(HZ/2);     // delay for a half-second.
//        __delay_cycles(HZ/2);     // delay for a half-second.
//        __delay_cycles(HZ/2);     // delay for a half-second.

        if (takeVal==1){
            takeVal=0;
            int diff=((meas2-meas1)&0xFFFF);
            //int distCM=(diff/3000000)*340/2;
            //int distCM=(diff*170)/3000000;
            int distCM=(diff/3)/58;
            printf("Distance: %i cm \n",distCM);
        }

    }
}

void TA0_N_IRQHandler(void)
{
    int rising  = 0;

    Timer_A_clearCaptureCompareInterrupt(TIMER_A0_BASE,
            TIMER_A_CAPTURECOMPARE_REGISTER_1);

    if(P2IN&0x10) rising=1; else rising=0;

    if(rising) // Start
    {
        meas1 = Timer_A_getCaptureCompareCount(TIMER_A0_BASE, TIMER_A_CAPTURECOMPARE_REGISTER_1);
        printf("Measure 1 %i \n",meas1);
        meas1Count=1;
    }
    else
    {
        meas2 = Timer_A_getCaptureCompareCount(TIMER_A0_BASE, TIMER_A_CAPTURECOMPARE_REGISTER_1);
        printf("Measure 2 %i \n",meas2);
        if (meas1Count==1){ //if meas1 has been collected
            meas1Count=0; //reset meas1 count
            takeVal=1; //flag for conversion
        }
    }
}

When I comment out the meas1 and meas2 prints this is a typical output:

Distance: 0 cm 
Distance: 137 cm 
Distance: 147 cm 
Distance: 144 cm 
Distance: 135 cm 
Distance: 227 cm 
Distance: 136 cm 
Distance: 222 cm 
Distance: 131 cm 
Distance: 133 cm 
Distance: 134 cm 
Distance: 129 cm 
Distance: 228 cm 
Distance: 237 cm 
Distance: 135 cm

When I keep the print statement in this is a typical output:

Measure 1 1 
Measure 2 11537 
Distance: 66 cm 
Measure 1 47626 
Measure 2 55703 
Distance: 46 cm 
Measure 1 27494 
Measure 2 29699 
Measure 1 23192 
Measure 2 65385 
Measure 1 8440 
Measure 2 16585 
Measure 1 24577 
Measure 2 32799 
Measure 2 427 
Measure 1 59435 
Measure 2 1113 
Measure 2 33962 
Measure 1 43383 
Measure 1 10885 
Measure 2 2588 
Measure 1 61997 
Measure 1 45161 
Measure 1 27988 
Measure 1 11263 
Measure 2 3016 
Measure 2 51416 
Measure 2 33972 
Measure 2 43254 
Measure 2 26443 
Measure 1 35817 
Measure 1 33857 
Measure 1 1960 
Measure 1 345 
Measure 1 48697 
Measure 1 31889 
Measure 2 53372 
Measure 1 63311 
Measure 1 15686 
Measure 1 48716 
Measure 2 40190 
Measure 2 23186 
Measure 1 32531 
Measure 2 39627 
Measure 1 33550 
Measure 2 55807 
Measure 2 53844 
Measure 1 13498 
Measure 1 62052 
Measure 1 44944 
Measure 1 12568 
Measure 1 45714 
Measure 1 13870 
Measure 1 46865 
Measure 2 4102 
Measure 2 52800 
Measure 1 60952 
Measure 2 18678 
Measure 2 51661 
Distance: 323 cm 

I've been playing around with how many half second delays to add to the code in an attempt to get more consistent/reliable measurements. Is there a more methodical method than guess and check? Also, I know print statements slow down the code, but I don't know why there would be multiple rising measurements and falling measurements in a row.