DccDecoder.hxx

Go to the documentation of this file.

 
#include "RailcomDriver.hxx" // for debug pins
#include "dcc/Receiver.hxx"
#include "dcc/PacketProcessor.hxx"
#include "dcc/packet.h"
 
template <class Module> class DccDecoder : public Node
{
public:
    DccDecoder(const char *name, RailcomDriver *railcom_driver);
 
    ~DccDecoder()
    {
        inputData_->destroy();
    }
 
    void set_packet_processor(dcc::PacketProcessor *p)
    {
        packetProcessor_ = p;
    }
 
    inline void interrupt_handler() __attribute__((always_inline));
 
    inline void rcom_interrupt_handler() __attribute__((always_inline));
 
    inline void os_interrupt_handler() __attribute__((always_inline));
 
private:
    ssize_t read(File *file, void *buf, size_t count) OVERRIDE {
        HASSERT((count % inputData_->member_size()) == 0);
        unsigned max = count / inputData_->member_size();
        while (true)
        {
            portENTER_CRITICAL();
            unsigned copied = inputData_->get((input_data_type *)buf, max);
            if (!decoder_.pkt() && inputData_->space())
            {
                DCCPacket* next;
                inputData_->data_write_pointer(&next);
                decoder_.set_packet(next);
            }
            portEXIT_CRITICAL();
            if (copied > 0)
            {
                return copied * inputData_->member_size();
            }
            if (file->flags & O_NONBLOCK)
            {
                return -EAGAIN;
            }
            inputData_->block_until_condition(file, true);
        }
    }
 
    ssize_t write(File *file, const void *buf, size_t count) OVERRIDE
    {
        return -EINVAL;
    }
 
    bool select(File *file, int mode) OVERRIDE
    {
        bool retval = false;
        portENTER_CRITICAL();
        switch (mode)
        {
            case FREAD:
                if (inputData_->pending() > 0)
                {
                    retval = true;
                }
                else
                {
                    inputData_->select_insert();
                }
                break;
            default:
                break;
        }
        portEXIT_CRITICAL();
        return retval;
    }
 
    void enable() override;  
    void disable() override; 
    void flush_buffers() override
    {
        inputData_->flush();
    };
 
#ifdef DCC_DECODER_DEBUG
    LogRing<uint16_t, 256> debugLog_;
#endif
    
    typedef DCCPacket input_data_type;
    DeviceBuffer<DCCPacket> *inputData_ {
        DeviceBuffer<DCCPacket>::create(Module::Q_SIZE)};
    bool nextPacketFilled_{false};
    uint32_t lastTimerValue_;
    uint32_t nextSample_;
    bool sampleActive_ = false;
    unsigned lastLevel_;
    bool waitSampleForOverflow_ = false;
    bool inCutout_ = false;
    bool prepCutout_ = false;
    uint32_t cutoutState_;
    uint32_t packetId_ = 0;
    //uint32_t overflowCount_ {0};
 
    RailcomDriver *railcomDriver_;
 
    dcc::PacketProcessor* packetProcessor_ = nullptr;
 
    dcc::DccDecoder decoder_ {Module::get_ticks_per_usec()};
 
    static const auto RAILCOM_CUTOUT_PRE = 26;
    static const auto RAILCOM_CUTOUT_MID = 185;
    static const auto RAILCOM_CUTOUT_END = 471;
 
    DISALLOW_COPY_AND_ASSIGN(DccDecoder);
};
 
template <class Module>
DccDecoder<Module>::DccDecoder(const char *name, RailcomDriver *railcom_driver)
    : Node(name)
    , railcomDriver_(railcom_driver)
{
    Module::NRZ_Pin::hw_init();
    Module::module_init();
    disable();
}
 
template <class Module> void DccDecoder<Module>::enable()
{
    disable();
 
    Module::module_enable();
    Module::set_cap_timer_capture();
 
    lastTimerValue_ = Module::TIMER_MAX_VALUE;
    nextSample_ = lastTimerValue_ - Module::SAMPLE_PERIOD_CLOCKS;
 
    if (!decoder_.pkt() && inputData_->space())
    {
        DCCPacket *next;
        inputData_->data_write_pointer(&next);
        decoder_.set_packet(next);
    }
}
 
template <class Module> void DccDecoder<Module>::disable()
{
    Module::module_disable();
}
 
template <class Module>
__attribute__((optimize("-O3"))) void DccDecoder<Module>::interrupt_handler()
{
    Debug::DccDecodeInterrupts::set(true);
    if (Module::int_get_and_clear_capture_event())
    {
        // We have a capture event at hand.
        // Debug::DccDecodeInterrupts::toggle();
        uint32_t raw_new_value = Module::get_capture_counter();
        uint32_t old_value = lastTimerValue_;
#ifdef DCC_DECODER_DEBUG
        debugLog_.add(0);
        debugLog_.add(old_value);
        debugLog_.add(raw_new_value);
#endif
        if (raw_new_value > old_value) {
            // Timer has overflowed.
            if (nextSample_ < old_value) {
                nextSample_ += Module::TIMER_MAX_VALUE;
            }
            old_value += Module::TIMER_MAX_VALUE;
            waitSampleForOverflow_ = false;
            Debug::CapTimerOverflow::set(false);
        }
        if (raw_new_value < nextSample_ && !waitSampleForOverflow_) {
            sampleActive_ = true;
            if (nextSample_ <= Module::SAMPLE_PERIOD_CLOCKS)
            {
                nextSample_ += Module::TIMER_MAX_VALUE;
                waitSampleForOverflow_ = true;
                Debug::CapTimerOverflow::set(true);
            }
            nextSample_ -= Module::SAMPLE_PERIOD_CLOCKS;
        }
        uint32_t new_value = old_value - raw_new_value;
#ifdef DCC_DECODER_DEBUG
        debugLog_.add(new_value);
#endif        
        bool cutout_just_finished = false;
        decoder_.process_data(new_value);
        if (decoder_.before_dcc_cutout())
        {
            prepCutout_ = true;
            auto* p = decoder_.pkt();
            if (p)
            {
                p->feedback_key = ++packetId_;
            }
            railcomDriver_->set_feedback_key(packetId_);
            Module::dcc_before_cutout_hook();
        }
        // If we are at the second half of the last 1 bit and the
        // value of the input pin is 1, then we cannot recognize when
        // the first half of the cutout bit disappears thus we'll
        // never get the DCC cutout signal. We will therefore start
        // the cutout by hand with a bit of delay.
        else if (decoder_.state() == dcc::DccDecoder::DCC_MAYBE_CUTOUT &&
            true) // Module::NRZ_Pin::get())
        {
            //Debug::RailcomDriverCutout::set(true);
            Module::set_cap_timer_time();
            Module::set_cap_timer_delay_usec(
                RAILCOM_CUTOUT_PRE + Module::time_delta_railcom_pre_usec());
            inCutout_ = true;
            cutoutState_ = 0;
            if (decoder_.pkt())
            {
                nextPacketFilled_ = true;
            }
            Module::trigger_os_interrupt();
        }
        else if (decoder_.state() == dcc::DccDecoder::DCC_CUTOUT)
        {
            //railcomDriver_->start_cutout();
            //inCutout_ = true;
        }
        else if (decoder_.state() == dcc::DccDecoder::DCC_PACKET_FINISHED)
        {
            Debug::DccPacketFinishedHook::set(true);
            if (inCutout_) {
                //railcomDriver_->end_cutout();
                inCutout_ = false;
            }
            Module::dcc_packet_finished_hook();
            prepCutout_ = false;
            cutout_just_finished = true;
            Debug::DccPacketFinishedHook::set(false);
        }
        lastTimerValue_ = raw_new_value;
        if (sampleActive_ && Module::NRZ_Pin::get() && !prepCutout_ &&
            !cutout_just_finished)
        {
            sampleActive_ = false;
            // The first positive edge after the sample timer expired (but
            // outside of the cutout).
            railcomDriver_->feedback_sample();
            Module::after_feedback_hook();
        }
    }
}
 
template <class Module>
__attribute__((optimize("-O3"))) void
DccDecoder<Module>::rcom_interrupt_handler()
{
    Debug::DccDecodeInterrupts::set(true);
    if (Module::int_get_and_clear_delay_event())
    {
        // Debug::RailcomDriverCutout::set(false);
        switch (cutoutState_)
        {
            case 0:
            {
                Module::set_cap_timer_delay_usec(
                    RAILCOM_CUTOUT_MID + Module::time_delta_railcom_mid_usec());
                railcomDriver_->start_cutout();
                cutoutState_ = 1;
                break;
            }
            case 1:
            {
                Module::set_cap_timer_delay_usec(
                    RAILCOM_CUTOUT_END + Module::time_delta_railcom_end_usec());
                railcomDriver_->middle_cutout();
                cutoutState_ = 2;
                break;
            }
            default:
            {
                Module::stop_cap_timer_time();
                Module::set_cap_timer_capture();
                railcomDriver_->end_cutout();
                inCutout_ = false;
                break;
            }
        }
    }
    Debug::DccDecodeInterrupts::set(false);
}
 
template <class Module>
__attribute__((optimize("-O3"))) void DccDecoder<Module>::os_interrupt_handler()
{
    unsigned woken = 0;
    if (nextPacketFilled_)
    {
        if (packetProcessor_)
        {
            packetProcessor_->packet_arrived(decoder_.pkt(), railcomDriver_);
        }
        inputData_->advance(1);
        nextPacketFilled_ = false;
        inputData_->signal_condition_from_isr();
        woken = 1;
        decoder_.set_packet(nullptr);
    }
    if (!decoder_.pkt() && inputData_->space())
    {
        DCCPacket *next;
        inputData_->data_write_pointer(&next);
        decoder_.set_packet(next);
    }
    portYIELD_FROM_ISR(woken);
}