Measuring boat speed (Part 2)

In the previous post, I described in a general way how the boat speed is measured. I present here the part of the microcontroller code that is used for this task.

volatile uint16_t icp3_start_time;
volatile uint16_t icp3_period;
volatile uint8_t zero_flag;

double boat_speed;
uint16_t period3;
uint8_t sreg;

/*
 * This interrupt routine is called each time
 * a new pulse rising edge is detected
 */
ISR(TIMER3_CAPT_vect)
{
   uint16_t icr3;
   uint16_t test_period;

   /*
    * Make a copy of the timer value saved in the ICR3 register
    * when the rising edge of the pulse occured
    */
    icr3 = ICR3;

   if(zero_flag)  // this is the first pulse of a new series
   {

      /*
       * Save the start timestamp in a global variable
       * for further use
       */
       icp3_start_time = icr3;

      /*
       * Push the timeout window forward by moving the OCR3A timeout
       * value just behind the capture timestamp so that the timer
       * will have to go through nearly a whole cyle before reaching OCR3A
       */
       OCR3A = icr3 - 100;

      /*
       * Next time, go to the 'else' section to calculate the time
       * interval unless a timeout has occured meanwhile, setting back
       * the zero_flag to 1
       */
       zero_flag = 0;
    }
    else
    {
       /*
        * Calculate the number of timer ticks since the last pulse
        */
        test_period = icr3 - icp3_start_time; // length of previous period

       /*
        * This is a debouncing test that is probably not required, but
        * safe to keep. If icp_period is less than 200, this means that
        * the nominal boat speed will be calculated at more than 16.6 knots,
        * an indication of a false or noisy pulse that should be discarded
        */
        if(test_period > 200)   // if we have a good pulse
        {
           icp3_period = test_period;
           icp3_start_time = icr3;    // icr3 becomes the new start time
           OCR3A = icr3 - 100;     // move the timeout window
        }
    }
}

¸

/*
 * This interrupt routine is called when the timeout
 * period is reached, i.e. TCNT3 = OCR3A (boat speed less than 0.05 knot)
 */
ISR(TIMER3_COMPA_vect)
{
   // tell everyone that we have a zero speed
   zero_flag = 1;
}

void init_timer(void)
{
   // Set timer/counter 3 with a prescale of 1024
   // and with input capture on rising edge
   TCCR3B = _BV(ICES3) | _BV(CS32)| _BV(CS30);
   TCNT3 = 0;    // initialize timer/counter 3
   ETIMSK |= _BV(TICIE3);    // enable input capture interrupt

   OCR3A = 0;  // inialize timeout value
   ETIMSK |= _BV(OCIE3A); // enable output compare interrupt
}

int main(void)
{
   // ...

   zero_flag = 1;

   init_timer();

   /* enable interrupts */
   sei();

   boat_speed = 0.0;

   for(;;)
   {
     // begin a new cycle

     // ...

     // calculate the measured boat speed
     if(zero_flag)
        boat_speed = 0.0;
     else
     {
        sreg = SREG;
        cli();  // disable interrupts while we transfer a volatile 16-bit value
        period3 = icp3_period;
        SREG = sreg;  // re-enable interrupts

        boat_speed = 1.0 / (period3 * 0.000064 * 4.7);

        // get the calibration correction factor
        // ...

        // apply the calibration correction factor
        boat_speed *= calbat;

     }

     // put the result in the data structure
     dump_info.mbs1 = boat_speed;

     // ...

     // Wait for timer signal to begin a new cycle

     // ...
   }

}