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

binaries in, merge fix

Browse Source
This commit is contained in:
maliakal_d 2021-08-06 16:14:53 +02:00
commit 67916cc188
24 changed files with 132 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
python/scripts/generate_enums.py
View File

@ -12,7 +12,7 @@ import subprocess
from parse import remove_comments
allow_bitwise_op = ["M3_GainCaps"]
allow_bitwise_op = ["ethernetInterface"]
allow_bitwise_op = ["streamingInterface"]
op_key = {"operator|": "__or__",
"operator&" : "__and__"}
@ -23,7 +23,7 @@ def single_line_enum(line):
def extract_enums(lines):
# deal with enum class ethernetInterface : int32_t
# deal with enum class streamingInterface : int32_t
# and normal enum burstMode {
line_iter = iter(lines)
@ -90,7 +90,7 @@ def generate_enum_string(enums):
#Here add the operators
for op in operators:
data.append(f"\n\t.def(\"{op_key[op]}\", py::overload_cast< const slsDetectorDefs::ethernetInterface&, const slsDetectorDefs::ethernetInterface&>(&{op}))")
data.append(f"\n\t.def(\"{op_key[op]}\", py::overload_cast< const slsDetectorDefs::streamingInterface&, const slsDetectorDefs::streamingInterface&>(&{op}))")
data.append(';\n\n')

8
python/slsdet/detector.py
View File

@ -7,7 +7,7 @@ timingMode = slsDetectorDefs.timingMode
speedLevel = slsDetectorDefs.speedLevel
dacIndex = slsDetectorDefs.dacIndex
detectorType = slsDetectorDefs.detectorType
ethernetInterface = slsDetectorDefs.ethernetInterface
streamingInterface = slsDetectorDefs.streamingInterface
defs = slsDetectorDefs
@ -2416,7 +2416,7 @@ class Detector(CppDetectorApi):
Note
----
Default: both off
Options: NONE, I3GBE, 10GBE (debugging)
Options: NONE, LOW_LATENCY_LINK, 10GBE (debugging)
Debugging interface also enables second interface in receiver (separate file), which also restarts zmq streaming if enabled.
"""
return self.getVetoStream()
@ -2432,10 +2432,10 @@ class Detector(CppDetectorApi):
"""[Gotthard2] Algorithm used for veto
Example
----------
>>> d.vetoalg = defs.DEFAULT_ALGORITHM, defs.I10GBE
>>> d.vetoalg = defs.DEFAULT_ALGORITHM, defs.ETHERNET_10GB
"""
result = {}
interface = [ethernetInterface.I3GBE, ethernetInterface.I10GBE]
interface = [streamingInterface.LOW_LATENCY_LINK, streamingInterface.ETHERNET_10GB]
for eth in interface:
result[eth] = element_if_equal(self.getVetoAlgorithm(eth))
return result

8
python/src/detector.cpp
View File

@ -1129,23 +1129,23 @@ void init_det(py::module &m) {
Detector::setVeto,
py::arg(), py::arg() = Positions{})
.def("getVetoStream",
(Result<defs::ethernetInterface>(Detector::*)(sls::Positions)
(Result<defs::streamingInterface>(Detector::*)(sls::Positions)
const) &
Detector::getVetoStream,
py::arg() = Positions{})
.def("setVetoStream",
(void (Detector::*)(const defs::ethernetInterface,
(void (Detector::*)(const defs::streamingInterface,
sls::Positions)) &
Detector::setVetoStream,
py::arg(), py::arg() = Positions{})
.def("getVetoAlgorithm",
(Result<defs::vetoAlgorithm>(Detector::*)(
const defs::ethernetInterface, sls::Positions) const) &
const defs::streamingInterface, sls::Positions) const) &
Detector::getVetoAlgorithm,
py::arg(), py::arg() = Positions{})
.def("setVetoAlgorithm",
(void (Detector::*)(const defs::vetoAlgorithm,
const defs::ethernetInterface,
const defs::streamingInterface,
sls::Positions)) &
Detector::setVetoAlgorithm,
py::arg(), py::arg(), py::arg() = Positions{})

18
python/src/enums.cpp
View File

@ -286,20 +286,20 @@ void init_enums(py::module &m) {
.value("BOTTOM", slsDetectorDefs::portPosition::BOTTOM)
.export_values();
py::enum_<slsDetectorDefs::ethernetInterface>(Defs, "ethernetInterface",
py::enum_<slsDetectorDefs::streamingInterface>(Defs, "streamingInterface",
py::arithmetic())
.value("NONE", slsDetectorDefs::ethernetInterface::NONE)
.value("I3GBE", slsDetectorDefs::ethernetInterface::I3GBE)
.value("I10GBE", slsDetectorDefs::ethernetInterface::I10GBE)
.value("ALL", slsDetectorDefs::ethernetInterface::ALL)
.value("NONE", slsDetectorDefs::streamingInterface::NONE)
.value("LOW_LATENCY_LINK", slsDetectorDefs::streamingInterface::LOW_LATENCY_LINK)
.value("ETHERNET_10GB", slsDetectorDefs::streamingInterface::ETHERNET_10GB)
.value("ALL", slsDetectorDefs::streamingInterface::ALL)
.export_values()
.def("__or__",
py::overload_cast<const slsDetectorDefs::ethernetInterface &,
const slsDetectorDefs::ethernetInterface &>(
py::overload_cast<const slsDetectorDefs::streamingInterface &,
const slsDetectorDefs::streamingInterface &>(
&operator|))
.def("__and__",
py::overload_cast<const slsDetectorDefs::ethernetInterface &,
const slsDetectorDefs::ethernetInterface &>(
py::overload_cast<const slsDetectorDefs::streamingInterface &,
const slsDetectorDefs::streamingInterface &>(
&operator&));
py::enum_<slsDetectorDefs::vetoAlgorithm>(Defs, "vetoAlgorithm")

BIN
slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

12
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -1752,10 +1752,10 @@ int configureMAC() {
"\tDest Port : %d\n\n",
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
int i3gbe = getVetoStream();
int lll = getVetoStream();
int i10gbe = (getNumberofUDPInterfaces() == 2 ? 1 : 0);
if (i3gbe) {
if (lll) {
LOG(logINFOGREEN, ("\tVeto (3GbE) : enabled\n\n"));
} else {
LOG(logINFORED, ("\tVeto (3GbE) : disabled\n\n"));
@ -2642,9 +2642,9 @@ int getVetoStream() {
return ((bus_r(CONFIG_REG) & CONFIG_VETO_CH_3GB_ENBL_MSK) ? 1 : 0);
}
enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface) {
enum vetoAlgorithm getVetoAlgorithm(enum streamingInterface interface) {
// 3gbe
if (interface == I3GBE) {
if (interface == LOW_LATENCY_LINK) {
int retval = ((bus_r(CONFIG_REG) & CONFIG_VETO_CH_3GB_ALG_MSK) >>
CONFIG_VETO_CH_3GB_ALG_OFST);
switch (retval) {
@ -2669,14 +2669,14 @@ enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface) {
}
}
void setVetoAlgorithm(enum ethernetInterface interface,
void setVetoAlgorithm(enum streamingInterface interface,
enum vetoAlgorithm alg) {
uint32_t addr = CONFIG_REG;
uint32_t value = bus_r(addr);
switch (alg) {
// more to follow
case DEFAULT_ALGORITHM:
if (interface == I3GBE) {
if (interface == LOW_LATENCY_LINK) {
LOG(logINFO, ("Setting default veto algorithm for 3Gbe\n"));
value &= (~CONFIG_VETO_CH_3GB_ALG_MSK);
value |= CONFIG_VETO_CH_3GB_ALG_DEFAULT_VAL;

BIN
slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

4
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -541,8 +541,8 @@ void setVeto(int enable);
int getVeto();
void setVetoStream(int value);
int getVetoStream();
enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface);
void setVetoAlgorithm(enum ethernetInterface interface, enum vetoAlgorithm alg);
enum vetoAlgorithm getVetoAlgorithm(enum streamingInterface interface);
void setVetoAlgorithm(enum streamingInterface interface, enum vetoAlgorithm alg);
void setBadChannels(int nch, int *channels);
int *getBadChannels(int *nch);
#endif

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

@ -8339,7 +8339,7 @@ int set_datastream(int file_des) {
int get_veto_stream(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum ethernetInterface retval = NONE;
enum streamingInterface retval = NONE;
LOG(logDEBUG1, ("Getting veto stream\n"));
@ -8356,7 +8356,7 @@ int get_veto_stream(int file_des) {
int set_veto_stream(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum ethernetInterface arg = 0;
enum streamingInterface arg = 0;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
@ -8388,7 +8388,7 @@ int set_veto_stream(int file_des) {
int get_veto_algorithm(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum ethernetInterface arg = NONE;
enum streamingInterface arg = NONE;
enum vetoAlgorithm retval = DEFAULT_ALGORITHM;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
@ -8399,7 +8399,7 @@ int get_veto_algorithm(int file_des) {
functionNotImplemented();
#else
// get only
if (arg != I3GBE && arg != I10GBE) {
if (arg != LOW_LATENCY_LINK && arg != ETHERNET_10GB) {
ret = FAIL;
sprintf(mess, "Could not get vetoalgorithm. Invalid interface %d.\n",
arg);
@ -8420,7 +8420,7 @@ int set_veto_algorithm(int file_des) {
return printSocketReadError();
enum vetoAlgorithm alg = args[0];
enum ethernetInterface interface = args[1];
enum streamingInterface interface = args[1];
LOG(logINFO, ("Setting vetoalgorithm (interface: %d): %u\n", (int)interface,
(int)alg));
@ -8429,7 +8429,7 @@ int set_veto_algorithm(int file_des) {
#else
// only set
if (Server_VerifyLock() == OK) {
if (interface != I3GBE && interface != I10GBE) {
if (interface != LOW_LATENCY_LINK && interface != ETHERNET_10GB) {
ret = FAIL;
sprintf(mess,
"Could not set vetoalgorithm. Invalid interface %d.\n",

16
slsDetectorSoftware/include/sls/Detector.h
View File

@ -1304,26 +1304,26 @@ class Detector {
void setVeto(const bool enable, Positions pos = {});
/** [Gotthard2] */
Result<defs::ethernetInterface> getVetoStream(Positions pos = {}) const;
Result<defs::streamingInterface> getVetoStream(Positions pos = {}) const;
/** [Gotthard2] Options: NONE (Default), I3GBE, I10GBE (debugging), ALL
/** [Gotthard2] Options: NONE (Default), LOW_LATENCY_LINK, ETHERNET_10GB (debugging), ALL
* Enable or disable the 2 veto streaming interfaces available. Can
* concatenate more than one interface. \n3GbE (2.5GbE) is the default
* interface to work with. \n10GbE is for debugging and also enables second
* concatenate more than one interface. \nLOW_LATENCY_LINK is the default
* interface to work with. \nETHERNET_10GB is for debugging and also enables second
* interface in receiver for listening to veto packets (writes a separate
* file if writing enabled). Also restarts client and receiver zmq sockets
* if zmq streaming enabled.*/
void setVetoStream(const defs::ethernetInterface value, Positions pos = {});
void setVetoStream(const defs::streamingInterface value, Positions pos = {});
/** [Gotthard2] */
Result<defs::vetoAlgorithm>
getVetoAlgorithm(const defs::ethernetInterface value,
getVetoAlgorithm(const defs::streamingInterface value,
Positions pos = {}) const;
/** [Gotthard2] Options(vetoAlgorithm): DEFAULT_ALGORITHM.
* Options(ethernetInterface): I3GBE, I10GBE */
* Options(streamingInterface): LOW_LATENCY_LINK, ETHERNET_10GB */
void setVetoAlgorithm(const defs::vetoAlgorithm alg,
const defs::ethernetInterface value,
const defs::streamingInterface value,
Positions pos = {});
/** [Gotthard2] */

22
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -1945,9 +1945,9 @@ std::string CmdProxy::VetoStreaming(int action) {
std::ostringstream os;
os << cmd << ' ';
if (action == defs::HELP_ACTION) {
os << "[none|3gbe|10gbe|...]\n\t[Gotthard2] Enable or disable the 2 "
os << "[none|lll|10gbe|...]\n\t[Gotthard2] Enable or disable the 2 "
"veto streaming interfaces available. Can include more than one "
"interface. \n\tDefault: none. 3GbE (2.5GbE) is the default "
"interface. \n\tDefault: none. lll (low latency link) is the default "
"interface to work with. \n\t10GbE is for debugging and also "
"enables second interface in receiver for listening to veto "
"packets (writes a separate file if writing enabled). Also "
@ -1964,7 +1964,7 @@ std::string CmdProxy::VetoStreaming(int action) {
if (args.empty()) {
WrongNumberOfParameters(1);
}
defs::ethernetInterface interface = defs::ethernetInterface::NONE;
defs::streamingInterface interface = defs::streamingInterface::NONE;
for (const auto &arg : args) {
if (arg == "none") {
if (args.size() > 1) {
@ -1975,7 +1975,7 @@ std::string CmdProxy::VetoStreaming(int action) {
}
break;
}
interface = interface | (StringTo<defs::ethernetInterface>(arg));
interface = interface | (StringTo<defs::streamingInterface>(arg));
}
det->setVetoStream(interface, std::vector<int>{det_id});
os << ToString(interface) << '\n';
@ -1989,16 +1989,16 @@ std::string CmdProxy::VetoAlgorithm(int action) {
std::ostringstream os;
os << cmd << ' ';
if (action == defs::HELP_ACTION) {
os << "[default] [3gbe|10gbe]\n\t[Gotthard2] Set the veto "
os << "[default] [lll|10gbe]\n\t[Gotthard2] Set the veto "
"algorithm."
<< '\n';
} else if (action == defs::GET_ACTION) {
if (args.size() != 1) {
WrongNumberOfParameters(1);
}
defs::ethernetInterface interface =
StringTo<defs::ethernetInterface>(args[0]);
if (interface == defs::ethernetInterface::NONE) {
defs::streamingInterface interface =
StringTo<defs::streamingInterface>(args[0]);
if (interface == defs::streamingInterface::NONE) {
throw sls::RuntimeError(
"Must specify an interface to set algorithm");
}
@ -2009,9 +2009,9 @@ std::string CmdProxy::VetoAlgorithm(int action) {
WrongNumberOfParameters(2);
}
defs::vetoAlgorithm alg = StringTo<defs::vetoAlgorithm>(args[0]);
defs::ethernetInterface interface =
StringTo<defs::ethernetInterface>(args[1]);
if (interface == defs::ethernetInterface::NONE) {
defs::streamingInterface interface =
StringTo<defs::streamingInterface>(args[1]);
if (interface == defs::streamingInterface::NONE) {
throw sls::RuntimeError(
"Must specify an interface to set algorithm");
}

30
slsDetectorSoftware/src/Detector.cpp
View File

@ -1636,49 +1636,49 @@ void Detector::setVeto(bool enable, Positions pos) {
pimpl->Parallel(&Module::setVeto, pos, enable);
}
Result<defs::ethernetInterface> Detector::getVetoStream(Positions pos) const {
Result<defs::streamingInterface> Detector::getVetoStream(Positions pos) const {
// 3gbe
auto r3 = pimpl->Parallel(&Module::getVetoStream, pos);
// 10gbe (debugging interface) opens 2nd udp interface in receiver
auto r10 = pimpl->getNumberofUDPInterfaces(pos);
Result<defs::ethernetInterface> res(r3.size());
Result<defs::streamingInterface> res(r3.size());
for (unsigned int i = 0; i < res.size(); ++i) {
res[i] = (r3[i] ? defs::ethernetInterface::I3GBE
: defs::ethernetInterface::NONE);
res[i] = (r3[i] ? defs::streamingInterface::LOW_LATENCY_LINK
: defs::streamingInterface::NONE);
if (r10[i] == 2) {
res[i] = res[i] | defs::ethernetInterface::I10GBE;
res[i] = res[i] | defs::streamingInterface::ETHERNET_10GB;
}
}
return res;
}
void Detector::setVetoStream(defs::ethernetInterface interface, Positions pos) {
void Detector::setVetoStream(defs::streamingInterface interface, Positions pos) {
// 3gbe
bool i3gbe = ((interface & defs::ethernetInterface::I3GBE) ==
defs::ethernetInterface::I3GBE);
pimpl->Parallel(&Module::setVetoStream, pos, i3gbe);
bool LOW_LATENCY_LINK = ((interface & defs::streamingInterface::LOW_LATENCY_LINK) ==
defs::streamingInterface::LOW_LATENCY_LINK);
pimpl->Parallel(&Module::setVetoStream, pos, LOW_LATENCY_LINK);
// 10gbe (debugging interface) opens 2nd udp interface in receiver
int old_numinterfaces = pimpl->getNumberofUDPInterfaces(pos).tsquash(
"retrieved inconsistent number of udp interfaces");
int numinterfaces = (((interface & defs::ethernetInterface::I10GBE) ==
defs::ethernetInterface::I10GBE)
? 2
: 1);
int numinterfaces = (((interface & defs::streamingInterface::ETHERNET_10GB) ==
defs::streamingInterface::ETHERNET_10GB)
? 2
: 1);
if (numinterfaces != old_numinterfaces) {
setNumberofUDPInterfaces_(numinterfaces, pos);
}
}
Result<defs::vetoAlgorithm>
Detector::getVetoAlgorithm(const defs::ethernetInterface interface,
Detector::getVetoAlgorithm(const defs::streamingInterface interface,
Positions pos) const {
return pimpl->Parallel(&Module::getVetoAlgorithm, pos, interface);
}
void Detector::setVetoAlgorithm(const defs::vetoAlgorithm alg,
defs::ethernetInterface interface,
defs::streamingInterface interface,
Positions pos) {
pimpl->Parallel(&Module::setVetoAlgorithm, pos, alg, interface);
}

4
slsDetectorSoftware/src/Module.cpp
View File

@ -1928,14 +1928,14 @@ void Module::setVetoStream(const bool value) {
}
slsDetectorDefs::vetoAlgorithm Module::getVetoAlgorithm(
const slsDetectorDefs::ethernetInterface interface) const {
const slsDetectorDefs::streamingInterface interface) const {
return sendToDetector<vetoAlgorithm>(F_GET_VETO_ALGORITHM,
static_cast<int>(interface));
}
void Module::setVetoAlgorithm(
const slsDetectorDefs::vetoAlgorithm alg,
const slsDetectorDefs::ethernetInterface interface) {
const slsDetectorDefs::streamingInterface interface) {
int args[]{static_cast<int>(alg), static_cast<int>(interface)};
sendToDetector(F_SET_VETO_ALGORITHM, args, nullptr);
}

4
slsDetectorSoftware/src/Module.h
View File

@ -419,9 +419,9 @@ class Module : public virtual slsDetectorDefs {
bool getVetoStream() const;
void setVetoStream(const bool value);
slsDetectorDefs::vetoAlgorithm
getVetoAlgorithm(const slsDetectorDefs::ethernetInterface interface) const;
getVetoAlgorithm(const slsDetectorDefs::streamingInterface interface) const;
void setVetoAlgorithm(const slsDetectorDefs::vetoAlgorithm alg,
const slsDetectorDefs::ethernetInterface interface);
const slsDetectorDefs::streamingInterface interface);
int getADCConfiguration(const int chipIndex, const int adcIndex) const;
void setADCConfiguration(const int chipIndex, const int adcIndex,
int value);

34
slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
View File

@ -657,25 +657,25 @@ TEST_CASE("vetostream", "[.cmd]") {
}
{
std::ostringstream oss;
proxy.Call("vetostream", {"3gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream 3gbe\n");
proxy.Call("vetostream", {"lll"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {}, -1, GET, oss);
REQUIRE(oss.str() == "vetostream 3gbe\n");
REQUIRE(oss.str() == "vetostream lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {"3gbe", "10gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream 3gbe, 10gbe\n");
proxy.Call("vetostream", {"lll", "10gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
}
{
std::ostringstream oss;
proxy.Call("vetostream", {}, -1, GET, oss);
REQUIRE(oss.str() == "vetostream 3gbe, 10gbe\n");
REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
}
REQUIRE_THROWS(proxy.Call("vetostream", {"3gbe", "none"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("vetostream", {"lll", "none"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setVetoStream(prev_val[i], {i});
}
@ -691,18 +691,18 @@ TEST_CASE("vetoalg", "[.cmd]") {
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::GOTTHARD2) {
auto prev_val_3g = det.getVetoAlgorithm(defs::ethernetInterface::I3GBE);
auto prev_val_3g = det.getVetoAlgorithm(defs::streamingInterface::LOW_LATENCY_LINK);
auto prev_val_10g =
det.getVetoAlgorithm(defs::ethernetInterface::I10GBE);
det.getVetoAlgorithm(defs::streamingInterface::ETHERNET_10GB);
{
std::ostringstream oss;
proxy.Call("vetoalg", {"default", "3gbe"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg default 3gbe\n");
proxy.Call("vetoalg", {"default", "lll"}, -1, PUT, oss);
REQUIRE(oss.str() == "vetoalg default lll\n");
}
{
std::ostringstream oss;
proxy.Call("vetoalg", {"3gbe"}, -1, GET, oss);
REQUIRE(oss.str() == "vetoalg default 3gbe\n");
proxy.Call("vetoalg", {"lll"}, -1, GET, oss);
REQUIRE(oss.str() == "vetoalg default lll\n");
}
{
std::ostringstream oss;
@ -715,16 +715,16 @@ TEST_CASE("vetoalg", "[.cmd]") {
REQUIRE(oss.str() == "vetoalg default 10gbe\n");
}
REQUIRE_THROWS(
proxy.Call("vetoalg", {"default", "3gbe", "10gbe"}, -1, PUT));
proxy.Call("vetoalg", {"default", "lll", "10gbe"}, -1, PUT));
REQUIRE_THROWS(proxy.Call("vetoalg", {"default", "none"}, -1, PUT));
for (int i = 0; i != det.size(); ++i) {
det.setVetoAlgorithm(prev_val_3g[i], defs::ethernetInterface::I3GBE,
det.setVetoAlgorithm(prev_val_3g[i], defs::streamingInterface::LOW_LATENCY_LINK,
{i});
det.setVetoAlgorithm(prev_val_10g[i],
defs::ethernetInterface::I10GBE, {i});
defs::streamingInterface::ETHERNET_10GB, {i});
}
} else {
REQUIRE_THROWS(proxy.Call("vetoalg", {"3gbe"}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetoalg", {"lll"}, -1, GET));
REQUIRE_THROWS(proxy.Call("vetoalg", {"none"}, -1, PUT));
}
REQUIRE_THROWS(proxy.Call("vetoalg", {"dfgd"}, -1, GET));

6
slsSupportLib/include/sls/ToString.h
View File

@ -36,9 +36,13 @@ std::string ToString(const defs::dacIndex s);
std::string ToString(const std::vector<defs::dacIndex> &vec);
std::string ToString(const defs::burstMode s);
std::string ToString(const defs::timingSourceType s);
<<<<<<< HEAD
std::string ToString(const defs::M3_GainCaps s);
std::string ToString(const defs::portPosition s);
std::string ToString(const defs::ethernetInterface s);
=======
std::string ToString(const defs::streamingInterface s);
>>>>>>> 5.2.0-rc
std::string ToString(const defs::vetoAlgorithm s);
std::string ToString(const defs::gainMode s);
@ -304,7 +308,7 @@ template <> defs::burstMode StringTo(const std::string &s);
template <> defs::timingSourceType StringTo(const std::string &s);
template <> defs::M3_GainCaps StringTo(const std::string &s);
template <> defs::portPosition StringTo(const std::string &s);
template <> defs::ethernetInterface StringTo(const std::string &s);
template <> defs::streamingInterface StringTo(const std::string &s);
template <> defs::vetoAlgorithm StringTo(const std::string &s);
template <> defs::gainMode StringTo(const std::string &s);

26
slsSupportLib/include/sls/sls_detector_defs.h
View File

@ -403,14 +403,14 @@ typedef struct {
enum portPosition { LEFT, RIGHT, TOP, BOTTOM };
#ifdef __cplusplus
enum class ethernetInterface {
enum class streamingInterface {
#else
enum ethernetInterface {
enum streamingInterface {
#endif
NONE = 0,
I3GBE = 1 << 0,
I10GBE = 1 << 1,
ALL = I3GBE | I10GBE
LOW_LATENCY_LINK = 1 << 0,
ETHERNET_10GB = 1 << 1,
ALL = LOW_LATENCY_LINK | ETHERNET_10GB
};
enum vetoAlgorithm { DEFAULT_ALGORITHM };
@ -517,17 +517,17 @@ typedef struct {
#ifdef __cplusplus
};
inline slsDetectorDefs::ethernetInterface
operator|(const slsDetectorDefs::ethernetInterface &a,
const slsDetectorDefs::ethernetInterface &b) {
return slsDetectorDefs::ethernetInterface(static_cast<int32_t>(a) |
inline slsDetectorDefs::streamingInterface
operator|(const slsDetectorDefs::streamingInterface &a,
const slsDetectorDefs::streamingInterface &b) {
return slsDetectorDefs::streamingInterface(static_cast<int32_t>(a) |
static_cast<int32_t>(b));
};
inline slsDetectorDefs::ethernetInterface
operator&(const slsDetectorDefs::ethernetInterface &a,
const slsDetectorDefs::ethernetInterface &b) {
return slsDetectorDefs::ethernetInterface(static_cast<int32_t>(a) &
inline slsDetectorDefs::streamingInterface
operator&(const slsDetectorDefs::streamingInterface &a,
const slsDetectorDefs::streamingInterface &b) {
return slsDetectorDefs::streamingInterface(static_cast<int32_t>(a) &
static_cast<int32_t>(b));
};
#endif

12
slsSupportLib/include/sls/versionAPI.h
View File

@ -3,10 +3,10 @@
#define APILIB 0x210225
#define APIRECEIVER 0x210225
#define APIGUI 0x210225
#define APICTB 0x210729
#define APIGOTTHARD 0x210729
#define APIMYTHEN3 0x210729
#define APIMOENCH 0x210729
#define APIEIGER 0x210729
#define APIJUNGFRAU 0x210802
#define APIEIGER 0x210806
#define APICTB 0x210806
#define APIGOTTHARD 0x210806
#define APIGOTTHARD2 0x210806
#define APIJUNGFRAU 0x210806
#define APIMYTHEN3 0x210806
#define APIMOENCH 0x210806

26
slsSupportLib/src/ToString.cpp
View File

@ -553,18 +553,18 @@ std::string ToString(const defs::portPosition s) {
}
}
std::string ToString(const defs::ethernetInterface s) {
std::string ToString(const defs::streamingInterface s) {
std::ostringstream os;
std::string rs;
switch (s) {
case defs::ethernetInterface::NONE:
case defs::streamingInterface::NONE:
return std::string("none");
default:
if ((s & defs::ethernetInterface::I3GBE) !=
defs::ethernetInterface::NONE)
os << "3gbe, ";
if ((s & defs::ethernetInterface::I10GBE) !=
defs::ethernetInterface::NONE)
if ((s & defs::streamingInterface::LOW_LATENCY_LINK) !=
defs::streamingInterface::NONE)
os << "lll, ";
if ((s & defs::streamingInterface::ETHERNET_10GB) !=
defs::streamingInterface::NONE)
os << "10gbe, ";
auto rs = os.str();
rs.erase(rs.end() - 2, rs.end());
@ -966,17 +966,17 @@ template <> defs::portPosition StringTo(const std::string &s) {
throw sls::RuntimeError("Unknown port position " + s);
}
template <> defs::ethernetInterface StringTo(const std::string &s) {
template <> defs::streamingInterface StringTo(const std::string &s) {
std::string rs = s;
if (s.find(',') != std::string::npos)
rs.erase(rs.find(','));
if (rs == "none")
return defs::ethernetInterface::NONE;
if (rs == "3gbe")
return defs::ethernetInterface::I3GBE;
return defs::streamingInterface::NONE;
if (rs == "lll")
return defs::streamingInterface::LOW_LATENCY_LINK;
if (rs == "10gbe")
return defs::ethernetInterface::I10GBE;
throw sls::RuntimeError("Unknown ethernetInterface type " + s);
return defs::streamingInterface::ETHERNET_10GB;
throw sls::RuntimeError("Unknown streamingInterface type " + s);
}
template <> defs::vetoAlgorithm StringTo(const std::string &s) {

12
slsSupportLib/tests/test-ToString.cpp
View File

@ -324,10 +324,10 @@ TEST_CASE("Print a member of patternParameters") {
REQUIRE(ToString(pat->limits) == "[4, 100]");
}
TEST_CASE("ethernetInterface") {
REQUIRE(ToString(sls::defs::ethernetInterface::NONE) == "none");
REQUIRE(ToString(sls::defs::ethernetInterface::I10GBE) == "10gbe");
REQUIRE(ToString(sls::defs::ethernetInterface::I3GBE) == "3gbe");
REQUIRE(ToString(sls::defs::ethernetInterface::I3GBE |
sls::defs::ethernetInterface::I10GBE) == "3gbe, 10gbe");
TEST_CASE("streamingInterface") {
REQUIRE(ToString(sls::defs::streamingInterface::NONE) == "none");
REQUIRE(ToString(sls::defs::streamingInterface::ETHERNET_10GB) == "10gbe");
REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK) == "lll");
REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK |
sls::defs::streamingInterface::ETHERNET_10GB) == "lll, 10gbe");
}