commAdapter.hpp

Go to the documentation of this file.

 
#ifndef FGF_DVC_COM_ADAPTER_HPP_H_
#define FGF_DVC_COM_ADAPTER_HPP_H_
 
#include <stdint.h>
#include <vector>
#include <cstdint>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <mutex>
 
#include <ifw/odp/cppcpl/imageCube.hpp>
#include <ifw/odp/cppcpl/image.hpp>
 
#include <ifw/fnd/tools/tools.hpp>
 
#include <ifw/fgf/common/rawImage.hpp>
#include <ifw/fgf/common/rtmsPublisher.hpp>
#include <ifw/fgf/common/logger.hpp>
#include <ifw/fgf/common/camBase.hpp>
#include <ifw/fgf/common/iCommAdapter.hpp>
 
 
namespace sbss::fgf::dvc {
 
    using DevCtrlEnumKey = std::variant<ifw::fgf::common::SetupParam::ParamEnum>;
 
    struct DevCtrlEnumKeyHash {
    std::size_t operator()(const DevCtrlEnumKey& key) const {
        return std::visit([](auto&& arg) -> std::size_t {
            return std::hash<std::underlying_type_t<std::decay_t<decltype(arg)>>>()
                (static_cast<std::underlying_type_t<std::decay_t<decltype(arg)>>>(arg));
        }, key);
      }
    };
 
   using DevStatEnumKey = std::variant<ifw::fgf::common::StatusParam::StatusEnum, 
                                       ifw::fgf::common::SetupParam::ParamEnum>;
 
    struct DevStatEnumKeyHash {
    std::size_t operator()(const DevStatEnumKey& key) const {
        return std::visit([](auto&& arg) -> std::size_t {
            return std::hash<std::underlying_type_t<std::decay_t<decltype(arg)>>>()
                (static_cast<std::underlying_type_t<std::decay_t<decltype(arg)>>>(arg));
        }, key);
      }
    };
 

    class CommAdapter: public ifw::fgf::common::ICommAdapter {
    public:
 
        CommAdapter(ifw::fgf::common::RtmsPublisher& publisher, const std::string& filename);
 
        virtual ~CommAdapter();

        virtual void Initialise();

        virtual void CheckConnection(bool& connected);

        virtual void Connect();

        virtual void Disconnect();

        virtual bool IsConnected() const;

        virtual void Read(ifw::fgf::common::VectorVariant& params) const override;

        virtual void Read(ifw::fgf::common::PairVariant& param) const override;

        virtual void Write(const ifw::fgf::common::VectorVariant& params) override;

        virtual void Write(const ifw::fgf::common::PairVariant& param) override;

        virtual short Setup() override;

        virtual short Start() override;

        virtual short Stop() override;

        virtual short Reset() override;

        //virtual short GetLoggers() override; // TODO: Return value should be std::string
        virtual std::string GetLoggers() override;

        virtual short SetLogLevel(std::string& level, std::string& logger) override;
 
        void WaitForEmptyQueue(const int timeout_ms) const;
 
    private:
        virtual void Run();
        void StartAcqThread();
        void StopAcqThread();
        void FillDataVectors();
        void SerialiseDataInt(const ifw::odp::Image& image, std::vector<uint8_t>& datavec) const;
        void SetSetupParam(fgf::dvc::DevCtrlEnumKey key,
                           const ifw::fgf::common::Variant& value);
        void GetParam(fgf::dvc::DevStatEnumKey key,
                      ifw::fgf::common::Variant& value) const;
 
    protected:
 
        // Pointer to latest received image
        std::shared_ptr<ifw::fgf::common::RawImage> m_raw_image;
        int   m_img_bpp{0};
        int   m_img_width{0};
        int   m_img_height{0};
 
    private:
        // Reference to the RTMS publisher
        ifw::fgf::common::RtmsPublisher& m_publisher;
 
        // Vector storing FITS planes to be used for the simulation
        std::vector<std::vector<uint8_t>> m_image_data_vector;

        static std::atomic<bool>   m_stopped;
        std::atomic<bool>          m_acq_active{false};
        std::atomic<bool>          m_acq_running{false};

        std::thread                m_acq_thread;
        std::string                m_filename;
        ifw::fgf::common::CameraSetup   m_cam_setup;
        ifw::fgf::common::CameraStatus  m_cam_status;
        log4cplus::Logger          m_logger;
 
        double                                    m_sim_im_acq_period{0.0};
        ifw::fnd::tools::LoopFrequencyCalculator  m_frame_rate_calculator;
    };
 
}
 
#endif // FGF_DVC_COM_ADAPTER_HPP_H_