MockTIM.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef STM32H730_MOCKTIM_H
#define STM32H730_MOCKTIM_H
 
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.HAL.STM32H730/Peripherals/TIM.h>
#include <map>
 
namespace imt {
namespace base {
namespace hal {
namespace stm32h730 {
namespace mock {
 
class MockTIM {
public:
 
    explicit MockTIM() {
        clear();
    }
 
    virtual ~MockTIM() {
    }
 
    void clear() {
        m_captureCompareEnabledMap.clear();
        m_mainOutputEnabledMap.clear();
        m_timerEnabledMap.clear();
        m_flagMap.clear();
        m_irqMap.clear();
        m_pwmMap.clear();
    }
 
    void init(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::InitStruct const& initConfig) {
    }
 
    void initClock(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::ClkSrcInitStruct const& clockSourceConfig) {
    }
 
    void initEncoder(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::EncInitStruct const& encoderConfig) {
    }
 
    void configMaster(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::MasterInitStruct const& masterConfig) {
    }
 
    void configSlave(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::SlaveInitStruct const& slaveConfig) {
    }
 
    void enable(TIMModuleAddress const module, bool const doEnable) {
        m_timerEnabledMap[module] = doEnable;
    }
 
    void enableCC(TIMModuleAddress const module, bool const doEnable) {
        m_captureCompareEnabledMap[module] = doEnable;
    }
 
    void enableMOE(TIMModuleAddress const module, bool const doEnable) {
        m_mainOutputEnabledMap[module] = doEnable;
    }
 
    void clearFlag(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Flag const flag) {
        m_flagMap[module][flag] = false;
    }
 
    bool isFlagSet(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Flag const flag) {
        return m_flagMap[module][flag];
    }
 
    void enableIrq(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Irq const irq, bool const doEnable) {
        m_irqMap[module][irq] = doEnable;
    }
 
    bool isIrqEnabled(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Irq const irq) {
        return m_irqMap[module][irq];
    }
 
    void setCounter(TIMModuleAddress const module, uint32_t const count) {
    }
 
    uint32_t getCounter(TIMModuleAddress const module) {
        return 0U;
    }
 
    void setCompare(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel, uint32_t const value) {
        m_pwmMap[module][channel] = value;
    }
 
    uint32_t getCompare(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
        return m_pwmMap[module][channel];
    }
 
    void setAutoReload(TIMModuleAddress const module, uint32_t const value) {
    }
 
    void setOCConfig(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::OCInitStruct const& ocInitStruct, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void configPWMChannel(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::OCInitStruct const& ocInitStruct, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void initInputCapture(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::ICInitStruct const& inputCaptureConfig, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void setTIConfig(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::ICInitStruct const& init, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void startPWM(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void startEncoder(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void startInputCapture(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    void stopInputCapture(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
    }
 
    bool isInputCaptureSelected(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Channel const channel) {
        return true;
    }
 
    bool isEnabled(TIMModuleAddress const module) {
        return m_timerEnabledMap[module];
    }
 
    bool isCCEnabled(TIMModuleAddress const module) {
        return m_captureCompareEnabledMap[module];
    }
 
    bool isMOEEnabled(TIMModuleAddress const module) {
        return m_mainOutputEnabledMap[module];
    }
 
    void setFlag(TIMModuleAddress const module, imt::base::hal::stm32h730::peripherals::TIM::Flag const flag) {
        m_flagMap[module][flag] = true;
    }
 
private:
 
    std::map<TIMModuleAddress, bool> m_captureCompareEnabledMap;
    std::map<TIMModuleAddress, bool> m_mainOutputEnabledMap;
    std::map<TIMModuleAddress, bool> m_timerEnabledMap;
    std::map<TIMModuleAddress, std::map<imt::base::hal::stm32h730::peripherals::TIM::Irq, bool>> m_irqMap;
    std::map<TIMModuleAddress, std::map<imt::base::hal::stm32h730::peripherals::TIM::Flag, bool>> m_flagMap;
    std::map<TIMModuleAddress, std::map<imt::base::hal::stm32h730::peripherals::TIM::Channel, uint32_t>> m_pwmMap;
};
 
} // namespace mock
} // namespace stm32h730
} // namespace hal
} // namespace base
} // namespace imt
 
#endif // #ifndef STM32H730_MOCKADC_H