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

WIP

Browse Source
This commit is contained in:
maliakal_d 2020-04-08 20:27:10 +02:00
parent b3fe0e79bc
commit 38c31fdada
7 changed files with 372 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -6839,6 +6839,47 @@ int get_receiver_parameters(int file_des) {
uint32_t u32 = 0;
uint64_t u64 = 0;
// udp interfaces
#ifdef JUNGFRAUD
i32 = getNumberofUDPInterfaces();
#else
i32 = 1;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst port
i32 = udpDetails.dstport;
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst ip
u32 = udpDetails.dstip;
u32 = __builtin_bswap32(u32);
n = sendData(file_des,&u32,sizeof(u32),INT32);
if (n < 0) return printSocketReadError();
// udp dst mac
u64 = udpDetails.dstmac;
n = sendData(file_des,&u64,sizeof(u64),INT64);
if (n < 0) return printSocketReadError();
// udp dst port2
i32 = udpDetails.dstport2;
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst ip2
u32 = udpDetails.dstip2;
u32 = __builtin_bswap32(u32);
n = sendData(file_des,&u32,sizeof(u32),INT32);
if (n < 0) return printSocketReadError();
// udp dst mac2
u64 = udpDetails.dstmac2;
n = sendData(file_des,&u64,sizeof(u64),INT64);
if (n < 0) return printSocketReadError();
// frames
i64 = getNumFrames();
n = sendData(file_des,&i64,sizeof(i64),INT64);
@ -6904,9 +6945,23 @@ int get_receiver_parameters(int file_des) {
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
// activate
#ifdef EIGERD
i32 = activate(-1);
#else
i32 = 0;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// quad
#ifdef EIGERD
i32 = getQuad();
#else
i32 = 0;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// dynamic range
i32 = setDynamicRange(-1);
@ -6918,15 +6973,6 @@ int get_receiver_parameters(int file_des) {
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// activate
#ifdef EIGERD
i32 = activate(-1);
#else
i32 = 0;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// 10 gbe
#if defined(EIGERD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
i32 = enableTenGigabitEthernet(-1);
@ -6936,15 +6982,6 @@ int get_receiver_parameters(int file_des) {
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// quad
#ifdef EIGERD
i32 = getQuad();
#else
i32 = 0;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// readout mode
#ifdef CHIPTESTBOARD
i32 = getReadoutMode();
@ -7005,49 +7042,5 @@ int get_receiver_parameters(int file_des) {
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp interfaces
#ifdef JUNGFRAUD
i32 = getNumberofUDPInterfaces();
#else
i32 = 1;
#endif
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst port
i32 = udpDetails.dstport;
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst ip
u32 = udpDetails.dstip;
u32 = __builtin_bswap32(u32);
n = sendData(file_des,&u32,sizeof(u32),INT32);
if (n < 0) return printSocketReadError();
// udp dst mac
u64 = udpDetails.dstmac;
n = sendData(file_des,&u64,sizeof(u64),INT64);
if (n < 0) return printSocketReadError();
// udp dst port2
i32 = udpDetails.dstport2;
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
// udp dst ip2
u32 = udpDetails.dstip2;
u32 = __builtin_bswap32(u32);
n = sendData(file_des,&u32,sizeof(u32),INT32);
if (n < 0) return printSocketReadError();
// udp dst mac2
u64 = udpDetails.dstmac2;
n = sendData(file_des,&u64,sizeof(u64),INT64);
if (n < 0) return printSocketReadError();
return OK;
}

271
slsDetectorSoftware/src/Module.cpp
View File

@ -526,27 +526,6 @@ Module::getTypeFromDetector(const std::string &hostname, int cport) {
return retval;
}
int Module::setDetectorType(detectorType const type) {
int fnum = F_GET_DETECTOR_TYPE;
detectorType retval = GENERIC;
LOG(logDEBUG1) << "Setting detector type to " << type;
// if unspecified, then get from detector
if (type == GET_DETECTOR_TYPE) {
sendToDetector(fnum, nullptr, retval);
shm()->myDetectorType = static_cast<detectorType>(retval);
LOG(logDEBUG1) << "Detector Type: " << retval;
}
if (shm()->useReceiverFlag) {
auto arg = static_cast<int>(shm()->myDetectorType);
retval = GENERIC;
LOG(logDEBUG1) << "Sending detector type to Receiver: " << arg;
sendToReceiver(F_SET_RECEIVER_TYPE, arg, retval);
LOG(logDEBUG1) << "Receiver Type: " << retval;
}
return retval;
}
slsDetectorDefs::detectorType Module::getDetectorType() const {
return shm()->myDetectorType;
}
@ -1510,14 +1489,13 @@ uint32_t Module::clearBit(uint32_t addr, int n) {
}
}
std::string Module::setReceiverHostname(const std::string &receiverIP) {
void Module::setReceiverHostname(const std::string &receiverIP) {
LOG(logDEBUG1) << "Setting up Receiver with " << receiverIP;
// recieverIP is none
if (receiverIP == "none") {
memset(shm()->rxHostname, 0, MAX_STR_LENGTH);
sls::strcpy_safe(shm()->rxHostname, "none");
shm()->useReceiverFlag = false;
return std::string(shm()->rxHostname);
}
// stop acquisition if running
@ -1537,96 +1515,31 @@ std::string Module::setReceiverHostname(const std::string &receiverIP) {
shm()->useReceiverFlag = true;
checkReceiverVersionCompatibility();
if (setDetectorType(shm()->myDetectorType) != GENERIC) {
sendMultiDetectorSize();
setDetectorId();
setDetectorHostname();
// setup udp
updateRxDestinationUDPIP();
setDestinationUDPPort(getDestinationUDPPort());
if (shm()->myDetectorType == JUNGFRAU || shm()->myDetectorType == EIGER ) {
setDestinationUDPPort2(getDestinationUDPPort2());
}
if (shm()->myDetectorType == JUNGFRAU) {
updateRxDestinationUDPIP2();
setNumberofUDPInterfaces(getNumberofUDPInterfaces());
}
LOG(logDEBUG1) << printReceiverConfiguration();
setReceiverUDPSocketBufferSize(0);
setNumberOfFrames(getNumberOfFrames());
setNumberOfTriggers(getNumberOfTriggers());
setTimingMode(getTimingMode());
setExptime(getExptime());
setPeriod(getPeriod());
// detector specific
switch (shm()->myDetectorType) {
case EIGER:
setSubExptime(getSubExptime());
setSubDeadTime(getSubDeadTime());
setDynamicRange(getDynamicRange());
activate(-1);
enableTenGigabitEthernet(-1);
setQuad(getQuad());
break;
case CHIPTESTBOARD:
setNumberOfAnalogSamples(getNumberOfAnalogSamples());
setNumberOfDigitalSamples(getNumberOfDigitalSamples());
enableTenGigabitEthernet(-1);
setReadoutMode(getReadoutMode());
setADCEnableMask(getADCEnableMask());
setTenGigaADCEnableMask(getTenGigaADCEnableMask());
break;
case MOENCH:
setNumberOfAnalogSamples(getNumberOfAnalogSamples());
enableTenGigabitEthernet(-1);
setADCEnableMask(getADCEnableMask());
setTenGigaADCEnableMask(getTenGigaADCEnableMask());
break;
case GOTTHARD:
setROI(getROI());
break;
case MYTHEN3:
sendNumberofCounterstoReceiver(getCounterMask());
setDynamicRange(getDynamicRange());
break;
case GOTTHARD2:
setNumberOfBursts(getNumberOfBursts());
setBurstMode(getBurstMode());
break;
default:
break;
}
// to use rx_hostname if empty and also update client zmqip
updateReceiverStreamingIP();
test();
}
return std::string(shm()->rxHostname);
}
void Module::test() {
// populate parameters for receiver
int n = 0;
rxParameters retval;
rxParameters retval;
// populate from shared memory
retval.detType = shm()->myDetectorType;
n += sizeof(retval.detType);
retval.multiSize.x = shm()->multiSize.x;
retval.multiSize.y = shm()->multiSize.y;
n += sizeof(retval.multiSize);
retval.detId = detId;
n += sizeof(retval.detId);
memset(retval.hostname, 0, sizeof(retval.hostname));
strcpy_safe(retval.hostname, shm()->hostname);
n += sizeof(retval.hostname);
// populate from detector
auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
client.sendCommandThenRead(F_GET_RECEIVER_PARAMETERS, nullptr, 0, nullptr, 0);
n += client.Receive(&retval.udpInterfaces, sizeof(retval.udpInterfaces));
n += client.Receive(&retval.udp_dstport, sizeof(retval.udp_dstport));
n += client.Receive(&retval.udp_dstip, sizeof(retval.udp_dstip));
n += client.Receive(&retval.udp_dstmac, sizeof(retval.udp_dstmac));
n += client.Receive(&retval.udp_dstport2, sizeof(retval.udp_dstport2));
n += client.Receive(&retval.udp_dstip2, sizeof(retval.udp_dstip2));
n += client.Receive(&retval.udp_dstmac2, sizeof(retval.udp_dstmac2));
n += client.Receive(&retval.frames, sizeof(retval.frames));
n += client.Receive(&retval.triggers, sizeof(retval.triggers));
n += client.Receive(&retval.bursts, sizeof(retval.bursts));
@ -1636,12 +1549,11 @@ void Module::test() {
n += client.Receive(&retval.periodNs, sizeof(retval.periodNs));
n += client.Receive(&retval.subExpTimeNs, sizeof(retval.subExpTimeNs));
n += client.Receive(&retval.subDeadTimeNs, sizeof(retval.subDeadTimeNs));
n += client.Receive(&retval.activate, sizeof(retval.activate));
n += client.Receive(&retval.quad, sizeof(retval.quad));
n += client.Receive(&retval.dynamicRange, sizeof(retval.dynamicRange));
n += client.Receive(&retval.timMode, sizeof(retval.timMode));
n += client.Receive(&retval.activate, sizeof(retval.activate));
n += client.Receive(&retval.tenGiga, sizeof(retval.tenGiga));
n += client.Receive(&retval.quad, sizeof(retval.quad));
n += client.Receive(&retval.roMode, sizeof(retval.roMode));
n += client.Receive(&retval.adcMask, sizeof(retval.adcMask));
n += client.Receive(&retval.adc10gMask, sizeof(retval.adc10gMask));
@ -1650,51 +1562,70 @@ void Module::test() {
n += client.Receive(&retval.countermask, sizeof(retval.countermask));
n += client.Receive(&retval.burstType, sizeof(retval.burstType));
n += client.Receive(&retval.udpInterfaces, sizeof(retval.udpInterfaces));
n += client.Receive(&retval.udp_dstport, sizeof(retval.udp_dstport));
n += client.Receive(&retval.udp_dstip, sizeof(retval.udp_dstip));
n += client.Receive(&retval.udp_dstmac, sizeof(retval.udp_dstmac));
n += client.Receive(&retval.udp_dstport2, sizeof(retval.udp_dstport2));
n += client.Receive(&retval.udp_dstip2, sizeof(retval.udp_dstip2));
n += client.Receive(&retval.udp_dstmac2, sizeof(retval.udp_dstmac2));
LOG(logINFO) << "n:" << n << " retvalsize:" << sizeof(retval);
if (n != sizeof(retval)) {
throw RuntimeError("Could not get parameters from detector to configure receiver");
}
LOG(logINFO)
<< "detType:" << retval.detType << std::endl
<< "multiSize.x:" << retval.multiSize.x << std::endl
<< "multiSize.y:" << retval.multiSize.y << std::endl
<< "detId:" << retval.detId << std::endl
<< "hostname:" << retval.hostname << std::endl
<< "udpInterfaces:" << retval.udpInterfaces << std::endl
<< "udp_dstport:" << retval.udp_dstport << std::endl
<< "udp_dstip:" << sls::IpAddr(retval.udp_dstip) << std::endl
<< "udp_dstmac:" << sls::MacAddr(retval.udp_dstmac) << std::endl
<< "udp_dstport2:" << retval.udp_dstport2 << std::endl
<< "udp_dstip2:" << sls::IpAddr(retval.udp_dstip2) << std::endl
<< "udp_dstmac2:" << sls::MacAddr(retval.udp_dstmac2) << std::endl
<< "frames:" << retval.frames << std::endl
<< "triggers:" << retval.triggers << std::endl
<< "bursts:" << retval.bursts << std::endl
<< "analogSamples:" << retval.analogSamples << std::endl
<< "digitalSamples:" << retval.digitalSamples << std::endl
<< "expTimeNs:" << retval.expTimeNs << std::endl
<< "periodNs:" << retval.periodNs << std::endl
<< "subExpTimeNs:" << retval.subExpTimeNs << std::endl
<< "subDeadTimeNs:" << retval.subDeadTimeNs << std::endl
<< "activate:" << retval.activate << std::endl
<< "quad:" << retval.quad << std::endl
<< "dynamicRange:" << retval.dynamicRange << std::endl
<< "timMode:" << retval.timMode << std::endl
<< "tenGiga:" << retval.tenGiga << std::endl
<< "roMode:" << retval.roMode << std::endl
<< "adcMask:" << retval.adcMask << std::endl
<< "adc10gMask:" << retval.adc10gMask << std::endl
<< "roi.xmin:" << retval.roi.xmin << std::endl
<< "roi.xmax:" << retval.roi.xmax << std::endl
<< "countermask:" << retval.countermask << std::endl
<< "burstType:" << retval.burstType << std::endl;
LOG(logINFO) << "detType:" << retval.detType;
LOG(logINFO) << "frames:" << retval.frames;
LOG(logINFO) << "triggers:" << retval.triggers;
LOG(logINFO) << "bursts:" << retval.bursts;
LOG(logINFO) << "analogSamples:" << retval.analogSamples;
LOG(logINFO) << "digitalSamples:" << retval.digitalSamples;
LOG(logINFO) << "expTimeNs:" << retval.expTimeNs;
LOG(logINFO) << "periodNs:" << retval.periodNs;
LOG(logINFO) << "subExpTimeNs:" << retval.subExpTimeNs;
LOG(logINFO) << "subDeadTimeNs:" << retval.subDeadTimeNs;
sls::MacAddr retvals[2];
sendToReceiver(F_SETUP_RECEIVER, retval, retvals);
// update detectors with dest mac
if (retval.udp_dstmac == 0 && retvals[0] != 0) {
LOG(logINFO) << "Setting destination udp mac of "
"detector " << detId << " to " << retvals[0];
sendToDetector(F_SET_DEST_UDP_MAC, retvals[0], nullptr);
}
if (retval.udp_dstmac2 == 0 && retvals[1] != 0) {
LOG(logINFO) << "Setting destination udp mac2 of "
"detector " << detId << " to " << retvals[1];
sendToDetector(F_SET_DEST_UDP_MAC2, retvals[1], nullptr);
}
LOG(logINFO) << "dynamicRange:" << retval.dynamicRange;
LOG(logINFO) << "timMode:" << retval.timMode;
LOG(logINFO) << "activate:" << retval.activate;
LOG(logINFO) << "tenGiga:" << retval.tenGiga;
LOG(logINFO) << "quad:" << retval.quad;
LOG(logINFO) << "roMode:" << retval.roMode;
LOG(logINFO) << "adcMask:" << retval.adcMask;
LOG(logINFO) << "adc10gMask:" << retval.adc10gMask;
LOG(logINFO) << "roi.xmin:" << retval.roi.xmin;
LOG(logINFO) << "roi.xmax:" << retval.roi.xmax;
LOG(logINFO) << "countermask:" << retval.countermask;
LOG(logINFO) << "burstType:" << retval.burstType;
// update numinterfaces if different
shm()->numUDPInterfaces = retval.udpInterfaces;
LOG(logINFO) << "udpInterfaces:" << retval.udpInterfaces;
LOG(logINFO) << "udp_dstport:" << retval.udp_dstport;
LOG(logINFO) << "udp_dstip:" << sls::IpAddr(retval.udp_dstip);
LOG(logINFO) << "udp_dstmac:" << sls::MacAddr(retval.udp_dstmac);
LOG(logINFO) << "udp_dstport2:" << retval.udp_dstport2;
LOG(logINFO) << "udp_dstip2:" << sls::IpAddr(retval.udp_dstip2);
LOG(logINFO) << "udp_dstmac2:" << sls::MacAddr(retval.udp_dstmac2);
if (shm()->myDetectorType == MOENCH) {
setAdditionalJsonParameter("adcmask_1g", std::to_string(retval.adcMask));
setAdditionalJsonParameter("adcmask_10g", std::to_string(retval.adc10gMask));
}
// to use rx_hostname if empty and also update client zmqip
updateReceiverStreamingIP();
}
std::string Module::getReceiverHostname() const {
@ -1789,13 +1720,6 @@ sls::IpAddr Module::getDestinationUDPIP() {
return retval;
}
void Module::updateRxDestinationUDPIP() {
auto ip = getDestinationUDPIP();
if (ip != 0) {
setDestinationUDPIP(ip);
}
}
void Module::setDestinationUDPIP2(const IpAddr ip) {
LOG(logDEBUG1) << "Setting destination udp ip2 to " << ip;
if (ip == 0) {
@ -1819,13 +1743,6 @@ sls::IpAddr Module::getDestinationUDPIP2() {
return retval;
}
void Module::updateRxDestinationUDPIP2() {
auto ip = getDestinationUDPIP2();
if (ip != 0) {
setDestinationUDPIP2(ip);
}
}
void Module::setDestinationUDPMAC(const MacAddr mac) {
LOG(logDEBUG1) << "Setting destination udp mac to " << mac;
if (mac == 0) {
@ -2970,38 +2887,6 @@ void Module::execReceiverCommand(const std::string &cmd) {
}
}
void Module::sendMultiDetectorSize() {
int args[]{shm()->multiSize.x, shm()->multiSize.y};
int retval = -1;
LOG(logDEBUG1) << "Sending multi detector size to receiver: ("
<< shm()->multiSize.x << "," << shm()->multiSize.y
<< ")";
if (shm()->useReceiverFlag) {
sendToReceiver(F_SEND_RECEIVER_MULTIDETSIZE, args, retval);
LOG(logDEBUG1) << "Receiver multi size returned: " << retval;
}
}
void Module::setDetectorId() {
LOG(logDEBUG1) << "Sending detector pos id to receiver: " << detId;
if (shm()->useReceiverFlag) {
int retval = -1;
sendToReceiver(F_SEND_RECEIVER_DETPOSID, detId, retval);
LOG(logDEBUG1) << "Receiver Position Id returned: " << retval;
}
}
void Module::setDetectorHostname() {
char args[MAX_STR_LENGTH]{};
char retvals[MAX_STR_LENGTH]{};
sls::strcpy_safe(args, shm()->hostname);
LOG(logDEBUG1) << "Sending detector hostname to receiver: " << args;
if (shm()->useReceiverFlag) {
sendToReceiver(F_SEND_RECEIVER_DETHOSTNAME, args, retvals);
LOG(logDEBUG1) << "Receiver set detector hostname: " << retvals;
}
}
std::string Module::getFilePath() {
if (!shm()->useReceiverFlag) {
throw RuntimeError("Set rx_hostname first to use receiver parameters (file path)");
@ -3546,10 +3431,6 @@ void Module::setPipeline(int clkIndex, int value) {
void Module::setCounterMask(uint32_t countermask) {
LOG(logDEBUG1) << "Setting Counter mask to " << countermask;
sendToDetector(F_SET_COUNTER_MASK, countermask, nullptr);
sendNumberofCounterstoReceiver(countermask);
}
void Module::sendNumberofCounterstoReceiver(uint32_t countermask) {
if (shm()->useReceiverFlag) {
int ncounters = __builtin_popcount(countermask);
LOG(logDEBUG1) << "Sending Reciver #counters: " << ncounters;

47
slsDetectorSoftware/src/Module.h
View File

@ -176,13 +176,6 @@ class Module : public virtual slsDetectorDefs {
*/
detectorType getDetectorType() const;
/**
* Gets detector type from detector and set it in receiver
* @param type the detector type
* @returns detector type in receiver
*/
int setDetectorType(detectorType type = GET_DETECTOR_TYPE);
/**
* Update total number of channels (chiptestboard or moench)
* from the detector server
@ -647,9 +640,8 @@ class Module : public virtual slsDetectorDefs {
* significant for the receiver Also configures the detector to the receiver
* as UDP destination
* @param receiver receiver hostname or IP address
* @returns the receiver IP address from shared memory
*/
std::string setReceiverHostname(const std::string &receiver);
void setReceiverHostname(const std::string &receiver);
void test();
/**
@ -722,13 +714,6 @@ class Module : public virtual slsDetectorDefs {
*/
sls::IpAddr getDestinationUDPIP();
/**
* Gets destination udp ip from detector,
* if 0, it converts rx_hostname to ip and
* updates both detector and receiver
*/
void updateRxDestinationUDPIP();
/**
* Validates the format of the receiver UDP IP address (bottom half) and
* sets it(Jungfrau only)
@ -744,13 +729,6 @@ class Module : public virtual slsDetectorDefs {
*/
sls::IpAddr getDestinationUDPIP2();
/**
* Gets destination udp ip2 from detector,
* if 0, it converts rx_hostname to ip and
* updates both detector and receiver
*/
void updateRxDestinationUDPIP2();
/**
* Validates the format of the receiver UDP MAC address and sets it
* @param mac receiver UDP MAC address
@ -1345,26 +1323,6 @@ class Module : public virtual slsDetectorDefs {
*/
void execReceiverCommand(const std::string &cmd);
/**
* Send the multi detector size to the detector
* @param detx number of detectors in x dir
* @param dety number of detectors in y dir
*/
void sendMultiDetectorSize();
/**
* Send the detector pos id to the receiver
* for various file naming conventions for multi detectors in receiver
*/
void setDetectorId();
/**
* Send the detector host name to the receiver
* for various handshaking required with the detector
*/
void setDetectorHostname();
std::string getFilePath();
void setFilePath(const std::string &path);
std::string getFileName();
@ -1607,9 +1565,6 @@ class Module : public virtual slsDetectorDefs {
/** [Mythen3] */
void setCounterMask(uint32_t countermask);
/** [Mythen3] */
void sendNumberofCounterstoReceiver(uint32_t countermask);
/** [Mythen3] */
uint32_t getCounterMask();

323
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -115,8 +115,7 @@ int ClientInterface::functionTable(){
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;
flist[F_SET_RECEIVER_TYPE] = &ClientInterface::set_detector_type;
flist[F_SEND_RECEIVER_DETHOSTNAME] = &ClientInterface::set_detector_hostname;
flist[F_SETUP_RECEIVER] = &ClientInterface::setup_receiver;
flist[F_RECEIVER_SET_ROI] = &ClientInterface::set_roi;
flist[F_RECEIVER_SET_NUM_FRAMES] = &ClientInterface::set_num_frames;
flist[F_SET_RECEIVER_NUM_TRIGGERS] = &ClientInterface::set_num_triggers;
@ -160,8 +159,6 @@ int ClientInterface::functionTable(){
flist[F_SET_FLIPPED_DATA_RECEIVER] = &ClientInterface::set_flipped_data;
flist[F_SET_RECEIVER_FILE_FORMAT] = &ClientInterface::set_file_format;
flist[F_GET_RECEIVER_FILE_FORMAT] = &ClientInterface::get_file_format;
flist[F_SEND_RECEIVER_DETPOSID] = &ClientInterface::set_detector_posid;
flist[F_SEND_RECEIVER_MULTIDETSIZE] = &ClientInterface::set_multi_detector_size;
flist[F_SET_RECEIVER_STREAMING_PORT] = &ClientInterface::set_streaming_port;
flist[F_GET_RECEIVER_STREAMING_PORT] = &ClientInterface::get_streaming_port;
flist[F_SET_RECEIVER_STREAMING_SRC_IP] = &ClientInterface::set_streaming_source_ip;
@ -336,69 +333,210 @@ int ClientInterface::get_version(Interface &socket) {
return socket.sendResult(getReceiverVersion());
}
int ClientInterface::set_detector_type(Interface &socket) {
auto arg = socket.Receive<detectorType>();
// set
if (arg >= 0) {
// if object exists, verify unlocked and idle, else only verify lock
// (connecting first time)
if (receiver != nullptr) {
verifyIdle(socket);
}
switch (arg) {
case GOTTHARD:
case EIGER:
case CHIPTESTBOARD:
case MOENCH:
case JUNGFRAU:
case MYTHEN3:
case GOTTHARD2:
break;
default:
throw RuntimeError("Unknown detector type: " + std::to_string(arg));
break;
}
int ClientInterface::setup_receiver(Interface &socket) {
auto arg = socket.Receive<rxParameters>();
LOG(logINFO)
<< "detType:" << arg.detType << std::endl
<< "multiSize.x:" << arg.multiSize.x << std::endl
<< "multiSize.y:" << arg.multiSize.y << std::endl
<< "detId:" << arg.detId << std::endl
<< "hostname:" << arg.hostname << 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;
try {
myDetectorType = GENERIC;
receiver = sls::make_unique<Implementation>(arg);
myDetectorType = arg;
} catch (...) {
throw RuntimeError("Could not set detector type");
}
// callbacks after (in setdetectortype, the object is reinitialized)
if (startAcquisitionCallBack != nullptr)
impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
pStartAcquisition);
if (acquisitionFinishedCallBack != nullptr)
impl()->registerCallBackAcquisitionFinished(
acquisitionFinishedCallBack, pAcquisitionFinished);
if (rawDataReadyCallBack != nullptr)
impl()->registerCallBackRawDataReady(rawDataReadyCallBack,
pRawDataReady);
if (rawDataModifyReadyCallBack != nullptr)
impl()->registerCallBackRawDataModifyReady(
rawDataModifyReadyCallBack, pRawDataReady);
// if object exists, verify unlocked and idle, else only verify lock
// (connecting first time)
if (receiver != nullptr) {
verifyIdle(socket);
}
return socket.sendResult(myDetectorType);
// basic setup
setDetectorType(arg.detType);
{
int msize[2] = {arg.multiSize.x, arg.multiSize.y};
impl()->setMultiDetectorSize(msize);
}
impl()->setDetectorPositionId(arg.detId);
impl()->setDetectorHostname(arg.hostname);
// udp setup
sls::MacAddr retvals[2];
if (arg.udp_dstmac == 0 && arg.udp_dstip != 0) {
retvals[0] = setUdpIp(sls::IpAddr(arg.udp_dstip));
}
if (arg.udp_dstmac2 == 0 && arg.udp_dstip2 != 0) {
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()->setUDPSocketBufferSize(0);
// acquisition parameters
impl()->setNumberOfFrames(arg.frames);
impl()->setNumberOfTriggers(arg.triggers);
if (myDetectorType == GOTTHARD) {
impl()->setNumberOfBursts(arg.bursts);
}
if (myDetectorType == MOENCH || myDetectorType == CHIPTESTBOARD) {
try {
impl()->setNumberofAnalogSamples(arg.analogSamples);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set num analog samples to " +
std::to_string(arg.analogSamples) +
" due to fifo structure memory allocation.");
}
}
if (myDetectorType == CHIPTESTBOARD) {
try {
impl()->setNumberofDigitalSamples(arg.digitalSamples);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set num digital samples to "
+ std::to_string(arg.analogSamples) +
" due to fifo structure memory allocation.");
}
}
impl()->setAcquisitionTime(arg.expTimeNs);
impl()->setAcquisitionPeriod(arg.periodNs);
if (myDetectorType == EIGER) {
impl()->setSubExpTime(arg.subExpTimeNs);
impl()->setSubPeriod(arg.subExpTimeNs + arg.subDeadTimeNs);
impl()->setActivate(static_cast<bool>(arg.activate));
try {
impl()->setQuad(arg.quad == 0 ? false : true);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set quad to " +
std::to_string(arg.quad) +
" due to fifo strucutre memory allocation");
}
}
if (myDetectorType == EIGER || myDetectorType == MYTHEN3) {
try {
impl()->setDynamicRange(arg.dynamicRange);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set dynamic range. Could not allocate "
"memory for fifo or could not start listening/writing threads");
}
}
impl()->setTimingMode(arg.timMode);
if (myDetectorType == EIGER || myDetectorType == MOENCH ||
myDetectorType == CHIPTESTBOARD) {
try {
impl()->setTenGigaEnable(arg.tenGiga);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set 10GbE.");
}
}
if (myDetectorType == CHIPTESTBOARD) {
try {
impl()->setReadoutMode(arg.roMode);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set read out mode "
"due to fifo memory allocation.");
}
}
if (myDetectorType == CHIPTESTBOARD || myDetectorType == MOENCH) {
try {
impl()->setADCEnableMask(arg.adcMask);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set adc enable mask "
"due to fifo memory allcoation");
}
try {
impl()->setTenGigaADCEnableMask(arg.adc10gMask);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set 10Gb adc enable mask "
"due to fifo memory allcoation");
}
}
if (myDetectorType == GOTTHARD) {
try {
impl()->setROI(arg.roi);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set ROI");
}
}
if (myDetectorType == MYTHEN3) {
int ncounters = __builtin_popcount(arg.countermask);
impl()->setNumberofCounters(ncounters);
}
if (myDetectorType == GOTTHARD) {
impl()->setBurstMode(arg.burstType);
}
return socket.sendResult(retvals);
}
int ClientInterface::set_detector_hostname(Interface &socket) {
char hostname[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(hostname);
void ClientInterface::setDetectorType(detectorType arg) {
switch (arg) {
case GOTTHARD:
case EIGER:
case CHIPTESTBOARD:
case MOENCH:
case JUNGFRAU:
case MYTHEN3:
case GOTTHARD2:
break;
default:
throw RuntimeError("Unknown detector type: " + std::to_string(arg));
break;
}
if (strlen(hostname) != 0) {
verifyIdle(socket);
impl()->setDetectorHostname(hostname);
try {
myDetectorType = GENERIC;
receiver = sls::make_unique<Implementation>(arg);
myDetectorType = arg;
} catch (...) {
throw RuntimeError("Could not set detector type");
}
auto s = impl()->getDetectorHostname();
sls::strcpy_safe(retval, s.c_str());
if (s.empty()) {
throw RuntimeError("Hostname not set");
}
return socket.sendResult(retval);
// callbacks after (in setdetectortype, the object is reinitialized)
if (startAcquisitionCallBack != nullptr)
impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
pStartAcquisition);
if (acquisitionFinishedCallBack != nullptr)
impl()->registerCallBackAcquisitionFinished(
acquisitionFinishedCallBack, pAcquisitionFinished);
if (rawDataReadyCallBack != nullptr)
impl()->registerCallBackRawDataReady(rawDataReadyCallBack,
pRawDataReady);
if (rawDataModifyReadyCallBack != nullptr)
impl()->registerCallBackRawDataModifyReady(
rawDataModifyReadyCallBack, pRawDataReady);
}
int ClientInterface::set_roi(Interface &socket) {
@ -514,7 +652,6 @@ 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);
}
@ -831,7 +968,7 @@ int ClientInterface::enable_tengiga(Interface &socket) {
try {
impl()->setTenGigaEnable(val);
} catch(const RuntimeError &e) {
throw RuntimeError("Could not set 10GbE.");
throw RuntimeError("Could not set 10GbE." );
}
}
int retval = impl()->getTenGigaEnable();
@ -952,34 +1089,6 @@ int ClientInterface::get_file_format(Interface &socket) {
return socket.sendResult(retval);
}
int ClientInterface::set_detector_posid(Interface &socket) {
auto arg = socket.Receive<int>();
if (arg >= 0) {
verifyIdle(socket);
LOG(logDEBUG1) << "Setting detector position id:" << arg;
impl()->setDetectorPositionId(arg);
}
auto retval = impl()->getDetectorPositionId();
validate(arg, retval, "set detector position id", DEC);
LOG(logDEBUG1) << "Position Id:" << retval;
return socket.sendResult(retval);
}
int ClientInterface::set_multi_detector_size(Interface &socket) {
int arg[]{-1, -1};
socket.Receive(arg);
if ((arg[0] > 0) && (arg[1] > 0)) {
verifyIdle(socket);
LOG(logDEBUG1)
<< "Setting multi detector size:" << arg[0] << "," << arg[1];
impl()->setMultiDetectorSize(arg);
}
int *temp = impl()->getMultiDetectorSize(); // TODO! return by value!
int retval = temp[0] * temp[1];
LOG(logDEBUG1) << "Multi Detector Size:" << retval;
return socket.sendResult(retval);
}
int ClientInterface::set_streaming_port(Interface &socket) {
auto port = socket.Receive<int>();
if (port < 0) {
@ -1363,11 +1472,7 @@ int ClientInterface::set_read_n_lines(Interface &socket) {
return socket.Send(OK);
}
int ClientInterface::set_udp_ip(Interface &socket) {
auto arg = socket.Receive<sls::IpAddr>();
verifyIdle(socket);
LOG(logINFO) << "Received UDP IP: " << arg;
sls::MacAddr ClientInterface::setUdpIp(sls::IpAddr arg) {
// getting eth
std::string eth = sls::IpToInterfaceName(arg.str());
if (eth == "none") {
@ -1386,18 +1491,19 @@ int ClientInterface::set_udp_ip(Interface &socket) {
if (retval == 0) {
throw RuntimeError("Failed to get udp mac adddress to listen to (eth:" + eth + ", ip:" + arg.str() + ")\n");
}
return retval;
}
int ClientInterface::set_udp_ip(Interface &socket) {
auto arg = socket.Receive<sls::IpAddr>();
verifyIdle(socket);
LOG(logINFO) << "Received UDP IP: " << arg;
auto retval = setUdpIp(arg);
LOG(logINFO) << "Receiver MAC Address: " << retval;
return socket.sendResult(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;
sls::MacAddr ClientInterface::setUdpIp2(sls::IpAddr arg) {
// getting eth
std::string eth = sls::IpToInterfaceName(arg.str());
if (eth == "none") {
@ -1414,6 +1520,17 @@ int ClientInterface::set_udp_ip2(Interface &socket) {
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);
}

8
slsReceiverSoftware/src/ClientInterface.h
View File

@ -56,8 +56,8 @@ class ClientInterface : private virtual slsDetectorDefs {
int get_last_client_ip(sls::ServerInterface &socket);
int set_port(sls::ServerInterface &socket);
int get_version(sls::ServerInterface &socket);
int set_detector_type(sls::ServerInterface &socket);
int set_detector_hostname(sls::ServerInterface &socket);
int setup_receiver(sls::ServerInterface &socket);
void setDetectorType(detectorType arg);
int set_roi(sls::ServerInterface &socket);
int set_num_frames(sls::ServerInterface &socket);
int set_num_triggers(sls::ServerInterface &socket);
@ -102,8 +102,6 @@ class ClientInterface : private virtual slsDetectorDefs {
int set_flipped_data(sls::ServerInterface &socket);
int set_file_format(sls::ServerInterface &socket);
int get_file_format(sls::ServerInterface &socket);
int set_detector_posid(sls::ServerInterface &socket);
int set_multi_detector_size(sls::ServerInterface &socket);
int set_streaming_port(sls::ServerInterface &socket);
int get_streaming_port(sls::ServerInterface &socket);
int set_streaming_source_ip(sls::ServerInterface &socket);
@ -132,7 +130,9 @@ class ClientInterface : private virtual slsDetectorDefs {
int get_dbit_offset(sls::ServerInterface &socket);
int set_quad_type(sls::ServerInterface &socket);
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);

30
slsSupportLib/include/sls_detector_defs.h
View File

@ -175,7 +175,7 @@ class slsDetectorDefs {
struct ROI {
int xmin{-1}; /**< is the roi xmin (in channel number) */
int xmax{-1}; /**< is the roi xmax (in channel number)*/
};
}__attribute__((packed));
#else
typedef struct {
int xmin; /**< is the roi xmin (in channel number) */
@ -203,7 +203,7 @@ class slsDetectorDefs {
int y{0};
xy() = default;
xy(int x, int y):x(x),y(y){};
};
}__attribute__((packed));
#endif
@ -466,7 +466,16 @@ class slsDetectorDefs {
*/
struct rxParameters {
detectorType detType{GENERIC};
xy multiSize;
int detId{0};
char hostname[MAX_STR_LENGTH];
int udpInterfaces{1};
int udp_dstport{0};
uint32_t udp_dstip{0U};
uint64_t udp_dstmac{0LU};
int udp_dstport2{0};
uint32_t udp_dstip2{0U};
uint64_t udp_dstmac2{0LU};
int64_t frames{0};
int64_t triggers{0};
int64_t bursts{0};
@ -476,28 +485,17 @@ class slsDetectorDefs {
int64_t periodNs{0};
int64_t subExpTimeNs{0};
int64_t subDeadTimeNs{0};
int activate{0};
int quad{0};
int dynamicRange{16};
timingMode timMode{AUTO_TIMING};
int activate{0};
int tenGiga{0};
int quad{0};
readoutMode roMode{ANALOG_ONLY};
uint32_t adcMask{0};
uint32_t adc10gMask{0};
ROI roi;
uint32_t countermask{0};
burstMode burstType{BURST_OFF};
int udpInterfaces{1};
int udp_dstport{0};
uint32_t udp_dstip{0U};
uint64_t udp_dstmac{0LU};
int udp_dstport2{0};
uint32_t udp_dstip2{0U};
uint64_t udp_dstmac2{0LU};
}__attribute__((packed));
#endif

8
slsSupportLib/include/sls_detector_funcs.h
View File

@ -208,8 +208,6 @@ enum detFuncs{
F_GET_LAST_RECEIVER_CLIENT_IP,
F_SET_RECEIVER_PORT,
F_GET_RECEIVER_VERSION,
F_SET_RECEIVER_TYPE,
F_SEND_RECEIVER_DETHOSTNAME,
F_RECEIVER_SET_ROI,
F_RECEIVER_SET_NUM_FRAMES,
F_SET_RECEIVER_NUM_TRIGGERS,
@ -253,8 +251,6 @@ enum detFuncs{
F_SET_FLIPPED_DATA_RECEIVER,
F_SET_RECEIVER_FILE_FORMAT,
F_GET_RECEIVER_FILE_FORMAT,
F_SEND_RECEIVER_DETPOSID,
F_SEND_RECEIVER_MULTIDETSIZE,
F_SET_RECEIVER_STREAMING_PORT,
F_GET_RECEIVER_STREAMING_PORT,
F_SET_RECEIVER_STREAMING_SRC_IP,
@ -501,8 +497,6 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_SET_RECEIVER_PORT: return "F_SET_RECEIVER_PORT";
case F_GET_RECEIVER_VERSION: return "F_GET_RECEIVER_VERSION";
case F_SETUP_RECEIVER: return "F_SETUP_RECEIVER";
case F_SET_RECEIVER_TYPE: return "F_SET_RECEIVER_TYPE";
case F_SEND_RECEIVER_DETHOSTNAME: return "F_SEND_RECEIVER_DETHOSTNAME";
case F_RECEIVER_SET_ROI: return "F_RECEIVER_SET_ROI";
case F_RECEIVER_SET_NUM_FRAMES: return "F_RECEIVER_SET_NUM_FRAMES";
case F_SET_RECEIVER_NUM_TRIGGERS: return "F_SET_RECEIVER_NUM_TRIGGERS";
@ -546,8 +540,6 @@ static const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_SET_FLIPPED_DATA_RECEIVER: return "F_SET_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_SEND_RECEIVER_DETPOSID: return "F_SEND_RECEIVER_DETPOSID";
case F_SEND_RECEIVER_MULTIDETSIZE: return "F_SEND_RECEIVER_MULTIDETSIZE";
case F_SET_RECEIVER_STREAMING_PORT: return "F_SET_RECEIVER_STREAMING_PORT";
case F_GET_RECEIVER_STREAMING_PORT: return "F_GET_RECEIVER_STREAMING_PORT";
case F_SET_RECEIVER_STREAMING_SRC_IP: return "F_SET_RECEIVER_STREAMING_SRC_IP";