timur/RaptorEagleV
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rewrite AcquisitionProcess class (use of detached thread)

Browse Source 
code clean-ups
This commit is contained in:
Timur A. Fatkhullin 2025-01-15 00:12:56 +03:00
parent cf3e34f88c
commit 7497b72b32
3 changed files with 124 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
raptor_eagle_acqproc.cpp
View File

@ -40,7 +40,7 @@ double JulianDay(const std::chrono::utc_clock::time_point& tm)
} // namespace details } // namespace details
RaptorEagleCCD::AcquisitionProcess::AcquisitionProcess(RaptorEagleCCD* manager) : _manager(manager) RaptorEagleCCD::AcquisitionProcess::AcquisitionProcess()
{ {
std::stringstream st; std::stringstream st;
st << std::this_thread::get_id(); st << std::this_thread::get_id();
@ -58,17 +58,16 @@ RaptorEagleCCD::AcquisitionProcess::~AcquisitionProcess()
void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_t>& params) void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_t>& params)
{ {
// if (isAcqInProgress) {
// throw std::system_error(RaptorEagleCCDError::ERROR_ACQUISITION_IN_PROGRESS);
// }
isAcqInProgress = true; isAcqInProgress = true;
// _acqParams = std::move(params);
_acqParams = params; _acqParams = params;
// _acqParams->abortTime = std::chrono::utc_clock::time_point(); // to ensure the time point is in past
_snapAndCopyFuture = std::async(std::launch::async, [self = shared_from_this(), this]() { std::thread([self = shared_from_this(), this]() {
{
std::lock_guard lock_guard(serverPtr->_acqProcessesMutex);
acqProcSptr.insert(self);
}
std::chrono::milliseconds timeout = std::chrono::milliseconds timeout =
CAMERA_CAPTURE_TIMEOUT_ADD_CONSTANT + CAMERA_CAPTURE_TIMEOUT_ADD_CONSTANT +
std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(_acqParams->expTime * 1000)); std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(_acqParams->expTime * 1000));
@ -77,6 +76,8 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
std::stringstream st; std::stringstream st;
st << std::this_thread::get_id(); st << std::this_thread::get_id();
_status = STATUS_ARMED;
serverPtr->logDebug("Arm grabber and wait for acquisition starting trigger (thread id: {}) ...", st.str()); serverPtr->logDebug("Arm grabber and wait for acquisition starting trigger (thread id: {}) ...", st.str());
serverPtr->xclibApiCall(pxd_doSnap(serverPtr->_cameraUnitmap, 1, timeout.count()), serverPtr->xclibApiCall(pxd_doSnap(serverPtr->_cameraUnitmap, 1, timeout.count()),
@ -86,14 +87,11 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
if ((_acqParams->abortTime > _acqParams->startTime) && if ((_acqParams->abortTime > _acqParams->startTime) &&
!_acqParams->saveInAbort) { // abort acquisition was occured! just exit !_acqParams->saveInAbort) { // abort acquisition was occured! just exit
serverPtr->logInfo("It seems the acquisition was aborted! Do not save acquired image!");
isAcqInProgress = false; isAcqInProgress = false;
_status = STATUS_IDLE; _status = STATUS_IDLE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE; serverPtr->logInfo("It seems the acquisition was aborted! Do not save acquired image!");
return; return;
} }
@ -105,39 +103,37 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
// compute image dimension // compute image dimension
// NOTE: _acqParams->roiWidth and _acqParams->roiHeight are expected in CCD pixels (not binned)!!! // NOTE: _acqParams->roiWidth and _acqParams->roiHeight are expected in CCD pixels (not binned)!!!
// auto div = std::div(_acqParams->roiWidth - _acqParams->roiStartX, _acqParams->binX);
auto div = std::div(_acqParams->roiWidth, _acqParams->binX); auto div = std::div(_acqParams->roiWidth, _acqParams->binX);
auto dimx = div.quot + (div.rem ? 1 : 0); auto dimx = div.quot + (div.rem ? 1 : 0);
// div = std::div(_acqParams->roiHeight - _acqParams->roiStartY, _acqParams->binY);
div = std::div(_acqParams->roiHeight, _acqParams->binY); div = std::div(_acqParams->roiHeight, _acqParams->binY);
auto dimy = div.quot + (div.rem ? 1 : 0); auto dimy = div.quot + (div.rem ? 1 : 0);
// LONGLONG npix = _acqParams->roiWidth * _acqParams->roiHeight;
LONGLONG npix = dimx * dimy; LONGLONG npix = dimx * dimy;
// NOTE: // NOTE:
auto ldiv = std::lldiv(npix, serverPtr->_dimCCD[0]); auto ldiv = std::lldiv(npix, serverPtr->_dimCCD[0]);
_imageBufferRows = ldiv.quot + (ldiv.rem ? 1 : 0); auto im_buffer_rows = ldiv.quot + (ldiv.rem ? 1 : 0);
bool gap = false; bool gap = false;
if ((_acqParams->roiWidth + _acqParams->roiStartX) < serverPtr->_dimCCD[0]) { if ((_acqParams->roiWidth + _acqParams->roiStartX) < serverPtr->_dimCCD[0]) {
/* IT SEEMS IF MAX ROI X-COORDINATE IS LESS THAN CCD DIM /* IT SEEMS IF MAX ROI X-COORDINATE IS LESS THAN CCD DIM
* EAGLE CAMERA CONTROLLER SETUP READING FOR WIDTH+1 ROI!!! */ * EAGLE CAMERA CONTROLLER SETUP READING FOR WIDTH+1 ROI!!! */
gap = true; gap = true;
++_imageBufferRows; ++im_buffer_rows;
} }
// _imageBufferRows = static_cast<size_t>(std::ceil(npix / serverPtr->_dimCCD[0]));
// read size // read size
// size_t sz = _imageBufferRows * serverPtr->_dimCCD[0]; auto im_buffer_size = im_buffer_rows * serverPtr->_dimCCD[0];
_imageBufferSize = _imageBufferRows * serverPtr->_dimCCD[0];
auto log_str = std::format("pxd_readushort({}, 1, 0, 0, -1, {}, {}, {}, \"{}\")", serverPtr->_cameraUnitmap, auto log_str = std::format("pxd_readushort({}, 1, 0, 0, -1, {}, {}, {}, \"{}\")", serverPtr->_cameraUnitmap,
_imageBufferRows, (void*)_acqParams->imageBufferPtr, _imageBufferSize, color_space); im_buffer_rows, (void*)_acqParams->imageBufferPtr, im_buffer_size, color_space);
serverPtr->xclibApiCall(pxd_readushort(serverPtr->_cameraUnitmap, 1, 0, 0, -1, _imageBufferRows, serverPtr->xclibApiCall(pxd_readushort(serverPtr->_cameraUnitmap, 1, 0, 0, -1, im_buffer_rows,
_acqParams->imageBufferPtr, _imageBufferSize, (char*)color_space), _acqParams->imageBufferPtr, im_buffer_size, (char*)color_space),
log_str); log_str);
@ -150,18 +146,11 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
serverPtr->logWarn("An empty FITS filename is given! Do not save acquired image!"); serverPtr->logWarn("An empty FITS filename is given! Do not save acquired image!");
_status = STATUS_IDLE; _status = STATUS_IDLE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
return; return;
} }
_status = STATUS_SAVE; _status = STATUS_SAVE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end()) +
// std::format(" {}", _acqParams->filename);
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_SAVE;
std::string fname{"!"}; // to overwrite existing file std::string fname{"!"}; // to overwrite existing file
fname += _acqParams->filename; fname += _acqParams->filename;
@ -174,9 +163,6 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
const int naxis = 2; const int naxis = 2;
long naxes[naxis] = {dimx, dimy}; long naxes[naxis] = {dimx, dimy};
// long naxes[2];
// naxes[0] = _acqParams->roiWidth;
// naxes[1] = _acqParams->roiHeight;
char err_str[100]; char err_str[100];
@ -306,24 +292,25 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
} }
} }
// permanent keywords (may update keywords from template file!)
auto save_keywords = [&status, &err_str, &fitsFilePtr](auto& kwd_list, const std::string& mark) {
char card[81]; char card[81];
char kname[9] = " "; char kname[9] = " ";
int k_type; int k_type;
if (_acqParams->permanentKeywords.size()) { if (kwd_list.size()) {
serverPtr->logDebug("Copy {} permanent keywords", _acqParams->permanentKeywords.size()); serverPtr->logDebug("Copy {} {} keywords", mark, kwd_list.size());
} else { } else {
serverPtr->logDebug("There is no one permanent keyword! Skip!"); serverPtr->logDebug("There is no one permanent keyword! Skip!");
} }
for (auto& s : _acqParams->permanentKeywords) { for (auto & s : kwd_list) {
fits_parse_template(s.data(), card, &k_type, &status); fits_parse_template(s.data(), card, &k_type, &status);
if (status) { // ignore possible errors if (status) { // ignore possible errors
fits_get_errstatus(status, err_str); fits_get_errstatus(status, err_str);
serverPtr->logWarn( serverPtr->logWarn(
"An error occured while writing permanent keyword card [{}] (err = {}, msg = {})! " "An error occured while writing {} keyword card [{}] (err = {}, msg = {})! "
"Ignore!", "Ignore!",
s, status, err_str); mark, s, status, err_str);
status = 0; status = 0;
} else { } else {
@ -339,50 +326,21 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
if (status) { if (status) {
fits_get_errstatus(status, err_str); fits_get_errstatus(status, err_str);
serverPtr->logWarn( serverPtr->logWarn(
"An error occured while updating FITS card (name = '{}') (err = {}, msg = {})! Skip!", kname, "An error occured while updating FITS card (name = '{}') (err = {}, msg = {})! Skip!",
status, err_str); kname, status, err_str);
} else { } else {
serverPtr->logTrace("The FITS card (name = '{}') was updated successfully", kname); serverPtr->logTrace("The FITS card (name = '{}') was updated successfully", kname);
} }
} }
};
// permanent keywords (may update keywords from template file!)
save_keywords(_acqParams->permanentKeywords, "permanent");
// keyword from user (may update template file and permanent keywords!) // keyword from user (may update template file and permanent keywords!)
if (_acqParams->currentKeywords.size()) { save_keywords(_acqParams->currentKeywords, "current");
serverPtr->logDebug("Copy {} current keywords", _acqParams->currentKeywords.size());
} else {
serverPtr->logDebug("There is no one current keyword! Skip!");
}
for (auto& s : _acqParams->currentKeywords) {
fits_parse_template(s.data(), card, &k_type, &status);
if (status) { // ignore possible errors
fits_get_errstatus(status, err_str);
serverPtr->logWarn(
"An error occured while writing user keyword card [{}] (err = {}, msg = {})! "
"Ignore!",
s, status, err_str);
status = 0;
} else {
for (int i = 0; i < 8; ++i) {
kname[i] = card[i];
}
} }
serverPtr->logTrace("Try to update [{}] FITS card (name = '{}')", card, kname);
fits_update_card(fitsFilePtr, kname, card, &status);
if (status) {
fits_get_errstatus(status, err_str);
serverPtr->logWarn(
"An error occured while updating FITS card (name = '{}') (err = {}, msg = {})! Skip!", kname,
status, err_str);
} else {
serverPtr->logTrace("The FITS card (name = '{}') was updated successfully", kname);
}
}
}
// hardcoded camera hardware version info keywords // hardcoded camera hardware version info keywords
@ -404,8 +362,6 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
fits_close_file(fitsFilePtr, &status); fits_close_file(fitsFilePtr, &status);
_status = STATUS_IDLE; _status = STATUS_IDLE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
fits_get_errstatus(status, err_str); fits_get_errstatus(status, err_str);
@ -416,13 +372,16 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
serverPtr->logInfo("FITS file '{}' is saved", _acqParams->filename); serverPtr->logInfo("FITS file '{}' is saved", _acqParams->filename);
} }
// _imageBuffer.release();
std::lock_guard lock_guard(serverPtr->_acqProcessesMutex); std::lock_guard lock_guard(serverPtr->_acqProcessesMutex);
serverPtr->_acqRingFreeBufferPtrs.push(_acqParams->imageBufferPtr); // return buffer pointer to queue of free serverPtr->_acqRingFreeBufferPtrs.push(_acqParams->imageBufferPtr); // return buffer pointer to queue of free
serverPtr->logDebug("Return buffer address {} to queue of free", (void*)_acqParams->imageBufferPtr); serverPtr->logDebug("Return buffer address {} to queue of free", (void*)_acqParams->imageBufferPtr);
});
acqProcSptr.erase(self);
}).detach();
} }
@ -433,12 +392,14 @@ void RaptorEagleCCD::AcquisitionProcess::stop(bool save)
_acqParams->saveInAbort = save; _acqParams->saveInAbort = save;
auto bytes = serverPtr->readRegisters({0xD4}); // current trigger mode register // auto bytes = serverPtr->readRegisters({0xD4}); // current trigger mode register
bytes[0] |= CL_ABORT_CURRENT_EXP; // set abort acquisition bit // bytes[0] |= CL_ABORT_CURRENT_EXP; // set abort acquisition bit
_acqParams->abortTime = std::chrono::utc_clock::now(); // _acqParams->abortTime = std::chrono::utc_clock::now();
serverPtr->writeRegisters({0xD4}, bytes); // serverPtr->writeRegisters({0xD4}, bytes);
_acqParams->abortTime = serverPtr->setTriggerRegisterBit(CL_TRIGGER_MODE_ABORT_CURRENT_EXP_BIT);
} else { } else {
serverPtr->logWarn("There was no active acquisition process! Ignore!"); serverPtr->logWarn("There was no active acquisition process! Ignore!");
@ -450,30 +411,35 @@ std::string RaptorEagleCCD::AcquisitionProcess::status()
{ {
std::lock_guard lock(_statusMutex); std::lock_guard lock(_statusMutex);
std::string stat_str;
switch (_status) { switch (_status) {
case STATUS_IDLE: case STATUS_IDLE:
_statusString = std::format("{}", CAMERA_ATTR_CAMERA_STATUS_IDLE); stat_str = std::format("{}", CAMERA_ATTR_CAMERA_STATUS_IDLE);
break;
case STATUS_ARMED: // actually it should not be! but it presents here for debug reasons
stat_str = std::format("{}", CAMERA_ATTR_CAMERA_STATUS_ARMED);
break; break;
case STATUS_ACQ: { case STATUS_ACQ: {
std::chrono::duration<double> curr_exp = std::chrono::utc_clock::now() - _acqParams->startTime; std::chrono::duration<double> curr_exp = std::chrono::utc_clock::now() - _acqParams->startTime;
auto remain_exp = _acqParams->expTime - curr_exp.count(); auto remain_exp = _acqParams->expTime - curr_exp.count();
if (remain_exp < 0) { if (remain_exp < 0) {
_status = STATUS_READ; _status = STATUS_READ;
_statusString = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_READ, _acqParams->filename); stat_str = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_READ, _acqParams->filename);
} else { } else {
_statusString = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_ACQ, remain_exp); stat_str = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_ACQ, remain_exp);
} }
break; break;
} }
case STATUS_READ: case STATUS_READ:
_statusString = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_READ, _acqParams->filename); stat_str = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_READ, _acqParams->filename);
break; break;
case STATUS_SAVE: case STATUS_SAVE:
_statusString = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_SAVE, _acqParams->filename); stat_str = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_SAVE, _acqParams->filename);
break; break;
default: default:
_statusString = "UNKNOWN"; // is should not be!!! stat_str = "UNKNOWN"; // is should not be!!!
} }
return _statusString; return stat_str;
} }

78
raptor_eagle_ccd.cpp
View File

@ -179,8 +179,27 @@ RaptorEagleCCD::RaptorEagleCCD(std::shared_ptr<spdlog::logger> logger)
RaptorEagleCCD::~RaptorEagleCCD() RaptorEagleCCD::~RaptorEagleCCD()
{ {
if (AcquisitionProcess::isAcqInProgress) {
(*this)[CAMERA_CMD_ABORT_EXP];
}
// wait for detached acquisition threads?
if (AcquisitionProcess::acqProcSptr.size()) {
logInfo("DTOR: waiting for the end of the acquisition process {} ...", AcquisitionProcess::acqProcSptr.size() > 1 ? "threads" : "thread");
auto start = std::chrono::utc_clock::now();
while (AcquisitionProcess::acqProcSptr.size()) {
std::this_thread::sleep_for(std::chrono::milliseconds(200));
if ((std::chrono::utc_clock::now() - start) >= std::chrono::milliseconds(2000)) {
break;
}
}
}
closePIXCI(); closePIXCI();
logDebug("DTOR: Delete RaptorEagleCCD class instance"); logDebug("DTOR: Delete RaptorEagleCCD class instance");
} }
@ -1088,21 +1107,7 @@ void RaptorEagleCCD::startAquisition()
} }
// std::lock_guard lock_guard(_acqProcessesMutex); std::make_shared<AcquisitionProcess>()->start(acq_pars);
auto sptr = std::make_shared<AcquisitionProcess>(this);
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) {
if (it->expired()) {
it = _acqProcesses.erase(it);
} else {
break;
}
}
_acqProcesses.emplace_back(sptr);
// arm grabber here
sptr->start(acq_pars);
// start acquisition here // start acquisition here
acq_pars->startTime = setTriggerRegisterBit(CL_TRIGGER_MODE_SNAPSHOT_BIT); acq_pars->startTime = setTriggerRegisterBit(CL_TRIGGER_MODE_SNAPSHOT_BIT);
@ -1111,9 +1116,6 @@ void RaptorEagleCCD::startAquisition()
xclibApiCall(status = pxd_goneLive(_cameraUnitmap, 0), std::format("pxd_goneLive({}, 0)", _cameraUnitmap)); xclibApiCall(status = pxd_goneLive(_cameraUnitmap, 0), std::format("pxd_goneLive({}, 0)", _cameraUnitmap));
if (status == 0) { if (status == 0) {
logError("CANNOT START ACQUIRING!!!"); logError("CANNOT START ACQUIRING!!!");
sptr->_status = AcquisitionProcess::STATUS_IDLE;
} else {
sptr->_status = AcquisitionProcess::STATUS_ACQ;
} }
} }
@ -1122,13 +1124,10 @@ void RaptorEagleCCD::stopAcquisition(bool save_acq)
{ {
std::lock_guard lock_guard(_acqProcessesMutex); std::lock_guard lock_guard(_acqProcessesMutex);
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) { for (auto& sptr : AcquisitionProcess::acqProcSptr) {
if (it->expired()) { if (sptr->_status == AcquisitionProcess::STATUS_ACQ) {
it = _acqProcesses.erase(it);
} else {
auto sptr = it->lock();
sptr->stop(save_acq); sptr->stop(save_acq);
return; // there was only the single active aquisition, so exit here! return; // the only one active acquisition process
} }
} }
@ -1264,36 +1263,23 @@ void RaptorEagleCCD::initAttrComm()
addAttribute(CAMERA_ATTR_CAMERA_STATUS, [this]() { addAttribute(CAMERA_ATTR_CAMERA_STATUS, [this]() {
std::lock_guard lock_guard(_acqProcessesMutex); std::lock_guard lock_guard(_acqProcessesMutex);
std::string s, s_head; std::string s;
if (!_acqProcesses.empty()) { if (AcquisitionProcess::isAcqInProgress) {
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) { s = CAMERA_ATTR_CAMERA_STATUS_ACQ;
if (it->expired()) {
it = _acqProcesses.erase(it);
} else {
auto sptr = it->lock();
auto st = sptr->status();
if (st.substr(0, CAMERA_ATTR_CAMERA_STATUS_ACQ.size()) ==
CAMERA_ATTR_CAMERA_STATUS_ACQ) { // if the camera is acquiring then
s_head = st + ","; // return it at the beginning of the status string
} else if (st.substr(0, CAMERA_ATTR_CAMERA_STATUS_IDLE.size()) == CAMERA_ATTR_CAMERA_STATUS_IDLE) {
// here, cquisition process is already inactive
it = _acqProcesses.erase(it);
continue;
} else {
std::ranges::copy(st, std::back_inserter(s));
s += ","; s += ",";
} }
++it;
if (AcquisitionProcess::acqProcSptr.size()) {
for (auto& sptr : AcquisitionProcess::acqProcSptr) {
if (sptr->_status != AcquisitionProcess::STATUS_ACQ) {
s += sptr->status() + ",";
} }
} }
} }
if (!s.empty() || !s_head.empty()) { if (!s.empty()) {
s = s_head + s;
// if (_acqProcesses.size() == 1) {
s.resize(s.size() - 1); // delete trailing "," s.resize(s.size() - 1); // delete trailing ","
// }
} else { } else {
s = std::string{CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end()}; s = std::string{CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end()};
} }

19
raptor_eagle_ccd.h
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <queue> #include <queue>
#include <set>
#ifdef USE_SPDLOG_LIBRARY #ifdef USE_SPDLOG_LIBRARY
#include <spdlog/sinks/null_sink.h> #include <spdlog/sinks/null_sink.h>
#endif #endif
@ -151,6 +152,7 @@ public:
// camera status // camera status
static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_IDLE{"IDLE"}; static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_IDLE{"IDLE"};
static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_ARMED{"ARMED"};
static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_ACQ{"ACQ"}; // camera is acquiring static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_ACQ{"ACQ"}; // camera is acquiring
static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_READ{"READING"}; // camera is reading from CCD static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_READ{"READING"}; // camera is reading from CCD
static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_SAVE{"SAVING"}; // camera is saving to FITS file static constexpr std::string_view CAMERA_ATTR_CAMERA_STATUS_SAVE{"SAVING"}; // camera is saving to FITS file
@ -207,29 +209,24 @@ private:
friend class RaptorEagleCCD; friend class RaptorEagleCCD;
public: public:
AcquisitionProcess(RaptorEagleCCD*); AcquisitionProcess();
~AcquisitionProcess(); ~AcquisitionProcess();
void start(const std::shared_ptr<acq_params_t>& params); // asynchronous method! void start(const std::shared_ptr<acq_params_t>& params); // asynchronous method!
void stop(bool save = true); void stop(bool save = true);
std::string status(); std::string status();
// static std::string acqProcStatus();
private: private:
inline static RaptorEagleCCD* serverPtr = nullptr; inline static RaptorEagleCCD* serverPtr = nullptr;
inline static std::atomic_bool isAcqInProgress = false; inline static std::atomic_bool isAcqInProgress = false;
RaptorEagleCCD* _manager; inline static std::set<std::shared_ptr<AcquisitionProcess>> acqProcSptr{};
std::shared_ptr<acq_params_t> _acqParams{}; std::shared_ptr<acq_params_t> _acqParams{};
std::unique_ptr<ushort[]> _imageBuffer{};
size_t _imageBufferSize = 0;
size_t _imageBufferRows = 0;
std::future<void> _snapAndCopyFuture; enum int8_t { STATUS_IDLE, STATUS_ARMED, STATUS_ACQ, STATUS_READ, STATUS_SAVE };
// std::future<void> _saveFitsFileFuture;
std::string _statusString{CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end()};
enum int8_t { STATUS_IDLE, STATUS_ACQ, STATUS_READ, STATUS_SAVE };
std::atomic_int8_t _status = STATUS_IDLE; std::atomic_int8_t _status = STATUS_IDLE;
std::mutex _statusMutex; std::mutex _statusMutex;
}; };
@ -285,7 +282,7 @@ private:
// acquisition process members // acquisition process members
std::mutex _acqProcessesMutex; std::mutex _acqProcessesMutex;
std::list<std::weak_ptr<AcquisitionProcess>> _acqProcesses{}; // std::list<std::weak_ptr<AcquisitionProcess>> _acqProcesses{};
// std::future<void> _doSnapAndCopyFuture; // std::future<void> _doSnapAndCopyFuture;
// std::future<void> _saveFitsFile; // std::future<void> _saveFitsFile;