shutterConfig.hpp

Go to the documentation of this file.

#ifndef DEVMGR_DEVICE_SHUTTER_CONFIG_HPP
#define DEVMGR_DEVICE_SHUTTER_CONFIG_HPP

// System headers
#include <string>

// Third party headers
#include <yaml-cpp/yaml.h>

#include <fcf/common/iComm.hpp>
#include <devmgr/common/deviceConfig.hpp>
#include <devmgr/common/configSet.hpp>
#include <devmgr/common/dataContext.hpp>
#include <devmgr/devices/shutterRpcErrors.hpp>
#include <devmgr/devices/shutterHwErrors.hpp>

namespace devmgr {
  namespace shutter {

    // Constants for internal mapping
    const std::string CI_ACTIVE_LOW_CLOSED    = "low_closed";
    const std::string CI_ACTIVE_LOW_FAULT     = "low_fault";
    const std::string CI_ACTIVE_LOW_OPEN      = "low_open";
    const std::string CI_ACTIVE_LOW_SWITCH    = "low_switch";
    const std::string CI_IGNORE_CLOSED        = "ignore_closed";
    const std::string CI_IGNORE_FAULT         = "ignore_fault";
    const std::string CI_IGNORE_OPEN          = "ignore_open";
    const std::string CI_INITIAL_STATE        = "initial_state";
    const std::string CI_TIMEOUT              = "timeout";

    const bool DEFAULT_ACTIVE_LOW_CLOSE       = false;
    const bool DEFAULT_ACTIVE_LOW_FAULT       = false;
    const bool DEFAULT_ACTIVE_LOW_OPEN        = false;
    const bool DEFAULT_ACTIVE_LOW_SWITCH      = false;
    const bool DEFAULT_IGNORE_CLOSED          = false;
    const bool DEFAULT_IGNORE_FAULT           = false;
    const bool DEFAULT_IGNORE_OPEN            = false;
    const bool DEFAULT_INITIAL_STATE          = false;
    const unsigned int DEFAULT_TIMEOUT        = 10000;

    // Specific shutter RPC
    const std::string RPC_OPEN                = "rpcOpen";
    const std::string RPC_CLOSE               = "rpcClose";

    // Specific constant values for shutter device state/substate
    const short SUBSTATE_NOTREADY             =  100;
    const short SUBSTATE_INITIALISING         =  101;
    const short SUBSTATE_READY_CLOSE          =  102;
    const short SUBSTATE_READY_OPEN           =  103;
    const short SUBSTATE_STANDBY_FAILURE      =  104;

    const short SUBSTATE_OP_DISABLING         =  200;
    const short SUBSTATE_OP_CLOSE             =  201;
    const short SUBSTATE_OP_CLOSING           =  202;
    const short SUBSTATE_OP_OPEN              =  203;
    const short SUBSTATE_OP_OPENING           =  204;
    const short SUBSTATE_OP_FAILURE           =  205;

    const std::string SUBSTATE_NOTREADY_STR      =  "NotReady";
    const std::string SUBSTATE_INITIALISING_STR  =  "Initialising";
    const std::string SUBSTATE_READY_CLOSE_STR   =  "Ready/Close";
    const std::string SUBSTATE_READY_OPEN_STR    =  "Ready/Open";
    const std::string SUBSTATE_FAILURE_STR       =  "Failure";

    const std::string SUBSTATE_OP_DISABLING_STR  =  "Disabling";
    const std::string SUBSTATE_OP_CLOSE_STR      =  "Close";
    const std::string SUBSTATE_OP_CLOSING_STR    =  "Closing";
    const std::string SUBSTATE_OP_OPEN_STR       =  "Open";
    const std::string SUBSTATE_OP_OPENING_STR    =  "Opening";
    const std::string SUBSTATE_OP_FAILURE_STR    =  "Failure";

    const std::unordered_map<short, std::string>  SubstateMap = {
      {SUBSTATE_NOTREADY,       SUBSTATE_NOTREADY_STR},
      {SUBSTATE_INITIALISING,   SUBSTATE_INITIALISING_STR},
      {SUBSTATE_READY_CLOSE,    SUBSTATE_READY_CLOSE_STR},
      {SUBSTATE_READY_OPEN,     SUBSTATE_READY_OPEN_STR},
      {SUBSTATE_STANDBY_FAILURE,SUBSTATE_FAILURE_STR},
      {SUBSTATE_OP_DISABLING,   SUBSTATE_OP_DISABLING_STR},
      {SUBSTATE_OP_CLOSE,       SUBSTATE_OP_CLOSE_STR},
      {SUBSTATE_OP_CLOSING,     SUBSTATE_OP_CLOSING_STR},
      {SUBSTATE_OP_OPEN,        SUBSTATE_OP_OPEN_STR},
      {SUBSTATE_OP_OPENING,     SUBSTATE_OP_OPENING_STR},
      {SUBSTATE_OP_FAILURE,     SUBSTATE_OP_FAILURE_STR},
    };

    const std::vector<std::string> cfgMapping = {
      CI_ACTIVE_LOW_FAULT,
      CI_ACTIVE_LOW_OPEN,
    };

    const std::vector<std::string> statMapping = {
      devmgr::common::CI_STAT_SUBSTATE,
      devmgr::common::CI_STAT_STATE,
      devmgr::common::CI_STAT_LOCAL,
      devmgr::common::CI_STAT_ERROR_CODE
    };

    const std::vector<std::string> rpcMapping = {
      devmgr::common::RPC_INIT,
      devmgr::common::RPC_ENABLE,
      devmgr::common::RPC_DISABLE,
      devmgr::common::RPC_RESET,
      devmgr::common::RPC_STOP,
      RPC_CLOSE,
      RPC_OPEN
    };

    class ShutterConfig : public devmgr::common::DeviceConfig {

      // Enumerations of configuration paramters
      enum {
        CFG_IGCLOSED    = 0,
        CFG_IGFAULT     = 1,
        CFG_IGOPEN      = 2,
        CFG_LOWCLOSED   = 3,
        CFG_LOWFAULT    = 4,
        CFG_LOWOPEN     = 5,
        CFG_LOWSWITCH   = 6,
        CFG_INITSTATE   = 7,
        CFG_TIMEOUT     = 8,
        END_ENUM_SHUTTER // WARNING: This should be always last enumerator.
      };

    public:

      ShutterConfig(const std::string filename,
                    const std::string name);

      virtual ~ShutterConfig();

      virtual void ReadConfig();

      virtual void GetConfig(fcf::common::VectorVariant& params);

      virtual std::string  GetMapFile();

      virtual void GetConfigList(std::vector<std::string>& cfg_list, std::string prefix);



    private:
      devmgr::common::MapCfgBool   m_map_cfg_bool; 
      devmgr::common::MapCfgUInt   m_map_cfg_uint; 

    };
  }
}


#endif //DEVMGR_DEVICE_SHUTTER_CONFIG_HPP