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

Merge pull request #1148 from slsdetectorgroup/dev/cmd_for_ctb_reorder
Some checks failed
CMake / Configure and build using cmake (push) Failing after 1m19s
Details

Browse Source 
Dev/cmd for ctb reorder
This commit is contained in:
maliakal_d
2025-03-17 17:10:52 +01:00
committed by GitHub
parent e0a48e1e75 f4626c2c81
commit d9a50705e4
23 changed files with 290 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -218,6 +218,8 @@ int ClientInterface::functionTable(){
flist[F_RECEIVER_SET_TRANSCEIVER_MASK] = &ClientInterface::set_transceiver_mask;
flist[F_RECEIVER_SET_ROW] = &ClientInterface::set_row;
flist[F_RECEIVER_SET_COLUMN] = &ClientInterface::set_column;
flist[F_GET_RECEIVER_DBIT_REORDER] = &ClientInterface::get_dbit_reorder;
flist[F_SET_RECEIVER_DBIT_REORDER] = &ClientInterface::set_dbit_reorder;
for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) {
@ -1789,4 +1791,25 @@ int ClientInterface::set_column(Interface &socket) {
return socket.Send(OK);
}
int ClientInterface::get_dbit_reorder(Interface &socket) {
if (detType != CHIPTESTBOARD && detType != XILINX_CHIPTESTBOARD)
functionNotImplemented();
int retval = impl()->getDbitReorder();
LOG(logDEBUG1) << "Dbit reorder retval: " << retval;
return socket.sendResult(retval);
}
int ClientInterface::set_dbit_reorder(Interface &socket) {
auto arg = socket.Receive<int>();
if (detType != CHIPTESTBOARD && detType != XILINX_CHIPTESTBOARD)
functionNotImplemented();
if (arg < 0) {
throw RuntimeError("Invalid dbit reorder: " + std::to_string(arg));
}
verifyIdle(socket);
LOG(logDEBUG1) << "Setting Dbit offset: " << arg;
impl()->setDbitReorder(arg);
return socket.Send(OK);
}
} // namespace sls

2
slsReceiverSoftware/src/ClientInterface.h
View File

@ -164,6 +164,8 @@ class ClientInterface : private virtual slsDetectorDefs {
int set_transceiver_mask(ServerInterface &socket);
int set_row(ServerInterface &socket);
int set_column(ServerInterface &socket);
int get_dbit_reorder(ServerInterface &socket);
int set_dbit_reorder(ServerInterface &socket);
Implementation *impl() {
if (receiver != nullptr) {

12
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -3,7 +3,7 @@
/************************************************
* @file DataProcessor.cpp
* @short creates data processor thread that
* pulls pointers to memory addresses from fifos
* pulls pointers to memory addresses from fifos
* and processes data stored in them & writes them to file
***********************************************/
@ -75,10 +75,10 @@ void DataProcessor::SetCtbDbitList(std::vector<int> value) {
ctbDbitList = value;
}
void DataProcessor::SetReorder(const bool value) { reorder = value; }
void DataProcessor::SetCtbDbitOffset(int value) { ctbDbitOffset = value; }
void DataProcessor::SetCtbDbitReorder(bool value) { ctbDbitReorder = value; }
void DataProcessor::SetQuadEnable(bool value) { quadEnable = value; }
void DataProcessor::SetFlipRows(bool fd) {
@ -361,7 +361,7 @@ void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
// rearrange ctb digital bits
if (!ctbDbitList.empty()) {
ArrangeDbitData(size, data);
} else if (reorder) {
} else if (ctbDbitReorder) {
Reorder(size, data);
} else if (ctbDbitOffset > 0) {
RemoveTrailingBits(size, data);
@ -679,7 +679,7 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
0; // number of bytes for selected digital data given by dtbDbitList
// store each selected bit from all samples consecutively
if (reorder) {
if (ctbDbitReorder) {
size_t numBitsPerDbit =
numDigitalSamples; // num bits per selected digital
// Bit for all samples
@ -699,7 +699,7 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
std::vector<uint8_t> result(totalNumBytes, 0);
uint8_t *dest = &result[0];
if (reorder) {
if (ctbDbitReorder) {
// loop through digital bit enable vector
int bitoffset = 0;
for (auto bi : ctbDbitList) {

6
slsReceiverSoftware/src/DataProcessor.h
View File

@ -46,8 +46,8 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
void SetStreamingStartFnum(uint32_t value);
void SetFramePadding(bool enable);
void SetCtbDbitList(std::vector<int> value);
void SetReorder(const bool reorder);
void SetCtbDbitOffset(int value);
void SetCtbDbitReorder(bool value);
void SetQuadEnable(bool value);
void SetFlipRows(bool fd);
void SetNumberofTotalFrames(uint64_t value);
@ -177,11 +177,11 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
uint32_t streamingTimerInMs;
uint32_t streamingStartFnum;
uint32_t currentFreqCount{0};
struct timespec timerbegin {};
struct timespec timerbegin{};
bool framePadding;
std::vector<int> ctbDbitList;
bool reorder{false}; // true if data should be reordered TODO: add as mode
int ctbDbitOffset{0};
bool ctbDbitReorder{true};
std::atomic<bool> startedFlag{false};
std::atomic<uint64_t> firstIndex{0};
bool quadEnable{false};

10
slsReceiverSoftware/src/Implementation.cpp
View File

@ -202,6 +202,7 @@ void Implementation::SetupDataProcessor(int i) {
dataProcessor[i]->SetFramePadding(framePadding);
dataProcessor[i]->SetCtbDbitList(ctbDbitList);
dataProcessor[i]->SetCtbDbitOffset(ctbDbitOffset);
dataProcessor[i]->SetCtbDbitReorder(ctbDbitReorder);
dataProcessor[i]->SetQuadEnable(quadEnable);
dataProcessor[i]->SetFlipRows(flipRows);
dataProcessor[i]->SetNumberofTotalFrames(numberOfTotalFrames);
@ -1766,6 +1767,15 @@ void Implementation::setDbitOffset(const int s) {
LOG(logINFO) << "Dbit offset: " << ctbDbitOffset;
}
bool Implementation::getDbitReorder() const { return ctbDbitReorder; }
void Implementation::setDbitReorder(const bool reorder) {
ctbDbitReorder = reorder;
for (const auto &it : dataProcessor)
it->SetCtbDbitReorder(ctbDbitReorder);
LOG(logINFO) << "Dbit reorder: " << ctbDbitReorder;
}
uint32_t Implementation::getTransceiverEnableMask() const {
return generalData->transceiverMask;
}

5
slsReceiverSoftware/src/Implementation.h
View File

@ -252,6 +252,10 @@ class Implementation : private virtual slsDetectorDefs {
int getDbitOffset() const;
/* [Ctb] */
void setDbitOffset(const int s);
bool getDbitReorder() const;
/* [Ctb] */
void setDbitReorder(const bool reorder);
uint32_t getTransceiverEnableMask() const;
/* [Ctb] */
void setTransceiverEnableMask(const uint32_t mask);
@ -368,6 +372,7 @@ class Implementation : private virtual slsDetectorDefs {
std::vector<int64_t> rateCorrections;
std::vector<int> ctbDbitList;
int ctbDbitOffset{0};
bool ctbDbitReorder{true};
// callbacks
void (*startAcquisitionCallBack)(const startCallbackHeader,

10
slsReceiverSoftware/tests/test-ArrangeDataBasedOnBitList.cpp
View File

@ -179,7 +179,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Reorder all",
set_num_samples(num_samples);
set_data();
dataprocessor->SetReorder(true); // set reorder to true
dataprocessor->SetCtbDbitReorder(true); // set reorder to true
const size_t expected_size =
num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
@ -216,7 +216,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
set_data();
dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);
dataprocessor->SetReorder(true); // set reorder to true
dataprocessor->SetCtbDbitReorder(true); // set reorder to true
const size_t expected_num_digital_bytes = 64;
std::vector<uint8_t> expected_digital_part{0b00011111};
@ -266,7 +266,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder false",
dataprocessor->SetCtbDbitList(bitlist);
dataprocessor->SetReorder(false);
dataprocessor->SetCtbDbitReorder(false);
set_num_samples(num_samples);
set_data();
@ -318,7 +318,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder true",
dataprocessor->SetCtbDbitList(bitlist);
dataprocessor->SetReorder(true);
dataprocessor->SetCtbDbitReorder(true);
set_num_samples(num_samples);
set_data();
@ -362,7 +362,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
dataprocessor->SetCtbDbitList(bitlist);
dataprocessor->SetReorder(false);
dataprocessor->SetCtbDbitReorder(false);
dataprocessor->SetCtbDbitOffset(num_random_offset_bytes);