commAdapter.hpp

Go to the documentation of this file.

 
#ifndef DCS_ANDOR_LIB_COM_ADPT_HPP_H_
#define DCS_ANDOR_LIB_COM_ADPT_HPP_H_
 
#include <stdint.h>
#include <vector>
#include <cstdint>
#include <type_traits>
#include "atcore.h"
 
 
#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/fgf/common_llnetio/defines.hpp>
#include <ifw/fgf/andor/rtmsLlnetioPublisher.hpp>
#include <ifw/fgf/andor/camAndor.hpp>
#include <ifw/fgf/andor/statusParam.hpp>
#include <ifw/fgf/andor/setupParam.hpp>
 
 
typedef std::unique_ptr<AT_U8[]> image_t;
 
// Define a helper type trait to check if a type is in a list of types
template<typename T, typename... Types>
struct is_any_of;
 
template<typename T>
struct is_any_of<T> : std::false_type {};
 
template<typename T, typename U, typename... Types>
struct is_any_of<T, U, Types...> : std::conditional_t<std::is_same_v<T, U>, std::true_type, is_any_of<T, Types...>> {};
 
 
namespace ifw::fgf::andor {
 
class Config;
 
 
const double      CONNECT_TIMEOUT             = 10.0;
const double      FRAME_REC_THR_SLEEP_TIME    = 0.0005;
const uint16_t    MAX_NB_OF_RECEP_BUFFERS     = 10;
const uint16_t    NB_OF_INPUT_BUFFERS         = 5;
const int32_t     DEFAULT_PACKET_SIZE         = 1500;
const uint32_t    STREAM_BYTES_PER_SECOND_MIN = 1000000;
const uint32_t    STREAM_BYTES_PER_SECOND_MAX = 248000000; // 12400000;
const int         TIMEOUTMS                   = 30000;
const short       RPC_SUCCESS                 = 0;
const short       RPC_ERROR                   = -1;
const short       FEATURE_ERROR               = -5;
const AT_64       ALIGNMENT = 16;
constexpr const char* BALOR_TYPE = "Balor";
constexpr const char* MARANA_TYPE = "Marana";
constexpr const char* SIM_TYPE = "Andor SimCam";
constexpr const char* CAMERA_INTERFACE = "CoaXPress";
enum CameraType {
    UNKNOWN = 0,
    BALOR = 1,
    MARANA = 2,
    SIM = 3
};
 
 
enum RpcError: short {
    PARAM_SETUP_ERROR = -1
};

// struct RtmsNetworkConfig is in the publisher header, used transitively.
 
 
    using AndorCtrlEnumKey = std::variant<ifw::fgf::common::SetupParam::ParamEnum, 
                                           ifw::fgf::andor::SetupParam::ParamEnum>;

    struct AndorCtrlEnumKeyHash {
    std::size_t operator()(const AndorCtrlEnumKey& 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 AndorStatEnumKey = std::variant<ifw::fgf::common::StatusParam::StatusEnum, 
                                         ifw::fgf::andor::StatusParam::StatusEnum, 
                                         ifw::fgf::common::SetupParam::ParamEnum, 
                                         ifw::fgf::andor::SetupParam::ParamEnum>;
 
    struct AndorStatEnumKeyHash {
    std::size_t operator()(const AndorStatEnumKey& 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 fgf::common::ICommAdapter {
public:
 
     // Method that returns an error string given an error code
     // Surprisingly, the Andor SDK does not have a function for this.
    static std::string getErrorMessage(int errorCode) {
        auto it = enumerated_errors.find(errorCode);
        if (it != enumerated_errors.end()) {
            return it->second;
        }
        return "Unknown error";  // Default for unknown error codes
    }
 

    CommAdapter(const RtmsNetworkConfig& rtms_cfg,
                std::string_view config_filename = "",
                bool compute_latency = false,
                const PublisherThreadConfig& thread_cfg = PublisherThreadConfig());

    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 Start() override;

    virtual short Stop() override;

    virtual short Init();
 
    virtual std::string GetLoggers();
 
    virtual short SetLogLevel(std::string& level, std::string& logger);

    virtual short Reset() override;
 

    virtual short Setup() ;
 
private:

    virtual void Run();

    virtual void Monitor();

    void StartAcqThread();

    void StartMonThread();

    void StopAcqThread();

    void StopMonThread();

    short SetupAcquisition();
 
 
    int SetupFeatures();
    int ReadFeatures();
    void SetSetupParam(ifw::fgf::andor::AndorCtrlEnumKey key, const ifw::fgf::common::Variant& value);

    void GetStatusParam(ifw::fgf::andor::AndorStatEnumKey key, ifw::fgf::common::Variant& value) const;
 
 

    void WaitForInitialisation();

    void GetCameraInfo();

    void GetCameraStatus();

    void StartAcquisition();

    void WaitForEmptyQueue(const int timeout_ms) const;

    template<typename T>
    typename std::enable_if<is_any_of<T, bool, int, double, long long>::value, int>::type
    SetParam(const AT_WC* feature, T value);

    template<typename T>
    typename std::enable_if<is_any_of<T, bool, int, double, long long>::value, int>::type
    GetParam(const AT_WC* feature, T& value);
 
    template<typename T>
    typename std::enable_if<is_any_of<T, std::string>::value, int>::type
    GetParam(const AT_WC* feature, T& value);
    template<typename T>
    typename std::enable_if<is_any_of<T, const AT_WC*, const wchar_t*>::value, int>::type
    SetParam(const AT_WC* feature, T value);
 
    template<typename T>
    typename std::enable_if<is_any_of<T, std::string_view>::value, int>::type
    SetParam(const AT_WC* feature, T value);

    int GetEnumParam(const AT_WC* feature, std::string& value);
 
 
 
protected:

    std::shared_ptr<ifw::fgf::common::RawImage> m_rawimage;
    int   m_img_bpp{0};
    int   m_img_width{0};
    int   m_img_height{0};
 
private:
    std::unique_ptr<RtmsLlnetioPublisher> m_publisher;

    std::condition_variable m_acq_condvar;

    std::condition_variable m_mon_condvar;

    std::mutex m_mtx;

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

    CameraType m_cam_type{CameraType::UNKNOWN};

    std::thread m_acq_thread;
    std::thread m_mon_thread;
 
    fgf::common::CameraSetup m_cam_setup;
    fgf::andor::CameraSetup m_andor_setup;
    fgf::common::CameraStatus m_cam_status;
    fgf::andor::CameraStatus m_andor_status;
    log4cplus::Logger  m_logger;

    double m_mudpi_basetimestamp{0.0};
 
    // Andor specific member attributes
    std::vector<image_t> images;
    int m_buffer_segments{1000};
    int m_number_frames{1000};
    unsigned char * m_image_buffer{nullptr};
    unsigned char *m_image_data{nullptr};
    unsigned char** m_acq_buffers;
    unsigned char** m_aligned_buffers;
    int m_cam_id{0};
    int m_cam_handle{AT_HANDLE_UNINITIALISED};
    unsigned int m_frame_counter{0};
    AT_64 m_width, m_height;
    AT_64 m_size_in_bytes;
    AT_64 m_timestamp_clock_freq;
    int m_buffer_size{0};
 
    std::string m_config_filename{};
    std::unique_ptr<fgf::andor::Config>  m_config;
 
    // Static maps for different error categories
    static const std::map<int, std::string> enumerated_errors;
 
 
};
 
 
// Specialization for types using a custom type trait
 
template<typename T>
typename std::enable_if<is_any_of<T, bool, int, double, long long>::value, int>::type
CommAdapter::SetParam(const AT_WC* feature, T value) {
    int i_err = AT_SUCCESS;
 
    size_t len = std::wcstombs(nullptr, feature, 0);
    std::string command(len, '\0');
    std::wcstombs(&command[0], feature, len);
 
    const std::string msg = "Setting " + command + " to " + std::to_string(value) + " ...";
    LOG4CPLUS_INFO(m_logger, msg);
 
    if (std::is_same_v<T, AT_64>) {
        LOG4CPLUS_DEBUG(m_logger, "long long type");
        i_err = AT_SetInt(m_cam_handle, feature, value);
    } else if (std::is_same_v<T, AT_BOOL>) {
        LOG4CPLUS_DEBUG(m_logger, "SDK boolean type");
        i_err = AT_SetBool(m_cam_handle, feature, value);
    } else if (std::is_same_v<T, bool>) {
        AT_BOOL bool_value = value ? AT_TRUE : AT_FALSE;
        LOG4CPLUS_DEBUG(m_logger, "boolean type");
        i_err = AT_SetBool(m_cam_handle, feature, bool_value);
    } else if (std::is_same_v<T, double>) {
        LOG4CPLUS_DEBUG(m_logger, "double type");
        i_err = AT_SetFloat(m_cam_handle, feature, value);
    }
    if (i_err != AT_SUCCESS) {
        const std::string msg = "Failure setting " + command + ", SDK error: " +
                getErrorMessage(i_err);
        LOG4CPLUS_ERROR(m_logger, msg);
        m_andor_status.cmd_error_text = msg;
    }
    return i_err;
}
 
template<typename T>
typename std::enable_if<is_any_of<T, bool, int, double, long long>::value, int>::type
CommAdapter::GetParam(const AT_WC* feature, T& value) {
    int i_err = AT_SUCCESS;
 
    size_t len = std::wcstombs(nullptr, feature, 0);
    std::string command(len, '\0');
    std::wcstombs(&command[0], feature, len);
 
    const std::string msg = "Getting " + command +  "...";
    LOG4CPLUS_INFO(m_logger, msg);
 
    if (std::is_same_v<T, AT_64>) {
        LOG4CPLUS_DEBUG(m_logger, "long long type");
        AT_64 local_value;
        i_err = AT_GetInt(m_cam_handle, feature, &local_value);
        if (i_err == AT_SUCCESS) {
            LOG4CPLUS_INFO(m_logger, "Read " << command << "=" << local_value);
            value = static_cast<T>(local_value); // Assign to the output value
        }
    } else if (std::is_same_v<T, bool>) {
        LOG4CPLUS_DEBUG(m_logger, "boolean type");
        AT_BOOL local_value;
        i_err = AT_GetBool(m_cam_handle, feature, &local_value);
        if (i_err == AT_SUCCESS) {
            LOG4CPLUS_INFO(m_logger, "Read " << command << "=" << local_value);
            if (local_value == AT_TRUE) {
                value = true;
            } else {
                value = false;
            }
        }
    } else if (std::is_same_v<T, AT_BOOL>) {
        LOG4CPLUS_DEBUG(m_logger, "boolean type");
        AT_BOOL local_value;
        i_err = AT_GetBool(m_cam_handle, feature, &local_value);
        if (i_err == AT_SUCCESS) {
            LOG4CPLUS_INFO(m_logger, "Read " << command << "=" << local_value);
            value = static_cast<T>(local_value); // Assign to the output value
        }
    } else if (std::is_same_v<T, double>) {
        LOG4CPLUS_DEBUG(m_logger, "double type");
        double local_value;
        i_err = AT_GetFloat(m_cam_handle, feature, &local_value);
        if (i_err == AT_SUCCESS) {
            LOG4CPLUS_INFO(m_logger, "Read " << command << "=" << local_value);
            value = static_cast<T>(local_value); // Assign to the output value
        }
    } 
    if (i_err != AT_SUCCESS) {
        const std::string msg = "Failure getting " + command + ", SDK error: " +
                getErrorMessage(i_err);
        LOG4CPLUS_ERROR(m_logger, msg);
        m_andor_status.cmd_error_text = msg;
    }
    return i_err;
}
 
template<typename T>
typename std::enable_if<is_any_of<T, std::string>::value, int>::type
CommAdapter::GetParam(const AT_WC* feature, T& value) {
    int i_err = AT_SUCCESS;
 
    size_t len = std::wcstombs(nullptr, feature, 0);
    std::string command(len, '\0');
    std::wcstombs(&command[0], feature, len);
 
    const std::string msg = "Getting " + command +  "...";
    LOG4CPLUS_INFO(m_logger, msg);
 
    int length = 0;
    i_err = AT_GetStringMaxLength(m_cam_handle,feature, &length);
    if(AT_SUCCESS != i_err) {
        LOG4CPLUS_ERROR(m_logger,"Problems getting maximum string length");
        return i_err;
    }
 
    std::vector<AT_WC> string_value(static_cast<size_t>(length));
    string_value.resize(static_cast<size_t>(length));
    i_err = AT_GetString(m_cam_handle,feature,string_value.data(), static_cast<int>(string_value.size()));
    if(i_err == AT_SUCCESS) {
        std::string local_value;
        local_value = std::string(string_value.begin(), string_value.end());
        value = static_cast<T>(local_value); // Assign to the output value
        LOG4CPLUS_INFO(m_logger, "Read " << command << "=" << value);
 
        // Special case, the CameraName defines the camera type used to
        // differentiate the two cameras.
        if (feature == std::wstring(L"CameraName")) {
            char szStr[32];
            wcstombs(szStr, &string_value[0],string_value.size());
            std::string camera_type{szStr};
 
            if (camera_type == std::string(MARANA_TYPE)) {
                m_cam_type = CameraType::MARANA;
                LOG4CPLUS_INFO(m_logger,"Andor Marana ");
            } else  if (camera_type == std::string(BALOR_TYPE)) {
                m_cam_type = CameraType::BALOR;
                LOG4CPLUS_INFO(m_logger,"Andor Balor ");
            } else  if (camera_type == std::string(SIM_TYPE)) {
                m_cam_type = CameraType::SIM;
                LOG4CPLUS_INFO(m_logger,"Andor Sim Camera ");
            } else {
                LOG4CPLUS_ERROR(m_logger,"Wrong camera name ");
            }
        }   
         string_value.clear();
    }
 
 
    if (i_err != AT_SUCCESS) {
        const std::string msg = "Failure getting " + command + ", SDK error: " +
                getErrorMessage(i_err);
        LOG4CPLUS_ERROR(m_logger, msg);
        m_andor_status.cmd_error_text = msg;
    }
    return i_err;
}
 
// Specialization for const wchar_t* (or AT_WC*)
template<typename T>
typename std::enable_if<is_any_of<T, const AT_WC*, const wchar_t*>::value, int>::type
CommAdapter::SetParam(const AT_WC* feature, T value) {
 
    int i_err = AT_SUCCESS;
 
    size_t len = std::wcstombs(nullptr, feature, 0);
    std::string command(len, '\0');
    std::wcstombs(&command[0], feature, len);
 
    size_t lenval = std::wcstombs(nullptr, value, 0);
    std::string strvalue(lenval, '\0');
    std::wcstombs(&strvalue[0], value, lenval);
 
    const std::string msg = "Setting " + command + " to " + strvalue + " ...";
    LOG4CPLUS_INFO(m_logger, msg);
 
    i_err =  AT_SetEnumString(m_cam_handle, feature, value);
    if (i_err != AT_SUCCESS) {
        const std::string msg = "Failure setting " + command + ", SDK error: " +
                getErrorMessage(i_err);
        LOG4CPLUS_ERROR(m_logger, msg);
        m_andor_status.cmd_error_text = msg;
    }
    return i_err;
}
 
// Specialization for const std::string
template<typename T>
typename std::enable_if<is_any_of<T, std::string_view>::value, int>::type
CommAdapter::SetParam(const AT_WC* feature, T value) {
 
    int i_err = AT_SUCCESS;
 
    size_t len = value.length() + 1; // +1 for null terminator
    std::vector<wchar_t> wstr_value(len);
    std::mbstowcs(&wstr_value[0], value.data(), len);
 
    len = std::wcstombs(nullptr, feature, 0);
    std::string command(len, '\0');
    std::wcstombs(&command[0], feature, len);
 
 
 
    //const std::string msg = "Setting " + command + " to " + std::string(value.data()) + " ...";
    LOG4CPLUS_INFO(m_logger, "Setting " << command <<  " to " << value <<  " ...");
 
    i_err =  AT_SetEnumString(m_cam_handle, feature, &wstr_value[0]);
    if (i_err != AT_SUCCESS) {
        const std::string msg = "Failure setting " + command + ", SDK error: " +
                getErrorMessage(i_err);
        LOG4CPLUS_ERROR(m_logger, msg);
        m_andor_status.cmd_error_text = msg;
    }
    return i_err;
}
 
 
 
}
 
#endif // DCS_ANDOR_LIB_COM_ADPT_HPP_H_