...

CMakeLists.txt

@@ -13,6 +13,7 @@ find_package(spdlog REQUIRED)
 find_package(CFITSIO REQUIRED)
 find_package(XCLIB REQUIRED)
 
+
 set(RAPTOR_EAGLEV_LIB raptor_eaglev)
 add_library(${RAPTOR_EAGLEV_LIB} SHARED
     raptor_eagle_ccd.h raptor_eagle_ccd.cpp
@@ -25,7 +26,7 @@ target_compile_definitions(${RAPTOR_EAGLEV_LIB} PRIVATE USE_SPDLOG_LIBRARY)
 # !!!!! TEMPORARY !!!!!
 target_include_directories(${RAPTOR_EAGLEV_LIB} PRIVATE "../ADC/")
 target_include_directories(${RAPTOR_EAGLEV_LIB} PRIVATE ${XCLIB_INCLUDE_DIR})
-target_link_libraries(${RAPTOR_EAGLEV_LIB} PUPLIC Threads::Threads spdlog::spdlog)
+target_link_libraries(${RAPTOR_EAGLEV_LIB} PUBLIC Threads::Threads spdlog::spdlog_header_only ${XCLIB_LIBRARIES})
 
 add_executable(RaptorEagleV main.cpp)
 

raptor_eagle_acqproc.cpp

@@ -1,3 +1,4 @@
+#include <fitsio.h>
 #include <cmath>
 #include "raptor_eagle_ccd.h"
 
@@ -74,6 +75,48 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
         isAcqInProgress = false;
 
         // save to FITS file
+
+        _manager->logInfo("Try to save FITS file with name '{}'", _acqParams->filename);
+
+        fitsfile* fitsFilePtr;
+        int status = 0;
+
+        int naxis = 2;
+        long naxes[naxis];
+        naxes[0] = _acqParams->roiWidth;
+        naxes[1] = _acqParams->roiHeight;
+
+        char err_str[100];
+
+        fits_clear_errmsg();
+
+        fits_create_file(&fitsFilePtr, _acqParams->filename.c_str(), &status);
+
+        // keywords from user template file
+        if (_acqParams->templateFilename.size() && !status) {
+            _manager->logDebug("Copy keywords from '{}' template file", _acqParams->templateFilename);
+            fits_write_key_template(fitsFilePtr, _acqParams->templateFilename.c_str(), &status);
+            if (status) {  // ignore possible errors
+                fits_get_errstatus(status, err_str);
+                _manager->logWarn(
+                    "An error occured while copy keywords from the template file '{}' (err = {}, msg = {})! Ignore!",
+                    _acqParams->templateFilename, status, err_str);
+
+                status = 0;
+            }
+        }
+
+        // the keywords
+
+        fits_update_key_str(fitsFilePtr, "ORIGIN", "SAO RAS", NULL, &status);
+        fits_update_key_str(fitsFilePtr, "CREATOR", "RaptorEagleV control software", NULL, &status);
+
+
+        fits_close_file(fitsFilePtr, &status);
+
+        fits_get_errstatus(status, err_str);
+
+        _manager->logInfo("FITS file '{}' is saved", _acqParams->filename);
     });
 }
 

raptor_eagle_ccd.cpp

@@ -1022,7 +1022,7 @@ void RaptorEagleCCD::initAttrComm()
                 _permanentFitsKeywords.push_back(key);
             }
         },
-        [this](const std::vector<std::string>& keys) {  // serialize as "USER_FITS_KEY_SEP_SEQ" separated char sequences
+        [](const std::vector<std::string>& keys) {  // serialize as "USER_FITS_KEY_SEP_SEQ" separated char sequences
             attribute_t::serialized_t res;
 
             if (keys.size() > 1) {
@@ -1036,7 +1036,7 @@ void RaptorEagleCCD::initAttrComm()
 
             return res;
         },
-        [this](const attribute_t::serialized_t& char_seq) {
+        [](const attribute_t::serialized_t& char_seq) {
             std::vector<std::string> keys;
             for (auto const& key : char_seq | std::views::split(USER_FITS_KEY_SEP_SEQ)) {
                 keys.push_back({key.begin(), key.end()});
@@ -1062,7 +1062,7 @@ void RaptorEagleCCD::initAttrComm()
                 _currentFitsKeywords.push_back(key);
             }
         },
-        [this](const std::vector<std::string>& keys) {  // serialize as "USER_FITS_KEY_SEP_SEQ" separated char sequences
+        [](const std::vector<std::string>& keys) {  // serialize as "USER_FITS_KEY_SEP_SEQ" separated char sequences
             attribute_t::serialized_t res;
 
             if (keys.size() > 1) {
@@ -1076,7 +1076,7 @@ void RaptorEagleCCD::initAttrComm()
 
             return res;
         },
-        [this](const attribute_t::serialized_t& char_seq) {
+        [](const attribute_t::serialized_t& char_seq) {
             std::vector<std::string> keys;
             for (auto const& key : char_seq | std::views::split(USER_FITS_KEY_SEP_SEQ)) {
                 keys.push_back({key.begin(), key.end()});
@@ -1467,6 +1467,18 @@ void RaptorEagleCCD::initAttrComm()
             writeRegisters(CL_READMODE_ADDR, {bits});
 
             logDebug("Readout mode is set to 0x{:02X} bits", bits);
+        },
+        adc::utils::AdcDefaultValueConverter<>::serialize<attribute_t::serialized_t, std::string_view>,
+        [](const attribute_t::serialized_t& v) {
+            auto comp_case_ignore = [](const auto& v1, const auto& v2) { return std::toupper(v1) == v2; };
+
+            if (std::ranges::equal(v, CAMERA_ATTR_READ_MODE_NORMAL, comp_case_ignore)) {
+                return CAMERA_ATTR_READ_MODE_NORMAL;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_READ_MODE_TEST, comp_case_ignore)) {
+                return CAMERA_ATTR_READ_MODE_TEST;
+            }
+
+            return CAMERA_ATTR_STR_INVALID;
         });
 
 
@@ -1508,6 +1520,18 @@ void RaptorEagleCCD::initAttrComm()
             writeRegisters(CL_FRAMERATE_ADDR, bytes);
 
             logDebug("Readout rate is set to [0x{:02X}, 0x{:02X}] bytes", bytes[0], bytes[1]);
+        },
+        adc::utils::AdcDefaultValueConverter<>::serialize<attribute_t::serialized_t, std::string_view>,
+        [](const attribute_t::serialized_t& v) {
+            auto comp_case_ignore = [](const auto& v1, const auto& v2) { return std::toupper(v1) == v2; };
+
+            if (std::ranges::equal(v, CAMERA_ATTR_READ_RATE_FAST, comp_case_ignore)) {
+                return CAMERA_ATTR_READ_RATE_FAST;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_READ_RATE_SLOW, comp_case_ignore)) {
+                return CAMERA_ATTR_READ_RATE_SLOW;
+            }
+
+            return CAMERA_ATTR_STR_INVALID;
         });
 
 
@@ -1552,6 +1576,20 @@ void RaptorEagleCCD::initAttrComm()
             writeRegisters(CL_SHUTTER_CONTROL_ADDR, bytes);
 
             logDebug("Shutter state is set to 0x{:02X}", bytes[0]);
+        },
+        adc::utils::AdcDefaultValueConverter<>::serialize<attribute_t::serialized_t, std::string_view>,
+        [](const attribute_t::serialized_t& v) {
+            auto comp_case_ignore = [](const auto& v1, const auto& v2) { return std::toupper(v1) == v2; };
+
+            if (std::ranges::equal(v, CAMERA_ATTR_SHUTTER_STATE_EXP, comp_case_ignore)) {
+                return CAMERA_ATTR_SHUTTER_STATE_EXP;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_SHUTTER_STATE_CLOSED, comp_case_ignore)) {
+                return CAMERA_ATTR_SHUTTER_STATE_CLOSED;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_SHUTTER_STATE_OPEN, comp_case_ignore)) {
+                return CAMERA_ATTR_SHUTTER_STATE_OPEN;
+            }
+
+            return CAMERA_ATTR_STR_INVALID;
         });
 
 
@@ -1674,6 +1712,24 @@ void RaptorEagleCCD::initAttrComm()
             }
 
             logDebug("Trigger mode bits are set to 0b{:08b}", bits);
+        },
+        adc::utils::AdcDefaultValueConverter<>::serialize<attribute_t::serialized_t, std::string_view>,
+        [](const attribute_t::serialized_t& v) {
+            auto comp_case_ignore = [](const auto& v1, const auto& v2) { return std::toupper(v1) == v2; };
+
+            if (std::ranges::equal(v, CAMERA_ATTR_TRIGGER_MODE_EXT_RISING, comp_case_ignore)) {
+                return CAMERA_ATTR_TRIGGER_MODE_EXT_RISING;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_TRIGGER_MODE_EXT_FALLING, comp_case_ignore)) {
+                return CAMERA_ATTR_TRIGGER_MODE_EXT_FALLING;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_TRIGGER_MODE_FFR, comp_case_ignore)) {
+                return CAMERA_ATTR_TRIGGER_MODE_FFR;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_TRIGGER_MODE_ITR, comp_case_ignore)) {
+                return CAMERA_ATTR_TRIGGER_MODE_ITR;
+            } else if (std::ranges::equal(v, CAMERA_ATTR_TRIGGER_MODE_SNAPSHOT, comp_case_ignore)) {
+                return CAMERA_ATTR_TRIGGER_MODE_SNAPSHOT;
+            }
+
+            return CAMERA_ATTR_STR_INVALID;
         });
 
     logDebug("Attributes and commands are successfully created!");