STM32F030_Mock.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef STM32F030MOCK_H
#define STM32F030MOCK_H
 
#include <Imt.Base.Core.Platform/Platform.h>
#include <Imt.Base.HAL.STM32F030/SystemPeripherals_ADC.h>
#include <Imt.Base.HAL.STM32F030/SystemPeripherals_EXTI.h>
#include <Imt.Base.HAL.STM32F030/SystemPeripherals_GPIO.h>
#include <Imt.Base.HAL.STM32F030/SystemPeripherals_RCC.h>
#include <Imt.Base.HAL.STM32F030/SystemPeripherals_TIM.h>
#include <vector>
 
namespace imt {
namespace base {
namespace hal {
namespace stm32f030 {
namespace mock {
 
class STM32F030Mock {
public:
 
    static uint32_t const DEFAULT_SYSCLK_FREQUENCY = 8000000;
    static uint32_t const DEFAULT_HCLK_FREQUENCY = 8000000;
    static uint32_t const DEFAULT_PCLK_FREQUENCY = 8000000;
    static uint32_t const DEFAULT_ADCCLK_FREQUENCY = 4000000;
 
    static STM32F030Mock& getSingle();
 
    static void clear();
 
    static void setGpioState(GPIO_Pin const pin, bool const value);
 
    static bool getGpioState(GPIO_Pin const pin);
 
    // SystemPeripherals_ADC.c:
    uint32_t m_adc_DeInitInvokeCounter;
    uint32_t m_adc_InitInvokeCounter;
    uint32_t m_adc_ClockModeConfigInvokeCounter;
    uint32_t m_adc_EnableInvokeCounter;
    uint32_t m_adc_AutoPowerOffHSI14InvokeCounter;
    uint32_t m_adc_WaitModeCmdInvokeCounter;
    uint32_t m_adc_TempSensorCmdInvokeCounter;
    uint32_t m_adc_VrefintCmdInvokeCounter;
    uint32_t m_adc_ChannelConfigInvokeCounter;
    std::vector<ADC_Channel> m_adc_ChannelConfigChannelParam;
    std::vector<ADC_SampleTime> m_adc_ChannelConfigSampleTimeParam;
    uint32_t m_adc_ContinuousModeCmdInvokeCounter;
    uint32_t m_adc_DiscontinuousInvokeCounter;
    uint32_t m_adc_OverrunModeCmdInvokeCounter;
    uint32_t m_adc_GetCalibrationFactorInvokeCounter;
    uint32_t m_adc_GetCalibrationFactorReturnValue;
    uint32_t m_adc_StopOfConversionInvokeCounter;
    uint32_t m_adc_StartOfConversionInvokeCounter;
    uint32_t m_adc_GetConversionValueInvokeCounter;
    uint16_t m_adc_GetConversionValueReturnValue;
    uint32_t m_adc_DMACmdInvokeCounter;
    uint32_t m_adc_DMARequestModeConfigInvokeCounter;
    uint32_t m_adc_ITConfigInvokeCounter;
    uint32_t m_adc_GetFlagStatusInvokeCounter;
    bool m_adc_GetFlagStatusReturnValue;
    uint32_t m_adc_ClearFlagInvokeCounter;
    uint32_t m_adc_GetITStatusInvokeCounter;
    bool m_adc_GetITStatusReturnValue;
    uint32_t m_adc_ClearITPendingBitInvokeCounter;
    // SystemPeripherals_DMA.c:
    uint32_t m_dma_DeInitInvokeCounter;
    uint32_t m_dma_InitInvokeCounter;
    uint32_t m_dma_EnableInvokeCounter;
    // SystemPeripherals_EXTI.c:
    bool m_exti_Initialized;
    std::vector<EXTI_Line> m_exti_GenerateSWInterruptLineParam;
    std::vector<EXTI_Line> m_exti_ClearITPendingBitLineParam;
    uint32_t m_exti_IsITPending;
    // SystemPeripherals_SysTick.c:
    uint32_t m_sysTick_ConfigureSystemTickInterruptInvokeCounter;
    uint32_t m_sysTick_EnableSystemTickInterruptInvokeCounter;
    std::vector<bool> m_systTick_EnableSystemTickInterruptParam;
    // SystemPeripherals_RCC.c:
    uint32_t m_rcc_EnableAHBPeriphClockInvokeCounter;
    uint32_t m_rcc_EnableAPB1PeripheralClockInvokeCounter;
    uint32_t m_rcc_EnableAPB2PeripheralClockInvokeCounter;
    uint32_t m_rcc_ResetAHBPeripheralInvokeCounter;
    uint32_t m_rcc_ResetAPB1PeripheralInvokeCounter;
    uint32_t m_rcc_ResetAPB2PeripheralInvokeCounter;
    uint32_t m_rcc_GetClocksFreqInvokeCounter;
    RCC_Clocks m_rcc_GetClocksFreqInvokeCounterReturnValue;
    uint32_t m_rcc_IsWindowWatchdogResetInvokeCounter;
    bool m_rcc_IsWindowWatchdogResetReturnValue;
    uint32_t m_rcc_ClearResetFlagsInvokeCounter;
    // SystemPeripherals_GPIO.c:
    uint32_t m_gpio_InitInvokeCounter;
    uint32_t m_gpio_WriteInvokeCounter;
    std::vector<GPIO_Pin> m_gpio_Write_PinParam;
    std::vector<bool> m_gpio_Write_ValueParam;
    std::vector<GPIO_Pin> m_gpio_Read_PinParam;
    uint32_t m_gpio_ReadInvokeCounter;
    uint32_t m_gpio_SetBitsInvokeCounter;
    std::vector<GPIO_ModuleAddress> m_gpio_SetBits_PortParam;
    std::vector<uint16_t> m_gpio_SetBits_GpioPinParam;
    uint32_t m_gpio_ResetBitsInvokeCounter;
    std::vector<GPIO_ModuleAddress> m_gpio_ResetBits_PortParam;
    std::vector<uint16_t> m_gpio_ResetBits_GpioPinParam;
    // SystemPeripherals_NVIC.c:
    uint32_t m_nvic_SetPriorityInvokeCounter;
    uint32_t m_nvic_EnableIRQInvokeCounter;
    uint32_t m_nvic_SystemResetInvokeCounter;
    // SystemPeripherals_TIM.c:
    uint32_t m_tim_TimeBaseInitInvokeCounter;
    std::vector<TIM_ModuleAddress> m_tim_TimeBaseInitTimerModuleParam;
    std::vector<TIM_TimeBaseInitStruct> m_tim_TimeBaseInitInitStructParam;
    uint32_t m_tim_SetCompareValueInvokeCounter;
    std::vector<TIM_Channel> m_tim_SetCompareValueChannelParam;
    std::vector<uint16_t> m_tim_SetCompareValueCaptureCompareValueParam;
    uint32_t m_tim_ClearPendingInterruptInvokeCounter;
    std::vector<TIM_ModuleAddress> m_tim_ClearPendingInterruptTimerModulelParam;
    std::vector<TIM_IrqFlag> m_tim_ClearPendingInterruptIrqFlagParam;
    uint32_t m_tim_EnableInvokeCounter;
    std::vector<TIM_ModuleAddress> m_tim_EnableTimerModuleParam;
    std::vector<bool> m_tim_EnableDoEnableParam;
    uint32_t m_tim_EnableInterruptInvokeCounter;
    std::vector<TIM_ModuleAddress> m_tim_EnableInterruptTimerModuleParam;
    std::vector<TIM_Irq> m_tim_EnableInterruptIrqParam;
    std::vector<bool> m_tim_EnableInterruptDoEnableParam;
    uint32_t m_tim_SetAutoreloadRegisterInvokeCounter;
    std::vector<TIM_ModuleAddress> m_tim_SetAutoreloadRegisterTimerModulelParam;
    std::vector<uint16_t> m_tim_SetAutoreloadRegisterNewValueParam;
    // SystemPeripherals_IWDG.c:
    uint32_t m_iwdg_ResetInvokeCounter;
 
private:
 
    explicit STM32F030Mock();
 
    virtual ~STM32F030Mock();
 
    STM32F030Mock(STM32F030Mock const&);
 
    STM32F030Mock& operator=(STM32F030Mock const&);
 
    static uint16_t getGpioPinIndex(GPIO_Pin const pin);
 
    static uint16_t const NUMBER_OF_GPIO_PORTS = 5;
    static uint16_t const NUMBER_OF_GPIO_PINS_PER_PORTS = 16;
 
    static STM32F030Mock* s_pSingle;
 
    bool m_gpio_PinStates[NUMBER_OF_GPIO_PORTS * NUMBER_OF_GPIO_PINS_PER_PORTS];
};
 
} // namespace mock
} // namespace stm32f030
} // namespace hal
} // namespace base
} // namespace imt
 
#endif // STM32F030MOCK_H