Stm32DCCDecoder.hxx

Go to the documentation of this file.

 
#include "FreeRTOSConfig.h"
#include "Stm32Gpio.hxx" // for pin definitions
#include "freertos_drivers/common/DccDecoder.hxx"
 
#include "stm32f_hal_conf.hxx"
 
typedef DummyPin PIN_RailcomCutout;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
template <class HW> class Stm32DccTimerModule
{
public:
    using NRZ_Pin = typename HW::NRZ_Pin;
 
    // These constants are exported from HW to the driver.
 
    static constexpr uint32_t TIMER_MAX_VALUE = 0xffff;
    static constexpr uint32_t SAMPLE_PERIOD_CLOCKS = HW::SAMPLE_PERIOD_TICKS;
    static constexpr unsigned Q_SIZE = HW::Q_SIZE;
 
    static uint32_t get_ticks_per_usec()
    {
        // We set the timer prescaler to go at one tick per usec.
        return 1;
    }
 
    static void module_init();
 
    static void module_enable();
 
    static void module_disable();
 
    static void trigger_os_interrupt()
    {
        NVIC_SetPendingIRQ(HW::OS_IRQn);
    }
 
    static void before_cutout_hook()
    {
        HW::before_cutout_hook();
    }
 
    static void dcc_before_cutout_hook()
    {
        HW::dcc_before_cutout_hook();
    }
 
    static void dcc_packet_finished_hook()
    {
        HW::dcc_packet_finished_hook();
    }
 
    static void after_feedback_hook()
    {
        HW::after_feedback_hook();
    }
 
    static int time_delta_railcom_pre_usec()
    {
        return HW::time_delta_railcom_pre_usec();
    }
 
    static int time_delta_railcom_mid_usec()
    {
        return HW::time_delta_railcom_mid_usec();
    }
 
    static int time_delta_railcom_end_usec()
    {
        return HW::time_delta_railcom_end_usec();
    }
    
    static inline bool int_get_and_clear_capture_event();
 
    static inline uint32_t get_capture_counter();
 
    static inline bool int_get_and_clear_delay_event();
 
    static void set_cap_timer_delay_usec(int usec)
    {
        Debug::DccPacketDelay::toggle();
        // This code handles underflow of the timer correctly. We cannot wait
        // longer than one full cycle though (65 msec -- typical RailCom waits
        // are 20-500 usec).
        uint32_t new_match_v = usecTimerStart_ + usec;
        new_match_v &= 0xffff;
        __HAL_TIM_SET_COMPARE(
            usec_timer_handle(), HW::USEC_CHANNEL, new_match_v);
        __HAL_TIM_CLEAR_IT(usec_timer_handle(), HW::USEC_IF);
        __HAL_TIM_ENABLE_IT(usec_timer_handle(), HW::USEC_IF);
    }
 
    static void set_cap_timer_capture()
    {
        __HAL_TIM_CLEAR_IT(capture_timer_handle(), HW::CAPTURE_IF);
        __HAL_TIM_ENABLE_IT(capture_timer_handle(), HW::CAPTURE_IF);
    }
 
    static void set_cap_timer_time()
    {
        if (shared_timers()) {
            usecTimerStart_ =  get_raw_capture_counter();
        } else {
            usecTimerStart_ =  __HAL_TIM_GET_COUNTER(usec_timer_handle());
        }
        // channel setup already happened in module_enable.
    }
 
    static void stop_cap_timer_time()
    {
        __HAL_TIM_DISABLE_IT(usec_timer_handle(), HW::USEC_IF);
        //TIM_CCxChannelCmd(usec_timer(), HW::USEC_CHANNEL, TIM_CCx_DISABLE);
    }
 
private:
    static TIM_HandleTypeDef captureTimerHandle_;
    static TIM_HandleTypeDef usecTimerHandle_;
    static uint32_t usecTimerStart_;
 
    static void init_timer(TIM_HandleTypeDef *handle, TIM_TypeDef *instance)
    {
        memset(handle, 0, sizeof(*handle));
        handle->Instance = instance;
        handle->Init.Period = TIMER_MAX_VALUE;
        // 1 usec per tick
        handle->Init.Prescaler = configCPU_CLOCK_HZ / 1000000;
        handle->Init.ClockDivision = 0;
        handle->Init.CounterMode = TIM_COUNTERMODE_UP;
        handle->Init.RepetitionCounter = 0;
        handle->Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 
        HASSERT(HAL_TIM_IC_DeInit(handle) == HAL_OK);
        HASSERT(HAL_TIM_IC_Init(handle) == HAL_OK);
    }
 
    static inline uint32_t get_raw_capture_counter();
    
    static TIM_TypeDef *capture_timer()
    {
        return reinterpret_cast<TIM_TypeDef *>(HW::CAPTURE_TIMER);
    }
    static TIM_HandleTypeDef *capture_timer_handle()
    {
        return &captureTimerHandle_;
    }
 
    static TIM_TypeDef *usec_timer()
    {
        return reinterpret_cast<TIM_TypeDef *>(HW::USEC_TIMER);
    }
    static TIM_HandleTypeDef *usec_timer_handle()
    {
        if (shared_timers())
        {
            return capture_timer_handle();
        }
        return &usecTimerHandle_;
    }
 
    static bool shared_timers()
    {
        return HW::CAPTURE_TIMER == HW::USEC_TIMER;
    }
 
    Stm32DccTimerModule();
 
    DISALLOW_COPY_AND_ASSIGN(Stm32DccTimerModule);
};
 
template <class HW>
TIM_HandleTypeDef Stm32DccTimerModule<HW>::captureTimerHandle_;
template <class HW> TIM_HandleTypeDef Stm32DccTimerModule<HW>::usecTimerHandle_;
template <class HW> uint32_t Stm32DccTimerModule<HW>::usecTimerStart_;
 
template <class HW> void Stm32DccTimerModule<HW>::module_init()
{
    memset(&captureTimerHandle_, 0, sizeof(captureTimerHandle_));
    memset(&usecTimerHandle_, 0, sizeof(usecTimerHandle_));
    // GPIO input.
    NRZ_Pin::hw_init();
}
 
template <class HW> void Stm32DccTimerModule<HW>::module_enable()
{
    init_timer(capture_timer_handle(), capture_timer());
    // Switches pin to GPIO input.
    NRZ_Pin::hw_init();
    // This must precede switching the pin to alternate mode to avoid the MCU
    // driving the pin as an output in case the timer channel registers are
    // uninitialized or in PWM mode.
    set_cap_timer_capture();
 
    GPIO_InitTypeDef gpio_init;
    memset(&gpio_init, 0, sizeof(gpio_init));
    gpio_init.Mode = GPIO_MODE_AF_PP;
    gpio_init.Pull = GPIO_PULLUP;
    gpio_init.Speed = GPIO_SPEED_FREQ_HIGH;
    gpio_init.Alternate = HW::CAPTURE_AF_MODE;
    gpio_init.Pin = HW::NRZ_Pin::pin();
    HAL_GPIO_Init(HW::NRZ_Pin::port(), &gpio_init);
 
    if (!shared_timers())
    {
        init_timer(usec_timer_handle(), usec_timer());
    }
 
    // Set up capture channel.
    {
        TIM_IC_InitTypeDef channel_init;
        memset(&channel_init, 0, sizeof(channel_init));
        channel_init.ICPolarity = TIM_ICPOLARITY_BOTHEDGE;
        channel_init.ICSelection = TIM_ICSELECTION_DIRECTTI;
        channel_init.ICPrescaler = TIM_ICPSC_DIV1;
        channel_init.ICFilter = HW::CAPTURE_FILTER;
        HASSERT(HAL_TIM_IC_ConfigChannel(capture_timer_handle(), &channel_init,
                    HW::CAPTURE_CHANNEL) == HAL_OK);
    }
 
    HASSERT(HAL_TIM_IC_Start_IT(capture_timer_handle(), HW::CAPTURE_CHANNEL) ==
        HAL_OK);
    // Disable interrupt until the set_cap_timer_capture() is called.
    __HAL_TIM_DISABLE_IT(capture_timer_handle(), HW::CAPTURE_IF);
 
    // Set up timing channel
    {
        TIM_OC_InitTypeDef channel_init;
        memset(&channel_init, 0, sizeof(channel_init));
        channel_init.OCMode = TIM_OCMODE_TIMING; // frozen -- no output
        channel_init.Pulse = (__HAL_TIM_GET_COUNTER(usec_timer_handle()) + 1) &
            0xffff; // will be reloaded in the delay_usec function.
        // the rest are irrelevant.
        channel_init.OCPolarity = TIM_OCPOLARITY_HIGH;
        channel_init.OCNPolarity = TIM_OCNPOLARITY_HIGH;
        channel_init.OCFastMode = TIM_OCFAST_DISABLE;
        channel_init.OCIdleState = TIM_OCIDLESTATE_RESET;
        channel_init.OCNIdleState = TIM_OCNIDLESTATE_RESET;
        HASSERT(HAL_TIM_OC_ConfigChannel(usec_timer_handle(), &channel_init,
                    HW::USEC_CHANNEL) == HAL_OK);
    }
 
    HASSERT(
        HAL_TIM_OC_Start_IT(usec_timer_handle(), HW::USEC_CHANNEL) == HAL_OK);
    // Disable interrupt until the delay_usec() is called.
    __HAL_TIM_DISABLE_IT(usec_timer_handle(), HW::USEC_IF);
 
#if defined(GCC_ARMCM0)
    HAL_NVIC_SetPriority(HW::CAPTURE_IRQn, 0, 0);
    HAL_NVIC_SetPriority(HW::TIMER_IRQn, 0, 0);
    HAL_NVIC_SetPriority(HW::OS_IRQn, 3, 0);
#elif defined(GCC_ARMCM3)
    SetInterruptPriority(HW::CAPTURE_IRQn, 0x20);
    SetInterruptPriority(HW::TIMER_IRQn, 0x20);
    SetInterruptPriority(HW::OS_IRQn, configKERNEL_INTERRUPT_PRIORITY);
#else
#error not defined how to set interrupt priority
#endif
 
    NVIC_EnableIRQ(HW::CAPTURE_IRQn);
    NVIC_EnableIRQ(HW::TIMER_IRQn);
    NVIC_EnableIRQ(HW::OS_IRQn);
}
 
template <class HW> void Stm32DccTimerModule<HW>::module_disable()
{
    // Switches pin to GPIO input.
    NRZ_Pin::hw_init();
 
    capture_timer_handle()->Instance = capture_timer();
    usec_timer_handle()->Instance = usec_timer();
    NVIC_DisableIRQ(HW::CAPTURE_IRQn);
    NVIC_DisableIRQ(HW::TIMER_IRQn);
    NVIC_DisableIRQ(HW::OS_IRQn);
    HASSERT(HAL_TIM_IC_Stop_IT(capture_timer_handle(), HW::CAPTURE_CHANNEL) ==
        HAL_OK);
 
    HASSERT(
        HAL_TIM_OC_Stop_IT(usec_timer_handle(), HW::USEC_CHANNEL) == HAL_OK);
    if (!shared_timers())
    {
        HASSERT(HAL_TIM_IC_DeInit(usec_timer_handle()) == HAL_OK);
    }
    HASSERT(HAL_TIM_IC_DeInit(capture_timer_handle()) == HAL_OK);
}
 
template <class HW>
bool Stm32DccTimerModule<HW>::int_get_and_clear_capture_event()
{
    if (__HAL_TIM_GET_FLAG(capture_timer_handle(), HW::CAPTURE_IF))
    {
        //Debug::DccDecodeInterrupts::toggle();
        HW::cap_event_hook();
        __HAL_TIM_CLEAR_FLAG(capture_timer_handle(), HW::CAPTURE_IF);
        return true;
    }
    return false;
}
 
template <class HW> uint32_t Stm32DccTimerModule<HW>::get_capture_counter()
{
    // Simulates down-counting.
    return TIMER_MAX_VALUE - get_raw_capture_counter();
}
 
template <class HW> uint32_t Stm32DccTimerModule<HW>::get_raw_capture_counter()
{
    // This if structure will be optimized away.
    if (HW::CAPTURE_CHANNEL == TIM_CHANNEL_1)
    {
        return capture_timer()->CCR1;
    }
    else if (HW::CAPTURE_CHANNEL == TIM_CHANNEL_2)
    {
        return capture_timer()->CCR2;
    }
    else if (HW::CAPTURE_CHANNEL == TIM_CHANNEL_3)
    {
        return capture_timer()->CCR3;
    }
    else if (HW::CAPTURE_CHANNEL == TIM_CHANNEL_4)
    {
        return capture_timer()->CCR4;
    }
    else
    {
        DIE("Unknown capture channel");
        return 0;
    }
}
 
template <class HW>
bool Stm32DccTimerModule<HW>::int_get_and_clear_delay_event()
{
    if (__HAL_TIM_GET_FLAG(usec_timer_handle(), HW::USEC_IF))
    {
        Debug::DccDecodeInterrupts::set(true);
        __HAL_TIM_CLEAR_IT(usec_timer_handle(), HW::USEC_IF);
        // we also disable the interrupt until it is reenabled by loading a new
        // usec delay target.
        __HAL_TIM_DISABLE_IT(usec_timer_handle(), HW::USEC_IF);
        return true;
    }
    return false;
}
 
template <class HW> using Stm32DccDecoder = DccDecoder<Stm32DccTimerModule<HW>>;