wip

slsDetectorServers/eigerDetectorServer/FebControl.c

@@ -998,7 +998,7 @@ int Feb_Control_StartAcquisition() {
 
 int Feb_Control_StopAcquisition() { return Feb_Control_Reset(); }
 
-int Feb_Control_SoftwareTrigger() {
+int Feb_Control_SoftwareTrigger(int block) {
     if (Feb_Control_activated) {
         // read exp toggle value
         unsigned int value = 0;
@@ -1063,12 +1063,14 @@ int Feb_Control_SoftwareTrigger() {
         }
 
         // wait for toggle for exposure to be done
+        if (block) {
             while (toggle == prev_toggle) {
                 usleep(5000);
                 toggle = ((value & FEB_REG_STATUS_EXP_TGL_MSK) >>
                           FEB_REG_STATUS_EXP_TGL_OFST);
             }
         }
+    }
     return 1;
 }
 

slsDetectorServers/eigerDetectorServer/FebControl.h

@@ -55,7 +55,7 @@ int Feb_Control_PrepareForAcquisition();
 void Feb_Control_PrintAcquisitionSetup();
 int Feb_Control_StartAcquisition();
 int Feb_Control_StopAcquisition();
-int Feb_Control_SoftwareTrigger();
+int Feb_Control_SoftwareTrigger(int block);
 
 // parameters
 int Feb_Control_SetDynamicRange(unsigned int four_eight_sixteen_or_thirtytwo);

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c

@@ -2404,12 +2404,12 @@ int stopStateMachine() {
 #endif
 }
 
-int softwareTrigger() {
+int softwareTrigger(int block) {
 #ifdef VIRTUAL
     return OK;
 #else
     sharedMemory_lockLocalLink();
-    if (!Feb_Control_SoftwareTrigger()) {
+    if (!Feb_Control_SoftwareTrigger(block)) {
         sharedMemory_unlockLocalLink();
         return FAIL;
     }

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -576,9 +576,12 @@ int startStateMachine();
 void *start_timer(void *arg);
 #endif
 int stopStateMachine();
-#if defined(EIGERD) || defined(MYTHEN3D)
+#ifdef MYTHEN3D
 int softwareTrigger();
 #endif
+#ifdef EIGERD
+int softwareTrigger(int block);
+#endif
 #if defined(EIGERD) || defined(MYTHEN3D)
 int startReadOut();
 #endif

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -4163,16 +4163,29 @@ int check_version(int file_des) {
 int software_trigger(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
+    int arg = -1;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logDEBUG1, ("Software Trigger (block: %d\n", arg));
 
-    LOG(logDEBUG1, ("Software Trigger\n"));
 #if !defined(EIGERD) && !defined(MYTHEN3D)
     functionNotImplemented();
 #else
+    if (arg && myDetectorType == MYTHEN3) {
+        ret = FAIL;
+        strcpy(mess, "Blocking trigger not implemented for Mythen3. Please use non blocking trigger.\n");
+        LOG(logERROR, (mess));
+    }
     // only set
-    if (Server_VerifyLock() == OK) {
+    else if (Server_VerifyLock() == OK) {
+#ifdef MYTHEN3
         ret = softwareTrigger();
+#else
+        ret = softwareTrigger(arg);
+#endif
         if (ret == FAIL) {
-            sprintf(mess, "Could not send software trigger\n");
+            strcpy(mess, "Could not send software trigger\n");
             LOG(logERROR, (mess));
         }
         LOG(logDEBUG1, ("Software trigger successful\n"));
@@ -7588,8 +7601,10 @@ int set_pattern(int file_des) {
         LOG(logINFO,
             ("Setting Pattern Word (printing every 10 words that are not 0\n"));
         /****************************************************************************************************************/
-	/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A SEPARATE FUNCTION WHICH COULD BE REUSED*/
+        /* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A
-	/* added loadPattern.c/h - the same func could be reused also in readDefaultPattern                                  */
+         * SEPARATE FUNCTION WHICH COULD BE REUSED*/
+        /* added loadPattern.c/h - the same func could be reused also in
+         * readDefaultPattern                                  */
         /***************************************************************************************************************/
 
         for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {

slsDetectorSoftware/include/sls/Detector.h

@@ -520,8 +520,10 @@ class Detector {
      * numbers for different modules.*/
     void setNextFrameNumber(uint64_t value, Positions pos = {});
 
-    /** [Eiger][Mythen3] Sends an internal software trigger to the detector */
+    /** [Eiger][Mythen3] Sends an internal software trigger to the detector
-    void sendSoftwareTrigger(Positions pos = {});
+     * block true if command blocks till frames are sent out from that trigger
+     */
+    void sendSoftwareTrigger(const bool block = false, Positions pos = {});
 
     Result<defs::scanParameters> getScan(Positions pos = {}) const;
 
@@ -1308,7 +1310,6 @@ class Detector {
 
     Result<bool> getMaster(Positions pos = {}) const;
 
-
     // TODO! check if we really want to expose this !!!!!
     Result<int> getChipStatusRegister(Positions pos = {}) const;
 

slsDetectorSoftware/src/CmdProxy.cpp

@@ -1193,6 +1193,41 @@ std::string CmdProxy::Scan(int action) {
     return os.str();
 }
 
+std::string CmdProxy::Trigger(int action) {
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        if (cmd == "trigger") {
+            os << "[Eiger][Mythen3] Sends software trigger signal to detector";
+        } else if (cmd == "blockingtrigger") {
+            os << "[Eiger] Sends software trigger signal to detector and "
+                  "blocks till "
+                  "the frames are sent out for that trigger.";
+        } else {
+            throw sls::RuntimeError("unknown command " + cmd);
+        }
+        os << '\n';
+    } else if (action == slsDetectorDefs::GET_ACTION) {
+        throw sls::RuntimeError("Cannot get");
+    } else if (action == slsDetectorDefs::PUT_ACTION) {
+        if (det_id != -1) {
+            throw sls::RuntimeError("Cannot execute this at module level");
+        }
+        if (!args.empty()) {
+            WrongNumberOfParameters(0);
+        }
+        bool block = false;
+        if (cmd == "blockingtrigger") {
+            block = true;
+        }
+        det->sendSoftwareTrigger(block);
+        os << "successful\n";
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 /* Network Configuration (Detector<->Receiver) */
 
 std::string CmdProxy::UDPDestinationIP(int action) {
@@ -1981,12 +2016,12 @@ std::string CmdProxy::GateDelay(int action) {
     return os.str();
 }
 
-
 std::string CmdProxy::GainCaps(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[cap1, cap2, ...]\n\t[Mythen3] gain, options: C10pre, C15sh, C30sh, C50sh, C225ACsh, C15pre"
+        os << "[cap1, cap2, ...]\n\t[Mythen3] gain, options: C10pre, C15sh, "
+              "C30sh, C50sh, C225ACsh, C15pre"
            << '\n';
     } else if (action == defs::GET_ACTION) {
         if (!args.empty())

slsDetectorSoftware/src/CmdProxy.h

@@ -571,7 +571,6 @@ class CmdProxy {
         return ToString(value, unit);
     }
 
-
     using FunctionMap = std::map<std::string, std::string (CmdProxy::*)(int)>;
     using StringMap = std::map<std::string, std::string>;
 
@@ -839,7 +838,7 @@ class CmdProxy {
         {"rx_framescaught", &CmdProxy::rx_framescaught},
         {"rx_missingpackets", &CmdProxy::rx_missingpackets},
         {"nextframenumber", &CmdProxy::nextframenumber},
-        {"trigger", &CmdProxy::trigger},
+        {"trigger", &CmdProxy::Trigger},
         {"scan", &CmdProxy::Scan},
         {"scanerrmsg", &CmdProxy::scanerrmsg},
 
@@ -900,6 +899,7 @@ class CmdProxy {
         {"rx_zmqhwm", &CmdProxy::rx_zmqhwm},
 
         /* Eiger Specific */
+        {"blockingtrigger", &CmdProxy::Trigger},
         {"subexptime", &CmdProxy::subexptime},
         {"subdeadtime", &CmdProxy::subdeadtime},
         {"overflow", &CmdProxy::overflow},
@@ -1094,6 +1094,7 @@ class CmdProxy {
     std::string ReceiverStatus(int action);
     std::string DetectorStatus(int action);
     std::string Scan(int action);
+    std::string Trigger(int action);
     /* Network Configuration (Detector<->Receiver) */
     std::string UDPDestinationIP(int action);
     std::string UDPDestinationIP2(int action);
@@ -1460,10 +1461,6 @@ class CmdProxy {
                            "Stopping acquisition might result in "
                            "different frame numbers for different modules.");
 
-    EXECUTE_SET_COMMAND(
-        trigger, sendSoftwareTrigger,
-        "\n\t[Eiger][Mythen3] Sends software trigger signal to detector.");
-
     GET_COMMAND(scanerrmsg, getScanErrorMessage,
                 "\n\tGets Scan error message if scan ended in error for non "
                 "blocking acquisitions.");

slsDetectorSoftware/src/Detector.cpp

@@ -690,14 +690,15 @@ void Detector::startDetector() {
     } else {
         pimpl->Parallel(&Module::startAcquisition, {});
     }
-    
 }
 
 void Detector::startDetectorReadout() {
     pimpl->Parallel(&Module::startReadout, {});
 }
 
-void Detector::stopDetector(Positions pos) { pimpl->Parallel(&Module::stopAcquisition, pos); }
+void Detector::stopDetector(Positions pos) {
+    pimpl->Parallel(&Module::stopAcquisition, pos);
+}
 
 Result<defs::runStatus> Detector::getDetectorStatus(Positions pos) const {
     return pimpl->Parallel(&Module::getRunStatus, pos);
@@ -724,8 +725,8 @@ void Detector::setNextFrameNumber(uint64_t value, Positions pos) {
     pimpl->Parallel(&Module::setNextFrameNumber, pos, value);
 }
 
-void Detector::sendSoftwareTrigger(Positions pos) {
+void Detector::sendSoftwareTrigger(const bool block, Positions pos) {
-    pimpl->Parallel(&Module::sendSoftwareTrigger, pos);
+    pimpl->Parallel(&Module::sendSoftwareTrigger, pos, false);
 }
 
 Result<defs::scanParameters> Detector::getScan(Positions pos) const {
@@ -733,8 +734,10 @@ Result<defs::scanParameters> Detector::getScan(Positions pos) const {
 }
 
 void Detector::setScan(const defs::scanParameters t) {
-    if(getDetectorType().squash() == defs::MYTHEN3 && size()>1 && t.enable != 0){
+    if (getDetectorType().squash() == defs::MYTHEN3 && size() > 1 &&
-        throw DetectorError("Scan is only allowed for single module Mythen 3 because of synchronization");
+        t.enable != 0) {
+        throw DetectorError("Scan is only allowed for single module Mythen 3 "
+                            "because of synchronization");
     }
     pimpl->Parallel(&Module::setScan, {}, t);
 }
@@ -1627,7 +1630,6 @@ Result<int> Detector::getGainCaps(Positions pos){
     return pimpl->Parallel(&Module::getGainCaps, pos);
 }
 
-
 // CTB/ Moench Specific
 
 Result<int> Detector::getNumberOfAnalogSamples(Positions pos) const {

slsDetectorSoftware/src/Module.cpp

@@ -364,7 +364,9 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
         }
     }
     if (out_of_range) {
-            LOG(logWARNING) << "Some trimbits were out of range after interpolation, these have been replaced with 0 or 63.";
+        LOG(logWARNING)
+            << "Some trimbits were out of range after interpolation, these "
+               "have been replaced with 0 or 63.";
     }
 
     // check dacs
@@ -379,10 +381,10 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
         }
     }
     if (out_of_range) {
-            LOG(logWARNING) << "Some dacs were out of range after interpolation, these have been replaced with 600 or 2400.";
+        LOG(logWARNING) << "Some dacs were out of range after interpolation, "
+                           "these have been replaced with 600 or 2400.";
     }
 
-
     setModule(myMod, trimbits);
     if (getSettings() != isettings) {
         throw RuntimeError("setThresholdEnergyAndSettings: Could not set "
@@ -412,7 +414,8 @@ void Module::loadSettingsFile(const std::string &fname) {
         if (shm()->myDetectorType == MYTHEN3) {
             serialNumberWidth = 4;
         }
-        if ((fname.find(".sn") == std::string::npos) && (fname.find(".trim") == std::string::npos)) {
+        if ((fname.find(".sn") == std::string::npos) &&
+            (fname.find(".trim") == std::string::npos)) {
             ostfn << ".sn" << std::setfill('0') << std::setw(serialNumberWidth)
                   << std::dec << getSerialNumber();
         }
@@ -773,7 +776,9 @@ void Module::setNextFrameNumber(uint64_t value) {
     sendToDetector(F_SET_NEXT_FRAME_NUMBER, value, nullptr);
 }
 
-void Module::sendSoftwareTrigger() { sendToDetectorStop(F_SOFTWARE_TRIGGER); }
+void Module::sendSoftwareTrigger(const bool block) {
+    sendToDetectorStop(F_SOFTWARE_TRIGGER, static_cast<int>(block), nullptr);
+}
 
 defs::scanParameters Module::getScan() const {
     return sendToDetector<defs::scanParameters>(F_GET_SCAN);
@@ -1994,9 +1999,7 @@ std::array<time::ns, 3> Module::getGateDelayForAllGates() const {
     return sendToDetector<std::array<time::ns, 3>>(F_GET_GATE_DELAY_ALL_GATES);
 }
 
-bool Module::isMaster() const{
+bool Module::isMaster() const { return sendToDetector<int>(F_GET_MASTER); }
-    return sendToDetector<int>(F_GET_MASTER);
-}
 
 int Module::getChipStatusRegister() const {
     return sendToDetector<int>(F_GET_CSR);
@@ -2006,9 +2009,7 @@ void Module::setGainCaps(int caps){
     sendToDetector<int>(F_SET_GAIN_CAPS, caps);
 }
 
-int Module::getGainCaps(){
+int Module::getGainCaps() { return sendToDetector<int>(F_GET_GAIN_CAPS); }
-    return sendToDetector<int>(F_GET_GAIN_CAPS);
-}
 
 // CTB / Moench Specific
 int Module::getNumberOfAnalogSamples() const {
@@ -3209,7 +3210,6 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     auto file_size = getFileSize(infile);
 
-
     // eiger
     if (shm()->myDetectorType == EIGER) {
         infile.read(reinterpret_cast<char *>(myMod.dacs),
@@ -3235,16 +3235,15 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     // mythen3 (dacs, trimbits)
     else if (shm()->myDetectorType == MYTHEN3) {
-        int expected_size =
+        int expected_size = sizeof(int) * myMod.ndac +
-            sizeof(int) * myMod.ndac + sizeof(int) * myMod.nchan + sizeof(myMod.reg);
+                            sizeof(int) * myMod.nchan + sizeof(myMod.reg);
         if (file_size != expected_size) {
             throw RuntimeError("The size of the settings file: " + fname +
                                " differs from the expected size, " +
                                std::to_string(file_size) + " instead of " +
                                std::to_string(expected_size) + " bytes");
         }
-        infile.read(reinterpret_cast<char *>(&myMod.reg),
+        infile.read(reinterpret_cast<char *>(&myMod.reg), sizeof(myMod.reg));
-                    sizeof(myMod.reg));
         infile.read(reinterpret_cast<char *>(myMod.dacs),
                     sizeof(int) * (myMod.ndac));
         for (int i = 0; i < myMod.ndac; ++i) {

slsDetectorSoftware/src/Module.h

@@ -185,7 +185,7 @@ class Module : public virtual slsDetectorDefs {
     std::vector<uint64_t> getNumMissingPackets() const;
     uint64_t getNextFrameNumber() const;
     void setNextFrameNumber(uint64_t value);
-    void sendSoftwareTrigger();
+    void sendSoftwareTrigger(const bool block);
     defs::scanParameters getScan() const;
     void setScan(const defs::scanParameters t);
     std::string getScanErrorMessage() const;

slsDetectorSoftware/tests/test-CmdProxy.cpp

@@ -1446,6 +1446,45 @@ TEST_CASE("trigger", "[.cmd]") {
     }
 }
 
+TEST_CASE("blockingtrigger", "[.cmd]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    REQUIRE_THROWS(proxy.Call("blockingtrigger", {}, -1, GET));
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::EIGER) {
+        REQUIRE_THROWS(proxy.Call("blockingtrigger", {}, -1, PUT));
+    } else if (det_type == defs::EIGER) {
+        auto prev_timing =
+            det.getTimingMode().tsquash("inconsistent timing mode in test");
+        auto prev_frames =
+            det.getNumberOfFrames().tsquash("inconsistent #frames in test");
+        auto prev_exptime =
+            det.getExptime().tsquash("inconsistent exptime in test");
+        auto prev_period =
+            det.getPeriod().tsquash("inconsistent period in test");
+        det.setTimingMode(defs::TRIGGER_EXPOSURE);
+        det.setNumberOfFrames(1);
+        det.setExptime(std::chrono::microseconds(200));
+        det.setPeriod(std::chrono::milliseconds(1));
+        auto nextframenumber =
+            det.getNextFrameNumber().tsquash("inconsistent frame nr in test");
+        det.startDetector();
+        {
+            std::ostringstream oss;
+            proxy.Call("blockingtrigger", {}, -1, PUT, oss);
+            REQUIRE(oss.str() == "blockingtrigger successful\n");
+        }
+        auto currentfnum =
+            det.getNextFrameNumber().tsquash("inconsistent frame nr in test");
+        REQUIRE(nextframenumber + 1 == currentfnum);
+        det.stopDetector();
+        det.setTimingMode(prev_timing);
+        det.setNumberOfFrames(prev_frames);
+        det.setExptime(prev_exptime);
+        det.setPeriod(prev_period);
+    }
+}
+
 TEST_CASE("clearbusy", "[.cmd]") {
     Detector det;
     CmdProxy proxy(&det);