commAdapter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#include <vector>
#include <cstdint>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <memory>
#include <string>
#include <variant>
 
#include <ifw/odp/cppcpl/imageCube.hpp>
#include <ifw/odp/cppcpl/image.hpp>
 
#include <ifw/fnd/tools/tools.hpp>
 
#include <ifw/fgf/common_llnetio/rawImage.hpp>
#include <ifw/fgf/common_llnetio/logger.hpp>
#include <ifw/fgf/common_llnetio/camBase.hpp>
#include <ifw/fgf/common_llnetio/iCommAdapter.hpp>
#include <ifw/rtmslib_llnetio/rtmsSender.hpp>
 
 
namespace sbss::fgf::dvc {
 
    struct RtmsNetworkConfig {
        std::string                   src_ip;
        std::string                   dest_ip;
        int                           dest_port{0};
        ifw::rtmslib::SenderConfig    sender_cfg{};
    };
 
    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(const RtmsNetworkConfig& rtms_cfg, 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;
 
    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;
        void EnsureRtmsSender(int width, int height, int bpp);
        void PublishFrame(const std::shared_ptr<ifw::fgf::common::RawImage>& raw_image);
 
    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:
        // Vector storing FITS planes to be used for the simulation
        std::vector<std::vector<uint8_t>> m_image_data_vector;
        mutable std::mutex                 m_image_data_mtx;

        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;
        RtmsNetworkConfig               m_rtms_cfg;
        std::unique_ptr<ifw::rtmslib::RtmsSender> m_rtms_sender;
        int                              m_active_sender_bpp{0};
        size_t                           m_active_sender_size{0};
 
        double                                    m_sim_im_acq_period{0.0};
        ifw::fnd::tools::LoopFrequencyCalculator  m_frame_rate_calculator;
    };
 
}