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

works for deactivated server and receiver

Browse Source
This commit is contained in:
Dhanya Maliakal 2016-10-04 07:36:00 +02:00
parent 572047b72d
commit 2a4bd8022e
8 changed files with 195 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
slsReceiverSoftware/include/UDPBaseImplementation.h
View File

@ -193,6 +193,14 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
*/
runStatus getStatus() const;
/**
* Get activate
* If deactivated, receiver will write dummy packets 0xFF
* (as it will receive nothing from detector)
* @return 0 for deactivated, 1 for activated
*/
int getActivate() const;
@ -417,6 +425,13 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
*/
void closeFile(int i = -1);
/**
* Activate / Deactivate Receiver
* If deactivated, receiver will write dummy packets 0xFF
* (as it will receive nothing from detector)
*/
int setActivate(int enable = -1);
//***callback functions***
/**
@ -485,6 +500,8 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
const static int MAX_NUMBER_OF_LISTENING_THREADS = 2;
/** Receiver Status */
runStatus status;
/** Activated/Deactivated */
int activated;
//***connection parameters***
/** Ethernet Interface */
@ -528,6 +545,7 @@ class UDPBaseImplementation : protected virtual slsReceiverDefs, public UDPInter
//***callback parameters***
/**
* function being called back for start acquisition

15
slsReceiverSoftware/include/UDPInterface.h
View File

@ -252,6 +252,14 @@ class UDPInterface {
*/
virtual slsReceiverDefs::runStatus getStatus() const = 0;
/**
* Get activate
* If deactivated, receiver will write dummy packets 0xFF
* (as it will receive nothing from detector)
* @return 0 for deactivated, 1 for activated
*/
virtual int getActivate() const = 0;
@ -474,6 +482,13 @@ class UDPInterface {
*/
virtual void closeFile(int i = -1) = 0;
/**
* Activate / Deactivate Receiver
* If deactivated, receiver will write dummy packets 0xFF
* (as it will receive nothing from detector)
*/
virtual int setActivate(int enable = -1) = 0;
//***callback functions***
/**

4
slsReceiverSoftware/include/UDPStandardImplementation.h
View File

@ -597,6 +597,7 @@ private:
/** Missing Packet identifier value */
const static uint16_t missingPacketValue = 0xFFFF;
const static uint16_t deactivatedPacketValue = 0xFEFE;
/** Dummy Packet identifier value */
const static uint32_t dummyPacketValue = 0xFFFFFFFF;
@ -675,6 +676,9 @@ private:
bool killAllWritingThreads;
//***deactivated parameters***
uint64_t deactivated_framenumber[MAX_NUMBER_OF_LISTENING_THREADS];
uint32_t deactivated_packetnumber[MAX_NUMBER_OF_LISTENING_THREADS];

4
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -207,6 +207,10 @@ private:
/** set fifo depth */
int set_fifo_depth();
/** activate/ deactivate */
int set_activate();
//General Functions
/** Locks Receiver */
int lock_receiver();

4
slsReceiverSoftware/include/sls_receiver_funcs.h
View File

@ -49,7 +49,9 @@ enum {
F_ENABLE_RECEIVER_OVERWRITE, /**< set overwrite flag in receiver */
F_ENABLE_RECEIVER_TEN_GIGA, /**< enable 10Gbe in receiver */
F_SET_RECEIVER_FIFO_DEPTH /**< set receiver fifo depth */
F_SET_RECEIVER_FIFO_DEPTH, /**< set receiver fifo depth */
F_ACTIVATE /** < activate/deactivate readout */
/* Always append functions hereafter!!! */
};

14
slsReceiverSoftware/src/UDPBaseImplementation.cpp
View File

@ -49,6 +49,7 @@ void UDPBaseImplementation::initializeMembers(){
//***receiver parameters***
status = IDLE;
activated = true;
//***connection parameters***
strcpy(eth,"");
@ -187,7 +188,7 @@ uint32_t UDPBaseImplementation::getFifoDepth() const{ FILE_LOG(logDEBUG) << __AT
/***receiver status***/
slsReceiverDefs::runStatus UDPBaseImplementation::getStatus() const{ FILE_LOG(logDEBUG) << __AT__ << " starting"; return status;}
int UDPBaseImplementation::getActivate() const{FILE_LOG(logDEBUG) << __AT__ << " starting"; return activated;}
/*************************************************************************
@ -448,6 +449,17 @@ void UDPBaseImplementation::closeFile(int i){
}
int UDPBaseImplementation::setActivate(int enable){
FILE_LOG(logDEBUG) << __AT__ << " starting";
if(enable != -1){
activated = enable;
FILE_LOG(logINFO) << "Activation: " << stringEnable(activated);
}
return activated;
}
/***callback functions***/
void UDPBaseImplementation::registerCallBackStartAcquisition(int (*func)(char*, char*,int, int, void*),void *arg){
startAcquisitionCallBack=func;

58
slsReceiverSoftware/src/UDPStandardImplementation.cpp
View File

@ -191,6 +191,12 @@ void UDPStandardImplementation::initializeMembers(){
createFileMask = 0x0;
killAllWritingThreads = false;
//***deactivated parameters***
for(int i=0; i < MAX_NUMBER_OF_LISTENING_THREADS; i++){
deactivated_framenumber[i] = 0;
deactivated_packetnumber[i] = 0;
}
//***filter parameters***
commonModeSubtractionEnable = false;
moenchCommonModeSubtraction = NULL;
@ -837,6 +843,11 @@ int UDPStandardImplementation::startReceiver(char *c){
fileCreateSuccess = false;
pthread_mutex_unlock(&statusMutex);
//deactivated parameters
for(int i = 0; i < numberofListeningThreads; ++i){
deactivated_framenumber[i] = 0;
deactivated_packetnumber[i] = 0;
}
//Print Receiver Configuration
if(myDetectorType != EIGER){
@ -959,6 +970,8 @@ void UDPStandardImplementation::startReadout(){
if(status == RUNNING){
//needs to wait for packets only if activated
if(activated){
//check if all packets got
int totalP = 0,prev,i;
for(i=0; i<numberofListeningThreads; ++i){
@ -974,7 +987,7 @@ void UDPStandardImplementation::startReadout(){
cprintf(MAGENTA,"waiting for all packets totalP:%d\n",totalP);
#endif
usleep(5000);/* Need to find optimal time (exposure time and acquisition period) **/
usleep(50000);/* Need to find optimal time (exposure time and acquisition period) **/
prev = totalP;
totalP=0;
for(i=0; i<numberofListeningThreads; ++i){
@ -982,7 +995,7 @@ void UDPStandardImplementation::startReadout(){
}
}
}
}
//set status
@ -1514,6 +1527,9 @@ void UDPStandardImplementation::startListening(){
tempBuffer = new char[onePacketSize * (packetsPerFrame - 1)]; //store maximum of 1 packets less in a frame
}
if(!activated)
usleep(1* 1000 * 1000);
/* inner loop - loop for each buffer */
//until mask unset (udp sockets shut down by client)
while((1 << ithread) & listeningThreadsMask){
@ -1552,7 +1568,7 @@ void UDPStandardImplementation::startListening(){
//problem in receiving or end of acquisition
if (status == TRANSMITTING){
if ((status == TRANSMITTING)||(rc == 0 && activated == 0)){
stopListening(ithread,rc);
continue;
}
@ -1607,6 +1623,39 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int lSize, in
if(cSize)
memcpy(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS, temp, cSize);
if(!activated){
//first time
if(!deactivated_framenumber[ithread])
deactivated_framenumber[ithread]++;
//new frame
if(deactivated_packetnumber[ithread] == (packetsPerFrame/numberofListeningThreads)){
deactivated_packetnumber[ithread] = 0;
deactivated_framenumber[ithread]++;
//last time
if(deactivated_framenumber[ithread] == (numberOfFrames+1))
return 0;
}
deactivated_packetnumber[ithread]++;
//copy dummy packet
memset(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize, 0xFF,onePacketSize);
eiger_packet_header_t* header = (eiger_packet_header_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize);
eiger_packet_footer_t* footer = (eiger_packet_footer_t*)(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize + footerOffset);
*( (uint16_t*) header->missingPacket) = deactivatedPacketValue;
*( (uint64_t*) footer) = deactivated_framenumber[ithread];
*( (uint16_t*) footer->packetNumber) = deactivated_packetnumber[ithread];
//*( (uint16_t*) footer->packetNumber) = ithread*(packetsPerFrame/numberofListeningThreads)+deactivated_packetnumber[ithread];
#ifdef MANUALDEBUG
eiger_packet_footer_t* efooter = (eiger_packet_footer_t*)(buffer[ithread] + footerOffset + HEADER_SIZE_NUM_TOT_PACKETS);
cprintf(GREEN,"thread:%d pnum:%d fnum:%d\n",
ithread,
(*( (uint16_t*) efooter->packetNumber)),
(uint32_t)(*( (uint64_t*) efooter)));
#endif
return onePacketSize;
}
int receivedSize = udpSocket[ithread]->ReceiveDataOnly(buffer[ithread] + HEADER_SIZE_NUM_TOT_PACKETS + cSize, lSize + cSize);
//throw away packets that is not one packet size, need to check status if socket is shut down
@ -1622,6 +1671,7 @@ int UDPStandardImplementation::prepareAndListenBuffer(int ithread, int lSize, in
}
totalListeningFrameCount[ithread] += (receivedSize/onePacketSize);
#ifdef MANUALDEBUG
if(receivedSize>0){
if(myDetectorType == JUNGFRAU){
@ -2565,6 +2615,8 @@ void UDPStandardImplementation::stopWriting(int ithread, char* wbuffer[]){
cprintf(GREEN, "Total Packets Caught:%lld\n", (long long int)totalPacketsCaught);
cprintf(GREEN, "Total Frames Caught:%lld\n",(long long int)(totalPacketsCaught/packetsPerFrame));
}
if(!activated)
cprintf(RED,"Note: Deactivated Receiver\n");
//acquisition end
if (acquisitionFinishedCallBack)
acquisitionFinishedCallBack((int)(totalPacketsCaught/packetsPerFrame), pAcquisitionFinished);

68
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -262,6 +262,7 @@ int slsReceiverTCPIPInterface::function_table(){
flist[F_ENABLE_RECEIVER_TEN_GIGA] = &slsReceiverTCPIPInterface::enable_tengiga;
flist[F_SET_RECEIVER_FIFO_DEPTH] = &slsReceiverTCPIPInterface::set_fifo_depth;
flist[F_ACTIVATE] = &slsReceiverTCPIPInterface::set_activate;
#ifdef VERYVERBOSE
@ -2720,8 +2721,75 @@ int slsReceiverTCPIPInterface::set_fifo_depth() {
int slsReceiverTCPIPInterface::set_activate() {
ret=OK;
int retval=-1;
int enable;
strcpy(mess,"Could not activate/deactivate\n");
// receive arguments
if(socket->ReceiveDataOnly(&enable,sizeof(enable)) < 0 ){
strcpy(mess,"Error reading from socket\n");
cprintf(RED,"%s",mess);
ret = FAIL;
}
// execute action if the arguments correctly arrived
#ifdef SLS_RECEIVER_UDP_FUNCTIONS
if (ret==OK) {
if (lockStatus==1 && socket->differentClients==1){
sprintf(mess,"Receiver locked by %s\n", socket->lastClientIP);
ret=FAIL;
}
if(ret!=FAIL){
if (receiverBase == NULL){
strcpy(mess,SET_RECEIVER_ERR_MESSAGE);
cprintf(RED,"%s",mess);
ret=FAIL;
}else if(receiverBase->getStatus()==RUNNING){
strcpy(mess,"Cannot activate/deactivate while status is running\n");
cprintf(RED,"%s",mess);
ret=FAIL;
}else{
if(enable != -1)
receiverBase->setActivate(enable);
retval = receiverBase->getActivate();
if(enable >= 0 && retval != enable){
sprintf(mess,"Tried to set activate to %d, but returned %d\n",enable,retval);
ret = FAIL;
cprintf(RED,"%s",mess);
}
}
}
}
#endif
#ifdef VERYVERBOSE
if(ret!=FAIL)
cout << "Activate: " << retval << endl;
else
cout << mess << endl;
#endif
if(ret==OK && socket->differentClients){
FILE_LOG(logDEBUG) << "Force update";
ret=FORCE_UPDATE;
}
// send answer
socket->SendDataOnly(&ret,sizeof(ret));
if(ret==FAIL){
cprintf(RED,"%s\n",mess);
socket->SendDataOnly(mess,sizeof(mess));
}
socket->SendDataOnly(&retval,sizeof(retval));
//return ok/fail
return ret;
}