TractionCvSpace.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_TRACTIONCVSPACE_HXX_
#define _OPENLCB_TRACTIONCVSPACE_HXX_
 
#include "dcc/RailCom.hxx"
#include "dcc/RailcomHub.hxx"
#include "dcc/TrackIf.hxx"
#include "executor/StateFlow.hxx"
#include "openlcb/MemoryConfig.hxx"
 
namespace openlcb
{
 
class TractionCvSpace : private MemorySpace,
                        private dcc::RailcomHubPortInterface,
                        public StateFlowBase
{
public:
    TractionCvSpace(MemoryConfigHandler *parent, dcc::TrackIf *track,
        dcc::RailcomHubFlow *railcom_hub, uint8_t space_id);
 
    ~TractionCvSpace();
 
private:
    static const unsigned MAX_CV = 1023;
 
    bool set_node(Node *node) OVERRIDE;
 
    bool read_only() OVERRIDE
    {
        return false;
    }
 
    address_t max_address() OVERRIDE
    {
        return OFFSET_CV_VALUE;
    }
 
    size_t write(address_t destination, const uint8_t *data, size_t len,
                 errorcode_t *error, Notifiable *again) OVERRIDE;
 
    size_t read(address_t source, uint8_t *dst, size_t len, errorcode_t *error,
                Notifiable *again) OVERRIDE;
 
    // State flow states.
    Action try_read1();
    Action fill_read1_packet();
    Action read_returned();
 
    Action try_write1();
    Action fill_write1_packet();
    Action write_returned();
 
    Action pgm_verify();
    Action pgm_verify_wait_flush();
    Action pgm_verify_reset();
    Action pgm_verify_packet();
    Action pgm_verify_done();
    Action pgm_verify_reset_done();
    Action pgm_verify_exit();
 
    // Railcom feedback
    void send(Buffer<dcc::RailcomHubData> *b, unsigned priority) OVERRIDE;
    void record_railcom_status(unsigned code);
 
    MemoryConfigHandler *parent_;
    dcc::TrackIf *track_;
    dcc::RailcomHubFlow *railcomHub_;
    uint16_t currId_;
    uint16_t dccAddressNum_ : 14;
    uint16_t dccIsLong_ : 1;
    uint16_t cvNumber_;
    uint8_t cvData_;
    uint8_t errorCode_ : 4;
    uint8_t numTry_ : 4;
    enum
    {
        ERROR_NOOP = 0,
        ERROR_PENDING = 1,
        ERROR_OK = 2,
        _ERROR_BUSY = 3,
        ERROR_NACK = 7,
        ERROR_NO_RAILCOM_CH2_DATA = 4,
        ERROR_GARBAGE = 5,
        ERROR_UNKNOWN_RESPONSE = 6,
        _ERROR_TIMEOUT = 8,
    };
 
public:
    enum
    {
        OFFSET_CV_INDEX = 0x7F000000,
        OFFSET_CV_VALUE = 0x7F000004,
        OFFSET_CV_VERIFY_VALUE = 0x7F000005,
        OFFSET_CV_VERIFY_RESULT = 0x7F000006,
    };
 
private:
    Action async_done()
    {
        done_->notify();
        done_ = nullptr;
        return exit();
    }
 
    uint8_t spaceId_;
    uint16_t lastIndexedNode_;
    uint8_t lastVerifyValue_;
    uint32_t lastIndexedCv_;
 
    Notifiable *done_; //< notify when transfer is done
    StateFlowTimer timer_;
    long long deadline_;  //< time when we should give up and return error.
    vector<dcc::RailcomPacket> interpretedResponse_;
};
 
} // namespace openlcb
 
#endif // _OPENLCB_TRACTIONCVSPACE_HXX_