avr_timer0.h

Go to the documentation of this file.

 
#ifndef AVR_TIMER0_H_
#define AVR_TIMER0_H_
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include "avr_macros.h"
#include "avr_utils.h"
 
#pragma message ( "avr_timer0.h included" )
 
#define TIMER0_OC0A_NO_OUTPUT       (0<<COM0A1) | (0<<COM0A0) 
#define TIMER0_OC0A_TOGGLE_ON_MATCH (1<<COM0A0)               
#define TIMER0_OC0A_CLEAR_ON_MATCH  (1<<COM0A1)               
#define TIMER0_OC0A_SET_ON_MATCH    (1<<COM0A1) | (1<<COM0A0) 
#define TIMER0_OC0A_NON_INVERTING   (1<<COM0A1)               
#define TIMER0_OC0A_INVERTING       (1<<COM0A1) | (1<<COM0A0) 
#define TIMER0_OC0A_MASK            (1<<COM0A1) | (1<<COM0A0) 
#define TIMER0_OC0B_NO_OUTPUT       (0<<COM0B1) | (0<<COM0B0) 
#define TIMER0_OC0B_TOGGLE_ON_MATCH (1<<COM0B0)               
#define TIMER0_OC0B_CLEAR_ON_MATCH  (1<<COM0B1)               
#define TIMER0_OC0B_SET_ON_MATCH    (1<<COM0B1) | (1<<COM0B0) 
#define TIMER0_OC0B_NON_INVERTING   (1<<COM0B1)               
#define TIMER0_OC0B_INVERTING       (1<<COM0B1) | (1<<COM0B0) 
#define TIMER0_OC0B_MASK            (1<<COM0B1) | (1<<COM0B0) 
#define TIMER0_MODE_NORMAL            (0<<WGM01) | (0<<WGM00) 
#define TIMER0_MODE_PHASE_CORRECT_PWM (1<<WGM00)              
#define TIMER0_MODE_CTC               (1<<WGM01)              
#define TIMER0_MODE_FAST_PWM          (1<<WGM01) | (1<<WGM00) 
#define TIMER0_MODE_MASK              (1<<WGM01) | (1<<WGM00) 
#define TIMER0_PWM_TOP_0xFF           (0<<WGM02) 
#define TIMER0_PWM_TOP_OCRA           (1<<WGM02) 
#define TIMER0_PWM_TOP_MASK           (1<<WGM02) 
#define TIMER0_PRESCALER_0    (0<<CS02) | (0<<CS01) | (0<<CS00) 
#define TIMER0_PRESCALER_1    (1<<CS00)                         
#define TIMER0_PRESCALER_8    (1<<CS01)                         
#define TIMER0_PRESCALER_64   (1<<CS01) | (1<<CS00)             
#define TIMER0_PRESCALER_256  (1<<CS02)                         
#define TIMER0_PRESCALER_1024 (1<<CS02) | (1<<CS00)             
#define TIMER0_PRESCALER_MASK (1<<CS02) | (1<<CS01) | (1<<CS00) 
#define TIMER0_COMPARE_MATCH_A_INTERRUPT (1<<OCIE0A) 
#define TIMER0_COMPARE_MATCH_B_INTERRUPT (1<<OCIE0B) 
#define TIMER0_OVERFLOW_INTERRUPT        (1<<TOIE0)  
static volatile uint32_t TIMER0_SystemTickCount = 0;        
static volatile uint32_t TIMER0_SystemTickFrequency = 0;    
static volatile uint8_t  TIMER0_SystemTickTimePeriodUs = 0; 
static volatile uint8_t  TIMER0_SystemTickPerMs = 0;        
typedef struct TIMER0_ConfigData
{
    uint8_t TimerMode;
    uint8_t Prescaler;
    uint8_t OutputCompareModePinA;
    uint8_t OutputCompareModePinB;
    uint8_t OutputCompareRegisterA;
    uint8_t OutputCompareRegisterB;
    uint8_t TimerCounterRegister;
    uint8_t SystemTickState;
} TIMER0_ConfigData;
inline void TIMER0_EnableOverflowInterrupt();
inline void TIMER0_DisableOverflowInterrupt();
inline void TIMER0_EnableCompareMatchAInterrupt();
inline void TIMER0_DisableCompareMatchAInterrupt();
inline void TIMER0_EnableCompareMatchBInterrupt();
inline void TIMER0_DisableCompareMatchBInterrupt();
inline void TIMER0_EnableAllInterrupt();
inline void TIMER0_DisableAllInterrupt();
void TIMER0_Init(TIMER0_ConfigData Data);
void TIMER0_DeInit();
inline void TIMER0_SetOCR0A(uint8_t Value);
inline void TIMER0_SetOCR0B(uint8_t Value);
uint32_t TIMER0_GetSystemTick();
uint64_t TIMER0_GetSystemTimeUs();
uint32_t TIMER0_GetSystemTimeMs();
uint32_t TIMER0_TickToUs(uint32_t Tick);
uint16_t TIMER0_UsToTick(uint16_t Time);
void TIMER0_DelayTick(uint16_t Tick);
void TIMER0_DelayUs(uint16_t Time);
void TIMER0_DelayMs(uint16_t Time);
inline void TIMER0_EnableOverflowInterrupt() /* Timer-0 Sample 1 */
{
    TIMSK0 |= TIMER0_OVERFLOW_INTERRUPT;
}
 
inline void TIMER0_DisableOverflowInterrupt()
{
    TIMSK0 &= ~TIMER0_OVERFLOW_INTERRUPT;
}
 
inline void TIMER0_EnableCompareMatchAInterrupt()
{
    TIMSK0 |= TIMER0_COMPARE_MATCH_A_INTERRUPT;
}
 
inline void TIMER0_DisableCompareMatchAInterrupt()
{
    TIMSK0 &= ~TIMER0_COMPARE_MATCH_A_INTERRUPT;
}
 
inline void TIMER0_EnableCompareMatchBInterrupt()
{
    TIMSK0 |= TIMER0_COMPARE_MATCH_B_INTERRUPT;
}
 
inline void TIMER0_DisableCompareMatchBInterrupt()
{
    TIMSK0 &= ~TIMER0_COMPARE_MATCH_B_INTERRUPT;
}
 
inline void TIMER0_EnableAllInterrupt()
{
    TIMSK0 |= TIMER0_COMPARE_MATCH_B_INTERRUPT | TIMER0_COMPARE_MATCH_A_INTERRUPT | TIMER0_OVERFLOW_INTERRUPT;
}
 
inline void TIMER0_DisableAllInterrupt()
{
    TIMSK0 &= ~(TIMER0_COMPARE_MATCH_B_INTERRUPT | TIMER0_COMPARE_MATCH_A_INTERRUPT | TIMER0_OVERFLOW_INTERRUPT);
}
 
void TIMER0_Init(TIMER0_ConfigData Data)
{
    TCCR0A = Data.OutputCompareModePinA | Data.OutputCompareModePinB | Data.TimerMode;
    TCCR0B = TIMER0_PWM_TOP_0xFF | Data.Prescaler;
    TCNT0  = Data.TimerCounterRegister;
    OCR0A  = Data.OutputCompareRegisterA;
    OCR0B  = Data.OutputCompareRegisterB;
    
    uint32_t TIMER0_InputClockFrequency = 0;
    
    /* Computes the Input Clock Frequency for Timer-0 */
    if(Data.Prescaler == TIMER0_PRESCALER_1)
    {
        TIMER0_InputClockFrequency = F_CPU / 1;
    }
    else if(Data.Prescaler == TIMER0_PRESCALER_8)
    {
        TIMER0_InputClockFrequency = F_CPU / 8;
    }
    else
    {
        TIMER0_InputClockFrequency = F_CPU / (2 ^ Data.Prescaler);
    }
    
    /* Computes the System Tick Frequency for Timer-0 */
    if (Data.SystemTickState == ENABLE)
    {
        if(Data.TimerMode == (TIMER0_MODE_NORMAL))
        {
            TIMER0_SystemTickFrequency = 2 * TIMER0_InputClockFrequency / 512;  /* Computes the Tick Count Frequency for Timer-0 in NORMAL MODE */
            TIMER0_SystemTickTimePeriodUs = (uint8_t)(F_1Mhz / TIMER0_SystemTickFrequency);
            TIMER0_SystemTickPerMs = (uint8_t)(TIMER0_SystemTickFrequency / F_1kHz);
            TIMER0_EnableOverflowInterrupt();
        }
        else if(Data.TimerMode == (TIMER0_MODE_CTC))
        {
            TIMER0_SystemTickFrequency = F_100kHz; /* Sets the Tick Count Frequency for Timer-0 in CTC MODE */
            OCR0A = (uint8_t)(TIMER0_InputClockFrequency / TIMER0_SystemTickFrequency) - 1; /* OCR0A Count Calculation Formula for Timer-0 in CTC Mode*/
            TIMER0_SystemTickTimePeriodUs = (uint8_t)(F_1Mhz / TIMER0_SystemTickFrequency);
            TIMER0_SystemTickPerMs = (uint8_t)(TIMER0_SystemTickFrequency / F_1kHz);
            TIMER0_EnableCompareMatchAInterrupt();
        }
        else if(Data.TimerMode == (TIMER0_MODE_FAST_PWM))
        {
            TIMER0_SystemTickFrequency = TIMER0_InputClockFrequency / 256; /* Computes the Tick Count Frequency for Timer-0 in FAST PWM MODE */
            TIMER0_SystemTickTimePeriodUs = (uint8_t)(F_1Mhz / TIMER0_SystemTickFrequency);
            TIMER0_SystemTickPerMs = (uint8_t)(TIMER0_SystemTickFrequency / F_1kHz);
            TIMER0_EnableOverflowInterrupt();
        }
        else if(Data.TimerMode == (TIMER0_MODE_PHASE_CORRECT_PWM))
        {
            TIMER0_SystemTickFrequency = TIMER0_InputClockFrequency / 510; /* Computes the Tick Count Frequency for Timer-0 in PHASE CORRECT PWM MODE */
            TIMER0_SystemTickTimePeriodUs = (uint8_t)(F_1Mhz / TIMER0_SystemTickFrequency);
            TIMER0_SystemTickPerMs = (uint8_t)(TIMER0_SystemTickFrequency / F_1kHz);
            TIMER0_EnableOverflowInterrupt();
        }
    }
    
    if (Data.OutputCompareModePinA != (TIMER0_OC0A_NO_OUTPUT))
    {
        DDRD |= (1<<5);
        
    }
    
    if (Data.OutputCompareModePinB != (TIMER0_OC0B_NO_OUTPUT))
    {
 
        DDRD |= (1<<6);
    }
    
    /* Enables Global Interrupts */
    sei();
}
 
void TIMER0_DeInit()
{
    TCCR0B = 0x00;
    TCCR0A = 0x00;
    TCNT0  = 0x00;
    OCR0A  = 0x00;
    OCR0B  = 0x00;
    TIMER0_DisableAllInterrupt();
}
 
inline void TIMER0_SetOCR0A(uint8_t Value)
{
    OCR0A = Value;
}
 
inline void TIMER0_SetOCR0B(uint8_t Value)
{
    OCR0B = Value;
}
 
uint32_t TIMER0_GetSystemTick()
{
    return TIMER0_SystemTickCount;
}
 
uint64_t TIMER0_GetSystemTimeUs()
{
    return (uint64_t)(TIMER0_SystemTickCount * TIMER0_SystemTickTimePeriodUs);
}
 
uint32_t TIMER0_GetSystemTimeMs()
{
    return (uint32_t)((TIMER0_SystemTickCount * F_1kHz) / TIMER0_SystemTickFrequency);
}
 
uint32_t TIMER0_TickToUs(uint32_t Tick)
{ 
    return (uint32_t)(Tick * TIMER0_SystemTickTimePeriodUs);
}
 
uint16_t TIMER0_UsToTick(uint16_t Time)
{
    return (uint16_t)(Time / TIMER0_SystemTickTimePeriodUs);
}
 
void TIMER0_DelayTick(uint16_t Tick)
{
    TIMER0_DisableAllInterrupt();
    uint32_t LocalTick = TIMER0_SystemTickCount + Tick;
    if((TCCR0A & (TIMER0_MODE_MASK)) == TIMER0_MODE_CTC)
    {
        TIMER0_EnableCompareMatchAInterrupt();
    }
    else
    {
        TIMER0_EnableOverflowInterrupt();
    }
    while(TIMER0_SystemTickCount != LocalTick);
}
 
void TIMER0_DelayUs(uint16_t Time)
{
    TIMER0_DisableAllInterrupt();
    uint32_t Count = Time / TIMER0_SystemTickTimePeriodUs;
    uint32_t LocalTime = TIMER0_SystemTickCount + Count;
    if((TCCR0A & (TIMER0_MODE_MASK)) == TIMER0_MODE_CTC)
    {
        TIMER0_EnableCompareMatchAInterrupt();
    }
    else
    {
        TIMER0_EnableOverflowInterrupt();
    }
    while(TIMER0_SystemTickCount != LocalTime);
}
 
void TIMER0_DelayMs(uint16_t Time)
{
    TIMER0_DisableAllInterrupt();
    uint32_t Count = (uint32_t)Time * (uint32_t)TIMER0_SystemTickPerMs;
    uint32_t LocalTime = TIMER0_SystemTickCount + Count;
    if((TCCR0A & (TIMER0_MODE_MASK)) == TIMER0_MODE_CTC)
    {
        TIMER0_EnableCompareMatchAInterrupt();
    }
    else
    {
        TIMER0_EnableOverflowInterrupt();
    }
    while(TIMER0_SystemTickCount != LocalTime);
}
 
ISR(TIMER0_OVF_vect) // 1.375us
{
    TIMER0_SystemTickCount++;   
}
 
ISR(TIMER0_COMPA_vect) // 1.5 + 1.41us + 1.41 Takes Total 4.33uS
{
    TIMER0_SystemTickCount++;
}
 
ISR(TIMER0_COMPB_vect)
{
    
}
 
#endif /* AVR_TIMER0_H_ */