DccOutput.hxx

Go to the documentation of this file.

 
#ifndef _DCC_DCCOUTPUT_HXX_
#define _DCC_DCCOUTPUT_HXX_
 
#include <atomic>
#include <cstdint>
 
class DccOutput
{
public:
    enum Type : int
    {
        TRACK = 1,
        PGM = 2,
        LCC = 3,
    };
 
    enum class DisableReason : uint8_t
    {
        INITIALIZATION_PENDING = 0x01,
        CONFIG_SETTING         = 0x02,
        LOCAL_DISABLE          = CONFIG_SETTING,
        GLOBAL_EOFF            = 0x04,
        SHORTED                = 0x08,
        THERMAL                = 0x10,
        PGM_TRACK_LOCKOUT      = 0x20,
        INVALID_SIGNAL_INPUT   = 0x40,
        USR1                   = 0x80,
    };
 
    virtual void disable_output_for_reason(DisableReason bit) = 0;
 
    virtual void clear_disable_output_for_reason(DisableReason bit) = 0;
 
    void override_disable_bit_for_reason(DisableReason bit, bool value)
    {
        if (value)
        {
            disable_output_for_reason(bit);
        }
        else
        {
            clear_disable_output_for_reason(bit);
        }
    }
 
    virtual uint8_t get_disable_output_reasons() = 0;
 
    enum class RailcomCutout
    {
        DISABLED = 0,
        SHORT_CUTOUT = 1,
        LONG_CUTOUT = 2
    };
 
    virtual void set_railcom_cutout_enabled(RailcomCutout cutout) = 0;
};
 
DccOutput *get_dcc_output(DccOutput::Type type);
 
template <class HW> class DccOutputImpl : public DccOutput
{
public:
    constexpr DccOutputImpl()
    {
    }
 
    void disable_output_for_reason(DisableReason bit) override
    {
        HW::set_disable_reason(bit);
    }
    void clear_disable_output_for_reason(DisableReason bit) override
    {
        HW::clear_disable_reason(bit);
    }
 
    void set_railcom_cutout_enabled(RailcomCutout cutout) override
    {
        HW::isRailcomCutoutEnabled_ = (uint8_t)cutout;
    }
 
    uint8_t get_disable_output_reasons() override
    {
        return HW::outputDisableReasons_;
    }
 
    static constexpr DccOutput *instance()
    {
        return const_cast<DccOutput *>(
            static_cast<const DccOutput *>(&instance_));
    }
 
private:
    static const DccOutputImpl<HW> instance_;
};
 
template <class HW> const DccOutputImpl<HW> DccOutputImpl<HW>::instance_;
 
template <int OUTPUT_NUMBER> struct DccOutputHw
{
public:
    static std::atomic_uint_least8_t outputDisableReasons_;
 
    static std::atomic_uint_least8_t isRailcomCutoutEnabled_;
 
    static uint8_t isRailcomCutoutActive_;
 
    static bool need_railcom_cutout()
    {
        return (outputDisableReasons_ == 0) && (isRailcomCutoutEnabled_ != 0);
    }
 
    static bool should_be_enabled()
    {
        return outputDisableReasons_ == 0;
    }
 
    static void clear_disable_reason(DccOutput::DisableReason bit)
    {
        outputDisableReasons_ &= ~((uint8_t)bit);
    }
 
protected:
    static void set_disable_reason_impl(DccOutput::DisableReason bit)
    {
        outputDisableReasons_ |= (uint8_t)bit;
    }
 
private:
    DccOutputHw();
};
 
template <int N>
std::atomic_uint_least8_t DccOutputHw<N>::outputDisableReasons_ {
    (uint8_t)DccOutput::DisableReason::INITIALIZATION_PENDING};
template <int N>
std::atomic_uint_least8_t DccOutputHw<N>::isRailcomCutoutEnabled_ {
    (uint8_t)DccOutput::RailcomCutout::LONG_CUTOUT};
template <int N> uint8_t DccOutputHw<N>::isRailcomCutoutActive_ {0};
 
template <int N> struct DccOutputHwDummy : public DccOutputHw<N>
{
public:
    static void hw_preinit(void)
    {
    }
 
    static unsigned start_railcom_cutout_phase1(void)
    {
        return 0;
    }
 
    static unsigned start_railcom_cutout_phase2(void)
    {
        return 0;
    }
 
    static unsigned stop_railcom_cutout_phase1(void)
    {
        return 0;
    }
 
    static void stop_railcom_cutout_phase2(void)
    {
    }
 
    static void enable_output(void)
    {
    }
 
    static bool need_railcom_cutout()
    {
        return false;
    }
 
    static void set_disable_reason(DccOutput::DisableReason bit)
    {
        DccOutputHwDummy::set_disable_reason_impl(bit);
        // no actual output needs to be disabled.
    }
};
 
template <int N, class BOOSTER_ENABLE, class RAILCOM_ENABLE,
    unsigned DELAY_ON_1, unsigned DELAY_ON_2, unsigned DELAY_OFF>
struct DccOutputHwReal : public DccOutputHw<N>
{
public:
    static void hw_preinit(void)
    {
        BOOSTER_ENABLE::hw_init();
        BOOSTER_ENABLE::set(false);
        RAILCOM_ENABLE::hw_init();
        RAILCOM_ENABLE::set(false);
    }
 
    static unsigned start_railcom_cutout_phase1(void)
    {
        BOOSTER_ENABLE::set(false);
        return DELAY_ON_1;
    }
 
    static unsigned start_railcom_cutout_phase2(void)
    {
        RAILCOM_ENABLE::set(true);
        return DELAY_ON_2;
    }
 
    static unsigned stop_railcom_cutout_phase1(void)
    {
        RAILCOM_ENABLE::set(false);
        return DELAY_OFF;
    }
 
    static void stop_railcom_cutout_phase2(void)
    {
    }
 
    static void enable_output(void)
    {
        BOOSTER_ENABLE::set(true);
    }
 
    static void set_disable_reason(DccOutput::DisableReason bit)
    {
        DccOutputHw<N>::set_disable_reason_impl(bit);
        BOOSTER_ENABLE::set(false);
    }
};
 
#endif // _DCC_DCCOUTPUT_HXX_