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

adding config for tests

Browse Source
This commit is contained in:
Erik Frojdh 2019-04-23 17:37:02 +02:00
parent 72091f47d9
commit 02fd4b356e
9 changed files with 258 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
integrationTests/a.cpp
View File

@ -36,9 +36,10 @@ std::ostream &operator<<(std::ostream &out, const ROI &r) {
int main() { int main() {
int ret[]{0,0,0}; std::cout << "nullptr: " << sizeof(nullptr) << "\n";
for (auto i: ret) // int ret[]{0,0,0};
std::cout << i << "\n"; // for (auto i: ret)
// std::cout << i << "\n";
// uint32_t imageSize = 101; // uint32_t imageSize = 101;
// uint32_t packetSize = 100; // uint32_t packetSize = 100;
// std::cout << "a: " << std::ceil((double)imageSize / (double)packetSize) <<'\n'; // std::cout << "a: " << std::ceil((double)imageSize / (double)packetSize) <<'\n';

180
integrationTests/test-integrationDectector.cpp
View File

@ -13,18 +13,41 @@
#include <vector> #include <vector>
#define VERBOSE #define VERBOSE
//Header holding all configurations for different detectors // Header holding all configurations for different detectors
#include "config.h" #include "tests/config.h"
TEST_CASE("single EIGER detector no receiver basic set and get", "[.integration]") { using dt = slsDetectorDefs::detectorType;
//TODO! this test should take command line arguments for config extern std::string hostname;
extern std::string detector_type;
extern dt type;
TEST_CASE("Single detector no receiver", "[.integration][cli]") {
auto t = slsDetector::getTypeFromDetector(hostname);
CHECK(t == type);
slsDetector d(t);
CHECK(d.getDetectorTypeAsEnum() == t);
CHECK(d.getDetectorTypeAsString() == detector_type);
d.setHostname(hostname);
CHECK(d.getHostname() == hostname);
d.setOnline(true);
CHECK(d.getOnlineFlag() == true);
d.freeSharedMemory();
}
TEST_CASE("single EIGER detector no receiver basic set and get",
"[.integration][eiger]") {
// TODO! this test should take command line arguments for config
SingleDetectorConfig c; SingleDetectorConfig c;
//Read type by connecting to the detector // Read type by connecting to the detector
auto type = slsDetector::getTypeFromDetector(c.hostname); auto type = slsDetector::getTypeFromDetector(c.hostname);
CHECK(type == c.type_enum); CHECK(type == c.type_enum);
//Create slsDetector of said type and set hostname and detector online // Create slsDetector of said type and set hostname and detector online
slsDetector d(type); slsDetector d(type);
CHECK(d.getDetectorTypeAsEnum() == type); CHECK(d.getDetectorTypeAsEnum() == type);
CHECK(d.getDetectorTypeAsString() == c.type_string); CHECK(d.getDetectorTypeAsString() == c.type_string);
@ -38,19 +61,22 @@ TEST_CASE("single EIGER detector no receiver basic set and get", "[.integration]
CHECK(d.getReceiverOnline() == false); CHECK(d.getReceiverOnline() == false);
CHECK(d.checkDetectorVersionCompatibility() == slsDetectorDefs::OK); CHECK(d.checkDetectorVersionCompatibility() == slsDetectorDefs::OK);
//Setting and reading exposure time // Setting and reading exposure time
auto t = 1000000000; auto t = 1000000000;
d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t); d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t); CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t);
//size of an eiger half module with and without gap pixels // size of an eiger half module with and without gap pixels
CHECK(d.getTotalNumberOfChannels() == 256 * 256 * 4); CHECK(d.getTotalNumberOfChannels() == 256 * 256 * 4);
CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::X) == 1024); CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::X) == 1024);
CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Y) == 256); CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Y) == 256);
// CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Z) == 1); // CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Z) == 1);
CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::X) == 1024); CHECK(d.getTotalNumberOfChannelsInclGapPixels(
CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::Y) == 256); slsDetectorDefs::dimension::X) == 1024);
// CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::Z) == 1); CHECK(d.getTotalNumberOfChannelsInclGapPixels(
slsDetectorDefs::dimension::Y) == 256);
// CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::Z)
// == 1);
CHECK(d.getNChans() == 256 * 256); CHECK(d.getNChans() == 256 * 256);
CHECK(d.getNChans(slsDetectorDefs::dimension::X) == 256); CHECK(d.getNChans(slsDetectorDefs::dimension::X) == 256);
@ -69,7 +95,7 @@ TEST_CASE("Set control port then create a new object with this control port",
"[.integration]") { "[.integration]") {
/* /*
TODO! TODO!
Standard port but should not be hardcoded Standard port but should not be hardcoded
Is this the best way to initialize the detectors Is this the best way to initialize the detectors
Using braces to make the object go out of scope Using braces to make the object go out of scope
*/ */
@ -102,7 +128,7 @@ TEST_CASE("Set control port then create a new object with this control port",
d.setOnline(true); d.setOnline(true);
//Reset standard ports // Reset standard ports
d.setControlPort(old_cport); d.setControlPort(old_cport);
d.setStopPort(old_sport); d.setStopPort(old_sport);
d.freeSharedMemory(); d.freeSharedMemory();
@ -124,17 +150,17 @@ TEST_CASE("Locking mechanism and last ip", "[.integration]") {
d.setHostname(c.hostname); d.setHostname(c.hostname);
d.setOnline(true); d.setOnline(true);
//Check that detector server is unlocked then lock // Check that detector server is unlocked then lock
CHECK(d.lockServer() == 0); CHECK(d.lockServer() == 0);
d.lockServer(1); d.lockServer(1);
CHECK(d.lockServer() == 1); CHECK(d.lockServer() == 1);
//Can we still access the detector while it's locked // Can we still access the detector while it's locked
auto t = 1300000000; auto t = 1300000000;
d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t); d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t); CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t);
//unlock again and free // unlock again and free
d.lockServer(0); d.lockServer(0);
CHECK(d.lockServer() == 0); CHECK(d.lockServer() == 0);
@ -142,15 +168,17 @@ TEST_CASE("Locking mechanism and last ip", "[.integration]") {
d.freeSharedMemory(); d.freeSharedMemory();
} }
TEST_CASE("Excersise all possible set timer functions", "[.integration]") { TEST_CASE("Timer functions", "[.integration][cli]") {
// FRAME_NUMBER, /**< number of real time frames: total number of acquisitions is number or frames*number of cycles */ // FRAME_NUMBER, /**< number of real time frames: total number of
// ACQUISITION_TIME, /**< exposure time */ // acquisitions is number or frames*number of cycles */ ACQUISITION_TIME,
// FRAME_PERIOD, /**< period between exposures */ // /**< exposure time */ FRAME_PERIOD, /**< period between exposures */
// DELAY_AFTER_TRIGGER, /**< delay between trigger and start of exposure or readout (in triggered mode) */ // DELAY_AFTER_TRIGGER, /**< delay between trigger and start of exposure or
// GATES_NUMBER, /**< number of gates per frame (in gated mode) */ // readout (in triggered mode) */ GATES_NUMBER, /**< number of gates per
// CYCLES_NUMBER, /**< number of cycles: total number of acquisitions is number or frames*number of cycles */ // frame (in gated mode) */ CYCLES_NUMBER, /**< number of cycles: total
// number of acquisitions is number or frames*number of cycles */
// ACTUAL_TIME, /**< Actual time of the detector's internal timer */ // ACTUAL_TIME, /**< Actual time of the detector's internal timer */
// MEASUREMENT_TIME, /**< Time of the measurement from the detector (fifo) */ // MEASUREMENT_TIME, /**< Time of the measurement from the detector (fifo)
// */
// PROGRESS, /**< fraction of measurement elapsed - only get! */ // PROGRESS, /**< fraction of measurement elapsed - only get! */
// MEASUREMENTS_NUMBER, // MEASUREMENTS_NUMBER,
@ -163,43 +191,56 @@ TEST_CASE("Excersise all possible set timer functions", "[.integration]") {
// MEASURED_PERIOD, /**< measured period */ // MEASURED_PERIOD, /**< measured period */
// MEASURED_SUBPERIOD, /**< measured subperiod */ // MEASURED_SUBPERIOD, /**< measured subperiod */
// MAX_TIMERS // MAX_TIMERS
SingleDetectorConfig c;
auto type = slsDetector::getTypeFromDetector(c.hostname);
slsDetector d(type); slsDetector d(type);
d.setHostname(c.hostname); d.setHostname(hostname);
d.setOnline(true); d.setOnline(true);
//Number of frames // Number of frames
auto frames = 10; auto frames = 5;
d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, frames); d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, frames);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER) == frames); CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER) == frames);
auto t = 10000000; auto exptime = 2000000000;
d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t); d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, exptime);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t); CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == exptime);
auto period = 1000000000; auto period = 2000000000;
d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period); d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD) == period); CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD) == period);
// not implemented for EIGER if (type != dt::EIGER) {
// auto delay = 10000; auto delay = 10000;
// d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, delay); d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, delay);
// CHECK(d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER) == delay); CHECK(d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER) ==
delay);
}
// auto gates = 1; if (type != dt::EIGER) {
// d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, gates); auto gates = 1;
// CHECK(d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER) == gates); d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, gates);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER) == gates);
}
auto cycles = 2; auto cycles = 2;
d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, cycles); d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, cycles);
CHECK(d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER) == cycles); CHECK(d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER) == cycles);
auto subtime = 200; if (type == dt::EIGER) {
d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, subtime); auto subtime = 200;
CHECK(d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME) == subtime); d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME,
subtime);
CHECK(d.setTimer(
slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME) ==
subtime);
}
// for (int i =0; i!=frames; ++i)
d.startAndReadAll();
d.freeSharedMemory(); d.freeSharedMemory();
// If we add a timer we should add tests for the timer
CHECK(slsDetectorDefs::MAX_TIMERS == 19);
} }
// TEST_CASE("Aquire", "[.integration][eiger]"){ // TEST_CASE("Aquire", "[.integration][eiger]"){
@ -216,26 +257,27 @@ TEST_CASE("Excersise all possible set timer functions", "[.integration]") {
// d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period); // d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period);
// d.startAndReadAll(); // d.startAndReadAll();
// auto rperiod =
// d.getTimeLeft(slsDetectorDefs::timerIndex::MEASURED_PERIOD);
// auto rperiod = d.getTimeLeft(slsDetectorDefs::timerIndex::MEASURED_PERIOD);
// CHECK(rperiod == 0.1); // CHECK(rperiod == 0.1);
// d.freeSharedMemory(); // d.freeSharedMemory();
// } // }
TEST_CASE("Eiger Dynamic Range with effect on rate correction and clock divider", "[.eigerintegration]") { TEST_CASE(
"Eiger Dynamic Range with effect on rate correction and clock divider",
"[.eigerintegration]") {
SingleDetectorConfig c; SingleDetectorConfig c;
int ratecorr = 125; int ratecorr = 125;
// pick up multi detector from shm id 0 // pick up multi detector from shm id 0
multiSlsDetector m(0); multiSlsDetector m(0);
// ensure eiger detector type, hostname and online // ensure eiger detector type, hostname and online
REQUIRE(m.getDetectorTypeAsEnum()==c.type_enum); REQUIRE(m.getDetectorTypeAsEnum() == c.type_enum);
REQUIRE(m.getHostname()==c.hostname); REQUIRE(m.getHostname() == c.hostname);
REQUIRE(m.setOnline(true)==slsDetectorDefs::ONLINE_FLAG); REQUIRE(m.setOnline(true) == slsDetectorDefs::ONLINE_FLAG);
// starting state with rate correction off // starting state with rate correction off
CHECK(m.setRateCorrection(0) == 0); CHECK(m.setRateCorrection(0) == 0);
@ -267,27 +309,26 @@ TEST_CASE("Eiger Dynamic Range with effect on rate correction and clock divider"
// ratecorr fail with dr 4 or 8 // ratecorr fail with dr 4 or 8
CHECK_THROWS_AS(m.setDynamicRange(8), sls::NonCriticalError); CHECK_THROWS_AS(m.setDynamicRange(8), sls::NonCriticalError);
CHECK(m.getRateCorrection()==0); CHECK(m.getRateCorrection() == 0);
m.setDynamicRange(16); m.setDynamicRange(16);
m.setDynamicRange(16); m.setDynamicRange(16);
m.setRateCorrection(ratecorr); m.setRateCorrection(ratecorr);
m.setDynamicRange(16); m.setDynamicRange(16);
m.setRateCorrection(ratecorr); m.setRateCorrection(ratecorr);
CHECK_THROWS_AS(m.setDynamicRange(4), sls::NonCriticalError); CHECK_THROWS_AS(m.setDynamicRange(4), sls::NonCriticalError);
CHECK(m.getRateCorrection()==0); CHECK(m.getRateCorrection() == 0);
} }
TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") { TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
SingleDetectorConfig c; SingleDetectorConfig c;
// pick up multi detector from shm id 0 // pick up multi detector from shm id 0
multiSlsDetector m(0); multiSlsDetector m(0);
// ensure ctb detector type, hostname and online // ensure ctb detector type, hostname and online
REQUIRE(m.getDetectorTypeAsEnum()==c.type_enum); REQUIRE(m.getDetectorTypeAsEnum() == c.type_enum);
REQUIRE(m.getHostname()==c.hostname); REQUIRE(m.getHostname() == c.hostname);
REQUIRE(m.setOnline(true)==slsDetectorDefs::ONLINE_FLAG); REQUIRE(m.setOnline(true) == slsDetectorDefs::ONLINE_FLAG);
uint64_t word = 0; uint64_t word = 0;
int addr = 0; int addr = 0;
@ -314,25 +355,30 @@ TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
m.setPatternWord(addr, word); m.setPatternWord(addr, word);
CHECK(m.setPatternWord(addr, -1) == word); CHECK(m.setPatternWord(addr, -1) == word);
addr = MAX_ADDR; addr = MAX_ADDR;
CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError); CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError);
CHECK_THROWS_WITH(m.setPatternWord(addr, word), Catch::Matchers::Contains( "be between 0 and" )); CHECK_THROWS_WITH(m.setPatternWord(addr, word),
Catch::Matchers::Contains("be between 0 and"));
addr = -1; addr = -1;
CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError); CHECK_THROWS_AS(m.setPatternWord(addr, word), sls::NonCriticalError);
CHECK_THROWS_WITH(m.setPatternWord(addr, word), Catch::Matchers::Contains( "be between 0 and" )); CHECK_THROWS_WITH(m.setPatternWord(addr, word),
Catch::Matchers::Contains("be between 0 and"));
addr = 0x2FF; addr = 0x2FF;
for (level = 0; level < 3; ++level) { for (level = 0; level < 3; ++level) {
CHECK(m.setPatternWaitAddr(level, addr) == addr); CHECK(m.setPatternWaitAddr(level, addr) == addr);
CHECK(m.setPatternWaitAddr(level, -1) == addr); CHECK(m.setPatternWaitAddr(level, -1) == addr);
} }
CHECK_THROWS_WITH(m.setPatternWaitAddr(-1, addr), Catch::Matchers::Contains( "be between 0 and" )); CHECK_THROWS_WITH(m.setPatternWaitAddr(-1, addr),
CHECK_THROWS_WITH(m.setPatternWaitAddr(0, MAX_ADDR), Catch::Matchers::Contains( "be between 0 and" )); Catch::Matchers::Contains("be between 0 and"));
CHECK_THROWS_WITH(m.setPatternWaitAddr(0, MAX_ADDR),
Catch::Matchers::Contains("be between 0 and"));
for (level = 0; level < 3; ++level) { for (level = 0; level < 3; ++level) {
CHECK(m.setPatternWaitTime(level, word) == word); CHECK(m.setPatternWaitTime(level, word) == word);
CHECK(m.setPatternWaitTime(level, -1) == word); CHECK(m.setPatternWaitTime(level, -1) == word);
} }
CHECK_THROWS_WITH(m.setPatternWaitTime(-1, word), Catch::Matchers::Contains( "be between 0 and" )); CHECK_THROWS_WITH(m.setPatternWaitTime(-1, word),
Catch::Matchers::Contains("be between 0 and"));
{ {
int startaddr = addr; int startaddr = addr;
@ -354,6 +400,6 @@ TEST_CASE("Chiptestboard Loading Patterns", "[.ctbintegration]") {
CHECK_THROWS_WITH(m.setPatternLoops(-1, startaddr, MAX_ADDR, nloops), CHECK_THROWS_WITH(m.setPatternLoops(-1, startaddr, MAX_ADDR, nloops),
Catch::Matchers::Contains("be less than")); Catch::Matchers::Contains("be less than"));
CHECK_THROWS_WITH(m.setPatternLoops(-1, MAX_ADDR, stopaddr, nloops), CHECK_THROWS_WITH(m.setPatternLoops(-1, MAX_ADDR, stopaddr, nloops),
Catch::Matchers::Contains("be less than")); Catch::Matchers::Contains("be less than"));
} }
} }

87
integrationTests/test-integrationMulti.cpp
View File

@ -1,11 +1,78 @@
// #include "catch.hpp" #include "catch.hpp"
// #include "multiSlsDetector.h"
// #include <iostream> #include "multiSlsDetector.h"
// TEST_CASE("Initialize a detector") { #include "string_utils.h"
// multiSlsDetector det(0, true, true);
// std::cout << "Size: " << det.getNumberOfDetectors() << std::endl; #include "tests/globals.h"
// std::cout << "Hostname: " << det.getHostname() << std::endl;
// REQUIRE(false); #include <iostream>
// } TEST_CASE("Initialize a multi detector", "[.integration][.multi]") {
auto hostnames = sls::split(hostname, '+');
multiSlsDetector d(0, true, true);
d.setHostname(hostname.c_str());
REQUIRE(d.setOnline() == true); // get!
CHECK(d.getHostname() == hostname);
for (size_t i = 0; i != hostnames.size(); ++i) {
CHECK(d.getHostname(i) == hostnames[i]);
}
CHECK(d.getDetectorTypeAsEnum() == type);
CHECK(d.getDetectorTypeAsString() == detector_type);
CHECK(d.getNumberOfDetectors() == hostnames.size());
d.freeSharedMemory();
}
TEST_CASE("Set and get dacs", "[.integration][.multi]"){
multiSlsDetector d(0, true, true);
d.setHostname(hostname.c_str());
switch(type){
case dt::EIGER:
d.setDAC(3500, di::E_Vrf, 0);
CHECK(d.setDAC(-1, di::E_Vrf, 0) == 3500);
d.setDAC(1500, di::E_Vcmp_ll, 0);
CHECK(d.setDAC(-1, di::E_Vcmp_ll, 0) == 1500);
d.setDAC(1400, di::E_Vcmp_lr, 0);
CHECK(d.setDAC(-1, di::E_Vcmp_lr, 0) == 1400);
d.setDAC(1300, di::E_Vcmp_rl, 0);
CHECK(d.setDAC(-1, di::E_Vcmp_rl, 0) == 1300);
d.setDAC(1200, di::E_Vcmp_rr, 0);
CHECK(d.setDAC(-1, di::E_Vcmp_rr, 0) == 1200);
auto th = 1000;
d.setDAC(th, di::THRESHOLD, 0);
CHECK(d.setDAC(-1, di::THRESHOLD, 0) == th);
CHECK(d.setDAC(-1, di::E_Vcmp_ll, 0) == th);
CHECK(d.setDAC(-1, di::E_Vcmp_lr, 0) == th);
CHECK(d.setDAC(-1, di::E_Vcmp_rl, 0) == th);
CHECK(d.setDAC(-1, di::E_Vcmp_rr, 0) == th);
break;
}
d.freeSharedMemory();
}
TEST_CASE("Timers", "[.integration][.multi]") {
multiSlsDetector d(0, true, true);
d.setHostname(hostname.c_str());
int n_frames = 3;
d.setNumberOfFrames(n_frames);
CHECK(d.setNumberOfFrames() == n_frames);
double exptime = 1;
d.setExposureTime(exptime, true);
CHECK(d.setExposureTime(-1, true) == exptime);
d.freeSharedMemory();
}

2
slsDetectorSoftware/include/slsDetector.h
View File

@ -291,6 +291,8 @@ class slsDetector : public virtual slsDetectorDefs{
*/ */
int64_t getId(idMode mode); int64_t getId(idMode mode);
int sendToDetector(int fnum, void* args, size_t args_size, void* retval, size_t retval_size);
int64_t getReceiverSoftwareVersion() const; int64_t getReceiverSoftwareVersion() const;

24
slsDetectorSoftware/src/slsDetector.cpp
View File

@ -1826,16 +1826,13 @@ int slsDetector::getDataBytesInclGapPixels() {
int slsDetector::setDAC(int val, dacIndex index, int mV) { int slsDetector::setDAC(int val, dacIndex index, int mV) {
int fnum = F_SET_DAC; int fnum = F_SET_DAC;
int ret = FAIL; int ret = FAIL;
int args[3]{static_cast<int>(index), mV, val}; int args[]{static_cast<int>(index), mV, val};
int retval = -1; int retval = -1;
FILE_LOG(logDEBUG1) << "Setting DAC " << index << " to " << val FILE_LOG(logDEBUG1) << "Setting DAC " << index << " to " << val
<< (mV != 0 ? "mV" : "dac units"); << (mV != 0 ? "mV" : "dac units");
if (detector_shm()->onlineFlag == ONLINE_FLAG) { if (detector_shm()->onlineFlag == ONLINE_FLAG) {
auto client = DetectorSocket(detector_shm()->hostname, ret = sendToDetector(fnum, args, sizeof(args), &retval, sizeof(retval));
detector_shm()->controlPort);
ret = client.sendCommandThenRead(fnum, args, sizeof(args), &retval,
sizeof(retval));
FILE_LOG(logDEBUG1) << "Dac index " << index << ": " << retval FILE_LOG(logDEBUG1) << "Dac index " << index << ": " << retval
<< (mV != 0 ? "mV" : "dac units"); << (mV != 0 ? "mV" : "dac units");
} }
@ -1845,6 +1842,15 @@ int slsDetector::setDAC(int val, dacIndex index, int mV) {
return retval; return retval;
} }
int slsDetector::sendToDetector(int fnum, void* args, size_t args_size, void* retval, size_t retval_size)
{
auto client = DetectorSocket(detector_shm()->hostname,
detector_shm()->controlPort);
return client.sendCommandThenRead(fnum, args, args_size, retval, retval_size);
}
int slsDetector::getADC(dacIndex index) { int slsDetector::getADC(dacIndex index) {
int fnum = F_GET_ADC; int fnum = F_GET_ADC;
int arg = static_cast<int>(index); int arg = static_cast<int>(index);
@ -1870,10 +1876,10 @@ slsDetector::setExternalCommunicationMode(externalCommunicationMode pol) {
FILE_LOG(logDEBUG1) << "Setting communication to mode " << pol; FILE_LOG(logDEBUG1) << "Setting communication to mode " << pol;
if (detector_shm()->onlineFlag == ONLINE_FLAG) { if (detector_shm()->onlineFlag == ONLINE_FLAG) {
auto client = DetectorSocket(detector_shm()->hostname, ret = sendToDetector(fnum, &arg, sizeof(arg), &retval,sizeof(retval));
detector_shm()->controlPort); // auto client = DetectorSocket(detector_shm()->hostname,
ret = client.sendCommandThenRead(fnum, &arg, sizeof(arg), &retval, // detector_shm()->controlPort);
sizeof(retval)); // ret = client.sendCommandThenRead(fnum, &arg, sizeof(arg), &retval,sizeof(retval));
FILE_LOG(logDEBUG1) << "Timing Mode: " << retval; FILE_LOG(logDEBUG1) << "Timing Mode: " << retval;
} }
if (ret == FORCE_UPDATE) { if (ret == FORCE_UPDATE) {

1
tests/CMakeLists.txt
View File

@ -1,5 +1,6 @@
include_directories( include_directories(
${PROJECT_SOURCE_DIR}/catch ${PROJECT_SOURCE_DIR}/catch
include
) )
set(SLS_TEST_SOURCES set(SLS_TEST_SOURCES

3
integrationTests/config.h → tests/include/tests/config.h
View File

@ -1,5 +1,8 @@
#pragma once #pragma once
#include <string> #include <string>
#include "sls_detector_defs.h"
struct SingleDetectorConfig { struct SingleDetectorConfig {
slsDetectorDefs::detectorType type_enum = slsDetectorDefs::detectorType type_enum =
slsDetectorDefs::detectorType::CHIPTESTBOARD; slsDetectorDefs::detectorType::CHIPTESTBOARD;

6
tests/include/tests/globals.h Normal file
View File

@ -0,0 +1,6 @@
#include "sls_detector_defs.h"
using dt = slsDetectorDefs::detectorType;
using di = slsDetectorDefs::dacIndex;
extern std::string hostname;
extern std::string detector_type;
extern dt type;

39
tests/test.cpp
View File

@ -1,3 +1,38 @@
// tests-main.cpp // tests-main.cpp
#define CATCH_CONFIG_MAIN // #define CATCH_CONFIG_MAIN
#include "catch.hpp" // #include "catch.hpp"
#define CATCH_CONFIG_RUNNER
#include "catch.hpp"
#include "sls_detector_defs.h"
#include "tests/config.h"
#include <string>
// using namespace Catch::clara;
using Opt = Catch::clara::Opt;
using dt = slsDetectorDefs::detectorType;
std::string hostname;
std::string detector_type;
dt type;
int main(int argc, char *argv[]) {
Catch::Session session;
auto cli = session.cli() |
Opt(hostname, "hostname")["-hn"]["--hostname"](
"Detector hostname for integration tests") |
Opt(detector_type, "detector_type")["-dt"]["--detector_type"](
"Detector type for integration tests");
session.cli(cli);
auto ret = session.applyCommandLine(argc, argv);
if (ret) {
return ret;
}
type = slsDetectorDefs::detectorTypeToEnum(detector_type);
return session.run();
}