AVRFreaks.net

//   Flowmeter polling/debouncing/pulse counting
//   ===========================================
//
//   Up to 6 pulse-output flowmeters (on PC1-PC6) are polled,
//   debounced in parallel, and changed edges "counted" in the
//   fast timer ISR.
//
//   With 7.37MHz, /8, and 0xe5 KAVRCALC gives very close to 250us period.
//   This is nearly identical to continuous ADC conversions at 57kHz ADC clock,
//   and USART comms at 38.4kbps.  The aim is to keep the ISR about the
//   same time as a general ADC or UART ISR.
//

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 460.800 kHz
// Mode: CTC top=OCR0A
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x02;
TCCR0B=0x02;
TCNT0=0x00;
OCR0A=0xE5;   // ~250us at /8, 7.37MHz
OCR0B=0x00;

...
// **************************************************************************
// *
// *      T I M E R 0 _ C O M P A _ I S R
// *
// **************************************************************************
//
// Sampling routine for flow sensor channels.
//
// Timer 0 output compare A interrupt service routine
interrupt [TIM0_COMPA] void timer0_compa_isr(void)
{
// Stage 2 (signal_bounce2) removed--add in if another stage is needed

   signal_work = signal_bounce3;      // move prior states closer to validated

   signal_bounce3 = signal_bounce1;
   signal_bounce1 = (PINC) & FLOW_MASK;// get the new strobe data -- "signal_fetch()"

   signal_bounce1 ^= signal_current;   // only concerned with changes from current

   signal_work &= signal_bounce1;      // make sure there are no bounces
   signal_work &= signal_bounce3;
   signal_current ^= signal_work;      // make validated changes to current
   signal_bounce1 ^= signal_work;      //  and remove from pending stages
   signal_bounce3 ^= signal_work;

//   signal_edge = signal_work & signal_current;      // only want "on" transitions
// Flip-flop divides by two, so count both edges

//   signal_edge = signal_work;  // NOTE: could eliminate one of these...

   if (signal_work & FLOW_1_MASK)
      {
      chan_raw[0]++;
      }
// Channels 4 & 6 are swapped on the board--adjusted in FLOW_n_MASK
   if (signal_work & FLOW_2_MASK) chan_raw[1]++;
   if (signal_work & FLOW_3_MASK) chan_raw[2]++;
   if (signal_work & FLOW_4_MASK) chan_raw[3]++;
   if (signal_work & FLOW_5_MASK) chan_raw[4]++;
   if (signal_work & FLOW_6_MASK) chan_raw[5]++;

}

... below is done every 100ms, calculating new values (to be applied to DAC in this app)

// Capture new channel counts from _raw
      for (looper = 0; looper < NUM_CHANNELS; looper++)
         {
         // Get a channel count for the last 100ms, and clear.
         //   8-bit value allows for 256x10=2560Hz; way more than spec.
         #asm ("cli")
         chan_samples[looper][clicks] = chan_raw[looper];
         chan_raw[looper] = 0;
         #asm ("sei")

         chan_total[looper] = 0;   // init for the summing below
         }

// Calculate the full-second totals-- Hertz
      ptr = chan_samples[0];
      iptr = chan_total;

      grand_total = 0;

      for (looper = 0; looper < NUM_CHANNELS; looper++)
         {
         // Unroll the loop CLICKS_PER_SECOND times (should be faster than nested loop)
         //  Revised to nested loop
         for (scratch = 0, worknum = 0; scratch < CLICKS_PER_SECOND; scratch++)
            {
            worknum += *ptr++;
            }
         *iptr++ = worknum;
         grand_total += worknum;
         }

// Calculate the DAC output value
//   (could be merged into the loops above)
      iptr = chan_total;
      for (looper = 0; looper < NUM_CHANNELS; looper++)
         {
         // Get 4mA and 20mA 16-bit count numbers into register variables
         workmin = ee_min[looper];
         workmax = ee_max[looper];

         // Note:  ee_setpoint (for the 20mA max value) is in Hertz*10
         worknum = ee_setpoint[looper];


// calculate setpoint in 32-bit for overflow purposes
         worklong.u32 = (DAC_MAX * 10ul) * (unsigned long)*iptr / worknum;

         if (worklong.u32 > DAC_MAX)
            {
            chan_setpoint[looper] = DAC_MAX;
            }
         else
            {
            chan_setpoint[looper] = worklong.u16[0]; // low 16 bits
            }

         iptr++;
         }

//
// Interrupt vectors
//

// 10ms. Timer Tick
interrupt [TIM0_COMPA]   void   timer0_compa_isr   (void);

// External Interrupt 1 service routine -- FLOW2 using INT1
interrupt [EXT_INT1]   void   ext_int1_isr      (void);

// External Interrupt 0 service routine -- FLOW1 using INT0
interrupt [EXT_INT0]   void   ext_int0_isr      (void);

// Analog Comparator interrupt service routine  -- FLOW4 using AIN1
interrupt [ANA_COMP]   void   ana_comp_isr      (void);

// Timer1 used as counter -- FLOW3 using T1
//   (no ISR needed for each count; TCNT1 read/cleared every 10ms)

...
//
// **************************************************************************
// *
// *      F L O W M E T E R   P U L S E   C O U N T I N G   I S R S
// *
// **************************************************************************
//
//   If a flowmeter ISR takes 5us to service and there are 4 active,
//   and to use no more than ~50% of CPU (USART is continually going),
//   then about 40ksps total is comforatble or 10ksps/flowmeter.
//
//   Typical flowmeters are about 100pps so this is no problem.  In
//   addition, channel 4 uses T1 and can handle rates into the Msps range.
//

// External Interrupt 1 service routine -- FLOW2 using INT1
interrupt [EXT_INT1] void ext_int1_isr(void)
{
   flow2++;
}

// External Interrupt 0 service routine -- FLOW1 using INT0
interrupt [EXT_INT0] void ext_int0_isr(void)
{
   flow1++;
}

// Timer1 used as counter -- FLOW3 using T1
//   (no ISR needed for each count; TCNT1 read/cleared every 10ms)

// Analog Comparator interrupt service routine  -- FLOW4 using AIN1
interrupt [ANA_COMP] void ana_comp_isr(void)
{
   flow4++;
}
... every 10ms, update the per-channel running 32-bit counts for the master's flow
// ***********
// Flowmeter interval counters
// ***********
//

// Flowmeter 1 -- INT1 rising edges
      #asm ("cli")
      worknum = flow1;
      flow1 = 0;
      #asm ("sei")
      flow1_counts += worknum;

// Flowmeter 2 -- INT0 rising edges
      #asm ("cli")
      worknum = flow2;
      flow2 = 0;
      #asm ("sei")
      flow2_counts += worknum;

// Flowmeter 3 -- T1 rising edges (timer1 as counter; TCNT1)
      #asm ("cli")
      retval = TCNT1L;   // read low first, then high
      scratch = TCNT1H;
      TCNT1H=0x00;        // write high first, then low
      TCNT1L=0x00;
      #asm ("sei")
      worknum = ((unsigned int) scratch << 8) | retval;
      flow3_counts += worknum;

// Flowmeter 4 -- AIN1 rising edges
      #asm ("cli")
      worknum = flow4;
      flow4 = 0;
      #asm ("sei")
      flow4_counts += worknum;

// Store in om_frames[] to reply to the master with the per-channel running counts
      om_frames[0].u32 = flow1_counts;
      om_frames[1].u32 = flow2_counts;
      om_frames[2].u32 = flow3_counts;
      om_frames[3].u32 = flow4_counts;