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

slsReceiver: removed special receiver config, added rx_dbitlist, rx_dbitoffset to put bits together in file, connected adcinvert, extsamplingsrc and extsampling properly to the detector, added tests

Browse Source
This commit is contained in:
maliakal_d
2019-05-03 20:37:40 +02:00
parent 7683b18fa3
commit e14519c236
27 changed files with 1088 additions and 485 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
slsReceiverSoftware/include/DataProcessor.h
View File

@ -39,15 +39,15 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
* @param act pointer to activated
* @param depaden pointer to deactivated padding enable
* @param sm pointer to silent mode
* @param ct pointer to ctb type
* @param cdo pointer to ctb digital offset
* @param cdl pointer to vector or ctb digital bits enable
* @param cdo pointer to digital bits offset
* @param cad pointer to ctb analog databytes
*/
DataProcessor(int ind, detectorType dtype, Fifo* f, fileFormat* ftype,
bool fwenable, bool* mfwenable, bool* dsEnable, bool* gpEnable, uint32_t* dr,
uint32_t* freq, uint32_t* timer,
bool* fp, bool* act, bool* depaden, bool* sm,
int* ct, int* cdo, int* cad);
std::vector <int> * cdl, int* cdo, int* cad);
/**
* Destructor
@ -223,20 +223,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
void registerCallBackRawDataModifyReady(void (*func)(char* ,
char*, uint32_t &, void*),void *arg);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void registerCallBackCTBReceiverReady(void (*func)(char*,
char*, uint32_t &, int, int, int, void*),void *arg);
private:
@ -307,6 +293,11 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
void PadMissingPackets(char* buf);
/**
* Align corresponding digital bits together (CTB only if ctbDbitlist is not empty)
*/
void RearrangeDbitData(char* buf);
/**
* Processing Function (inserting gap pixels) eiger specific
* @param buf pointer to image
@ -380,6 +371,15 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
/** frame padding */
bool* framePadding;
/** ctb digital bits enable list */
std::vector <int> *ctbDbitList;
/** ctb digital bits offset */
int* ctbDbitOffset;
/** ctb analog databytes */
int* ctbAnalogDataBytes;
//acquisition start
/** Aquisition Started flag */
bool acquisitionStartedFlag;
@ -404,14 +404,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
/** Frame Number of latest processed frame number of an entire Acquisition (including all scans) */
uint64_t currentFrameIndex;
// for ctb call back
/** ctb type*/
int* ctbType;
/** ctb digital offset */
int* ctbDigitalOffset;
/** ctb analog databytes */
int* ctbAnalogDataBytes;
@ -435,20 +427,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
void (*rawDataModifyReadyCallBack)(char*,
char*, uint32_t &, void*);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void (*ctbRawDataReadyCallBack)(char*,
char*, uint32_t &, int, int, int, void*);
void *pRawDataReady;

15
slsReceiverSoftware/include/slsReceiver.h
View File

@ -95,21 +95,6 @@ class slsReceiver : private virtual slsDetectorDefs {
void registerCallBackRawDataModifyReady(void (*func)(char* ,
char*, uint32_t &,void*),void *arg);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void registerCallBackCTBReceiverReady(void (*func)(char*,
char*, uint32_t &, int, int, int, void*),void *arg);
private:
std::unique_ptr<slsReceiverTCPIPInterface> tcpipInterface;

65
slsReceiverSoftware/include/slsReceiverImplementation.h
View File

@ -300,6 +300,18 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/
bool getSilentMode() const;
/**
* Get CTB digital bits enable list
* @returns digital bits enable list
*/
std::vector <int> getDbitList() const;
/**
* Get CTB digital bits offset
* @returns digital bits offset
*/
int getDbitOffset() const;
/**
* Get activate
* If deactivated, receiver will create dummy data if deactivated padding is enabled
@ -637,6 +649,18 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
*/
void setSilentMode(const bool i);
/**
* Set CTB digital bits enable list
* @param v digital bits enable list
*/
void setDbitList(const std::vector <int> v);
/**
* Set CTB digital bits offset
* @param s digital bits offset
*/
void setDbitOffset(const int s);
/*************************************************************************
* Behavioral functions***************************************************
@ -751,20 +775,6 @@ class slsReceiverImplementation: private virtual slsDetectorDefs {
void registerCallBackRawDataModifyReady(void (*func)(char* ,
char*, uint32_t &,void*),void *arg);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void registerCallBackCTBReceiverReady(void (*func)(char*,
char*, uint32_t &, int, int, int, void*),void *arg);
private:
/**
@ -877,6 +887,12 @@ private:
bool framePadding;
/** silent mode */
bool silentMode;
/** ctb digital bits enabled list (empty: all enabled) */
std::vector <int> ctbDbitList;
/** ctb digital bit offset in bytes */
int ctbDbitOffset;
/* analog data bytes */
int ctbAnalogDataBytes;
//***connection parameters***
/** Number of UDP Interfaces */
@ -938,13 +954,6 @@ private:
/** Fifo Structure to store addresses of memory writes */
std::vector<std::unique_ptr<Fifo>> fifo;
/** ctb type for callback*/
int ctbType;
/* ctb digital offset for callback */
int ctbDigitalOffset;
/* analog data bytes */
int ctbAnalogDataBytes;
//***callback parameters***
/**
* Call back for start acquisition
@ -986,20 +995,6 @@ private:
void (*rawDataModifyReadyCallBack)(char* ,
char*, uint32_t &, void*);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void (*ctbRawDataReadyCallBack)(char*,
char*, uint32_t &, int, int, int, void*);
void *pRawDataReady;

40
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -92,20 +92,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
void registerCallBackRawDataModifyReady(void (*func)(char* ,
char*, uint32_t &,void*),void *arg);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void registerCallBackCTBReceiverReady(void (*func)(char*,
char*, uint32_t &, int, int, int, void*),void *arg);
private:
@ -295,7 +281,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
int set_padding_enable();
/** set deactivated receiver padding enable */
int set_deactivated_receiver_padding_enable();
int set_deactivated_padding_enable();
/** set readout flags */
int set_readout_flags();
@ -303,6 +289,15 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
/** set adc mask */
int set_adc_mask();
/** set receiver dbit list */
int set_dbit_list();
/** get receiver dbit list */
int get_dbit_list();
/** set dbit offset */
int set_dbit_offset();
/** detector type */
detectorType myDetectorType;
@ -382,21 +377,6 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
void (*rawDataModifyReadyCallBack)(char* ,
char*, uint32_t &, void*);
/**
* Call back for raw CTB data that will be modified
* args to raw data call back are
* args to raw data ready callback are
* sls_receiver_header frame metadata
* dataPointer is the pointer to the data
* revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value).
* type CTB chip type
* digitalOffset digital offset
* analogdataBytes analog databytes
*/
void (*ctbRawDataReadyCallBack)(char*,
char*, uint32_t &, int, int, int, void*);
void *pRawDataReady;

10
slsReceiverSoftware/include/slsReceiverUsers.h
View File

@ -87,16 +87,6 @@ public:
void registerCallBackRawDataModifyReady(void (*func)(char* header,
char* datapointer, uint32_t &revDatasize, void*),void *arg);
/**
@short register callback to be called when CTB data are available in receiver (to process and/or save the data).
\param func raw data ready callback. arguments are sls_receiver_header, dataPointer, revDatasize is the reference of data size in bytes, chip type, digital offset, analog databytes. revDatasize be modified to the new size to be written/streamed. (only smaller value).
\param arg argument
\returns nothing
*/
void registerCallBackCTBReceiverReady(void (*func)(char* header,
char* datapointer, uint32_t &revDatasize, int type, int digitalOffset, int analogDataBytes, void*),void *arg);
//receiver object
std::unique_ptr<slsReceiver> receiver;
};