deviceFacade.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
#define FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
 
// System headers
#include <list>
 
// Local headers
#include <rad/smAdapter.hpp>
#include <rad/topicPub.hpp>
#include <rad/anyEvent.hpp>
#include <rad/activity.hpp>
 
#include <fcf/common/dispatcher.hpp>
#include <fcf/devmgr/common/device.hpp>
#include <fcf/devmgr/common/events.rad.hpp>
 
namespace fcf {
  namespace devmgr {
    namespace common {
 
      struct DaqInfo {
        ::metadaqif::DaqState    m_state{::metadaqif::DaqState::Undefined};
        std::string              m_msg{""};
        std::vector<std::string> m_files;
        double                   m_timestamp{0};
 
        void StartDaq(std::string filename);
        void StopDaq(std::string filename);
        void AbortDaq(std::string msg);
        bool IsActive();
        bool IsStopped();
      };
 
      class Config;
      class IDevice;
 
      class DeviceFacade {
      public:
        DeviceFacade(rad::SMAdapter& sm,
                     IConfig& config,
                     fcf::common::Dispatcher<>& failure,
                     fcf::common::Dispatcher<>& normal);
 
        virtual     ~DeviceFacade();
 
        virtual bool Init(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
        virtual bool Enable(rad::SMAdapter& sm, rad::ThreadActivity* activity);
 
        virtual bool Recover(rad::SMAdapter& sm, rad::ThreadActivity* activity);
        virtual bool Disable();
 
        virtual bool Setup(const std::any& payload, rad::ThreadActivity* activity);
        virtual void Stop();
 
        virtual void Reset();
 
        virtual void Status(const std::any& payload, std::string& buffer);
 
 
        virtual void Simulate(rad::AnyEvent const& last_event);
 
        virtual void StopSim(rad::AnyEvent const& last_event);
 
        virtual void Ignore(rad::AnyEvent const& last_event);
 
        virtual void StopIgn(rad::AnyEvent const& last_event);
 
        virtual void HwReset(rad::AnyEvent const& last_event);
 
        virtual void HwInit(rad::AnyEvent const& last_event);
 
        virtual void HwEnable(rad::AnyEvent const& last_event);
 
        virtual void HwDisable(rad::AnyEvent const& last_event);
 
        virtual std::string DevNames();
 
        virtual std::string DevInfo();
 
        virtual std::string DevConfig(const std::string devname);
 
        void StartDaq(std::string daqid);
 
        fcf::devmgr::common::DaqInfo StopDaq(std::string daqid);
 
       void AbortDaq(std::string daqid);
 
       fcf::devmgr::common::DaqInfo GetDaqStatus(std::string daqid) const;
 
        void    TriggerInternalEvent(rad::SMAdapter& sm, rad::UniqueEvent&& e);
 
        void    AddDevice(std::shared_ptr<IDevice> device);
 
        void    ClearDevices();
 
        fcf::common::Dispatcher<>& GetFailureCB();
 
        fcf::common::Dispatcher<>& GetNormalCB();
 
        const int GetNumDevices();
 
      private:
 
        DeviceFacade(const DeviceFacade&) = delete;             
        DeviceFacade& operator= (const DeviceFacade&) = delete; 
 
        void InitSync(rad::ThreadActivity* activity,
                      std::chrono::system_clock::time_point start_time,
                      bool& stopped,
                      bool& timeout);
 
        void EnableSync(rad::ThreadActivity* activity,
                        std::chrono::system_clock::time_point start_time,
                        bool& stopped,
                        bool& timeout);
 
        void DeviceFailureCB();
 
        void DeviceNormalCB();
 
        void CheckDeviceName(const std::vector<std::string>& devices) const;
 
        std::vector<std::shared_ptr<IDevice> >  m_devices;   
        std::vector<std::string>  m_device_names;   
        boost::asio::io_service               m_ios;       
        rad::SMAdapter&                       m_sm;        
        IConfig&                              m_config;
        std::string                           m_dp_filename; 
        std::map<std::string, fcf::devmgr::common::DaqInfo>    m_daq;
        fcf::common::Dispatcher<>   m_failure;
 
        fcf::common::Dispatcher<>   m_normal;
      };
    }
  }
}  // namespace devmgr::Common
 
#endif  // FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_