WIP

slsDetectorGui/src/qTabAdvanced.cpp

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

slsDetectorSoftware/include/Detector.h

@@ -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
+     * Frees shared memory and adds detectors to the list
-     * contains module id and file index as well.
+     * Also updates local detector cache
-     * @param pos detector positions
+     * @param name hostnames for the positions given
-     * @returns file name prefix
      */
-    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();
+     *    PATTERN                                     *
-
+     *                                                *
-    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;
    
     /** [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
+     * [CTB] 
-     * @param addr address of the word
+     * Caution: If word is  -1  reads the addr (same as
-     * @param word word to be written, -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.
+     * [CTB] 
-     * @param level -1 complete pattern, 0,1,2, loop level
+     * Options: level: -1 (complete pattern) and 0-2 levels
-     * @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
      * @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
+     * [CTB] 
-     * @param level  0,1,2, wait level
+     * Options: start, stop, n : 0-2
-     * @param addr wait address
+     * level: -1 (complete pattern) and 0-2 levels
-     * @param pos detector position
-     * @returns actual value
      */
-    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
+     * [CTB] 
-     * @param level  0,1,2, wait level
+     * Options: level 0-2 
-     * @param t wait time
-     * @param pos detector position
      */
-    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. */
+    /** [CTB]  */
-    Result<uint64_t> getPatternMask(Positions pos = {});
+    Result<uint64_t> getPatternBitMask(Positions pos = {}) const;
 
     /**
      * [CTB] Sets the bitmask that the mask will be applied to for every
-     * pattern.
+     * pattern
-     * @param mask mask to select bits
      */
     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;
 
 
 

slsDetectorSoftware/include/multiSlsDetector.h

@@ -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

slsDetectorSoftware/include/slsDetector.h

@@ -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)

slsDetectorSoftware/src/Detector.cpp

@@ -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<std::string> Detector::getHostname(Positions pos) const {
-
+    return pimpl->Parallel(&slsDetector::getHostname, pos);
-
-
-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);
 }
 
-// File
+void Detector::setHostname(const std::vector<std::string> &value) {
-void Detector::setFileName(const std::string &fname, Positions pos) {
+    pimpl->setHostname(value);
-    pimpl->Parallel(&slsDetector::setFileName, pos, fname);
-}
-Result<std::string> Detector::getFileName(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setFileName, pos, "");
 }
 
-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) {
+// pattern
-    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));
-}
 
 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) {
+void Detector::setPatternIOControl(uint64_t word, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
+    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) {
+void Detector::setPatternClockControl(uint64_t word, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
+    pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
 }
 
-void Detector::setPatternLoops(int level, int start, int stop, int n,
+void Detector::setPatternWord(int addr, uint64_t word, Positions pos) {
-                               Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
-    pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n);
 }
 
 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) {
+void Detector::setPatternLoops(int level, int start, int stop, int n,
-    pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr);
+                               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) {
+void Detector::setPatternWaitAddr(int level, int addr, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t);
+    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) {
+void Detector::setPatternMask(uint64_t mask, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask);
+    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) {
+void Detector::setPatternBitMask(uint64_t mask, Positions pos) {
-    pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast<int>(enable));
+    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

slsDetectorSoftware/src/multiSlsDetector.cpp

@@ -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) {
+    auto r = parallelCall(&slsDetector::printReceiverConfiguration);
-        d->printReceiverConfiguration(level);
+    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);
+        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;
     }
+
+    // multi
+    parallelCall(&slsDetector::setPattern, fname);
 }
 
 uint64_t multiSlsDetector::setPatternIOControl(uint64_t word, int detPos) {

slsDetectorSoftware/src/slsDetector.cpp

@@ -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,12 +2945,12 @@ void slsDetector::updateRateCorrection() {
     }
 }
 
-void slsDetector::printReceiverConfiguration(TLogLevel level) {
+std::string slsDetector::printReceiverConfiguration() {
-    FILE_LOG(level) << "#Detector " << detId << ":\n Receiver Hostname:\t"
+    std::ostringstream os;
-                    << getReceiverHostname()
+    os << "#Detector " << detId << ":\n Receiver Hostname:\t"
-                    << "\nDetector UDP IP (Source):\t\t" << getDetectorIP()
+       << getReceiverHostname() << "\nDetector UDP IP (Source):\t\t"
-                    << "\nDetector UDP IP2 (Source):\t\t" << getDetectorIP2()
+       << getDetectorIP() << "\nDetector UDP IP2 (Source):\t\t"
-                    << "\nDetector UDP MAC:\t\t" << getDetectorMAC()
+       << getDetectorIP2() << "\nDetector UDP MAC:\t\t" << getDetectorMAC()
        << "\nDetector UDP MAC2:\t\t" << getDetectorMAC2()
        << "\nReceiver UDP IP:\t" << getReceiverUDPIP()
        << "\nReceiver UDP IP2:\t" << getReceiverUDPIP2()
@@ -2958,6 +2958,7 @@ void slsDetector::printReceiverConfiguration(TLogLevel level) {
        << "\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) {

slsDetectorSoftware/src/slsDetectorCommand.cpp

@@ -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") {