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

Merge branch 'developer' of github.com:slsdetectorgroup/slsDetectorPackage into developer

Browse Source
This commit is contained in:
Erik Frojdh 2020-08-04 15:38:45 +02:00
commit a70d4e1e5d
14 changed files with 181 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
slsDetectorServers/mythen3DetectorServer/RegisterDefs.h
View File

@ -152,6 +152,17 @@
#define PKT_CONFIG_1G_INTERFACE_OFST (16) #define PKT_CONFIG_1G_INTERFACE_OFST (16)
#define PKT_CONFIG_1G_INTERFACE_MSK (0x00000001 << PKT_CONFIG_1G_INTERFACE_OFST) #define PKT_CONFIG_1G_INTERFACE_MSK (0x00000001 << PKT_CONFIG_1G_INTERFACE_OFST)
#define PKT_FRAG_REG (0x01 * REG_OFFSET + BASE_PKT)
#define PKT_FRAG_1G_N_DSR_PER_PKT_OFST (0)
#define PKT_FRAG_1G_N_DSR_PER_PKT_MSK (0x0000003F << PKT_FRAG_1G_N_DSR_PER_PKT_OFST)
#define PKT_FRAG_10G_N_DSR_PER_PKT_OFST (8)
#define PKT_FRAG_10G_N_DSR_PER_PKT_MSK (0x0000003F << PKT_FRAG_10G_N_DSR_PER_PKT_OFST)
#define PKT_FRAG_1G_NUM_PACKETS_OFST (16)
#define PKT_FRAG_1G_NUM_PACKETS_MSK (0x0000003F << PKT_FRAG_1G_NUM_PACKETS_OFST)
#define PKT_FRAG_10G_NUM_PACKETS_OFST (24)
#define PKT_FRAG_10G_NUM_PACKETS_MSK (0x0000003F << PKT_FRAG_10G_NUM_PACKETS_OFST)
/* Module Coordinates Register */ /* Module Coordinates Register */
#define COORD_0_REG (0x02 * REG_OFFSET + BASE_PKT) #define COORD_0_REG (0x02 * REG_OFFSET + BASE_PKT)
#define COORD_ROW_OFST (0) #define COORD_ROW_OFST (0)

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

95
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -409,6 +409,9 @@ void setupDetector() {
setDefaultDacs(); setDefaultDacs();
setASICDefaults(); setASICDefaults();
// no roi for 1g and 10g
setumberOfDeserializers(MAX_NUM_DESERIALIZERS, 0);
setumberOfDeserializers(MAX_NUM_DESERIALIZERS, 1);
// dynamic range // dynamic range
setDynamicRange(DEFAULT_DYNAMIC_RANGE); setDynamicRange(DEFAULT_DYNAMIC_RANGE);
// enable all counters // enable all counters
@ -552,6 +555,7 @@ int setDynamicRange(int dr) {
// set it // set it
bus_w(CONFIG_REG, bus_r(CONFIG_REG) & ~CONFIG_DYNAMIC_RANGE_MSK); bus_w(CONFIG_REG, bus_r(CONFIG_REG) & ~CONFIG_DYNAMIC_RANGE_MSK);
bus_w(CONFIG_REG, bus_r(CONFIG_REG) | regval); bus_w(CONFIG_REG, bus_r(CONFIG_REG) | regval);
updateNumberOfPackets();
} }
uint32_t regval = bus_r(CONFIG_REG) & CONFIG_DYNAMIC_RANGE_MSK; uint32_t regval = bus_r(CONFIG_REG) & CONFIG_DYNAMIC_RANGE_MSK;
@ -1032,6 +1036,7 @@ void setCounterMask(uint32_t arg) {
CONFIG_COUNTERS_ENA_MSK)); CONFIG_COUNTERS_ENA_MSK));
LOG(logDEBUG, ("Config Reg: 0x%x\n", bus_r(addr))); LOG(logDEBUG, ("Config Reg: 0x%x\n", bus_r(addr)));
updateNumberOfPackets();
updateGatePeriod(); updateGatePeriod();
} }
@ -1039,6 +1044,59 @@ uint32_t getCounterMask() {
return ((bus_r(CONFIG_REG) & CONFIG_COUNTERS_ENA_MSK) >> return ((bus_r(CONFIG_REG) & CONFIG_COUNTERS_ENA_MSK) >>
CONFIG_COUNTERS_ENA_OFST); CONFIG_COUNTERS_ENA_OFST);
} }
void setumberOfDeserializers(int val, int tgEnable) {
const uint32_t addr = PKT_FRAG_REG;
LOG(logINFO, ("Setting Number of deserializers per packet: %d for %s\n",
val, (tgEnable ? "10g" : "1g")));
if (tgEnable) {
bus_w(addr, bus_r(addr) & ~PKT_FRAG_10G_N_DSR_PER_PKT_MSK);
bus_w(addr, bus_r(addr) | ((val << PKT_FRAG_10G_N_DSR_PER_PKT_OFST) &
PKT_FRAG_10G_N_DSR_PER_PKT_MSK));
} else {
bus_w(addr, bus_r(addr) & ~PKT_FRAG_1G_N_DSR_PER_PKT_MSK);
bus_w(addr, bus_r(addr) | ((val << PKT_FRAG_1G_N_DSR_PER_PKT_OFST) &
PKT_FRAG_1G_N_DSR_PER_PKT_MSK));
}
}
void updateNumberOfPackets() {
const int ncounters = __builtin_popcount(getCounterMask());
const int tgEnable = enableTenGigabitEthernet(-1);
int packetsPerFrame = 0;
// 10g
if (tgEnable) {
const int dr = setDynamicRange(-1);
packetsPerFrame = 1;
if (dr == 32 && ncounters > 1) {
packetsPerFrame = 2;
}
}
// 1g
else {
int dataSize = 1280;
if (ncounters == 3) {
dataSize = 768;
}
packetsPerFrame = calculateDataBytes() / dataSize;
}
// bus_w()
LOG(logINFO, ("Number of Packets/Frame: %d for %s\n", packetsPerFrame,
(tgEnable ? "10g" : "1g")));
const uint32_t addr = PKT_FRAG_REG;
if (tgEnable) {
bus_w(addr, bus_r(addr) & ~PKT_FRAG_10G_NUM_PACKETS_MSK);
bus_w(addr, bus_r(addr) |
((packetsPerFrame << PKT_FRAG_10G_NUM_PACKETS_OFST) &
PKT_FRAG_10G_NUM_PACKETS_MSK));
} else {
bus_w(addr, bus_r(addr) & ~PKT_FRAG_1G_NUM_PACKETS_MSK);
bus_w(addr,
bus_r(addr) | ((packetsPerFrame << PKT_FRAG_1G_NUM_PACKETS_OFST) &
PKT_FRAG_1G_NUM_PACKETS_MSK));
}
}
int setDelayAfterTrigger(int64_t val) { int setDelayAfterTrigger(int64_t val) {
if (val < 0) { if (val < 0) {
@ -1509,6 +1567,7 @@ int enableTenGigabitEthernet(int val) {
else { else {
bus_w(addr, bus_r(addr) & (~PKT_CONFIG_1G_INTERFACE_MSK)); bus_w(addr, bus_r(addr) & (~PKT_CONFIG_1G_INTERFACE_MSK));
} }
updateNumberOfPackets();
} }
int oneG = ((bus_r(addr) & PKT_CONFIG_1G_INTERFACE_MSK) >> int oneG = ((bus_r(addr) & PKT_CONFIG_1G_INTERFACE_MSK) >>
PKT_CONFIG_1G_INTERFACE_OFST); PKT_CONFIG_1G_INTERFACE_OFST);
@ -2059,24 +2118,38 @@ void *start_timer(void *arg) {
const int numFrames = (getNumFrames() * getNumTriggers()); const int numFrames = (getNumFrames() * getNumTriggers());
const int64_t expUs = getGatePeriod() / 1000; const int64_t expUs = getGatePeriod() / 1000;
const int imagesize = calculateDataBytes(); const int imageSize = calculateDataBytes();
const int tgEnable = enableTenGigabitEthernet(-1); const int tgEnable = enableTenGigabitEthernet(-1);
const int packetsPerFrame = const int dr = setDynamicRange(-1);
tgEnable ? PACKETS_PER_FRAME_10G : PACKETS_PER_FRAME_1G; int ncounters = __builtin_popcount(getCounterMask());
const int dataSize = imagesize / packetsPerFrame; int dataSize = 0;
int packetsPerFrame = 0;
// 10g
if (tgEnable) {
packetsPerFrame = 1;
if (dr == 32 && ncounters > 1) {
packetsPerFrame = 2;
}
}
// 1g
else {
dataSize = 1280;
if (ncounters == 3) {
dataSize = 768;
}
packetsPerFrame = imageSize / dataSize;
}
const int packetSize = dataSize + sizeof(sls_detector_header); const int packetSize = dataSize + sizeof(sls_detector_header);
LOG(logDEBUG1, LOG(logDEBUG1,
("imagesize:%d tg:%d packets/Frame:%d datasize:%d packetSize:%d\n", ("imageSize:%d tg:%d packets/Frame:%d datasize:%d packetSize:%d\n",
imagesize, tgEnable, packetsPerFrame, dataSize, packetSize)); imageSize, tgEnable, packetsPerFrame, dataSize, packetSize));
// Generate data // Generate data
char imageData[imagesize]; char imageData[imageSize];
memset(imageData, 0, imagesize); memset(imageData, 0, imageSize);
{ {
const int dr = setDynamicRange(-1); const int nchannels = NCHAN_1_COUNTER * NCHIP * ncounters;
const int numCounters = __builtin_popcount(getCounterMask());
const int nchannels = NCHAN_1_COUNTER * NCHIP * numCounters;
switch (dr) { switch (dr) {
/*case 1: // TODO: Not implemented in firmware yet /*case 1: // TODO: Not implemented in firmware yet

1
slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h
View File

@ -49,6 +49,7 @@
#define FIXED_PLL_FREQUENCY (020000000) // 20MHz #define FIXED_PLL_FREQUENCY (020000000) // 20MHz
#define READOUT_PLL_VCO_FREQ_HZ (1250000000) // 1.25GHz #define READOUT_PLL_VCO_FREQ_HZ (1250000000) // 1.25GHz
#define SYSTEM_PLL_VCO_FREQ_HZ (1000000000) // 1GHz #define SYSTEM_PLL_VCO_FREQ_HZ (1000000000) // 1GHz
#define MAX_NUM_DESERIALIZERS (40)
/** Other Definitions */ /** Other Definitions */
#define BIT16_MASK (0xFFFF) #define BIT16_MASK (0xFFFF)

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

@ -250,6 +250,8 @@ int getNumDigitalSamples();
#ifdef MYTHEN3D #ifdef MYTHEN3D
void setCounterMask(uint32_t arg); void setCounterMask(uint32_t arg);
uint32_t getCounterMask(); uint32_t getCounterMask();
void setumberOfDeserializers(int val, int tgEnable);
void updateNumberOfPackets();
#endif #endif
#if defined(JUNGFRAUD) || defined(GOTTHARDD) || defined(CHIPTESTBOARDD) || \ #if defined(JUNGFRAUD) || defined(GOTTHARDD) || defined(CHIPTESTBOARDD) || \

5
slsDetectorSoftware/src/Module.cpp
View File

@ -1723,9 +1723,8 @@ void Module::setCounterMask(uint32_t countermask) {
LOG(logDEBUG1) << "Setting Counter mask to " << countermask; LOG(logDEBUG1) << "Setting Counter mask to " << countermask;
sendToDetector(F_SET_COUNTER_MASK, countermask, nullptr); sendToDetector(F_SET_COUNTER_MASK, countermask, nullptr);
if (shm()->useReceiverFlag) { if (shm()->useReceiverFlag) {
int ncounters = __builtin_popcount(countermask); LOG(logDEBUG1) << "Sending Reciver counter mask: " << countermask;
LOG(logDEBUG1) << "Sending Reciver #counters: " << ncounters; sendToReceiver(F_RECEIVER_SET_COUNTER_MASK, countermask, nullptr);
sendToReceiver(F_RECEIVER_SET_NUM_COUNTERS, ncounters, nullptr);
} }
} }

11
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -190,7 +190,7 @@ int ClientInterface::functionTable(){
flist[F_SET_RECEIVER_UDP_PORT2] = &ClientInterface::set_udp_port2; 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_ADC_MASK_10G] = &ClientInterface::set_adc_mask_10g;
flist[F_RECEIVER_SET_NUM_COUNTERS] = &ClientInterface::set_num_counters; flist[F_RECEIVER_SET_COUNTER_MASK] = &ClientInterface::set_counter_mask;
flist[F_INCREMENT_FILE_INDEX] = &ClientInterface::increment_file_index; flist[F_INCREMENT_FILE_INDEX] = &ClientInterface::increment_file_index;
flist[F_SET_ADDITIONAL_JSON_PARAMETER] = &ClientInterface::set_additional_json_parameter; flist[F_SET_ADDITIONAL_JSON_PARAMETER] = &ClientInterface::set_additional_json_parameter;
flist[F_GET_ADDITIONAL_JSON_PARAMETER] = &ClientInterface::get_additional_json_parameter; flist[F_GET_ADDITIONAL_JSON_PARAMETER] = &ClientInterface::get_additional_json_parameter;
@ -445,8 +445,7 @@ int ClientInterface::setup_receiver(Interface &socket) {
} }
} }
if (myDetectorType == MYTHEN3) { if (myDetectorType == MYTHEN3) {
int ncounters = __builtin_popcount(arg.countermask); impl()->setCounterMask(arg.countermask);
impl()->setNumberofCounters(ncounters);
impl()->setAcquisitionTime1(arg.expTime1Ns); impl()->setAcquisitionTime1(arg.expTime1Ns);
impl()->setAcquisitionTime2(arg.expTime2Ns); impl()->setAcquisitionTime2(arg.expTime2Ns);
impl()->setAcquisitionTime3(arg.expTime3Ns); impl()->setAcquisitionTime3(arg.expTime3Ns);
@ -1587,11 +1586,11 @@ int ClientInterface::set_adc_mask_10g(Interface &socket) {
return socket.sendResult(retval); return socket.sendResult(retval);
} }
int ClientInterface::set_num_counters(Interface &socket) { int ClientInterface::set_counter_mask(Interface &socket) {
auto arg = socket.Receive<int>(); auto arg = socket.Receive<uint32_t>();
verifyIdle(socket); verifyIdle(socket);
LOG(logDEBUG1) << "Setting counters: " << arg; LOG(logDEBUG1) << "Setting counters: " << arg;
impl()->setNumberofCounters(arg); impl()->setCounterMask(arg);
return socket.Send(OK); return socket.Send(OK);
} }

2
slsReceiverSoftware/src/ClientInterface.h
View File

@ -146,7 +146,7 @@ class ClientInterface : private virtual slsDetectorDefs {
int set_udp_port2(sls::ServerInterface &socket); int set_udp_port2(sls::ServerInterface &socket);
int set_num_interfaces(sls::ServerInterface &socket); int set_num_interfaces(sls::ServerInterface &socket);
int set_adc_mask_10g(sls::ServerInterface &socket); int set_adc_mask_10g(sls::ServerInterface &socket);
int set_num_counters(sls::ServerInterface &socket); int set_counter_mask(sls::ServerInterface &socket);
int increment_file_index(sls::ServerInterface &socket); int increment_file_index(sls::ServerInterface &socket);
int set_additional_json_parameter(sls::ServerInterface &socket); int set_additional_json_parameter(sls::ServerInterface &socket);
int get_additional_json_parameter(sls::ServerInterface &socket); int get_additional_json_parameter(sls::ServerInterface &socket);

32
slsReceiverSoftware/src/GeneralData.h
View File

@ -157,8 +157,9 @@ class GeneralData {
* set number of counters (mythen3) * set number of counters (mythen3)
* @param n number of counters * @param n number of counters
* @param dr dynamic range * @param dr dynamic range
* @param tgEnable ten giga enable
*/ */
virtual void SetNumberofCounters(const int n, const int dr) { virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) {
LOG(logERROR) << "SetNumberofCounters is a generic function that " LOG(logERROR) << "SetNumberofCounters is a generic function that "
"should be overloaded by a derived class"; "should be overloaded by a derived class";
} }
@ -440,17 +441,33 @@ class Mythen3Data : public GeneralData {
* set number of counters (mythen3) * set number of counters (mythen3)
* @param n number of counters * @param n number of counters
* @param dr dynamic range * @param dr dynamic range
* @param tgEnable ten giga enable
*/ */
virtual void SetNumberofCounters(const int n, const int dr) { virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) {
if (n < 1 || n > 3) {
throw sls::RuntimeError("Invalid number of counters " +
std::to_string(n));
}
ncounters = n; ncounters = n;
nPixelsX = NCHAN * ncounters; nPixelsX = NCHAN * ncounters;
LOG(logINFO) << "nPixelsX: " << nPixelsX; LOG(logINFO) << "nPixelsX: " << nPixelsX;
imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00); imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00);
dataSize = imageSize / packetsPerFrame; // 10g
if (tgEnable) {
if (dr == 32 && n > 1) {
packetsPerFrame = 2;
} else {
packetsPerFrame = 1;
}
dataSize = imageSize / packetsPerFrame;
}
// 1g
else {
if (n == 3) {
dataSize = 768;
} else {
dataSize = 1280;
}
packetsPerFrame = imageSize / dataSize;
}
LOG(logINFO) << "Packets Per Frame: " << packetsPerFrame;
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;
LOG(logINFO) << "PacketSize: " << packetSize; LOG(logINFO) << "PacketSize: " << packetSize;
} }
@ -462,6 +479,7 @@ class Mythen3Data : public GeneralData {
*/ */
void SetDynamicRange(int dr, bool tgEnable) { void SetDynamicRange(int dr, bool tgEnable) {
imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00); imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00);
packetsPerFrame = tgEnable ? 2 : 20; packetsPerFrame = tgEnable ? 2 : 20;
dataSize = imageSize / packetsPerFrame; dataSize = imageSize / packetsPerFrame;
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;

47
slsReceiverSoftware/src/Implementation.cpp
View File

@ -120,7 +120,7 @@ void Implementation::InitializeMembers() {
subPeriod = 0; subPeriod = 0;
numberOfAnalogSamples = 0; numberOfAnalogSamples = 0;
numberOfDigitalSamples = 0; numberOfDigitalSamples = 0;
numberOfCounters = 0; counterMask = 0;
dynamicRange = 16; dynamicRange = 16;
roi.xmin = -1; roi.xmin = -1;
roi.xmax = -1; roi.xmax = -1;
@ -962,6 +962,7 @@ void Implementation::SetupWriter() {
masterAttributes->dbitlist |= (1 << i); masterAttributes->dbitlist |= (1 << i);
} }
masterAttributes->roi = roi; masterAttributes->roi = roi;
masterAttributes->counterMask = counterMask;
masterAttributes->exptime1 = std::chrono::nanoseconds(acquisitionTime1); masterAttributes->exptime1 = std::chrono::nanoseconds(acquisitionTime1);
masterAttributes->exptime2 = std::chrono::nanoseconds(acquisitionTime2); masterAttributes->exptime2 = std::chrono::nanoseconds(acquisitionTime2);
masterAttributes->exptime3 = std::chrono::nanoseconds(acquisitionTime3); masterAttributes->exptime3 = std::chrono::nanoseconds(acquisitionTime3);
@ -1616,24 +1617,30 @@ void Implementation::setNumberofDigitalSamples(const uint32_t i) {
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame); LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
} }
int Implementation::getNumberofCounters() const { uint32_t Implementation::getCounterMask() const {
LOG(logDEBUG3) << __SHORT_AT__ << " called"; LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfCounters; return counterMask;
} }
void Implementation::setNumberofCounters(const int i) { void Implementation::setCounterMask(const uint32_t i) {
if (numberOfCounters != i) { if (counterMask != i) {
numberOfCounters = i; int ncounters = __builtin_popcount(i);
if (ncounters < 1 || ncounters > 3) {
if (myDetectorType == MYTHEN3) { throw sls::RuntimeError("Invalid number of counters " +
generalData->SetNumberofCounters(i, dynamicRange); std::to_string(ncounters) +
// to update npixelsx, npixelsy in file writer ". Expected 1-3.");
for (const auto &it : dataProcessor)
it->SetPixelDimension();
SetupFifoStructure();
} }
counterMask = i;
generalData->SetNumberofCounters(ncounters, dynamicRange,
tengigaEnable);
// to update npixelsx, npixelsy in file writer
for (const auto &it : dataProcessor)
it->SetPixelDimension();
SetupFifoStructure();
} }
LOG(logINFO) << "Number of Counters: " << numberOfCounters; LOG(logINFO) << "Counter mask: " << sls::ToStringHex(counterMask);
int ncounters = __builtin_popcount(counterMask);
LOG(logINFO) << "Number of counters: " << ncounters;
} }
uint32_t Implementation::getDynamicRange() const { uint32_t Implementation::getDynamicRange() const {
@ -1647,7 +1654,14 @@ void Implementation::setDynamicRange(const uint32_t i) {
dynamicRange = i; dynamicRange = i;
if (myDetectorType == EIGER || myDetectorType == MYTHEN3) { if (myDetectorType == EIGER || myDetectorType == MYTHEN3) {
generalData->SetDynamicRange(i, tengigaEnable);
if (myDetectorType == EIGER) {
generalData->SetDynamicRange(i, tengigaEnable);
} else {
int ncounters = __builtin_popcount(counterMask);
generalData->SetNumberofCounters(ncounters, i, tengigaEnable);
}
// to update npixelsx, npixelsy in file writer // to update npixelsx, npixelsy in file writer
for (const auto &it : dataProcessor) for (const auto &it : dataProcessor)
it->SetPixelDimension(); it->SetPixelDimension();
@ -1689,13 +1703,14 @@ bool Implementation::getTenGigaEnable() const {
void Implementation::setTenGigaEnable(const bool b) { void Implementation::setTenGigaEnable(const bool b) {
if (tengigaEnable != b) { if (tengigaEnable != b) {
tengigaEnable = b; tengigaEnable = b;
int ncounters = __builtin_popcount(counterMask);
// side effects // side effects
switch (myDetectorType) { switch (myDetectorType) {
case EIGER: case EIGER:
generalData->SetTenGigaEnable(b, dynamicRange); generalData->SetTenGigaEnable(b, dynamicRange);
break; break;
case MYTHEN3: case MYTHEN3:
generalData->SetDynamicRange(dynamicRange, b); generalData->SetNumberofCounters(ncounters, dynamicRange, b);
break; break;
case MOENCH: case MOENCH:
case CHIPTESTBOARD: case CHIPTESTBOARD:

7
slsReceiverSoftware/src/Implementation.h
View File

@ -186,8 +186,9 @@ class Implementation : private virtual slsDetectorDefs {
uint32_t getNumberofDigitalSamples() const; uint32_t getNumberofDigitalSamples() const;
/**[Ctb] */ /**[Ctb] */
void setNumberofDigitalSamples(const uint32_t i); void setNumberofDigitalSamples(const uint32_t i);
int getNumberofCounters() const; uint32_t getCounterMask() const;
void setNumberofCounters(const int i); /** [Mythen3] */
void setCounterMask(const uint32_t i);
uint32_t getDynamicRange() const; uint32_t getDynamicRange() const;
void setDynamicRange(const uint32_t i); void setDynamicRange(const uint32_t i);
ROI getROI() const; ROI getROI() const;
@ -329,7 +330,7 @@ class Implementation : private virtual slsDetectorDefs {
uint64_t subPeriod; uint64_t subPeriod;
uint64_t numberOfAnalogSamples; uint64_t numberOfAnalogSamples;
uint64_t numberOfDigitalSamples; uint64_t numberOfDigitalSamples;
int numberOfCounters; uint32_t counterMask;
uint32_t dynamicRange; uint32_t dynamicRange;
ROI roi; ROI roi;
bool tengigaEnable; bool tengigaEnable;

14
slsReceiverSoftware/src/MasterAttributes.h
View File

@ -40,6 +40,7 @@ struct MasterAttributes {
uint32_t dbitoffset{0}; uint32_t dbitoffset{0};
uint64_t dbitlist{0}; uint64_t dbitlist{0};
slsDetectorDefs::ROI roi{}; slsDetectorDefs::ROI roi{};
uint32_t counterMask{0};
ns exptime1{0}; ns exptime1{0};
ns exptime2{0}; ns exptime2{0};
ns exptime3{0}; ns exptime3{0};
@ -344,7 +345,7 @@ class EigerMasterAttributes : public MasterAttributes {
// Rate corrections // Rate corrections
{ {
DataSpace dataspace = DataSpace(H5S_SCALAR); DataSpace dataspace = DataSpace(H5S_SCALAR);
StrType strdatatype(PredType::C_S1, 256); StrType strdatatype(PredType::C_S1, 1024);
DataSet dataset = group->createDataSet("rate corrections", DataSet dataset = group->createDataSet("rate corrections",
strdatatype, dataspace); strdatatype, dataspace);
dataset.write(sls::ToString(ratecorr), strdatatype); dataset.write(sls::ToString(ratecorr), strdatatype);
@ -363,6 +364,8 @@ class Mythen3MasterAttributes : public MasterAttributes {
<< "Dynamic Range : " << dynamicRange << '\n' << "Dynamic Range : " << dynamicRange << '\n'
<< "Ten Giga : " << tenGiga << '\n' << "Ten Giga : " << tenGiga << '\n'
<< "Period : " << sls::ToString(period) << '\n' << "Period : " << sls::ToString(period) << '\n'
<< "Counter Mask : " << sls::ToStringHex(counterMask)
<< '\n'
<< "Exptime1 : " << sls::ToString(exptime1) << "Exptime1 : " << sls::ToString(exptime1)
<< '\n' << '\n'
<< "Exptime2 : " << sls::ToString(exptime2) << "Exptime2 : " << sls::ToString(exptime2)
@ -386,6 +389,13 @@ class Mythen3MasterAttributes : public MasterAttributes {
MasterAttributes::WriteHDF5DynamicRange(fd, group); MasterAttributes::WriteHDF5DynamicRange(fd, group);
MasterAttributes::WriteHDF5TenGiga(fd, group); MasterAttributes::WriteHDF5TenGiga(fd, group);
MasterAttributes::WriteHDF5Period(fd, group); MasterAttributes::WriteHDF5Period(fd, group);
// Counter Mask
{
DataSpace dataspace = DataSpace(H5S_SCALAR);
DataSet dataset = group->createDataSet(
"counter mask", PredType::STD_U32LE, dataspace);
dataset.write(&counterMask, PredType::STD_U32LE);
}
// Exptime1 // Exptime1
{ {
DataSpace dataspace = DataSpace(H5S_SCALAR); DataSpace dataspace = DataSpace(H5S_SCALAR);
@ -439,7 +449,7 @@ class Mythen3MasterAttributes : public MasterAttributes {
DataSpace dataspace = DataSpace(H5S_SCALAR); DataSpace dataspace = DataSpace(H5S_SCALAR);
DataSet dataset = DataSet dataset =
group->createDataSet("gates", PredType::STD_U32LE, dataspace); group->createDataSet("gates", PredType::STD_U32LE, dataspace);
dataset.write(&gates, PredType::STD_U64LE); dataset.write(&gates, PredType::STD_U32LE);
} }
}; };
#endif #endif

4
slsSupportLib/include/sls_detector_funcs.h
View File

@ -298,7 +298,7 @@ enum detFuncs {
F_SET_RECEIVER_UDP_PORT2, F_SET_RECEIVER_UDP_PORT2,
F_SET_RECEIVER_NUM_INTERFACES, F_SET_RECEIVER_NUM_INTERFACES,
F_RECEIVER_SET_ADC_MASK_10G, F_RECEIVER_SET_ADC_MASK_10G,
F_RECEIVER_SET_NUM_COUNTERS, F_RECEIVER_SET_COUNTER_MASK,
F_INCREMENT_FILE_INDEX, F_INCREMENT_FILE_INDEX,
F_SET_ADDITIONAL_JSON_PARAMETER, F_SET_ADDITIONAL_JSON_PARAMETER,
F_GET_ADDITIONAL_JSON_PARAMETER, F_GET_ADDITIONAL_JSON_PARAMETER,
@ -609,7 +609,7 @@ const char* getFunctionNameFromEnum(enum detFuncs func) {
case F_SET_RECEIVER_UDP_PORT2: return "F_SET_RECEIVER_UDP_PORT2"; 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_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_ADC_MASK_10G: return "F_RECEIVER_SET_ADC_MASK_10G";
case F_RECEIVER_SET_NUM_COUNTERS: return "F_RECEIVER_SET_NUM_COUNTERS"; case F_RECEIVER_SET_COUNTER_MASK: return "F_RECEIVER_SET_COUNTER_MASK";
case F_INCREMENT_FILE_INDEX: return "F_INCREMENT_FILE_INDEX"; case F_INCREMENT_FILE_INDEX: return "F_INCREMENT_FILE_INDEX";
case F_SET_ADDITIONAL_JSON_PARAMETER: return "F_SET_ADDITIONAL_JSON_PARAMETER"; case F_SET_ADDITIONAL_JSON_PARAMETER: return "F_SET_ADDITIONAL_JSON_PARAMETER";
case F_GET_ADDITIONAL_JSON_PARAMETER: return "F_GET_ADDITIONAL_JSON_PARAMETER"; case F_GET_ADDITIONAL_JSON_PARAMETER: return "F_GET_ADDITIONAL_JSON_PARAMETER";

2
slsSupportLib/include/versionAPI.h
View File

@ -7,6 +7,6 @@
#define APICTB 0x200729 #define APICTB 0x200729
#define APIGOTTHARD 0x200729 #define APIGOTTHARD 0x200729
#define APIJUNGFRAU 0x200729 #define APIJUNGFRAU 0x200729
#define APIMYTHEN3 0x200729
#define APIMOENCH 0x200729 #define APIMOENCH 0x200729
#define APIGOTTHARD2 0x200730 #define APIGOTTHARD2 0x200730
#define APIMYTHEN3 0x200804