mxs-usrs.hh

Go to the documentation of this file.

      #ifndef __MXS_USRS_HH__
      #define __MXS_USRS_HH__
      
      #include <string>
      #include <global-types.h>
      #include <usr.hh>
      #include <usrset.hh>
      #include <mxs-device.hh>
      #include <platform.h>
      #include <devinfo.hh>

      
      namespace DeviceAccess
      {
      namespace EqModMXS
      {
      static const string EQ_MODEL_NAME = "MXS_03";
    class E_API WriteCONNECT : public DeviceAccess::Usr
    {
    public:
    WriteCONNECT(MXSDevice* dev, const string& propname = "CONNECT") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_ALL, MASTER_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteCONNECT()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadCONNECT : public DeviceAccess::Usr
    {
    public:
    ReadCONNECT(MXSDevice* dev, const string& propname = "CONNECT") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadCONNECT()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WritePOWER : public DeviceAccess::Usr
    {
    public:
    WritePOWER(MXSDevice* dev, const string& propname = "POWER") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_ALL, MASTER_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WritePOWER()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadPOWER : public DeviceAccess::Usr
    {
    public:
    ReadPOWER(MXSDevice* dev, const string& propname = "POWER") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadPOWER()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteINVERTER : public DeviceAccess::Usr
    {
    public:
    WriteINVERTER(MXSDevice* dev, const string& propname = "INVERTER") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_ALL, MASTER_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteINVERTER()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadINVERTER : public DeviceAccess::Usr
    {
    public:
    ReadINVERTER(MXSDevice* dev, const string& propname = "INVERTER") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadINVERTER()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteACTIV : public DeviceAccess::Usr
    {
    public:
    WriteACTIV(MXSDevice* dev, const string& propname = "ACTIV") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_VRTACC, SLAVE_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteACTIV()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadACTIV : public DeviceAccess::Usr
    {
    public:
    ReadACTIV(MXSDevice* dev, const string& propname = "ACTIV") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadACTIV()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadDSTATUS : public DeviceAccess::Usr
    {
    public:
    ReadDSTATUS(MXSDevice* dev, const string& propname = "DSTATUS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadDSTATUS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteFIELDS : public DeviceAccess::Usr
    {
    public:
    WriteFIELDS(MXSDevice* dev, const string& propname = "FIELDS") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_VRTACC, SLAVE_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteFIELDS()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadFIELDS : public DeviceAccess::Usr
    {
    public:
    ReadFIELDS(MXSDevice* dev, const string& propname = "FIELDS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadFIELDS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadFIELDI : public DeviceAccess::Usr
    {
    public:
    ReadFIELDI(MXSDevice* dev, const string& propname = "FIELDI") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadFIELDI()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteCURRENTS : public DeviceAccess::Usr
    {
    public:
    WriteCURRENTS(MXSDevice* dev, const string& propname = "CURRENTS") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_VRTACC, SLAVE_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteCURRENTS()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadCURRENTS : public DeviceAccess::Usr
    {
    public:
    ReadCURRENTS(MXSDevice* dev, const string& propname = "CURRENTS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadCURRENTS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadCURRENTI : public DeviceAccess::Usr
    {
    public:
    ReadCURRENTI(MXSDevice* dev, const string& propname = "CURRENTI") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadCURRENTI()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteVOLTS : public DeviceAccess::Usr
    {
    public:
    WriteVOLTS(MXSDevice* dev, const string& propname = "VOLTS") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_VRTACC, SLAVE_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteVOLTS()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadVOLTS : public DeviceAccess::Usr
    {
    public:
    ReadVOLTS(MXSDevice* dev, const string& propname = "VOLTS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadVOLTS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadVOLTI : public DeviceAccess::Usr
    {
    public:
    ReadVOLTI(MXSDevice* dev, const string& propname = "VOLTI") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadVOLTI()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMAGNINFO : public DeviceAccess::Usr
    {
    public:
    ReadMAGNINFO(MXSDevice* dev, const string& propname = "MAGNINFO") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMAGNINFO()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadCALC : public DeviceAccess::Usr
    {
    public:
    ReadCALC(MXSDevice* dev, const string& propname = "CALC") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadCALC()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadCONSTANT : public DeviceAccess::Usr
    {
    public:
    ReadCONSTANT(MXSDevice* dev, const string& propname = "CONSTANT") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadCONSTANT()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteCOPYSET : public DeviceAccess::Usr
    {
    public:
    WriteCOPYSET(MXSDevice* dev, const string& propname = "COPYSET") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_ALL, SLAVE_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteCOPYSET()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteMAGNSVCS : public DeviceAccess::Usr
    {
    public:
    WriteMAGNSVCS(MXSDevice* dev, const string& propname = "MAGNSVCS") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_ALL, MASTER_PROPERTY, PROP_ACCESS_DEVICE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteMAGNSVCS()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMAGNSVCS : public DeviceAccess::Usr
    {
    public:
    ReadMAGNSVCS(MXSDevice* dev, const string& propname = "MAGNSVCS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMAGNSVCS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMAGNSVCI : public DeviceAccess::Usr
    {
    public:
    ReadMAGNSVCI(MXSDevice* dev, const string& propname = "MAGNSVCI") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMAGNSVCI()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API WriteMEDDATAS : public DeviceAccess::Usr
    {
    public:
    WriteMEDDATAS(MXSDevice* dev, const string& propname = "MEDDATAS") :
    Usr(propname, PROP_MODE_WRITE , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~WriteMEDDATAS()
    {
    }
    virtual AccDevRetStatus write(SLong vrtAcc, const AccData& rcvPara, const AccData& rcvData);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMEDDATAS : public DeviceAccess::Usr
    {
    public:
    ReadMEDDATAS(MXSDevice* dev, const string& propname = "MEDDATAS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMEDDATAS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMEDDATAI : public DeviceAccess::Usr
    {
    public:
    ReadMEDDATAI(MXSDevice* dev, const string& propname = "MEDDATAI") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, SLAVE_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMEDDATAI()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMSTDATAS : public DeviceAccess::Usr
    {
    public:
    ReadMSTDATAS(MXSDevice* dev, const string& propname = "MSTDATAS") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMSTDATAS()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

    class E_API ReadMXSCONST : public DeviceAccess::Usr
    {
    public:
    ReadMXSCONST(MXSDevice* dev, const string& propname = "MXSCONST") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadMXSCONST()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
        virtual AccDevRetStatus readV08(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
      
    private:
    MXSDevice* _dev;
    };

    class E_API ReadINFOSTAT : public DeviceAccess::Usr
    {
    public:
    ReadINFOSTAT(MXSDevice* dev, const string& propname = "INFOSTAT") :
    Usr(propname, PROP_MODE_READ , MEDLOCK_NONE, MASTER_PROPERTY, PROP_ACCESS_FREE, NO_ACCDATATYPE, NO_ACCDATATYPE, 0), _dev(dev)
    {
    }
    
    ~ReadINFOSTAT()
    {
    }
    virtual AccDevRetStatus read(SLong vrtAcc, const AccData& rcvPara, AccData& sndData, AccStamp& stamp, AccEFICD& eficd);
    
    private:
    MXSDevice* _dev;
    };

      
      // -- Add Usrs
      void addUsrs(DeviceAccess::UsrSet& ua, MXSDevice* vd);
      
      } // namespace EqModMXS
      } // namespace DeviceAccess
      
      #endif

---