mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-06-19 08:17:13 +02:00
removed online flags, apiversion in shm, ret for ok and fail, bind socket help in exception message (#43)
* removed online flag, removed rxronline flag, added useReceier flag that is set only when rxr hostname is set, removed setonline, setreceiveronline flag, removed ret for ok or fail, using exceptions for this, changed cannot bind socket printout * fixed python
This commit is contained in:
Dhanya Thattil
@ -182,22 +182,20 @@ bool multiSlsDetector::isAcquireReady() {
|
||||
return OK != 0u;
|
||||
}
|
||||
|
||||
int multiSlsDetector::checkDetectorVersionCompatibility(int detPos) {
|
||||
void multiSlsDetector::checkDetectorVersionCompatibility(int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->checkDetectorVersionCompatibility();
|
||||
detectors[detPos]->checkDetectorVersionCompatibility();
|
||||
}
|
||||
|
||||
auto r = parallelCall(&slsDetector::checkDetectorVersionCompatibility);
|
||||
return sls::minusOneIfDifferent(r);
|
||||
parallelCall(&slsDetector::checkDetectorVersionCompatibility);
|
||||
}
|
||||
|
||||
int multiSlsDetector::checkReceiverVersionCompatibility(int detPos) {
|
||||
void multiSlsDetector::checkReceiverVersionCompatibility(int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->checkReceiverVersionCompatibility();
|
||||
detectors[detPos]->checkReceiverVersionCompatibility();
|
||||
}
|
||||
|
||||
auto r = parallelCall(&slsDetector::checkReceiverVersionCompatibility);
|
||||
return sls::minusOneIfDifferent(r);
|
||||
parallelCall(&slsDetector::checkReceiverVersionCompatibility);
|
||||
}
|
||||
|
||||
int64_t multiSlsDetector::getId(idMode mode, int detPos) {
|
||||
@ -312,7 +310,6 @@ void multiSlsDetector::initializeDetectorStructure() {
|
||||
multi_shm()->numberOfDetectors = 0;
|
||||
multi_shm()->numberOfDetector[X] = 0;
|
||||
multi_shm()->numberOfDetector[Y] = 0;
|
||||
multi_shm()->onlineFlag = 1;
|
||||
multi_shm()->stoppedFlag = 0;
|
||||
multi_shm()->dataBytes = 0;
|
||||
multi_shm()->dataBytesInclGapPixels = 0;
|
||||
@ -421,7 +418,6 @@ void multiSlsDetector::addMultipleDetectors(const char *name) {
|
||||
addSlsDetector(hostname);
|
||||
}
|
||||
|
||||
setOnline();
|
||||
updateOffsets();
|
||||
}
|
||||
|
||||
@ -451,7 +447,6 @@ void multiSlsDetector::addSlsDetector(const std::string &hostname) {
|
||||
multi_shm()->numberOfChannels += detectors[pos]->getTotalNumberOfChannels();
|
||||
|
||||
detectors[pos]->setHostname(hostname);
|
||||
detectors[pos]->setOnline(1);
|
||||
}
|
||||
|
||||
void multiSlsDetector::addSlsDetector(std::unique_ptr<slsDetector> det) {
|
||||
@ -725,29 +720,6 @@ void multiSlsDetector::updateOffsets() {
|
||||
}
|
||||
}
|
||||
|
||||
int multiSlsDetector::setOnline(int value, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setOnline(value);
|
||||
}
|
||||
|
||||
// multi
|
||||
if (value != GET_ONLINE_FLAG) {
|
||||
auto r = parallelCall(&slsDetector::setOnline, value);
|
||||
multi_shm()->onlineFlag = sls::minusOneIfDifferent(r);
|
||||
}
|
||||
return multi_shm()->onlineFlag;
|
||||
}
|
||||
|
||||
int multiSlsDetector::getOnlineFlag(int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->getOnlineFlag();
|
||||
}
|
||||
|
||||
auto r = serialCall(&slsDetector::getOnlineFlag);
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
std::string multiSlsDetector::checkOnline(int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->checkOnline();
|
||||
@ -809,20 +781,18 @@ std::string multiSlsDetector::getLastClientIP(int detPos) {
|
||||
return sls::concatenateIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::exitServer(int detPos) {
|
||||
void multiSlsDetector::exitServer(int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->exitServer();
|
||||
detectors[detPos]->exitServer();
|
||||
}
|
||||
auto r = parallelCall(&slsDetector::exitServer);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::exitServer);
|
||||
}
|
||||
|
||||
int multiSlsDetector::execCommand(const std::string &cmd, int detPos) {
|
||||
void multiSlsDetector::execCommand(const std::string &cmd, int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->execCommand(cmd);
|
||||
detectors[detPos]->execCommand(cmd);
|
||||
}
|
||||
auto r = parallelCall(&slsDetector::execCommand, cmd);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::execCommand, cmd);
|
||||
}
|
||||
|
||||
void multiSlsDetector::readConfigurationFile(const std::string &fname) {
|
||||
@ -949,26 +919,24 @@ std::string multiSlsDetector::setSettingsDir(const std::string &directory,
|
||||
return sls::concatenateIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::loadSettingsFile(const std::string &fname, int detPos) {
|
||||
void multiSlsDetector::loadSettingsFile(const std::string &fname, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->loadSettingsFile(fname);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::loadSettingsFile, fname);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::loadSettingsFile, fname);
|
||||
}
|
||||
|
||||
int multiSlsDetector::saveSettingsFile(const std::string &fname, int detPos) {
|
||||
void multiSlsDetector::saveSettingsFile(const std::string &fname, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->saveSettingsFile(fname);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::saveSettingsFile, fname);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::saveSettingsFile, fname);
|
||||
}
|
||||
|
||||
slsDetectorDefs::runStatus multiSlsDetector::getRunStatus(int detPos) {
|
||||
@ -993,39 +961,33 @@ slsDetectorDefs::runStatus multiSlsDetector::getRunStatus(int detPos) {
|
||||
return IDLE;
|
||||
}
|
||||
|
||||
int multiSlsDetector::prepareAcquisition(int detPos) {
|
||||
void multiSlsDetector::prepareAcquisition(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->prepareAcquisition();
|
||||
detectors[detPos]->prepareAcquisition();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::prepareAcquisition);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::prepareAcquisition);
|
||||
}
|
||||
|
||||
int multiSlsDetector::startAcquisition(int detPos) {
|
||||
void multiSlsDetector::startAcquisition(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
if (detectors[detPos]->getDetectorTypeAsEnum() == EIGER) {
|
||||
if (detectors[detPos]->prepareAcquisition() == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
detectors[detPos]->prepareAcquisition();
|
||||
}
|
||||
return detectors[detPos]->startAcquisition();
|
||||
detectors[detPos]->startAcquisition();
|
||||
}
|
||||
|
||||
// multi
|
||||
if (getDetectorTypeAsEnum() == EIGER) {
|
||||
if (prepareAcquisition() == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
prepareAcquisition();
|
||||
}
|
||||
auto r = parallelCall(&slsDetector::startAcquisition);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::startAcquisition);
|
||||
}
|
||||
|
||||
int multiSlsDetector::stopAcquisition(int detPos) {
|
||||
void multiSlsDetector::stopAcquisition(int detPos) {
|
||||
// locks to synchronize using client->receiver simultaneously (processing
|
||||
// thread)
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
@ -1035,77 +997,67 @@ int multiSlsDetector::stopAcquisition(int detPos) {
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
}
|
||||
|
||||
return detectors[detPos]->stopAcquisition();
|
||||
detectors[detPos]->stopAcquisition();
|
||||
} else {
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
auto r = parallelCall(&slsDetector::stopAcquisition);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::stopAcquisition);
|
||||
}
|
||||
}
|
||||
|
||||
int multiSlsDetector::sendSoftwareTrigger(int detPos) {
|
||||
void multiSlsDetector::sendSoftwareTrigger(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->sendSoftwareTrigger();
|
||||
detectors[detPos]->sendSoftwareTrigger();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::sendSoftwareTrigger);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::sendSoftwareTrigger);
|
||||
}
|
||||
|
||||
int multiSlsDetector::startAndReadAll(int detPos) {
|
||||
void multiSlsDetector::startAndReadAll(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
if (detectors[detPos]->getDetectorTypeAsEnum() == EIGER) {
|
||||
if (detectors[detPos]->prepareAcquisition() == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
detectors[detPos]->prepareAcquisition();
|
||||
}
|
||||
return detectors[detPos]->startAndReadAll();
|
||||
detectors[detPos]->startAndReadAll();
|
||||
}
|
||||
|
||||
// multi
|
||||
if (getDetectorTypeAsEnum() == EIGER) {
|
||||
if (prepareAcquisition() == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
prepareAcquisition();
|
||||
}
|
||||
auto r = parallelCall(&slsDetector::startAndReadAll);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::startAndReadAll);
|
||||
}
|
||||
|
||||
int multiSlsDetector::startReadOut(int detPos) {
|
||||
void multiSlsDetector::startReadOut(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->startReadOut();
|
||||
detectors[detPos]->startReadOut();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::startReadOut);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::startReadOut);
|
||||
}
|
||||
|
||||
int multiSlsDetector::readAll(int detPos) {
|
||||
void multiSlsDetector::readAll(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->readAll();
|
||||
detectors[detPos]->readAll();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::readAll);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::readAll);
|
||||
}
|
||||
|
||||
int multiSlsDetector::configureMAC(int detPos) {
|
||||
void multiSlsDetector::configureMAC(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->configureMAC();
|
||||
detectors[detPos]->configureMAC();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::configureMAC);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::configureMAC);
|
||||
}
|
||||
|
||||
void multiSlsDetector::setStartingFrameNumber(const uint64_t value,
|
||||
@ -2134,12 +2086,12 @@ int multiSlsDetector::digitalTest(digitalTestMode mode, int ival, int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::loadImageToDetector(imageType index,
|
||||
void multiSlsDetector::loadImageToDetector(imageType index,
|
||||
const std::string &fname,
|
||||
int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->loadImageToDetector(index, fname);
|
||||
detectors[detPos]->loadImageToDetector(index, fname);
|
||||
}
|
||||
|
||||
// multi
|
||||
@ -2153,56 +2105,36 @@ int multiSlsDetector::loadImageToDetector(imageType index,
|
||||
}
|
||||
|
||||
// send image to all
|
||||
std::vector<int> r;
|
||||
for (size_t idet = 0; idet < detectors.size(); ++idet) {
|
||||
r.push_back(detectors[idet]->sendImageToDetector(
|
||||
index,
|
||||
imageVals + idet * detectors[idet]->getTotalNumberOfChannels()));
|
||||
detectors[idet]->sendImageToDetector(index, imageVals + idet * detectors[idet]->getTotalNumberOfChannels());
|
||||
}
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
}
|
||||
|
||||
int multiSlsDetector::writeCounterBlockFile(const std::string &fname,
|
||||
void multiSlsDetector::writeCounterBlockFile(const std::string &fname,
|
||||
int startACQ, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->writeCounterBlockFile(fname, startACQ);
|
||||
detectors[detPos]->writeCounterBlockFile(fname, startACQ);
|
||||
}
|
||||
|
||||
// multi
|
||||
|
||||
// get image from all
|
||||
int nch = multi_shm()->numberOfChannels;
|
||||
short int imageVals[nch];
|
||||
std::vector<int> r;
|
||||
for (size_t idet = 0; idet < detectors.size(); ++idet) {
|
||||
r.push_back(detectors[idet]->getCounterBlock(
|
||||
detectors[idet]->getCounterBlock(
|
||||
imageVals + idet * detectors[idet]->getTotalNumberOfChannels(),
|
||||
startACQ));
|
||||
startACQ);
|
||||
}
|
||||
|
||||
// write image if all ok
|
||||
if (sls::allEqualTo(r, static_cast<int>(OK))) {
|
||||
if (writeDataFile(fname, nch, imageVals) <
|
||||
nch * (int)sizeof(short int)) {
|
||||
throw RuntimeError(
|
||||
"Could not open file to write or did not write enough data"
|
||||
" in file to write counter block file from detector.");
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
int multiSlsDetector::resetCounterBlock(int startACQ, int detPos) {
|
||||
void multiSlsDetector::resetCounterBlock(int startACQ, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->resetCounterBlock(startACQ);
|
||||
detectors[detPos]->resetCounterBlock(startACQ);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::resetCounterBlock, startACQ);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::resetCounterBlock, startACQ);
|
||||
}
|
||||
|
||||
int multiSlsDetector::setCounterBit(int i, int detPos) {
|
||||
@ -2232,10 +2164,10 @@ void multiSlsDetector::verifyMinMaxROI(int n, ROI r[]) {
|
||||
}
|
||||
}
|
||||
|
||||
int multiSlsDetector::setROI(int n, ROI roiLimits[], int detPos) {
|
||||
void multiSlsDetector::setROI(int n, ROI roiLimits[], int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setROI(n, roiLimits);
|
||||
detectors[detPos]->setROI(n, roiLimits);
|
||||
}
|
||||
|
||||
// multi
|
||||
@ -2252,7 +2184,7 @@ int multiSlsDetector::setROI(int n, ROI roiLimits[], int detPos) {
|
||||
}
|
||||
|
||||
if ((n < 0) || (roiLimits == nullptr)) {
|
||||
return FAIL;
|
||||
throw RuntimeError("Cannot set ROI due to Invalid ROI");
|
||||
}
|
||||
|
||||
// ensures min < max
|
||||
@ -2371,12 +2303,9 @@ int multiSlsDetector::setROI(int n, ROI roiLimits[], int detPos) {
|
||||
}
|
||||
|
||||
// settings the rois for each detector
|
||||
std::vector<int> r;
|
||||
r.reserve(detectors.size());
|
||||
for (size_t i = 0; i != detectors.size(); ++i) {
|
||||
r.push_back(detectors[i]->setROI(nroi[i], allroi[i]));
|
||||
detectors[i]->setROI(nroi[i], allroi[i]);
|
||||
}
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
}
|
||||
|
||||
const slsDetectorDefs::ROI *multiSlsDetector::getROI(int &n, int detPos) {
|
||||
@ -2645,16 +2574,15 @@ int multiSlsDetector::getReceiverDbitOffset(int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::writeAdcRegister(uint32_t addr, uint32_t val,
|
||||
void multiSlsDetector::writeAdcRegister(uint32_t addr, uint32_t val,
|
||||
int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->writeAdcRegister(addr, val);
|
||||
detectors[detPos]->writeAdcRegister(addr, val);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::writeAdcRegister, addr, val);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::writeAdcRegister, addr, val);
|
||||
}
|
||||
|
||||
int multiSlsDetector::activate(int const enable, int detPos) {
|
||||
@ -2762,37 +2690,34 @@ std::vector<int> multiSlsDetector::getTrimEn(int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::pulsePixel(int n, int x, int y, int detPos) {
|
||||
void multiSlsDetector::pulsePixel(int n, int x, int y, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->pulsePixel(n, x, y);
|
||||
detectors[detPos]->pulsePixel(n, x, y);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::pulsePixel, n, x, y);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::pulsePixel, n, x, y);
|
||||
}
|
||||
|
||||
int multiSlsDetector::pulsePixelNMove(int n, int x, int y, int detPos) {
|
||||
void multiSlsDetector::pulsePixelNMove(int n, int x, int y, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->pulsePixelNMove(n, x, y);
|
||||
detectors[detPos]->pulsePixelNMove(n, x, y);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::pulsePixelNMove, n, x, y);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::pulsePixelNMove, n, x, y);
|
||||
}
|
||||
|
||||
int multiSlsDetector::pulseChip(int n, int detPos) {
|
||||
void multiSlsDetector::pulseChip(int n, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->pulseChip(n);
|
||||
detectors[detPos]->pulseChip(n);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::pulseChip, n);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::pulseChip, n);
|
||||
}
|
||||
|
||||
int multiSlsDetector::setThresholdTemperature(int val, int detPos) {
|
||||
@ -2839,61 +2764,57 @@ int multiSlsDetector::setStoragecellStart(int pos, int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::programFPGA(const std::string &fname, int detPos) {
|
||||
void multiSlsDetector::programFPGA(const std::string &fname, int detPos) {
|
||||
FILE_LOG(logINFO) << "This can take awhile. Please be patient...";
|
||||
// read pof file
|
||||
std::vector<char> buffer = readPofFile(fname);
|
||||
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->programFPGA(buffer);
|
||||
detectors[detPos]->programFPGA(buffer);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::programFPGA, buffer);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::programFPGA, buffer);
|
||||
}
|
||||
|
||||
int multiSlsDetector::resetFPGA(int detPos) {
|
||||
void multiSlsDetector::resetFPGA(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->resetFPGA();
|
||||
detectors[detPos]->resetFPGA();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::resetFPGA);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::resetFPGA);
|
||||
}
|
||||
|
||||
int multiSlsDetector::copyDetectorServer(const std::string &fname,
|
||||
void multiSlsDetector::copyDetectorServer(const std::string &fname,
|
||||
const std::string &hostname,
|
||||
int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
detectors[detPos]->copyDetectorServer(fname, hostname);
|
||||
return detectors[detPos]
|
||||
->rebootController(); // reboot and copy should be independant for
|
||||
detectors[detPos]->rebootController();
|
||||
// reboot and copy should be independant for
|
||||
// update command
|
||||
}
|
||||
|
||||
// multi
|
||||
parallelCall(&slsDetector::copyDetectorServer, fname, hostname);
|
||||
auto r = parallelCall(&slsDetector::rebootController);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::rebootController);
|
||||
}
|
||||
|
||||
int multiSlsDetector::rebootController(int detPos) {
|
||||
void multiSlsDetector::rebootController(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->rebootController();
|
||||
detectors[detPos]->rebootController();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::rebootController);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::rebootController);
|
||||
}
|
||||
|
||||
int multiSlsDetector::update(const std::string &sname,
|
||||
void multiSlsDetector::update(const std::string &sname,
|
||||
const std::string &hostname,
|
||||
const std::string &fname, int detPos) {
|
||||
FILE_LOG(logINFO) << "This can take awhile. Please be patient...";
|
||||
@ -2903,13 +2824,12 @@ int multiSlsDetector::update(const std::string &sname,
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
detectors[detPos]->copyDetectorServer(sname, hostname);
|
||||
return detectors[detPos]->programFPGA(buffer);
|
||||
detectors[detPos]->programFPGA(buffer);
|
||||
}
|
||||
|
||||
// multi
|
||||
parallelCall(&slsDetector::copyDetectorServer, sname, hostname);
|
||||
auto r = parallelCall(&slsDetector::programFPGA, buffer);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::programFPGA, buffer);
|
||||
}
|
||||
|
||||
int multiSlsDetector::powerChip(int ival, int detPos) {
|
||||
@ -2944,15 +2864,14 @@ int multiSlsDetector::setAutoComparatorDisableMode(int ival, int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::setRateCorrection(int64_t t, int detPos) {
|
||||
void multiSlsDetector::setRateCorrection(int64_t t, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setRateCorrection(t);
|
||||
detectors[detPos]->setRateCorrection(t);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::setRateCorrection, t);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::setRateCorrection, t);
|
||||
}
|
||||
|
||||
int64_t multiSlsDetector::getRateCorrection(int detPos) {
|
||||
@ -2978,26 +2897,19 @@ void multiSlsDetector::printReceiverConfiguration(TLogLevel level, int detPos) {
|
||||
}
|
||||
}
|
||||
|
||||
int multiSlsDetector::setReceiverOnline(int value, int detPos) {
|
||||
bool multiSlsDetector::getUseReceiverFlag(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setReceiverOnline(value);
|
||||
return detectors[detPos]->getUseReceiverFlag();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::setReceiverOnline, value);
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::getReceiverOnlineFlag(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->getReceiverOnlineFlag();
|
||||
auto r = parallelCall(&slsDetector::getUseReceiverFlag);
|
||||
if (sls::allEqual(r)) {
|
||||
return r.front();
|
||||
} else {
|
||||
throw RuntimeError("Inconsistent Use receiver flags");
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::getReceiverOnlineFlag);
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
std::string multiSlsDetector::checkReceiverOnline(int detPos) {
|
||||
@ -3033,26 +2945,24 @@ std::string multiSlsDetector::getReceiverLastClientIP(int detPos) {
|
||||
return sls::concatenateIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::exitReceiver(int detPos) {
|
||||
void multiSlsDetector::exitReceiver(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->exitReceiver();
|
||||
detectors[detPos]->exitReceiver();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::exitReceiver);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::exitReceiver);
|
||||
}
|
||||
|
||||
int multiSlsDetector::execReceiverCommand(const std::string &cmd, int detPos) {
|
||||
void multiSlsDetector::execReceiverCommand(const std::string &cmd, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->execReceiverCommand(cmd);
|
||||
detectors[detPos]->execReceiverCommand(cmd);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::execReceiverCommand, cmd);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::execReceiverCommand, cmd);
|
||||
}
|
||||
|
||||
std::string multiSlsDetector::getFilePath(int detPos) {
|
||||
@ -3204,26 +3114,24 @@ int multiSlsDetector::getFileIndex(int detPos) const {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::startReceiver(int detPos) {
|
||||
void multiSlsDetector::startReceiver(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->startReceiver();
|
||||
detectors[detPos]->startReceiver();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::startReceiver);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::startReceiver);
|
||||
}
|
||||
|
||||
int multiSlsDetector::stopReceiver(int detPos) {
|
||||
void multiSlsDetector::stopReceiver(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->stopReceiver();
|
||||
detectors[detPos]->stopReceiver();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::stopReceiver);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::stopReceiver);
|
||||
}
|
||||
|
||||
slsDetectorDefs::runStatus multiSlsDetector::getReceiverStatus(int detPos) {
|
||||
@ -3285,15 +3193,14 @@ uint64_t multiSlsDetector::getReceiverCurrentFrameIndex(int detPos) {
|
||||
return ((sls::sum(r)) / (int)detectors.size());
|
||||
}
|
||||
|
||||
int multiSlsDetector::resetFramesCaught(int detPos) {
|
||||
void multiSlsDetector::resetFramesCaught(int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->resetFramesCaught();
|
||||
detectors[detPos]->resetFramesCaught();
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::resetFramesCaught);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::resetFramesCaught);
|
||||
}
|
||||
|
||||
int multiSlsDetector::createReceivingDataSockets(const bool destroy) {
|
||||
@ -3938,15 +3845,14 @@ uint64_t multiSlsDetector::setPatternWaitTime(int level, uint64_t t,
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::setPatternMask(uint64_t mask, int detPos) {
|
||||
void multiSlsDetector::setPatternMask(uint64_t mask, int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setPatternMask(mask);
|
||||
detectors[detPos]->setPatternMask(mask);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::setPatternMask, mask);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::setPatternMask, mask);
|
||||
}
|
||||
|
||||
uint64_t multiSlsDetector::getPatternMask(int detPos) {
|
||||
@ -3962,12 +3868,11 @@ uint64_t multiSlsDetector::getPatternMask(int detPos) {
|
||||
}
|
||||
}
|
||||
|
||||
int multiSlsDetector::setPatternBitMask(uint64_t mask, int detPos) {
|
||||
void multiSlsDetector::setPatternBitMask(uint64_t mask, int detPos) {
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setPatternBitMask(mask);
|
||||
detectors[detPos]->setPatternBitMask(mask);
|
||||
}
|
||||
auto r = parallelCall(&slsDetector::setPatternBitMask, mask);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::setPatternBitMask, mask);
|
||||
}
|
||||
|
||||
uint64_t multiSlsDetector::getPatternBitMask(int detPos) {
|
||||
@ -3995,16 +3900,15 @@ int multiSlsDetector::setLEDEnable(int enable, int detPos) {
|
||||
return sls::minusOneIfDifferent(r);
|
||||
}
|
||||
|
||||
int multiSlsDetector::setDigitalIODelay(uint64_t pinMask, int delay,
|
||||
void multiSlsDetector::setDigitalIODelay(uint64_t pinMask, int delay,
|
||||
int detPos) {
|
||||
// single
|
||||
if (detPos >= 0) {
|
||||
return detectors[detPos]->setDigitalIODelay(pinMask, delay);
|
||||
detectors[detPos]->setDigitalIODelay(pinMask, delay);
|
||||
}
|
||||
|
||||
// multi
|
||||
auto r = parallelCall(&slsDetector::setDigitalIODelay, pinMask, delay);
|
||||
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
|
||||
parallelCall(&slsDetector::setDigitalIODelay, pinMask, delay);
|
||||
}
|
||||
|
||||
int multiSlsDetector::retrieveDetectorSetup(const std::string &fname1,
|
||||
@ -4209,7 +4113,7 @@ void multiSlsDetector::registerDataCallback(
|
||||
void *pArg) {
|
||||
dataReady = userCallback;
|
||||
pCallbackArg = pArg;
|
||||
if (setReceiverOnline() == slsDetectorDefs::ONLINE_FLAG) {
|
||||
if (getUseReceiverFlag()) {
|
||||
if (dataReady == nullptr) {
|
||||
enableDataStreamingToClient(0);
|
||||
enableDataStreamingFromReceiver(0);
|
||||
@ -4282,7 +4186,7 @@ int multiSlsDetector::acquire() {
|
||||
// process)
|
||||
sem_init(&sem_endRTAcquisition, 1, 0);
|
||||
|
||||
bool receiver = (setReceiverOnline() == ONLINE_FLAG);
|
||||
bool receiver = getUseReceiverFlag();
|
||||
progressIndex = 0;
|
||||
multi_shm()->stoppedFlag = 0;
|
||||
setJoinThreadFlag(false);
|
||||
@ -4291,9 +4195,7 @@ int multiSlsDetector::acquire() {
|
||||
if (receiver) {
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
if (getReceiverStatus() != IDLE) {
|
||||
if (stopReceiver() == FAIL) {
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
}
|
||||
stopReceiver();
|
||||
}
|
||||
}
|
||||
|
||||
@ -4302,19 +4204,13 @@ int multiSlsDetector::acquire() {
|
||||
// resets frames caught in receiver
|
||||
if (receiver && multi_shm()->stoppedFlag == 0) {
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
if (resetFramesCaught() == FAIL) {
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
}
|
||||
resetFramesCaught();
|
||||
}
|
||||
|
||||
// start receiver
|
||||
if (receiver && multi_shm()->stoppedFlag == 0) {
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
if (startReceiver() == FAIL) {
|
||||
FILE_LOG(logERROR) << "Start receiver failed ";
|
||||
stopReceiver();
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
}
|
||||
startReceiver();
|
||||
// let processing thread listen to these packets
|
||||
if (multi_shm()->stoppedFlag == 0)
|
||||
sem_post(&sem_newRTAcquisition);
|
||||
@ -4326,15 +4222,13 @@ int multiSlsDetector::acquire() {
|
||||
// stop receiver
|
||||
if (receiver) {
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
if (stopReceiver() == FAIL) {
|
||||
multi_shm()->stoppedFlag = 1;
|
||||
} else {
|
||||
stopReceiver();
|
||||
if (dataReady != nullptr) {
|
||||
sem_wait(&sem_endRTAcquisition); // waits for receiver's
|
||||
}
|
||||
// external process to be
|
||||
// done sending data to gui
|
||||
}
|
||||
|
||||
incrementFileIndex();
|
||||
}
|
||||
|
||||
@ -4372,9 +4266,7 @@ void multiSlsDetector::startProcessingThread() {
|
||||
}
|
||||
|
||||
void multiSlsDetector::processData() {
|
||||
if (setReceiverOnline() == OFFLINE_FLAG) {
|
||||
return;
|
||||
} else {
|
||||
if (getUseReceiverFlag()) {
|
||||
if (dataReady != nullptr) {
|
||||
readFrameFromReceiver();
|
||||
}
|
||||
@ -4391,7 +4283,7 @@ void multiSlsDetector::processData() {
|
||||
}
|
||||
}
|
||||
// get progress
|
||||
if (setReceiverOnline() == ONLINE_FLAG) {
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mg);
|
||||
caught = getFramesCaughtByReceiver(0);
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -301,13 +301,6 @@ slsDetectorCommand::slsDetectorCommand(multiSlsDetector *det) {
|
||||
commands to configure detector status
|
||||
*/
|
||||
|
||||
/*! \page config
|
||||
- <b>online [i]</b> sets the detector in online (1) or offline (0) mode. \c Returns \c (int)
|
||||
*/
|
||||
descrToFuncMap[i].m_pFuncName = "online";
|
||||
descrToFuncMap[i].m_pFuncPtr = &slsDetectorCommand::cmdOnline;
|
||||
++i;
|
||||
|
||||
/*! \page config
|
||||
- <b>checkonline</b> returns the hostnames of all detectors without connecting to them. \c Returns (string) "All online" or "[list of offline hostnames] : Not online".
|
||||
*/
|
||||
@ -1804,13 +1797,6 @@ slsDetectorCommand::slsDetectorCommand(multiSlsDetector *det) {
|
||||
descrToFuncMap[i].m_pFuncPtr = &slsDetectorCommand::cmdReceiver;
|
||||
++i;
|
||||
|
||||
/*! \page receiver
|
||||
- <b>rx_online [i]</b> sets/gets the receiver in online/offline mode. 1 is online, 0 is offline. Get is from shared memory. \c Returns \c (int)
|
||||
*/
|
||||
descrToFuncMap[i].m_pFuncName = "rx_online";
|
||||
descrToFuncMap[i].m_pFuncPtr = &slsDetectorCommand::cmdOnline;
|
||||
++i;
|
||||
|
||||
/*! \page receiver
|
||||
- <b>rx_checkonline</b> Checks the receiver if it is online/offline mode. Only get! \c Returns (string) "All online" or "[list of offline hostnames] : Not online".
|
||||
*/
|
||||
@ -2219,13 +2205,9 @@ std::string slsDetectorCommand::cmdAcquire(int narg, const char * const args[],
|
||||
return std::string("acquire failed");
|
||||
}
|
||||
|
||||
int rx_online = myDet->setReceiverOnline(-1, detPos);
|
||||
|
||||
|
||||
|
||||
if (myDet->acquire() == FAIL)
|
||||
return std::string("acquire failed");
|
||||
if (rx_online) {
|
||||
if (myDet->getUseReceiverFlag(detPos)) {
|
||||
char answer[100];
|
||||
sprintf(answer, "\nAcquired %d", myDet->getFramesCaughtByReceiver(detPos));
|
||||
return std::string(answer);
|
||||
@ -2261,7 +2243,7 @@ std::string slsDetectorCommand::cmdData(int narg, const char * const args[], int
|
||||
// myDet->setThreadedProcessing(0);
|
||||
// myDet->readAll(detPos);
|
||||
// //processdata in receiver is useful only for gui purposes
|
||||
// if(myDet->setReceiverOnline(detPos)==OFFLINE_FLAG)
|
||||
// if(myDet->getUseReceiverFlag(detPos)==OFFLINE_FLAG)
|
||||
// myDet->processData();
|
||||
// myDet->setThreadedProcessing(b);
|
||||
return std::string("");
|
||||
@ -2489,28 +2471,20 @@ std::string slsDetectorCommand::cmdExitServer(int narg, const char * const args[
|
||||
|
||||
if (action == PUT_ACTION) {
|
||||
if (cmd == "exitserver") {
|
||||
if (myDet->exitServer(detPos) == OK)
|
||||
return std::string("Server shut down.");
|
||||
else
|
||||
return std::string("Error closing server\n");
|
||||
myDet->exitServer(detPos);
|
||||
return std::string("Server shut down.");
|
||||
} else if (cmd == "rx_exit") {
|
||||
|
||||
if (myDet->exitReceiver(detPos) == OK)
|
||||
return std::string("Receiver shut down\n");
|
||||
else
|
||||
return std::string("Error closing receiver\n");
|
||||
myDet->exitReceiver(detPos);
|
||||
return std::string("Receiver shut down\n");
|
||||
} else if (cmd == "execcommand") {
|
||||
if (myDet->execCommand(std::string(args[1]), detPos) == OK)
|
||||
return std::string("Command executed successfully\n");
|
||||
else
|
||||
return std::string("Command failed\n");
|
||||
myDet->execCommand(std::string(args[1]), detPos);
|
||||
return std::string("Command executed successfully\n");
|
||||
} else if (cmd == "rx_execcommand") {
|
||||
|
||||
if (myDet->execReceiverCommand(std::string(args[1]), detPos) == OK)
|
||||
return std::string("Command executed successfully\n");
|
||||
else
|
||||
return std::string("Command failed\n");
|
||||
} else
|
||||
myDet->execReceiverCommand(std::string(args[1]), detPos);
|
||||
return std::string("Command executed successfully\n");
|
||||
} else
|
||||
return ("cannot decode command\n");
|
||||
} else
|
||||
return ("cannot get");
|
||||
@ -2781,7 +2755,6 @@ std::string slsDetectorCommand::helpThreaded(int action) {
|
||||
|
||||
std::string slsDetectorCommand::cmdImage(int narg, const char * const args[], int action, int detPos) {
|
||||
std::string sval;
|
||||
int retval = FAIL;
|
||||
if (action == HELP_ACTION)
|
||||
return helpImage(HELP_ACTION);
|
||||
else if (action == GET_ACTION)
|
||||
@ -2790,14 +2763,11 @@ std::string slsDetectorCommand::cmdImage(int narg, const char * const args[], in
|
||||
sval = std::string(args[1]);
|
||||
|
||||
if (std::string(args[0]) == std::string("darkimage"))
|
||||
retval = myDet->loadImageToDetector(DARK_IMAGE, sval, detPos);
|
||||
myDet->loadImageToDetector(DARK_IMAGE, sval, detPos);
|
||||
else if (std::string(args[0]) == std::string("gainimage"))
|
||||
retval = myDet->loadImageToDetector(GAIN_IMAGE, sval, detPos);
|
||||
myDet->loadImageToDetector(GAIN_IMAGE, sval, detPos);
|
||||
|
||||
if (retval == OK)
|
||||
return std::string("Image loaded succesfully");
|
||||
else
|
||||
return std::string("Image load failed");
|
||||
return std::string("Image loaded succesfully");
|
||||
}
|
||||
|
||||
std::string slsDetectorCommand::helpImage(int action) {
|
||||
@ -2831,13 +2801,16 @@ std::string slsDetectorCommand::cmdCounter(int narg, const char * const args[],
|
||||
if (narg < 3)
|
||||
return std::string("should specify I/O file");
|
||||
sval = std::string(args[2]);
|
||||
retval = myDet->writeCounterBlockFile(sval, ival, detPos);
|
||||
myDet->writeCounterBlockFile(sval, ival, detPos);
|
||||
return std::string("Counter read succesfully");
|
||||
}
|
||||
} else if (std::string(args[0]) == std::string("resetctr")) {
|
||||
if (action == GET_ACTION)
|
||||
return std::string("Cannot get");
|
||||
else
|
||||
retval = myDet->resetCounterBlock(ival, detPos);
|
||||
else {
|
||||
myDet->resetCounterBlock(ival, detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
}
|
||||
|
||||
else if (std::string(args[0]) == std::string("resmat")) {
|
||||
@ -2852,7 +2825,7 @@ std::string slsDetectorCommand::cmdCounter(int narg, const char * const args[],
|
||||
}
|
||||
|
||||
if (retval == OK)
|
||||
return std::string("Counter read/reset succesfully");
|
||||
return std::string("Counter set/reset succesfully");
|
||||
else
|
||||
return std::string("Counter read/reset failed");
|
||||
}
|
||||
@ -3254,15 +3227,7 @@ std::string slsDetectorCommand::cmdOnline(int narg, const char * const args[], i
|
||||
int ival;
|
||||
char ans[1000];
|
||||
|
||||
if (cmd == "online") {
|
||||
if (action == PUT_ACTION) {
|
||||
if (sscanf(args[1], "%d", &ival))
|
||||
myDet->setOnline(ival, detPos);
|
||||
else
|
||||
return std::string("Could not scan online mode ") + std::string(args[1]);
|
||||
}
|
||||
sprintf(ans, "%d", myDet->setOnline(-1, detPos));
|
||||
} else if (cmd == "checkonline") {
|
||||
if (cmd == "checkonline") {
|
||||
if (action == PUT_ACTION)
|
||||
return std::string("cannot set");
|
||||
strcpy(ans, myDet->checkOnline(detPos).c_str());
|
||||
@ -3289,14 +3254,6 @@ std::string slsDetectorCommand::cmdOnline(int narg, const char * const args[], i
|
||||
}
|
||||
int ret = myDet->setDeactivatedRxrPaddingMode(-1, detPos);
|
||||
sprintf(ans, "%d %s", myDet->activate(-1, detPos), ret == 1 ? "padding" : (ret == 0 ? "nopadding" : "unknown"));
|
||||
} else if (cmd == "rx_online") {
|
||||
if (action == PUT_ACTION) {
|
||||
if (sscanf(args[1], "%d", &ival))
|
||||
myDet->setReceiverOnline(ival, detPos);
|
||||
else
|
||||
return std::string("Could not scan online mode ") + std::string(args[1]);
|
||||
}
|
||||
sprintf(ans, "%d", myDet->setReceiverOnline(-1, detPos));
|
||||
} else {
|
||||
if (action == PUT_ACTION)
|
||||
return std::string("cannot set");
|
||||
@ -3314,14 +3271,10 @@ std::string slsDetectorCommand::helpOnline(int action) {
|
||||
|
||||
std::ostringstream os;
|
||||
if (action == PUT_ACTION || action == HELP_ACTION) {
|
||||
os << "online i \n sets the detector in online (1) or offline (0) mode" << std::endl;
|
||||
os << "rx_online i \n sets the receiver in online (1) or offline (0) mode" << std::endl;
|
||||
os << "activate i [p]\n sets the detector in activated (1) or deactivated (0) mode (does not send data). p is optional and can be padding (default) or nonpadding for receivers for deactivated detectors. Only for Eiger." << std::endl;
|
||||
}
|
||||
if (action == GET_ACTION || action == HELP_ACTION) {
|
||||
os << "online \n gets the detector online (1) or offline (0) mode" << std::endl;
|
||||
os << "checkonline \n returns the hostnames of all detectors in offline mode" << std::endl;
|
||||
os << "rx_online \n gets the receiver online (1) or offline (0) mode" << std::endl;
|
||||
os << "rx_checkonline \n returns the hostnames of all receiver in offline mode" << std::endl;
|
||||
os << "activate \n gets the detector activated (1) or deactivated (0) mode. And padding or nonpadding for the deactivated receiver. Only for Eiger." << std::endl;
|
||||
}
|
||||
@ -3333,17 +3286,12 @@ std::string slsDetectorCommand::cmdConfigureMac(int narg, const char * const arg
|
||||
if (action == HELP_ACTION) {
|
||||
return helpConfigureMac(action);
|
||||
}
|
||||
int ret;
|
||||
char ans[1000];
|
||||
|
||||
if (action == PUT_ACTION) {
|
||||
|
||||
ret = myDet->configureMAC(detPos);
|
||||
myDet->configureMAC(detPos);
|
||||
} else
|
||||
return std::string("Cannot get ") + cmd;
|
||||
|
||||
sprintf(ans, "%d", ret);
|
||||
return ans;
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
std::string slsDetectorCommand::helpConfigureMac(int action) {
|
||||
@ -3547,17 +3495,13 @@ std::string slsDetectorCommand::cmdSettings(int narg, const char * const args[],
|
||||
#ifdef VERBOSE
|
||||
std::cout << " trimfile " << sval << std::endl;
|
||||
#endif
|
||||
int ret = OK;
|
||||
if (action == GET_ACTION) {
|
||||
//create file names
|
||||
ret = myDet->saveSettingsFile(sval, detPos);
|
||||
myDet->saveSettingsFile(sval, detPos);
|
||||
} else if (action == PUT_ACTION) {
|
||||
ret = myDet->loadSettingsFile(sval, detPos);
|
||||
myDet->loadSettingsFile(sval, detPos);
|
||||
}
|
||||
if (ret == OK)
|
||||
return sval;
|
||||
else
|
||||
return std::string("failed");
|
||||
return sval;
|
||||
}
|
||||
return std::string("Specify file name for geting settings file");
|
||||
} else if (cmd == "trimval") {
|
||||
@ -3652,19 +3596,13 @@ std::string slsDetectorCommand::cmdSN(int narg, const char * const args[], int a
|
||||
}
|
||||
|
||||
if (cmd == "checkdetversion") {
|
||||
int retval = myDet->checkDetectorVersionCompatibility(detPos);
|
||||
if (retval < 0)
|
||||
sprintf(answer, "%d", -1);
|
||||
sprintf(answer, "%s", retval == OK ? "compatible" : "incompatible");
|
||||
return std::string(answer);
|
||||
myDet->checkDetectorVersionCompatibility(detPos);
|
||||
return std::string("compatible");
|
||||
}
|
||||
|
||||
if (cmd == "rx_checkversion") {
|
||||
int retval = myDet->checkReceiverVersionCompatibility(detPos);
|
||||
if (retval < 0)
|
||||
sprintf(answer, "%d", -1);
|
||||
sprintf(answer, "%s", retval == OK ? "compatible" : "incompatible");
|
||||
return std::string(answer);
|
||||
myDet->checkReceiverVersionCompatibility(detPos);
|
||||
return std::string("compatible");
|
||||
}
|
||||
|
||||
return std::string("unknown id mode ") + cmd;
|
||||
@ -3779,7 +3717,8 @@ std::string slsDetectorCommand::cmdRegister(int narg, const char * const args[],
|
||||
;
|
||||
else
|
||||
return std::string("Could not scan value (hexadecimal fomat) ") + std::string(args[2]);
|
||||
sprintf(answer, "%s", (myDet->writeAdcRegister(addr, val, detPos) == OK) ? "successful" : "failed");
|
||||
myDet->writeAdcRegister(addr, val, detPos);
|
||||
sprintf(answer, "%s","successful");
|
||||
} else {
|
||||
|
||||
if (sscanf(args[2], "%d", &n))
|
||||
@ -4815,17 +4754,15 @@ std::string slsDetectorCommand::cmdAdvanced(int narg, const char * const args[],
|
||||
if (strstr(args[1], ".pof") == nullptr)
|
||||
return std::string("wrong usage: programming file should have .pof extension");
|
||||
std::string sval = std::string(args[1]);
|
||||
if (myDet->programFPGA(sval, detPos) == OK)
|
||||
return std::string("successful");
|
||||
return std::string("failed");
|
||||
myDet->programFPGA(sval, detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "resetfpga") {
|
||||
if (action == GET_ACTION)
|
||||
return std::string("cannot get");
|
||||
if (myDet->resetFPGA(detPos) == OK)
|
||||
return std::string("successful");
|
||||
return std::string("failed");
|
||||
myDet->resetFPGA(detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "copydetectorserver") {
|
||||
@ -4835,17 +4772,15 @@ std::string slsDetectorCommand::cmdAdvanced(int narg, const char * const args[],
|
||||
return ("wrong usage." + helpAdvanced(PUT_ACTION));
|
||||
std::string sval = std::string(args[1]);
|
||||
std::string pval = std::string(args[2]);
|
||||
if (myDet->copyDetectorServer(sval, pval, detPos) == OK)
|
||||
return std::string("successful");
|
||||
return std::string("failed");
|
||||
myDet->copyDetectorServer(sval, pval, detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "rebootcontroller") {
|
||||
if (action == GET_ACTION)
|
||||
return std::string("cannot get");
|
||||
if (myDet->rebootController(detPos) == OK)
|
||||
return std::string("successful");
|
||||
return std::string("failed");
|
||||
myDet->rebootController(detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "update") {
|
||||
@ -4859,9 +4794,8 @@ std::string slsDetectorCommand::cmdAdvanced(int narg, const char * const args[],
|
||||
std::string sval = std::string(args[1]);
|
||||
std::string pval = std::string(args[2]);
|
||||
std::string fval = std::string(args[3]);
|
||||
if (myDet->update(sval, pval, fval, detPos) == OK)
|
||||
return std::string("successful");
|
||||
return std::string("failed");
|
||||
myDet->update(sval, pval, fval, detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "powerchip") {
|
||||
@ -4899,10 +4833,8 @@ std::string slsDetectorCommand::cmdAdvanced(int narg, const char * const args[],
|
||||
if (!sscanf(args[2], "%d", &delay))
|
||||
return std::string("could not scan diodelay delay " + std::string(args[2]));
|
||||
|
||||
int retval = myDet->setDigitalIODelay(pinMask, delay, detPos);
|
||||
if (retval == -1)
|
||||
return std::to_string(-1);
|
||||
return std::string((retval == OK) ? "successful" : "failed");
|
||||
myDet->setDigitalIODelay(pinMask, delay, detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
|
||||
else if (cmd == "auto_comp_disable") {
|
||||
@ -5048,11 +4980,8 @@ std::string slsDetectorCommand::cmdReceiver(int narg, const char * const args[],
|
||||
if (action == GET_ACTION)
|
||||
return std::string("cannot get");
|
||||
else {
|
||||
if (myDet->resetFramesCaught(detPos) == OK)
|
||||
strcpy(answer, "successful");
|
||||
else
|
||||
strcpy(answer, "failed");
|
||||
return std::string(answer);
|
||||
myDet->resetFramesCaught(detPos);
|
||||
return std::string("successful");
|
||||
}
|
||||
}
|
||||
|
||||
@ -5102,7 +5031,7 @@ std::string slsDetectorCommand::cmdReceiver(int narg, const char * const args[],
|
||||
else if (cmd == "rx_silent") {
|
||||
if (action == PUT_ACTION) {
|
||||
if (!sscanf(args[1], "%d", &ival))
|
||||
return std::string("Could not scan rx_online input ") + std::string(args[1]);
|
||||
return std::string("Could not scan rx_silent input ") + std::string(args[1]);
|
||||
if (ival >= 0)
|
||||
sprintf(answer, "%d", myDet->setReceiverSilentMode(ival, detPos));
|
||||
} else
|
||||
@ -5729,7 +5658,6 @@ std::string slsDetectorCommand::helpPulse(int action) {
|
||||
}
|
||||
|
||||
std::string slsDetectorCommand::cmdPulse(int narg, const char * const args[], int action, int detPos) {
|
||||
int retval = FAIL;
|
||||
|
||||
if (action == HELP_ACTION)
|
||||
return helpPulse(action);
|
||||
@ -5742,7 +5670,7 @@ std::string slsDetectorCommand::cmdPulse(int narg, const char * const args[], in
|
||||
return std::string("Could not scan 1st argument ") + std::string(args[1]);
|
||||
|
||||
if (std::string(args[0]) == std::string("pulsechip"))
|
||||
retval = myDet->pulseChip(ival1, detPos);
|
||||
myDet->pulseChip(ival1, detPos);
|
||||
|
||||
else {
|
||||
//next commands requires 3 addnl. arguments
|
||||
@ -5755,19 +5683,16 @@ std::string slsDetectorCommand::cmdPulse(int narg, const char * const args[], in
|
||||
return std::string("Could not scan 3rd argument ") + std::string(args[3]);
|
||||
|
||||
if (std::string(args[0]) == std::string("pulse"))
|
||||
retval = myDet->pulsePixel(ival1, ival2, ival3, detPos);
|
||||
myDet->pulsePixel(ival1, ival2, ival3, detPos);
|
||||
|
||||
else if (std::string(args[0]) == std::string("pulsenmove"))
|
||||
retval = myDet->pulsePixelNMove(ival1, ival2, ival3, detPos);
|
||||
myDet->pulsePixelNMove(ival1, ival2, ival3, detPos);
|
||||
|
||||
else
|
||||
return std::string("could not decode command") + cmd;
|
||||
std::string("could not decode command") + cmd;
|
||||
}
|
||||
|
||||
if (retval == OK)
|
||||
return std::string(" successful");
|
||||
else
|
||||
return std::string(" failed");
|
||||
return std::string(" successful");
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -30,13 +30,6 @@ int slsDetectorUsers::getDetectorSize(int &x, int &y, int &nx, int &ny, int detP
|
||||
std::string slsDetectorUsers::getDetectorType(int detPos){
|
||||
return detector.getDetectorTypeAsString(detPos);
|
||||
}
|
||||
int slsDetectorUsers::setOnline(int const online, int detPos){
|
||||
return detector.setOnline(online, detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::setReceiverOnline(int const online, int detPos){
|
||||
return detector.setReceiverOnline(online, detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::readConfigurationFile(const std::string& fname){
|
||||
try{
|
||||
@ -79,36 +72,36 @@ int64_t slsDetectorUsers::getReceiverSoftwareVersion(int detPos){
|
||||
return detector.getId(slsDetectorDefs::RECEIVER_VERSION, detPos);
|
||||
}
|
||||
|
||||
bool slsDetectorUsers::isDetectorVersionCompatible(int detPos) {
|
||||
return (detector.checkDetectorVersionCompatibility(detPos) == slsDetectorDefs::OK);
|
||||
void slsDetectorUsers::isDetectorVersionCompatible(int detPos) {
|
||||
detector.checkDetectorVersionCompatibility(detPos);
|
||||
}
|
||||
|
||||
bool slsDetectorUsers::isReceiverVersionCompatible(int detPos) {
|
||||
return (detector.checkReceiverVersionCompatibility(detPos) == slsDetectorDefs::OK);
|
||||
void slsDetectorUsers::isReceiverVersionCompatible(int detPos) {
|
||||
detector.checkReceiverVersionCompatibility(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::startMeasurement(){
|
||||
return detector.acquire();
|
||||
}
|
||||
|
||||
int slsDetectorUsers::stopMeasurement(int detPos){
|
||||
return detector.stopAcquisition(detPos);
|
||||
void slsDetectorUsers::stopMeasurement(int detPos){
|
||||
detector.stopAcquisition(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::getDetectorStatus(int detPos){
|
||||
return (int)detector.getRunStatus(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::startAcquisition(int detPos) {
|
||||
return detector.startAcquisition(detPos);
|
||||
void slsDetectorUsers::startAcquisition(int detPos) {
|
||||
detector.startAcquisition(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::stopAcquisition(int detPos) {
|
||||
return detector.stopAcquisition(detPos);
|
||||
void slsDetectorUsers::stopAcquisition(int detPos) {
|
||||
detector.stopAcquisition(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::sendSoftwareTrigger(int detPos) {
|
||||
return detector.sendSoftwareTrigger(detPos);
|
||||
void slsDetectorUsers::sendSoftwareTrigger(int detPos) {
|
||||
detector.sendSoftwareTrigger(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::enableCountRateCorrection(int i, int detPos){
|
||||
@ -237,8 +230,8 @@ int slsDetectorUsers::setFlowControl10G(int i, int detPos) {
|
||||
return detector.setFlowControl10G(i, detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::setROI(int n, slsDetectorDefs::ROI roiLimits[], int detPos) {
|
||||
return detector.setROI(n, roiLimits, detPos);
|
||||
void slsDetectorUsers::setROI(int n, slsDetectorDefs::ROI roiLimits[], int detPos) {
|
||||
detector.setROI(n, roiLimits, detPos);
|
||||
}
|
||||
|
||||
const slsDetectorDefs::ROI* slsDetectorUsers::getROI(int &n, int detPos) {
|
||||
@ -252,20 +245,20 @@ const slsDetectorDefs::ROI* slsDetectorUsers::getROI(int &n, int detPos) {
|
||||
*********************************************************************/
|
||||
|
||||
|
||||
int slsDetectorUsers::startReceiver(int detPos) {
|
||||
return detector.startReceiver(detPos);
|
||||
void slsDetectorUsers::startReceiver(int detPos) {
|
||||
detector.startReceiver(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::stopReceiver(int detPos) {
|
||||
return detector.stopReceiver(detPos);
|
||||
void slsDetectorUsers::stopReceiver(int detPos) {
|
||||
detector.stopReceiver(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::setReceiverSilentMode(int i, int detPos) {
|
||||
return detector.setReceiverSilentMode(i, detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::resetFramesCaughtInReceiver(int detPos) {
|
||||
return detector.resetFramesCaught(detPos);
|
||||
void slsDetectorUsers::resetFramesCaughtInReceiver(int detPos) {
|
||||
detector.resetFramesCaught(detPos);
|
||||
}
|
||||
|
||||
int slsDetectorUsers::setReceiverFifoDepth(int i, int detPos) {
|
||||
|
||||
Reference in New Issue
Block a user