mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-24 15:20:02 +02:00
242 lines
8.0 KiB
C++
242 lines
8.0 KiB
C++
/**
|
|
\file mainReceiver.cpp
|
|
|
|
This file is an example of how to implement the slsReceiverUsers class
|
|
You can compile it linking it to the slsReceiver library
|
|
|
|
g++ mainReceiver.cpp -L lib -lSlsReceiver -L/usr/lib64/ -L lib2 -lzmq -pthread -lrt -lm -lstdc++
|
|
|
|
where,
|
|
|
|
lib is the location of lSlsReceiver.so
|
|
|
|
lib2 is the location of the libzmq.a.
|
|
[ libzmq.a is required only when using data call backs and enabling data streaming from receiver to client.
|
|
It is linked in manual/manual-api from slsReceiverSoftware/include ]
|
|
|
|
*/
|
|
|
|
#include "sls_receiver_defs.h"
|
|
#include "slsReceiverUsers.h"
|
|
|
|
#include <iostream>
|
|
#include <string.h>
|
|
#include <signal.h> //SIGINT
|
|
#include <cstdlib> //system
|
|
//#include "utilities.h"
|
|
//#include "logger.h"
|
|
#include <sys/types.h> //wait
|
|
#include <sys/wait.h> //wait
|
|
#include <string>
|
|
using namespace std;
|
|
|
|
/* Define Number of receivers */
|
|
#define NUM_RECEIVERS 1
|
|
/** Define TCP Port of First Receiver, others are incremented by 1 */
|
|
#define START_TCP_PORT 1954
|
|
/** Define Colors to print data call back in different colors for different recievers */
|
|
#define PRINT_IN_COLOR(c,f, ...) printf ("\033[%dm" f RESET, 30 + c+1, ##__VA_ARGS__)
|
|
|
|
/* List of process IDs of all child receiver processes */
|
|
pid_t childPid[NUM_RECEIVERS];
|
|
/** Variable is true to continue running, set to false upon interrupt */
|
|
bool keeprunning;
|
|
/** Variable indicating number of child processes running */
|
|
int numrunning;
|
|
|
|
|
|
/**
|
|
* Child Exit Signal Interrupt Handler
|
|
* When a child process exits, this function is called,
|
|
* blocks until all child processes exit &
|
|
* decreases the variable indicating number of running processes
|
|
* @param sig signal enum
|
|
*/
|
|
void sigChildExitedHandler(int sig) {
|
|
pid_t pid = wait(NULL);
|
|
bprintf(GRAY, "\nChild Process Pid %d exited.\n", pid);
|
|
numrunning--;
|
|
}
|
|
|
|
/**
|
|
* Control+C Interrupt Handler
|
|
* Sets the variable keeprunning to false, to let all the processes know to exit properly
|
|
*/
|
|
void sigInterruptHandler(int p){
|
|
keeprunning = false;
|
|
}
|
|
|
|
/**
|
|
* Start Acquisition Call back
|
|
* slsReceiver writes data if file write enabled.
|
|
* Users get data to write using call back if registerCallBackRawDataReady is registered.
|
|
* @param filepath file path
|
|
* @param filename file name
|
|
* @param fileindex file index
|
|
* @param datasize data size in bytes
|
|
* @param p pointer to object
|
|
* \returns ignored
|
|
*/
|
|
int StartAcq(char* filepath, char* filename, uint64_t fileindex, uint32_t datasize, void*p){
|
|
bprintf(BLUE, "#### StartAcq: filepath:%s filename:%s fileindex:%llu datasize:%u ####\n",
|
|
filepath, filename, fileindex, datasize);
|
|
|
|
bprintf(BLUE, "--StartAcq: returning 0\n");
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Acquisition Finished Call back
|
|
* @param frames Number of frames caught
|
|
* @param p pointer to object
|
|
*/
|
|
void AcquisitionFinished(uint64_t frames, void*p){
|
|
bprintf(BLUE, "#### AcquisitionFinished: frames:%llu ####\n",frames);
|
|
}
|
|
|
|
/**
|
|
* Get Receiver Data Call back
|
|
* Prints in different colors(for each receiver process) the different headers for each image call back.
|
|
* @param frameNumber frame number
|
|
* @param expLength real time exposure length (in 100ns) or sub frame number (Eiger 32 bit mode only)
|
|
* @param packetNumber number of packets caught for this frame
|
|
* @param bunchId bunch id from beamline
|
|
* @param timestamp time stamp in 10MHz clock (not implemented for most)
|
|
* @param modId module id (not implemented for most)
|
|
* @param xCoord x coordinates (detector id in 1D)
|
|
* @param yCoord y coordinates (not implemented)
|
|
* @param zCoord z coordinates (not implemented)
|
|
* @param debug debug values if any
|
|
* @param roundRNumber (not implemented)
|
|
* @param detType detector type see :: detectorType
|
|
* @param version version of standard header (structure format)
|
|
* @param datapointer pointer to data
|
|
* @param datasize data size in bytes
|
|
* @param p pointer to object
|
|
*/
|
|
void GetData(uint64_t frameNumber, uint32_t expLength, uint32_t packetNumber, uint64_t bunchId, uint64_t timestamp,
|
|
uint16_t modId, uint16_t xCoord, uint16_t yCoord, uint16_t zCoord, uint32_t debug, uint16_t roundRNumber, uint8_t detType, uint8_t version,
|
|
char* datapointer, uint32_t datasize, void* p){
|
|
|
|
PRINT_IN_COLOR (xCoord,
|
|
"#### %d GetData: ####\n"
|
|
"frameNumber: %llu\t\texpLength: %u\t\tpacketNumber: %u\t\tbunchId: %llu\t\ttimestamp: %llu\t\tmodId: %u\t\t"
|
|
"xCoord: %u\t\tyCoord: %u\t\tzCoord: %u\t\tdebug: %u\t\troundRNumber: %u\t\tdetType: %u\t\t"
|
|
"version: %u\t\tfirstbytedata: 0x%x\t\tdatsize: %u\n\n",
|
|
xCoord, frameNumber, expLength, packetNumber, bunchId, timestamp, modId,
|
|
xCoord, yCoord, zCoord, debug, roundRNumber, detType, version,
|
|
((uint8_t)(*((uint8_t*)(datapointer)))), datasize);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Example of main program using the slsReceiverUsers class
|
|
*
|
|
* - Defines in file for:
|
|
* - Default Number of receivers is 1
|
|
* - Default Start TCP port is 1954
|
|
*/
|
|
int main(int argc, char *argv[]) {
|
|
|
|
/** - set default values: child process pid values to -1, keeprunning to true, numrunning to 0 */
|
|
for (int i = 0; i < NUM_RECEIVERS; ++i)
|
|
childPid[i] = -1;
|
|
keeprunning = true;
|
|
numrunning = 0;
|
|
|
|
/** - Catch signal SIGINT to close files and call destructors properly */
|
|
struct sigaction sa;
|
|
sa.sa_flags=0; // no flags
|
|
sa.sa_handler=sigInterruptHandler; // handler function
|
|
sigemptyset(&sa.sa_mask); // dont block additional signals during invocation of handler
|
|
if (sigaction(SIGINT, &sa, NULL) == -1) {
|
|
bprintf(RED, "Could not set handler function for SIGINT\n");
|
|
}
|
|
|
|
/** - wait for all the SIGCHILD signals and decrease numrunningeach time a child process exits*/
|
|
struct sigaction asa;
|
|
asa.sa_flags=0; // no flags
|
|
asa.sa_handler=sigChildExitedHandler; // handler function
|
|
sigemptyset(&asa.sa_mask); // dont block additional signals during invocation of handler
|
|
if (sigaction(SIGCHLD, &asa, NULL) == -1) {
|
|
bprintf(RED, "Could not set handler function for SICHILD\n");
|
|
}
|
|
|
|
|
|
/** - loop over number of receivers */
|
|
for (int i = 0; i < NUM_RECEIVERS; ++i) {
|
|
|
|
/** - fork process to create child process */
|
|
childPid[i] = fork();
|
|
|
|
/** - if fork failed, raise SIGINT and kill all receiver objects */
|
|
if (childPid[i] < 0) {
|
|
bprintf(RED,"fork() failed. Killing all the receiver objects\n");
|
|
raise(SIGINT);
|
|
}
|
|
|
|
/** - if child process */
|
|
else if (childPid[i] == 0) {
|
|
bprintf(BLUE,"Starting Receiver %d with pid %ld\n", i, (long)getpid());
|
|
|
|
char temp[10];
|
|
sprintf(temp,"%d",START_TCP_PORT + i);
|
|
char* args[] = {(char*)"ignored", (char*)"--rx_tcpport", temp};
|
|
int ret = slsReceiverDefs::OK;
|
|
/** - create slsReceiverUsers object with appropriate arguments
|
|
(START_TCP_PORT incrementing by 1 */
|
|
slsReceiverUsers *receiver = new slsReceiverUsers(3, args, ret);
|
|
if(ret==slsReceiverDefs::FAIL){
|
|
delete receiver;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/** - register callbacks. remember to set file write enable to 0 (using the client)
|
|
if we should not write files and you will write data using the callbacks */
|
|
|
|
/** - Call back for start acquisition */
|
|
bprintf(BLUE, "Registering StartAcq()\n");
|
|
receiver->registerCallBackStartAcquisition(StartAcq, NULL);
|
|
|
|
/** - Call back for acquisition finished */
|
|
bprintf(BLUE, "Registering AcquisitionFinished()\n");
|
|
receiver->registerCallBackAcquisitionFinished(AcquisitionFinished, NULL);
|
|
|
|
/* - Call back for raw data */
|
|
bprintf(BLUE, "Registering GetData() \n");
|
|
receiver->registerCallBackRawDataReady(GetData,NULL);
|
|
|
|
|
|
/** - start tcp server thread */
|
|
if (receiver->start() == slsReceiverDefs::FAIL){
|
|
delete receiver;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/** - as long as keeprunning is true, usleep for a second */
|
|
while(keeprunning)
|
|
usleep(1 * 1000 * 1000);
|
|
/** - interrupt caught, delete slsReceiverUsers object and exit */
|
|
delete receiver;
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/** - parent process, increment number of running processes */
|
|
else
|
|
numrunning++;
|
|
|
|
}
|
|
|
|
/** - Print Ready and Instructions how to exit */
|
|
cout << "Ready ... " << endl;
|
|
bprintf(GRAY, "\n[ Press \'Ctrl+c\' to exit ]\n");
|
|
|
|
/** - Parent process waits for all child processes to exit by sleeping till numrunning is 0 */
|
|
while(numrunning)
|
|
usleep(1 * 1000 * 1000);
|
|
cout << "Goodbye!" << endl;
|
|
return 0;
|
|
}
|
|
|