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

WIP

Browse Source
This commit is contained in:
maliakal_d 2019-08-12 18:57:53 +02:00
parent 99dc9bd44d
commit 25eccdffab
8 changed files with 649 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
slsDetectorGui/src/qTabAdvanced.cpp
View File

@ -332,7 +332,7 @@ void qTabAdvanced::SetDetector(int index) {
GetRxrZMQPort();
GetRxrZMQIP();
myDet->printReceiverConfiguration(logDEBUG);
FILE_LOG(logDEBUG) << myDet->printReceiverConfiguration();
}
void qTabAdvanced::SetControlPort(int port) {

518
slsDetectorSoftware/include/Detector.h
View File

@ -24,33 +24,12 @@ class Detector {
Detector(int multi_id = 0);
~Detector();
// Acquisition
/**
* Blocking call, starts the receiver and detector. Acquired
* the number of frames set.
*/
void acquire();
void startReceiver(Positions pos = {});
void stopReceiver(Positions pos = {});
/**
* Get the acquiring flag. When true the detector blocks
* any attempt to start a new acquisition.
*/
bool getAcquiringFlag() const;
/**
* Set the acquiring flag. This might have to done manually
* after an acquisition was aborted.
*/
void setAcquiringFlag(bool value);
/** Read back the run status of the receiver */
Result<defs::runStatus> getReceiverStatus(Positions pos = {});
// Configuration
/**************************************************
* *
* CONFIG *
* *
* ************************************************/
/**
* Frees the shared memory of this detector and all modules
* belonging to it.
@ -58,45 +37,13 @@ class Detector {
void freeSharedMemory();
void setConfig(const std::string &fname);
Result<std::string> getHostname(Positions pos = {}) const;
// void setHostname(Positions pos = {});
Result<uint64_t> getStartingFrameNumber(Positions pos = {}) const;
void setStartingFrameNumber(uint64_t value, Positions pos);
// Bits and registers
/**************************************************
* *
* FILE, anything concerning file writing or *
* reading goes here *
* *
* ************************************************/
/**
* Returns receiver file name prefix. The actual file name
* contains module id and file index as well.
* @param pos detector positions
* @returns file name prefix
* Frees shared memory and adds detectors to the list
* Also updates local detector cache
* @param name hostnames for the positions given
*/
Result<std::string> getFileName(Positions pos = {}) const;
void setHostname(const std::vector<std::string> &value);
/**
* Sets the receiver file name prefix
* @param fname file name prefix
*/
void setFileName(const std::string &fname, Positions pos = {});
Result<std::string> getFilePath(Positions pos = {}) const;
void setFilePath(const std::string &fname, Positions pos = {});
Result<bool> getFileWrite(Positions pos = {}) const;
void setFileWrite(bool value, Positions pos = {});
Result<bool> getFileOverWrite(Positions pos = {}) const;
void setFileOverWrite(bool value, Positions pos = {});
// dhanya
/**
* Get multidetector Id
* @returns multidetector Id
@ -155,13 +102,6 @@ class Detector {
*/
std::string getUserDetails() const;
/**
* Frees shared memory and adds detectors to the list
* Also updates local detector cache
* @param name hostnames for the positions given
*/
void setHostname(const std::vector<std::string> &value);
/**
* Get Detector type as an enum
* @returns detector type
@ -505,6 +445,15 @@ class Detector {
*/
void setNumberOfStorageCells(int64_t value);
/** [Jungfrau] */
Result<int> getStorageCellStart(Positions pos = {}) const;
/**
* [Jungfrau] Sets the storage cell storing the first acquisition of the series
* Options: 0-15
*/
void setStoragecellStart(int cell, Positions pos = {});
/**
* Get number of analog samples (CTB)
* @param pos detector position
@ -1235,6 +1184,191 @@ class Detector {
/** [Eiger] Pulse chip n times */
void pulseChip(int n, Positions pos = {});
/** [Jungfrau] */
Result<int> getThresholdTemperature(Positions pos = {}) const;
/**
* [Jungfrau]Set threshold temperature
* If temperature crosses threshold temperature
* and temperature control is enabled,
* power to chip will be switched off and
* temperature event will be set
* @param val value in millidegrees TODO! Verify
*/
void setThresholdTemperature(int temp, Positions pos = {});
/** [Jungfrau] */
Result<bool> getTemperatureControl(Positions pos = {}) const;
/** [Jungfrau] */
void setTemperatureControl(bool enable, Positions pos = {});
/** [Jungfrau] */
Result<int> getTemperatureEvent(Positions pos = {}) const;
/** [Jungfrau] */
void ResetTemperatureEvent(Positions pos = {});
/** [Jungfrau][CTB] */
void programFPGA(const std::string &fname, Positions pos = {});
/** [Jungfrau][CTB] */
void resetFPGA(Positions pos = {});
/**
* Copy detector server fname from tftp folder of hostname to detector
* Also changes respawn server, which is effective after a reboot.
*/
void copyDetectorServer(const std::string &fname,
const std::string &hostname, Positions pos = {});
/** [Jungfrau][Gotthard][CTB] */
void rebootController(Positions pos = {});
/**
* [Jungfrau][Gotthard][CTB]
* Updates the firmware, detector server and then reboots detector
* controller blackfin.
* @param sname name of detector server binary found on tftp folder of host pc
* @param hostname name of pc to tftp from
* @param fname programming file name
* @param pos detector positions
*/
void updateFirmwareAndServer(const std::string &sname,
const std::string &hostname,
const std::string &fname, Positions pos = {});
/** [Jungfrau] */
Result<bool> getPowerChip(Positions pos = {}) const;
/** [Jungfrau] */
void setPowerChip(bool on, Positions pos = {});
/** [Jungfrau] */
Result<bool> getAutoCompDisable(Positions pos = {}) const;
/** [Jungfrau] TODO??? fix docs ? */
void setAutoCompDisable(bool value, Positions pos = {});
/** [Eiger]
* @returns deadtime in ns, 0 = disabled
*/
Result<int64_t> getRateCorrection(Positions pos = {}) const;
/**
* [Eiger] Set Rate correction
* 0 disable correction, <0 set to default, >0 deadtime in ns
*/
void setRateCorrection(int64_t dead_time_ns, Positions pos = {});
/** [Eiger][Jungfrau] */
Result<uint64_t> getStartingFrameNumber(Positions pos = {}) const;
/** [Eiger][Jungfrau] */
void setStartingFrameNumber(uint64_t value, Positions pos);
/** [Eiger] */
Result<bool> getTenGigaEnabled(Positions pos = {}) const;
/** [Eiger] */
void setTenGigaEnabled(bool value, Positions pos = {});
/** [CTB] */
Result<bool> getLEDEnable(Positions pos = {}) const;
/** [CTB] */
void setLEDEnable(bool enable, Positions pos = {});
/**
* [CTB] Set Digital IO Delay
* cannot get
* @param digital IO mask to select the pins
* @param delay delay in ps(1 bit=25ps, max of 775 ps)
*/
void setDigitalIODelay(uint64_t pinMask, int delay, Positions pos = {});
/**************************************************
* *
* FILE, anything concerning file writing or *
* reading goes here *
* *
* ************************************************/
Result<defs::fileFormat> getFileFormat(Positions pos = {}) const;
/** default binary, Options: BINARY, HDF5 (library must be compiled with this option) */
void setFileFormat(defs::fileFormat f, Positions pos = {});
Result<std::string> getFilePath(Positions pos = {}) const;
void setFilePath(const std::string &fname, Positions pos = {});
Result<std::string> getFileNamePrefix(Positions pos = {}) const;
/** default run */
void setFileNamePrefix(const std::string &fname, Positions pos = {});
Result<int> getFileIndex(Positions pos = {}) const;
void setFileIndex(int i, Positions pos = {});
Result<bool> getFileWrite(Positions pos = {}) const;
/** default writes */
void setFileWrite(bool value, Positions pos = {});
Result<bool> getMasterFileWrite(Positions pos = {}) const;
void setMasterFileWrite(bool value, Positions pos = {});
Result<bool> getFileOverWrite(Positions pos = {}) const;
/** default overwites */
void setFileOverWrite(bool value, Positions pos = {});
Result<int> getFramesPerFile(Positions pos = {}) const;
void setFramesPerFile(int n, Positions pos = {});
/**************************************************
* *
* RECEIVER CONFIG *
* *
* ************************************************/
/** true when slsReceiver is used */
Result<bool> getUseReceiverFlag(Positions pos = {}) const;
Result<std::string> printReceiverConfiguration(Positions pos = {}) const;
Result<bool> getReceiverLock(Positions pos = {});
/** locks receiver server to client IP */
void setReceiverLock(bool value, Positions pos = {});
Result<std::string> getReceiverLastClientIP(Positions pos = {}) const;
void exitReceiver(Positions pos = {});
void execReceiverCommand(const std::string &cmd, Positions pos = {});
Result<int> getReceiverStreamingFrequency(Positions pos = {}) const;
/** @param freq nth frame streamed out of receiver.
* If 0, streaming timer is the timeout,
* after which current frame sent out. Default is 0 at 200 ms.
* For every frame, set freq to 1.
*/
void setReceiverStreamingFrequency(int freq, Positions pos = {});
Result<int> getReceiverStreamingTimer(Positions pos = {}) const;
/**
* If receiver streaming frequency is 0 (default), then this timer between each
* data stream is set. Default is 200 ms.
*/
void setReceiverStreamingTimer(int time_in_ms, Positions pos = {});
bool getDataStreamingToClient() const;
void setDataStreamingToClient(bool value);
Result<bool> getDataStreamingFromReceiver(Positions pos = {}) const;
void setDataStreamingFromReceiver(bool value, Positions pos = {});
Result<int> getReceiverFifoDepth(Positions pos = {}) const;
void setReceiverFifoDepth(int nframes, Positions pos = {});
Result<bool> getReceiverSilentMode(Positions pos = {}) const;
void setReceiverSilentMode(bool value, Positions pos = {});
Result<defs::frameDiscardPolicy>
getReceiverFrameDiscardPolicy(Positions pos = {}) const;
/**
* default NO_DISCARD
* Options: NO_DISCARD, DISCARD_EMPTY_FRAMES, DISCARD_PARTIAL_FRAMES
*/
void setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
Positions pos = {});
Result<bool> getPartialFramesPadding(Positions pos = {}) const;
/** padding enabled */
void setPartialFramesPadding(bool value, Positions pos = {});
/** [Eiger] */
Result<bool> getRxPadDeactivatedMod(Positions pos = {}) const;
@ -1252,271 +1386,147 @@ class Detector {
Result<int64_t>
getReceiverRealUDPSocketBufferSize(Positions pos = {}) const;
/**************************************************
* *
* ACQUISITION *
* *
* ************************************************/
/**
* Blocking call, starts the receiver and detector.
* Increments file index if file write enabled.
* Acquired the number of frames set.
*/
void acquire();
/**
* Get the acquiring flag. When true the detector blocks
* any attempt to start a new acquisition.
*/
bool getAcquiringFlag() const;
/**
* Set the acquiring flag. This might have to done manually
* after an acquisition was aborted.
*/
void setAcquiringFlag(bool value);
/** Receiver starts listening to UDP packets from detector */
void startReceiver(Positions pos = {});
/** Receiver stops listening to UDP packets from detector */
void stopReceiver(Positions pos = {});
/** Read back the run status of the receiver */
Result<defs::runStatus> getReceiverStatus(Positions pos = {});
Result<int> getFramesCaughtByReceiver(Positions pos = {}) const;
Result<uint64_t> getReceiverCurrentFrameIndex(Positions pos = {}) const;
void resetFramesCaught(Positions pos = {});
// TODO!
// int createReceivingDataSockets(const bool destroy = false);
// void readFrameFromReceiver();
void setMasterFileWrite(bool value, Positions pos = {});
Result<bool> getMasterFileWrite(Positions pos = {}) const;
void setReceiverStreamingFrequency(int freq = -1, int detPos = -1);
/**
* [All] If receiver streaming frequency is 0, then this timer between each
* data stream is set. Default is 500 ms.
*/
void setReceiverStreamingTimer(int time_in_ms = 500, Positions pos = {});
/** [All] */
Result<int> getReceiverStreamingTimer(Positions pos = {}) const;
bool getDataStreamingToClient() const;
void setDataStreamingToClient(bool value);
Result<bool> getDataStreamingFromReceiver(Positions pos = {}) const;
void setDataStreamingFromReceiver(bool value, Positions pos = {});
/** [TODO! All?] */
void setTenGigaEnabled(bool value, Positions pos = {});
/** [TODO! All?] */
Result<bool> getTenGigaEnabled(Positions pos = {}) const;
/** [All] */
void setReceiverFifoDepth(int nframes, Positions pos = {});
/** [All] */
Result<int> getReceiverFifoDepth(Positions pos = {}) const;
/** [All] */
void setReceiverSilentMode(bool value, Positions pos = {});
/** [All] */
Result<bool> getReceiverSilentMode(Positions pos = {}) const;
/**************************************************
* *
* PATTERN *
* *
* ************************************************/
/** [CTB] */
void setPattern(const std::string &fname, Positions pos = {});
/** [CTB] */
void setPatternIOControl(uint64_t word, Positions pos = {});
/** [CTB] */
Result<uint64_t> getPatternIOControl(Positions pos = {}) const;
/** [CTB] */
void setPatternClockControl(uint64_t word, Positions pos = {});
void setPatternIOControl(uint64_t word, Positions pos = {});
/** [CTB] */
Result<uint64_t> getPatternClockControl(Positions pos = {}) const;
/** [CTB] */
void setPatternClockControl(uint64_t word, Positions pos = {});
/**
* [CTB] Writes a pattern word
* @param addr address of the word
* @param word word to be written, -1 reads the addr (same as
* [CTB]
* Caution: If word is -1 reads the addr (same as
* executing the pattern)
* @param pos detector position
* @returns actual value
*/
void setPatternWord(int addr, uint64_t word, Positions pos = {});
// TODO! Does this have side effects?
// uint64_t getPatternWord()...
/**
* [CTB] Sets the pattern or loop limits.
* @param level -1 complete pattern, 0,1,2, loop level
* @param start start address for level 0-2
* @param stop stop address for level 0-2
* @param n number of loops for level 0-2
* @param pos detector position
*/
void setPatternLoops(int level, int start, int stop, int n,
Positions pos = {});
/**
* [CTB] Gets the pattern loop limits
* @param level -1 complete pattern, 0,1,2, loop level
* @param pos detector positions
* [CTB]
* Options: level: -1 (complete pattern) and 0-2 levels
* @returns array of start address, stop address and number of loops
*/
Result<std::array<int, 3>> getPatternLoops(int level,
Positions pos = {}) const;
/**
* [CTB] Sets the wait address
* @param level 0,1,2, wait level
* @param addr wait address
* @param pos detector position
* @returns actual value
* [CTB]
* Options: start, stop, n : 0-2
* level: -1 (complete pattern) and 0-2 levels
*/
void setPatternWaitAddr(int level, int addr, Positions pos = {});
void setPatternLoops(int level, int start, int stop, int n,
Positions pos = {});
/* [CTB] */
Result<int> getPatternWaitAddr(int level, Positions pos = {}) const;
/**
* [CTB] Sets the wait time
* @param level 0,1,2, wait level
* @param t wait time
* @param pos detector position
* [CTB]
* Options: level 0-2
*/
void setPatternWaitTime(int level, uint64_t t, Positions pos = {});
void setPatternWaitAddr(int level, int addr, Positions pos = {});
/** [CTB] */
Result<uint64_t> getPatternWaitTime(int level, Positions pos = {}) const;
/** [CTB] Sets the mask applied to every pattern. */
/**
* [CTB]
* Options: level 0-2
*/
void setPatternWaitTime(int level, uint64_t t, Positions pos = {});
/** [CTB] */
Result<uint64_t> getPatternMask(Positions pos = {});
/** [CTB] Sets the mask applied to every pattern to the selected bit mask */
void setPatternMask(uint64_t mask, Positions pos = {});
/** [CTB] Gets the mask applied to every pattern. */
Result<uint64_t> getPatternMask(Positions pos = {});
/** [CTB] */
Result<uint64_t> getPatternBitMask(Positions pos = {}) const;
/**
* [CTB] Sets the bitmask that the mask will be applied to for every
* pattern.
* @param mask mask to select bits
* pattern
*/
void setPatternBitMask(uint64_t mask, Positions pos = {});
/**
* [CTB] Gets the bits that the mask will be applied to for every
* pattern
*/
Result<uint64_t> getPatternBitMask(Positions pos = {}) const;
/** [CTB] Enable or disable the LED */
void setLEDEnable(bool enable, Positions pos = {});
/** [CTB] Get LED enable. */
Result<bool> getLEDEnable(Positions pos = {}) const;
/**
* [CTB] Set Digital IO Delay
* @param digital IO mask to select the pins
* @param delay delay in ps(1 bit=25ps, max of 775 ps)
*/
void setDigitalIODelay(uint64_t pinMask, int delay, Positions pos = {});
Result<int> getFileIndex(Positions pos = {}) const;
void setFileIndex(int i, Positions pos = {});
Result<defs::fileFormat> getFileFormat(Positions pos = {}) const;
void setFileFormat(defs::fileFormat f, Positions pos = {});
Result<bool> getPartialFramesPadding(Positions pos = {}) const;
void setPartialFramesPadding(bool value, Positions pos = {});
void setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
Positions pos = {});
Result<defs::frameDiscardPolicy>
getReceiverFrameDiscardPolicy(Positions pos = {}) const;
void setFramesPerFile(int n, Positions pos = {});
Result<int> getFramesPerFile(Positions pos = {}) const;
// void execReceiverCommand(const std::string &cmd, int detPos = -1);
// void exitReceiver(int detPos = -1);
Result<std::string> getReceiverLastClientIP(Positions pos = {}) const;
void setReceiverLock(bool value, Positions pos = {});
Result<bool> getReceiverLock(Positions pos = {});
/** true when receiver is used otherwise false */
Result<bool> getUseReceiverFlag(Positions pos = {}) const;
void printReceiverConfiguration(Positions pos = {}) const;
/** [Eiger]
* @returns deadtime in ns, 0 = disabled
*/
Result<int64_t> getRateCorrection(Positions pos = {}) const;
/**
* [Eiger] Set Rate correction
* 0 disable correction, <0 set to default, >0 deadtime in ns
*/
void setRateCorrection(int64_t dead_time_ns, Positions pos = {});
/** [Jungfrau] TODO??? fix docs */
void setAutoCompDisable(bool value, Positions pos = {});
Result<bool> getAutoCompDisable(Positions pos = {}) const;
void setPowerChip(bool on, Positions pos = {});
Result<bool> getPowerChip(Positions pos = {}) const;
/**
* Updates the firmware, detector server and then reboots detector
* controller blackfin. (Not Eiger)
* @param sname name of detector server binary
* @param hostname name of pc to tftp from
* @param fname programming file name
* @param pos detector positions
*/
void updateFirmwareAndServer(const std::string &sname,
const std::string &hostname,
const std::string &fname, Positions pos = {});
/** [not Eiger] TODO! is this needed?*/
void rebootController(Positions pos = {});
/** Copy detector server to detector */
void copyDetectorServer(const std::string &fname,
const std::string &hostname, Positions pos = {});
/** [not Eiger] */
void resetFPGA(Positions pos = {});
/** [not Eiger] */
void programFPGA(const std::string &fname, Positions pos = {});
/**
* [Jungfrau] Set first storage cell of the series (Jungfrau)
* @param value storage cell index. Value can be 0 to 15.
*/
void setStoragecellStart(int cell, Positions pos = {});
Result<int> getStorageCellStart(Positions pos = {}) const;
/** [Jungfrau] 1 there was an temperature event */
void setTemperatureEvent(int val, Positions pos = {});
/** [Jungfrau] */
Result<int> getTemperatureEvent(Positions pos = {}) const;
/** [Jungfrau] */
void setTemperatureControl(bool enable, Positions pos = {});
/** [Jungfrau] */
Result<bool> getTemperatureControl(Positions pos = {}) const;
/**
* [Jungfrau]Set threshold temperature
* @param val value in millidegrees TODO! Verify
*/
void setThresholdTemperature(int temp, Positions pos = {});
Result<int> getThresholdTemperature(Positions pos = {}) const;

52
slsDetectorSoftware/include/multiSlsDetector.h
View File

@ -1638,14 +1638,14 @@ class multiSlsDetector : public virtual slsDetectorDefs {
int setStoragecellStart(int pos = -1, int detPos = -1);//
/**
* Programs FPGA with pof file (Not Eiger)
* Programs FPGA with pof file (Jungfrau, CTB, Moench)
* @param fname file name
* @param detPos -1 for all detectors in list or specific detector position
*/
void programFPGA(const std::string &fname, int detPos = -1); //
/**
* Resets FPGA (Not Eiger)
* Resets FPGA (Jungfrau, CTB, Moench)
* @param detPos -1 for all detectors in list or specific detector position
*/
void resetFPGA(int detPos = -1); //
@ -1710,10 +1710,10 @@ class multiSlsDetector : public virtual slsDetectorDefs {
/**
* Prints receiver configuration
* @param level print level
* @param detPos -1 for all detectors in list or specific detector position
* @returns receiver configuration
*/
void printReceiverConfiguration(TLogLevel level = logINFO, int detPos = -1); //
std::string printReceiverConfiguration(int detPos = -1); //
/**
* Get receiver online status
@ -1886,19 +1886,6 @@ class multiSlsDetector : public virtual slsDetectorDefs {
*/
void resetFramesCaught(int detPos = -1); //
/**
* Create Receiving Data Sockets
* @param destroy is true to destroy all the sockets
* @returns OK or FAIL
*/
int createReceivingDataSockets(const bool destroy = false);
/**
* Reads frames from receiver through a constant socket
* Called during acquire() when call back registered or when using gui
*/
void readFrameFromReceiver();
/**
* Sets/Gets receiver file write enable
* @param value 1 or 0 to set/reset file write enable
@ -1962,7 +1949,7 @@ class multiSlsDetector : public virtual slsDetectorDefs {
* @param detPos -1 for all detectors in list or specific detector position
* @returns receiver streaming timer in ms
*/
int setReceiverStreamingTimer(int time_in_ms = 500, int detPos = -1); //
int setReceiverStreamingTimer(int time_in_ms = 200, int detPos = -1); //
/**
* Enable data streaming to client
@ -2007,9 +1994,8 @@ class multiSlsDetector : public virtual slsDetectorDefs {
* Opens pattern file and sends pattern (CTB/ Moench)
* @param fname pattern file to open
* @param detPos -1 for all detectors in list or specific detector position
* @returns OK/FAIL
*/
int setPattern(const std::string &fname, int detPos = -1); //
void setPattern(const std::string &fname, int detPos = -1); //
/**
* Sets pattern IO control (CTB/ Moench)
@ -2192,12 +2178,6 @@ class multiSlsDetector : public virtual slsDetectorDefs {
std::vector<char> readPofFile(const std::string &fname);
private:
/**
* increments file index
* @param detPos -1 for all detectors in list or specific detector position
* @returns the file index
*/
int incrementFileIndex(int detPos = -1);
/**
* Creates/open shared memory, initializes detector structure and members
* Called by constructor/ set hostname / read config file
@ -2276,6 +2256,13 @@ class multiSlsDetector : public virtual slsDetectorDefs {
*/
void addSlsDetector(const std::string &hostname);
/**
* increments file index
* @param detPos -1 for all detectors in list or specific detector position
* @returns the file index
*/
int incrementFileIndex(int detPos = -1);
/**
* Ensures that min is less than max in both dimensions (Gotthard)
* @param n number of rois
@ -2292,6 +2279,19 @@ class multiSlsDetector : public virtual slsDetectorDefs {
*/
int processImageWithGapPixels(char *image, char *&gpImage);
/**
* Create Receiving Data Sockets
* @param destroy is true to destroy all the sockets
* @returns OK or FAIL
*/
int createReceivingDataSockets(const bool destroy = false);
/**
* Reads frames from receiver through a constant socket
* Called during acquire() when call back registered or when using gui
*/
void readFrameFromReceiver();
/**
* Set total progress (total number of frames/images in an acquisition)
* @returns total progress

9
slsDetectorSoftware/include/slsDetector.h
View File

@ -1461,9 +1461,9 @@ class slsDetector : public virtual slsDetectorDefs {
/**
* Prints receiver configuration
* @param level print level
* @returns receiver configuration
*/
void printReceiverConfiguration(TLogLevel level = logINFO);
std::string printReceiverConfiguration();
/**
* Gets the use receiver flag from shared memory
@ -1693,7 +1693,7 @@ class slsDetector : public virtual slsDetectorDefs {
* @param time_in_ms timer between frames
* @returns receiver streaming timer in ms
*/
int setReceiverStreamingTimer(int time_in_ms = 500);
int setReceiverStreamingTimer(int time_in_ms = 200);
/**
* Enable or disable streaming data from receiver to client
@ -1734,9 +1734,8 @@ class slsDetector : public virtual slsDetectorDefs {
/**
* Opens pattern file and sends pattern to CTB
* @param fname pattern file to open
* @returns OK/FAIL
*/
int setPattern(const std::string &fname);
void setPattern(const std::string &fname);
/**
* Sets pattern IO control (CTB/ Moench)

648
slsDetectorSoftware/src/Detector.cpp
View File

@ -12,78 +12,21 @@ Detector::Detector(int multi_id)
: pimpl(sls::make_unique<multiSlsDetector>(multi_id)) {}
Detector::~Detector() = default;
// Acquisition
void Detector::acquire() { pimpl->acquire(); }
void Detector::startReceiver(Positions pos) {
pimpl->Parallel(&slsDetector::startReceiver, pos);
}
void Detector::stopReceiver(Positions pos) {
pimpl->Parallel(&slsDetector::stopReceiver, pos);
}
Result<defs::runStatus> Detector::getReceiverStatus(Positions pos) {
return pimpl->Parallel(&slsDetector::getReceiverStatus, pos);
}
bool Detector::getAcquiringFlag() const { return pimpl->getAcquiringFlag(); }
void Detector::setAcquiringFlag(bool value) { pimpl->setAcquiringFlag(value); }
// Configuration
Result<std::string> Detector::getHostname(Positions pos) const {
return pimpl->Parallel(&slsDetector::getHostname, pos);
}
void Detector::freeSharedMemory() { pimpl->freeSharedMemory(); }
void Detector::setConfig(const std::string &fname) {
pimpl->readConfigurationFile(fname);
}
Result<uint64_t> Detector::getStartingFrameNumber(Positions pos) const {
return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos);
}
void Detector::setStartingFrameNumber(uint64_t value, Positions pos) {
pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value);
Result<std::string> Detector::getHostname(Positions pos) const {
return pimpl->Parallel(&slsDetector::getHostname, pos);
}
// File
void Detector::setFileName(const std::string &fname, Positions pos) {
pimpl->Parallel(&slsDetector::setFileName, pos, fname);
}
Result<std::string> Detector::getFileName(Positions pos) const {
return pimpl->Parallel(&slsDetector::setFileName, pos, "");
void Detector::setHostname(const std::vector<std::string> &value) {
pimpl->setHostname(value);
}
void Detector::setFilePath(const std::string &fpath, Positions pos) {
pimpl->Parallel(&slsDetector::setFilePath, pos, fpath);
}
Result<std::string> Detector::getFilePath(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFilePath, pos);
}
void Detector::setFileWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setFileWrite, pos, value);
}
Result<bool> Detector::getFileWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileWrite, pos);
}
void Detector::setFileOverWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setFileOverWrite, pos, value);
}
Result<bool> Detector::getFileOverWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileOverWrite, pos);
}
// dhanya
int Detector::getMultiId() const { return pimpl->getMultiId(); }
void Detector::checkDetectorVersionCompatibility(Positions pos) const {
@ -119,10 +62,6 @@ Result<int64_t> Detector::getReceiverSoftwareVersion(Positions pos) const {
std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); }
void Detector::setHostname(const std::vector<std::string> &value) {
pimpl->setHostname(value);
}
defs::detectorType Detector::getDetectorType() const {
return pimpl->getDetectorTypeAsEnum();
}
@ -339,6 +278,15 @@ void Detector::setNumberOfStorageCells(int64_t value) {
value);
}
Result<int> Detector::getStorageCellStart(Positions pos) const {
return pimpl->Parallel(&slsDetector::setStoragecellStart, pos, -1);
}
void Detector::setStoragecellStart(int cell, Positions pos) {
pimpl->Parallel(&slsDetector::setStoragecellStart, pos, cell);
}
Result<int64_t> Detector::getNumberOfAnalogSamples(Positions pos) const {
return pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES,
-1);
@ -1256,7 +1204,281 @@ void Detector::pulseChip(int n, Positions pos) {
pimpl->Parallel(&slsDetector::pulseChip, pos, n);
}
Result<int> Detector::getThresholdTemperature(Positions pos) const {
return pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1);
}
void Detector::setThresholdTemperature(int temp, Positions pos) {
pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp);
}
Result<bool> Detector::getTemperatureControl(Positions pos) const {
return pimpl->Parallel(&slsDetector::setTemperatureControl, pos, -1);
}
void Detector::setTemperatureControl(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::setTemperatureControl, pos,
static_cast<int>(enable));
}
Result<int> Detector::getTemperatureEvent(Positions pos) const {
return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1);
}
void Detector::ResetTemperatureEvent(Positions pos) {
pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, 0);
}
void Detector::programFPGA(const std::string &fname, Positions pos) {
FILE_LOG(logINFO) << "Updating Firmware. This can take awhile. Please be patient...";
std::vector<char> buffer = pimpl->readPofFile(fname);
pimpl->Parallel(&slsDetector::programFPGA, pos, buffer);
}
void Detector::resetFPGA(Positions pos) {
pimpl->Parallel(&slsDetector::resetFPGA, pos);
}
void Detector::copyDetectorServer(const std::string &fname,
const std::string &hostname, Positions pos) {
pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
rebootController(pos);
}
void Detector::rebootController(Positions pos) {
pimpl->Parallel(&slsDetector::rebootController, pos);
}
void Detector::updateFirmwareAndServer(const std::string &sname,
const std::string &hostname,
const std::string &fname,
Positions pos) {
pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
programFPGA(fname, pos);
rebootController(pos);
}
Result<bool> Detector::getPowerChip(Positions pos) const {
return pimpl->Parallel(&slsDetector::powerChip, pos, -1);
}
void Detector::setPowerChip(bool on, Positions pos) {
if (on && pimpl->size() > 3) {
for (unsigned int i = 0; i != pimpl->size(); ++i) {
pimpl->powerChip(static_cast<int>(on), i);
usleep(1000 * 1000);
}
} else {
pimpl->Parallel(&slsDetector::powerChip, pos, static_cast<int>(on));
}
}
Result<bool> Detector::getAutoCompDisable(Positions pos) const {
return pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, -1);
}
void Detector::setAutoCompDisable(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos,
static_cast<int>(value));
}
Result<int64_t> Detector::getRateCorrection(Positions pos) const {
return pimpl->Parallel(&slsDetector::getRateCorrection, pos);
}
void Detector::setRateCorrection(int64_t dead_time_ns, Positions pos) {
pimpl->Parallel(&slsDetector::setRateCorrection, pos, dead_time_ns);
}
Result<uint64_t> Detector::getStartingFrameNumber(Positions pos) const {
return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos);
}
void Detector::setStartingFrameNumber(uint64_t value, Positions pos) {
pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value);
}
Result<bool> Detector::getTenGigaEnabled(Positions pos) const {
return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1);
}
void Detector::setTenGigaEnabled(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos,
static_cast<int>(value));
}
Result<bool> Detector::getLEDEnable(Positions pos) const {
return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1);
}
void Detector::setLEDEnable(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast<int>(enable));
}
void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) {
pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay);
}
// File
Result<defs::fileFormat> Detector::getFileFormat(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileFormat, pos);
}
void Detector::setFileFormat(defs::fileFormat f, Positions pos) {
pimpl->Parallel(&slsDetector::setFileFormat, pos, f);
}
Result<std::string> Detector::getFilePath(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFilePath, pos);
}
void Detector::setFilePath(const std::string &fpath, Positions pos) {
pimpl->Parallel(&slsDetector::setFilePath, pos, fpath);
}
Result<std::string> Detector::getFileNamePrefix(Positions pos) const {
return pimpl->Parallel(&slsDetector::setFileName, pos, "");
}
void Detector::setFileNamePrefix(const std::string &fname, Positions pos) {
pimpl->Parallel(&slsDetector::setFileName, pos, fname);
}
Result<int> Detector::getFileIndex(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileIndex, pos);
}
void Detector::setFileIndex(int i, Positions pos) {
pimpl->Parallel(&slsDetector::setFileIndex, pos, i);
}
Result<bool> Detector::getFileWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileWrite, pos);
}
void Detector::setFileWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setFileWrite, pos, value);
}
void Detector::setMasterFileWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setMasterFileWrite, pos, value);
}
Result<bool> Detector::getMasterFileWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos);
}
Result<bool> Detector::getFileOverWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileOverWrite, pos);
}
void Detector::setFileOverWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setFileOverWrite, pos, value);
}
Result<int> Detector::getFramesPerFile(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFramesPerFile, pos);
}
void Detector::setFramesPerFile(int n, Positions pos) {
pimpl->Parallel(&slsDetector::setFramesPerFile, pos, n);
}
// Receiver
Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos);
}
Result<std::string> Detector::printReceiverConfiguration(Positions pos) const {
return pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos);
}
Result<bool> Detector::getReceiverLock(Positions pos) {
return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1);
}
void Detector::setReceiverLock(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast<int>(value));
}
Result<std::string> Detector::getReceiverLastClientIP(Positions pos) const {
return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos);
}
void Detector::exitReceiver(Positions pos) {
pimpl->Parallel(&slsDetector::exitReceiver, pos);
}
void Detector::execReceiverCommand(const std::string &cmd, Positions pos) {
pimpl->Parallel(&slsDetector::execReceiverCommand, pos, cmd);
}
Result<int> Detector::getReceiverStreamingFrequency(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
}
void Detector::setReceiverStreamingFrequency(int freq, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverStreamingFrequency, pos, freq);
}
Result<int> Detector::getReceiverStreamingTimer(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
}
void Detector::setReceiverStreamingTimer(int time_in_ms, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, time_in_ms);
}
bool Detector::getDataStreamingToClient() const {
return pimpl->enableDataStreamingToClient(-1);
}
void Detector::setDataStreamingToClient(bool enable) {
pimpl->enableDataStreamingToClient(static_cast<int>(enable));
}
Result<bool> Detector::getDataStreamingFromReceiver(Positions pos) const {
return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1);
}
void Detector::setDataStreamingFromReceiver(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos,
static_cast<int>(enable));
}
Result<int> Detector::getReceiverFifoDepth(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1);
}
void Detector::setReceiverFifoDepth(int nframes, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes);
}
Result<bool> Detector::getReceiverSilentMode(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1);
}
void Detector::setReceiverSilentMode(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos,
static_cast<int>(value));
}
Result<defs::frameDiscardPolicy>
Detector::getReceiverFrameDiscardPolicy(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos,
defs::GET_FRAME_DISCARD_POLICY);
}
void Detector::setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f);
}
Result<bool> Detector::getPartialFramesPadding(Positions pos) const {
return pimpl->Parallel(&slsDetector::getPartialFramesPadding, pos);
}
void Detector::setPartialFramesPadding(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setPartialFramesPadding, pos, value);
}
Result<bool> Detector::getRxPadDeactivatedMod(Positions pos) const {
return pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, -1);
@ -1283,8 +1505,23 @@ Detector::getReceiverRealUDPSocketBufferSize(Positions pos) const {
pos);
}
// Acquisition
void Detector::acquire() { pimpl->acquire(); }
bool Detector::getAcquiringFlag() const { return pimpl->getAcquiringFlag(); }
void Detector::setAcquiringFlag(bool value) { pimpl->setAcquiringFlag(value); }
void Detector::startReceiver(Positions pos) {
pimpl->Parallel(&slsDetector::startReceiver, pos);
}
void Detector::stopReceiver(Positions pos) {
pimpl->Parallel(&slsDetector::stopReceiver, pos);
}
Result<defs::runStatus> Detector::getReceiverStatus(Positions pos) {
return pimpl->Parallel(&slsDetector::getReceiverStatus, pos);
}
Result<int> Detector::getFramesCaughtByReceiver(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFramesCaughtByReceiver, pos);
@ -1298,92 +1535,30 @@ void Detector::resetFramesCaught(Positions pos) {
pimpl->Parallel(&slsDetector::resetFramesCaught, pos);
}
void Detector::setMasterFileWrite(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setMasterFileWrite, pos, value);
}
Result<bool> Detector::getMasterFileWrite(Positions pos) const {
return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos);
}
void Detector::setReceiverStreamingTimer(int time_in_ms, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, time_in_ms);
}
Result<int> Detector::getReceiverStreamingTimer(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
}
bool Detector::getDataStreamingToClient() const {
return pimpl->enableDataStreamingToClient(-1);
}
void Detector::setDataStreamingToClient(bool enable) {
pimpl->enableDataStreamingToClient(static_cast<int>(enable));
}
Result<bool> Detector::getDataStreamingFromReceiver(Positions pos) const {
return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1);
}
void Detector::setDataStreamingFromReceiver(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos,
static_cast<int>(enable));
}
void Detector::setTenGigaEnabled(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos,
static_cast<int>(value));
}
Result<bool> Detector::getTenGigaEnabled(Positions pos) const {
return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1);
}
Result<int> Detector::getReceiverFifoDepth(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1);
}
void Detector::setReceiverFifoDepth(int nframes, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes);
}
Result<bool> Detector::getReceiverSilentMode(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1);
}
void Detector::setReceiverSilentMode(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos,
static_cast<int>(value));
}
// pattern
void Detector::setPattern(const std::string &fname, Positions pos) {
pimpl->Parallel(&slsDetector::setPattern, pos, fname);
}
void Detector::setPatternIOControl(uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word);
}
Result<uint64_t> Detector::getPatternIOControl(Positions pos) const {
return pimpl->Parallel(&slsDetector::setPatternIOControl, pos, -1);
}
void Detector::setPatternClockControl(uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
void Detector::setPatternIOControl(uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word);
}
Result<uint64_t> Detector::getPatternClockControl(Positions pos) const {
return pimpl->Parallel(&slsDetector::setPatternClockControl, pos, -1);
}
void Detector::setPatternWord(int addr, uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
void Detector::setPatternClockControl(uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
}
void Detector::setPatternLoops(int level, int start, int stop, int n,
Positions pos) {
pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n);
void Detector::setPatternWord(int addr, uint64_t word, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
}
Result<std::array<int, 3>> Detector::getPatternLoops(int level,
@ -1392,220 +1567,41 @@ Result<std::array<int, 3>> Detector::getPatternLoops(int level,
-1);
}
void Detector::setPatternWaitAddr(int level, int addr, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr);
void Detector::setPatternLoops(int level, int start, int stop, int n,
Positions pos) {
pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n);
}
Result<int> Detector::getPatternWaitAddr(int level, Positions pos) const {
return pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, -1);
}
void Detector::setPatternWaitTime(int level, uint64_t t, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t);
void Detector::setPatternWaitAddr(int level, int addr, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr);
}
Result<uint64_t> Detector::getPatternWaitTime(int level, Positions pos) const {
return pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, -1);
}
void Detector::setPatternWaitTime(int level, uint64_t t, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t);
}
Result<uint64_t> Detector::getPatternMask(Positions pos) {
return pimpl->Parallel(&slsDetector::getPatternMask, pos);
}
void Detector::setPatternBitMask(uint64_t mask, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask);
void Detector::setPatternMask(uint64_t mask, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternMask, pos, mask);
}
Result<uint64_t> Detector::getPatternBitMask(Positions pos) const {
return pimpl->Parallel(&slsDetector::getPatternBitMask, pos);
}
void Detector::setLEDEnable(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast<int>(enable));
void Detector::setPatternBitMask(uint64_t mask, Positions pos) {
pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask);
}
Result<bool> Detector::getLEDEnable(Positions pos) const {
return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1);
}
void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) {
pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay);
}
Result<int> Detector::getFileIndex(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileIndex, pos);
}
void Detector::setFileIndex(int i, Positions pos) {
pimpl->Parallel(&slsDetector::setFileIndex, pos, i);
}
Result<defs::fileFormat> Detector::getFileFormat(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFileFormat, pos);
}
void Detector::setFileFormat(defs::fileFormat f, Positions pos) {
pimpl->Parallel(&slsDetector::setFileFormat, pos, f);
}
Result<bool> Detector::getPartialFramesPadding(Positions pos) const {
return pimpl->Parallel(&slsDetector::getPartialFramesPadding, pos);
}
void Detector::setPartialFramesPadding(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setPartialFramesPadding, pos, value);
}
void Detector::setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
Positions pos) {
pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f);
}
Result<defs::frameDiscardPolicy>
Detector::getReceiverFrameDiscardPolicy(Positions pos) const {
return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos,
defs::GET_FRAME_DISCARD_POLICY);
}
void Detector::setFramesPerFile(int n, Positions pos) {
pimpl->Parallel(&slsDetector::setFramesPerFile, pos, n);
}
Result<int> Detector::getFramesPerFile(Positions pos) const {
return pimpl->Parallel(&slsDetector::getFramesPerFile, pos);
}
Result<std::string> Detector::getReceiverLastClientIP(Positions pos) const {
return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos);
}
void Detector::setReceiverLock(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast<int>(value));
}
Result<bool> Detector::getReceiverLock(Positions pos) {
return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1);
}
Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos);
}
void Detector::printReceiverConfiguration(Positions pos) const {
pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos,
TLogLevel::logINFO);
}
Result<int64_t> Detector::getRateCorrection(Positions pos) const {
return pimpl->Parallel(&slsDetector::getRateCorrection, pos);
}
void Detector::setRateCorrection(int64_t dead_time_ns, Positions pos) {
pimpl->Parallel(&slsDetector::setRateCorrection, pos, dead_time_ns);
}
void Detector::setAutoCompDisable(bool value, Positions pos) {
pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos,
static_cast<int>(value));
}
Result<bool> Detector::getAutoCompDisable(Positions pos) const {
return pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, -1);
}
void Detector::setPowerChip(bool on, Positions pos) {
if (on && pimpl->size() > 3) {
for (unsigned int i = 0; i != pimpl->size(); ++i) {
pimpl->powerChip(static_cast<int>(on), i);
usleep(1000 * 1000);
}
} else {
pimpl->Parallel(&slsDetector::powerChip, pos, static_cast<int>(on));
}
}
Result<bool> Detector::getPowerChip(Positions pos) const {
return pimpl->Parallel(&slsDetector::powerChip, pos, -1);
}
void Detector::updateFirmwareAndServer(const std::string &sname,
const std::string &hostname,
const std::string &fname,
Positions pos) {
copyDetectorServer(fname, hostname, pos);
programFPGA(fname, pos);
}
void Detector::rebootController(Positions pos) {
pimpl->Parallel(&slsDetector::rebootController, pos);
}
void Detector::copyDetectorServer(const std::string &fname,
const std::string &hostname, Positions pos) {
pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
}
void Detector::resetFPGA(Positions pos) {
pimpl->Parallel(&slsDetector::resetFPGA, pos);
}
void Detector::programFPGA(const std::string &fname, Positions pos) {
FILE_LOG(logINFO) << "This can take awhile. Please be patient...";
std::vector<char> buffer = pimpl->readPofFile(fname);
pimpl->Parallel(&slsDetector::programFPGA, pos, buffer);
}
void Detector::setStoragecellStart(int cell, Positions pos) {
pimpl->Parallel(&slsDetector::setStoragecellStart, pos, cell);
}
Result<int> Detector::getStorageCellStart(Positions pos) const {
return pimpl->Parallel(&slsDetector::setStoragecellStart, pos, -1);
}
void Detector::setTemperatureEvent(int val, Positions pos) {
pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, val);
}
Result<int> Detector::getTemperatureEvent(Positions pos) const {
return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1);
}
void Detector::setTemperatureControl(bool enable, Positions pos) {
pimpl->Parallel(&slsDetector::setTemperatureControl, pos,
static_cast<int>(enable));
}
Result<bool> Detector::getTemperatureControl(Positions pos) const {
return pimpl->Parallel(&slsDetector::setTemperatureControl, pos, -1);
}
void Detector::setThresholdTemperature(int temp, Positions pos) {
pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp);
}
Result<int> Detector::getThresholdTemperature(Positions pos) const {
return pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1);
}
} // namespace sls

29
slsDetectorSoftware/src/multiSlsDetector.cpp
View File

@ -2910,16 +2910,15 @@ int64_t multiSlsDetector::getRateCorrection(int detPos) {
return sls::minusOneIfDifferent(r);
}
void multiSlsDetector::printReceiverConfiguration(TLogLevel level, int detPos) {
std::string multiSlsDetector::printReceiverConfiguration(int detPos) {
// single
if (detPos >= 0) {
return detectors[detPos]->printReceiverConfiguration(level);
return detectors[detPos]->printReceiverConfiguration();
}
// multi
for (auto &d : detectors) {
d->printReceiverConfiguration(level);
}
auto r = parallelCall(&slsDetector::printReceiverConfiguration);
return sls::concatenateIfDifferent(r);
}
bool multiSlsDetector::getUseReceiverFlag(int detPos) {
@ -3761,24 +3760,14 @@ int multiSlsDetector::setReceiverSilentMode(int i, int detPos) {
return sls::minusOneIfDifferent(r);
}
int multiSlsDetector::setPattern(const std::string &fname, int detPos) {
void multiSlsDetector::setPattern(const std::string &fname, int detPos) {
// single
if (detPos >= 0) {
return detectors[detPos]->setPattern(fname);
}
FILE *fd = fopen(fname.c_str(), "r");
if (fd == nullptr) {
throw RuntimeError("multiSlsDetector::setPattern: Could not open file");
} else {
int addr{0};
uint64_t word{0};
while (fread(&word, sizeof(word), 1, fd) != 0u) {
serialCall(&slsDetector::setPatternWord, addr, word);
++addr;
}
fclose(fd);
return addr;
detectors[detPos]->setPattern(fname);
}
// multi
parallelCall(&slsDetector::setPattern, fname);
}
uint64_t multiSlsDetector::setPatternIOControl(uint64_t word, int detPos) {

34
slsDetectorSoftware/src/slsDetector.cpp
View File

@ -2264,7 +2264,7 @@ void slsDetector::setUDPConnection() {
} else {
throw ReceiverError("setUDPConnection: Receiver is OFFLINE");
}
printReceiverConfiguration(logDEBUG1);
FILE_LOG(logDEBUG1) << printReceiverConfiguration();
}
int slsDetector::digitalTest(digitalTestMode mode, int ival) {
@ -2945,19 +2945,20 @@ void slsDetector::updateRateCorrection() {
}
}
void slsDetector::printReceiverConfiguration(TLogLevel level) {
FILE_LOG(level) << "#Detector " << detId << ":\n Receiver Hostname:\t"
<< getReceiverHostname()
<< "\nDetector UDP IP (Source):\t\t" << getDetectorIP()
<< "\nDetector UDP IP2 (Source):\t\t" << getDetectorIP2()
<< "\nDetector UDP MAC:\t\t" << getDetectorMAC()
<< "\nDetector UDP MAC2:\t\t" << getDetectorMAC2()
<< "\nReceiver UDP IP:\t" << getReceiverUDPIP()
<< "\nReceiver UDP IP2:\t" << getReceiverUDPIP2()
<< "\nReceiver UDP MAC:\t" << getReceiverUDPMAC()
<< "\nReceiver UDP MAC2:\t" << getReceiverUDPMAC2()
<< "\nReceiver UDP Port:\t" << getReceiverUDPPort()
<< "\nReceiver UDP Port2:\t" << getReceiverUDPPort2();
std::string slsDetector::printReceiverConfiguration() {
std::ostringstream os;
os << "#Detector " << detId << ":\n Receiver Hostname:\t"
<< getReceiverHostname() << "\nDetector UDP IP (Source):\t\t"
<< getDetectorIP() << "\nDetector UDP IP2 (Source):\t\t"
<< getDetectorIP2() << "\nDetector UDP MAC:\t\t" << getDetectorMAC()
<< "\nDetector UDP MAC2:\t\t" << getDetectorMAC2()
<< "\nReceiver UDP IP:\t" << getReceiverUDPIP()
<< "\nReceiver UDP IP2:\t" << getReceiverUDPIP2()
<< "\nReceiver UDP MAC:\t" << getReceiverUDPMAC()
<< "\nReceiver UDP MAC2:\t" << getReceiverUDPMAC2()
<< "\nReceiver UDP Port:\t" << getReceiverUDPPort()
<< "\nReceiver UDP Port2:\t" << getReceiverUDPPort2();
return os.str();
}
bool slsDetector::getUseReceiverFlag() const { return shm()->useReceiverFlag; }
@ -3439,7 +3440,7 @@ void slsDetector::restreamStopFromReceiver() {
}
}
int slsDetector::setPattern(const std::string &fname) {
void slsDetector::setPattern(const std::string &fname) {
uint64_t word;
uint64_t addr = 0;
FILE *fd = fopen(fname.c_str(), "r");
@ -3451,9 +3452,8 @@ int slsDetector::setPattern(const std::string &fname) {
}
fclose(fd);
} else {
return -1;
throw RuntimeError("Could not open file to set pattern");
}
return addr;
}
uint64_t slsDetector::setPatternIOControl(uint64_t word) {

5
slsDetectorSoftware/src/slsDetectorCommand.cpp
View File

@ -4864,7 +4864,7 @@ std::string slsDetectorCommand::cmdConfiguration(int narg, const char * const ar
} else if (cmd == "rx_printconfig") {
if (action == PUT_ACTION)
return std::string("cannot put");
myDet->printReceiverConfiguration(logINFO, detPos);
FILE_LOG(logINFO) << myDet->printReceiverConfiguration(detPos);
return std::string("");
} else if (cmd == "parameters") {
if (action == PUT_ACTION) {
@ -5171,7 +5171,8 @@ std::string slsDetectorCommand::cmdPattern(int narg, const char * const args[],
if (action == PUT_ACTION) {
fname = std::string(args[1]);
os << myDet->setPattern(fname, detPos);
myDet->setPattern(fname, detPos);
os << "successful";
} else if (action == GET_ACTION)
os << "Cannot get";
} else if (cmd == "patword") {