Attiny85, microsecond timer implemented on timer0 does not count the correct time

Question

There is Attiny85, with an internal clock source at 8 MHz.

I am trying to implement a microsecond timer based on the hardware timer timer0.

What is my logic: Since the clock frequency is 8 MHz and the prescaler is off, the time of one clock cycle will be about 0.1us (1/8000000). Initially, the timer overflows and causes interruptions when passing 0 ... 255, it takes more than 0.1us and is inconvenient for calculating 1μs.

To solve this, I thought about the option to change the initial value of the timer instead of 0 to 245. It turns out that in order to get to the interruption, you need to go through 10 clock cycles, which takes about 1us in time.

I load this code, but the Attiny LED obviously does not switch for about 5 seconds, although the code indicates 1 second (1000000us).

Code:

#include <avr/io.h>
#undef F_CPU
#define F_CPU 8000000UL
#include <avr/interrupt.h>


// Timer0 init
void timer0_Init() {
    cli();
    //SREG &= ~(1 << 7);
    // Enable interrupt for timer0 overflow
    TIMSK |= (1 << 1);
    // Enabled timer0 (not prescaler) - CS02..CS00 = 001
    TCCR0B = 0;
    TCCR0B |= (1 << 0);
    // Clear timer0 counter
    TCNT0 = 245;
    sei();
    //SREG |= (1 << 7);
}

// timer0 overflow interrupt
// 1us interval logic:
// MCU frequency = 8mHz (8000000Hz), not prescaler
// 1 tick = 1/8000000 = 100ns = 0.1us, counter up++ after 1 tick (0.1us)
// 1us timer = 10 tick's => 245..255
static unsigned long microsecondsTimer;
ISR(TIMER0_OVF_vect) {
    microsecondsTimer++;
    TCNT0 = 245;
}

// Millis
/*unsigned long timerMillis() {
   return microsecondsTimer / 1000;
}*/

void ledBlink() {
    static unsigned long blinkTimer;
    static int ledState;
    // 10000us = 0.01s
    // 1000000us = 1s
    if(microsecondsTimer - blinkTimer >= 1000000) {
        if(!ledState) {
            PORTB |= (1 << 3); // HIGH
            } else {
            PORTB &= ~(1 << 3); // LOW
        }
        ledState = !ledState;
        blinkTimer = microsecondsTimer;
    }
}


int main(void)
{
    
    // Set LED pin to OUTPUT mode
    DDRB |= (1 << 3);
    
    timer0_Init();

    while (1)
    {
        ledBlink();
    }
}

Attiny85 Datasheet

What could be the mistake? I have not yet learned how to work with fuses, so I initially loaded the fuses at 8 MHz through the Arduino IDE, and after that I already downloaded the main code (without changing the fuses) through AVRDUDE and Atmel Studio.

And another question, should I check the maximum value when updating my microsecond counter? I know that in Arduino, the micro and millis counters are reset when they reach the maximum value. For example, if I do not clear the TimerMicrosecond variables variable and it exceeds the size of the unsigned long, will it crash?

Answer 1

Sorry, i am late but i have got some suggestions. If you calculate the Timer0 with prescaler 1, the timer is counting up every 125ns. It is not possible to reach 1 us without a small divergence. But if you use prescaler 8 you reach exactly 1 us. I actually do not have your hardware but give this a try:

#ifndef F_CPU
  #define F_CPU 8000000UL
#else
  #error "F_CPU already defined"
#endif

#include <avr/io.h>
#include <avr/interrupt.h>

volatile unsigned int microsecondsTimer;

// Interrupt for Timer0 Compare Match A
ISR(TIMER0_COMPA_vect)
{
    microsecondsTimer++;
}

// Timer0 init
void timer0_Init()
{
  // Timer0:
  // - Mode: CTC
  // - Prescaler: /8

  TCCR0A = (1<<WGM01);
  TCCR0B = (1<<CS01);
  
  OCR0A = 1;
  
  TIMSK = (1<<OCIE0A)
  sei();
}

void ledBlink() {
  static unsigned int blinkTimer;
  
  if(microsecondsTimer >= 1000)
  {
      microsecondsTimer = 0;
      blinkTimer++;
  }
  
  if(blinkTimer >= 1000)
  {
      PORTB ^= (1<<PINB3);
      blinkTimer = 0;
  }
}

int main(void)
{ 
  // Set LED pin to OUTPUT mode
  DDRB |= (1 << PINB3);
  
  timer0_Init();

  while (1)
  {
      ledBlink();
  }
}

If you are using internal clock of attiny it may be divied by 8. To disable the clock division you have to disable the prescaler within 4 clock cycles (atomic operation):

int main(void)
{ 
  // Reset clock prescaling
  CLKPR = (1<<CLKPR);
  CLKPR = 0x00;
  // ...

Please try this solution an give feedback if it is working. Maybe you can verify it with an oscilloscope...

Notice that operations with unsigned long needs more than 1 clock cycle to handle on an 8 bit microcontroller. Maybe it would be better to use unsigned int or unsigned char. The main loop also should not contain lots if instructions. Otherwise error correction of microsecond timer has to be implemented.

Answer 2

why you didn't use pre-scaler ?!

your code need a relly relly big delay intervall(1 sec it's huge time according to cpu speed) .... so it's not wisdom choose to interrupt microcontroller every 1 us !!.. so it will be great if we could slow down your microcontroller clock and make interrupt for example every 1 ms

calculation

the microcontroller clock speed is 8 mega Hz so if we chose the preScaller to 64 then the timer clock will be 8MHz/64=125 KHz so that mean each tik (timer clock) time will be 1/125KHZ=8 us

so if we like to have inturrpt every 1ms then we need 125 tik

modify code

try this code it's more clear to understand

    #undef F_CPU
    #define F_CPU 8000000UL
    
    #include <avr/io.h>
    #include <avr/interrupt.h>
    
    volatile int millSec;
    
    void timer0_Init();
    void toggleLed();
    
    int main(void)
    {
        
        // Set LED pin to OUTPUT mode
        DDRB |= (1 << 3);
        
        timer0_Init();
        millSec = 0;  // init the millsecond
        
        sei(); // set Global Interrupt Enable 
    
        while (1)
        {
            if(millSec >= 1000){
                // this block of code will run every 1 sec          
                millSec =0; // start count for the new sec
                toggleLed(); // just toggle the led state           
            }
            // Do other backGround jobs
        }
    }
    
    
   //#####Helper functions###########
    
    void timer0_Init() {
        
        // Clear timer0 counter
        TCNT0 = 130;  //255-125=130
        
        // Enable interrupt for timer0 overflow
        TIMSK = (1 << 1);
        
        // set  prescaler to 64 and start the timer
        TCCR0B = (1<<CS00)|(1<<CS01);
        
        
        
    }
    
    void toggleLed(){
        PORTB ^= (1 << 3); // toggle led output
    }
    
    ISR(TIMER0_OVF_vect) {
        // this interrupt will happen every 1 ms
        millSec++;
        // Clear timer0 counter
        TCNT0 = 130;
    }

Answer 3

As pointed out by @ReAI, your ISR does not have enough time to run. Your ISR will take more than 1 microsecond to execute and return, so you always are missing interrupts.

There are other problems here too. For example, your microsecondsTimer variable is accessed in both the ISR and the foreground and is a long. long variables are 4 bytes wide and so are not updated atomically. It is possible, for example, that your foreground could start reading the value for microsecondsTimer and then in the middle of the read, the ISR could update some of the unread bytes, and then when the foreground starts again it will end up with a mangled value. Also, you should avoid messing with the count register since updating it can miss ticks unless you are very careful.

So how could you implement a working uSec timer? Firstly you'd like to call the ISR as infrequently as possible, so maybe pick the largest prescaller you can get get the resolution that you want and only ISR on overflow. In the case of the ATTINY85 Timer0, you can pick /8 prescaller which gets you one tick of the timer per microsecond with an 8Mhz system clock. Now your ISR only runs once every 256 microseconds and when it runs, it need only increment a "microseconds * 256" counter in each call.

Now to read the current microseconds in the foreground, you can get the number of microseconds mod 256 by directly reading the count register, and then read the "microseconds * 256" counter and multiply this by 256 and add that the counter and you'll have the full count. Note that you will need take special precautions to make sure your reads are atomic. You can do this either by carefully turning off the interrupts, quickly reading the values, and then turning the interrupts back on (save all the math for when interrupts are back on), or looping on the read values to make sure you get two full reads in a row that are the same (time means that have not updated while you were reading them).

Note that you can check out the source code to Arduino timer ISR for some insights, but note that theirs is more complicated because it can handle a wide range of tick speeds whereas you are able to keep things simple by specifically picking a 1us period.