deviceFacade.hpp

Go to the documentation of this file.

 
#ifndef FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
#define FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_
 
#include <functional>
#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/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,
                     std::function<void()> on_failure,
                     std::function<void()> on_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;

        std::string GetDeviceType(const std::string& devname) 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();

        std::function<void()> GetFailureCB();

        std::function<void()> 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;
        std::function<void()>   m_on_failure;

        std::function<void()>   m_on_normal;
      private:
        log4cplus::Logger           m_logger;
      };
    }
  }
}  // namespace devmgr::Common
 
#endif  // FCF_DEVMGR_COMMON_DEVICE_FACADE_HPP_