>I have a working 16 bit timer but now find that at low freq's we
are
> getting overflow so I need to go to a 32 bit timer
interrupt driven.
> Of course the ECT is 16 bit, so is this as simple as implementing an
> interrupt on the timer overflow and  adding 10000 to a time count each
> time and then finally adding the capture timer to the 32 bit count on
> the final edge?

IMO it doesn't make sense to use TOV interrupt to generate long pulses or 
periods. It's way easier to count 16bit overflows in TCx interrupts.
	setup_for_long_delay()
{
   TCx= t0 + loword(ticks);
   if(hiword(ticks) ==0) {TCTL=} // in case ticks < 2^16 next OC event is
                                                    // the target event
   clearTCxflag();
}

TCxISR()
{
    // don't update TCx, just clear flag, and interrupt will fire every 
0x10000 ticks

   if(hiword(ticks)) hiword(ticks) = hiword(ticks) - 1; // overflows counter
   if(hiword(ticks) ==0) {TCTL=}    // after overflows counter reached 0 - 
next OC
                                                        // event will be the 
target event
    clearTCxflag();
}
	Above pseudocode is oversimplified. loword(ticks) close to 0 are 
troublesome. Interrupts latency or code execution time may make your 
flagclear() too late. In case ticks&0xffff is very small I do divide 
overflow period (2^16) into two halves and generate first interrupt at 
t0+(0x8000+loword(ticks)), second interrupt at TCx+0x8000, further 
interrupts (if any) every TCx+0x10000.

char overhead;
#define minOCxperiod nnn

setup_for_long_delay()
{
   if(loword(ticks)<minOCperiod)
  {
      overhead=1;
      TCx = t0 + (0x8000 + loword(ticks));
   }
   else
   {
       overhead=0;
      TCx= t0 + loword(ticks);
   }
   if(hiword(ticks) ==0  && !overhead) {TCTL=}
                                         // in case ticks < 2^16 next OC 
event is
                                         // the target event
   clearTCxflag();
}

TCxISR()
{
   if(overhead) TCx +=0x8000;

   if(hiword(ticks)) hiword(ticks) = hiword(ticks) - 1; // overflows counter
   if(hiword(ticks) ==0) {TCTL=}    // after overflows counter reached 0 - 
next OC
                                                        // event will be the 
target event
    clearTCxflag();
}
	>
> I have to also drive a pin with the same freq
captured and I am not
> sure of the sync issues. How do you use the input timer over flow
> interrupt while, driving the output and also needing the overflow flag
> to track a similiar 32 bit number. The overflow flag has to be cleared
>  so wouldn't that mess up the other timer?
	HC11 pink book has good example how to measure long periods.
(http://www.freescale.com/files/microcontrollers/doc/ref_manual/M68HC11RM.pdf)

IMO that's the only application for TOV interrupt ( to count >16bit
ticks 
from one IC event to another IC event).
	>
> Or is there a better way to do this?
>
> Thanks in advance for the suggestions.
>
> Bob Lewis
	Regards,
Edward
	

I have a working 16 bit timer but now find that at low freq's we are 
getting overflow so I need to go to a 32 bit timer interrupt driven. 
Of course the ECT is 16 bit, so is this as simple as implementing an 
interrupt on the timer overflow and  adding 10000 to a time count each 
time and then finally adding the capture timer to the 32 bit count on 
the final edge?

I have to also drive a pin with the same freq captured and I am not 
sure of the sync issues. How do you use the input timer over flow 
interrupt while, driving the output and also needing the overflow flag 
to track a similiar 32 bit number. The overflow flag has to be cleared 
  so wouldn't that mess up the other timer?

Or is there a better way to do this?

Thanks in advance for the suggestions.

Bob Lewis