Loco.hxx

Go to the documentation of this file.

 
#ifndef _DCC_LOCO_HXX_
#define _DCC_LOCO_HXX_
 
#include "dcc/Defs.hxx"
#include "dcc/Packet.hxx"
#include "dcc/PacketSource.hxx"
#include "dcc/UpdateLoop.hxx"
#include "utils/constants.hxx"
#include "utils/logging.h"
 
DECLARE_CONST(dcc_virtual_f0_offset);
 
namespace dcc
{
 
enum DccTrainUpdateCode
{
    REFRESH = 0,
    SPEED = 1,
    FUNCTION0 = 2,
    FUNCTION5 = 3,
    FUNCTION9 = 4,
    FUNCTION13 = 5,
    FUNCTION21 = 6,
    FUNCTION29 = 7,
    FUNCTION37 = 8,
    FUNCTION45 = 9,
    FUNCTION53 = 10,
    FUNCTION61 = 11,
    MM_F1 = 2,
    MM_F2,
    MM_F3,
    MM_F4,
    MIN_REFRESH = SPEED,
    MAX_REFRESH = FUNCTION9,
    MM_MAX_REFRESH = 7,
    ESTOP = 16,
};
 
template <class P> class AbstractTrain : public PacketSource
{
public:
    AbstractTrain()
    {
    }
 
    void set_speed(SpeedType speed) OVERRIDE
    {
        float16_t new_speed = speed.get_wire();
        if (p.lastSetSpeed_ == new_speed)
        {
            LOG(VERBOSE, "not updating speed: old speed %04x, new speed %04x",
                p.lastSetSpeed_, new_speed);
            return;
        }
        p.lastSetSpeed_ = new_speed;
        p.isEstop_ = false;
        unsigned previous_light = get_effective_f0();
        if (speed.direction() != p.direction_)
        {
            p.directionChanged_ = 1;
            p.direction_ = speed.direction();
            update_f0_direction_changed();
        }
        float f_speed = speed.mph();
        if (f_speed > 0)
        {
            f_speed *= ((p.get_speed_steps() * 1.0) / 126);
            unsigned sp = f_speed + 0.5; // round
            if (sp == 0) // ceiling between speed step 0 and 1
            {
                sp = 1;
            }
            if (sp > p.get_speed_steps())
            {
                sp = p.get_speed_steps();
            }
            LOG(VERBOSE, "set speed to step %u", sp);
            p.speed_ = sp;
        }
        else
        {
            p.speed_ = 0;
        }
        unsigned light = get_effective_f0();
        if (previous_light && !light)
        {
            // Turns off light first then sends speed packet.
            packet_processor_notify_update(this, p.get_fn_update_code(0));
        }
        packet_processor_notify_update(this, SPEED);
        if (light && !previous_light)
        {
            // Turns on light after sending speed packets.
            packet_processor_notify_update(this, p.get_fn_update_code(0));
        }
    }
 
    SpeedType get_speed() OVERRIDE
    {
        SpeedType v;
        v.set_wire(p.lastSetSpeed_);
        return v;
    }
    SpeedType get_commanded_speed() OVERRIDE
    {
        return get_speed();
    }
    void set_emergencystop() OVERRIDE
    {
        p.speed_ = 0;
        p.isEstop_ = true;
        SpeedType dir0;
        dir0.set_direction(p.direction_);
        p.lastSetSpeed_ = dir0.get_wire();
        p.directionChanged_ = 1;
        packet_processor_notify_update(this, ESTOP);
    }
    bool get_emergencystop() OVERRIDE
    {
        return p.isEstop_;
    }
    void set_fn(uint32_t address, uint16_t value) OVERRIDE
    {
        const uint32_t virtf0 = config_dcc_virtual_f0_offset();
        if (address == 0 && p.f0SetDirectional_)
        {
            if (p.direction_ == 0)
            {
                p.f0OnForward_ = value ? 1 : 0;
            }
            else
            {
                p.f0OnReverse_ = value ? 1 : 0;
            }
            // continue into the handling of f0.
        }
        else if (address == virtf0 + VIRTF0_DIRECTIONAL_ENABLE)
        {
            if (value)
            {
                p.f0SetDirectional_ = 1;
                // Populates new state of separate f0 forward and f0
                // reverse.
                if (p.direction_ == 0)
                {
                    p.f0OnForward_ = p.get_fn_store(0);
                    p.f0OnReverse_ = 0;
                }
                else
                {
                    p.f0OnReverse_ = p.get_fn_store(0);
                    p.f0OnForward_ = 0;
                }
            }
            else
            {
                p.f0SetDirectional_ = 0;
                // whatever value we have in fn_[0] now is going to be the
                // new state, so we don't change anything.
            }
            // This command never changes f0, so no packets need to be sent to
            // the track.
            return;
        }
        else if (address == virtf0 + VIRTF0_BLANK_FWD)
        {
            p.f0BlankForward_ = value ? 1 : 0;
            packet_processor_notify_update(this, p.get_fn_update_code(0));
            return;
        }
        else if (address == virtf0 + VIRTF0_BLANK_REV)
        {
            p.f0BlankReverse_ = value ? 1 : 0;
            packet_processor_notify_update(this, p.get_fn_update_code(0));
            return;
        }
        if (address > p.get_max_fn())
        {
            // Ignore.
            return;
        }
        p.set_fn_store(address, value);
        packet_processor_notify_update(this, p.get_fn_update_code(address));
    }
    uint16_t get_fn(uint32_t address) OVERRIDE
    {
        const uint32_t virtf0 = config_dcc_virtual_f0_offset();
        if (address == virtf0 + VIRTF0_DIRECTIONAL_ENABLE)
        {
            return p.f0SetDirectional_;
        }
        else if (address == virtf0 + VIRTF0_BLANK_FWD)
        {
            return p.f0BlankForward_;
        }
        else if (address == virtf0 + VIRTF0_BLANK_REV)
        {
            return p.f0BlankReverse_;
        }
        if (address > p.get_max_fn())
        {
            // Unknown.
            return 0;
        }
        return p.get_fn_store(address) ? 1 : 0;
    }
    uint32_t legacy_address() OVERRIDE
    {
        return p.address_;
    }
    TrainAddressType legacy_address_type() OVERRIDE
    {
        return p.get_address_type();
    }
 
protected:
    static constexpr unsigned VIRTF0_DIRECTIONAL_ENABLE = 0;
    static constexpr unsigned VIRTF0_BLANK_FWD = 1;
    static constexpr unsigned VIRTF0_BLANK_REV = 2;
 
    unsigned get_effective_f0()
    {
        unsigned is_on = p.f0SetDirectional_ == 0 ? (p.fn_ & 1)
            : p.direction_ == 0                   ? p.f0OnForward_
                                                  : p.f0OnReverse_;
        if (p.direction_ == 0 && p.f0BlankForward_)
        {
            is_on = 0;
        }
        if (p.direction_ == 1 && p.f0BlankReverse_)
        {
            is_on = 0;
        }
        return is_on;
    }
 
    void update_f0_direction_changed()
    {
        if (p.f0SetDirectional_)
        {
            p.fn_ &= ~1;
            if (p.direction_ == 0 && p.f0OnForward_)
            {
                p.fn_ |= 1;
            }
            if (p.direction_ == 1 && p.f0OnReverse_)
            {
                p.fn_ |= 1;
            }
        }
    }
 
    P p;
};
 
struct DccPayloadBase
{
    uint16_t address_ : 14;
    uint16_t isShortAddress_ : 1;
    uint16_t direction_ : 1;
    uint16_t lastSetSpeed_ : 16;
 
    // ==== 32-bit boundary ====
 
    unsigned fn_ : 29;
    uint8_t nextRefresh_ : 3;
 
    // ==== 32-bit boundary ====
 
    uint8_t isEstop_ : 1;
    uint8_t directionChanged_ : 1;
    uint8_t f0SetDirectional_ : 1;
    uint8_t f0OnForward_ : 1;
    uint8_t f0OnReverse_ : 1;
    uint8_t f0BlankForward_ : 1;
    uint8_t f0BlankReverse_ : 1;
    uint8_t speed_ : 7;
 
    uint8_t fhi_[5];
 
    static unsigned get_max_fn()
    {
        return 68;
    }
 
    void set_fn_store(unsigned idx, bool value)
    {
        if (idx < 29)
        {
            if (value)
            {
                fn_ |= (1u << idx);
            }
            else
            {
                fn_ &= ~(1u << idx);
            }
        }
        else
        {
            idx -= 29;
            if (value)
            {
                fhi_[idx / 8] |= (1u << (idx & 7));
            }
            else
            {
                fhi_[idx / 8] &= ~(1u << (idx & 7));
            }
        }
    }
 
    bool get_fn_store(unsigned idx)
    {
        if (idx < 29)
        {
            return (fn_ & (1u << idx)) != 0;
        }
        else
        {
            idx -= 29;
            return (fhi_[idx / 8] & (1u << (idx & 7))) != 0;
        }
    }
 
    static unsigned get_fn_update_code(unsigned address);
    
    TrainAddressType get_address_type()
    {
        return isShortAddress_ ? TrainAddressType::DCC_SHORT_ADDRESS
                               : TrainAddressType::DCC_LONG_ADDRESS;
    }
};
 
struct Dcc28Payload : public DccPayloadBase
{
    Dcc28Payload()
    {
        memset(this, 0, sizeof(*this));
    }
    
    static unsigned get_speed_steps()
    {
        return 28;
    }
 
    void add_dcc_speed_to_packet(dcc::Packet *p)
    {
        p->add_dcc_speed28(!direction_, speed_);
    }
 
    void add_dcc_estop_to_packet(dcc::Packet *p)
    {
        p->add_dcc_speed28(!direction_, Packet::EMERGENCY_STOP);
    }
};
 
static_assert(sizeof(Dcc28Payload) == 16, "size of dcc payload is wrong");
 
template <class Payload> class DccTrain : public AbstractTrain<Payload>
{
public:
    DccTrain(DccShortAddress a)
    {
        this->p.isShortAddress_ = 1;
        this->p.address_ = a.value;
        packet_processor_add_refresh_source(this);
    }
 
    DccTrain(DccLongAddress a)
    {
        this->p.isShortAddress_ = 0;
        this->p.address_ = a.value;
        packet_processor_add_refresh_source(this);
    }
 
    ~DccTrain();
 
    void get_next_packet(unsigned code, Packet *packet) OVERRIDE;
};
 
typedef DccTrain<Dcc28Payload> Dcc28Train;
 
struct Dcc128Payload : public DccPayloadBase
{
    Dcc128Payload()
    {
        memset(this, 0, sizeof(*this));
    }
 
    static unsigned get_speed_steps()
    {
        return 126;
    }
 
    void add_dcc_speed_to_packet(dcc::Packet *p)
    {
        p->add_dcc_speed128(!direction_, speed_);
    }
 
    void add_dcc_estop_to_packet(dcc::Packet *p)
    {
        p->add_dcc_speed128(!direction_, Packet::EMERGENCY_STOP);
    }
};
 
typedef DccTrain<Dcc128Payload> Dcc128Train;
 
struct MMOldPayload
{
    MMOldPayload()
    {
        memset(this, 0, sizeof(*this));
    }
    unsigned address_ : 8;
    unsigned lastSetSpeed_ : 16;
    unsigned fn_ : 1;
    unsigned direction_ : 1;
    unsigned directionChanged_ : 1;
    unsigned speed_ : 4;
    unsigned isEstop_ : 1;
 
    unsigned f0SetDirectional_ : 1;
    unsigned f0OnForward_ : 1;
    unsigned f0OnReverse_ : 1;
    unsigned f0BlankForward_ : 1;
    unsigned f0BlankReverse_ : 1;
 
    unsigned get_speed_steps()
    {
        return 14;
    }
 
    unsigned get_max_fn()
    {
        return 0;
    }
 
    void set_fn_store(unsigned idx, bool value) {
        if (value)
        {
            fn_ |= (1u << idx);
        }
        else
        {
            fn_ &= ~(1u << idx);
        }
    }
 
    bool get_fn_store(unsigned idx)
    {
        return (fn_ & (1u << idx)) != 0;
    }
    
    unsigned get_fn_update_code(unsigned address)
    {
        return SPEED;
    }
 
    static TrainAddressType get_address_type()
    {
        return TrainAddressType::MM;
    }
};
 
class MMOldTrain : public AbstractTrain<MMOldPayload>
{
public:
    MMOldTrain(MMAddress a);
    ~MMOldTrain();
 
    void get_next_packet(unsigned code, Packet *packet) OVERRIDE;
};
 
struct MMNewPayload
{
    MMNewPayload()
    {
        memset(this, 0, sizeof(*this));
    }
    unsigned address_ : 8;
    unsigned lastSetSpeed_ : 16;
    unsigned fn_ : 5;
    unsigned direction_ : 1;
    unsigned directionChanged_ : 1;
    unsigned resvd1_ : 1;
    unsigned speed_ : 4;
    unsigned nextRefresh_ : 3;
    unsigned isEstop_ : 1;
 
    unsigned f0SetDirectional_ : 1;
    unsigned f0OnForward_ : 1;
    unsigned f0OnReverse_ : 1;
    unsigned f0BlankForward_ : 1;
    unsigned f0BlankReverse_ : 1;
 
    unsigned get_speed_steps()
    {
        return 14;
    }
 
    unsigned get_max_fn()
    {
        return 4;
    }
 
    void set_fn_store(unsigned idx, bool value) {
        if (value)
        {
            fn_ |= (1u << idx);
        }
        else
        {
            fn_ &= ~(1u << idx);
        }
    }
 
    bool get_fn_store(unsigned idx)
    {
        return (fn_ & (1u << idx)) != 0;
    }
 
    unsigned get_fn_update_code(unsigned address)
    {
        if (1 <= address && address <= 4)
        {
            return MM_F1 + address - 1;
        }
        else
        {
            return SPEED;
        }
    }
 
    static TrainAddressType get_address_type()
    {
        return TrainAddressType::MM;
    }
};
 
class MMNewTrain : public AbstractTrain<MMNewPayload>
{
public:
    MMNewTrain(MMAddress a);
    ~MMNewTrain();
 
    void get_next_packet(unsigned code, Packet *packet) OVERRIDE;
};
 
} // namespace dcc
 
#endif // _DCC_LOCO_HXX_