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

198
raptor_eagle_acqproc.cpp
View File

@ -40,7 +40,7 @@ double JulianDay(const std::chrono::utc_clock::time_point& tm)
} // namespace details
RaptorEagleCCD::AcquisitionProcess::AcquisitionProcess(RaptorEagleCCD* manager) : _manager(manager)
RaptorEagleCCD::AcquisitionProcess::AcquisitionProcess()
{
std::stringstream st;
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)
{
// if (isAcqInProgress) {
// throw std::system_error(RaptorEagleCCDError::ERROR_ACQUISITION_IN_PROGRESS);
// }
isAcqInProgress = true;
// _acqParams = std::move(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 =
CAMERA_CAPTURE_TIMEOUT_ADD_CONSTANT +
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;
st << std::this_thread::get_id();
_status = STATUS_ARMED;
serverPtr->logDebug("Arm grabber and wait for acquisition starting trigger (thread id: {}) ...", st.str());
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) &&
!_acqParams->saveInAbort) { // abort acquisition was occured! just exit
serverPtr->logInfo("It seems the acquisition was aborted! Do not save acquired image!");
isAcqInProgress = false;
_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;
}
@ -105,39 +103,37 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
// compute image dimension
// 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 dimx = div.quot + (div.rem ? 1 : 0);
// div = std::div(_acqParams->roiHeight - _acqParams->roiStartY, _acqParams->binY);
div = std::div(_acqParams->roiHeight, _acqParams->binY);
auto dimy = div.quot + (div.rem ? 1 : 0);
// LONGLONG npix = _acqParams->roiWidth * _acqParams->roiHeight;
LONGLONG npix = dimx * dimy;
// NOTE:
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;
if ((_acqParams->roiWidth + _acqParams->roiStartX) < serverPtr->_dimCCD[0]) {
/* IT SEEMS IF MAX ROI X-COORDINATE IS LESS THAN CCD DIM
* EAGLE CAMERA CONTROLLER SETUP READING FOR WIDTH+1 ROI!!! */
gap = true;
++_imageBufferRows;
++im_buffer_rows;
}
// _imageBufferRows = static_cast<size_t>(std::ceil(npix / serverPtr->_dimCCD[0]));
// read size
// size_t sz = _imageBufferRows * serverPtr->_dimCCD[0];
_imageBufferSize = _imageBufferRows * serverPtr->_dimCCD[0];
auto im_buffer_size = im_buffer_rows * serverPtr->_dimCCD[0];
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,
_acqParams->imageBufferPtr, _imageBufferSize, (char*)color_space),
serverPtr->xclibApiCall(pxd_readushort(serverPtr->_cameraUnitmap, 1, 0, 0, -1, im_buffer_rows,
_acqParams->imageBufferPtr, im_buffer_size, (char*)color_space),
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!");
_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;
}
_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
fname += _acqParams->filename;
@ -174,9 +163,6 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
const int naxis = 2;
long naxes[naxis] = {dimx, dimy};
// long naxes[2];
// naxes[0] = _acqParams->roiWidth;
// naxes[1] = _acqParams->roiHeight;
char err_str[100];
@ -306,84 +292,56 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
}
}
// permanent keywords (may update keywords from template file!)
char card[81];
char kname[9] = " ";
int k_type;
if (_acqParams->permanentKeywords.size()) {
serverPtr->logDebug("Copy {} permanent keywords", _acqParams->permanentKeywords.size());
} else {
serverPtr->logDebug("There is no one permanent keyword! Skip!");
}
for (auto& s : _acqParams->permanentKeywords) {
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 permanent keyword card [{}] (err = {}, msg = {})! "
"Ignore!",
s, status, err_str);
auto save_keywords = [&status, &err_str, &fitsFilePtr](auto& kwd_list, const std::string& mark) {
char card[81];
char kname[9] = " ";
int k_type;
status = 0;
if (kwd_list.size()) {
serverPtr->logDebug("Copy {} {} keywords", mark, kwd_list.size());
} else {
for (int i = 0; i < 8; ++i) {
kname[i] = card[i];
serverPtr->logDebug("There is no one permanent keyword! Skip!");
}
for (auto & s : kwd_list) {
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 {} keyword card [{}] (err = {}, msg = {})! "
"Ignore!",
mark, 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);
}
}
};
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);
}
}
// permanent keywords (may update keywords from template file!)
save_keywords(_acqParams->permanentKeywords, "permanent");
// keyword from user (may update template file and permanent keywords!)
if (_acqParams->currentKeywords.size()) {
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);
}
}
save_keywords(_acqParams->currentKeywords, "current");
}
// hardcoded camera hardware version info keywords
fits_update_key_ulng(fitsFilePtr, "SERNUM", (ULONGLONG)serverPtr->_cameraSerialNumber, "Camera serial number",
@ -404,8 +362,6 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
fits_close_file(fitsFilePtr, &status);
_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);
@ -416,13 +372,16 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
serverPtr->logInfo("FITS file '{}' is saved", _acqParams->filename);
}
// _imageBuffer.release();
std::lock_guard lock_guard(serverPtr->_acqProcessesMutex);
serverPtr->_acqRingFreeBufferPtrs.push(_acqParams->imageBufferPtr); // return buffer pointer to queue of free
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;
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();
serverPtr->writeRegisters({0xD4}, bytes);
// _acqParams->abortTime = std::chrono::utc_clock::now();
// serverPtr->writeRegisters({0xD4}, bytes);
_acqParams->abortTime = serverPtr->setTriggerRegisterBit(CL_TRIGGER_MODE_ABORT_CURRENT_EXP_BIT);
} else {
serverPtr->logWarn("There was no active acquisition process! Ignore!");
@ -450,30 +411,35 @@ std::string RaptorEagleCCD::AcquisitionProcess::status()
{
std::lock_guard lock(_statusMutex);
std::string stat_str;
switch (_status) {
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;
case STATUS_ACQ: {
std::chrono::duration<double> curr_exp = std::chrono::utc_clock::now() - _acqParams->startTime;
auto remain_exp = _acqParams->expTime - curr_exp.count();
if (remain_exp < 0) {
_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 {
_statusString = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_ACQ, remain_exp);
stat_str = std::format("{} {}", CAMERA_ATTR_CAMERA_STATUS_ACQ, remain_exp);
}
break;
}
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;
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;
default:
_statusString = "UNKNOWN"; // is should not be!!!
stat_str = "UNKNOWN"; // is should not be!!!
}
return _statusString;
return stat_str;
}

82
raptor_eagle_ccd.cpp
View File

@ -179,8 +179,27 @@ RaptorEagleCCD::RaptorEagleCCD(std::shared_ptr<spdlog::logger> logger)
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();
logDebug("DTOR: Delete RaptorEagleCCD class instance");
}
@ -1088,21 +1107,7 @@ void RaptorEagleCCD::startAquisition()
}
// std::lock_guard lock_guard(_acqProcessesMutex);
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);
std::make_shared<AcquisitionProcess>()->start(acq_pars);
// start acquisition here
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));
if (status == 0) {
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);
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) {
if (it->expired()) {
it = _acqProcesses.erase(it);
} else {
auto sptr = it->lock();
for (auto& sptr : AcquisitionProcess::acqProcSptr) {
if (sptr->_status == AcquisitionProcess::STATUS_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]() {
std::lock_guard lock_guard(_acqProcessesMutex);
std::string s, s_head;
std::string s;
if (!_acqProcesses.empty()) {
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) {
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 += ",";
}
++it;
if (AcquisitionProcess::isAcqInProgress) {
s = CAMERA_ATTR_CAMERA_STATUS_ACQ;
s += ",";
}
if (AcquisitionProcess::acqProcSptr.size()) {
for (auto& sptr : AcquisitionProcess::acqProcSptr) {
if (sptr->_status != AcquisitionProcess::STATUS_ACQ) {
s += sptr->status() + ",";
}
}
}
if (!s.empty() || !s_head.empty()) {
s = s_head + s;
// if (_acqProcesses.size() == 1) {
if (!s.empty()) {
s.resize(s.size() - 1); // delete trailing ","
// }
} else {
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
#include <queue>
#include <set>
#ifdef USE_SPDLOG_LIBRARY
#include <spdlog/sinks/null_sink.h>
#endif
@ -151,6 +152,7 @@ public:
// camera status
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_READ{"READING"}; // camera is reading from CCD
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;
public:
AcquisitionProcess(RaptorEagleCCD*);
AcquisitionProcess();
~AcquisitionProcess();
void start(const std::shared_ptr<acq_params_t>& params); // asynchronous method!
void stop(bool save = true);
std::string status();
// static std::string acqProcStatus();
private:
inline static RaptorEagleCCD* serverPtr = nullptr;
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::unique_ptr<ushort[]> _imageBuffer{};
size_t _imageBufferSize = 0;
size_t _imageBufferRows = 0;
std::future<void> _snapAndCopyFuture;
// 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 };
enum int8_t { STATUS_IDLE, STATUS_ARMED, STATUS_ACQ, STATUS_READ, STATUS_SAVE };
std::atomic_int8_t _status = STATUS_IDLE;
std::mutex _statusMutex;
};
@ -285,7 +282,7 @@ private:
// acquisition process members
std::mutex _acqProcessesMutex;
std::list<std::weak_ptr<AcquisitionProcess>> _acqProcesses{};
// std::list<std::weak_ptr<AcquisitionProcess>> _acqProcesses{};
// std::future<void> _doSnapAndCopyFuture;
// std::future<void> _saveFitsFile;