zmq fixed WIP

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -6846,14 +6846,11 @@ int get_receiver_parameters(int file_des) {
 	n += sendData(file_des,&i32,sizeof(i32),INT32);
 	if (n < 0) return printSocketReadError();
 	// multisize
-	i32 = 0;
 	n += sendData(file_des,&i32,sizeof(i32),INT32);
 	if (n < 0) return printSocketReadError();
-	i32 = 0;
 	n += sendData(file_des,&i32,sizeof(i32),INT32);
 	if (n < 0) return printSocketReadError();
 	// detId
-	i32 = 0;
 	n += sendData(file_des,&i32,sizeof(i32),INT32);
 	if (n < 0) return printSocketReadError();
 	// hostname
@@ -6863,6 +6860,12 @@ int get_receiver_parameters(int file_des) {
 		n += sendData(file_des, hostname, MAX_STR_LENGTH, OTHER);
 		if (n < 0) return printSocketReadError();		
 	}	
+	// interface id
+	n += sendData(file_des,&i32,sizeof(i32),INT32);
+	if (n < 0) return printSocketReadError();
+	// zmq ip
+	n += sendData(file_des,&i32,sizeof(i32),INT32);
+	if (n < 0) return printSocketReadError();
 	// end of shared memory variables in struct
 
 

slsDetectorSoftware/CMakeLists.txt

@@ -3,6 +3,7 @@ set(SOURCES
     src/slsDetectorUsers.cpp 
     src/Module.cpp 
     src/Detector.cpp
+    src/Receiver.cpp
     src/CmdProxy.cpp
     src/CmdParser.cpp
 )

slsDetectorSoftware/include/Detector.h

@@ -19,7 +19,7 @@ class IpAddr;
 //Free function to avoid dependence on class
 //and avoid the option to free another objects
 //shm by mistake
-void freeSharedMemory(int multiId, int detPos = -1);
+void freeSharedMemory(int detectorId, int moduleId = -1);
 
 
 /**
@@ -57,6 +57,8 @@ class Detector {
     /* Frees shared memory, adds detectors to the list
      * and updates local detector cache */
     void setHostname(const std::vector<std::string> &hostname);
+    void setHostname(const std::vector<std::string> &hostname,
+      const std::vector<int> &port);
 
     /** connects to n servers at local host starting at specific control port */
     void setVirtualDetectorServers(int numServers, int startingPort);
@@ -344,11 +346,15 @@ class Detector {
 
     Result<defs::runStatus> getDetectorStatus(Positions pos = {}) const;
 
-    Result<defs::runStatus> getReceiverStatus(Positions pos = {}) const;
+    Result<defs::runStatus> getReceiverStatus() const;
+    /** interface is by 1 (primary udp interface), 
+     * 2 for second udp interface [Eiger][Jungfrau] */
+    Result<defs::runStatus> getReceiverStatus(const int udpInterface, 
+      Positions pos = {}) const;
 
-    Result<int64_t> getFramesCaught(Positions pos = {}) const;
+    Result<uint64_t> getFramesCaught(Positions pos = {}) const;
 
-    Result<std::vector<uint64_t>> getNumMissingPackets(Positions pos = {}) const;
+    Result<uint64_t> getNumMissingPackets(Positions pos = {}) const;
 
     /** [Eiger][Jungfrau] */
     Result<uint64_t> getStartingFrameNumber(Positions pos = {}) const;
@@ -503,28 +509,40 @@ class Detector {
      *                                                *
      * ************************************************/
 
+    /** interface is by 1 (primary udp interface), 
+     * 2 for second udp interface [Eiger][Jungfrau] */
+    void removeReceivers(const int udpInterface);
+
     /** true when slsReceiver is used */
     Result<bool> getUseReceiverFlag(Positions pos = {}) const;
 
-    Result<std::string> getRxHostname(Positions pos = {}) const;
+    /** interface is by 1 (primary udp interface), 
-
+     * 2 for second udp interface [Eiger][Jungfrau]
+     */
+    Result<std::string> getRxHostname(const int udpInterface, Positions pos = {}) const;
     /**
      * Validates and sets the receiver.
-     * Updates local receiver cache parameters
      * Configures the detector to the receiver as UDP destination
-     * @param receiver receiver hostname or IP address, can include tcp port eg. hostname:port
+     * interface is by 1 (primary udp interface), 
+     * 2 for second udp interface [Eiger][Jungfrau]
      */
-    void setRxHostname(const std::string &receiver, Positions pos = {});
+    void setRxHostname(const int udpInterface, const std::string &hostname, 
+      Positions pos = {});
+      
+    /** cannot be for multiple detectors as port is unique */
+    void setRxHostname(const int udpInterface, const std::string &hostname, 
+      const int port, int module_id);
 
-    /** multiple rx hostnames (same as setRxHostname) */
+   /** interface is by 1 (primary udp interface), 
-    void setRxHostname(const std::vector<std::string> &name); 
+     * 2 for second udp interface [Eiger][Jungfrau] */
-
+    Result<int> getRxPort(const int udpInterface, Positions pos = {}) const;
-    Result<int> getRxPort(Positions pos = {}) const;
 
     /** Receiver TCP port (for client communication with Receiver)  
      *  module_id is -1 for all detectors, ports for each module is calculated
-     * (increments) */
+     * (increments) 
-    void setRxPort(int port, int module_id = -1);
+     *  interface is by 1 (primary udp interface), 
+     * 2 for second udp interface [Eiger][Jungfrau] */
+    void setRxPort(const int udpInterface, const int port, int module_id = -1);
 
     Result<int> getRxFifoDepth(Positions pos = {}) const;
 
@@ -656,6 +674,9 @@ class Detector {
 
     void setRxZmqIP(const IpAddr ip, Positions pos = {});
 
+    Result<bool> getClientZmq(Positions pos = {}) const;
+    void setClientZmq(const bool enable, Positions pos = {});
+
     Result<int> getClientZmqPort(Positions pos = {}) const;
 
     /**
@@ -1352,8 +1373,6 @@ class Detector {
 
     Result<uint64_t> getRxCurrentFrameIndex(Positions pos = {}) const;
 
-  private:
-    std::vector<int> getPortNumbers(int start_port);
 };
 
 } // namespace sls

slsDetectorSoftware/src/CmdProxy.cpp

@@ -115,13 +115,29 @@ std::string CmdProxy::ListCommands(int action) {
 }
 
 /* configuration */
+std::pair<std::string, int> 
+    CmdProxy::parseHostnameAndPort(std::string name) {
+    std::string host = name;
+    std::string hostname;
+    int port = 0;
+    auto res = sls::split(host, ':');
+    if (res.size() > 1) {
+        hostname = res[0];
+        port = StringTo<int>(res[1]);
+    } else {
+        hostname = host;
+    }
+    return std::make_pair(hostname, port);
+}
+
 
 std::string CmdProxy::Hostname(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
         os << "\n\tFrees shared memory and sets hostname (or IP address) of "
-              "all modules concatenated by +."
+        "all modules concatenated by +.\n\t"
+        "[hostname or ip address]:[tcp port] Use this for virtual servers\n\t"
            << '\n';
     } else if (action == defs::GET_ACTION) {
         if (!args.empty()) {
@@ -136,17 +152,35 @@ std::string CmdProxy::Hostname(int action) {
         if (det_id != -1) {
             throw sls::RuntimeError("Cannot execute this at module level");
         }
+        std::vector<std::string> arguments;
         // only args[0], but many hostames concatenated with +
         if (args[0].find('+') != std::string::npos) {
-            auto t = sls::split(args[0], '+');
+            if (args.size() > 1) {
-            det->setHostname(t);
+                throw sls::RuntimeError("Cannot have concatenated hostnames and"
-            os << ToString(t) << '\n';
+                    "multiple arguments");
+            }
+            arguments = sls::split(args[0], '+');
         }
         // either hostnames separated by space, or single hostname
         else {
-            det->setHostname(args);
+            arguments.assign(args.begin(), args.end());
-            os << ToString(args) << '\n';
         }
+        // separate hostname and port
+        std::vector<std::string> hostnames;
+        std::vector<int> ports;
+        for (size_t i = 0; i < arguments.size(); ++i) {
+            std::pair<std::string, int> res = parseHostnameAndPort(arguments[i]);
+            hostnames.push_back(res.first);
+            if (res.second == 0) {
+                ports.push_back(DEFAULT_PORTNO);
+            } else {
+                ports.push_back(res.second);
+            }
+        }      
+        det->setHostname(hostnames, ports);
+        auto t = det->getHostname({det_id});
+        os << OutString(t) << '\n';
+
     } else {
         throw sls::RuntimeError("Unknown action");
     }
@@ -787,16 +821,29 @@ std::vector<std::string> CmdProxy::DacCommands() {
 /* acquisition */
 
 std::string CmdProxy::ReceiverStatus(int action) {
+    int udpInterface = 1;
+    if (cmd == "rx_status") {
+        udpInterface = 1;
+    } else if (cmd == "rx_status2") {
+        udpInterface = 2;
+    } else {
+        throw sls::RuntimeError("Unknown command, use list to list all commands");
+    }
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "running, idle]\n\tReceiver listener status."
+        if (cmd == "rx_status") {
+            os << "running, idle]\n\tReceiver listener status."
                << '\n';
+        } else {
+            os << "running, idle]\n\tReceiver listener status for second udp port."
+               << '\n';
+        }
     } else if (action == defs::GET_ACTION) {
         if (args.size() != 0) {
             WrongNumberOfParameters(0);
         }
-        auto t = det->getReceiverStatus({det_id});
+        auto t = det->getReceiverStatus(udpInterface, {det_id});
         os << OutString(t) << '\n';  
     } else if (action == defs::PUT_ACTION) {
         throw sls::RuntimeError("Cannot put. Did you mean to use command 'rx_start' or 'rx_stop'?");
@@ -905,61 +952,76 @@ std::string CmdProxy::UDPDestinationIP2(int action) {
 }
 
 /* Receiver Config */
-std::string CmdProxy::ReceiveHostname(int action) {
+std::string CmdProxy::ReceiverHostname(int action) {
+    int udpInterface = 1;
+    if (cmd == "rx_hostname") {
+        udpInterface = 1;
+    } else if (cmd == "rx_hostname2") {
+        udpInterface = 2;
+    } else {
+        throw sls::RuntimeError("Unknown command, use list to list all commands");
+    }
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[hostname or ip address]\n\t"
+        if (cmd == "rx_hostname") {
-        "[hostname or ip address]:[tcp port]\n\t"
+            os << "[hostname or ip address]\n\t"
-        "[hostname1]:[tcp_port1]+[hostname2]:[tcp_port2]+\n\t"
+            "[hostname or ip address]:[tcp port]\n\t"
-        "Receiver hostname or IP. If port included, then the receiver tcp port.\n\t"
+            "Receiver hostname or IP. Port is the receiver tcp port (optional).\n\t"
-        "Used for TCP control communication between client and receiver "
+            "Use 'none' to remove receivers\n\t"
-        "to configure receiver. Also updates receiver with detector parameters."
+            "Used for TCP control communication between client and receiver "
-           << '\n';
+            "to configure receiver. Also updates receiver with detector parameters.\n\t"
+            "TCP port must be unique, if included.\n\t"
+            "If port not included and not set earlier, then it takes default port 1954"
+            " and calculates from there. \n\t"
+            "[Eiger][Jungfrau] For the 2nd udp interface, use rx_hostname2."
+            << '\n';
+        } else {
+            os << "[hostname or ip address]\n\t"
+            "[hostname or ip address]:[tcp port]\n\t"
+            "[Eiger][Jungfrau] Receiver hostname or IP for the second udp port. "
+            "Port is the receiver tcp port (optional).\n\t"
+            "Use 'none' to remove receivers\n\t"
+            "Refer rx_hostname help for details"
+            << '\n';
+        }
     } else if (action == defs::GET_ACTION) {
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
-        auto t = det->getRxHostname({det_id});
+        auto t = det->getRxHostname(udpInterface, {det_id});
         os << OutString(t) << '\n';
     } else if (action == defs::PUT_ACTION) {
-        if (args.size() < 1) {
+        if (args.size() != 1) {
             WrongNumberOfParameters(1);
         }
-        // multiple arguments
+        if (args[0].find('+') != std::string::npos) {
-        if (args.size() > 1) {
+            throw sls::RuntimeError("Cannot concatenate receiver hostnames");
-            // multiple in mulitple
+        }  
-            if (args[0].find('+') != std::string::npos) {
+        std::pair<std::string, int> res = parseHostnameAndPort(args[0]);
-                throw sls::RuntimeError("Cannot add multiple receivers at module level");
+        // removing receivers
-            }
+        if (res.first == "none") {
-            if (det_id != -1) {
+            det->removeReceivers(udpInterface);
-                throw sls::RuntimeError("Cannot add multiple receivers at module level");
+            os << "removed" << '\n';
-            }
-            det->setRxHostname(args);
-            os << ToString(args) << '\n';
         }
-        // single argument
+        // adding receivers
         else {
-            // multiple receivers concatenated with +
+            std::string hostname = res.first;
-            if (args[0].find('+') != std::string::npos) {
+            int port = res.second;
-                if (det_id != -1) {
+            if (port == 0) {
-                    throw sls::RuntimeError("Cannot add multiple receivers at module level");
+                det->setRxHostname(udpInterface, hostname, {det_id});
-                }            
+            } else {
-                auto t = sls::split(args[0], '+');
+                det->setRxHostname(udpInterface, hostname, port, det_id);
-                det->setRxHostname(t);
-                os << ToString(t) << '\n';
-            }
-            // single receiver
-            else {
-                det->setRxHostname(args[0], {det_id});
-                os << ToString(args) << '\n';
             }
+            auto t = det->getRxHostname(udpInterface, {det_id});
+            os << OutString(t) << '\n';
         }
     } else {
         throw sls::RuntimeError("Unknown action");
     }
     return os.str();
 }
+
 /* File */
 /* ZMQ Streaming Parameters (Receiver<->Client) */
 /* Eiger Specific */

slsDetectorSoftware/src/CmdProxy.h

@@ -719,8 +719,10 @@ class CmdProxy {
                           {"txndelay_right", &CmdProxy::txndelay_right},
 
                           /* Receiver Config */ 
-                          {"rx_hostname", &CmdProxy::ReceiveHostname}, 
+                          {"rx_hostname", &CmdProxy::ReceiverHostname}, 
+                          {"rx_hostname2", &CmdProxy::ReceiverHostname}, 
                           {"rx_tcpport", &CmdProxy::rx_tcpport},  
+                          {"rx_tcpport2", &CmdProxy::rx_tcpport2},  
                           {"rx_fifodepth", &CmdProxy::rx_fifodepth},
                           {"rx_silent", &CmdProxy::rx_silent},
                           {"rx_discardpolicy", &CmdProxy::rx_discardpolicy},
@@ -911,6 +913,7 @@ class CmdProxy {
     /* configuration */
     std::string free(int action); 
     // std::string config2(int action);
+    std::pair<std::string, int> parseHostnameAndPort(std::string name);
     std::string Hostname(int action); 
     std::string VirtualServer(int action); 
     std::string FirmwareVersion(int action);     
@@ -940,7 +943,7 @@ class CmdProxy {
     std::string UDPDestinationIP(int action);
     std::string UDPDestinationIP2(int action);
     /* Receiver Config */
-    std::string ReceiveHostname(int action);
+    std::string ReceiverHostname(int action);
     /* File */
     /* ZMQ Streaming Parameters (Receiver<->Client) */
     /* Eiger Specific */
@@ -1431,8 +1434,11 @@ class CmdProxy {
 
     /* Receiver Config */
 
-    INTEGER_COMMAND(rx_tcpport, getRxPort, setRxPort, StringTo<int>,
+    INTEGER_IND_COMMAND(rx_tcpport, getRxPort, setRxPort, StringTo<int>, 1,
                     "[port]\n\tTCP port for client-receiver communication. Default is 1954. Must be different if multiple receivers on same pc. Must be first command to set a receiver parameter. Multi command will automatically increment for individual modules.");  
+
+    INTEGER_IND_COMMAND(rx_tcpport2, getRxPort, setRxPort, StringTo<int>, 2,
+                    "[port]\n\t[Eiger][Jungfrau] TCP port for client-receiver communication for 2nd udp port. For details, refer rx_tcpport.");  
     
     INTEGER_COMMAND(rx_fifodepth, getRxFifoDepth, setRxFifoDepth, StringTo<int>,
         "[n_frames]\n\tSet the number of frames in the receiver fifo (buffer between listener and writer threads).");

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -5,6 +5,7 @@
 #include "file_utils.h"
 #include "logger.h"
 #include "Module.h"
+#include "Receiver.h"
 #include "sls_detector_exceptions.h"
 #include "versionAPI.h"
 
@@ -28,14 +29,14 @@
 
 namespace sls{
 
-DetectorImpl::DetectorImpl(int multi_id, bool verify, bool update)
+DetectorImpl::DetectorImpl(int detector_id, bool verify, bool update)
-    : multiId(multi_id), multi_shm(multi_id, -1) {
+    : detectorId(detector_id), detector_shm(detector_id, -1) {
-    setupMultiDetector(verify, update);
+    setupDetector(verify, update);
 }
 
 DetectorImpl::~DetectorImpl() = default;
 
-void DetectorImpl::setupMultiDetector(bool verify, bool update) {
+void DetectorImpl::setupDetector(bool verify, bool update) {
     initSharedMemory(verify);
     initializeMembers(verify);
     if (update) {
@@ -44,47 +45,94 @@ void DetectorImpl::setupMultiDetector(bool verify, bool update) {
 }
 
 void DetectorImpl::setAcquiringFlag(bool flag) {
-    multi_shm()->acquiringFlag = flag;
+    detector_shm()->acquiringFlag = flag;
 }
 
-int DetectorImpl::getMultiId() const { return multiId; }
+int DetectorImpl::getDetectorId() const { return detectorId; }
 
-void DetectorImpl::freeSharedMemory(int multiId, int detPos) {
+void DetectorImpl::freeSharedMemory(int detectorId, int moduleId) {
     // single
-    if (detPos >= 0) {
+    if (moduleId >= 0) {
-        SharedMemory<sharedSlsDetector> temp_shm(multiId, detPos);
+        SharedMemory<sharedModule> moduleShm(detectorId, moduleId);
-        if (temp_shm.IsExisting()) {
+        if (moduleShm.IsExisting()) {
-            temp_shm.RemoveSharedMemory();
+            moduleShm.OpenSharedMemory();
+            int numReceivers = 0, numReceivers2 = 0;
+            if (Module::hasSharedMemoryReceiverList(moduleShm()->shmversion)) {
+                numReceivers = moduleShm()->numberOfReceivers;
+                numReceivers2 = moduleShm()->numberOfReceivers2;
+            }
+            moduleShm.RemoveSharedMemory();
+            for (int iReceiver = 0; iReceiver < numReceivers; ++iReceiver) {
+                SharedMemory<sharedModule> receiverShm(detectorId, moduleId, 0, iReceiver);
+                if (receiverShm.IsExisting()) {
+                    receiverShm.RemoveSharedMemory();
+                }
+            }
+            for (int iReceiver = 0; iReceiver < numReceivers2; ++iReceiver) {
+                SharedMemory<sharedModule> receiverShm(detectorId, moduleId, 1, iReceiver);
+                if (receiverShm.IsExisting()) {
+                    receiverShm.RemoveSharedMemory();
+                }
+            }
         }
         return;
     }
 
     // multi - get number of detectors from shm
-    SharedMemory<sharedMultiSlsDetector> multiShm(multiId, -1);
+    SharedMemory<sharedDetector> detectorShm(detectorId, -1);
     int numDetectors = 0;
 
-    if (multiShm.IsExisting()) {
+    if (detectorShm.IsExisting()) {
-        multiShm.OpenSharedMemory();
+        detectorShm.OpenSharedMemory();
-        numDetectors = multiShm()->numberOfDetectors;
+        numDetectors = detectorShm()->numberOfModules;
-        multiShm.RemoveSharedMemory();
+        detectorShm.RemoveSharedMemory();
     }
 
-    for (int i = 0; i < numDetectors; ++i) {
+    for (int iModule = 0; iModule < numDetectors; ++iModule) {
-        SharedMemory<sharedSlsDetector> shm(multiId, i);
+        SharedMemory<sharedModule> moduleShm(detectorId, iModule);
-        shm.RemoveSharedMemory();
+        if (moduleShm.IsExisting()) {
+            moduleShm.OpenSharedMemory();
+            int numReceivers = 0, numReceivers2 = 0;
+            if (Module::hasSharedMemoryReceiverList(moduleShm()->shmversion)) {
+                numReceivers = moduleShm()->numberOfReceivers;
+                numReceivers2 = moduleShm()->numberOfReceivers2;
+            }
+            moduleShm.RemoveSharedMemory();
+            for (int iReceiver = 0; iReceiver < numReceivers; ++iReceiver) {
+                SharedMemory<sharedModule> receiverShm(detectorId, iModule, 0, iReceiver);
+                if (receiverShm.IsExisting()) {
+                    receiverShm.RemoveSharedMemory();
+                }
+            }
+            for (int iReceiver = 0; iReceiver < numReceivers2; ++iReceiver) {
+                SharedMemory<sharedModule> receiverShm(detectorId, iModule, 1, iReceiver);
+                if (receiverShm.IsExisting()) {
+                    receiverShm.RemoveSharedMemory();
+                }
+            }
+        }
     }
 }
 
 void DetectorImpl::freeSharedMemory() {
-    zmqSocket.clear();
     for (auto &d : detectors) {
         d->freeSharedMemory();
     }
     detectors.clear();
-
+    for (auto &dr : receivers) {
+        for (auto &r : dr) {
+            r->freeSharedMemory();
+        }
+    }
+    receivers.clear();    
+    for (auto &dr : receivers2) {
+        for (auto &r : dr) {
+            r->freeSharedMemory();
+        }
+    }
+    receivers2.clear(); 
     // clear multi detector shm
-    multi_shm.RemoveSharedMemory();
+    detector_shm.RemoveSharedMemory();
-    client_downstream = false;
 }
 
 std::string DetectorImpl::getUserDetails() {
@@ -101,8 +149,8 @@ std::string DetectorImpl::getUserDetails() {
     }
     sstream << "\nType: ";
     // get type from multi shm
-    if (multi_shm()->shmversion >= MULTI_SHMAPIVERSION) {
+    if (detector_shm()->shmversion >= DETECTOR_SHMAPIVERSION) {
-        sstream << ToString(multi_shm()->multiDetectorType);
+        sstream << ToString(detector_shm()->multiDetectorType);
     }
     // get type from slsdet shm
     else {
@@ -114,33 +162,33 @@ std::string DetectorImpl::getUserDetails() {
         }
     }
 
-    sstream << "\nPID: " << multi_shm()->lastPID
+    sstream << "\nPID: " << detector_shm()->lastPID
-            << "\nUser: " << multi_shm()->lastUser
+            << "\nUser: " << detector_shm()->lastUser
-            << "\nDate: " << multi_shm()->lastDate << std::endl;
+            << "\nDate: " << detector_shm()->lastDate << std::endl;
 
     return sstream.str();
 }
 
 bool DetectorImpl::getInitialChecks() const {
-    return multi_shm()->initialChecks;
+    return detector_shm()->initialChecks;
 }
 
 void DetectorImpl::setInitialChecks(const bool value) {
-    multi_shm()->initialChecks = value;
+    detector_shm()->initialChecks = value;
 }
 
 void DetectorImpl::initSharedMemory(bool verify) {
-    if (!multi_shm.IsExisting()) {
+    if (!detector_shm.IsExisting()) {
-        multi_shm.CreateSharedMemory();
+        detector_shm.CreateSharedMemory();
         initializeDetectorStructure();
     } else {
-        multi_shm.OpenSharedMemory();
+        detector_shm.OpenSharedMemory();
-        if (verify && multi_shm()->shmversion != MULTI_SHMVERSION) {
+        if (verify && detector_shm()->shmversion != DETECTOR_SHMVERSION) {
-            LOG(logERROR) << "Multi shared memory (" << multiId
+            LOG(logERROR) << "Detector shared memory (" << detectorId
                                << ") version mismatch "
                                   "(expected 0x"
-                               << std::hex << MULTI_SHMVERSION << " but got 0x"
+                               << std::hex << DETECTOR_SHMVERSION << " but got 0x"
-                               << multi_shm()->shmversion << std::dec
+                               << detector_shm()->shmversion << std::dec
                                << ". Clear Shared memory to continue.";
             throw SharedMemoryError("Shared memory version mismatch!");
         }
@@ -148,56 +196,76 @@ void DetectorImpl::initSharedMemory(bool verify) {
 }
 
 void DetectorImpl::initializeDetectorStructure() {
-    multi_shm()->shmversion = MULTI_SHMVERSION;
+    detector_shm()->shmversion = DETECTOR_SHMVERSION;
-    multi_shm()->numberOfDetectors = 0;
+    detector_shm()->numberOfModules = 0;
-    multi_shm()->multiDetectorType = GENERIC;
+    detector_shm()->multiDetectorType = GENERIC;
-    multi_shm()->numberOfDetector.x = 0;
+    detector_shm()->numberOfDetector.x = 0;
-    multi_shm()->numberOfDetector.y = 0;
+    detector_shm()->numberOfDetector.y = 0;
-    multi_shm()->numberOfChannels.x = 0;
+    detector_shm()->numberOfChannels.x = 0;
-    multi_shm()->numberOfChannels.y = 0;
+    detector_shm()->numberOfChannels.y = 0;
-    multi_shm()->acquiringFlag = false;
+    detector_shm()->acquiringFlag = false;
-    multi_shm()->initialChecks = true;
+    detector_shm()->initialChecks = true;
-    multi_shm()->gapPixels = false;
+    detector_shm()->gapPixels = false;
 }
 
 void DetectorImpl::initializeMembers(bool verify) {
     // DetectorImpl
-    zmqSocket.clear();
+    int numModules = detector_shm()->numberOfModules;
 
     // get objects from single det shared memory (open)
-    for (int i = 0; i < multi_shm()->numberOfDetectors; i++) {
+    try {
-        try {
+        for (int iModule = 0; iModule < numModules; ++iModule) {
             detectors.push_back(
-                sls::make_unique<Module>(multiId, i, verify));
+                    sls::make_unique<Module>(detectorId, iModule, verify));
-        } catch (...) {
+            int numReceivers = detectors[iModule]->getNumberOfReceivers();
-            detectors.clear();
+            if (numReceivers != 0) {
-            throw;
+                receivers.resize(numModules);
+                for (int iReceiver = 0; iReceiver < numReceivers; ++iReceiver) {
+                        receivers[iModule].push_back(
+                            sls::make_unique<Receiver>(detectorId, iModule, 0, 
+                            iReceiver, verify));
+                }
+            }
+            int numReceivers2 = detectors[iModule]->getNumberOfReceivers2();
+            if (numReceivers2 != 0) {
+                receivers2.resize(numModules);
+                for (int iReceiver = 0; iReceiver < numReceivers2; ++iReceiver) {
+                        receivers2[iModule].push_back(
+                            sls::make_unique<Receiver>(detectorId, iModule, 1,
+                            iReceiver, verify));
+                }
+            }
         }
+    } catch (...) {
+        detectors.clear();
+        receivers.clear();
+        receivers2.clear();
+        throw;
     }
 }
 
 void DetectorImpl::updateUserdetails() {
-    multi_shm()->lastPID = getpid();
+    detector_shm()->lastPID = getpid();
-    memset(multi_shm()->lastUser, 0, sizeof(multi_shm()->lastUser));
+    memset(detector_shm()->lastUser, 0, sizeof(detector_shm()->lastUser));
-    memset(multi_shm()->lastDate, 0, sizeof(multi_shm()->lastDate));
+    memset(detector_shm()->lastDate, 0, sizeof(detector_shm()->lastDate));
     try {
-        sls::strcpy_safe(multi_shm()->lastUser, exec("whoami").c_str());
+        sls::strcpy_safe(detector_shm()->lastUser, exec("whoami").c_str());
-        sls::strcpy_safe(multi_shm()->lastDate, exec("date").c_str());
+        sls::strcpy_safe(detector_shm()->lastDate, exec("date").c_str());
     } catch (...) {
-        sls::strcpy_safe(multi_shm()->lastUser, "errorreading");
+        sls::strcpy_safe(detector_shm()->lastUser, "errorreading");
-        sls::strcpy_safe(multi_shm()->lastDate, "errorreading");
+        sls::strcpy_safe(detector_shm()->lastDate, "errorreading");
     }
 }
 
 bool DetectorImpl::isAcquireReady() {
-    if (multi_shm()->acquiringFlag) {
+    if (detector_shm()->acquiringFlag) {
         LOG(logWARNING)
             << "Acquire has already started. "
                "If previous acquisition terminated unexpectedly, "
                "reset busy flag to restart.(sls_detector_put clearbusy)";
         return false;
     }
-    multi_shm()->acquiringFlag = true;
+    detector_shm()->acquiringFlag = true;
     return true;
 }
 
@@ -222,48 +290,63 @@ std::string DetectorImpl::exec(const char *cmd) {
 
 void DetectorImpl::setVirtualDetectorServers(const int numdet, const int port) {
     std::vector<std::string> hostnames;
+    std::vector<int> ports;
     for (int i = 0; i < numdet; ++i) {
+        hostnames.push_back(std::string("localhost"));
         // * 2 is for control and stop port
-        hostnames.push_back(std::string("localhost:") +
+        ports.push_back(port + i * 2);
-                            std::to_string(port + i * 2));
     }
-    setHostname(hostnames);
+    setHostname(hostnames, ports);
 }
 
 void DetectorImpl::setHostname(const std::vector<std::string> &name) {
     // this check is there only to allow the previous detsizechan command
-    if (multi_shm()->numberOfDetectors != 0) {
+    if (detector_shm()->numberOfModules != 0) {
         LOG(logWARNING)
             << "There are already detector(s) in shared memory."
                "Freeing Shared memory now.";
-        bool initialChecks = multi_shm()->initialChecks;
+        bool initialChecks = detector_shm()->initialChecks;
         freeSharedMemory();
-        setupMultiDetector();
+        setupDetector();
-        multi_shm()->initialChecks = initialChecks;
+        detector_shm()->initialChecks = initialChecks;
     }
     for (const auto &hostname : name) {
-        addSlsDetector(hostname);
+        addModule(hostname, DEFAULT_PORTNO);
     }
     updateDetectorSize();
 }
 
-void DetectorImpl::addSlsDetector(const std::string &hostname) {
+void DetectorImpl::setHostname(const std::vector<std::string> &name,
-    LOG(logINFO) << "Adding detector " << hostname;
+        const std::vector<int> &port) {
-
+    if (name.size() != port.size()) {
-    int port = DEFAULT_PORTNO;
+        throw RuntimeError("hostname vector size and port vector size do not match");
-    std::string host = hostname;
-    auto res = sls::split(hostname, ':');
-    if (res.size() > 1) {
-        host = res[0];
-        port = StringTo<int>(res[1]);
     }
+    // this check is there only to allow the previous detsizechan command
+    if (detector_shm()->numberOfModules != 0) {
+        LOG(logWARNING)
+            << "There are already detector(s) in shared memory."
+               "Freeing Shared memory now.";
+        bool initialChecks = detector_shm()->initialChecks;
+        freeSharedMemory();
+        setupDetector();
+        detector_shm()->initialChecks = initialChecks;
+    }
+    for (size_t i = 0; i < name.size(); ++i) {
+        addModule(name[i], port[i]);
+    }
+    updateDetectorSize();    
+}
 
-    if (host != "localhost") {
+void DetectorImpl::addModule(const std::string &hostname,
+    const int port) {
+    LOG(logINFO) << "Adding detector " << hostname << " on port " << port;
+
+    if (hostname != "localhost") {
         for (auto &d : detectors) {
-            if (d->getHostname() == host) {
+            if (d->getHostname() == hostname) {
                 LOG(logWARNING)
-                    << "Detector " << host
+                    << "Detector " << hostname
-                    << "already part of the multiDetector!" << std::endl
+                    << "already part of the Detector!" << std::endl
                     << "Remove it before adding it back in a new position!";
                 return;
             }
@@ -271,28 +354,176 @@ void DetectorImpl::addSlsDetector(const std::string &hostname) {
     }
 
     // get type by connecting
-    detectorType type = Module::getTypeFromDetector(host, port);
+    detectorType type = Module::getTypeFromDetector(hostname, port);
     auto pos = detectors.size();
     detectors.emplace_back(
-        sls::make_unique<Module>(type, multiId, pos, false));
+        sls::make_unique<Module>(type, detectorId, pos, false));
-    multi_shm()->numberOfDetectors = detectors.size();
+    detector_shm()->numberOfModules = detectors.size();
     detectors[pos]->setControlPort(port);
     detectors[pos]->setStopPort(port + 1);
-    detectors[pos]->setHostname(host, multi_shm()->initialChecks);
+    detectors[pos]->setHostname(hostname, detector_shm()->initialChecks);
     // detector type updated by now
-    multi_shm()->multiDetectorType =
+    detector_shm()->multiDetectorType =
         Parallel(&Module::getDetectorType, {})
             .tsquash("Inconsistent detector types.");
     // for moench and ctb
     detectors[pos]->updateNumberOfChannels();     
 }
 
+int DetectorImpl::getNumberofReceiversPerModule() const {
+    int retval = receivers.size();
+    if (receivers2.size()) {
+        retval *= 2;
+    }
+    // for round robin
+    if (retval) {
+        retval *= receivers[0].size();
+    }
+    return retval;
+}
+
+
+void DetectorImpl::initReceiver(const int udpInterface) {
+    if (udpInterface == 1) {
+        if (receivers.size() != 0) {
+            throw RuntimeError("receiver vector already initialized");
+        }
+        int tcpPort = DEFAULT_RX_PORTNO;
+        int zmqPort = DEFAULT_ZMQ_CL_PORTNO;
+        try {
+            for (int iModule = 0; iModule < size(); ++iModule) {
+                receivers.resize(detectors.size());
+                receivers[iModule].push_back(
+                    sls::make_unique<Receiver>(detectorId, iModule, 0, 
+                        0, tcpPort++, "", zmqPort++));    
+                detectors[iModule]->setNumberOfReceivers(1);
+            }
+        } catch (...) {
+            receivers.clear();
+            throw;
+        }
+    } else if (udpInterface == 2) {
+        if (receivers2.size() != 0) {
+            throw RuntimeError("receiver2 vector already initialized");
+        }
+        int tcpPort = DEFAULT_RX_PORTNO + size();
+        int zmqPort = DEFAULT_ZMQ_CL_PORTNO + size();
+        try {
+            for (int iModule = 0; iModule < size(); ++iModule) {
+                receivers2.resize(detectors.size());
+                receivers2[iModule].push_back(
+                    sls::make_unique<Receiver>(detectorId, iModule, 1, 
+                        0, tcpPort++, "", zmqPort++));    
+                detectors[iModule]->setNumberOfReceivers2(1);
+            }
+        } catch (...) {
+            receivers2.clear();
+            throw;
+        }
+    } else {
+        throw RuntimeError("Invalid udp interface number " + 
+            std::to_string(udpInterface));
+    }
+}
+
+bool DetectorImpl::isReceiverInitialized(const int udpInterface) {
+    switch (udpInterface) {
+        case 1:
+            return (receivers.size() > 0);
+        case 2:
+            return (receivers2.size() > 0);
+        default:
+            throw RuntimeError("Invalid udp interface number " + 
+                std::to_string(udpInterface));            
+    }
+}
+
+void DetectorImpl::removeReceivers(const int udpInterface) {
+    if (udpInterface == 1) {
+        for (auto & dr: receivers) {
+            for (auto & r : dr) {
+                r->freeSharedMemory();
+            }
+        }
+        receivers.clear();
+    } else if (udpInterface == 2) {
+        for (auto & dr: receivers2) {
+            for (auto & r : dr) {
+                r->freeSharedMemory();
+            }
+        }      
+        receivers2.clear();  
+    } else {
+        throw RuntimeError("Invalid udp interface number " + 
+            std::to_string(udpInterface));
+    }
+}
+
+void DetectorImpl::configureReceiver(const int udpInterface, Positions pos, 
+    const std::string &hostname) {
+
+    if (Parallel(&Module::getRunStatus, pos).squash(defs::ERROR) == defs::RUNNING) {
+        LOG(logWARNING) << "Acquisition already running, Stopping it.";
+        Parallel(&Module::stopAcquisition, {});
+    }
+    if (!isReceiverInitialized(udpInterface)) {
+        initReceiver(udpInterface);
+    }
+    auto t = Parallel(&Module::getReceiverParameters, pos);
+    if (udpInterface == 1) {
+        Parallel1(&Receiver::setHostname, pos, {}, hostname);
+        for (int iMod = 0; iMod < size(); ++iMod) {
+            auto m = receivers[iMod][0]->configure(t[iMod]);
+            if (m != 0) {
+                detectors[iMod]->setDestinationUDPMAC(m);
+            }
+        }
+    } else {
+        Parallel2(&Receiver::setHostname, pos, {}, hostname);
+        for (int iMod = 0; iMod < size(); ++iMod) {
+            auto m = receivers2[iMod][0]->configure(t[iMod]);
+            if (m != 0) {
+                detectors[iMod]->setDestinationUDPMAC2(m);
+            }
+        }
+    }
+}
+
+void DetectorImpl::configureReceiver(const int udpInterface, int module_id, 
+    const std::string &hostname, const int port) {
+
+    if (Parallel(&Module::getRunStatus, {}).squash(defs::ERROR) == defs::RUNNING) {
+        LOG(logWARNING) << "Acquisition already running, Stopping it.";
+        Parallel(&Module::stopAcquisition, {});
+    }
+    if (!isReceiverInitialized(udpInterface)) {
+        initReceiver(udpInterface);
+    }
+    std::cout << "module_id:"<<module_id << std::endl;
+    auto t = detectors[module_id]->getReceiverParameters();
+    if (udpInterface == 1) {
+        receivers[module_id][0]->setTCPPort(port);
+        receivers[module_id][0]->setHostname(hostname);
+        auto m = receivers[module_id][0]->configure(t);
+        if (m != 0) {
+            detectors[module_id]->setDestinationUDPMAC(m);
+        }
+    } else {
+        receivers2[module_id][0]->setTCPPort(port);
+        receivers2[module_id][0]->setHostname(hostname);
+        auto m = receivers2[module_id][0]->configure(t);
+        if (m != 0) {
+            detectors[module_id]->setDestinationUDPMAC2(m);
+        }
+    }
+}
+
 void DetectorImpl::updateDetectorSize() {
-    LOG(logDEBUG) << "Updating Multi-Detector Size: " << size();
+    LOG(logDEBUG) << "Updating Detector Size: " << size();
 
     const slsDetectorDefs::xy det_size = detectors[0]->getNumberOfChannels();
 
-    int maxy = multi_shm()->numberOfChannels.y;
+    int maxy = detector_shm()->numberOfChannels.y;
     if (maxy == 0) {
         maxy = det_size.y * size();
     }
@@ -303,33 +534,33 @@ void DetectorImpl::updateDetectorSize() {
         ++ndetx;
     }
 
-    multi_shm()->numberOfDetector.x = ndetx;
+    detector_shm()->numberOfDetector.x = ndetx;
-    multi_shm()->numberOfDetector.y = ndety;
+    detector_shm()->numberOfDetector.y = ndety;
-    multi_shm()->numberOfChannels.x = det_size.x * ndetx;
+    detector_shm()->numberOfChannels.x = det_size.x * ndetx;
-    multi_shm()->numberOfChannels.y = det_size.y * ndety;
+    detector_shm()->numberOfChannels.y = det_size.y * ndety;
 
     LOG(logDEBUG) << "\n\tNumber of Detectors in X direction:"
-                       << multi_shm()->numberOfDetector.x
+                       << detector_shm()->numberOfDetector.x
                        << "\n\tNumber of Detectors in Y direction:"
-                       << multi_shm()->numberOfDetector.y
+                       << detector_shm()->numberOfDetector.y
                        << "\n\tNumber of Channels in X direction:"
-                       << multi_shm()->numberOfChannels.x
+                       << detector_shm()->numberOfChannels.x
                        << "\n\tNumber of Channels in Y direction:"
-                       << multi_shm()->numberOfChannels.y;
+                       << detector_shm()->numberOfChannels.y;
 
     for (auto &d : detectors) {
-        d->updateMultiSize(multi_shm()->numberOfDetector);
+        d->updateDetectorSize(detector_shm()->numberOfDetector);
     }
 }
 
 int DetectorImpl::size() const { return detectors.size(); }
 
 slsDetectorDefs::xy DetectorImpl::getNumberOfDetectors() const {
-    return multi_shm()->numberOfDetector;
+    return detector_shm()->numberOfDetector;
 }
 
 slsDetectorDefs::xy DetectorImpl::getNumberOfChannels() const {
-    return multi_shm()->numberOfChannels;
+    return detector_shm()->numberOfChannels;
 }
 
 void DetectorImpl::setNumberOfChannels(const slsDetectorDefs::xy c) {
@@ -337,90 +568,38 @@ void DetectorImpl::setNumberOfChannels(const slsDetectorDefs::xy c) {
         throw RuntimeError(
             "Set the number of channels before setting hostname.");
     }
-    multi_shm()->numberOfChannels = c;
+    detector_shm()->numberOfChannels = c;
 }
 
 bool DetectorImpl::getGapPixelsinCallback() const {
-    return multi_shm()->gapPixels;
+    return detector_shm()->gapPixels;
 }
 
 void DetectorImpl::setGapPixelsinCallback(const bool enable) {
     if (enable) {
-        switch (multi_shm()->multiDetectorType) {
+        switch (detector_shm()->multiDetectorType) {
             case JUNGFRAU:
                 break;
             case EIGER:
                 if (size() && detectors[0]->getQuad()) {
                     break;
                 }
-                if (multi_shm()->numberOfDetector.y % 2 != 0) {
+                if (detector_shm()->numberOfDetector.y % 2 != 0) {
                     throw RuntimeError("Gap pixels can only be used "
                     "for full modules.");
                 }
                 break;
             default:
                 throw RuntimeError("Gap Pixels is not implemented for " 
-                + multi_shm()->multiDetectorType);
+                + detector_shm()->multiDetectorType);
         }
     }
-    multi_shm()->gapPixels = enable;
+    detector_shm()->gapPixels = enable;
-}
-
-int DetectorImpl::createReceivingDataSockets(const bool destroy) {
-    if (destroy) {
-        LOG(logINFO) << "Going to destroy data sockets";
-        // close socket
-        zmqSocket.clear();
-
-        client_downstream = false;
-        LOG(logINFO) << "Destroyed Receiving Data Socket(s)";
-        return OK;
-    }
-    if (client_downstream) {
-        return OK;
-    }
-    LOG(logINFO) << "Going to create data sockets";
-    
-    size_t numSockets = detectors.size();
-    size_t numSocketsPerDetector = 1;
-    if (multi_shm()->multiDetectorType == EIGER) {
-        numSocketsPerDetector = 2;
-    }
-    if (Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash() ==
-        2) {
-        numSocketsPerDetector = 2;
-    }
-    numSockets *= numSocketsPerDetector;
-
-    for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
-        uint32_t portnum = (detectors[iSocket / numSocketsPerDetector]
-                                ->getClientStreamingPort());
-        portnum += (iSocket % numSocketsPerDetector);
-        try {
-            zmqSocket.push_back(sls::make_unique<ZmqSocket>(
-                detectors[iSocket / numSocketsPerDetector]
-                    ->getClientStreamingIP()
-                    .str()
-                    .c_str(),
-                portnum));
-            LOG(logINFO) << "Zmq Client[" << iSocket << "] at "
-                              << zmqSocket.back()->GetZmqServerAddress();
-        } catch (...) {
-            LOG(logERROR)
-                << "Could not create Zmq socket on port " << portnum;
-            createReceivingDataSockets(true);
-            return FAIL;
-        }
-    }
-
-    client_downstream = true;
-    LOG(logINFO) << "Receiving Data Socket(s) created";
-    return OK;
 }
 
 void DetectorImpl::readFrameFromReceiver() {
 
-    bool gapPixels = multi_shm()->gapPixels;
+    bool gapPixels = detector_shm()->gapPixels;
     LOG(logDEBUG) << "Gap pixels: " << gapPixels;
 
     int nX = 0;
@@ -429,23 +608,32 @@ void DetectorImpl::readFrameFromReceiver() {
     int nDetPixelsY = 0;
     bool quadEnable = false;
     bool eiger = false;
-    bool numInterfaces =
+    int numInterfaces =
         Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
             .squash(); // cannot pick up from zmq
 
-    bool runningList[zmqSocket.size()], connectList[zmqSocket.size()];
+    size_t nZmq = receivers.size() + receivers2.size();
+    std::vector<ZmqSocket*> zmqSockets;
+    for (size_t i = 0; i < receivers.size(); ++i) {
+        zmqSockets.push_back(receivers[i][0]->getZmqSocket());
+        if (receivers2.size()) {
+            zmqSockets.push_back(receivers2[i][0]->getZmqSocket());
+        }
+    }
+    bool runningList[nZmq], connectList[nZmq];
     int numRunning = 0;
-    for (size_t i = 0; i < zmqSocket.size(); ++i) {
+    for (size_t i = 0; i < nZmq; ++i) {
-        if (zmqSocket[i]->Connect() == 0) {
+        if (zmqSockets[i]->Connect() == 0) {
             connectList[i] = true;
             runningList[i] = true;
             ++numRunning;
         } else {
             // to remember the list it connected to, to disconnect later
             connectList[i] = false;
-            LOG(logERROR) << "Could not connect to socket  "
-                               << zmqSocket[i]->GetZmqServerAddress();
             runningList[i] = false;
+            LOG(logERROR) << "Could not connect to socket "
+                <<  zmqSockets[i]->GetZmqServerAddress();
+
         }
     }
     int numConnected = numRunning;
@@ -482,7 +670,7 @@ void DetectorImpl::readFrameFromReceiver() {
         completeImage = true;
 
         // get each frame
-        for (unsigned int isocket = 0; isocket < zmqSocket.size(); ++isocket) {
+        for (unsigned int isocket = 0; isocket < nZmq; ++isocket) {
 
             // if running
             if (runningList[isocket]) {
@@ -490,7 +678,7 @@ void DetectorImpl::readFrameFromReceiver() {
                 // HEADER
                 {
                     zmqHeader zHeader;
-                    if (zmqSocket[isocket]->ReceiveHeader(
+                    if (zmqSockets[isocket]->ReceiveHeader(
                             isocket, zHeader, SLS_DETECTOR_JSON_HEADER_VERSION) ==
                         0) {
                         // parse error, version error or end of acquisition for
@@ -504,7 +692,7 @@ void DetectorImpl::readFrameFromReceiver() {
                     if (image == nullptr) {
                         // allocate
                         size = zHeader.imageSize;
-                        multisize = size * zmqSocket.size();
+                        multisize = size * nZmq;
                         image = new char[size];
                         multiframe = new char[multisize];
                         memset(multiframe, 0xFF, multisize);
@@ -515,8 +703,8 @@ void DetectorImpl::readFrameFromReceiver() {
                         nPixelsX = zHeader.npixelsx;
                         nPixelsY = zHeader.npixelsy;
                         // detector shape
-                        nX = zHeader.ndetx;
+                        nX = zHeader.nSocketX;
-                        nY = zHeader.ndety;
+                        nY = zHeader.nSocketY;
                         nY *= numInterfaces;
                         nDetPixelsX = nX * nPixelsX;
                         nDetPixelsY = nY * nPixelsY;
@@ -569,7 +757,7 @@ void DetectorImpl::readFrameFromReceiver() {
 
                 // DATA
                 data = true;
-                zmqSocket[isocket]->ReceiveData(isocket, image, size);
+                zmqSockets[isocket]->ReceiveData(isocket, image, size);
 
                 // creating multi image
                 {
@@ -577,7 +765,7 @@ void DetectorImpl::readFrameFromReceiver() {
                     uint32_t yoffset = coordY * nPixelsY;
                     uint32_t singledetrowoffset = nPixelsX * bytesPerPixel;
                     uint32_t rowoffset = nX * singledetrowoffset;
-                    if (multi_shm()->multiDetectorType == CHIPTESTBOARD) {
+                    if (detector_shm()->multiDetectorType == CHIPTESTBOARD) {
                         singledetrowoffset = size;
 		            }
                     LOG(logDEBUG1)
@@ -656,7 +844,7 @@ void DetectorImpl::readFrameFromReceiver() {
                 running = false;
             } else {
                 // starting a new scan/measurement (got dummy data)
-                for (size_t i = 0; i < zmqSocket.size(); ++i) {
+                for (size_t i = 0; i < zmqSockets.size(); ++i) {
                     runningList[i] = connectList[i];
                 }
                 numRunning = numConnected;
@@ -665,9 +853,9 @@ void DetectorImpl::readFrameFromReceiver() {
     }
 
     // Disconnect resources
-    for (size_t i = 0; i < zmqSocket.size(); ++i) {
+    for (size_t i = 0; i < zmqSockets.size(); ++i) {
         if (connectList[i]) {
-            zmqSocket[i]->Disconnect();
+            zmqSockets[i]->Disconnect();
         }
     }
 
@@ -755,7 +943,7 @@ int DetectorImpl::InsertGapPixels(char *image, char *&gpImage,
     // eiger requires inter chip gap pixels are halved 
     // jungfrau prefers same inter chip gap pixels as the boundary pixels
     int divisionValue = 2;
-    slsDetectorDefs::detectorType detType = multi_shm()->multiDetectorType;
+    slsDetectorDefs::detectorType detType = detector_shm()->multiDetectorType;
     if (detType == JUNGFRAU) {
         divisionValue = 1;
     }
@@ -973,23 +1161,6 @@ int DetectorImpl::InsertGapPixels(char *image, char *&gpImage,
     return imagesize; 
 }
 
-
-
-bool DetectorImpl::enableDataStreamingToClient(int enable) {
-    if (enable >= 0) {
-        // destroy data threads
-        if (enable == 0) {
-            createReceivingDataSockets(true);
-            // create data threads
-        } else {
-            if (createReceivingDataSockets() == FAIL) {
-                throw RuntimeError("Could not create data threads in client.");
-            }
-        }
-    }
-    return client_downstream;
-}
-
 void DetectorImpl::registerAcquisitionFinishedCallback(void (*func)(double, int,
                                                                     void *),
                                                        void *pArg) {
@@ -1003,7 +1174,6 @@ void DetectorImpl::registerDataCallback(void (*userCallback)(detectorData *,
                                         void *pArg) {
     dataReady = userCallback;
     pCallbackArg = pArg;
-    enableDataStreamingToClient(dataReady == nullptr ? 0 : 1);
 }
 
 int DetectorImpl::acquire() {
@@ -1024,16 +1194,16 @@ int DetectorImpl::acquire() {
         // receiver/ext process)
         sem_init(&sem_endRTAcquisition, 1, 0);
 
-        bool receiver =
+        bool receiver1 = isReceiverInitialized(1);
-            Parallel(&Module::getUseReceiverFlag, {}).squash(false);
+        bool receiver2 = isReceiverInitialized(2);
+        bool receiver = receiver1 || receiver2;
             
         setJoinThreadFlag(false);
 
         // verify receiver is idle
         if (receiver) {
-            if (Parallel(&Module::getReceiverStatus, {}).squash(ERROR) !=
+            if (Parallel3(&Receiver::getStatus).squash(ERROR) != IDLE) {
-                IDLE) {
+                Parallel3(&Receiver::stop);
-                Parallel(&Module::stopReceiver, {});
             }
         }
 
@@ -1041,32 +1211,32 @@ int DetectorImpl::acquire() {
 
         // start receiver
         if (receiver) {
-            Parallel(&Module::startReceiver, {});
+            Parallel3(&Receiver::start);
             // let processing thread listen to these packets
             sem_post(&sem_newRTAcquisition);
         }
 
         // start and read all
         try {
-            if (multi_shm()->multiDetectorType == EIGER) {
+            if (detector_shm()->multiDetectorType == EIGER) {
                 Parallel(&Module::prepareAcquisition, {});
             }
             Parallel(&Module::startAndReadAll, {});
         } catch (...) {
-            Parallel(&Module::stopReceiver, {});
+            Parallel3(&Receiver::stop);
             throw;
         }
 
         // stop receiver
         if (receiver) {
-            Parallel(&Module::stopReceiver, {});
+            Parallel3(&Receiver::stop);
             if (dataReady != nullptr) {
                 sem_wait(&sem_endRTAcquisition); // waits for receiver's
             }
             // external process to be
             // done sending data to gui
 
-            Parallel(&Module::incrementFileIndex, {});
+            Parallel3(&Receiver::incrementFileIndex);
         }
 
         // waiting for the data processing thread to finish!
@@ -1076,7 +1246,7 @@ int DetectorImpl::acquire() {
 
         if (acquisition_finished != nullptr) {
             int status = Parallel(&Module::getRunStatus, {}).squash(ERROR);
-            auto a = Parallel(&Module::getReceiverProgress, {});
+            auto a = Parallel3(&Receiver::getProgress);
             int progress = (*std::min_element (a.begin(), a.end()));
             acquisition_finished((double)progress, status, acqFinished_p);
         }
@@ -1109,7 +1279,7 @@ void DetectorImpl::startProcessingThread() {
 }
 
 void DetectorImpl::processData() {
-    if (Parallel(&Module::getUseReceiverFlag, {}).squash(false)) {
+    if (isReceiverInitialized(1) || isReceiverInitialized(2)) {
         if (dataReady != nullptr) {
             readFrameFromReceiver();
         }
@@ -1128,7 +1298,7 @@ void DetectorImpl::processData() {
                     }
                 }
                 // get and print progress
-                double temp = (double)Parallel(&Module::getReceiverProgress, {0}).squash();
+                double temp = (double)Parallel1(&Receiver::getProgress, {0}, {0}).squash();
                 if (temp != progress) {
                     printProgress(progress);
                     progress = temp;
@@ -1137,7 +1307,7 @@ void DetectorImpl::processData() {
                 // exiting loop
                 if (getJoinThreadFlag()) {
                     // print progress one final time before exiting
-                    progress = (double)Parallel(&Module::getReceiverProgress, {0}).squash();
+                    progress = (double)Parallel1(&Receiver::getProgress, {0}, {0}).squash();
                     printProgress(progress);
                     break;
                 }
@@ -1172,7 +1342,7 @@ int DetectorImpl::kbhit() {
 std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     // validate type of file
     bool isPof = false;
-    switch (multi_shm()->multiDetectorType) {
+    switch (detector_shm()->multiDetectorType) {
     case JUNGFRAU:
     case CHIPTESTBOARD:
     case MOENCH:

slsDetectorSoftware/src/DetectorImpl.h

@@ -5,7 +5,6 @@
 #include "logger.h"
 #include "sls_detector_defs.h"
 
-class ZmqSocket;
 class detectorData;
 
 #include <memory>
@@ -15,8 +14,8 @@ class detectorData;
 #include <thread>
 #include <vector>
 
-#define MULTI_SHMAPIVERSION 0x190809
+#define DETECTOR_SHMAPIVERSION 0x190809
-#define MULTI_SHMVERSION 0x200319
+#define DETECTOR_SHMVERSION 0x200319
 #define SHORT_STRING_LENGTH 50
 
 #include <future>
@@ -25,12 +24,13 @@ class detectorData;
 namespace sls{
 
 class Module;
+class Receiver;
 
 /**
  * @short structure allocated in shared memory to store detector settings
  * for IPC and cache
  */
-struct sharedMultiSlsDetector {
+struct sharedDetector {
 
     /* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND
      * ------*/
@@ -47,7 +47,7 @@ struct sharedMultiSlsDetector {
     /** last time stamp when accessing the shared memory */
     char lastDate[SHORT_STRING_LENGTH];
 
-    int numberOfDetectors;
+    int numberOfModules;
     slsDetectorDefs::detectorType multiDetectorType;
 
     /** END OF FIXED PATTERN
@@ -68,12 +68,12 @@ class DetectorImpl : public virtual slsDetectorDefs {
   public:
     /**
      * Constructor
-     * @param id multi detector id
+     * @param detector_id multi detector id
      * @param verify true to verify if shared memory version matches existing
      * one
      * @param update true to update last user pid, date etc
      */
-    explicit DetectorImpl(int multi_id = 0, bool verify = true,
+    explicit DetectorImpl(int detector_id = 0, bool verify = true,
                               bool update = true);
 
     /**
@@ -189,14 +189,460 @@ class DetectorImpl : public virtual slsDetectorDefs {
     }
 
 
+
+
+
+
+
+
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel1(RT (sls::Receiver::*somefunc)(CT...),
+                             std::vector<int> dPositions,
+                             std::vector<int> rxPositions,
+                             typename NonDeduced<CT>::type... Args) {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<RT>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(dPositions.size() * rxPositions.size());
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel1(RT (sls::Receiver::*somefunc)(CT...) const,
+                             std::vector<int> dPositions,
+                             std::vector<int> rxPositions,
+                             typename NonDeduced<CT>::type... Args) const {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<RT>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(dPositions.size() * rxPositions.size());
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename... CT>
+    void Parallel1(void (sls::Receiver::*somefunc)(CT...),
+                std::vector<int> dPositions,
+                std::vector<int> rxPositions,
+                typename NonDeduced<CT>::type... Args) {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<void>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+    template <typename... CT>
+    void Parallel1(void (sls::Receiver::*somefunc)(CT...) const,
+                std::vector<int> dPositions,
+                std::vector<int> rxPositions,
+                typename NonDeduced<CT>::type... Args) const {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<void>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel2(RT (sls::Receiver::*somefunc)(CT...),
+                             std::vector<int> dPositions,
+                             std::vector<int> rxPositions,
+                             typename NonDeduced<CT>::type... Args) {
+
+        if (receivers2.size() == 0) 
+            throw sls::RuntimeError("No receivers2 added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers2.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers2[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<RT>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers2.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(dPositions.size() * rxPositions.size());
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel2(RT (sls::Receiver::*somefunc)(CT...) const,
+                             std::vector<int> dPositions,
+                             std::vector<int> rxPositions,
+                             typename NonDeduced<CT>::type... Args) const {
+
+        if (receivers2.size() == 0) 
+            throw sls::RuntimeError("No receivers2 added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers2.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers2[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<RT>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers2.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(dPositions.size() * rxPositions.size());
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename... CT>
+    void Parallel2(void (sls::Receiver::*somefunc)(CT...),
+                std::vector<int> dPositions,
+                std::vector<int> rxPositions,
+                typename NonDeduced<CT>::type... Args) {
+
+        if (receivers2.size() == 0) 
+            throw sls::RuntimeError("No receivers2 added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers2.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers2[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<void>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers2.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+    template <typename... CT>
+    void Parallel2(void (sls::Receiver::*somefunc)(CT...) const,
+                std::vector<int> dPositions,
+                std::vector<int> rxPositions,
+                typename NonDeduced<CT>::type... Args) const {
+
+        if (receivers2.size() == 0) 
+            throw sls::RuntimeError("No receivers2 added");                      
+        if (dPositions.empty() ||
+            (dPositions.size() == 1 && dPositions[0] == -1)) {
+            dPositions.resize(receivers2.size());
+            std::iota(begin(dPositions), end(dPositions), 0);
+        }
+        if (rxPositions.empty() ||
+            (rxPositions.size() == 1 && rxPositions[0] == -1)) {
+            rxPositions.resize(receivers2[0].size());
+            std::iota(begin(rxPositions), end(rxPositions), 0);
+        }
+        std::vector<std::future<void>> futures;
+        futures.reserve(dPositions.size() * rxPositions.size());
+        for (size_t i : dPositions) {
+            if (i >= receivers2.size())
+                throw sls::RuntimeError("Detector out of range");
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+
+
+
+
+    // for all , but dont complain if receiver2 doesnt exist
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel3(RT (sls::Receiver::*somefunc)(CT...),
+                             typename NonDeduced<CT>::type... Args) {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");  
+        std::vector<int> dPositions;
+        dPositions.resize(receivers.size()); 
+        std::iota(begin(dPositions), end(dPositions), 0);
+        std::vector<int> rxPositions;
+        rxPositions.resize(receivers[0].size());
+        std::iota(begin(rxPositions), end(rxPositions), 0);
+        // multiply by 2 if receivers2 exists
+        size_t futureSize = dPositions.size() * rxPositions.size() * 
+            (receivers2.size() > 0 ? 2 : 1);
+        std::vector<std::future<RT>> futures;
+        futures.reserve(futureSize);
+        for (size_t i : dPositions) {
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+                 if (receivers2.size()) {
+                    futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));                                        
+                }                                       
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(futureSize);
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename RT, typename... CT>
+    sls::Result<RT> Parallel3(RT (sls::Receiver::*somefunc)(CT...) const,
+                             typename NonDeduced<CT>::type... Args) const {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");  
+        std::vector<int> dPositions;
+        dPositions.resize(receivers.size()); 
+        std::iota(begin(dPositions), end(dPositions), 0);
+        std::vector<int> rxPositions;
+        rxPositions.resize(receivers[0].size());
+        std::iota(begin(rxPositions), end(rxPositions), 0);
+        // multiply by 2 if receivers2 exists
+        size_t futureSize = dPositions.size() * rxPositions.size() * 
+            (receivers2.size() > 0 ? 2 : 1);
+        std::vector<std::future<RT>> futures;
+        futures.reserve(futureSize);
+        for (size_t i : dPositions) {
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+                if (receivers2.size()) {
+                    futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));                                        
+                }
+            }
+        }
+        sls::Result<RT> result;
+        result.reserve(futureSize);
+        for (auto &i : futures) {
+            result.push_back(i.get());
+        }
+        return result;
+    }
+
+    template <typename... CT>
+    void Parallel3(void (sls::Receiver::*somefunc)(CT...),
+                typename NonDeduced<CT>::type... Args) {
+
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");  
+        std::vector<int> dPositions;
+        dPositions.resize(receivers.size()); 
+        std::iota(begin(dPositions), end(dPositions), 0);
+        std::vector<int> rxPositions;
+        rxPositions.resize(receivers[0].size());
+        std::iota(begin(rxPositions), end(rxPositions), 0);
+        // multiply by 2 if receivers2 exists
+        size_t futureSize = dPositions.size() * rxPositions.size() * 
+            (receivers2.size() > 0 ? 2 : 1);
+        std::vector<std::future<void>> futures;
+        futures.reserve(futureSize);
+        for (size_t i : dPositions) {
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+                if (receivers2.size()) {
+                    futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));                                        
+                }                                      
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+    template <typename... CT>
+    void Parallel3(void (sls::Receiver::*somefunc)(CT...) const,
+                typename NonDeduced<CT>::type... Args) const {
+        
+        if (receivers.size() == 0) 
+            throw sls::RuntimeError("No receivers added");  
+        std::vector<int> dPositions;
+        dPositions.resize(receivers.size()); 
+        std::iota(begin(dPositions), end(dPositions), 0);
+        std::vector<int> rxPositions;
+        rxPositions.resize(receivers[0].size());
+        std::iota(begin(rxPositions), end(rxPositions), 0);
+        // multiply by 2 if receivers2 exists
+        size_t futureSize = dPositions.size() * rxPositions.size() * 
+            (receivers2.size() > 0 ? 2 : 1);
+        std::vector<std::future<void>> futures;
+        futures.reserve(futureSize);
+        for (size_t i : dPositions) {
+            // each entry
+            for (size_t j : rxPositions) {
+                futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers[i][j].get(), Args...));
+                if (receivers2.size()) {
+                    futures.push_back(std::async(std::launch::async, somefunc,
+                                         receivers2[i][j].get(), Args...));                                        
+                }                                       
+            }
+        }
+        for (auto &i : futures) {
+            i.get();
+        }
+    }
+
+
     /** set acquiring flag in shared memory */
     void setAcquiringFlag(bool flag); 
 
-    /** return multi detector shared memory ID */
+    /** return detector shared memory ID */
-    int getMultiId() const;
+    int getDetectorId() const;
 
     /** Free specific shared memory from the command line without creating object */
-    static void freeSharedMemory(int multiId, int detPos = -1);
+    static void freeSharedMemory(int detectorId, int moduleId = -1);
 
     /** Free all modules from current multi Id shared memory and delete members */
     void freeSharedMemory(); 
@@ -217,8 +663,18 @@ class DetectorImpl : public virtual slsDetectorDefs {
      */
     void setVirtualDetectorServers(const int numdet, const int port);
 
-    /** Sets the hostname of all sls detectors in shared memory and updates local cache */
     void setHostname(const std::vector<std::string> &name); 
+    void setHostname(const std::vector<std::string> &name,
+        const std::vector<int> &port); 
+
+    int getNumberofReceiversPerModule() const;
+    void initReceiver(const int udpInterface);
+    bool isReceiverInitialized(const int udpInterface);
+    void removeReceivers(const int udpInterface);
+    void configureReceiver(const int udpInterface, Positions pos, 
+        const std::string &hostname);
+    void configureReceiver(const int udpInterface, int module_id, 
+        const std::string &hostname, const int port);
 
     /** Gets the total number of detectors */
     int size() const;
@@ -236,13 +692,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
     /** [Eiger][Jungfrau] */
     void setGapPixelsinCallback(const bool enable);
 
-    /**
-     * Enable data streaming to client
-     * @param enable 0 to disable, 1 to enable, -1 to get the value
-     * @returns data streaming to client enable
-     */
-    bool enableDataStreamingToClient(int enable = -1);
-
     /**
      * register callback for accessing acquisition final data
      * @param func function to be called at the end of the acquisition.
@@ -298,7 +747,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
      * one
      * @param update true to update last user pid, date etc
      */
-    void setupMultiDetector(bool verify = true, bool update = true);
+    void setupDetector(bool verify = true, bool update = true);
 
     /**
      * Creates shm and initializes shm structure OR
@@ -324,17 +773,10 @@ class DetectorImpl : public virtual slsDetectorDefs {
     /** Execute command in terminal and return result */
     std::string exec(const char *cmd);
 
-    void addSlsDetector(const std::string &hostname);
+    void addModule(const std::string &hostname, const int port);
 
     void updateDetectorSize();
 
-    /**
-     * 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
@@ -377,19 +819,18 @@ class DetectorImpl : public virtual slsDetectorDefs {
     int kbhit();
 
     /** Multi detector Id */
-    const int multiId{0};
+    const int detectorId{0};
 
     /** Shared Memory object */
-    sls::SharedMemory<sharedMultiSlsDetector> multi_shm{0, -1};
+    sls::SharedMemory<sharedDetector> detector_shm{0, -1};
 
     /** pointers to the Module structures */
     std::vector<std::unique_ptr<sls::Module>> detectors;
 
-    /** data streaming (down stream) enabled in client (zmq sckets created) */
+    /** pointers to the Receiver structures, each row for a module */
-    bool client_downstream{false};
+    std::vector<std::vector<std::unique_ptr<sls::Receiver>>> receivers;
-
+    /** for the second udp port [Eiger][Jungfrau] */
-    /** ZMQ Socket - Receiver to Client */
+    std::vector<std::vector<std::unique_ptr<sls::Receiver>>> receivers2;
-    std::vector<std::unique_ptr<ZmqSocket>> zmqSocket;
 
     /** semaphore to let postprocessing thread continue for next
      * scan/measurement */

slsDetectorSoftware/src/Module.h

@@ -13,8 +13,9 @@
 
 class ServerInterface;
 
-#define SLS_SHMAPIVERSION 0x190726
+#define MODULE_SHMRXVERSION 0x200415
-#define SLS_SHMVERSION 0x200402
+#define MODULE_SHMAPIVERSION 0x190726
+#define MODULE_SHMVERSION 0x200423
 
 namespace sls{
 
@@ -22,7 +23,7 @@ namespace sls{
  * @short structure allocated in shared memory to store detector settings for
  * IPC and cache
  */
-struct sharedSlsDetector {
+struct sharedModule {
 
     /* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/
 
@@ -36,10 +37,13 @@ struct sharedSlsDetector {
     /** detector type  \ see :: detectorType*/
     slsDetectorDefs::detectorType myDetectorType;
 
+    int numberOfReceivers;
+    int numberOfReceivers2;
+
     /** END OF FIXED PATTERN -----------------------------------------------*/
 
     /** Number of detectors in multi list in x dir and y dir */
-    slsDetectorDefs::xy multiSize;
+    slsDetectorDefs::xy detectorSize;
 
     /** is the port used for control functions */
     int controlPort;
@@ -62,27 +66,8 @@ struct sharedSlsDetector {
     /**  number of dacs per module*/
     int nDacs;
 
-    /** ip address/hostname of the receiver for client control via TCP */
-    char rxHostname[MAX_STR_LENGTH];
-
-    /** is the TCP port used to communicate between client and the receiver */
-    int rxTCPPort;
-
-    /** is set if the receiver hostname given and is connected,
-     * unset if socket connection is not possible  */
-    bool useReceiverFlag;
-
-    /** tcp port from gui/different process to receiver (only data) */
-    int zmqport;
-
-    /**  zmq tcp src ip address in client (only data) **/
-    sls::IpAddr zmqip;
-
     /** num udp interfaces */
     int numUDPInterfaces;
-
-    /** stopped flag to inform rxr */
-    bool stoppedFlag;
 };
 
 class Module : public virtual slsDetectorDefs {
@@ -90,22 +75,22 @@ class Module : public virtual slsDetectorDefs {
     /**
      * Constructor called when creating new shared memory
      * @param type detector type
-     * @param multi_id multi detector shared memory id
+     * @param detector_id multi detector shared memory id
-     * @param id sls detector id (position in detectors list)
+     * @param module_id module id (position in detectors list)
      * @param verify true to verify if shared memory version matches existing
      * one
      */
-    explicit Module(detectorType type, int multi_id = 0, int det_id = 0,
+    explicit Module(detectorType type, int detector_id = 0, int module_id = 0,
                          bool verify = true);
 
     /**
      * Constructor called when opening existing shared memory
-     * @param multi_id multi detector shared memory id
+     * @param detector_id multi detector shared memory id
-     * @param id sls detector id (position in detectors list)
+     * @param module_id module id (position in detectors list)
      * @param verify true to verify if shared memory version matches existing
      * one
      */
-    explicit Module(int multi_id = 0, int det_id = 0, bool verify = true);
+    explicit Module(int detector_id = 0, int module_id = 0, bool verify = true);
 
     /**
      * Destructor
@@ -118,11 +103,13 @@ class Module : public virtual slsDetectorDefs {
      */
     bool isFixedPatternSharedMemoryCompatible();
 
-    /**
+    static bool hasSharedMemoryReceiverList(int version);
-     * Check version compatibility with receiver software
-     */
-    void checkReceiverVersionCompatibility();
 
+    int getNumberOfReceivers() const;
+    void setNumberOfReceivers(const int num);
+    int getNumberOfReceivers2() const;
+    void setNumberOfReceivers2(const int num);
+ 
     /**
      * Check version compatibility with detector software
      */
@@ -134,14 +121,9 @@ class Module : public virtual slsDetectorDefs {
 
     int64_t getSerialNumber();
 
-    /**
-     * Get Receiver Software version
-     */
-    int64_t getReceiverSoftwareVersion() const;
-
     /**
      * Free shared memory and delete shared memory structure
-     * occupied by the sharedSlsDetector structure
+     * occupied by the sharedModule structure
      * Is only safe to call if one deletes the Module object afterward
      * and frees multi shared memory/updates
      * thisMultiDetector->numberOfDetectors
@@ -213,12 +195,12 @@ class Module : public virtual slsDetectorDefs {
      * Set Detector offset in shared memory in dimension d
      * @param det detector size
      */
-    void updateMultiSize(slsDetectorDefs::xy det);
+    void updateDetectorSize(slsDetectorDefs::xy det);
 
     int setControlPort(int port_number);
 
     /**
-     * Returns the detector TCP control port  \sa sharedSlsDetector
+     * Returns the detector TCP control port  
      * @returns the detector TCP control port
      */
     int getControlPort() const;
@@ -226,19 +208,11 @@ class Module : public virtual slsDetectorDefs {
     int setStopPort(int port_number);
 
     /**
-     * Returns the detector TCP stop port  \sa sharedSlsDetector
+     * Returns the detector TCP stop port  
      * @returns the detector TCP stop port
      */
     int getStopPort() const;
 
-    int setReceiverPort(int port_number);
-
-    /**
-     * Returns the receiver TCP 	port  \sa sharedSlsDetector
-     * @returns the receiver TCP port
-     */
-    int getReceiverPort() const;
-
     /**
      * Lock server for this client IP
      * @param p 0 to unlock, 1 to lock (-1 gets)
@@ -306,13 +280,13 @@ class Module : public virtual slsDetectorDefs {
                                        int tb = 1);
 
     /**
-     * Returns the detector trimbit/settings directory  \sa sharedSlsDetector
+     * Returns the detector trimbit/settings directory  
      * @returns the trimbit/settings directory
      */
     std::string getSettingsDir();
 
     /**
-     * Sets the detector trimbit/settings directory  \sa sharedSlsDetector
+     * Sets the detector trimbit/settings directory  
      * @param s trimbits/settings directory
      * @returns the trimbit/settings directory
      */
@@ -634,22 +608,9 @@ class Module : public virtual slsDetectorDefs {
      */
     uint32_t clearBit(uint32_t addr, int n);
 
-     /**
+    /** gets receiver parameters from detector and shared memory */
-     * Validates and sets the receiver.
+    rxParameters getReceiverParameters();
-     * Also updates the receiver with all the shared memory parameters
+    
-     * significant for the receiver Also configures the detector to the receiver
-     * as UDP destination
-     * @param receiver receiver hostname or IP address
-     */
-    void setReceiverHostname(const std::string &receiver);
-
-    void test();
-    /**
-     * Returns the receiver IP address\sa sharedSlsDetector
-     * @returns the receiver IP address
-     */
-    std::string getReceiverHostname() const;
-
    /**
      * Validates the format of the detector MAC address and sets it 
      * @param mac detector MAC address
@@ -755,26 +716,26 @@ class Module : public virtual slsDetectorDefs {
     sls::MacAddr getDestinationUDPMAC2();
 
     /**
-     * Sets the receiver UDP port\sa sharedSlsDetector
+     * Sets the receiver UDP port
      * @param udpport receiver UDP port
      */
     void setDestinationUDPPort(int udpport);
 
     /**
-     * Returns the receiver UDP port\sa sharedSlsDetector
+     * Returns the receiver UDP port
      * @returns the receiver UDP port
      */
     int getDestinationUDPPort();
 
     /**
-     * Sets the receiver UDP port 2\sa sharedSlsDetector (Eiger and Jungfrau
+     * Sets the receiver UDP port 2 (Eiger and Jungfrau
      * only)
      * @param udpport receiver UDP port 2
      */
     void setDestinationUDPPort2(int udpport);
 
     /**
-     * Returns the receiver UDP port 2 of same interface\sa sharedSlsDetector
+     * Returns the receiver UDP port 2 of same interface
      * (Eiger and Jungfrau only)
      * @returns the receiver UDP port 2 of same interface
      */
@@ -813,53 +774,7 @@ class Module : public virtual slsDetectorDefs {
      */
     int getSelectedUDPInterface();
 
-    /**
+    std::string printUDPConfiguration();
-     * Sets the client zmq port\sa sharedSlsDetector
-     * @param port client zmq port
-     */
-    void setClientStreamingPort(int port);
-
-    /**
-     * Returns the client zmq port \sa sharedSlsDetector
-     * @returns the client zmq port
-     */
-    int getClientStreamingPort();
-
-    /**
-     * Sets the receiver zmq port\sa sharedSlsDetector
-     * @param port receiver zmq port
-     */
-    void setReceiverStreamingPort(int port);
-
-    /**
-     * Returns the receiver zmq port \sa sharedSlsDetector
-     * @returns the receiver zmq port
-     */
-    int getReceiverStreamingPort();
-
-    /**
-     * Sets the client zmq ip\sa sharedSlsDetector
-     * @param ip client zmq ip
-     */
-    void setClientStreamingIP(const sls::IpAddr ip);
-
-    /**
-     * Returns the client zmq ip \sa sharedSlsDetector
-     * @returns the client zmq ip
-     */
-    sls::IpAddr getClientStreamingIP();
-
-    /**
-     * Sets the receiver zmq ip\sa sharedSlsDetector
-     * @param ip receiver zmq ip
-     */
-    void setReceiverStreamingIP(const sls::IpAddr ip);
-
-    /**
-     * Returns the receiver zmq ip \sa sharedSlsDetector
-     * @returns the receiver zmq ip
-     */
-    sls::IpAddr getReceiverStreamingIP();
 
     /** update receiver stremaing ip from shm to receiver
      * if empty, use rx_hostname ip
@@ -903,35 +818,6 @@ class Module : public virtual slsDetectorDefs {
      */
     void setTransmissionDelayRight(int value);
 
-    /** empty vector deletes entire additional json header */
-    void setAdditionalJsonHeader(const std::map<std::string, std::string> &jsonHeader);
-    std::map<std::string, std::string> getAdditionalJsonHeader();
-
-    /**
-     * Sets the value for the additional json header parameter key if found, else
-     * append it. If value empty, then deletes parameter */
-    void setAdditionalJsonParameter(const std::string &key, const std::string &value);
-    std::string getAdditionalJsonParameter(const std::string &key);
-
-    /**
-     * Sets the receiver UDP socket buffer size
-     * @param udpsockbufsize additional json header
-     * @returns receiver udp socket buffer size
-     */
-    int64_t setReceiverUDPSocketBufferSize(int64_t udpsockbufsize = -1);
-
-    /**
-     * Returns the receiver UDP socket buffer size\sa sharedSlsDetector
-     * @returns the receiver UDP socket buffer size
-     */
-    int64_t getReceiverUDPSocketBufferSize();
-
-    /**
-     * Returns the receiver real UDP socket buffer size\sa sharedSlsDetector
-     * @returns the receiver real UDP socket buffer size
-     */
-    int64_t getReceiverRealUDPSocketBufferSize() const;
-
     /** [Gotthard][Jungfrau][CTB][Moench] */
     void executeFirmwareTest();
 
@@ -1009,28 +895,10 @@ class Module : public virtual slsDetectorDefs {
      */
     slsDetectorDefs::ROI getROI();
 
-    /**
+
-     * Set ADC Enable Mask (CTB, Moench)
-     * @param mask ADC Enable mask
-     */
     void setADCEnableMask(uint32_t mask);
-
-    /**
-     * Get ADC Enable Mask (CTB, Moench)
-     * @returns ADC Enable mask
-     */
     uint32_t getADCEnableMask();
-
-     /**
-     * Set 10Gb  ADC Enable Mask (CTB, Moench)
-     * @param mask ADC Enable mask
-     */
     void setTenGigaADCEnableMask(uint32_t mask);
-
-    /**
-     * Get 10Gb ADC Enable Mask (CTB, Moench)
-     * @returns ADC Enable mask
-     */
     uint32_t getTenGigaADCEnableMask();   
 
     /**
@@ -1077,14 +945,6 @@ class Module : public virtual slsDetectorDefs {
      */
     int getExternalSampling();
 
-    /** digital data bits enable (CTB only) */
-    void setReceiverDbitList(const std::vector<int>& list);
-    std::vector<int> getReceiverDbitList() const;
-
-    /** Set digital data offset in bytes (CTB only) */
-    void setReceiverDbitOffset(int value);
-    int getReceiverDbitOffset();
-
     /**
      * Write to ADC register (Gotthard, Jungfrau, ChipTestBoard). For expert
      * users
@@ -1093,32 +953,10 @@ class Module : public virtual slsDetectorDefs {
      */
     void writeAdcRegister(uint32_t addr, uint32_t val);
 
-    /**
+    /** [Eiger] */
-     * Activates/Deactivates the detector (Eiger only)
+    bool getActivate();
-     * @param enable active (1) or inactive (0), -1 gets
+    /** [Eiger] */
-     * @returns 0 (inactive) or 1 (active)for activate mode
+    void setActivate(const bool enable);
-     */
-    int activate(int const enable = -1);
-
-    bool getDeactivatedRxrPaddingMode();
-
-    /**
-     * Set deactivated Receiver padding mode (Eiger only)
-     */
-    void setDeactivatedRxrPaddingMode(bool padding);
-
-    /**
-     * Returns the enable if data will be flipped across x axis (Eiger)
-     * @returns if flipped across x axis
-     */
-    bool getFlippedDataX();
-
-    /**
-     * Sets the enable which determines if
-     * data will be flipped across x axis (Eiger)
-     * @param value 0 or 1 to reset/set 
-     */
-    void setFlippedDataX(bool value);
 
     /**
      * Sets all the trimbits to a particular value (Eiger)
@@ -1129,7 +967,6 @@ class Module : public virtual slsDetectorDefs {
 
     /**
      * Sets the number of trim energies and their value  (Eiger)
-     * \sa sharedSlsDetector
      * @param nen number of energies
      * @param vector os trimmed energies
      * @returns number of trim energies
@@ -1138,7 +975,6 @@ class Module : public virtual slsDetectorDefs {
 
     /**
      * Returns a vector with the trimmed energies  (Eiger)
-     * \sa sharedSlsDetector
      * @returns vector with the trimmed energies
      */
     std::vector<int> getTrimEn();
@@ -1287,149 +1123,8 @@ class Module : public virtual slsDetectorDefs {
      */
     void updateRateCorrection();
 
-    /**
+    bool getTenGiga();
-     * Prints receiver configuration
+    void setTenGiga(bool value);
-     * @returns receiver configuration
-     */
-    std::string printReceiverConfiguration();
-
-    /**
-     * Gets the use receiver flag from shared memory
-     */
-    bool getUseReceiverFlag() const;
-
-    /**
-     * Locks/Unlocks the connection to the receiver
-     * @param lock sets (1), usets (0), gets (-1) the lock
-     * @returns lock status of the receiver
-     */
-    int lockReceiver(int lock = -1);
-
-    /**
-     * Returns the IP of the last client connecting to the receiver
-     * @returns the IP of the last client connecting to the receiver
-     */
-    sls::IpAddr getReceiverLastClientIP() const;
-
-    /**
-     * Exits the receiver TCP server
-     */
-    void exitReceiver();
-
-    /**
-     * Executes a system command on the receiver server
-     * e.g. mount an nfs disk, reboot and returns answer etc.
-     * @param cmd command to be executed
-     */
-    void execReceiverCommand(const std::string &cmd);
-
-    std::string getFilePath();
-    void setFilePath(const std::string &path);
-    std::string getFileName();
-    void setFileName(const std::string &fname);
-    int64_t getFileIndex();
-    void setFileIndex(int64_t file_index);
-    void incrementFileIndex();
-    fileFormat getFileFormat() ;
-    void setFileFormat(fileFormat f);
-    int getFramesPerFile();
-    /** 0 will set frames per file to unlimited */
-    void setFramesPerFile(int n_frames);
-    frameDiscardPolicy getReceiverFramesDiscardPolicy();
-    void setReceiverFramesDiscardPolicy(frameDiscardPolicy f);
-    bool getPartialFramesPadding();
-    void setPartialFramesPadding(bool padding);
-
-
-    /**
-     * Receiver starts listening to packets
-     */
-    void startReceiver();
-
-    /**
-     * Stops the listening mode of receiver
-     */
-    void stopReceiver();
-
-    /**
-     * Gets the status of the listening mode of receiver
-     * @returns status
-     */
-    runStatus getReceiverStatus() const;
-
-    /**
-     * Gets the number of frames caught by receiver
-     * @returns number of frames caught by receiver
-     */
-    int64_t getFramesCaughtByReceiver() const;
-
-    /** Gets number of missing packets */
-    std::vector<uint64_t> getNumMissingPackets() const;
-
-    /**
-     * Gets the current frame index of receiver
-     * @returns current frame index of receiver
-     */
-    uint64_t getReceiverCurrentFrameIndex() const;
-    int getReceiverProgress() const;
-
-
-    void setFileWrite(bool value);
-    bool getFileWrite();
-    void setMasterFileWrite(bool value);
-    bool getMasterFileWrite();
-    void setFileOverWrite(bool value);
-    bool getFileOverWrite();
-
-    int getReceiverStreamingFrequency();
-
-    /**
-     * (previously setReadReceiverFrequency)
-     * Sets the receiver streaming frequency
-     * @param freq nth frame streamed out, if 0, streamed out at a timer of 200
-     * ms
-     * @param detPos -1 for all detectors in  list or specific detector position
-     */
-    void setReceiverStreamingFrequency(int freq);
-
-    /**
-     * (previously setReceiverReadTimer)
-     * Sets the receiver streaming timer
-     * If receiver streaming frequency is 0, then this timer between each
-     * data stream is set. Default is 200 ms.
-     * @param time_in_ms timer between frames
-     * @returns receiver streaming timer in ms
-     */
-    int setReceiverStreamingTimer(int time_in_ms = 200);
-
-    bool getReceiverStreaming();
-
-    void setReceiverStreaming(bool enable);
-
-    /**
-     * Enable/disable or 10Gbe
-     * @param i is -1 to get, 0 to disable and 1 to enable
-     * @returns if 10Gbe is enabled
-     */
-    bool enableTenGigabitEthernet(int value = -1);
-
-    /**
-     * Set/get receiver fifo depth
-     * @param i is -1 to get, any other value to set the fifo deph
-     * @returns the receiver fifo depth
-     */
-    int setReceiverFifoDepth(int n_frames = -1);
-
-    bool getReceiverSilentMode();
-    void setReceiverSilentMode(bool enable);
-
-    /**
-     * If data streaming in receiver is enabled,
-     * restream the stop dummy packet from receiver
-     * Used usually for Moench,
-     * in case it is lost in network due to high data rate
-     */
-    void restreamStopFromReceiver();
 
     /**
      * Opens pattern file and sends pattern to CTB
@@ -1630,67 +1325,23 @@ class Module : public virtual slsDetectorDefs {
 
     void sendToDetectorStop(int fnum) const;
 
-    /**
-     * Send function parameters to receiver
-     * @param fnum function enum
-     * @param args argument pointer
-     * @param args_size size of argument
-     * @param retval return pointers
-     * @param retval_size size of return value
-     */
-    void sendToReceiver(int fnum, const void *args, size_t args_size,
-                        void *retval, size_t retval_size);
-
-    void sendToReceiver(int fnum, const void *args, size_t args_size,
-                        void *retval, size_t retval_size) const;
-
-    template <typename Arg, typename Ret>
-    void sendToReceiver(int fnum, const Arg &args, Ret &retval);
-
-    template <typename Arg, typename Ret>
-    void sendToReceiver(int fnum, const Arg &args, Ret &retval) const;
-
-    template <typename Arg>
-    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t);
-
-    template <typename Arg>
-    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t) const;
-
-    template <typename Ret>
-    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval);
-
-    template <typename Ret>
-    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval) const;
-
-    template <typename Ret>
-    Ret sendToReceiver(int fnum);
-
-    template <typename Ret>
-    Ret sendToReceiver(int fnum) const;
-
-    template <typename Ret, typename Arg>
-    Ret sendToReceiver(int fnum, const Arg &args);
-
-    template <typename Ret, typename Arg>
-    Ret sendToReceiver(int fnum, const Arg &args) const;
-
     /**
      * Get Detector Type from Shared Memory (opening shm without verifying size)
-     * @param multi_id multi detector Id
+     * @param detector_id multi detector Id
      * @param verify true to verify if shm size matches existing one
      * @returns detector type
      */
-    detectorType getDetectorTypeFromShm(int multi_id, bool verify = true);
+    detectorType getDetectorTypeFromShm(int detector_id, bool verify = true);
 
     /**
      * Initialize shared memory
      * @param created true if shared memory must be created, else false to open
      * @param type type of detector
-     * @param multi_id multi detector Id
+     * @param detector_id multi detector Id
      * @param verify true to verify if shm size matches existing one
      * @returns true if the shared memory was created now
      */
-    void initSharedMemory(detectorType type, int multi_id, bool verify = true);
+    void initSharedMemory(detectorType type, int detector_id, bool verify = true);
 
     /**
      * Initialize detector structure to defaults
@@ -1773,10 +1424,10 @@ class Module : public virtual slsDetectorDefs {
     std::vector<std::string> getSettingsFileDacNames();
 
     /** Module Id or position in the detectors list */
-    const int detId;
+    const int moduleId;
 
     /** Shared Memory object */
-    mutable sls::SharedMemory<sharedSlsDetector> shm{0, 0};
+    mutable sls::SharedMemory<sharedModule> shm{0, 0};
 };
 
 }// sls

slsDetectorSoftware/src/Receiver.cpp

@@ -0,0 +1,918 @@
+#include "Receiver.h"
+#include "ClientSocket.h"
+#include "ZmqSocket.h"
+#include "FixedCapacityContainer.h"
+#include "string_utils.h"
+#include "versionAPI.h"
+#include "ToString.h"
+
+#include "container_utils.h"
+
+namespace sls {
+
+// create shm
+Receiver::Receiver(int detector_id, int module_id,  int interface_id, 
+    int receiver_id, int tcp_port, std::string hostname,
+    int zmq_port) :
+    receiverId(receiver_id), interfaceId(interface_id), moduleId(module_id), 
+    shm(detector_id, module_id, interface_id, receiver_id) {
+    createIndexString();   
+
+    // ensure shared memory was not created before
+    if (shm.IsExisting()) {
+        LOG(logWARNING) << "This shared memory should have been deleted "
+        "before! " << shm.GetName() << ". Freeing it again";
+        shm.RemoveSharedMemory();
+    }
+    shm = SharedMemory<sharedReceiver>(detector_id, module_id, interface_id,
+        receiver_id);
+    shm.CreateSharedMemory();
+
+    // initalize receiver structure
+    shm()->shmversion = RECEIVER_SHMVERSION;
+    memset(shm()->hostname, 0, MAX_STR_LENGTH);
+    shm()->tcpPort = DEFAULT_RX_PORTNO + receiver_id;
+    shm()-> stoppedFlag = false;
+    shm()->zmqPort = DEFAULT_ZMQ_RX_PORTNO + receiver_id;
+    shm()->zmqIp = IpAddr{};
+
+    // copy port, hostname if given
+    if (tcp_port != 0) {
+        setTCPPort(tcp_port);
+    }
+    if (zmq_port != 0) {
+        shm()->zmqPort = zmq_port;
+    }
+    if (!hostname.empty()) {
+        setHostname(hostname);
+    }
+}
+
+// open shm
+Receiver::Receiver(int detector_id, int module_id,  int interface_id, 
+    int receiver_id, bool verify) :
+    receiverId(receiver_id), interfaceId(interface_id), moduleId(module_id),
+    shm(detector_id, module_id, interface_id, receiver_id) {
+    createIndexString();   
+
+    shm.OpenSharedMemory();
+    if (verify && shm()->shmversion != RECEIVER_SHMVERSION) {
+        std::ostringstream ss;
+        ss << "Receiver shared memory (" << detector_id << "-" << indexString
+            << ":" << receiverId << ") version mismatch (expected 0x" << std::hex
+            << RECEIVER_SHMVERSION << " but got 0x" << shm()->shmversion << ")"
+            << std::dec << ". Clear Shared memory to continue.";
+        throw SharedMemoryError(ss.str());
+    }
+}
+
+Receiver::~Receiver() = default;
+
+void Receiver::createIndexString() {
+    std::ostringstream oss;
+    oss << '(' << moduleId << (char)(interfaceId + 97) << "." << receiverId << ')';
+    indexString = oss.str();
+}
+
+/** Configuration */
+
+void Receiver::freeSharedMemory() {
+    if (shm.IsExisting()) {
+        shm.RemoveSharedMemory();
+    }
+}
+
+std::string Receiver::getHostname() const {
+    return shm()->hostname;
+}
+
+void Receiver::setHostname(const std::string &hostname) {
+    if (hostname.empty()) {
+        throw RuntimeError("Invalid receiver hostname. Cannot be empty.");
+    }
+    sls::strcpy_safe(shm()->hostname, hostname.c_str());
+    checkVersionCompatibility();
+}
+
+int Receiver::getTCPPort() const {
+    return shm()->tcpPort;
+}
+
+void Receiver::setTCPPort(const int port) {
+    LOG(logDEBUG1) << "Setting reciever port to " << port;
+    if (port >= 0 && port != shm()->tcpPort) {
+        if (strlen(shm()->hostname) != 0) {
+            int retval = -1;
+            sendToReceiver(F_SET_RECEIVER_PORT, port, retval);
+            shm()->tcpPort = retval;
+            LOG(logDEBUG1) << "Receiver port: " << retval;
+        } else {
+            shm()->tcpPort = port;
+        }
+    }
+}
+
+void Receiver::checkVersionCompatibility() {
+    int64_t arg = APIRECEIVER;
+    LOG(logDEBUG1)
+        << "Checking version compatibility with receiver with value "
+        << std::hex << arg << std::dec;
+    sendToReceiver(F_RECEIVER_CHECK_VERSION, arg, nullptr);
+}
+
+sls::MacAddr Receiver::configure(slsDetectorDefs::rxParameters arg) {
+    // hostname
+    memset(arg.hostname, 0, sizeof(arg.hostname));
+    strcpy_safe(arg.hostname, shm()->hostname);
+    // interface id
+    arg.interfaceId = interfaceId;
+    // zmqip
+    {
+        sls::IpAddr ip;
+        // Hostname could be ip try to decode otherwise look up the hostname
+        ip = sls::IpAddr{shm()->hostname};
+        if (ip == 0) {
+            ip = HostnameToIp(shm()->hostname);
+        }  
+        LOG(logINFO) << "Setting default receiver " << indexString 
+            << " streaming zmq ip to " << ip;  
+        // if client zmqip is empty, update it
+        if (shm()->zmqIp == 0) {
+            shm()->zmqIp = ip;
+        }   
+        memcpy(&arg.zmq_ip, &ip, sizeof(ip));
+    } 
+
+    if (arg.detType == EIGER) {
+        arg.udpInterfaces = 2;        
+    }
+
+    LOG(logDEBUG) 
+        << "detType:" << arg.detType << std::endl
+        << "detectorSize.x:" << arg.detectorSize.x << std::endl
+        << "detectorSize.y:" << arg.detectorSize.y << std::endl
+        << "moduleId:" << arg.moduleId << std::endl
+        << "hostname:" << arg.hostname << std::endl
+        << "interfaceId: " << arg.interfaceId << std::endl
+        << "zmq ip:" << arg.zmq_ip << std::endl
+        << "udpInterfaces:" << arg.udpInterfaces << std::endl
+        << "udp_dstport:" << arg.udp_dstport << std::endl
+        << "udp_dstip:" << sls::IpAddr(arg.udp_dstip) << std::endl
+        << "udp_dstmac:" << sls::MacAddr(arg.udp_dstmac) << std::endl
+        << "udp_dstport2:" << arg.udp_dstport2 << std::endl
+        << "udp_dstip2:" << sls::IpAddr(arg.udp_dstip2) << std::endl
+        << "udp_dstmac2:" << sls::MacAddr(arg.udp_dstmac2) << std::endl
+        << "frames:" << arg.frames << std::endl
+        << "triggers:" << arg.triggers << std::endl
+        << "bursts:" << arg.bursts << std::endl
+        << "analogSamples:" << arg.analogSamples << std::endl
+        << "digitalSamples:" << arg.digitalSamples << std::endl
+        << "expTimeNs:" << arg.expTimeNs << std::endl
+        << "periodNs:" << arg.periodNs << std::endl
+        << "subExpTimeNs:" << arg.subExpTimeNs << std::endl
+        << "subDeadTimeNs:" << arg.subDeadTimeNs << std::endl
+        << "activate:" << arg.activate << std::endl
+        << "quad:" << arg.quad << std::endl
+        << "dynamicRange:" << arg.dynamicRange << std::endl
+        << "timMode:" << arg.timMode << std::endl
+        << "tenGiga:" << arg.tenGiga << std::endl
+        << "roMode:" << arg.roMode << std::endl
+        << "adcMask:" << arg.adcMask << std::endl
+        << "adc10gMask:" << arg.adc10gMask << std::endl
+        << "roi.xmin:" << arg.roi.xmin << std::endl
+        << "roi.xmax:" << arg.roi.xmax << std::endl
+        << "countermask:" << arg.countermask << std::endl
+        << "burstType:" << arg.burstType << std::endl;
+
+    sls::MacAddr mac;
+    {
+        sls::MacAddr retval;
+        sendToReceiver(F_SETUP_RECEIVER, arg, retval);
+        // detector does not have customized udp mac
+        if (arg.udp_dstmac == 0) {
+            mac = retval;
+        }
+    } 
+    if (arg.detType == MOENCH) {
+        setAdditionalJsonParameter("adcmask_1g", std::to_string(arg.adcMask));
+        setAdditionalJsonParameter("adcmask_10g", std::to_string(arg.adc10gMask));
+    }
+
+    LOG(logINFOBLUE) <<  "reciever " << indexString << " configured!";
+    return mac;
+}
+
+std::string Receiver::printConfiguration() {
+    std::ostringstream oss;
+    
+    oss << std::endl << std::endl
+        << "Receiver " << indexString << std::endl
+        << "Hostname : " << shm()->hostname << std::endl
+        << "Tcp port : " << shm()->tcpPort << std::endl;
+
+        
+    /*
+        
+    os << "\nReceiver UDP IP:\t" 
+       << getDestinationUDPIP() << "\nReceiver UDP MAC:\t" << getDestinationUDPMAC();
+
+    if (shm()->myDetectorType == JUNGFRAU) {
+        os << "\nDetector UDP IP2:\t" << getSourceUDPIP2() 
+       << "\nDetector UDP MAC2:\t" << getSourceUDPMAC2()
+       << "\nReceiver UDP IP2:\t" << getDestinationUDPIP2()      
+       << "\nReceiver UDP MAC2:\t" << getDestinationUDPMAC2();
+    }
+    os << "\nReceiver UDP Port:\t" << getDestinationUDPPort();
+    if (shm()->myDetectorType == JUNGFRAU || shm()->myDetectorType == EIGER) {
+       os << "\nReceiver UDP Port2:\t" << getDestinationUDPPort2();
+    }
+    */
+    oss << "\n";
+    return oss.str();
+}
+
+int64_t Receiver::getSoftwareVersion() const {
+    LOG(logDEBUG1) << "Getting receiver software version";
+    return sendToReceiver<int64_t>(F_GET_RECEIVER_VERSION);
+}
+
+/** Acquisition */
+
+void Receiver::start() {
+    LOG(logDEBUG1) << "Starting Receiver";
+    shm()->stoppedFlag = false;
+    sendToReceiver(F_START_RECEIVER, nullptr, nullptr);
+}
+
+void Receiver::stop() {
+    LOG(logDEBUG1) << "Stopping Receiver";
+    int arg = static_cast<int>(shm()->stoppedFlag);
+    sendToReceiver(F_STOP_RECEIVER, arg, nullptr);
+}
+
+slsDetectorDefs::runStatus Receiver::getStatus() const {
+    runStatus retval = ERROR;
+    LOG(logDEBUG1) << "Getting Receiver Status";
+    sendToReceiver(F_GET_RECEIVER_STATUS, nullptr, retval);
+    LOG(logDEBUG1) << "Receiver Status: " << ToString(retval);
+    return retval;
+}
+
+int Receiver::getProgress() const {
+    int retval = -1;
+    sendToReceiver(F_GET_RECEIVER_PROGRESS, nullptr, retval);
+    LOG(logDEBUG1) << "Current Progress of Receiver: " << retval;
+    return retval;
+}
+
+void Receiver::setStoppedFlag() {
+    shm()->stoppedFlag = true;
+}
+
+void Receiver::restreamStop() {
+    LOG(logDEBUG1) << "Restream stop dummy from Receiver via zmq";
+    sendToReceiver(F_RESTREAM_STOP_FROM_RECEIVER, nullptr, nullptr);
+}
+
+
+uint64_t Receiver::getFramesCaught() const {
+    return sendToReceiver<uint64_t>(F_GET_RECEIVER_FRAMES_CAUGHT);
+}
+
+uint64_t Receiver::getNumMissingPackets() const {
+    return sendToReceiver<uint64_t>(F_GET_NUM_MISSING_PACKETS);    
+}
+
+uint64_t Receiver::getCurrentFrameIndex() const {
+    return sendToReceiver<uint64_t>(F_GET_RECEIVER_FRAME_INDEX);
+}
+
+/** Network Configuration (Detector<->Receiver) */
+
+sls::MacAddr Receiver::setUDPIP(const IpAddr ip) {
+    LOG(logDEBUG1) << "Setting udp ip to receier: " << ip;
+    if (ip == 0) {
+        throw RuntimeError("Invalid destination udp ip address");
+    }
+    sls::MacAddr retval(0LU);
+    sendToReceiver(F_SET_RECEIVER_UDP_IP, ip, retval);
+    return retval;
+}
+
+void Receiver::setUDPPort(const int port) {
+    LOG(logDEBUG1) << "Setting udp port to  receiver: " << port;
+    sendToReceiver(F_SET_RECEIVER_UDP_PORT, port, nullptr); 
+}
+
+int64_t Receiver::getUDPSocketBufferSize() const {
+    return sendToReceiver<int64_t>(F_GET_RECEIVER_UDP_SOCK_BUF_SIZE);
+}
+
+void Receiver::setUDPSocketBufferSize(int64_t value) {
+    LOG(logDEBUG1) << "Sending UDP Socket Buffer size to receiver: "
+                        << value;
+    sendToReceiver(F_SET_RECEIVER_UDP_SOCK_BUF_SIZE, value, nullptr);
+}
+
+int64_t Receiver::getRealUDPSocketBufferSize() const {
+    return sendToReceiver<int64_t>(F_GET_RECEIVER_REAL_UDP_SOCK_BUF_SIZE);
+}
+
+/** ZMQ Streaming Parameters (Receiver<->Client) */
+
+bool Receiver::getZmq() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_STREAMING);
+}
+
+void Receiver::setZmq(const bool enable) {
+    int arg = static_cast<int>(enable);
+    sendToReceiver(F_SET_RECEIVER_STREAMING, arg, nullptr);
+}
+
+int Receiver::getZmqFrequency() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_STREAMING_FREQUENCY);
+}
+
+void Receiver::setZmqFrequency(const int freq) {
+    if (freq < 0) {
+        throw RuntimeError("Invalid streaming frequency " + std::to_string(freq));
+    }
+    sendToReceiver(F_SET_RECEIVER_STREAMING_FREQUENCY, freq, nullptr);
+}
+
+int Receiver::getZmqTimer() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_STREAMING_TIMER);
+}
+
+void Receiver::setZmqTimer(const int time_in_ms) {
+    sendToReceiver(F_SET_RECEIVER_STREAMING_TIMER, time_in_ms, nullptr);
+}
+
+int Receiver::getZmqPort() const {    
+    return sendToReceiver<int>(F_GET_RECEIVER_STREAMING_PORT);
+}
+
+void Receiver::setZmqPort(int port) {
+    sendToReceiver(F_SET_RECEIVER_STREAMING_PORT, port, nullptr);
+}
+
+sls::IpAddr Receiver::getZmqIP() const {
+    return sendToReceiver<sls::IpAddr>(F_GET_RECEIVER_STREAMING_SRC_IP);
+}
+
+void Receiver::setZmqIP(const sls::IpAddr ip) {
+    if (ip == 0) {
+        throw RuntimeError("Invalid receiver zmq ip address");
+    }
+   
+    // if client zmqip is empty, update it
+    if (shm()->zmqIp == 0) {
+        shm()->zmqIp = ip;
+    }
+    sendToReceiver(F_SET_RECEIVER_STREAMING_SRC_IP, ip, nullptr);
+}
+
+int Receiver::getClientZmqPort() const { 
+    return shm()->zmqPort; 
+}
+
+void Receiver::setClientZmqPort(const int port) { 
+    shm()->zmqPort = port;
+}
+
+sls::IpAddr Receiver::getClientZmqIP() const { 
+    return shm()->zmqIp; 
+}
+
+void Receiver::setClientZmqIP(const sls::IpAddr ip) {
+    LOG(logDEBUG1) << "Setting client zmq ip to " << ip;
+    if (ip == 0) {
+        throw RuntimeError("Invalid client zmq ip address");
+    } 
+    shm()->zmqIp = ip;  
+}
+
+bool Receiver::getClientZmq() const {
+    return (zmqSocket != nullptr);
+}
+
+void Receiver::setClientZmq(const bool enable) {
+    // destroy
+    if (!enable) {
+        if (zmqSocket != nullptr) {
+            zmqSocket.reset();
+        }
+    }
+    // create
+    else {
+        if (zmqSocket == nullptr) {
+            try {
+                zmqSocket = sls::make_unique<ZmqSocket>(
+                    shm()->zmqIp.str().c_str(), shm()->zmqPort);
+                LOG(logINFO) << "Zmq Client[" << indexString << "] at "
+                    << zmqSocket->GetZmqServerAddress();
+            } catch(...) {
+            throw RuntimeError(
+                "Could not create Zmq socket [" + indexString 
+                + " on port " + std::to_string(shm()->zmqPort));
+            }
+        }
+    }
+}
+
+ZmqSocket* Receiver::getZmqSocket() {
+    return zmqSocket.get();
+}
+
+/** Receiver Parameters */
+
+bool Receiver::getLock() const {
+    return sendToReceiver<int>(F_GET_LOCK_RECEIVER);
+}
+
+void Receiver::setLock(const bool lock) {
+    LOG(logDEBUG1) << "Setting receiver server lock to " << lock;
+    sendToReceiver(F_SET_LOCK_RECEIVER, lock, nullptr);
+}
+
+sls::IpAddr Receiver::getLastClientIP() const {
+    return sendToReceiver<sls::IpAddr>(F_GET_LAST_RECEIVER_CLIENT_IP);
+}
+
+void Receiver::exitServer() {
+    LOG(logDEBUG1) << "Sending exit command to receiver server";
+    sendToReceiver(F_EXIT_RECEIVER, nullptr, nullptr);
+}
+
+bool Receiver::getDeactivatedPaddingMode() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_DEACTIVATED_PADDING);
+}
+
+void Receiver::setDeactivatedPaddingMode(const bool padding) {
+    int arg = static_cast<int>(padding);
+    sendToReceiver(F_SET_RECEIVER_DEACTIVATED_PADDING, arg, nullptr);
+}
+
+bool Receiver::getFlippedDataX() const { 
+    int arg = -1;
+    return sendToReceiver<int>(F_GET_FLIPPED_DATA_RECEIVER, arg);
+}
+
+void Receiver::setFlippedDataX(const bool value) {
+    int arg = static_cast<int>(value);
+    LOG(logDEBUG1) << "Setting flipped data across x axis with value: "
+                        << value;
+    sendToReceiver(F_SET_FLIPPED_DATA_RECEIVER, arg, nullptr);
+}
+
+slsDetectorDefs::frameDiscardPolicy Receiver::getFramesDiscardPolicy() const {
+    return static_cast<frameDiscardPolicy>(
+        sendToReceiver<int>(F_GET_RECEIVER_DISCARD_POLICY));    
+}
+
+void Receiver::setFramesDiscardPolicy(const frameDiscardPolicy f) {
+    int arg = static_cast<int>(f);
+    sendToReceiver(F_SET_RECEIVER_DISCARD_POLICY, arg, nullptr);    
+}
+
+bool Receiver::getPartialFramesPadding() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_PADDING);    
+}
+
+void Receiver::setPartialFramesPadding(const bool padding) {
+    int arg = static_cast<int>(padding);
+    sendToReceiver(F_SET_RECEIVER_PADDING, arg, nullptr);        
+}
+
+int Receiver::getFifoDepth() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_FIFO_DEPTH);    
+}
+
+void Receiver::setFifoDepth(const int value) {
+    sendToReceiver(F_SET_RECEIVER_FIFO_DEPTH, value, nullptr);
+}
+
+bool Receiver::getSilentMode() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_SILENT_MODE);
+}
+
+void Receiver::setSilentMode(const bool enable) {
+    int arg = static_cast<int>(enable);
+    sendToReceiver(F_SET_RECEIVER_SILENT_MODE, arg, nullptr);
+}
+
+/** File */
+
+std::string Receiver::getFilePath() const {
+    char retvals[MAX_STR_LENGTH]{};
+    sendToReceiver(F_GET_RECEIVER_FILE_PATH, nullptr, retvals);
+    return std::string(retvals);
+}
+
+void Receiver::setFilePath(const std::string &path) {
+    if (path.empty()) {
+        throw RuntimeError("Cannot set empty file path");
+    }
+    char args[MAX_STR_LENGTH]{};
+    sls::strcpy_safe(args, path.c_str());
+    sendToReceiver(F_SET_RECEIVER_FILE_PATH, args, nullptr);
+}
+
+std::string Receiver::getFileName() const {
+    char retvals[MAX_STR_LENGTH]{};
+    sendToReceiver(F_GET_RECEIVER_FILE_NAME, nullptr, retvals);
+    return std::string(retvals);
+}
+
+void Receiver::setFileName(const std::string &fname) {
+    if (fname.empty()) {
+        throw RuntimeError("Cannot set empty file name prefix");
+    }
+    char args[MAX_STR_LENGTH]{};
+    sls::strcpy_safe(args, fname.c_str());
+    sendToReceiver(F_SET_RECEIVER_FILE_NAME, args, nullptr);
+}
+
+int64_t Receiver::getFileIndex() const { 
+    return sendToReceiver<int64_t>(F_GET_RECEIVER_FILE_INDEX);
+}
+
+void Receiver::setFileIndex(const int64_t file_index) {
+    sendToReceiver(F_SET_RECEIVER_FILE_INDEX, file_index, nullptr);
+}
+
+void Receiver::incrementFileIndex() {
+    sendToReceiver(F_INCREMENT_FILE_INDEX, nullptr, nullptr);
+}
+
+slsDetectorDefs::fileFormat Receiver::getFileFormat() const {
+    return static_cast<fileFormat>(
+        sendToReceiver<int>(F_GET_RECEIVER_FILE_FORMAT)); 
+}
+
+void Receiver::setFileFormat(const fileFormat f) {
+    int arg = static_cast<int>(f);
+    sendToReceiver(F_SET_RECEIVER_FILE_FORMAT, arg, nullptr);
+}
+
+int Receiver::getFramesPerFile() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_FRAMES_PER_FILE);
+}
+
+void Receiver::setFramesPerFile(const int n_frames) {
+    sendToReceiver(F_SET_RECEIVER_FRAMES_PER_FILE, n_frames, nullptr);
+}
+
+bool Receiver::getFileWrite() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_FILE_WRITE);    
+}
+
+void Receiver::setFileWrite(const bool value) {
+    int arg = static_cast<int>(value);
+    sendToReceiver(F_SET_RECEIVER_FILE_WRITE, arg, nullptr);    
+}
+
+bool Receiver::getMasterFileWrite() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_MASTER_FILE_WRITE);
+}
+
+void Receiver::setMasterFileWrite(const bool value) {
+    int arg = static_cast<int>(value);
+    sendToReceiver(F_SET_RECEIVER_MASTER_FILE_WRITE, arg, nullptr);
+}
+
+bool Receiver::getFileOverWrite() const { 
+    return sendToReceiver<int>(F_GET_RECEIVER_OVERWRITE);
+}
+
+void Receiver::setFileOverWrite(const bool value) {
+    int arg = static_cast<int>(value);
+    sendToReceiver(F_SET_RECEIVER_OVERWRITE, arg, nullptr);
+}
+
+/** Detector Parameters */
+
+void Receiver::setNumberOfFrames(const int64_t value) {
+    LOG(logDEBUG1) << "Sending number of frames to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_NUM_FRAMES, value, nullptr);   
+}
+
+void Receiver::setNumberOfTriggers(const int64_t value) {
+    LOG(logDEBUG1) << "Sending number of triggers to Receiver: " << value;
+    sendToReceiver(F_SET_RECEIVER_NUM_TRIGGERS, value, nullptr);   
+}
+
+void Receiver::setNumberOfBursts(const int64_t value) {
+    LOG(logDEBUG1) << "Sending number of bursts to Receiver: " << value;
+    sendToReceiver(F_SET_RECEIVER_NUM_BURSTS, value, nullptr);   
+}
+
+void Receiver::setNumberOfAnalogSamples(const int value) {
+    LOG(logDEBUG1) << "Sending number of analog samples to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_NUM_ANALOG_SAMPLES, value, nullptr);   
+}
+
+void Receiver::setNumberOfDigitalSamples(const int value) {
+    LOG(logDEBUG1) << "Sending number of digital samples to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_NUM_DIGITAL_SAMPLES, value, nullptr);   
+}
+
+void Receiver::setExptime(const int64_t value) {
+    LOG(logDEBUG1) << "Sending exptime to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_EXPTIME, value, nullptr);   
+}
+
+void Receiver::setPeriod(const int64_t value) {
+    LOG(logDEBUG1) << "Sending period to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_PERIOD, value, nullptr);   
+}
+
+void Receiver::setSubExptime(const int64_t value) {
+    LOG(logDEBUG1) << "Sending sub exptime to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_SUB_EXPTIME, value, nullptr);   
+}
+
+void Receiver::setSubDeadTime(const int64_t value) {
+    LOG(logDEBUG1) << "Sending sub deadtime to Receiver: " << value;
+    sendToReceiver(F_RECEIVER_SET_SUB_DEADTIME, value, nullptr);   
+}
+
+void Receiver::setTimingMode(const timingMode value) {
+    LOG(logDEBUG1) << "Sending timing mode to Receiver: " << value;
+    sendToReceiver(F_SET_RECEIVER_TIMING_MODE, value, nullptr);   
+}
+
+void Receiver::setDynamicRange(const int n) {
+    int retval = -1;
+    LOG(logDEBUG1) << "Sending dynamic range to receiver: " << n;
+    sendToReceiver(F_SET_RECEIVER_DYNAMIC_RANGE, n, retval);
+}
+
+void Receiver::setReadoutMode(const slsDetectorDefs::readoutMode mode) {
+    sendToReceiver(F_RECEIVER_SET_READOUT_MODE, mode, nullptr);
+}
+
+void Receiver::setQuad(const bool enable) {
+    int value = enable ? 1 : 0;
+    LOG(logDEBUG1) << "Setting Quad type to " << value << " in Receiver";
+    sendToReceiver(F_SET_RECEIVER_QUAD, value, nullptr);
+}
+
+void Receiver::setReadNLines(const int value) {
+    LOG(logDEBUG1) << "Setting read n lines to " << value
+                        << " in Receiver";
+    sendToReceiver(F_SET_RECEIVER_READ_N_LINES, value, nullptr);
+}
+
+void Receiver::setADCEnableMask(const uint32_t mask) {
+    sendToReceiver(F_RECEIVER_SET_ADC_MASK, mask, nullptr);
+}
+
+void Receiver::setTenGigaADCEnableMask(const uint32_t mask) {
+    sendToReceiver(F_RECEIVER_SET_ADC_MASK_10G, mask, nullptr);
+}
+
+void Receiver::setBurstMode(const slsDetectorDefs::burstMode value) {
+    LOG(logDEBUG1) << "Sending burst mode to Receiver: " << value;
+    sendToReceiver(F_SET_RECEIVER_BURST_MODE, value, nullptr);   
+}
+
+void Receiver::setROI(const slsDetectorDefs::ROI arg) {
+    std::array<int, 2> args{arg.xmin, arg.xmax};
+    LOG(logDEBUG1) << "Sending ROI to receiver";
+    sendToReceiver(F_RECEIVER_SET_ROI, args, nullptr);
+}
+
+void Receiver::clearROI() {
+    LOG(logDEBUG1) << "Clearing ROI";
+    slsDetectorDefs::ROI arg;
+    arg.xmin = -1;
+    arg.xmax = -1;
+    setROI(arg);
+}
+
+std::vector<int> Receiver::getDbitList() const {
+    sls::FixedCapacityContainer<int, MAX_RX_DBIT> retval;
+    sendToReceiver(F_GET_RECEIVER_DBIT_LIST, nullptr, retval);
+    return retval;    
+}
+
+void Receiver::setDbitList(const std::vector<int>& list) {
+    LOG(logDEBUG1) << "Setting Receiver Dbit List";
+    if (list.size() > 64) {
+        throw sls::RuntimeError("Dbit list size cannot be greater than 64\n");
+    }
+    for (auto &it : list) {
+        if (it < 0 || it > 63) {
+            throw sls::RuntimeError(
+                "Dbit list value must be between 0 and 63\n");
+        }
+    }
+    sls::FixedCapacityContainer<int, MAX_RX_DBIT> arg = list;
+    sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr);        
+}
+
+int Receiver::getDbitOffset() const {
+    return sendToReceiver<int>(F_GET_RECEIVER_DBIT_OFFSET);    
+}
+
+void Receiver::setDbitOffset(const int value) {
+    sendToReceiver(F_SET_RECEIVER_DBIT_OFFSET, value, nullptr);        
+}
+
+void Receiver::setActivate(const bool enable) {
+    int arg = static_cast<int>(enable);
+    sendToReceiver(F_RECEIVER_ACTIVATE, arg, nullptr);        
+}
+
+void Receiver::setTenGiga(const bool enable) {
+    int arg = static_cast<int>(enable);
+    sendToReceiver(F_ENABLE_RECEIVER_TEN_GIGA, arg, nullptr);        
+}
+
+void Receiver::setCounterMask(const uint32_t mask) {
+    int ncounters = __builtin_popcount(mask);
+    LOG(logDEBUG1) << "Sending Reciver #counters: " << ncounters;
+    sendToReceiver(F_RECEIVER_SET_NUM_COUNTERS, ncounters, nullptr);
+}
+
+/** Json */
+
+std::map<std::string, std::string> Receiver::getAdditionalJsonHeader() const {
+    int fnum = F_GET_ADDITIONAL_JSON_HEADER;
+    int ret = FAIL;
+    int size = 0;
+    auto client = ReceiverSocket(shm()->hostname, shm()->tcpPort);
+    client.Send(&fnum, sizeof(fnum));
+    client.Receive(&ret, sizeof(ret));
+    if (ret == FAIL) {
+        char mess[MAX_STR_LENGTH]{};
+        client.Receive(mess, MAX_STR_LENGTH);
+        throw RuntimeError("Receiver " + std::to_string(moduleId) +
+                           " returned error: " + std::string(mess));
+    } else {
+        client.Receive(&size, sizeof(size));
+        std::map<std::string, std::string> retval;
+        if (size > 0) {
+            char retvals[size * 2][SHORT_STR_LENGTH];
+            memset(retvals, 0, sizeof(retvals));
+            client.Receive(retvals, sizeof(retvals));
+            for (int i = 0; i < size; ++i) {
+                retval[retvals[2 * i]] = retvals[2 * i + 1];
+            }
+        }
+        LOG(logDEBUG) << "Getting additional json header " << ToString(retval);
+        return retval;
+    }
+}
+
+void Receiver::setAdditionalJsonHeader(const std::map<std::string, std::string> &jsonHeader) {
+    for (auto &it : jsonHeader) {
+        if (it.first.empty() || it.first.length() > SHORT_STR_LENGTH ||
+            it.second.length() > SHORT_STR_LENGTH ) {
+            throw RuntimeError(it.first + " or " + it.second + " pair has invalid size. "
+            "Key cannot be empty. Both can have max 20 characters");
+        }
+    }
+    const int size = jsonHeader.size();
+    int fnum = F_SET_ADDITIONAL_JSON_HEADER;
+    int ret = FAIL;
+    LOG(logDEBUG) << "Sending to receiver additional json header " << ToString(jsonHeader);
+    auto client = ReceiverSocket(shm()->hostname, shm()->tcpPort);
+    client.Send(&fnum, sizeof(fnum));
+    client.Send(&size, sizeof(size));
+    if (size > 0) {
+        char args[size * 2][SHORT_STR_LENGTH];
+        memset(args, 0, sizeof(args));
+        int iarg = 0;
+        for (auto &it : jsonHeader) {
+            sls::strcpy_safe(args[iarg], it.first.c_str());
+            sls::strcpy_safe(args[iarg + 1], it.second.c_str());
+            iarg += 2;
+        }
+        client.Send(args, sizeof(args));
+    }
+    client.Receive(&ret, sizeof(ret));
+    if (ret == FAIL) {
+        char mess[MAX_STR_LENGTH]{};
+        client.Receive(mess, MAX_STR_LENGTH);
+        throw RuntimeError("Receiver " + std::to_string(moduleId) +
+                           " returned error: " + std::string(mess));
+    }
+}
+
+std::string Receiver::getAdditionalJsonParameter(const std::string &key) const {
+    char arg[SHORT_STR_LENGTH]{};
+    sls::strcpy_safe(arg, key.c_str());
+    char retval[SHORT_STR_LENGTH]{};
+    sendToReceiver(F_GET_ADDITIONAL_JSON_PARAMETER, arg, retval); 
+    return retval;
+}
+
+void Receiver::setAdditionalJsonParameter(const std::string &key, const std::string &value) {
+    if (key.empty() || key.length() > SHORT_STR_LENGTH ||
+        value.length() > SHORT_STR_LENGTH ) {
+        throw RuntimeError(key + " or " + value + " pair has invalid size. "
+        "Key cannot be empty. Both can have max 2 characters");
+    }
+    char args[2][SHORT_STR_LENGTH]{};
+    sls::strcpy_safe(args[0], key.c_str());
+    sls::strcpy_safe(args[1], value.c_str());
+    sendToReceiver(F_SET_ADDITIONAL_JSON_PARAMETER, args, nullptr);
+}
+
+
+void Receiver::sendToReceiver(int fnum, const void *args, size_t args_size,
+                                 void *retval, size_t retval_size) {
+    static_cast<const Receiver &>(*this).sendToReceiver(
+        fnum, args, args_size, retval, retval_size);
+}
+
+void Receiver::sendToReceiver(int fnum, const void *args, size_t args_size,
+                                 void *retval, size_t retval_size) const {
+    if (strlen(shm()->hostname) == 0) {
+        throw RuntimeError("Reciver not added");
+    }
+    auto receiver = ReceiverSocket(shm()->hostname, shm()->tcpPort);
+    receiver.sendCommandThenRead(fnum, args, args_size, retval, retval_size);
+    receiver.close();
+}
+
+template <typename Arg, typename Ret>
+void Receiver::sendToReceiver(int fnum, const Arg &args, Ret &retval) {
+    sendToReceiver(fnum, &args, sizeof(args), &retval, sizeof(retval));
+}
+
+template <typename Arg, typename Ret>
+void Receiver::sendToReceiver(int fnum, const Arg &args, Ret &retval) const {
+    sendToReceiver(fnum, &args, sizeof(args), &retval, sizeof(retval));
+}
+
+template <typename Arg>
+void Receiver::sendToReceiver(int fnum, const Arg &args, std::nullptr_t) {
+    sendToReceiver(fnum, &args, sizeof(args), nullptr, 0);
+}
+
+template <typename Arg>
+void Receiver::sendToReceiver(int fnum, const Arg &args,
+                                 std::nullptr_t) const {
+    sendToReceiver(fnum, &args, sizeof(args), nullptr, 0);
+}
+
+template <typename Ret>
+void Receiver::sendToReceiver(int fnum, std::nullptr_t, Ret &retval) {
+    sendToReceiver(fnum, nullptr, 0, &retval, sizeof(retval));
+}
+
+template <typename Ret>
+void Receiver::sendToReceiver(int fnum, std::nullptr_t, Ret &retval) const {
+    sendToReceiver(fnum, nullptr, 0, &retval, sizeof(retval));
+}
+
+template <typename Ret>
+Ret Receiver::sendToReceiver(int fnum){
+    LOG(logDEBUG1) << "Sending: [" 
+    << getFunctionNameFromEnum(static_cast<slsDetectorDefs::detFuncs>(fnum))
+    << ", nullptr, 0, " << typeid(Ret).name() << ", " << sizeof(Ret) << "]";
+    Ret retval{};
+    sendToReceiver(fnum, nullptr, 0, &retval, sizeof(retval));
+    LOG(logDEBUG1) << "Got back: " << retval;
+    return retval;
+}
+
+template <typename Ret>
+Ret Receiver::sendToReceiver(int fnum) const{
+    LOG(logDEBUG1) << "Sending: [" 
+    << getFunctionNameFromEnum(static_cast<slsDetectorDefs::detFuncs>(fnum))
+    << ", nullptr, 0, " << typeid(Ret).name() << ", " << sizeof(Ret) << "]";
+    Ret retval{};
+    sendToReceiver(fnum, nullptr, 0, &retval, sizeof(retval));
+    LOG(logDEBUG1) << "Got back: " << retval;
+    return retval;
+}
+
+template <typename Ret, typename Arg>
+Ret Receiver::sendToReceiver(int fnum, const Arg &args){
+    LOG(logDEBUG1) << "Sending: [" 
+    << getFunctionNameFromEnum(static_cast<slsDetectorDefs::detFuncs>(fnum))
+    << ", " << args << ", " << sizeof(args) << ", " << typeid(Ret).name() 
+    << ", " << sizeof(Ret) << "]";
+    Ret retval{};
+    sendToReceiver(fnum, &args, sizeof(args), &retval, sizeof(retval));
+    LOG(logDEBUG1) << "Got back: " << retval;
+    return retval;
+}
+
+template <typename Ret, typename Arg>
+Ret Receiver::sendToReceiver(int fnum, const Arg &args) const{
+    LOG(logDEBUG1) << "Sending: [" 
+    << getFunctionNameFromEnum(static_cast<slsDetectorDefs::detFuncs>(fnum))
+    << ", " << args << ", " << sizeof(args) << ", " << typeid(Ret).name() 
+    << ", " << sizeof(Ret) << "]";
+    Ret retval{};
+    sendToReceiver(fnum, &args, sizeof(args), &retval, sizeof(retval));
+    LOG(logDEBUG1) << "Got back: " << retval;
+    return retval;
+}
+
+} // namespace sls

slsDetectorSoftware/src/Receiver.h

@@ -0,0 +1,258 @@
+#pragma once
+#include "SharedMemory.h"
+#include "logger.h"
+#include "sls_detector_defs.h"
+#include "network_utils.h"
+
+#include <map>
+#include <memory>
+
+#define RECEIVER_SHMVERSION 0x200421
+
+class ZmqSocket;
+
+namespace sls {
+struct sharedReceiver {
+
+/* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/
+int shmversion;
+char hostname[MAX_STR_LENGTH];
+int tcpPort;
+/** END OF FIXED PATTERN -----------------------------------------------*/
+
+int stoppedFlag;
+int zmqPort;
+sls::IpAddr zmqIp;
+
+};
+
+class Receiver : public virtual slsDetectorDefs {
+    public:
+    static size_t getNumReceivers();
+    // create shm
+    explicit Receiver(int detector_id, int module_id, int interface_id,
+        int receiver_id, int tcp_port = 0, std::string hostname = "",
+        int zmq_port = 0);
+    // open shm
+    explicit Receiver(int detector_id, int module_id, int interface_id,
+        int receiver_id, bool verify);
+
+    virtual ~Receiver();
+
+    void createIndexString();
+
+    /**************************************************
+    *                                                *
+    *    Configuration                               *
+    *                                                *
+    * ************************************************/
+    /**
+    * Free shared memory and delete shared memory structure
+    * occupied by the sharedReceiver structure
+    * Is only safe to call if one deletes the Receiver object afterward
+    * and frees multi shared memory/updates
+    * thisMultiDetector->numberOfReceivers
+    */
+    void freeSharedMemory();
+    std::string getHostname() const;
+    void setHostname(const std::string &hostname);
+    sls::MacAddr configure(slsDetectorDefs::rxParameters arg);
+    int getTCPPort() const;
+    void setTCPPort(const int port);
+    std::string printConfiguration();
+    int64_t getSoftwareVersion() const;
+
+    /**************************************************
+    *                                                *
+    *    Acquisition                                 *
+    *                                                *
+    * ************************************************/
+    void start();
+    void stop();
+    slsDetectorDefs::runStatus getStatus() const;
+    int getProgress() const;
+    void setStoppedFlag();
+    void restreamStop();
+    uint64_t getFramesCaught() const;
+    uint64_t getNumMissingPackets() const;
+    uint64_t getCurrentFrameIndex() const;
+
+    /**************************************************
+    *                                                 *
+    *    Network Configuration (Detector<->Receiver)  *
+    *                                                 *
+    * ************************************************/
+    sls::MacAddr setUDPIP(const sls::IpAddr ip);
+    void setUDPPort(const int udpport);
+    int64_t getUDPSocketBufferSize() const;
+    void setUDPSocketBufferSize(int64_t value);
+    int64_t getRealUDPSocketBufferSize() const;
+
+    /**************************************************
+    *                                                *
+    *    ZMQ Streaming Parameters (Receiver<->Client)*
+    *                                                *
+    * ************************************************/
+    bool getZmq() const;
+    void setZmq(const bool enable);
+    int getZmqFrequency() const;
+    /** Freq = 0 for a timer, else frequency */
+    void setZmqFrequency(const int freq);
+    int getZmqTimer() const;
+    void setZmqTimer(const int time_in_ms = 200);
+    int getZmqPort() const; 
+    void setZmqPort(int port);
+    sls::IpAddr getZmqIP() const;
+    void setZmqIP(const sls::IpAddr ip);
+    int getClientZmqPort() const;
+    void setClientZmqPort(const int port);
+    sls::IpAddr getClientZmqIP() const;
+    void setClientZmqIP(const sls::IpAddr ip);
+    bool getClientZmq() const;
+    void setClientZmq(const bool enable);
+    ZmqSocket* getZmqSocket();
+
+    /**************************************************
+    *                                                *
+    *    Receiver Parameters                         *
+    *                                                *
+    * ************************************************/
+    bool getLock() const;
+    void setLock(const bool lock);
+    sls::IpAddr getLastClientIP() const;
+    void exitServer();  
+
+    bool getDeactivatedPaddingMode() const;
+    void setDeactivatedPaddingMode(const bool padding);
+    bool getFlippedDataX() const;
+    void setFlippedDataX(const bool value);
+    frameDiscardPolicy getFramesDiscardPolicy() const;
+    void setFramesDiscardPolicy(const frameDiscardPolicy f);
+    bool getPartialFramesPadding() const;
+    void setPartialFramesPadding(const bool padding);
+    int getFifoDepth() const;
+    void setFifoDepth(const int value);
+    bool getSilentMode() const;
+    void setSilentMode(const bool value);
+
+    /**************************************************
+    *                                                *
+    *    File                                        *
+    *                                                *
+    * ************************************************/
+    std::string getFilePath() const;
+    void setFilePath(const std::string &path);
+    std::string getFileName() const;
+    void setFileName(const std::string &fname);
+    int64_t getFileIndex() const;
+    void setFileIndex(const int64_t file_index);
+    void incrementFileIndex();
+    fileFormat getFileFormat() const;
+    void setFileFormat(const fileFormat f);
+    int getFramesPerFile() const;
+    /** 0 will set frames per file to unlimited */
+    void setFramesPerFile(const int n_frames);
+    bool getFileWrite() const;
+    void setFileWrite(const bool value);
+    bool getMasterFileWrite() const;
+    void setMasterFileWrite(const bool value);
+    bool getFileOverWrite() const;
+    void setFileOverWrite(const bool value);
+
+    /**************************************************
+    *                                                *
+    *    Detector Parameters                         *
+    *                                                *
+    * ************************************************/
+    void setNumberOfFrames(const int64_t value);
+    void setNumberOfTriggers(const int64_t value);
+    void setNumberOfBursts(const int64_t value);
+    void setNumberOfAnalogSamples(const int value);
+    void setNumberOfDigitalSamples(const int value);
+    void setExptime(const int64_t value);
+    void setPeriod(const int64_t value);
+    void setSubExptime(const int64_t value);
+    void setSubDeadTime(const int64_t value);
+    void setTimingMode(const timingMode value);
+    void setDynamicRange(const int n);
+    void setReadoutMode(const readoutMode mode);
+    void setQuad(const bool enable);
+    void setReadNLines(const int value);
+    void setADCEnableMask(const uint32_t mask);
+    void setTenGigaADCEnableMask(const uint32_t mask);
+    void setBurstMode(const burstMode value);
+    void setROI(const slsDetectorDefs::ROI arg);
+    void clearROI();
+    std::vector<int> getDbitList() const;
+    /** digital data bits enable (CTB only) */
+    void setDbitList(const std::vector<int>& list);
+    int getDbitOffset() const;
+    /** Set digital data offset in bytes (CTB only) */
+    void setDbitOffset(const int value);
+    void setActivate(const bool enable);
+    void setTenGiga(const bool enable);
+    void setCounterMask(const uint32_t mask);
+
+    /**************************************************
+    *                                                *
+    *    Json                                        *
+    *                                                *
+    * ************************************************/
+
+    std::map<std::string, std::string> getAdditionalJsonHeader() const;
+    /** empty vector deletes entire additional json header */
+    void setAdditionalJsonHeader(const std::map<std::string, std::string> &jsonHeader);
+    std::string getAdditionalJsonParameter(const std::string &key) const;
+    /** Sets the value for the additional json header parameter key if found, 
+    else append it. If value empty, then deletes parameter */
+    void setAdditionalJsonParameter(const std::string &key, const std::string &value);
+
+
+
+    private:
+    void sendToReceiver(int fnum, const void *args, size_t args_size,
+                        void *retval, size_t retval_size);
+
+    void sendToReceiver(int fnum, const void *args, size_t args_size,
+                        void *retval, size_t retval_size) const;
+
+    template <typename Arg, typename Ret>
+    void sendToReceiver(int fnum, const Arg &args, Ret &retval);
+
+    template <typename Arg, typename Ret>
+    void sendToReceiver(int fnum, const Arg &args, Ret &retval) const;
+
+    template <typename Arg>
+    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t);
+
+    template <typename Arg>
+    void sendToReceiver(int fnum, const Arg &args, std::nullptr_t) const;
+
+    template <typename Ret>
+    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval);
+
+    template <typename Ret>
+    void sendToReceiver(int fnum, std::nullptr_t, Ret &retval) const;
+
+    template <typename Ret>
+    Ret sendToReceiver(int fnum);
+
+    template <typename Ret>
+    Ret sendToReceiver(int fnum) const;
+
+    template <typename Ret, typename Arg>
+    Ret sendToReceiver(int fnum, const Arg &args);
+
+    template <typename Ret, typename Arg>
+    Ret sendToReceiver(int fnum, const Arg &args) const;
+
+    void checkVersionCompatibility();
+    const int receiverId{0};
+    const int interfaceId{0};
+    const int moduleId{0};
+    std::string indexString;
+    mutable sls::SharedMemory<sharedReceiver> shm{0, 0, 0, 0};
+    std::unique_ptr<ZmqSocket> zmqSocket;
+};
+
+}   // sls

slsDetectorSoftware/src/SharedMemory.h

@@ -23,7 +23,8 @@
 #include <unistd.h>
 
 #define SHM_MULTI_PREFIX "/slsDetectorPackage_multi_"
-#define SHM_SLS_PREFIX "_sls_"
+#define SHM_MODULE_PREFIX "_module_"
+#define SHM_RECEIVER_PREFIX "_receiver_"
 #define SHM_ENV_NAME "SLSDETNAME"
 
 #include <iostream>
@@ -39,10 +40,12 @@ class SharedMemory {
 	 * Constructor
 	 * creates the single/multi detector shared memory name
 	 * @param multiId multi detector id
-     * @param slsId sls detector id, -1 if a multi detector shared memory
+     * @param moduleId module detectr id, -1 if a multi detector shared memory
+     * @param interfaceId 0 for primary interface, 1 for secondary
+     * @param receiverId receiver id, -1 if not a rxr shm, else round robin entry
  	 */
-    SharedMemory(int multiId, int slsId) {
+    SharedMemory(int multiId, int moduleId, int interfaceId = 0, int receiverId = -1) {
-        name = ConstructSharedMemoryName(multiId, slsId);
+        name = ConstructSharedMemoryName(multiId, moduleId, interfaceId, receiverId);
     }
 
     /** 
@@ -184,7 +187,8 @@ class SharedMemory {
             // silent exit if shm did not exist anyway
             if (errno == ENOENT)
                 return;
-            std::string msg = "Free Shared Memory " + name + " Failed: " + strerror(errno);
+            std::string msg = "Free Shared Memory " + name + " Failed: " + 
+            strerror(errno);
             LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
@@ -215,10 +219,13 @@ class SharedMemory {
      * Create Shared memory name
      * throws exception if name created is longer than required 255(manpages)
      * @param multiId multi detector id
-     * @param slsId sls detector id, -1 if a multi detector shared memory
+     * @param moduleId module detector id, -1 if a multi detector shared memory
+     * @param interfaceId 0 for primary interface, 1 for secondary
+     * @param receiverId receiver id, -1 if not a rxr shm, else round robin entry
      * @returns shared memory name
      */
-    std::string ConstructSharedMemoryName(int multiId, int slsId) {
+    std::string ConstructSharedMemoryName(int multiId, int moduleId, 
+        int interfaceId = 0, int receiverId = -1) {
 
         // using environment path
         std::string sEnvPath = "";
@@ -229,14 +236,22 @@ class SharedMemory {
         }
 
         std::stringstream ss;
-        if (slsId < 0)
+        if (moduleId < 0 && receiverId < 0)
             ss << SHM_MULTI_PREFIX << multiId << sEnvPath;
+        else if (receiverId < 0)
+            ss << SHM_MULTI_PREFIX << multiId << 
+                SHM_MODULE_PREFIX << moduleId << sEnvPath;
         else
-            ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath;
+            ss << SHM_MULTI_PREFIX << multiId << 
+                SHM_MODULE_PREFIX << moduleId << 
+                SHM_RECEIVER_PREFIX << (char)(interfaceId + 97) << '_' << receiverId << sEnvPath;
 
         std::string temp = ss.str();
         if (temp.length() > NAME_MAX_LENGTH) {
-            std::string msg = "Shared memory initialization failed. " + temp + " has " + std::to_string(temp.length()) + " characters. \n" + "Maximum is " + std::to_string(NAME_MAX_LENGTH) + ". Change the environment variable " + SHM_ENV_NAME;
+            std::string msg = "Shared memory initialization failed. " + 
+            temp + " has " + std::to_string(temp.length()) + " characters. \n" + 
+            "Maximum is " + std::to_string(NAME_MAX_LENGTH) + 
+            ". Change the environment variable " + SHM_ENV_NAME;
             LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
         }
@@ -250,9 +265,11 @@ class SharedMemory {
      */
 
     T *MapSharedMemory() {
-        void *addr = mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+        void *addr = mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, 
+            MAP_SHARED, fd, 0);
         if (addr == MAP_FAILED) {
-            std::string msg = "Mapping shared memory " + name + " failed: " + strerror(errno);
+            std::string msg = "Mapping shared memory " + name + " failed: " +
+                strerror(errno);
             LOG(logERROR) << msg;
             close(fd);
             throw SharedMemoryError(msg);
@@ -271,7 +288,8 @@ class SharedMemory {
         struct stat sb;
         // could not fstat
         if (fstat(fd, &sb) < 0) {
-            std::string msg = "Could not verify existing shared memory " + name + " size match " + "(could not fstat): " + strerror(errno);
+            std::string msg = "Could not verify existing shared memory " + 
+                name + " size match " + "(could not fstat): " + strerror(errno);
             LOG(logERROR) << msg;
             close(fd);
             throw SharedMemoryError(msg);
@@ -280,7 +298,9 @@ class SharedMemory {
         //size does not match
         auto sz = static_cast<size_t>(sb.st_size);
         if (sz != expectedSize) {
-            std::string msg = "Existing shared memory " + name + " size does not match" + "Expected " + std::to_string(expectedSize) + ", found " + std::to_string(sz);
+            std::string msg = "Existing shared memory " + name + 
+                " size does not match" + "Expected " + 
+                std::to_string(expectedSize) + ", found " + std::to_string(sz);
             LOG(logERROR) << msg;
             throw SharedMemoryError(msg);
             return 1;

slsReceiverSoftware/src/ClientInterface.cpp

@@ -95,7 +95,7 @@ void ClientInterface::startTCPServer() {
     }
 
     if (receiver) {
-        receiver->shutDownUDPSockets();
+        receiver->shutDownUDPSocket();
     }
     LOG(logINFOBLUE) << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) << "]";
 }
@@ -104,7 +104,8 @@ void ClientInterface::startTCPServer() {
 int ClientInterface::functionTable(){
 	flist[F_EXEC_RECEIVER_COMMAND]			=	&ClientInterface::exec_command;
 	flist[F_EXIT_RECEIVER]					=	&ClientInterface::exit_server;
-	flist[F_LOCK_RECEIVER]					=	&ClientInterface::lock_receiver;
+	flist[F_SET_LOCK_RECEIVER]				=	&ClientInterface::set_lock_server;
+	flist[F_GET_LOCK_RECEIVER]				=	&ClientInterface::get_lock_server;
 	flist[F_GET_LAST_RECEIVER_CLIENT_IP]	=	&ClientInterface::get_last_client_ip;
 	flist[F_SET_RECEIVER_PORT]				=	&ClientInterface::set_port;
 	flist[F_GET_RECEIVER_VERSION]			=	&ClientInterface::get_version;
@@ -145,11 +146,14 @@ int ClientInterface::functionTable(){
 	flist[F_GET_RECEIVER_OVERWRITE]		    = 	&ClientInterface::get_overwrite;
 	flist[F_ENABLE_RECEIVER_TEN_GIGA]		= 	&ClientInterface::enable_tengiga;
 	flist[F_SET_RECEIVER_FIFO_DEPTH]		= 	&ClientInterface::set_fifo_depth;
+	flist[F_GET_RECEIVER_FIFO_DEPTH]		= 	&ClientInterface::get_fifo_depth;
 	flist[F_RECEIVER_ACTIVATE]				= 	&ClientInterface::set_activate;
 	flist[F_SET_RECEIVER_STREAMING]		    = 	&ClientInterface::set_streaming;
 	flist[F_GET_RECEIVER_STREAMING]		    = 	&ClientInterface::get_streaming;
-	flist[F_RECEIVER_STREAMING_TIMER]		= 	&ClientInterface::set_streaming_timer;
+	flist[F_SET_RECEIVER_STREAMING_TIMER]	= 	&ClientInterface::set_streaming_timer;
+	flist[F_GET_RECEIVER_STREAMING_TIMER]	= 	&ClientInterface::get_streaming_timer;
 	flist[F_SET_FLIPPED_DATA_RECEIVER]		= 	&ClientInterface::set_flipped_data;
+	flist[F_GET_FLIPPED_DATA_RECEIVER]		= 	&ClientInterface::get_flipped_data;
 	flist[F_SET_RECEIVER_FILE_FORMAT]		= 	&ClientInterface::set_file_format;
 	flist[F_GET_RECEIVER_FILE_FORMAT]		= 	&ClientInterface::get_file_format;
 	flist[F_SET_RECEIVER_STREAMING_PORT]	= 	&ClientInterface::set_streaming_port;
@@ -161,8 +165,9 @@ int ClientInterface::functionTable(){
 	flist[F_RESTREAM_STOP_FROM_RECEIVER]	= 	&ClientInterface::restream_stop;
 	flist[F_SET_ADDITIONAL_JSON_HEADER]     =   &ClientInterface::set_additional_json_header;
 	flist[F_GET_ADDITIONAL_JSON_HEADER]     =   &ClientInterface::get_additional_json_header;
-    flist[F_RECEIVER_UDP_SOCK_BUF_SIZE]     =   &ClientInterface::set_udp_socket_buffer_size;
+    flist[F_SET_RECEIVER_UDP_SOCK_BUF_SIZE] =   &ClientInterface::set_udp_socket_buffer_size;
-    flist[F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]=   &ClientInterface::get_real_udp_socket_buffer_size;
+    flist[F_GET_RECEIVER_UDP_SOCK_BUF_SIZE] =   &ClientInterface::get_udp_socket_buffer_size;
+    flist[F_GET_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]=   &ClientInterface::get_real_udp_socket_buffer_size;
     flist[F_SET_RECEIVER_FRAMES_PER_FILE]	=   &ClientInterface::set_frames_per_file;
     flist[F_GET_RECEIVER_FRAMES_PER_FILE]	=   &ClientInterface::get_frames_per_file;
     flist[F_RECEIVER_CHECK_VERSION]			=   &ClientInterface::check_version_compatibility;
@@ -181,10 +186,8 @@ int ClientInterface::functionTable(){
     flist[F_SET_RECEIVER_QUAD]			    = 	&ClientInterface::set_quad_type;
     flist[F_SET_RECEIVER_READ_N_LINES]      =   &ClientInterface::set_read_n_lines;
     flist[F_SET_RECEIVER_UDP_IP]            =   &ClientInterface::set_udp_ip;
-	flist[F_SET_RECEIVER_UDP_IP2]           =   &ClientInterface::set_udp_ip2;
 	flist[F_SET_RECEIVER_UDP_PORT]          =   &ClientInterface::set_udp_port;
-	flist[F_SET_RECEIVER_UDP_PORT2]         =   &ClientInterface::set_udp_port2;
+    flist[F_SET_RECEIVER_NUM_INTERFACES]    =   &ClientInterface::set_num_interfaces;
-	flist[F_SET_RECEIVER_NUM_INTERFACES]    =   &ClientInterface::set_num_interfaces;
 	flist[F_RECEIVER_SET_ADC_MASK_10G]		=	&ClientInterface::set_adc_mask_10g;
     flist[F_RECEIVER_SET_NUM_COUNTERS]      =   &ClientInterface::set_num_counters;
     flist[F_INCREMENT_FILE_INDEX]           =   &ClientInterface::increment_file_index;
@@ -288,7 +291,7 @@ int ClientInterface::exit_server(Interface &socket) {
     return GOODBYE;
 }
 
-int ClientInterface::lock_receiver(Interface &socket) {
+int ClientInterface::set_lock_server(Interface &socket) {
     auto lock = socket.Receive<int>();
     LOG(logDEBUG1) << "Locking Server to " << lock;
     if (lock >= 0) {
@@ -300,6 +303,11 @@ int ClientInterface::lock_receiver(Interface &socket) {
             throw RuntimeError("Receiver locked\n");
         }
     }
+    socket.Send(OK);
+    return OK;
+}
+
+int ClientInterface::get_lock_server(Interface &socket) {
     return socket.sendResult(lockedByClient);
 }
 
@@ -330,10 +338,12 @@ int ClientInterface::setup_receiver(Interface &socket) {
     auto arg = socket.Receive<rxParameters>();
     LOG(logDEBUG1) 
         << "detType:" << arg.detType << std::endl
-        << "multiSize.x:" << arg.multiSize.x << std::endl
+        << "detectorSize.x:" << arg.detectorSize.x << std::endl
-        << "multiSize.y:" << arg.multiSize.y << std::endl
+        << "detectorSize.y:" << arg.detectorSize.y << std::endl
-        << "detId:" << arg.detId << std::endl
+        << "moduleId:" << arg.moduleId << std::endl
         << "hostname:" << arg.hostname << std::endl
+        << "interfaceId: " << arg.interfaceId << std::endl
+        << "zmq ip:" << arg.zmq_ip << std::endl
         << "udpInterfaces:" << arg.udpInterfaces << std::endl
         << "udp_dstport:" << arg.udp_dstport << std::endl
         << "udp_dstip:" << sls::IpAddr(arg.udp_dstip) << std::endl
@@ -373,29 +383,31 @@ int ClientInterface::setup_receiver(Interface &socket) {
     // basic setup
     setDetectorType(arg.detType);
     {
-        int msize[2] = {arg.multiSize.x, arg.multiSize.y};
+        int msize[2] = {arg.detectorSize.x, arg.detectorSize.y};
-        impl()->setMultiDetectorSize(msize);
+        impl()->setDetectorSize(msize);
     }
-    impl()->setDetectorPositionId(arg.detId);
+    impl()->setDetectorPositionId(arg.moduleId);
     impl()->setDetectorHostname(arg.hostname);
     
     // udp setup
-    sls::MacAddr retvals[2];
+    impl()->setInterfaceId(arg.interfaceId);
-    if (arg.udp_dstmac == 0 && arg.udp_dstip != 0) {
+    sls::MacAddr retval;
-        retvals[0] = setUdpIp(sls::IpAddr(arg.udp_dstip));
+    if (arg.interfaceId == 0) {
-    }
+        if (arg.udp_dstmac == 0 && arg.udp_dstip != 0) {
-    if (arg.udp_dstmac2 == 0 && arg.udp_dstip2 != 0) {
+            retval = setUdpIp(sls::IpAddr(arg.udp_dstip));
-        retvals[1] = setUdpIp2(sls::IpAddr(arg.udp_dstip2));
-    }
-    impl()->setUDPPortNumber(arg.udp_dstport);
-    impl()->setUDPPortNumber2(arg.udp_dstport2);
-    if (myDetectorType == JUNGFRAU) {
-        try {
-            impl()->setNumberofUDPInterfaces(arg.udpInterfaces);
-        } catch(const RuntimeError &e) {
-            throw RuntimeError("Failed to set number of interfaces to " + 
-            std::to_string(arg.udpInterfaces));
         }
+        impl()->setUDPPortNumber(arg.udp_dstport);
+    } else {
+        if (arg.udp_dstmac2 == 0 && arg.udp_dstip2 != 0) {
+            retval = setUdpIp(sls::IpAddr(arg.udp_dstip2));
+        }
+        impl()->setUDPPortNumber(arg.udp_dstport2);
+    }
+    try {
+        impl()->setNumberofUDPInterfaces(arg.udpInterfaces);
+    } catch(const RuntimeError &e) {
+        throw RuntimeError("Failed to set number of interfaces to " + 
+        std::to_string(arg.udpInterfaces));
     }
     impl()->setUDPSocketBufferSize(0);
 
@@ -490,8 +502,14 @@ int ClientInterface::setup_receiver(Interface &socket) {
     if (myDetectorType == GOTTHARD) {
         impl()->setBurstMode(arg.burstType);
     }
-
+    {
-    return socket.sendResult(retvals);
+        sls::IpAddr ip(arg.zmq_ip);
+        if (ip == 0) { 
+            throw RuntimeError("Invalid zmq ip: " + ip.str());
+        }
+        impl()->setStreamingSourceIP(ip);
+    }
+    return socket.sendResult(retval);
 }
 
 void ClientInterface::setDetectorType(detectorType arg) {
@@ -514,6 +532,7 @@ void ClientInterface::setDetectorType(detectorType arg) {
         receiver = sls::make_unique<Implementation>(arg);
         myDetectorType = arg;
     } catch (...) {
+        receiver.reset();
         throw RuntimeError("Could not set detector type");
     }
 
@@ -547,7 +566,8 @@ int ClientInterface::set_roi(Interface &socket) {
     } catch(const RuntimeError &e) {
         throw RuntimeError("Could not set ROI");
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_frames(Interface &socket) {
@@ -561,7 +581,8 @@ int ClientInterface::set_num_frames(Interface &socket) {
     impl()->setNumberOfFrames(value);
     int64_t retval = impl()->getNumberOfFrames();
     validate(value, retval, "set number of frames", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_triggers(Interface &socket) {
@@ -575,7 +596,8 @@ int ClientInterface::set_num_triggers(Interface &socket) {
     impl()->setNumberOfTriggers(value);
     int64_t retval = impl()->getNumberOfTriggers();
     validate(value, retval, "set number of triggers", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_bursts(Interface &socket) {
@@ -589,7 +611,8 @@ int ClientInterface::set_num_bursts(Interface &socket) {
     impl()->setNumberOfBursts(value);
     int64_t retval = impl()->getNumberOfBursts();
     validate(value, retval, "set number of bursts", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_add_storage_cells(Interface &socket) {
@@ -603,7 +626,8 @@ int ClientInterface::set_num_add_storage_cells(Interface &socket) {
     impl()->setNumberOfAdditionalStorageCells(value);
     int retval = impl()->getNumberOfAdditionalStorageCells();
     validate(value, retval, "set number of additional storage cells", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_timing_mode(Interface &socket) {
@@ -617,7 +641,8 @@ int ClientInterface::set_timing_mode(Interface &socket) {
     impl()->setTimingMode(static_cast<timingMode>(value));
     int retval = impl()->getTimingMode();
     validate(value, retval, "set timing mode", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_burst_mode(Interface &socket) {
@@ -631,7 +656,8 @@ int ClientInterface::set_burst_mode(Interface &socket) {
     impl()->setBurstMode(static_cast<burstMode>(value));
     int retval = impl()->getBurstMode();
     validate(value, retval, "set burst mode", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_analog_samples(Interface &socket) {
@@ -645,7 +671,8 @@ int ClientInterface::set_num_analog_samples(Interface &socket) {
     } catch(const RuntimeError &e) {
         throw RuntimeError("Could not set num analog samples to " + std::to_string(value) + " due to fifo structure memory allocation.");
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_digital_samples(Interface &socket) {
@@ -659,21 +686,24 @@ int ClientInterface::set_num_digital_samples(Interface &socket) {
     } catch(const RuntimeError &e) {
         throw RuntimeError("Could not set num digital samples to " + std::to_string(value) + " due to fifo structure memory allocation.");
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_exptime(Interface &socket) {
     auto value = socket.Receive<int64_t>();
     LOG(logDEBUG1) << "Setting exptime to " << value << "ns";
     impl()->setAcquisitionTime(value);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_period(Interface &socket) {
     auto value = socket.Receive<int64_t>();
     LOG(logDEBUG1) << "Setting period to " << value << "ns";
     impl()->setAcquisitionPeriod(value);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_subexptime(Interface &socket) {
@@ -682,7 +712,8 @@ int ClientInterface::set_subexptime(Interface &socket) {
     uint64_t subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
     impl()->setSubExpTime(value);
     impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_subdeadtime(Interface &socket) {
@@ -690,7 +721,8 @@ int ClientInterface::set_subdeadtime(Interface &socket) {
     LOG(logDEBUG1) << "Setting sub deadtime to " << value << "ns";
     impl()->setSubPeriod(value + impl()->getSubExpTime());
     LOG(logDEBUG1) << "Setting sub period to " << impl()->getSubPeriod() << "ns";    
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_dynamic_range(Interface &socket) {
@@ -745,7 +777,8 @@ int ClientInterface::set_streaming_frequency(Interface &socket) {
     
     int retval = impl()->getStreamingFrequency();
     validate(index, retval, "set streaming frequency", DEC);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_streaming_frequency(Interface &socket) {
@@ -765,7 +798,8 @@ int ClientInterface::start_receiver(Interface &socket) {
         LOG(logDEBUG1) << "Starting Receiver";
         impl()->startReceiver();
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::stop_receiver(Interface &socket) {
@@ -780,7 +814,8 @@ int ClientInterface::stop_receiver(Interface &socket) {
         throw RuntimeError("Could not stop receiver. It as it is: " +
                            sls::ToString(s));
 
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_file_dir(Interface &socket) {
@@ -803,7 +838,8 @@ int ClientInterface::set_file_dir(Interface &socket) {
     else
         LOG(logDEBUG1) << "file path:" << retval;
 
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_file_dir(Interface &socket) {
@@ -827,7 +863,8 @@ int ClientInterface::set_file_name(Interface &socket) {
     std::string s = impl()->getFileName();
     sls::strcpy_safe(retval, s.c_str());
     LOG(logDEBUG1) << "file name:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_file_name(Interface &socket) {
@@ -851,7 +888,8 @@ int ClientInterface::set_file_index(Interface &socket) {
     int64_t retval = impl()->getFileIndex();
     validate(index, retval, "set file index", DEC);
     LOG(logDEBUG1) << "file index:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_file_index(Interface &socket) {
@@ -867,19 +905,13 @@ int ClientInterface::get_frame_index(Interface &socket) {
 }
 
 int ClientInterface::get_missing_packets(Interface &socket) {
-    std::vector<uint64_t> m = impl()->getNumMissingPackets();
+    uint64_t retval = impl()->getNumMissingPackets();
-    LOG(logDEBUG1) << "missing packets:" << sls::ToString(m);
+    LOG(logDEBUG1) << "missing packets:" << retval;
-    int retvalsize = m.size();
+    return socket.sendResult(retval);
-    uint64_t retval[retvalsize];
-    std::copy(std::begin(m), std::end(m), retval);
-    socket.Send(OK);
-    socket.Send(&retvalsize, sizeof(retvalsize));
-    socket.Send(retval, sizeof(retval));
-    return OK;
 }
 
 int ClientInterface::get_frames_caught(Interface &socket) {
-    int64_t retval = impl()->getFramesCaught();
+    uint64_t retval = impl()->getFramesCaught();
     LOG(logDEBUG1) << "frames caught:" << retval;
     return socket.sendResult(retval);
 }
@@ -896,7 +928,8 @@ int ClientInterface::set_file_write(Interface &socket) {
     int retval = impl()->getFileWriteEnable();
     validate(enable, retval, "set file write enable", DEC);
     LOG(logDEBUG1) << "file write enable:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_file_write(Interface &socket) {
@@ -918,7 +951,8 @@ int ClientInterface::set_master_file_write(Interface &socket) {
     int retval = impl()->getMasterFileWriteEnable();
     validate(enable, retval, "set master file write enable", DEC);
     LOG(logDEBUG1) << "master file write enable:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_master_file_write(Interface &socket) {
@@ -940,7 +974,8 @@ int ClientInterface::set_overwrite(Interface &socket) {
     int retval = impl()->getOverwriteEnable();
     validate(index, retval, "set file overwrite enable", DEC);
     LOG(logDEBUG1) << "file overwrite enable:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_overwrite(Interface &socket) {
@@ -967,7 +1002,8 @@ int ClientInterface::enable_tengiga(Interface &socket) {
     int retval = impl()->getTenGigaEnable();
     validate(val, retval, "set 10GbE", DEC);
     LOG(logDEBUG1) << "10Gbe:" << retval;
-    return socket.sendResult(retval);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_fifo_depth(Interface &socket) {
@@ -984,6 +1020,14 @@ int ClientInterface::set_fifo_depth(Interface &socket) {
     int retval = impl()->getFifoDepth();
     validate(value, retval, std::string("set fifo depth"), DEC);
     LOG(logDEBUG1) << "fifo depth:" << retval;
+    socket.Send(OK);
+    return OK;
+}
+
+
+int ClientInterface::get_fifo_depth(Interface &socket) {
+    int retval = impl()->getFifoDepth();
+    LOG(logDEBUG1) << "fifo depth:" << retval;
     return socket.sendResult(retval);
 }
 
@@ -1020,7 +1064,8 @@ int ClientInterface::set_streaming(Interface &socket) {
     auto retval = static_cast<int>(impl()->getDataStreamEnable());
     validate(index, retval, "set data stream enable", DEC);
     LOG(logDEBUG1) << "data streaming enable:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_streaming(Interface &socket) {
@@ -1039,9 +1084,17 @@ int ClientInterface::set_streaming_timer(Interface &socket) {
     int retval = impl()->getStreamingTimer();
     validate(index, retval, "set data stream timer", DEC);
     LOG(logDEBUG1) << "Streaming timer:" << retval;
+    socket.Send(OK);
+    return OK;
+}
+
+int ClientInterface::get_streaming_timer(Interface &socket) {
+    int retval = impl()->getStreamingTimer();
+    LOG(logDEBUG1) << "Streaming timer:" << retval;
     return socket.sendResult(retval);
 }
 
+
 int ClientInterface::set_flipped_data(Interface &socket) {
     auto arg = socket.Receive<int>();
 
@@ -1056,6 +1109,13 @@ int ClientInterface::set_flipped_data(Interface &socket) {
     int retval = impl()->getFlippedDataX();
     validate(arg, retval, std::string("set flipped data"), DEC);
     LOG(logDEBUG1) << "Flipped Data:" << retval;
+    socket.Send(OK);
+    return OK;
+}
+
+int ClientInterface::get_flipped_data(Interface &socket) {
+    int retval = impl()->getFlippedDataX();
+    LOG(logDEBUG1) << "Flipped Data:" << retval;
     return socket.sendResult(retval);
 }
 
@@ -1073,7 +1133,8 @@ int ClientInterface::set_file_format(Interface &socket) {
     auto retval = impl()->getFileFormat();
     validate(f, retval, "set file format", DEC);
     LOG(logDEBUG1) << "File Format: " << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_file_format(Interface &socket) {
@@ -1094,7 +1155,8 @@ int ClientInterface::set_streaming_port(Interface &socket) {
     int retval = impl()->getStreamingPort();
     validate(port, retval, "set streaming port", DEC);
     LOG(logDEBUG1) << "streaming port:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_streaming_port(Interface &socket) {
@@ -1121,7 +1183,8 @@ int ClientInterface::set_streaming_source_ip(Interface &socket) {
            << ", but read " << retval << '\n';
         throw RuntimeError(os.str());
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_streaming_source_ip(Interface &socket) {
@@ -1143,7 +1206,8 @@ int ClientInterface::set_silent_mode(Interface &socket) {
     auto retval = static_cast<int>(impl()->getSilentMode());
     validate(value, retval, "set silent mode", DEC);
     LOG(logDEBUG1) << "silent mode:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_silent_mode(Interface &socket) {
@@ -1161,7 +1225,8 @@ int ClientInterface::restream_stop(Interface &socket) {
         LOG(logDEBUG1) << "Restreaming stop";
         impl()->restreamStop();
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_additional_json_header(Interface &socket) {
@@ -1178,7 +1243,8 @@ int ClientInterface::set_additional_json_header(Interface &socket) {
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting additional json header: " << sls::ToString(json);
     impl()->setAdditionalJsonHeader(json);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_additional_json_header(Interface &socket) {
@@ -1213,6 +1279,13 @@ int ClientInterface::set_udp_socket_buffer_size(Interface &socket) {
                  "set udp socket buffer size (No CAP_NET_ADMIN privileges?)",
                  DEC);
     LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval;
+    socket.Send(OK);
+    return OK;
+}
+
+int ClientInterface::get_udp_socket_buffer_size(Interface &socket) {
+    int64_t retval = impl()->getUDPSocketBufferSize();
+    LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval;
     return socket.sendResult(retval);
 }
 
@@ -1236,7 +1309,8 @@ int ClientInterface::set_frames_per_file(Interface &socket) {
     auto retval = static_cast<int>(impl()->getFramesPerFile());
     validate(index, retval, "set frames per file", DEC);
     LOG(logDEBUG1) << "frames per file:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_frames_per_file(Interface &socket) {
@@ -1270,7 +1344,8 @@ int ClientInterface::check_version_compatibility(Interface &socket) {
     } else {
         LOG(logINFO) << "Compatibility with Client: Successful";
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_discard_policy(Interface &socket) {
@@ -1284,7 +1359,8 @@ int ClientInterface::set_discard_policy(Interface &socket) {
     int retval = impl()->getFrameDiscardPolicy();
     validate(index, retval, "set discard policy", DEC);
     LOG(logDEBUG1) << "frame discard policy:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_discard_policy(Interface &socket) {
@@ -1305,7 +1381,8 @@ int ClientInterface::set_padding_enable(Interface &socket) {
     auto retval = static_cast<int>(impl()->getFramePaddingEnable());
     validate(index, retval, "set frame padding enable", DEC);
     LOG(logDEBUG1) << "Frame Padding Enable:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_padding_enable(Interface &socket) {
@@ -1331,7 +1408,8 @@ int ClientInterface::set_deactivated_padding_enable(
     auto retval = static_cast<int>(impl()->getDeactivatedPadding());
     validate(enable, retval, "set deactivated padding enable", DEC);
     LOG(logDEBUG1) << "Deactivated Padding Enable: " << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_deactivated_padding_enable(
@@ -1382,7 +1460,8 @@ int ClientInterface::set_adc_mask(Interface &socket) {
         throw RuntimeError(os.str());
     }
     LOG(logDEBUG1) << "1Gb ADC enable mask retval: " << retval;
-    return socket.sendResult(retval);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_dbit_list(Interface &socket) {
@@ -1397,7 +1476,8 @@ int ClientInterface::set_dbit_list(Interface &socket) {
     LOG(logDEBUG1) << "\n";
     verifyIdle(socket);
     impl()->setDbitList(args);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_dbit_list(Interface &socket) {
@@ -1424,7 +1504,8 @@ int ClientInterface::set_dbit_offset(Interface &socket) {
     int retval = impl()->getDbitOffset();
     validate(arg, retval, "set dbit offset", DEC);
     LOG(logDEBUG1) << "Dbit offset retval: " << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_dbit_offset(Interface &socket) {
@@ -1449,7 +1530,8 @@ int ClientInterface::set_quad_type(Interface &socket) {
     int retval = impl()->getQuad() ? 1 : 0;
     validate(quadEnable, retval, "set quad", DEC);
     LOG(logDEBUG1) << "quad retval:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_read_n_lines(Interface &socket) {
@@ -1462,7 +1544,8 @@ int ClientInterface::set_read_n_lines(Interface &socket) {
     int retval = impl()->getReadNLines();
     validate(arg, retval, "set read n lines", DEC);
     LOG(logDEBUG1) << "read n lines retval:" << retval;
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 sls::MacAddr ClientInterface::setUdpIp(sls::IpAddr arg) {
@@ -1476,9 +1559,7 @@ sls::MacAddr ClientInterface::setUdpIp(sls::IpAddr arg) {
         LOG(logERROR) << "Failed to get udp ethernet interface from IP " << arg << ". Got " << eth;
     }   
     impl()->setEthernetInterface(eth);
-    if (myDetectorType == EIGER) {
+
-        impl()->setEthernetInterface2(eth);
-    }
     // get mac address
     auto retval = sls::InterfaceNameToMac(eth);
     if (retval == 0) {
@@ -1496,55 +1577,13 @@ int ClientInterface::set_udp_ip(Interface &socket) {
     return socket.sendResult(retval);
 }
 
-sls::MacAddr ClientInterface::setUdpIp2(sls::IpAddr arg) {
-    // getting eth
-    std::string eth = sls::IpToInterfaceName(arg.str());
-    if (eth == "none") {
-        throw RuntimeError("Failed to get udp ethernet interface2 from IP " + arg.str());
-    }   
-    if (eth.find('.') != std::string::npos) {
-        eth = "";
-        LOG(logERROR) << "Failed to get udp ethernet interface2 from IP " << arg << ". Got " << eth;
-    }   
-    impl()->setEthernetInterface2(eth);
-
-    // get mac address
-    auto retval = sls::InterfaceNameToMac(eth);
-    if (retval == 0) {
-        throw RuntimeError("Failed to get udp mac adddress2 to listen to (eth:" + eth + ", ip:" + arg.str() + ")\n");
-    }
-    return retval;
-}
-
-int ClientInterface::set_udp_ip2(Interface &socket) {
-    auto arg = socket.Receive<sls::IpAddr>();
-    verifyIdle(socket);
-    if (myDetectorType != JUNGFRAU) {
-        throw RuntimeError("UDP Destination IP2 not implemented for this detector");
-    }
-    LOG(logINFO) << "Received UDP IP2: " << arg;
-    auto retval = setUdpIp2(arg);
-    LOG(logINFO) << "Receiver MAC Address2: " << retval;
-    return socket.sendResult(retval);
-}
-
 int ClientInterface::set_udp_port(Interface &socket) {
     auto arg = socket.Receive<int>();
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting UDP Port:" << arg;
     impl()->setUDPPortNumber(arg);
-    return socket.Send(OK);
+    socket.Send(OK);
-}
+    return OK;
-
-int ClientInterface::set_udp_port2(Interface &socket) {
-    auto arg = socket.Receive<int>();
-    verifyIdle(socket);
-    if (myDetectorType != JUNGFRAU && myDetectorType != EIGER) {
-        throw RuntimeError("UDP Destination Port2 not implemented for this detector");
-    }    
-    LOG(logDEBUG1) << "Setting UDP Port:" << arg;
-    impl()->setUDPPortNumber2(arg);
-    return socket.Send(OK);
 }
 
 int ClientInterface::set_num_interfaces(Interface &socket) {
@@ -1560,7 +1599,8 @@ int ClientInterface::set_num_interfaces(Interface &socket) {
     } catch(const RuntimeError &e) {
         throw RuntimeError("Failed to set number of interfaces to " + std::to_string(arg));
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_adc_mask_10g(Interface &socket) {
@@ -1580,7 +1620,8 @@ int ClientInterface::set_adc_mask_10g(Interface &socket) {
         throw RuntimeError(os.str());
     }
     LOG(logDEBUG1) << "10Gb ADC enable mask retval: " << retval;
-    return socket.sendResult(retval);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::set_num_counters(Interface &socket) {
@@ -1588,7 +1629,8 @@ int ClientInterface::set_num_counters(Interface &socket) {
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting counters: " << arg;
     impl()->setNumberofCounters(arg);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::increment_file_index(Interface &socket) {
@@ -1597,7 +1639,8 @@ int ClientInterface::increment_file_index(Interface &socket) {
         LOG(logDEBUG1) << "Incrementing file index";
         impl()->setFileIndex(impl()->getFileIndex() + 1);
     }
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 
@@ -1607,7 +1650,8 @@ int ClientInterface::set_additional_json_parameter(Interface &socket) {
     verifyIdle(socket);
     LOG(logDEBUG1) << "Setting additional json parameter (" << args[0] << "): " << args[1];
     impl()->setAdditionalJsonParameter(args[0], args[1]);
-    return socket.Send(OK);
+    socket.Send(OK);
+    return OK;
 }
 
 int ClientInterface::get_additional_json_parameter(Interface &socket) {

slsReceiverSoftware/src/ClientInterface.h

@@ -61,7 +61,8 @@ class ClientInterface : private virtual slsDetectorDefs {
 
     int exec_command(sls::ServerInterface &socket);
     int exit_server(sls::ServerInterface &socket);
-    int lock_receiver(sls::ServerInterface &socket);
+    int set_lock_server(sls::ServerInterface &socket);
+    int get_lock_server(sls::ServerInterface &socket);
     int get_last_client_ip(sls::ServerInterface &socket);
     int set_port(sls::ServerInterface &socket);
     int get_version(sls::ServerInterface &socket);
@@ -104,11 +105,14 @@ class ClientInterface : private virtual slsDetectorDefs {
     int get_overwrite(sls::ServerInterface &socket);
     int enable_tengiga(sls::ServerInterface &socket);
     int set_fifo_depth(sls::ServerInterface &socket);
+    int get_fifo_depth(sls::ServerInterface &socket);
     int set_activate(sls::ServerInterface &socket);
     int set_streaming(sls::ServerInterface &socket);
     int get_streaming(sls::ServerInterface &socket);
     int set_streaming_timer(sls::ServerInterface &socket);
+    int get_streaming_timer(sls::ServerInterface &socket);
     int set_flipped_data(sls::ServerInterface &socket);
+    int get_flipped_data(sls::ServerInterface &socket);
     int set_file_format(sls::ServerInterface &socket);
     int get_file_format(sls::ServerInterface &socket);
     int set_streaming_port(sls::ServerInterface &socket);
@@ -121,6 +125,7 @@ class ClientInterface : private virtual slsDetectorDefs {
     int set_additional_json_header(sls::ServerInterface &socket);
     int get_additional_json_header(sls::ServerInterface &socket);
     int set_udp_socket_buffer_size(sls::ServerInterface &socket);
+    int get_udp_socket_buffer_size(sls::ServerInterface &socket);
     int get_real_udp_socket_buffer_size(sls::ServerInterface &socket);
     int set_frames_per_file(sls::ServerInterface &socket);
     int get_frames_per_file(sls::ServerInterface &socket);
@@ -141,10 +146,7 @@ class ClientInterface : private virtual slsDetectorDefs {
     int set_read_n_lines(sls::ServerInterface &socket);
     sls::MacAddr setUdpIp(sls::IpAddr arg);
     int set_udp_ip(sls::ServerInterface &socket);
-    sls::MacAddr setUdpIp2(sls::IpAddr arg);
-    int set_udp_ip2(sls::ServerInterface &socket);
     int set_udp_port(sls::ServerInterface &socket);
-    int set_udp_port2(sls::ServerInterface &socket);
     int set_num_interfaces(sls::ServerInterface &socket);
     int set_adc_mask_10g(sls::ServerInterface &socket);  
     int set_num_counters(sls::ServerInterface &socket);  

slsReceiverSoftware/src/DataStreamer.cpp

@@ -17,7 +17,7 @@ const std::string DataStreamer::TypeName = "DataStreamer";
 
 
 DataStreamer::DataStreamer(int ind, Fifo* f, uint32_t* dr, ROI* r,
-		uint64_t* fi, int fd, int* nd, bool* qe, uint64_t* tot) :
+		uint64_t* fi, int fd, int* nr, bool* qe, uint64_t* tot) :
 		ThreadObject(ind, TypeName),
 		fifo(f),
 		dynamicRange(dr),
@@ -27,8 +27,8 @@ DataStreamer::DataStreamer(int ind, Fifo* f, uint32_t* dr, ROI* r,
 		quadEnable(qe),
 		totalNumFrames(tot)
 {
-	numDet[0] = nd[0];
+	numRx[0] = nr[0];
-	numDet[1] = nd[1];
+	numRx[1] = nr[1];
 	
     LOG(logDEBUG) << "DataStreamer " << ind << " created";
 }
@@ -74,9 +74,9 @@ void DataStreamer::SetGeneralData(GeneralData* g) {
 	generalData->Print();
 }
 
-void DataStreamer::SetNumberofDetectors(int* nd) {
+void DataStreamer::SetReceiverShape(int* nr) {
-	numDet[0] = nd[0];
+	numRx[0] = nr[0];
-	numDet[1] = nd[1];
+	numRx[1] = nr[1];
 }
 
 void DataStreamer::SetFlippedDataX(int fd) {
@@ -211,8 +211,8 @@ int DataStreamer::SendHeader(sls_receiver_header* rheader, uint32_t size, uint32
 
 	zHeader.dynamicRange = *dynamicRange;
 	zHeader.fileIndex = *fileIndex;
-	zHeader.ndetx = numDet[0];    
+	zHeader.nSocketX = numRx[0];    
-	zHeader.ndety = numDet[1];
+	zHeader.nSocketY = numRx[1];
     zHeader.npixelsx = nx;
     zHeader.npixelsy = ny;
     zHeader.imageSize = size;

slsReceiverSoftware/src/DataStreamer.h

@@ -29,12 +29,12 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
 	 * @param r roi
 	 * @param fi pointer to file index
 	 * @param fd flipped data enable for x dimension
-	 * @param nd pointer to number of detectors in each dimension
+	 * @param nd pointer to number of receivers in each dimension
 	 * @param qe pointer to quad Enable
 	 * @param tot pointer to total number of frames
 	 */
 	DataStreamer(int ind, Fifo* f, uint32_t* dr, ROI* r,
-			uint64_t* fi, int fd, int* nd, bool* qe, uint64_t* tot);
+			uint64_t* fi, int fd, int* nr, bool* qe, uint64_t* tot);
 
 	/**
 	 * Destructor
@@ -60,10 +60,10 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
 	void SetGeneralData(GeneralData* g);
 
 	/** 
-	 * Set number of detectors
+	 * Set receiver shape
-	 * @param number of detectors in both dimensions
+	 * @param number of receivers in both dimensions
 	 */
-	void SetNumberofDetectors(int* nd);
+	void SetReceiverShape(int* nr);
 
 	/** 
 	 * Set Flipped data enable across x dimension
@@ -178,8 +178,8 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
 	/** Complete buffer used for roi, eg. shortGotthard */
 	char* completeBuffer{nullptr};
 
-	/** Number of Detectors in X and Y dimension */
+	/** Number of Recievers in X and Y dimension */
-	int numDet[2];
+	int numRx[2];
 
 	/** Quad Enable */
 	bool* quadEnable;

slsReceiverSoftware/src/GeneralData.h

@@ -64,9 +64,6 @@ public:
 	/** Default Fifo depth */
 	uint32_t defaultFifoDepth;
 
-	/** Threads per receiver */
-	uint32_t threadsPerReceiver;
-
 	/** Size of a header packet */
 	uint32_t headerPacketSize;
 
@@ -105,7 +102,6 @@ public:
 		maxFramesPerFile(0),
 		fifoBufferHeaderSize(0),
 		defaultFifoDepth(0),
-		threadsPerReceiver(1),
 		headerPacketSize(0),
 		nPixelsXComplete(0),
 		nPixelsYComplete(0),
@@ -233,7 +229,6 @@ public:
 		LOG(level) << "Max Frames Per File: " << maxFramesPerFile;
 		LOG(level) << "Fifo Buffer Header Size: " << fifoBufferHeaderSize;
 		LOG(level) << "Default Fifo Depth: " << defaultFifoDepth;
-		LOG(level) << "Threads Per Receiver: " << threadsPerReceiver;
 		LOG(level) << "Header Packet Size: " << headerPacketSize;
 		LOG(level) << "Complete Pixels X: " << nPixelsXComplete;
 		LOG(level) << "Complete Pixels Y: " << nPixelsYComplete;
@@ -415,7 +410,6 @@ class EigerData : public GeneralData {
 		maxFramesPerFile 	= EIGER_MAX_FRAMES_PER_FILE;
 		fifoBufferHeaderSize= FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
 		defaultFifoDepth 	= 1000;
-		threadsPerReceiver	= 2;
 		headerPacketSize	= 40;
 		standardheader		= true;
 	};
@@ -479,7 +473,6 @@ class JungfrauData : public GeneralData {
     		nPixelsY 					= 256;
     		packetsPerFrame 			= 64;
     		imageSize 					= dataSize * packetsPerFrame;
-    		threadsPerReceiver			= 2;
     		defaultUdpSocketBufferSize 	= (500 * 1024 * 1024);
 
     	}
@@ -488,7 +481,6 @@ class JungfrauData : public GeneralData {
     		nPixelsY 					= 512;
     		packetsPerFrame 			= 128;
     		imageSize 					= dataSize * packetsPerFrame;
-    		threadsPerReceiver			= 1;
     		defaultUdpSocketBufferSize 	= (1000 * 1024 * 1024);
     	}
     }

slsReceiverSoftware/src/Implementation.h

@@ -29,7 +29,7 @@ class Implementation : private virtual slsDetectorDefs {
 
     void setDetectorType(const detectorType d);
     int *getMultiDetectorSize() const;
-    void setMultiDetectorSize(const int *size);
+    void setDetectorSize(const int *size);
     int getDetectorPositionId() const;
     void setDetectorPositionId(const int id);
     std::string getDetectorHostname() const;
@@ -76,12 +76,12 @@ class Implementation : private virtual slsDetectorDefs {
     uint64_t getFramesCaught() const;
     uint64_t getAcquisitionIndex() const;
     int getProgress() const;
-    std::vector<uint64_t> getNumMissingPackets() const;
+    uint64_t getNumMissingPackets() const;
     void startReceiver();
     void setStoppedFlag(bool stopped);
     void stopReceiver();
     void startReadout();
-    void shutDownUDPSockets();
+    void shutDownUDPSocket();
     void closeFiles();
     void restreamStop();
 
@@ -91,19 +91,15 @@ class Implementation : private virtual slsDetectorDefs {
      *   Network Configuration (UDP)                   *
      *                                                 *
      * ************************************************/
+    int getInterfaceId() const;
+    void setInterfaceId(const int value);
     int getNumberofUDPInterfaces() const;
     /* [Jungfrau] */
     void setNumberofUDPInterfaces(const int n);
     std::string getEthernetInterface() const;
     void setEthernetInterface(const std::string &c);
-    std::string getEthernetInterface2() const;
-    /* [Jungfrau] */
-    void setEthernetInterface2(const std::string &c);
     uint32_t getUDPPortNumber() const;
     void setUDPPortNumber(const uint32_t i);
-    uint32_t getUDPPortNumber2() const;
-    /* [Eiger][Jungfrau] */
-    void setUDPPortNumber2(const uint32_t i);
     int64_t getUDPSocketBufferSize() const;
     void setUDPSocketBufferSize(const int64_t s);
     int64_t getActualUDPSocketBufferSize() const;    
@@ -226,7 +222,7 @@ class Implementation : private virtual slsDetectorDefs {
     void SetupFifoStructure();
     
     void ResetParametersforNewAcquisition();
-    void CreateUDPSockets();
+    void CreateUDPSocket();
     void SetupWriter();
     void StartRunning();
 
@@ -238,9 +234,9 @@ class Implementation : private virtual slsDetectorDefs {
      * ************************************************/
  
     // config parameters
-    int numThreads;
     detectorType myDetectorType;
     int numDet[MAX_DIMENSIONS];
+    int numRx[MAX_DIMENSIONS];
     int detID;
     std::string detHostname;
     bool silentMode;
@@ -263,9 +259,10 @@ class Implementation : private virtual slsDetectorDefs {
     bool stoppedFlag;
 
     // network configuration (UDP)
+    int interfaceId;
     int numUDPInterfaces;
-    std::vector <std::string> eth;
+    std::string eth;
-    std::vector <uint32_t> udpPortNum;
+    uint32_t udpPortNum;
     int64_t udpSocketBufferSize;
     int64_t actualUDPSocketBufferSize;
 
@@ -318,8 +315,8 @@ class Implementation : private virtual slsDetectorDefs {
 
     // class objects
     GeneralData *generalData;
-    std::vector<std::unique_ptr<Listener>> listener;
+    std::unique_ptr<Listener> listener;
-    std::vector<std::unique_ptr<DataProcessor>> dataProcessor;
+    std::unique_ptr<DataProcessor> dataProcessor;
-    std::vector<std::unique_ptr<DataStreamer>> dataStreamer;
+    std::unique_ptr<DataStreamer> dataStreamer;
-    std::vector<std::unique_ptr<Fifo>> fifo;
+    std::unique_ptr<Fifo> fifo;
 };

slsReceiverSoftware/src/Listener.cpp

@@ -112,7 +112,7 @@ void Listener::SetGeneralData(GeneralData* g) {
 }
 
 
-void Listener::CreateUDPSockets() {
+void Listener::CreateUDPSocket() {
     if (!(*activated)) {
     	return;
     }

slsReceiverSoftware/src/Listener.h

@@ -83,9 +83,9 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
 	void SetGeneralData(GeneralData* g);
 
 	/**
-	 * Creates UDP Sockets
+	 * Creates UDP Socket
 	 */
-	void CreateUDPSockets();
+	void CreateUDPSocket();
 
 	/**
 	 * Shuts down and deletes UDP Sockets

slsSupportLib/include/ZmqSocket.h

@@ -26,10 +26,10 @@ struct zmqHeader {
   uint32_t jsonversion{0};
   uint32_t dynamicRange{0};
   uint64_t fileIndex{0};
-  /** number of detectors in x axis */
+  /** number of sockets in x axis */
-  uint32_t ndetx{0}; 
+  uint32_t nSocketX{0}; 
-  /** number of detectors in y axis */
+  /** number of sockets in y axis */
-  uint32_t ndety{0}; 
+  uint32_t nSocketY{0}; 
   /** number of pixels/channels in x axis for this zmq socket */
   uint32_t npixelsx{0};
   /** number of pixels/channels in y axis for this zmq socket */

slsSupportLib/include/sls_detector_defs.h

@@ -32,6 +32,7 @@
 
 /** default ports */
 #define DEFAULT_PORTNO 1952
+#define DEFAULT_RX_PORTNO 1954
 #define DEFAULT_UDP_PORTNO 50001
 #define DEFAULT_ZMQ_CL_PORTNO 30001
 #define DEFAULT_ZMQ_RX_PORTNO 30001
@@ -466,9 +467,11 @@ class slsDetectorDefs {
      */ 
     struct rxParameters {
         detectorType detType{GENERIC};
-        xy multiSize;
+        xy detectorSize;
-        int detId{0};
+        int moduleId{0};
         char hostname[MAX_STR_LENGTH];
+        int interfaceId{0};
+        uint32_t zmq_ip{0U};
         int udpInterfaces{1};
         int udp_dstport{0};
         uint32_t udp_dstip{0U};

slsSupportLib/include/sls_detector_funcs.h

@@ -204,7 +204,8 @@ enum detFuncs{
 
 	F_EXEC_RECEIVER_COMMAND,
 	F_EXIT_RECEIVER,
-	F_LOCK_RECEIVER,
+	F_SET_LOCK_RECEIVER,
+	F_GET_LOCK_RECEIVER,
 	F_GET_LAST_RECEIVER_CLIENT_IP,
 	F_SET_RECEIVER_PORT,
 	F_GET_RECEIVER_VERSION, 
@@ -244,11 +245,14 @@ enum detFuncs{
 	F_GET_RECEIVER_OVERWRITE,
 	F_ENABLE_RECEIVER_TEN_GIGA,
 	F_SET_RECEIVER_FIFO_DEPTH,
+	F_GET_RECEIVER_FIFO_DEPTH,
 	F_RECEIVER_ACTIVATE,
 	F_SET_RECEIVER_STREAMING,
 	F_GET_RECEIVER_STREAMING,
-	F_RECEIVER_STREAMING_TIMER,
+	F_SET_RECEIVER_STREAMING_TIMER,
+	F_GET_RECEIVER_STREAMING_TIMER,
 	F_SET_FLIPPED_DATA_RECEIVER,
+	F_GET_FLIPPED_DATA_RECEIVER,
 	F_SET_RECEIVER_FILE_FORMAT,
 	F_GET_RECEIVER_FILE_FORMAT,
 	F_SET_RECEIVER_STREAMING_PORT,
@@ -260,8 +264,9 @@ enum detFuncs{
 	F_RESTREAM_STOP_FROM_RECEIVER,
 	F_SET_ADDITIONAL_JSON_HEADER,
 	F_GET_ADDITIONAL_JSON_HEADER,
-	F_RECEIVER_UDP_SOCK_BUF_SIZE,
+	F_SET_RECEIVER_UDP_SOCK_BUF_SIZE,
-	F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE,
+	F_GET_RECEIVER_UDP_SOCK_BUF_SIZE,
+	F_GET_RECEIVER_REAL_UDP_SOCK_BUF_SIZE,
 	F_SET_RECEIVER_FRAMES_PER_FILE,
 	F_GET_RECEIVER_FRAMES_PER_FILE,
 	F_RECEIVER_CHECK_VERSION,
@@ -280,9 +285,7 @@ enum detFuncs{
 	F_SET_RECEIVER_QUAD,
 	F_SET_RECEIVER_READ_N_LINES,
 	F_SET_RECEIVER_UDP_IP,
-	F_SET_RECEIVER_UDP_IP2,
 	F_SET_RECEIVER_UDP_PORT,
-	F_SET_RECEIVER_UDP_PORT2,
 	F_SET_RECEIVER_NUM_INTERFACES,
 	F_RECEIVER_SET_ADC_MASK_10G,
 	F_RECEIVER_SET_NUM_COUNTERS,
@@ -492,7 +495,8 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
 
 	case F_EXEC_RECEIVER_COMMAND:			return "F_EXEC_RECEIVER_COMMAND";
 	case F_EXIT_RECEIVER: 					return "F_EXIT_RECEIVER";
-	case F_LOCK_RECEIVER: 					return "F_LOCK_RECEIVER";
+	case F_SET_LOCK_RECEIVER: 				return "F_SET_LOCK_RECEIVER";
+	case F_GET_LOCK_RECEIVER: 				return "F_GET_LOCK_RECEIVER";
 	case F_GET_LAST_RECEIVER_CLIENT_IP: 	return "F_GET_LAST_RECEIVER_CLIENT_IP";
 	case F_SET_RECEIVER_PORT: 				return "F_SET_RECEIVER_PORT";
 	case F_GET_RECEIVER_VERSION: 			return "F_GET_RECEIVER_VERSION";
@@ -533,11 +537,14 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
 	case F_GET_RECEIVER_OVERWRITE:			return "F_GET_RECEIVER_OVERWRITE";
 	case F_ENABLE_RECEIVER_TEN_GIGA:		return "F_ENABLE_RECEIVER_TEN_GIGA";
 	case F_SET_RECEIVER_FIFO_DEPTH:			return "F_SET_RECEIVER_FIFO_DEPTH";
+	case F_GET_RECEIVER_FIFO_DEPTH:			return "F_GET_RECEIVER_FIFO_DEPTH";
 	case F_RECEIVER_ACTIVATE:				return "F_RECEIVER_ACTIVATE";
 	case F_SET_RECEIVER_STREAMING:			return "F_SET_RECEIVER_STREAMING";
 	case F_GET_RECEIVER_STREAMING:			return "F_GET_RECEIVER_STREAMING";
-	case F_RECEIVER_STREAMING_TIMER:		return "F_RECEIVER_STREAMING_TIMER";
+	case F_SET_RECEIVER_STREAMING_TIMER:	return "F_SET_RECEIVER_STREAMING_TIMER";
+	case F_GET_RECEIVER_STREAMING_TIMER:	return "F_GET_RECEIVER_STREAMING_TIMER";
 	case F_SET_FLIPPED_DATA_RECEIVER:		return "F_SET_FLIPPED_DATA_RECEIVER";
+	case F_GET_FLIPPED_DATA_RECEIVER:		return "F_GET_FLIPPED_DATA_RECEIVER";
 	case F_SET_RECEIVER_FILE_FORMAT:		return "F_SET_RECEIVER_FILE_FORMAT";
 	case F_GET_RECEIVER_FILE_FORMAT:		return "F_GET_RECEIVER_FILE_FORMAT";
 	case F_SET_RECEIVER_STREAMING_PORT: 	return "F_SET_RECEIVER_STREAMING_PORT";
@@ -549,8 +556,9 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
 	case F_RESTREAM_STOP_FROM_RECEIVER:		return "F_RESTREAM_STOP_FROM_RECEIVER";
     case F_SET_ADDITIONAL_JSON_HEADER:      return "F_SET_ADDITIONAL_JSON_HEADER";
     case F_GET_ADDITIONAL_JSON_HEADER:      return "F_GET_ADDITIONAL_JSON_HEADER";
-    case F_RECEIVER_UDP_SOCK_BUF_SIZE:  	return "F_RECEIVER_UDP_SOCK_BUF_SIZE";
+    case F_SET_RECEIVER_UDP_SOCK_BUF_SIZE:  return "F_SET_RECEIVER_UDP_SOCK_BUF_SIZE";
-    case F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE: return "F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE";
+    case F_GET_RECEIVER_UDP_SOCK_BUF_SIZE:  return "F_GET_RECEIVER_UDP_SOCK_BUF_SIZE";
+    case F_GET_RECEIVER_REAL_UDP_SOCK_BUF_SIZE: return "F_GET_RECEIVER_REAL_UDP_SOCK_BUF_SIZE";
     case F_SET_RECEIVER_FRAMES_PER_FILE:	return "F_SET_RECEIVER_FRAMES_PER_FILE";
     case F_GET_RECEIVER_FRAMES_PER_FILE:	return "F_GET_RECEIVER_FRAMES_PER_FILE";
     case F_RECEIVER_CHECK_VERSION:			return "F_RECEIVER_CHECK_VERSION";
@@ -569,9 +577,7 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
 	case F_SET_RECEIVER_QUAD:				return "F_SET_RECEIVER_QUAD";
 	case F_SET_RECEIVER_READ_N_LINES:		return "F_SET_RECEIVER_READ_N_LINES";
 	case F_SET_RECEIVER_UDP_IP:				return "F_SET_RECEIVER_UDP_IP";
-	case F_SET_RECEIVER_UDP_IP2:			return "F_SET_RECEIVER_UDP_IP2";
 	case F_SET_RECEIVER_UDP_PORT:			return "F_SET_RECEIVER_UDP_PORT";
-	case F_SET_RECEIVER_UDP_PORT2:			return "F_SET_RECEIVER_UDP_PORT2";
 	case F_SET_RECEIVER_NUM_INTERFACES:		return "F_SET_RECEIVER_NUM_INTERFACES";
 	case F_RECEIVER_SET_ADC_MASK_10G:		return "F_RECEIVER_SET_ADC_MASK_10G";
 	case F_RECEIVER_SET_NUM_COUNTERS:		return "F_RECEIVER_SET_NUM_COUNTERS";

slsSupportLib/src/ZmqSocket.cpp

@@ -187,8 +187,8 @@ int ZmqSocket::SendHeader(
             header.jsonversion, 
             header.dynamicRange, 
             header.fileIndex, 
-            header.ndetx,
+            header.nSocketX,
-            header.ndety, 
+            header.nSocketY, 
             header.npixelsx, 
             header.npixelsy, 
             header.imageSize, 
@@ -319,8 +319,8 @@ int ZmqSocket::ParseHeader(const int index, int length, char *buff,
     zHeader.data = ((document["data"].GetUint()) == 0) ? false : true;
     zHeader.dynamicRange = document["bitmode"].GetUint();
     zHeader.fileIndex = document["fileIndex"].GetUint64(); 
-    zHeader.ndetx = document["detshape"][0].GetUint();
+    zHeader.nSocketX = document["detshape"][0].GetUint();
-    zHeader.ndety = document["detshape"][1].GetUint();
+    zHeader.nSocketY = document["detshape"][1].GetUint();
     zHeader.npixelsx = document["shape"][0].GetUint();
     zHeader.npixelsy = document["shape"][1].GetUint();
     zHeader.imageSize = document["size"].GetUint();