HardwareTimer.h

Go to the documentation of this file.

#ifndef _WIRISH_HARDWARETIMER_H_
#define _WIRISH_HARDWARETIMER_H_
 
//Uncomment to use custom MSP init/deinit function
//#define HT_ENABLE_MSP_INIT_CB - DO NOT USE
 
//Uncomment to enable array of available timers
//#define HT_ENABLE_ARR_AVAILABLE_TIMERS //enables array of available timers
 
 
#include "wirish.h"
 
//Includes
#if defined(STM32F103xB)
//#include "stm32f1xx_hal.h"
#ifdef TIM5
#define CHECKTIM5 (_instance_) || (_instance_) == TIM5
#else
#define CHECKTIM5
#endif
#ifdef TIM6
#define CHECKTIM6 (_instance_) || (_instance_) == TIM6
#else
#define CHECKTIM6
#endif
#ifdef TIM7
#define CHECKTIM7 (_instance_) || (_instance_) == TIM7
#else
#define CHECKTIM7
#endif
#define IS_TIMER_INSTANCE_ON_APB1(_instance_) ((_instance_) == TIM2 \
                                            || (_instance_) == TIM3 \
                                            || (_instance_) == TIM4 \
                                            CHECKTIM5 \
                                            CHECKTIM6 \
                                            CHECKTIM7)
#define IS_TIMER_INSTANCE_ON_APB2(_instance_) ((_instance_) == TIM1)
 
#elif defined(STM32F031x6) || defined(STM32F070xB) || defined(STM32F070x6) || defined(STM32F030x6)
//#include "stm32f0xx_hal.h"
//all timers are connected to APB1
#ifdef HT_ENABLE_MSP_INIT_CB
    #define TIM1_IRQn TIM1_CC_IRQn
#endif
#define IS_TIMER_INSTANCE_ON_APB1 IS_TIM_INSTANCE
 
#elif defined(STM32L031xx)
//#include "stm32l0xx_hal.h"
#define IS_TIMER_INSTANCE_ON_APB1(_instance_) ((_instance_) == TIM2)
#define IS_TIMER_INSTANCE_ON_APB2(_instance_) ((_instance_) == TIM22 || (_instance_) == TIM21)
 
#elif defined(STM32L432xx)
//#include "stm32l4xx_hal.h"
#define IS_TIMER_INSTANCE_ON_APB1(_instance_) ((_instance_) == TIM2 || (_instance_) == TIM6 || (_instance_) == TIM7)
#define IS_TIMER_INSTANCE_ON_APB2(_instance_) ((_instance_) == TIM1 || (_instance_) == TIM15 || (_instance_) == TIM16)
 
#else
#error #error "Definitions for your MCU are not defined."
//Steps to add your MCU:
//1. add hal library - deprecated
//2. define which timer use what APB clock using MACROS: IS_TIMER_INSTANCE_ON_APB1, IS_TIMER_INSTANCE_ON_APB2, ...
//3. define correct name to IRQn, e.g.: #define TIM1_IRQn TIM1_CC_IRQn
#endif
 
#if defined(HAL_TIM_MODULE_ENABLED) || defined(DOXYGEN_FORCED)
 
#if !defined(min)
#define min(a,b) (((a)<b)?(a):(b))
#endif
#if !defined(max)
#define max(a,b) (((a)>b)?(a):(b))
#endif
#if !defined(abs)
#define abs(a) (((a)>=0)?(a):-(a))
#endif
 
#define TIMER_16BIT_MAX_PRESCALER   (0xFFFFUL)
#define TIMER_32BIT_MAX_PERIOD      (0xFFFFFFFFUL)
#define TIMER_16BIT_MAX_PERIOD      (0xFFFFUL)
 
enum CalculateTimerState {
    CTS_BAD_ARGUMENT = -3,
    CTS_TOO_HIGH_RESULT = -2,
    CTS_TOO_LOW_RES = -1,
    CTS_NONE = 0,
    CTS_OK_JUST_PERIOD = 1,
    CTS_OK_JUST_PRESCALER = 2,
    CTS_OK_BEST_ACCURACY = 3,
    CTS_OK_ROUNDED_UP = 4,
    CTS_OK_ROUNDED_DOWN = 5
};
 
#define CTS_IS_OK(state) ((state)>CTS_NONE)
 
struct TimerSettings {
    uint16_t prescaler = 0;
    uint32_t period = 0;
    uint8_t divider = 0;
    CalculateTimerState state = CTS_NONE;
 
    TimerSettings(uint16_t prescaler_, uint32_t period_, uint8_t div, CalculateTimerState state_) {
        prescaler = prescaler_;
        period = period_;
        divider = div;
        state = state_;
    }
};
 
enum TimerState {
    TS_RUNNING,
    TS_PAUSED,
    TS_STOPPED,
    TS_ERROR
};
 
 
class HardwareTimer {
 
public:
    //Constructors:
    HardwareTimer(TIM_HandleTypeDef &tim);
 
    HardwareTimer(TIM_TypeDef* instance);
 
    //Destructor
    ~HardwareTimer();
 
 
    bool instanceExists(void);
 
    bool init(void);
 
    bool isInitDone(void);
 
    void deInit(void);
 
 
    bool supportsSelectionCounterMode();
 
    bool setCounterMode(uint32_t mode);
 
    uint32_t getCounterMode(void);
 
    /*bool setChannel(uint8_t channel);
    uint8_t getChannel(void);
    bool setChannelMode(uint32_t mode); //- do not use now
    uint32_t getChannelMode(void); //- do not use now
    void setChannelOCPulse(uint16_t val); //- do not use now
    uint16_t getChannelOCPulse(void); //- do not use now
    void setChannelOtCPolarityHIGH(bool isHigh); //- do not use now
    bool isChannelOtCPolarityHIGH(void); //- do not use now
    void enableOCFastMode(bool enable); //- do not use now
    bool isOCFastModeEnabled(void); //- do not use now*/
 
    /***/ //Setup methods END
 
 
 
 
    TimerSettings setInterval_ns(uint64_t interval_ns);
 
    TimerSettings setInterval(uint64_t interval_ms);
 
    uint64_t getInterval(void);
 
    uint64_t getInterval_ns(void);
 
    /***/ //Easiest settings methods applied in real time END
 
 
    uint16_t getPrescaler(void);
 
    void setPrescaler(uint16_t factor);
 
    uint32_t getPeriod();
 
    void setPeriod(uint32_t val);
 
    uint32_t getCount(void);
 
    void setCount(uint32_t val);
 
    /***/ //Basic settings methods applied in real time END
 
 
    void unlockSettings();
 
    void lockSettings();
 
    bool haveLockedSettings();
 
    void enableAutoReloadPreload(bool enable);
 
    bool isAutoReloadPreloadEnabled(void);
 
    bool is32BitTimer();
 
    bool supportsClockDivision();
 
    bool setClockDivision(uint8_t division);
 
    uint8_t getClockDivision(void);
 
    uint32_t getTimerClockFreq(void);
 
    uint32_t getDivTimerClockFreq(void);
 
    /***/ //Advanced settings methods applied in real time END
 
 
    void pause(void);
 
    void stop(void);
 
    bool resume(void);
 
    bool start(void);
 
    TimerState state(void);
 
    /***/ //Timer control functions END
 
 
    void setCallback(void (* PeriodElapsedCallback_)());
 
#ifdef HT_ENABLE_ARR_AVAILABLE_TIMERS
 
    const static TIM_TypeDef* availableTimers[];
#endif
 
    static inline void handleCallback(TIM_TypeDef* instance);
 
    static inline void handleCallback(uint32_t timerIndex);
 
    static uint32_t getTimerIndex(TIM_TypeDef* instance);
 
    static HardwareTimer** getTimerInstances(); //returns pointer to instances
 
    static uint8_t getAvailableTimersCount();
 
    uint8_t availableChannelsCount();
 
    TIM_HandleTypeDef& getHAL_TIM_Struct(){
        return _tim;
    }
 
    uint32_t setIntervalItLimit = 25;
 
    /***/ //Expert methods END
 
 
protected:
    TIM_HandleTypeDef createdTim;
 
    TIM_HandleTypeDef &_tim = createdTim;
 
    //TIM_OC_InitTypeDef sConfigOC = {0}; //channel configuration
 
    bool initDone = false;
 
    uint64_t inline CalculateTime_ns(uint32_t prescaler, uint32_t period, uint32_t timerFreq, uint8_t clockDiv) {
        uint64_t time = ((uint64_t)period + 1) * (((uint64_t)prescaler + 1) * 1000000000ULL) / timerFreq;
        //if (time > UINT32_MAX) time = UINT32_MAX;
        //if(clockDiv == 0) clockDiv = 1;
        return time * clockDiv;
    }
 
    uint64_t inline CalculateTime_ms(uint32_t prescaler, uint32_t period, uint32_t timerFreq, uint8_t clockDiv) {
        uint64_t time = ((uint64_t)period + 1) * (((uint64_t)prescaler + 1) * 1000UL) / timerFreq;
        //if (time > UINT32_MAX) time = UINT32_MAX;
        //if(clockDiv == 0) clockDiv = 1;
        return time * clockDiv;
    }
 
    TimerSettings CalculateTimer(uint64_t ticks, uint32_t maxPrescaler, uint64_t maxPeriod, uint32_t minPeriod, uint32_t timerFreq, bool divEnabled, uint32_t maxIterations = UINT32_MAX);
 
#ifdef HT_ENABLE_MSP_INIT_CB
 
    static void Base_MspInit_callback(TIM_HandleTypeDef* htim_oc);
 
    static void Base_MspDeInit_callback(TIM_HandleTypeDef* htim_oc);
#endif
 
    void addThisToInstArr();
 
    void removeThisFromInstArr();
 
    void (* TIMPeriodElapsedCallback)() = NULL;
 
    static HardwareTimer* instances[]; //There are stored pointers to all created instances of this class
 
    static uint8_t availableTimersCount;
};
 
/*The timer peripherals can be classified as:
• Advanced-configuration timers like TIM1 and TIM8 among others.
• General-purpose configuration timers like TIM2 and TIM3 among others
• Lite-configuration timers like TIM9, TIM10, TIM12 and TIM16 among others
• Basic-configuration timers like TIM6 and TIM7 among others.*/
 
#endif
#endif