detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-24 15:20:02 +02:00
Code Issues Actions Packages Releases Activity

const

Browse Source
This commit is contained in:
Erik Frojdh 2020-07-27 09:14:58 +02:00
parent b1a4723028
commit dc33f1a5da
2 changed files with 92 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
slsDetectorSoftware/src/Module.cpp
View File

@ -1273,7 +1273,7 @@ void Module::setQuad(const bool enable) {
// Jungfrau Specific // Jungfrau Specific
int Module::getThresholdTemperature() { int Module::getThresholdTemperature() const {
int arg = GET_FLAG; int arg = GET_FLAG;
auto retval = sendToDetectorStop<int>(F_THRESHOLD_TEMP, arg); auto retval = sendToDetectorStop<int>(F_THRESHOLD_TEMP, arg);
if (retval != 0) { if (retval != 0) {
@ -1291,7 +1291,7 @@ void Module::setThresholdTemperature(int val) {
sendToDetectorStop<int>(F_THRESHOLD_TEMP, val); sendToDetectorStop<int>(F_THRESHOLD_TEMP, val);
} }
bool Module::getTemperatureControl() { bool Module::getTemperatureControl() const {
int arg = GET_FLAG; int arg = GET_FLAG;
return static_cast<bool>(sendToDetectorStop<int>(F_TEMP_CONTROL, arg)); return static_cast<bool>(sendToDetectorStop<int>(F_TEMP_CONTROL, arg));
} }
@ -1300,7 +1300,7 @@ void Module::setTemperatureControl(bool val) {
sendToDetectorStop<int>(F_TEMP_CONTROL, static_cast<int>(val)); sendToDetectorStop<int>(F_TEMP_CONTROL, static_cast<int>(val));
} }
int Module::getTemperatureEvent() { int Module::getTemperatureEvent() const {
int arg = GET_FLAG; int arg = GET_FLAG;
return sendToDetectorStop<int>(F_TEMP_EVENT, arg); return sendToDetectorStop<int>(F_TEMP_EVENT, arg);
} }
@ -1310,7 +1310,7 @@ void Module::resetTemperatureEvent() {
sendToDetectorStop<int>(F_TEMP_EVENT, arg); sendToDetectorStop<int>(F_TEMP_EVENT, arg);
} }
bool Module::getAutoComparatorDisableMode() { bool Module::getAutoComparatorDisableMode() const{
int arg = GET_FLAG; int arg = GET_FLAG;
return static_cast<bool>(sendToDetector<int>(F_AUTO_COMP_DISABLE, arg)); return static_cast<bool>(sendToDetector<int>(F_AUTO_COMP_DISABLE, arg));
} }
@ -1319,7 +1319,7 @@ void Module::setAutoComparatorDisableMode(bool val) {
sendToDetector<int>(F_AUTO_COMP_DISABLE, static_cast<int>(val)); sendToDetector<int>(F_AUTO_COMP_DISABLE, static_cast<int>(val));
} }
int Module::getNumberOfAdditionalStorageCells() { int Module::getNumberOfAdditionalStorageCells() const {
return sendToDetector<int>(F_GET_NUM_ADDITIONAL_STORAGE_CELLS); return sendToDetector<int>(F_GET_NUM_ADDITIONAL_STORAGE_CELLS);
} }
@ -1327,7 +1327,7 @@ void Module::setNumberOfAdditionalStorageCells(int value) {
sendToDetector(F_SET_NUM_ADDITIONAL_STORAGE_CELLS, value, nullptr); sendToDetector(F_SET_NUM_ADDITIONAL_STORAGE_CELLS, value, nullptr);
} }
int Module::getStorageCellStart() { int Module::getStorageCellStart() const {
int arg = GET_FLAG; int arg = GET_FLAG;
return sendToDetector<int>(F_STORAGE_CELL_START, arg); return sendToDetector<int>(F_STORAGE_CELL_START, arg);
} }
@ -1336,7 +1336,7 @@ void Module::setStorageCellStart(int pos) {
sendToDetector<int>(F_STORAGE_CELL_START, pos); sendToDetector<int>(F_STORAGE_CELL_START, pos);
} }
int64_t Module::getStorageCellDelay() { int64_t Module::getStorageCellDelay() const {
return sendToDetector<int64_t>(F_GET_STORAGE_CELL_DELAY); return sendToDetector<int64_t>(F_GET_STORAGE_CELL_DELAY);
} }
@ -1346,7 +1346,7 @@ void Module::setStorageCellDelay(int64_t value) {
// Gotthard Specific // Gotthard Specific
slsDetectorDefs::ROI Module::getROI() { slsDetectorDefs::ROI Module::getROI() const {
return sendToDetector<slsDetectorDefs::ROI>(F_GET_ROI); return sendToDetector<slsDetectorDefs::ROI>(F_GET_ROI);
} }
@ -1369,7 +1369,7 @@ int64_t Module::getExptimeLeft() const {
// Gotthard2 Specific // Gotthard2 Specific
int64_t Module::getNumberOfBursts() { int64_t Module::getNumberOfBursts() const {
return sendToDetector<int64_t>(F_GET_NUM_BURSTS); return sendToDetector<int64_t>(F_GET_NUM_BURSTS);
} }
@ -1380,7 +1380,7 @@ void Module::setNumberOfBursts(int64_t value) {
} }
} }
int64_t Module::getBurstPeriod() { int64_t Module::getBurstPeriod() const {
return sendToDetector<int64_t>(F_GET_BURST_PERIOD); return sendToDetector<int64_t>(F_GET_BURST_PERIOD);
} }
@ -1388,7 +1388,7 @@ void Module::setBurstPeriod(int64_t value) {
sendToDetector(F_SET_BURST_PERIOD, value, nullptr); sendToDetector(F_SET_BURST_PERIOD, value, nullptr);
} }
std::array<int, 2> Module::getInjectChannel() { std::array<int, 2> Module::getInjectChannel() const {
return sendToDetector<std::array<int, 2>>(F_GET_INJECT_CHANNEL); return sendToDetector<std::array<int, 2>>(F_GET_INJECT_CHANNEL);
} }
@ -1398,7 +1398,7 @@ void Module::setInjectChannel(const int offsetChannel,
sendToDetector(F_SET_INJECT_CHANNEL, args, nullptr); sendToDetector(F_SET_INJECT_CHANNEL, args, nullptr);
} }
std::vector<int> Module::getVetoPhoton(const int chipIndex) { std::vector<int> Module::getVetoPhoton(const int chipIndex) const {
int fnum = F_GET_VETO_PHOTON; int fnum = F_GET_VETO_PHOTON;
int ret = FAIL; int ret = FAIL;
auto client = DetectorSocket(shm()->hostname, shm()->controlPort); auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
@ -1609,7 +1609,7 @@ void Module::setVetoFile(const int chipIndex, const std::string &fname) {
} }
} }
slsDetectorDefs::burstMode Module::getBurstMode() { slsDetectorDefs::burstMode Module::getBurstMode() const{
auto r = sendToDetector<int>(F_GET_BURST_MODE); auto r = sendToDetector<int>(F_GET_BURST_MODE);
return static_cast<slsDetectorDefs::burstMode>(r); return static_cast<slsDetectorDefs::burstMode>(r);
} }
@ -1622,19 +1622,19 @@ void Module::setBurstMode(slsDetectorDefs::burstMode value) {
} }
} }
bool Module::getCDSGain() { return sendToDetector<int>(F_GET_CDS_GAIN); } bool Module::getCDSGain() const { return sendToDetector<int>(F_GET_CDS_GAIN); }
void Module::setCDSGain(bool value) { void Module::setCDSGain(bool value) {
sendToDetector(F_SET_CDS_GAIN, static_cast<int>(value), nullptr); sendToDetector(F_SET_CDS_GAIN, static_cast<int>(value), nullptr);
} }
int Module::getFilter() { return sendToDetector<int>(F_GET_FILTER); } int Module::getFilter() const { return sendToDetector<int>(F_GET_FILTER); }
void Module::setFilter(int value) { void Module::setFilter(int value) {
sendToDetector(F_SET_FILTER, value, nullptr); sendToDetector(F_SET_FILTER, value, nullptr);
} }
bool Module::getCurrentSource() { bool Module::getCurrentSource() const {
return sendToDetector<int>(F_GET_CURRENT_SOURCE); return sendToDetector<int>(F_GET_CURRENT_SOURCE);
} }
@ -1642,7 +1642,7 @@ void Module::setCurrentSource(bool value) {
sendToDetector(F_SET_CURRENT_SOURCE, static_cast<int>(value), nullptr); sendToDetector(F_SET_CURRENT_SOURCE, static_cast<int>(value), nullptr);
} }
slsDetectorDefs::timingSourceType Module::getTimingSource() { slsDetectorDefs::timingSourceType Module::getTimingSource() const {
auto r = sendToDetector<int>(F_GET_TIMING_SOURCE); auto r = sendToDetector<int>(F_GET_TIMING_SOURCE);
return static_cast<slsDetectorDefs::timingSourceType>(r); return static_cast<slsDetectorDefs::timingSourceType>(r);
} }
@ -1651,13 +1651,13 @@ void Module::setTimingSource(slsDetectorDefs::timingSourceType value) {
sendToDetector(F_SET_TIMING_SOURCE, static_cast<int>(value), nullptr); sendToDetector(F_SET_TIMING_SOURCE, static_cast<int>(value), nullptr);
} }
bool Module::getVeto() { return sendToDetector<int>(F_GET_VETO); } bool Module::getVeto() const { return sendToDetector<int>(F_GET_VETO); }
void Module::setVeto(bool enable) { void Module::setVeto(bool enable) {
sendToDetector(F_SET_VETO, static_cast<int>(enable), nullptr); sendToDetector(F_SET_VETO, static_cast<int>(enable), nullptr);
} }
int Module::getADCConfiguration(const int chipIndex, const int adcIndex) { int Module::getADCConfiguration(const int chipIndex, const int adcIndex) const {
int args[]{chipIndex, adcIndex}; int args[]{chipIndex, adcIndex};
return sendToDetector<int>(F_GET_ADC_CONFIGURATION, args); return sendToDetector<int>(F_GET_ADC_CONFIGURATION, args);
} }
@ -1668,7 +1668,7 @@ void Module::setADCConfiguration(const int chipIndex, const int adcIndex,
sendToDetector(F_SET_ADC_CONFIGURATION, args, nullptr); sendToDetector(F_SET_ADC_CONFIGURATION, args, nullptr);
} }
void Module::getBadChannels(const std::string &fname) { void Module::getBadChannels(const std::string &fname) const {
LOG(logDEBUG1) << "Getting bad channels to " << fname; LOG(logDEBUG1) << "Getting bad channels to " << fname;
int fnum = F_GET_BAD_CHANNELS; int fnum = F_GET_BAD_CHANNELS;
int ret = FAIL; int ret = FAIL;
@ -1754,7 +1754,7 @@ void Module::setBadChannels(const std::string &fname) {
// Mythen3 Specific // Mythen3 Specific
uint32_t Module::getCounterMask() { uint32_t Module::getCounterMask() const {
return sendToDetector<uint32_t>(F_GET_COUNTER_MASK); return sendToDetector<uint32_t>(F_GET_COUNTER_MASK);
} }
@ -1768,7 +1768,7 @@ void Module::setCounterMask(uint32_t countermask) {
} }
} }
int Module::getNumberOfGates() { return sendToDetector<int>(F_GET_NUM_GATES); } int Module::getNumberOfGates() const { return sendToDetector<int>(F_GET_NUM_GATES); }
void Module::setNumberOfGates(int value) { void Module::setNumberOfGates(int value) {
sendToDetector(F_SET_NUM_GATES, value, nullptr); sendToDetector(F_SET_NUM_GATES, value, nullptr);
@ -1777,12 +1777,12 @@ void Module::setNumberOfGates(int value) {
} }
} }
std::array<time::ns, 3> Module::getExptimeForAllGates() { std::array<time::ns, 3> Module::getExptimeForAllGates() const {
static_assert(sizeof(time::ns) == 8, "ns needs to be 64bit"); static_assert(sizeof(time::ns) == 8, "ns needs to be 64bit");
return sendToDetector<std::array<time::ns, 3>>(F_GET_EXPTIME_ALL_GATES); return sendToDetector<std::array<time::ns, 3>>(F_GET_EXPTIME_ALL_GATES);
} }
int64_t Module::getGateDelay(int gateIndex) { int64_t Module::getGateDelay(int gateIndex) const {
return sendToDetector<int64_t>(F_GET_GATE_DELAY, gateIndex); return sendToDetector<int64_t>(F_GET_GATE_DELAY, gateIndex);
} }
@ -1794,14 +1794,14 @@ void Module::setGateDelay(int gateIndex, int64_t value) {
} }
} }
std::array<time::ns, 3> Module::getGateDelayForAllGates() { std::array<time::ns, 3> Module::getGateDelayForAllGates() const {
static_assert(sizeof(time::ns) == 8, "ns needs to be 64bit"); static_assert(sizeof(time::ns) == 8, "ns needs to be 64bit");
return sendToDetector<std::array<time::ns, 3>>(F_GET_GATE_DELAY_ALL_GATES); return sendToDetector<std::array<time::ns, 3>>(F_GET_GATE_DELAY_ALL_GATES);
} }
// CTB / Moench Specific // CTB / Moench Specific
int Module::getNumberOfAnalogSamples() { int Module::getNumberOfAnalogSamples() const {
return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES); return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES);
} }
@ -1814,7 +1814,7 @@ void Module::setNumberOfAnalogSamples(int value) {
} }
} }
int Module::getPipeline(int clkIndex) { int Module::getPipeline(int clkIndex) const {
return sendToDetector<int>(F_GET_PIPELINE, clkIndex); return sendToDetector<int>(F_GET_PIPELINE, clkIndex);
} }
@ -1823,7 +1823,7 @@ void Module::setPipeline(int clkIndex, int value) {
sendToDetector(F_SET_PIPELINE, args, nullptr); sendToDetector(F_SET_PIPELINE, args, nullptr);
} }
uint32_t Module::getADCEnableMask() { uint32_t Module::getADCEnableMask() const {
return sendToDetector<uint32_t>(F_GET_ADC_ENABLE_MASK); return sendToDetector<uint32_t>(F_GET_ADC_ENABLE_MASK);
} }
@ -1841,7 +1841,7 @@ void Module::setADCEnableMask(uint32_t mask) {
} }
} }
uint32_t Module::getTenGigaADCEnableMask() { uint32_t Module::getTenGigaADCEnableMask() const {
return sendToDetector<uint32_t>(F_GET_ADC_ENABLE_MASK_10G); return sendToDetector<uint32_t>(F_GET_ADC_ENABLE_MASK_10G);
} }
@ -1861,7 +1861,7 @@ void Module::setTenGigaADCEnableMask(uint32_t mask) {
// CTB Specific // CTB Specific
int Module::getNumberOfDigitalSamples() { int Module::getNumberOfDigitalSamples() const {
return sendToDetector<int>(F_GET_NUM_DIGITAL_SAMPLES); return sendToDetector<int>(F_GET_NUM_DIGITAL_SAMPLES);
} }
@ -1877,7 +1877,7 @@ void Module::setNumberOfDigitalSamples(int value) {
} }
} }
slsDetectorDefs::readoutMode Module::getReadoutMode() { slsDetectorDefs::readoutMode Module::getReadoutMode() const {
auto r = sendToDetector<int>(F_GET_READOUT_MODE); auto r = sendToDetector<int>(F_GET_READOUT_MODE);
return static_cast<readoutMode>(r); return static_cast<readoutMode>(r);
} }
@ -1903,7 +1903,7 @@ int Module::setExternalSamplingSource(int value) {
return sendToDetector<int>(F_EXTERNAL_SAMPLING_SOURCE, value); return sendToDetector<int>(F_EXTERNAL_SAMPLING_SOURCE, value);
} }
bool Module::getExternalSampling() { bool Module::getExternalSampling() const{
int arg = GET_FLAG; int arg = GET_FLAG;
return sendToDetector<int>(F_EXTERNAL_SAMPLING, arg); return sendToDetector<int>(F_EXTERNAL_SAMPLING, arg);
} }
@ -1932,7 +1932,7 @@ void Module::setReceiverDbitList(const std::vector<int> &list) {
sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr); sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr);
} }
int Module::getReceiverDbitOffset() { int Module::getReceiverDbitOffset() const {
return sendToReceiver<int>(F_GET_RECEIVER_DBIT_OFFSET); return sendToReceiver<int>(F_GET_RECEIVER_DBIT_OFFSET);
} }
@ -1945,7 +1945,7 @@ void Module::setDigitalIODelay(uint64_t pinMask, int delay) {
sendToDetector(F_DIGITAL_IO_DELAY, args, nullptr); sendToDetector(F_DIGITAL_IO_DELAY, args, nullptr);
} }
bool Module::getLEDEnable() { bool Module::getLEDEnable() const {
int arg = GET_FLAG; int arg = GET_FLAG;
return static_cast<bool>(sendToDetector<int>(F_LED, arg)); return static_cast<bool>(sendToDetector<int>(F_LED, arg));
} }
@ -2058,7 +2058,7 @@ void Module::setPattern(const std::string &fname) {
0); 0);
} }
uint64_t Module::getPatternIOControl() { uint64_t Module::getPatternIOControl() const {
int64_t arg = GET_FLAG; int64_t arg = GET_FLAG;
return sendToDetector<uint64_t>(F_SET_PATTERN_IO_CONTROL, arg); return sendToDetector<uint64_t>(F_SET_PATTERN_IO_CONTROL, arg);
} }
@ -2067,7 +2067,7 @@ void Module::setPatternIOControl(uint64_t word) {
sendToDetector<uint64_t>(F_SET_PATTERN_IO_CONTROL, word); sendToDetector<uint64_t>(F_SET_PATTERN_IO_CONTROL, word);
} }
uint64_t Module::getPatternWord(int addr) { uint64_t Module::getPatternWord(int addr) const {
uint64_t args[]{static_cast<uint64_t>(addr), uint64_t args[]{static_cast<uint64_t>(addr),
static_cast<uint64_t>(GET_FLAG)}; static_cast<uint64_t>(GET_FLAG)};
return sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args); return sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
@ -2078,7 +2078,7 @@ void Module::setPatternWord(int addr, uint64_t word) {
sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args); sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
} }
std::array<int, 2> Module::getPatternLoopAddresses(int level) { std::array<int, 2> Module::getPatternLoopAddresses(int level) const {
int args[]{level, GET_FLAG, GET_FLAG}; int args[]{level, GET_FLAG, GET_FLAG};
std::array<int, 2> retvals{}; std::array<int, 2> retvals{};
sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals); sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
@ -2091,7 +2091,7 @@ void Module::setPatternLoopAddresses(int level, int start, int stop) {
sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals); sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
} }
int Module::getPatternLoopCycles(int level) { int Module::getPatternLoopCycles(int level) const {
int args[]{level, GET_FLAG}; int args[]{level, GET_FLAG};
return sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args); return sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
} }
@ -2101,7 +2101,7 @@ void Module::setPatternLoopCycles(int level, int n) {
sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args); sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
} }
int Module::getPatternWaitAddr(int level) { int Module::getPatternWaitAddr(int level) const {
int args[]{level, GET_FLAG}; int args[]{level, GET_FLAG};
return sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args); return sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
} }
@ -2111,7 +2111,7 @@ void Module::setPatternWaitAddr(int level, int addr) {
sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args); sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
} }
uint64_t Module::getPatternWaitTime(int level) { uint64_t Module::getPatternWaitTime(int level) const {
uint64_t args[]{static_cast<uint64_t>(level), uint64_t args[]{static_cast<uint64_t>(level),
static_cast<uint64_t>(GET_FLAG)}; static_cast<uint64_t>(GET_FLAG)};
return sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_TIME, args); return sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_TIME, args);
@ -2122,7 +2122,7 @@ void Module::setPatternWaitTime(int level, uint64_t t) {
sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_TIME, args); sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_TIME, args);
} }
uint64_t Module::getPatternMask() { uint64_t Module::getPatternMask() const {
return sendToDetector<uint64_t>(F_GET_PATTERN_MASK); return sendToDetector<uint64_t>(F_GET_PATTERN_MASK);
} }
@ -2130,7 +2130,7 @@ void Module::setPatternMask(uint64_t mask) {
sendToDetector(F_SET_PATTERN_MASK, mask, nullptr); sendToDetector(F_SET_PATTERN_MASK, mask, nullptr);
} }
uint64_t Module::getPatternBitMask() { uint64_t Module::getPatternBitMask() const {
return sendToDetector<uint64_t>(F_GET_PATTERN_BIT_MASK); return sendToDetector<uint64_t>(F_GET_PATTERN_BIT_MASK);
} }
@ -2275,7 +2275,7 @@ void Module::rebootController() {
LOG(logINFO) << "Controller rebooted successfully!"; LOG(logINFO) << "Controller rebooted successfully!";
} }
uint32_t Module::readRegister(uint32_t addr) { uint32_t Module::readRegister(uint32_t addr) const {
return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr); return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr);
} }
@ -2311,7 +2311,7 @@ void Module::writeAdcRegister(uint32_t addr, uint32_t val) {
sendToDetector(F_WRITE_ADC_REG, args, nullptr); sendToDetector(F_WRITE_ADC_REG, args, nullptr);
} }
uint32_t Module::getADCInvert() { uint32_t Module::getADCInvert() const {
return sendToDetector<uint32_t>(F_GET_ADC_INVERT); return sendToDetector<uint32_t>(F_GET_ADC_INVERT);
} }
@ -2347,7 +2347,7 @@ int Module::setStopPort(int port_number) {
return shm()->stopPort; return shm()->stopPort;
} }
bool Module::getLockDetector() { bool Module::getLockDetector() const {
int arg = GET_FLAG; int arg = GET_FLAG;
return static_cast<bool>(sendToDetector<int>(F_LOCK_SERVER, arg)); return static_cast<bool>(sendToDetector<int>(F_LOCK_SERVER, arg));
} }
@ -2356,7 +2356,7 @@ void Module::setLockDetector(bool lock) {
sendToDetector<int>(F_LOCK_SERVER, static_cast<int>(lock)); sendToDetector<int>(F_LOCK_SERVER, static_cast<int>(lock));
} }
sls::IpAddr Module::getLastClientIP() { sls::IpAddr Module::getLastClientIP() const {
return sendToDetector<sls::IpAddr>(F_GET_LAST_CLIENT_IP); return sendToDetector<sls::IpAddr>(F_GET_LAST_CLIENT_IP);
} }

92
slsDetectorSoftware/src/Module.h
View File

@ -335,19 +335,19 @@ class Module : public virtual slsDetectorDefs {
* Jungfrau Specific * * Jungfrau Specific *
* * * *
* ************************************************/ * ************************************************/
int getThresholdTemperature(); int getThresholdTemperature() const;
void setThresholdTemperature(int val); void setThresholdTemperature(int val);
bool getTemperatureControl(); bool getTemperatureControl() const;
void setTemperatureControl(bool val); void setTemperatureControl(bool val);
int getTemperatureEvent(); int getTemperatureEvent() const;
void resetTemperatureEvent(); void resetTemperatureEvent();
bool getAutoComparatorDisableMode(); bool getAutoComparatorDisableMode() const;
void setAutoComparatorDisableMode(bool val); void setAutoComparatorDisableMode(bool val);
int getNumberOfAdditionalStorageCells(); int getNumberOfAdditionalStorageCells() const;
void setNumberOfAdditionalStorageCells(int value); void setNumberOfAdditionalStorageCells(int value);
int getStorageCellStart(); int getStorageCellStart() const;
void setStorageCellStart(int pos); void setStorageCellStart(int pos);
int64_t getStorageCellDelay(); int64_t getStorageCellDelay() const;
void setStorageCellDelay(int64_t value); void setStorageCellDelay(int64_t value);
/************************************************** /**************************************************
@ -355,7 +355,7 @@ class Module : public virtual slsDetectorDefs {
* Gotthard Specific * * Gotthard Specific *
* * * *
* ************************************************/ * ************************************************/
slsDetectorDefs::ROI getROI(); slsDetectorDefs::ROI getROI() const;
void setROI(slsDetectorDefs::ROI arg); void setROI(slsDetectorDefs::ROI arg);
void clearROI(); void clearROI();
int64_t getExptimeLeft() const; int64_t getExptimeLeft() const;
@ -365,33 +365,33 @@ class Module : public virtual slsDetectorDefs {
* Gotthard2 Specific * * Gotthard2 Specific *
* * * *
* ************************************************/ * ************************************************/
int64_t getNumberOfBursts(); int64_t getNumberOfBursts() const;
void setNumberOfBursts(int64_t value); void setNumberOfBursts(int64_t value);
int64_t getBurstPeriod(); int64_t getBurstPeriod() const;
void setBurstPeriod(int64_t value); void setBurstPeriod(int64_t value);
std::array<int, 2> getInjectChannel(); std::array<int, 2> getInjectChannel() const;
void setInjectChannel(const int offsetChannel, const int incrementChannel); void setInjectChannel(const int offsetChannel, const int incrementChannel);
std::vector<int> getVetoPhoton(const int chipIndex); std::vector<int> getVetoPhoton(const int chipIndex) const;
void setVetoPhoton(const int chipIndex, const int numPhotons, void setVetoPhoton(const int chipIndex, const int numPhotons,
const int energy, const std::string &fname); const int energy, const std::string &fname);
void setVetoReference(const int gainIndex, const int value); void setVetoReference(const int gainIndex, const int value);
void setVetoFile(const int chipIndex, const std::string &fname); void setVetoFile(const int chipIndex, const std::string &fname);
burstMode getBurstMode(); burstMode getBurstMode() const;
void setBurstMode(burstMode value); void setBurstMode(burstMode value);
bool getCDSGain(); bool getCDSGain() const;
void setCDSGain(bool value); void setCDSGain(bool value);
int getFilter(); int getFilter() const;
void setFilter(int value); void setFilter(int value);
bool getCurrentSource(); bool getCurrentSource() const;
void setCurrentSource(bool value); void setCurrentSource(bool value);
slsDetectorDefs::timingSourceType getTimingSource(); slsDetectorDefs::timingSourceType getTimingSource() const;
void setTimingSource(slsDetectorDefs::timingSourceType value); void setTimingSource(slsDetectorDefs::timingSourceType value);
bool getVeto(); bool getVeto() const;
void setVeto(bool enable); void setVeto(bool enable);
int getADCConfiguration(const int chipIndex, const int adcIndex); int getADCConfiguration(const int chipIndex, const int adcIndex) const;
void setADCConfiguration(const int chipIndex, const int adcIndex, void setADCConfiguration(const int chipIndex, const int adcIndex,
int value); int value);
void getBadChannels(const std::string &fname); void getBadChannels(const std::string &fname) const;
void setBadChannels(const std::string &fname); void setBadChannels(const std::string &fname);
/************************************************** /**************************************************
@ -399,27 +399,27 @@ class Module : public virtual slsDetectorDefs {
* Mythen3 Specific * * Mythen3 Specific *
* * * *
* ************************************************/ * ************************************************/
uint32_t getCounterMask(); uint32_t getCounterMask() const;
void setCounterMask(uint32_t countermask); void setCounterMask(uint32_t countermask);
int getNumberOfGates(); int getNumberOfGates() const;
void setNumberOfGates(int value); void setNumberOfGates(int value);
std::array<time::ns, 3> getExptimeForAllGates(); std::array<time::ns, 3> getExptimeForAllGates() const;
int64_t getGateDelay(int gateIndex); int64_t getGateDelay(int gateIndex) const;
void setGateDelay(int gateIndex, int64_t value); void setGateDelay(int gateIndex, int64_t value);
std::array<time::ns, 3> getGateDelayForAllGates(); std::array<time::ns, 3> getGateDelayForAllGates() const;
/************************************************** /**************************************************
* * * *
* CTB / Moench Specific * * CTB / Moench Specific *
* * * *
* ************************************************/ * ************************************************/
int getNumberOfAnalogSamples(); int getNumberOfAnalogSamples() const;
void setNumberOfAnalogSamples(int value); void setNumberOfAnalogSamples(int value);
int getPipeline(int clkIndex); int getPipeline(int clkIndex) const;
void setPipeline(int clkIndex, int value); void setPipeline(int clkIndex, int value);
uint32_t getADCEnableMask(); uint32_t getADCEnableMask() const;
void setADCEnableMask(uint32_t mask); void setADCEnableMask(uint32_t mask);
uint32_t getTenGigaADCEnableMask(); uint32_t getTenGigaADCEnableMask() const;
void setTenGigaADCEnableMask(uint32_t mask); void setTenGigaADCEnableMask(uint32_t mask);
/************************************************** /**************************************************
@ -427,20 +427,20 @@ class Module : public virtual slsDetectorDefs {
* CTB Specific * * CTB Specific *
* * * *
* ************************************************/ * ************************************************/
int getNumberOfDigitalSamples(); int getNumberOfDigitalSamples() const;
void setNumberOfDigitalSamples(int value); void setNumberOfDigitalSamples(int value);
readoutMode getReadoutMode(); readoutMode getReadoutMode() const;
void setReadoutMode(const readoutMode mode); void setReadoutMode(const readoutMode mode);
int getExternalSamplingSource(); int getExternalSamplingSource();
int setExternalSamplingSource(int value); int setExternalSamplingSource(int value);
bool getExternalSampling(); bool getExternalSampling() const;
void setExternalSampling(bool value); void setExternalSampling(bool value);
std::vector<int> getReceiverDbitList() const; std::vector<int> getReceiverDbitList() const;
void setReceiverDbitList(const std::vector<int> &list); void setReceiverDbitList(const std::vector<int> &list);
int getReceiverDbitOffset(); int getReceiverDbitOffset() const;
void setReceiverDbitOffset(int value); void setReceiverDbitOffset(int value);
void setDigitalIODelay(uint64_t pinMask, int delay); void setDigitalIODelay(uint64_t pinMask, int delay);
bool getLEDEnable(); bool getLEDEnable() const;
void setLEDEnable(bool enable); void setLEDEnable(bool enable);
/************************************************** /**************************************************
@ -449,21 +449,21 @@ class Module : public virtual slsDetectorDefs {
* * * *
* ************************************************/ * ************************************************/
void setPattern(const std::string &fname); void setPattern(const std::string &fname);
uint64_t getPatternIOControl(); uint64_t getPatternIOControl() const;
void setPatternIOControl(uint64_t word); void setPatternIOControl(uint64_t word);
uint64_t getPatternWord(int addr); uint64_t getPatternWord(int addr) const;
void setPatternWord(int addr, uint64_t word); void setPatternWord(int addr, uint64_t word);
std::array<int, 2> getPatternLoopAddresses(int level); std::array<int, 2> getPatternLoopAddresses(int level) const;
void setPatternLoopAddresses(int level, int start, int stop); void setPatternLoopAddresses(int level, int start, int stop);
int getPatternLoopCycles(int level); int getPatternLoopCycles(int level) const;
void setPatternLoopCycles(int level, int n); void setPatternLoopCycles(int level, int n);
int getPatternWaitAddr(int level); int getPatternWaitAddr(int level) const;
void setPatternWaitAddr(int level, int addr); void setPatternWaitAddr(int level, int addr);
uint64_t getPatternWaitTime(int level); uint64_t getPatternWaitTime(int level) const;
void setPatternWaitTime(int level, uint64_t t); void setPatternWaitTime(int level, uint64_t t);
uint64_t getPatternMask(); uint64_t getPatternMask() const;
void setPatternMask(uint64_t mask); void setPatternMask(uint64_t mask);
uint64_t getPatternBitMask(); uint64_t getPatternBitMask() const;
void setPatternBitMask(uint64_t mask); void setPatternBitMask(uint64_t mask);
void startPattern(); void startPattern();
@ -489,14 +489,14 @@ class Module : public virtual slsDetectorDefs {
void copyDetectorServer(const std::string &fname, void copyDetectorServer(const std::string &fname,
const std::string &hostname); const std::string &hostname);
void rebootController(); void rebootController();
uint32_t readRegister(uint32_t addr); uint32_t readRegister(uint32_t addr) const;
uint32_t writeRegister(uint32_t addr, uint32_t val); uint32_t writeRegister(uint32_t addr, uint32_t val);
uint32_t setBit(uint32_t addr, int n); uint32_t setBit(uint32_t addr, int n);
uint32_t clearBit(uint32_t addr, int n); uint32_t clearBit(uint32_t addr, int n);
void executeFirmwareTest(); void executeFirmwareTest();
void executeBusTest(); void executeBusTest();
void writeAdcRegister(uint32_t addr, uint32_t val); void writeAdcRegister(uint32_t addr, uint32_t val);
uint32_t getADCInvert(); uint32_t getADCInvert() const;
void setADCInvert(uint32_t value); void setADCInvert(uint32_t value);
/************************************************** /**************************************************
@ -508,9 +508,9 @@ class Module : public virtual slsDetectorDefs {
int setControlPort(int port_number); int setControlPort(int port_number);
int getStopPort() const; int getStopPort() const;
int setStopPort(int port_number); int setStopPort(int port_number);
bool getLockDetector(); bool getLockDetector() const;
void setLockDetector(bool lock); void setLockDetector(bool lock);
sls::IpAddr getLastClientIP(); sls::IpAddr getLastClientIP() const;
std::string execCommand(const std::string &cmd); std::string execCommand(const std::string &cmd);
int64_t getNumberOfFramesFromStart() const; int64_t getNumberOfFramesFromStart() const;
int64_t getActualTime() const; int64_t getActualTime() const;