@Md_Aslam wrote:
when I used uint64_t the compiler gave me the error!
Then your question is an X-Y problem - perhaps you should ask about the error with that solution. What compiler and what was the error? That error is likely more easily resolved than changing MCU for a non-existent 64-bit hardware timer!
All timers can generate an overflow interrupt, the solution is to use that to increment a counter that you then use as the upper 32 bits of a 64 bit counter. No need for timer cascading, which would be an unnecessary and profligate use of hardware for this purpose and offers no significant benefits for this application other than lower interrupt overhead.
So given for example a TIM2 configuration counting 0 to 0xFFFFFFFF with overflow interrupt enabled, then;
#include <stdint.h>
static volatile uint32_t overflow_count = 0 ;
void TIM2_IRQHandler(void)
{
overflow_count++ ;
}
uint64_t getTimerCount( void )
{
uint32_t count_lo = 0u ;
uint32_t count_hi = 0u ;
do
{
count_hi = overflow_count ;
count_lo = TIM2->TCNT ;
} while( count_hi != overflow_count ) ;
return ((uint64_t)count_hi << 32) | count_lo ;
}
The reason for the while loop is because the assignment of count_hi and count_lo is non-atomic and it is possible for overflow_count to be incremented between the count_hi and count_lo assignment causing and incorrect value to be generated. The loop ensures consistency between the two values (i.e. that they refer to the same overflow period).
Generally the loop will run once. Rarely it will run at most twice, but those rare occasions will save you from infrequent but really difficult to track down bugs.
You would have a similar consistency issue even if you use cascaded timers, and would use a similar solution.
Note that if `uint64_t` truly does not exist (more likely you failed to include stdint.h), then understand that it is simply an alias for `unsigned long long`.
