deviceFacade.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
#define FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
 
#include <list>
 
#include <rad/smAdapter.hpp>
#include <rad/topicPub.hpp>
#include <rad/anyEvent.hpp>
#include <rad/activity.hpp>
#include <ifw/core/utils/bat/logger.hpp>
 
#include <ifw/core/protocol/base/dispatcher.hpp>
#include <ifw/fcf/devmgr/common/device.hpp>
#include <ifw/fcf/devmgr/common/events.rad.hpp>
 
 
namespace ifw::fcf {
  namespace devmgr {
    namespace common {
 
      struct DaqInfo {
 
        void StartDaq(std::string filename);
        void StopDaq(std::string filename);
        void AbortDaq(std::string msg);
        bool IsActive();
        bool IsStopped();
 
        ::metadaqif::DaqState GetState() const noexcept;
        void SetState(::metadaqif::DaqState state);
        std::string GetMsg() const noexcept;
        std::vector<std::string> GetFiles() const noexcept;
        double GetTimestamp()  const noexcept;
 
        private:
         ::metadaqif::DaqState    m_state{::metadaqif::DaqState::Undefined};
        std::string              m_msg{""};
        std::vector<std::string> m_files;
        double                   m_timestamp{0};
      };
 
      class Config;
      class IDevice;
 
      class DeviceFacade {
      public:
        DeviceFacade(rad::SMAdapter& sm,
                     Config& config,
                     ifw::core::protocol::base::Dispatcher<>& failure,
                     ifw::core::protocol::base::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 AsyncSetup(const std::any& payload);
 
        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() const;
 
        virtual std::string DevInfo() const;
 
        virtual std::string DevConfig(const std::string devname) const;
 
        void StartDaq(std::string daqid);
 
        virtual void AddCustomStartStatus(const ifw::core::dit::did::Did& dictionary,
                                          std::shared_ptr<CCfits::FITS>& fits_handle);
 
        ifw::fcf::devmgr::common::DaqInfo StopDaq(std::string daqid);
 
        virtual void AddCustomStopStatus(const ifw::core::dit::did::Did& dictionary,
                                          std::shared_ptr<CCfits::FITS>& fits_handle);
 
       void AbortDaq(std::string daqid);
 
       ifw::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();
 
        ifw::core::protocol::base::Dispatcher<>& GetFailureCB();
 
        ifw::core::protocol::base::Dispatcher<>& GetNormalCB();
 
        const int GetNumDevices() const noexcept;
 
        void CheckDeviceName(const std::vector<std::string>& devices) const;
 
      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();
 
    private:
        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;        
        Config&                               m_config;
        std::string                           m_dp_filename; 
        std::map<std::string, fcf::devmgr::common::DaqInfo>    m_daq;
        ifw::core::protocol::base::Dispatcher<>   m_failure;
 
        ifw::core::protocol::base::Dispatcher<>   m_normal;
      private:
        log4cplus::Logger           m_logger;
      };
    }
  }
}  // namespace devmgr::Common
 
#endif  // FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_