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

start development branch.

Browse Source 
rewrite image buffer managment (dynamic ring buffer, allocation of
buffers at initialization of camera, no allocation of image buffer per
acquisition process)
This commit is contained in:
Timur A. Fatkhullin 2024-12-27 18:41:46 +03:00
parent 99e072be78
commit c1b7d249da
4 changed files with 146 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
raptor_eagle_acqproc.cpp
View File

@ -44,7 +44,7 @@ RaptorEagleCCD::AcquisitionProcess::AcquisitionProcess(RaptorEagleCCD* manager)
{
std::stringstream st;
st << std::this_thread::get_id();
_manager->logDebug("Create acquisition process (thread id: {})", st.str());
serverPtr->logDebug("Create acquisition process (thread id: {})", st.str());
}
@ -52,7 +52,7 @@ RaptorEagleCCD::AcquisitionProcess::~AcquisitionProcess()
{
std::stringstream st;
st << std::this_thread::get_id();
_manager->logDebug("Delete acquisition process (thread id: {})", st.str());
serverPtr->logDebug("Delete acquisition process (thread id: {})", st.str());
}
@ -77,30 +77,30 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
std::stringstream st;
st << std::this_thread::get_id();
_manager->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());
_manager->xclibApiCall(pxd_doSnap(_manager->_cameraUnitmap, 1, timeout.count()),
std::format("pxd_doSnap({}, 1, {})", _manager->_cameraUnitmap, timeout.count()));
serverPtr->xclibApiCall(pxd_doSnap(serverPtr->_cameraUnitmap, 1, timeout.count()),
std::format("pxd_doSnap({}, 1, {})", serverPtr->_cameraUnitmap, timeout.count()));
_manager->logDebug("Capture is finished (thread id: {})!", st.str());
serverPtr->logDebug("Capture is finished (thread id: {})!", st.str());
if ((_acqParams->abortTime > _acqParams->startTime) &&
!_acqParams->saveInAbort) { // abort acquisition was occured! just exit
_manager->logInfo("It seems the acquisition was aborted! Do not save acquired image!");
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());
// _manager->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
return;
}
_manager->logDebug("Image ROI [{}, {}, {}, {}] (binned {}x{})", _acqParams->roiStartX, _acqParams->roiStartY,
_acqParams->roiWidth, _acqParams->roiHeight, _acqParams->binX, _acqParams->binY);
_manager->logDebug("Copy image from grabber to buffer (thread id: {}) ...", st.str());
serverPtr->logDebug("Image ROI [{}, {}, {}, {}] (binned {}x{})", _acqParams->roiStartX, _acqParams->roiStartY,
_acqParams->roiWidth, _acqParams->roiHeight, _acqParams->binX, _acqParams->binY);
serverPtr->logDebug("Copy image from grabber to buffer (thread id: {}) ...", st.str());
// compute image dimension
// NOTE: _acqParams->roiWidth and _acqParams->roiHeight are expected in CCD pixels (not binned)!!!
@ -116,62 +116,43 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
LONGLONG npix = dimx * dimy;
// NOTE:
auto ldiv = std::lldiv(npix, _manager->_dimCCD[0]);
auto ldiv = std::lldiv(npix, serverPtr->_dimCCD[0]);
_imageBufferRows = ldiv.quot + (ldiv.rem ? 1 : 0);
bool gap = false;
if ((_acqParams->roiWidth + _acqParams->roiStartX) < _manager->_dimCCD[0]) {
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;
}
// _imageBufferRows = static_cast<size_t>(std::ceil(npix / _manager->_dimCCD[0]));
// _imageBufferRows = static_cast<size_t>(std::ceil(npix / serverPtr->_dimCCD[0]));
// read size
size_t sz = _imageBufferRows * _manager->_dimCCD[0];
// size_t sz = _imageBufferRows * serverPtr->_dimCCD[0];
_imageBufferSize = _imageBufferRows * serverPtr->_dimCCD[0];
try {
// sz = _manager->_dimCCD[0] * _manager->_dimCCD[1];
if (_imageBufferSize < sz) {
_manager->logDebug("Reallocate image buffer to {} elements", sz);
_imageBufferSize = sz;
_imageBuffer.reset(new ushort[sz]); // may thow std::bad_alloc here!
}
auto log_str = std::format("pxd_readushort({}, 1, 0, 0, -1, {}, {}, {}, \"{}\")", serverPtr->_cameraUnitmap,
_imageBufferRows, (void*)_acqParams->imageBufferPtr, _imageBufferSize, color_space);
auto log_str = std::format("pxd_readushort({}, 1, 0, 0, -1, {}, {}, {}, \"{}\")", _manager->_cameraUnitmap,
_imageBufferRows, (void*)_imageBuffer.get(), _imageBufferSize, color_space);
serverPtr->xclibApiCall(pxd_readushort(serverPtr->_cameraUnitmap, 1, 0, 0, -1, _imageBufferRows,
_acqParams->imageBufferPtr, _imageBufferSize, (char*)color_space),
log_str);
// _manager->xclibApiCall(pxd_readushort(_manager->_cameraUnitmap, 1, 0, 0, -1, -1,
// (ushort*)_imageBuffer.get(), _imageBufferSize, (char*)color_space),
// log_str);
_manager->xclibApiCall(pxd_readushort(_manager->_cameraUnitmap, 1, 0, 0, -1, _imageBufferRows,
(ushort*)_imageBuffer.get(), _imageBufferSize, (char*)color_space),
log_str);
isAcqInProgress = false;
} catch (...) {
isAcqInProgress = false;
_status = STATUS_IDLE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// _manager->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
throw;
}
isAcqInProgress = false;
// ------- save to FITS file --------
if (_acqParams->filename.empty()) {
_manager->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 = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// _manager->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
return;
}
@ -180,13 +161,13 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end()) +
// std::format(" {}", _acqParams->filename);
// _manager->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_SAVE;
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_SAVE;
std::string fname{"!"}; // to overwrite existing file
fname += _acqParams->filename;
_manager->logInfo("Try to save FITS file with name '{}'", _acqParams->filename);
_manager->logTrace("Actual saving filename: {}", fname);
serverPtr->logInfo("Try to save FITS file with name '{}'", _acqParams->filename);
serverPtr->logTrace("Actual saving filename: {}", fname);
fitsfile* fitsFilePtr;
int status = 0;
@ -201,13 +182,13 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
fits_clear_errmsg();
_manager->logDebug("Create an empty FITS file ...");
serverPtr->logDebug("Create an empty FITS file ...");
fits_create_file(&fitsFilePtr, fname.c_str(), &status);
_manager->logDebug("Create primary FITS HDU (dim = [{}, {}])", naxes[0], naxes[1]);
serverPtr->logDebug("Create primary FITS HDU (dim = [{}, {}])", naxes[0], naxes[1]);
fits_create_img(fitsFilePtr, USHORT_IMG, 2, naxes, &status);
_manager->logDebug("Write {} pixels to the HDU ...", npix);
serverPtr->logDebug("Write {} pixels to the HDU ...", npix);
if (gap) {
/* IT SEEMS IF MAX ROI X-COORDINATE IS LESS THAN CCD DIM
* EAGLE CAMERA CONTROLLER SETUP READING FOR WIDTH+1 ROI!!!
@ -259,9 +240,9 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
if (_acqParams->startTime < _acqParams->abortTime) { // acquisition was aborted
std::chrono::duration<double> real_exp = _acqParams->abortTime - _acqParams->startTime;
_manager->logTrace("Acq. start time: {}; acq. abort time: {}", _acqParams->startTime,
_acqParams->abortTime);
_manager->logDebug("Exposure was stopped! Recompute the exposure duration to {} secs", real_exp.count());
serverPtr->logTrace("Acq. start time: {}; acq. abort time: {}", _acqParams->startTime,
_acqParams->abortTime);
serverPtr->logDebug("Exposure was stopped! Recompute the exposure duration to {} secs", real_exp.count());
_acqParams->expTime = real_exp.count();
}
@ -313,11 +294,11 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
if (!status) {
// keywords from user template file
if (_acqParams->templateFilename.size() && !status) {
_manager->logDebug("Copy keywords from '{}' template file", _acqParams->templateFilename);
serverPtr->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(
serverPtr->logWarn(
"An error occured while copy keywords from the template file '{}' (err = {}, msg = {})! "
"Ignore!",
_acqParams->templateFilename, status, err_str);
@ -332,15 +313,15 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
int k_type;
if (_acqParams->permanentKeywords.size()) {
_manager->logDebug("Copy {} permanent keywords", _acqParams->permanentKeywords.size());
serverPtr->logDebug("Copy {} permanent keywords", _acqParams->permanentKeywords.size());
} else {
_manager->logDebug("There is no one permanent keyword! Skip!");
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);
_manager->logWarn(
serverPtr->logWarn(
"An error occured while writing permanent keyword card [{}] (err = {}, msg = {})! "
"Ignore!",
s, status, err_str);
@ -352,32 +333,32 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
}
}
_manager->logTrace("Try to update [{}] FITS card (name = '{}')", card, 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);
_manager->logWarn(
serverPtr->logWarn(
"An error occured while updating FITS card (name = '{}') (err = {}, msg = {})! Skip!", kname,
status, err_str);
} else {
_manager->logTrace("The FITS card (name = '{}') was updated successfully", kname);
serverPtr->logTrace("The FITS card (name = '{}') was updated successfully", kname);
}
}
// keyword from user (may update template file and permanent keywords!)
if (_acqParams->currentKeywords.size()) {
_manager->logDebug("Copy {} current keywords", _acqParams->currentKeywords.size());
serverPtr->logDebug("Copy {} current keywords", _acqParams->currentKeywords.size());
} else {
_manager->logDebug("There is no one current keyword! Skip!");
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);
_manager->logWarn(
serverPtr->logWarn(
"An error occured while writing user keyword card [{}] (err = {}, msg = {})! "
"Ignore!",
s, status, err_str);
@ -389,54 +370,57 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
}
}
_manager->logTrace("Try to update [{}] FITS card (name = '{}')", card, 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);
_manager->logWarn(
serverPtr->logWarn(
"An error occured while updating FITS card (name = '{}') (err = {}, msg = {})! Skip!", kname,
status, err_str);
} else {
_manager->logTrace("The FITS card (name = '{}') was updated successfully", kname);
serverPtr->logTrace("The FITS card (name = '{}') was updated successfully", kname);
}
}
}
// hardcoded camera hardware version info keywords
fits_update_key_ulng(fitsFilePtr, "SERNUM", (ULONGLONG)_manager->_cameraSerialNumber, "Camera serial number",
fits_update_key_ulng(fitsFilePtr, "SERNUM", (ULONGLONG)serverPtr->_cameraSerialNumber, "Camera serial number",
&status);
str = std::format("{}.{}", _manager->_microVersion[0], _manager->_microVersion[1]);
str = std::format("{}.{}", serverPtr->_microVersion[0], serverPtr->_microVersion[1]);
fits_update_key_str(fitsFilePtr, "MICROVER", str.c_str(), "Camera microcontroller version", &status);
str = std::format("{}.{}", _manager->_FPGAVersion[0], _manager->_FPGAVersion[1]);
str = std::format("{}.{}", serverPtr->_FPGAVersion[0], serverPtr->_FPGAVersion[1]);
fits_update_key_str(fitsFilePtr, "FPGAVER", str.c_str(), "Camera FPGA version", &status);
str = std::format("{}", _manager->_buildDate);
str = std::format("{}", serverPtr->_buildDate);
fits_update_key_str(fitsFilePtr, "BUILDDAT", str.c_str(), "Camera build date, YY-MM-DD", &status);
fits_update_key_str(fitsFilePtr, "BUILDCOD", sv2cstr(_manager->_buildCode), "Camera build code", &status);
fits_update_key_str(fitsFilePtr, "BUILDCOD", sv2cstr(serverPtr->_buildCode), "Camera build code", &status);
fits_close_file(fitsFilePtr, &status);
_status = STATUS_IDLE;
// _status = std::string(CAMERA_ATTR_CAMERA_STATUS_IDLE.begin(), CAMERA_ATTR_CAMERA_STATUS_IDLE.end());
// _manager->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
// serverPtr->_cameraStatus = CAMERA_ATTR_CAMERA_STATUS_IDLE;
fits_get_errstatus(status, err_str);
if (status) {
_manager->logError("An error occured while writing FITS file '{}'! FITS status = {} ({})",
_acqParams->filename, status, err_str);
serverPtr->logError("An error occured while writing FITS file '{}'! FITS status = {} ({})",
_acqParams->filename, status, err_str);
} else {
_manager->logInfo("FITS file '{}' is saved", _acqParams->filename);
serverPtr->logInfo("FITS file '{}' is saved", _acqParams->filename);
}
_imageBuffer.release();
// _imageBuffer.release();
std::lock_guard lock_guard(serverPtr->_acqProcessesMutex);
serverPtr->_acqRingFreeBufferPtrs.push(_acqParams->imageBufferPtr); // return buffer pointer to queue of free
});
}
@ -444,19 +428,19 @@ void RaptorEagleCCD::AcquisitionProcess::start(const std::shared_ptr<acq_params_
void RaptorEagleCCD::AcquisitionProcess::stop(bool save)
{
if (isAcqInProgress) {
_manager->logInfo("Abort current acquisition process!");
serverPtr->logInfo("Abort current acquisition process!");
_acqParams->saveInAbort = save;
auto bytes = _manager->readRegisters({0xD4}); // curent trigger mode register
auto bytes = serverPtr->readRegisters({0xD4}); // curent trigger mode register
bytes[0] |= CL_ABORT_CURRENT_EXP; // set abort acquisition bit
_acqParams->abortTime = std::chrono::utc_clock::now();
_manager->writeRegisters({0xD4}, bytes);
serverPtr->writeRegisters({0xD4}, bytes);
} else {
_manager->logWarn("There was no active acquisition process! Ignore!");
serverPtr->logWarn("There was no active acquisition process! Ignore!");
}
}

102
raptor_eagle_ccd.cpp
View File

@ -163,6 +163,8 @@ RaptorEagleCCD::RaptorEagleCCD(const adc::traits::adc_input_char_range auto& epi
logInfo("Set video format filename: {}", _epixFmtVideoFilename);
}
AcquisitionProcess::serverPtr = this;
initAttrComm();
openPIXCI();
@ -452,6 +454,28 @@ bool RaptorEagleCCD::initCamera(int unitmap)
xclibApiCall(_bitsPerPixel = pxd_imageBdim(), "pxd_imageBdim()");
xclibApiCall(_imageFrameBuffNumber = pxd_imageZdim(), "pxd_imageZdim()");
// memory
if (_acqRingBuffer.empty()) { // the first init. allocate ring buffer
logDebug("Allocate memory for acquisition ring buffer");
_acqRingBuffer.resize(DEFAULT_ACQ_RING_BUFFER_SIZE);
try {
for (auto& uptr : _acqRingBuffer) {
uptr.reset(new ushort[_dimCCD[0] * _dimCCD[1]]); // full CCD frame
_acqRingFreeBufferPtrs.push(uptr.get());
}
} catch (const std::bad_alloc&) {
logError("Cannot allocate memory for ring buffer!");
return false;
}
} else { // re-initialization. just resize ring buffer to initial default size
_acqRingBuffer.resize(DEFAULT_ACQ_RING_BUFFER_SIZE);
_acqRingFreeBufferPtrs = std::queue<ushort*>();
for (auto& uptr : _acqRingBuffer) {
_acqRingFreeBufferPtrs.push(uptr.get());
}
}
logDebug("------- CCD and grabber hardware info -------");
logDebug("CCD full-frame dimension [{}, {}] pixels", _dimCCD[0], _dimCCD[1]);
logDebug("CCD bits per pixel: {}", _bitsPerPixel);
@ -965,6 +989,26 @@ void RaptorEagleCCD::startAquisition()
throw std::system_error(RaptorEagleCCDError::ERROR_EXT_TRIGGER_MODE);
}
std::lock_guard lock_guard(_acqProcessesMutex);
if (_acqRingFreeBufferPtrs.empty()) {
logDebug("There is no free image buffers! Try to shrink ring buffer ...");
if (_acqRingBuffer.size() < DEFAULT_ACQ_RING_BUFFER_MAX_SIZE) { // shrink
size_t N = 0;
for (auto i = _acqRingBuffer.size(); i < DEFAULT_ACQ_RING_BUFFER_MAX_SIZE; ++i, ++N) {
if (N == DEFAULT_ACQ_RING_BUFFER_SIZE) {
break;
}
_acqRingBuffer.emplace_back(new ushort[_dimCCD[0] * _dimCCD[1]]);
_acqRingFreeBufferPtrs.push(_acqRingBuffer.back().get());
}
logDebug("{} new image buffers were allocated", N);
} else {
logError("Ring buffer exceeded maximum size!");
throw std::system_error(RaptorEagleCCDError::ERROR_NO_FREE_BUFFER);
}
}
// check filesystem permissions
std::string fname = (*this)[CAMERA_ATTR_FITS_FILENAME];
@ -998,32 +1042,33 @@ void RaptorEagleCCD::startAquisition()
logInfo("Start acquisition process ...");
auto acq_pars = std::make_shared<acq_params_t>(acq_params_t({
.startTime = std::chrono::utc_clock::time_point(),
.abortTime = std::chrono::utc_clock::time_point(),
.saveInAbort = false,
.expTime = (*this)[CAMERA_ATTR_EXPTIME],
.roiStartX = (*this)[CAMERA_ATTR_ROI_STARTX], // in CCD pixels (start from 0)
.roiStartY = (*this)[CAMERA_ATTR_ROI_STARTY], // in CCD pixels (start from 0)
.roiWidth = (*this)[CAMERA_ATTR_ROI_WIDTH], // in binned pixels
.roiHeight = (*this)[CAMERA_ATTR_ROI_HEIGHT], // in binned pixels
.binX = (*this)[CAMERA_ATTR_XBIN],
.binY = (*this)[CAMERA_ATTR_YBIN],
.shutterState = (*this)[CAMERA_ATTR_SHUTTER_STATE],
.readRate = (*this)[CAMERA_ATTR_READ_RATE],
.readMode = (*this)[CAMERA_ATTR_READ_MODE],
.gain = (*this)[CAMERA_ATTR_GAIN],
.ccdTemp = (*this)[CAMERA_ATTR_CCD_TEMP],
.tecSetPoint = (*this)[CAMERA_ATTR_TECPOINT],
.tecState = (*this)[CAMERA_ATTR_TECSTATE] == CAMERA_ATTR_TECSTATE_ON ? true : false,
.pcbTemp = (*this)[CAMERA_ATTR_PCB_TEMP],
// .filename = (*this)[CAMERA_ATTR_FITS_FILENAME],
.filename = fname,
.templateFilename = (*this)[CAMERA_ATTR_FITS_TEMPLATE],
.permanentKeywords = _permanentFitsKeywords, // copy
.currentKeywords = std::move(_currentFitsKeywords) // move!!!
}));
auto acq_pars = std::make_shared<acq_params_t>(
acq_params_t({.startTime = std::chrono::utc_clock::time_point(),
.abortTime = std::chrono::utc_clock::time_point(),
.saveInAbort = false,
.expTime = (*this)[CAMERA_ATTR_EXPTIME],
.roiStartX = (*this)[CAMERA_ATTR_ROI_STARTX], // in CCD pixels (start from 0)
.roiStartY = (*this)[CAMERA_ATTR_ROI_STARTY], // in CCD pixels (start from 0)
.roiWidth = (*this)[CAMERA_ATTR_ROI_WIDTH], // in binned pixels
.roiHeight = (*this)[CAMERA_ATTR_ROI_HEIGHT], // in binned pixels
.binX = (*this)[CAMERA_ATTR_XBIN],
.binY = (*this)[CAMERA_ATTR_YBIN],
.shutterState = (*this)[CAMERA_ATTR_SHUTTER_STATE],
.readRate = (*this)[CAMERA_ATTR_READ_RATE],
.readMode = (*this)[CAMERA_ATTR_READ_MODE],
.gain = (*this)[CAMERA_ATTR_GAIN],
.ccdTemp = (*this)[CAMERA_ATTR_CCD_TEMP],
.tecSetPoint = (*this)[CAMERA_ATTR_TECPOINT],
.tecState = (*this)[CAMERA_ATTR_TECSTATE] == CAMERA_ATTR_TECSTATE_ON ? true : false,
.pcbTemp = (*this)[CAMERA_ATTR_PCB_TEMP],
// .filename = (*this)[CAMERA_ATTR_FITS_FILENAME],
.filename = fname,
.templateFilename = (*this)[CAMERA_ATTR_FITS_TEMPLATE],
.permanentKeywords = _permanentFitsKeywords, // copy
.currentKeywords = std::move(_currentFitsKeywords), // move!!!
.imageBufferPtr = _acqRingFreeBufferPtrs.front()}));
_acqRingFreeBufferPtrs.pop();
// adjust geometry
@ -1041,7 +1086,7 @@ void RaptorEagleCCD::startAquisition()
}
std::lock_guard lock_guard(_acqProcessesMutex);
// std::lock_guard lock_guard(_acqProcessesMutex);
auto sptr = std::make_shared<AcquisitionProcess>(this);
for (auto it = _acqProcesses.begin(); it != _acqProcesses.end();) {
@ -1056,11 +1101,6 @@ void RaptorEagleCCD::startAquisition()
// arm grabber here
sptr->start(acq_pars);
// bits.set(CL_TRIGGER_MODE_SNAPSHOT_BIT); // start snapshot bit
// bytes[0] = static_cast<uint8_t>(bits.to_ulong());
// acq_pars->startTime = std::chrono::utc_clock::now();
// writeRegisters({0xD4}, bytes); // write to trigger mode register (start snapshot)
// start acquisition here
acq_pars->startTime = setTriggerRegisterBit(CL_TRIGGER_MODE_SNAPSHOT_BIT);

9
raptor_eagle_ccd.h
View File

@ -1,5 +1,6 @@
#pragma once
#include <queue>
#ifdef USE_SPDLOG_LIBRARY
#include <spdlog/sinks/null_sink.h>
#endif
@ -33,6 +34,7 @@ public:
static constexpr std::string_view USER_FITS_KEY_SEP_SEQ{"\t"};
static constexpr size_t DEFAULT_ACQ_RING_BUFFER_SIZE = 3;
static constexpr size_t DEFAULT_ACQ_RING_BUFFER_MAX_SIZE = 100;
/* some Eagle V camera constants */
// static constexpr double EAGLE_CAMERA_MAX_EXPTIME = 27487.7906944; // in seconds (0xFFFFFFFFFF * 25nsec)
@ -197,6 +199,7 @@ private:
// std::unique_ptr<ushort> imageBuffer;
// size_t imageBufferSize;
// size_t imageBufferRows;
ushort* imageBufferPtr;
};
class AcquisitionProcess : public std::enable_shared_from_this<AcquisitionProcess>
@ -212,6 +215,8 @@ private:
std::string status();
private:
inline static RaptorEagleCCD* serverPtr = nullptr;
inline static std::atomic_bool isAcqInProgress = false;
RaptorEagleCCD* _manager;
@ -257,8 +262,8 @@ private:
std::vector<std::string> _currentFitsKeywords{}; // current acquisition FITS keywords
std::vector<std::string> _permanentFitsKeywords{}; // permanent user FITS keywords
// std::list<std::unique_ptr<ushort>> _acqRingBuffer;
std::list<std::pair<std::unique_ptr<ushort>, size_t>> _acqRingBuffer;
std::vector<std::unique_ptr<ushort[]>> _acqRingBuffer{};
std::queue<ushort*> _acqRingFreeBufferPtrs{};
// hardware version info

5
raptor_eagle_exception.h
View File

@ -17,7 +17,8 @@ enum class RaptorEagleCCDError : int {
ERROR_EXT_TRIGGER_MODE,
ERROR_ACQUISITION_IN_PROGRESS,
ERROR_INVALID_PATH,
ERROR_INSUFFICIENT_FILESYSTEM_PERMISSIONS
ERROR_INSUFFICIENT_FILESYSTEM_PERMISSIONS,
ERROR_NO_FREE_BUFFER
};
@ -68,6 +69,8 @@ struct RaptorEagleCCDErrorCategory : std::error_category {
return "invalid filesystem path";
case RaptorEagleCCDError::ERROR_INSUFFICIENT_FILESYSTEM_PERMISSIONS:
return "insufficient filesystem permissions";
case RaptorEagleCCDError::ERROR_NO_FREE_BUFFER:
return "there is no free buffer in ring";
default:
return "UNKNOWN ERROR";
}