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

in the process of rewriting detector client interface

Browse Source
This commit is contained in:
maliakal_d 2018-10-18 10:58:48 +02:00
parent 178b832223
commit 86fb843021
24 changed files with 1012 additions and 1873 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

335
slsDetectorServers/eigerDetectorServer/Feb.c
View File

@ -1,335 +0,0 @@
/**
* @author Ian Johnson
* @version 1.0
*/
/*#include <iostream>
#include <iomanip>*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "xparameters.h"
#include "Feb.h"
void Feb_Feb(){
Feb_nfebs = 0;
Feb_feb_numb = 0;
Feb_send_ndata = 0;
Feb_send_buffer_size = 1026;
Feb_send_data_raw = malloc((Feb_send_buffer_size+1)*sizeof(int));
Feb_send_data = &Feb_send_data_raw[1];
Feb_recv_ndata = 0;
Feb_recv_buffer_size = 1026;
Feb_recv_data_raw = malloc((Feb_recv_buffer_size+1)*sizeof(int));
Feb_recv_data = &Feb_recv_data_raw[1];
Local_LocalLinkInterface1(ll,XPAR_PLB_LL_FIFO_AURORA_DUAL_CTRL_FEB_RIGHT_BASEADDR);
}
/*
~Feb(){
delete ll;
if(feb_numb) delete [] feb_numb;
delete [] send_data_raw;
delete [] recv_data_raw;
}
*/
void Feb_SendCompleteFebList(unsigned int n,unsigned int* list){
unsigned int i;
if(Feb_feb_numb) free(Feb_feb_numb);
Feb_nfebs = n;
Feb_feb_numb = malloc(n*sizeof(unsigned int));
for(i=0;i<n;i++) Feb_feb_numb[i] = list[i];
}
int Feb_WriteTo(unsigned int ch){
if(ch>0xfff) return 0;
Feb_send_data_raw[0] = 0x90000000 | (ch<<16); //we
if(Local_Write(ll,4,Feb_send_data_raw)!=4) return 0;
Feb_send_data_raw[0] = 0xc0000000; //data
return 1;//((Feb_send_ndata+1)*4==Local_Write(ll,(Feb_send_ndata+1)*4,Feb_send_data_raw));
}
int Feb_ReadFrom(unsigned int ch, unsigned int ntrys){
unsigned int t;
if(ch>=0xfff) return 0;
Feb_recv_data_raw[0] = 0xa0000000 | (ch<<16); //read data
Local_Write(ll,4,Feb_recv_data_raw);
usleep(20);
Feb_recv_ndata=-1;
for(t=0;t<ntrys;t++){
if((Feb_recv_ndata=Local_Read(ll,Feb_recv_buffer_size*4,Feb_recv_data_raw)/4)>0){
Feb_recv_ndata--;
break;
}
printf("\t Read try number: %d\n",t);
usleep(1000);
}
return (Feb_recv_ndata>=0);
}
void Feb_PrintData(){
int i;
printf("Sent data: %d\n",Feb_send_ndata);
for(i=0;i<Feb_send_ndata;i++) printf("\t%d)%d (0x%x)\n",i,Feb_send_data[i],Feb_send_data[i]);
printf("Receive data: %d\n",Feb_recv_ndata);
for(i=0;i<Feb_recv_ndata;i++) printf("\t%d)%d (0x%x)\n",i,Feb_recv_data[i],Feb_recv_data[i]);
printf("\n\n");
}
int Feb_CheckHeader(unsigned int valid_bit_mask, int print_error_info){
int header_returned_is_ok = (Feb_send_data[0] & valid_bit_mask)==(Feb_recv_data[0] & valid_bit_mask);
if(print_error_info && !header_returned_is_ok){
printf("Error: Command received not the same as command recieved.\n");
printf("\t\t Header sent: %d (0x%x) received: %d (0x%x)\n",Feb_send_data[0], Feb_send_data[0], Feb_recv_data[0], Feb_recv_data[0]);
if(Feb_send_ndata>1&&Feb_recv_ndata>1){
printf("\t\t Tail sent: %d (0x%x) receiver: %d (0x%x)\n",Feb_send_data[Feb_send_ndata-1],Feb_send_data[Feb_send_ndata-1],Feb_recv_data[Feb_recv_ndata-1],Feb_recv_data[Feb_recv_ndata-1]);
}else{
printf("Error printing tail, too little data nsent = 0x%x, nrecv = 0x%x.\n",Feb_send_ndata, Feb_recv_ndata);
}
Feb_PrintData();
}
return header_returned_is_ok;
}
int Feb_CheckTail(unsigned int valid_bit_mask){
if(Feb_send_ndata<=1&&Feb_recv_ndata<=1){
printf("Error checking tail, too little data nsent = %d, nrecv = %d.\n",Feb_send_ndata, Feb_recv_ndata);
return 0;
}
unsigned int the_tail = Feb_recv_data[Feb_recv_ndata-1]&valid_bit_mask;
if(the_tail!=0){
printf("Error returned in tail: 0x%x (%d)\n",the_tail,the_tail);
if(the_tail&0x10000000) printf("\t\tBusy flag address error.\n");
if(the_tail&0x20000000) printf("\t\tRead register address error.\n");
if(the_tail&0x40000000) printf("\t\tWrite register address error.\n");
if(the_tail&0x80000000) printf("\t\tBram number error.\n");
if(the_tail&0x08000000) printf("\t\tFifo to read from error.\n");
if(the_tail&0x3ff) printf("\t\tNumber of data send error.\n");
return 0; //error
}
return 1;
}
int Feb_CheckCommunication(){
Feb_send_data_raw[0] = 0x8fff0000; //rst-all serial coms and lls
if(Local_Write(ll,4,Feb_send_data_raw)!=4) return 0;
printf("CheckingCommunication ....\n");
while((Local_Read(ll,Feb_recv_buffer_size*4,Feb_recv_data_raw)/4)>0) printf("\t) Cleanning buffer ...\n");
return Feb_SetByteOrder();
}
int Feb_SetByteOrder(){
unsigned int i;
Feb_send_ndata = 2;
Feb_send_data[0] = 0; //header
Feb_send_data[1] = 0; //tail
unsigned int dst = 0xff;
for( i=0;i<Feb_nfebs;i++) dst = (dst | Feb_feb_numb[i]); //get sub dst bits (left right in this case)
int passed = Feb_WriteTo(dst);
for(i=0;i<Feb_nfebs;i++){
printf("\t%d) Set Byte Order .............. ",i);
unsigned int current_passed = Feb_ReadFrom(Feb_feb_numb[i],20)&&(Feb_recv_ndata==2)&&Feb_CheckHeader(0xffffffff,1);
if(current_passed) printf("passed.\n");
else printf("failed.\n");
passed&=current_passed;
}
printf("\n");
return passed;
}
/* feb_ needed
int Feb_CheckSubNumber(unsigned int Feb_sub_num){
if(sub_num>=nfebs){
cout<<"Error invalid sub number "<<sub_num<<" must be less than "<<nfebs<<"."<<endl;
return 0;
}
return 1;
}
int Feb_SetStartOnEndOnFebs(int sub_num_s, unsigned int& start_on, unsigned int& end_on){
// -1 means write to all
if(sub_num_s<=-2){
cout<<"Error bad subnumber "<<sub_num_s<<"."<<endl;
return 0;
}
start_on = sub_num_s!=-1 ? sub_num_s : 0;
end_on = sub_num_s!=-1 ? sub_num_s : nfebs - 1;
return Feb_CheckSubNumber(start_on);
}
*/
/*
int Feb_ReadRegister(unsigned int Feb_sub_num, unsigned int Feb_reg_num,unsigned int& Feb_value_read){
return Feb_ReadRegisters(Feb_sub_num,1,&Feb_reg_num,&Feb_value_read);
}
*/
int Feb_ReadRegister(unsigned int sub_num, unsigned int reg_num,unsigned int* value_read){
return Feb_ReadRegisters(sub_num,1,&reg_num,value_read);
}
int Feb_ReadRegisters(unsigned int sub_num, unsigned int nreads, unsigned int* reg_nums,unsigned int* values_read){
//here cout<<"Reading Register ...."<<endl;
unsigned int i;
nreads &= 0x3ff; //10 bits
if(!nreads||nreads>Feb_send_buffer_size-2) return 0;
Feb_send_ndata = nreads+2;
Feb_send_data[0] = 0x20000000 | nreads << 14; //cmd -> read "00" , nreads
for(i=0;i<nreads;i++) Feb_send_data[i+1]=reg_nums[i];
Feb_send_data[nreads+1] = 0; //tail
if(!Feb_WriteTo(sub_num)||!Feb_ReadFrom(sub_num,20)||Feb_recv_ndata!=(int)(nreads+2)||!Feb_CheckHeader(0xffffffff,1)||!Feb_CheckTail(0xffffffff)){
Feb_PrintData();
printf("Error reading register.\n");
return 0;
}
for(i=0;i<nreads;i++) values_read[i] = Feb_recv_data[i+1];
return 1;
}
int Feb_WriteRegister(unsigned int sub_num, unsigned int reg_num,unsigned int value, int wait_on, unsigned int wait_on_address){
return Feb_WriteRegisters(sub_num,1,&reg_num,&value,&wait_on,&wait_on_address);
}
int Feb_WriteRegisters(unsigned int sub_num, unsigned int nwrites, unsigned int* reg_nums, unsigned int* values, int* wait_ons, unsigned int* wait_on_addresses){
unsigned int i;
// sub_num == 0xfff means write to all
nwrites &= 0x3ff; //10 bits
if(!nwrites||nwrites>Feb_send_buffer_size-2) return 0;
//cout<<"Write register : "<<this<<" "<<s_num<<" "<<nwrites<<" "<<reg_nums<<" "<<values<<" "<<wait_ons<<" "<<wait_on_addresses<<endl;
Feb_send_ndata = 2*nwrites+2;
Feb_send_data[0] = 0x80000000 | nwrites << 14; //cmd -> write nwrites and how many
Feb_send_data[2*nwrites+1] = 0; //tail
for(i=0;i<nwrites;i++) Feb_send_data[2*i+1] = 0x3fff&reg_nums[i]; // register address data_in(13 downto 0)
for(i=0;i<nwrites;i++) Feb_send_data[2*i+2] = values[i]; // value is data_in(31 downto 0)
// wait on busy data(28), address of busy flag data(27 downto 14)
if(wait_ons&&wait_on_addresses) for(i=0;i<nwrites;i++) Feb_send_data[2*i+1] |= (wait_ons[i]<<28 | (0x3fff&wait_on_addresses[i])<<14);
if(!Feb_WriteTo(sub_num)){
printf("%d) Error writing register(s).\n",sub_num);
Feb_PrintData();
return 0;
}
int passed = 1;
unsigned int n = (sub_num&0xff)==0xff ? Feb_nfebs : 1;
unsigned int* nums = (sub_num&0xff)==0xff ? Feb_feb_numb : &sub_num;
for(i=0;i<n;i++){
if((sub_num&0xf00&(nums[i]))==0) continue;
if(!Feb_ReadFrom(nums[i],20)||Feb_recv_ndata!=2||!Feb_CheckHeader(0xffffffff,1)){
printf("%d) Error writing register(s) response.\n",nums[i]);
Feb_PrintData();
passed = 0;
}else{
passed = passed && Feb_CheckTail(0xffffffff);
}
}
return passed;
}
int Feb_WriteMemory(unsigned int sub_num, unsigned int mem_num, unsigned int start_address, unsigned int nwrites, unsigned int *values){
// -1 means write to all
unsigned int i;
mem_num &= 0x3f; //6 bits
start_address &= 0x3fff; //14 bits
nwrites &= 0x3ff; //10 bits
if(!nwrites||nwrites>Feb_send_buffer_size-2) return 0;
Feb_send_ndata = nwrites+2;
Feb_send_data[0] = 0xc0000000 | mem_num << 24 | nwrites << 14 | start_address; //cmd -> write to memory, nwrites, mem number, start address
Feb_send_data[nwrites+1] = 0; //tail
for(i=0;i<nwrites;i++) Feb_send_data[i+1] = values[i];
if(!Feb_WriteTo(sub_num)){
printf("%d) Error writing memory.\n",sub_num);
return 0;
}
int passed = 1;
unsigned int n = (sub_num&0xff)==0xff ? Feb_nfebs : 1;
unsigned int* nums = (sub_num&0xff)==0xff ? Feb_feb_numb : &sub_num;
for(i=0;i<n;i++){
if((sub_num&0xf00&(nums[i]))==0) continue;
if(!Feb_ReadFrom(nums[i],20)||Feb_recv_ndata!=2||!Feb_CheckHeader(0xffffffff,1)){
printf("%d) Error writing memory response. \n",nums[i]);
Feb_PrintData();
passed = 0;
}else{
passed = passed && Feb_CheckTail(0xffffffff);
}
}
// unsigned int n = sub_num==0xfff ? nfebs : 1;
// unsigned int* nums = sub_num==0xfff ? feb_numb : &sub_num;
// for(unsigned int i=0;i<n;i++){
return passed;
}
int Feb_Test(){//int sub_num_s, unsigned int mem_num, unsigned int start_address, unsigned int nwrites, unsigned int *values){
// -1 means write to all
unsigned int i;
unsigned int reg_nums[10]={0,1,2,3,1,2,3,1,2,3};
printf("Test\n\n\n\n");
unsigned int value = 0;
for(i=0;i<10;i++){
Feb_WriteRegister(0xfff,reg_nums[i%10],i,0,0);
Feb_ReadRegister(256,reg_nums[i%10],&value);
printf("%d %d\n",i,value);
Feb_ReadRegister(512,reg_nums[i%10],&value);
printf("%d %d\n",i,value);
Feb_WriteMemory(0xfff,0,0,10,reg_nums);
}
return 0;
}

59
slsDetectorServers/eigerDetectorServer/Feb.h
View File

@ -1,59 +0,0 @@
/**
* @author Ian Johnson
* @version 1.0
*/
#ifndef FEB_H
#define FEB_H
#include "LocalLinkInterface.h"
struct LocalLinkInterface* ll;
unsigned int Feb_nfebs;
unsigned int* Feb_feb_numb;
int Feb_send_ndata;
unsigned int Feb_send_buffer_size;
unsigned int* Feb_send_data_raw;
unsigned int* Feb_send_data;
int Feb_recv_ndata;
unsigned int Feb_recv_buffer_size;
unsigned int* Feb_recv_data_raw;
unsigned int* Feb_recv_data;
int Feb_WriteTo(unsigned int ch);
/*int Feb_ReadFrom(unsigned int Feb_ch, unsigned int Feb_ntrys=20);*/
int Feb_ReadFrom(unsigned int ch, unsigned int ntrys);
/* int Feb_CheckHeader(unsigned int Feb_valid_bit_mask=0xffffffff, int Feb_print_error_info=1);*/
int Feb_CheckHeader(unsigned int valid_bit_mask, int print_error_info);
/*int Feb_CheckTail(unsigned int Feb_valid_bit_mask=0xffffffff);*/
int Feb_CheckTail(unsigned int valid_bit_mask);
int Feb_SetByteOrder();
//int Feb_CheckSubNumber(unsigned int Feb_sub_num);
//int Feb_SetStartOnEndOnFebs(int Feb_sub_num_s, unsigned int& Feb_start_on, unsigned int& Feb_end_on);
void Feb_PrintData();
void Feb_Feb();
/*virtual ~Feb();*/
void Feb_SendCompleteFebList(unsigned int n,unsigned int* list);
int Feb_CheckCommunication();
/*int Feb_ReadRegister(unsigned int Feb_sub_num, unsigned int Feb_reg_num,unsigned int& Feb_value_read);*/
int Feb_ReadRegister(unsigned int sub_num, unsigned int reg_num,unsigned int* value_read);
int Feb_ReadRegisters(unsigned int sub_num, unsigned int nreads, unsigned int* reg_nums,unsigned int* values_read);
/*int WriteRegister(unsigned int sub_num, unsigned int reg_num,unsigned int value, int wait_on=0, unsigned int wait_on_address=0);*/
int Feb_WriteRegister(unsigned int sub_num, unsigned int reg_num,unsigned int value, int wait_on, unsigned int wait_on_address);
/*int WriteRegisters(unsigned int sub_num, unsigned int nwrites, unsigned int* reg_nums, unsigned int* values, int* wait_ons=0, unsigned int* wait_on_addresses=0);*/
int Feb_WriteRegisters(unsigned int sub_num, unsigned int nwrites, unsigned int* reg_nums, unsigned int* values, int* wait_ons, unsigned int* wait_on_addresses);
int Feb_WriteMemory(unsigned int sub_num, unsigned int mem_num, unsigned int start_address, unsigned int nwrites, unsigned int *values);
int Feb_Test();
#endif

4
slsDetectorServers/eigerDetectorServer/Makefile
View File

@ -1,6 +1,6 @@
CC = powerpc-4xx-softfloat-gcc CC = powerpc-4xx-softfloat-gcc
BLACKFIN_CC = bfin-uclinux-gcc BLACKFIN_CC = bfin-uclinux-gcc
CFLAGS += -Wall -DEIGERD -DSLS_DETECTOR_FUNCTION_LIST -DSTOP_SERVER #-DVERBOSEI #-DVERBOSE -DPCCOMPILE -DMARTIN CFLAGS += -Wall -DEIGERD -DSTOP_SERVER #-DVERBOSEI #-DVERBOSE -DPCCOMPILE -DMARTIN
LDLIBS += -lm -lstdc++ LDLIBS += -lm -lstdc++
PROGS = eigerDetectorServer PROGS = eigerDetectorServer
@ -8,7 +8,7 @@ DESTDIR ?= bin
INSTMODE = 0777 INSTMODE = 0777
SRC_CLNT = communication_funcs.c slsDetectorServer.c slsDetectorServer_funcs.c slsDetectorFunctionList.c FebControl.c Beb.c HardwareIO.c LocalLinkInterface.c Feb.c FebInterface.c SRC_CLNT = communication_funcs.c slsDetectorServer.c slsDetectorServer_funcs.c slsDetectorFunctionList.c FebControl.c Beb.c HardwareIO.c LocalLinkInterface.c FebInterface.c
OBJS = $(SRC_CLNT:.c=.o) OBJS = $(SRC_CLNT:.c=.o)

2
slsDetectorServers/eigerDetectorServer/Makefile.virtual
View File

@ -1,5 +1,5 @@
CC = gcc CC = gcc
CFLAGS += -Wall -DEIGERD -DSLS_DETECTOR_FUNCTION_LIST -DPCCOMPILE -DSTOP_SERVER #-DVERBOSE CFLAGS += -Wall -DEIGERD -DPCCOMPILE -DSTOP_SERVER #-DVERBOSE
CFLAGS += -DVIRTUAL -DVIRTUAL_9M CFLAGS += -DVIRTUAL -DVIRTUAL_9M
MASTERFLAG += -DVIRTUAL_MASTER MASTERFLAG += -DVIRTUAL_MASTER
LDLIBS += -lm -lstdc++ -pthread LDLIBS += -lm -lstdc++ -pthread

8
slsDetectorServers/eigerDetectorServer/gitInfo.txt
View File

@ -1,9 +1,9 @@
Path: slsDetectorPackage/slsDetectorServers/eigerDetectorServer Path: slsDetectorPackage/slsDetectorServers/eigerDetectorServer
URL: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git URL: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git
Repository Root: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git Repository Root: origin git@github.com:slsdetectorgroup/slsDetectorPackage.git
Repsitory UUID: c24a9b223cbb066d3851599f4d977ae835feffe4 Repsitory UUID: 178b83222380f7b7294cde66e66719c5d1c1363c
Revision: 0 Revision: 2
Branch: refactor Branch: refactor
Last Changed Author: Dhanya_Thattil Last Changed Author: Dhanya_Thattil
Last Changed Rev: 4099 Last Changed Rev: 4125
Last Changed Date: 2018-10-11 13:46:08.000000002 +0200 ./xparameters.h Last Changed Date: 2018-10-16 09:02:45.000000002 +0200 ./Makefile

6
slsDetectorServers/eigerDetectorServer/gitInfoEiger.h
View File

@ -1,6 +1,6 @@
#define GITURL "git@github.com:slsdetectorgroup/slsDetectorPackage.git" #define GITURL "git@github.com:slsdetectorgroup/slsDetectorPackage.git"
#define GITREPUUID "c24a9b223cbb066d3851599f4d977ae835feffe4" #define GITREPUUID "178b83222380f7b7294cde66e66719c5d1c1363c"
#define GITAUTH "Dhanya_Thattil" #define GITAUTH "Dhanya_Thattil"
#define GITREV 0x4099 #define GITREV 0x4125
#define GITDATE 0x20181011 #define GITDATE 0x20181016
#define GITBRANCH "refactor" #define GITBRANCH "refactor"

1
slsDetectorServers/eigerDetectorServer/logger.h Symbolic link
View File

@ -0,0 +1 @@
../slsDetectorServer/logger.h

21
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -1,5 +1,3 @@
//#ifdef SLS_DETECTOR_FUNCTION_LIST
#include <stdio.h> #include <stdio.h>
#include <unistd.h> //to gethostname #include <unistd.h> //to gethostname
@ -17,6 +15,9 @@
#include "versionAPI.h" #include "versionAPI.h"
#endif #endif
// Global variable from slsDetectorServer
extern int debugflag;
int default_tau_from_file= -1; int default_tau_from_file= -1;
#define BEB_NUM 34 #define BEB_NUM 34
@ -106,7 +107,7 @@ int getFirmwareCheckResult(char** mess) {
return firmware_compatibility; return firmware_compatibility;
} }
void checkFirmwareCompatibility(int flag){ void checkFirmwareCompatibility(){
firmware_compatibility = OK; firmware_compatibility = OK;
firmware_check_done = 0; firmware_check_done = 0;
memset(firmware_message, 0, MAX_STR_LENGTH); memset(firmware_message, 0, MAX_STR_LENGTH);
@ -148,8 +149,8 @@ void checkFirmwareCompatibility(int flag){
REQUIRED_FIRMWARE_VERSION, REQUIRED_FIRMWARE_VERSION,
(long long int)client_sw_apiversion); (long long int)client_sw_apiversion);
// return if flag is not zero, debug mode // return if debugflag is not zero, debug mode
if (flag) { if (debugflag) {
firmware_check_done = 1; firmware_check_done = 1;
return; return;
} }
@ -1100,7 +1101,7 @@ int setHighVoltage(int val){
/* parameters - timing, extsig */ /* parameters - timing, extsig */
enum externalCommunicationMode setTiming( enum externalCommunicationMode arg){ void setTiming( enum externalCommunicationMode arg){
enum externalCommunicationMode ret=GET_EXTERNAL_COMMUNICATION_MODE; enum externalCommunicationMode ret=GET_EXTERNAL_COMMUNICATION_MODE;
if(arg != GET_EXTERNAL_COMMUNICATION_MODE){ if(arg != GET_EXTERNAL_COMMUNICATION_MODE){
switch((int)arg){ switch((int)arg){
@ -1115,7 +1116,11 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg){
#endif #endif
eiger_triggermode = ret; eiger_triggermode = ret;
} }
}
enum externalCommunicationMode getTiming() {
enum externalCommunicationMode ret = GET_EXTERNAL_COMMUNICATION_MODE;
ret = eiger_triggermode; ret = eiger_triggermode;
switch((int)ret){ switch((int)ret){
case 0: ret = AUTO_TIMING; break; case 0: ret = AUTO_TIMING; break;
@ -1131,9 +1136,6 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg){
/* configure mac */ /* configure mac */
int configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t sourceip, uint32_t udpport, uint32_t udpport2, int ival) { int configureMAC(uint32_t destip, uint64_t destmac, uint64_t sourcemac, uint32_t sourceip, uint32_t udpport, uint32_t udpport2, int ival) {
@ -1832,4 +1834,3 @@ int getNumberOfOffsets(){return NOFFSET;}
//#endif

1
slsDetectorServers/jungfrauDetectorServer/slsDetectorServer_defs.h
View File

@ -8,7 +8,6 @@
#define GOODBYE (-200) #define GOODBYE (-200)
#define PROGRAMMING_MODE (-200)
#define MIN_REQRD_VRSN_T_RD_API 0x171220 #define MIN_REQRD_VRSN_T_RD_API 0x171220
#define REQRD_FRMWR_VRSN 0x180615 #define REQRD_FRMWR_VRSN 0x180615

850
slsDetectorServers/slsDetectorServer/communication_funcs.c
View File

@ -1,240 +1,231 @@
#include "communication_funcs.h" #include "communication_funcs.h"
//#include <sys/socket.h> #include "logger.h"
#include <netinet/tcp.h> /* for TCP_NODELAY */
//#include <netinet/tcp.h> /* for TCP_NODELAY */
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
#include <sys/time.h> #include <sys/time.h>
char lastClientIP[INET_ADDRSTRLEN];
char thisClientIP[INET_ADDRSTRLEN];
int lockStatus;
int differentClients;
//int socketDescriptor, file_des; // Global variables from errno.h
const int send_rec_max_size=SEND_REC_MAX_SIZE;
extern int errno; extern int errno;
// Variables that will be exported
int lockStatus = 0;
char lastClientIP[INET_ADDRSTRLEN] = "";
char thisClientIP[INET_ADDRSTRLEN] = "";
int differentClients = 0;
int isControlServer = 1;
int ret = FAIL;
int fnum = 0;
char mess[MAX_STR_LENGTH];
char dummyClientIP[INET_ADDRSTRLEN]; // Local variables
char dummyClientIP[INET_ADDRSTRLEN] = "";
const int send_rec_max_size = SEND_REC_MAX_SIZE;
int myport = -1;
// socket descriptor set
fd_set readset, tempset; fd_set readset, tempset;
int isock=0, maxfd; // number of socket descrptor listening to
int isock = 0;
// value of socket descriptor,
//becomes max value of socket descriptor (listen) and file descriptor (accept)
int maxfd = 0;
int myport=-1;
//struct sockaddr_in address;
//#define VERBOSE
#define DEFAULT_BACKLOG 5
int bindSocket(unsigned short int port_number) { int bindSocket(unsigned short int port_number) {
int i; ret = FAIL;
int socketDescriptor = -1;
int i = 0;
struct sockaddr_in addressS;
struct sockaddr_in addressS; // same port
int socketDescriptor; if (myport == port_number) {
//int file_des; sprintf(mess, "Cannot create %s socket with port %d. Already in use before.\n",
(isControlServer ? "control":"stop"), port_number);
FILE_LOG(logERROR, (mess));
}
// port ok
else {
//file_des= -1; // create socket
socketDescriptor = socket(AF_INET, SOCK_STREAM,0);
// socket error
if (socketDescriptor < 0) {
sprintf(mess, "Cannot create %s socket with port %d\n",
(isControlServer ? "control":"stop"), port_number);
FILE_LOG(logERROR, (mess));
}
// socket success
else {
i = 1;
// set port reusable
setsockopt(socketDescriptor, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
// Set some fields in the serverAddress structure
addressS.sin_family = AF_INET;
addressS.sin_addr.s_addr = htonl(INADDR_ANY);
addressS.sin_port = htons(port_number);
// bind socket error
if(bind(socketDescriptor,(struct sockaddr *) &addressS,sizeof(addressS)) < 0){
sprintf(mess, "Cannot bind %s socket to port %d.\n",
(isControlServer ? "control":"stop"), port_number);
FILE_LOG(logERROR, (mess));
}
// bind socket ok
else {
// listen to socket
if (listen(socketDescriptor, DEFAULT_BACKLOG) == 0) {
// clear set of descriptors. set of descriptors needed?
if (isock == 0) {
FD_ZERO(&readset);
}
// add a socket descriptor from listen
FD_SET(socketDescriptor, &readset);
isock++;
maxfd = socketDescriptor;
// success
myport = port_number;
ret = OK;
FILE_LOG(logINFO, (" %s socket bound: isock=%d port=%d fd=%d\n",
(isControlServer ? "Control":"Stop"), isock, port_number, socketDescriptor));
}
// listen socket error
else {
sprintf(mess, "Cannot bind %s socket to port %d.\n",
(isControlServer ? "control":"stop"), port_number);
FILE_LOG(logERROR, (mess));
}
}
}
}
return socketDescriptor;
if (myport==port_number)
return -10;
socketDescriptor = socket(AF_INET, SOCK_STREAM,0); //tcp
//socketDescriptor = socket(PF_INET, SOCK_STREAM, 0);
if (socketDescriptor < 0) {
printf("Can not create socket\n");
} else {
i = 1;
setsockopt(socketDescriptor, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
// setsockopt(socketDescriptor, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
// TCP_CORK
// Set some fields in the serverAddress structure.
addressS.sin_family = AF_INET;
addressS.sin_addr.s_addr = htonl(INADDR_ANY);
addressS.sin_port = htons(port_number);
// memset(&address.sin_addr, 0, sizeof(address.sin_addr));
if(bind(socketDescriptor,(struct sockaddr *) &addressS,sizeof(addressS))<0){
printf("Can not create socket\n");
socketDescriptor=-1;
} else {
if (listen(socketDescriptor, 5)==0) {
if (isock==0) {
FD_ZERO(&readset);
}
FD_SET(socketDescriptor, &readset);
isock++;
maxfd = socketDescriptor;
printf ("%d port %d fd %d\n",isock, port_number,socketDescriptor);
myport=port_number;
} else
printf("error on listen");
}
}
//int getrlimit(int resource, struct rlimit *rlim);
return socketDescriptor;
} }
int getServerError(int socketDescriptor)
{
if (socketDescriptor<0) return 1;
else return 0;
};
int acceptConnection(int socketDescriptor) { int acceptConnection(int socketDescriptor) {
int j;
struct sockaddr_in addressC;
int file_des = -1;
struct timeval tv;
socklen_t address_length = sizeof(struct sockaddr_in);
if (socketDescriptor < 0)
return -1;
int j; // copy file descriptor set temporarily
memcpy(&tempset, &readset, sizeof(tempset));
// set time out as 2777.77 hours?
tv.tv_sec = 10000000;
tv.tv_usec = 0;
struct sockaddr_in addressC; // monitor file descrptors
int file_des=-1; int result = select(maxfd + 1, &tempset, NULL, NULL, &tv);
struct timeval tv;
int result;
// timeout
if (result == 0) {
FILE_LOG(logDEBUG5, ("%s socket select() timed out!\n",
(isControlServer ? "control":"stop"), myport));
}
//socklen_t address_length; // error (not signal caught)
socklen_t address_length=sizeof(struct sockaddr_in); else if (result < 0 && errno != EINTR) {
FILE_LOG(logERROR, ("%s socket select() error: %s\n",
(isControlServer ? "control":"stop"), myport, strerror(errno)));
}
if (socketDescriptor<0) // activity in descriptor set
return -1; else if (result > 0) {
FILE_LOG(logDEBUG5, ("%s select returned!\n", (isControlServer ? "control":"stop")));
memcpy(&tempset, &readset, sizeof(tempset)); // loop through the file descriptor set
tv.tv_sec = 10000000; for (j = 0; j < maxfd + 1; ++j) {
tv.tv_usec = 0;
result = select(maxfd + 1, &tempset, NULL, NULL, &tv);
if (result == 0) { // checks if file descriptor part of set
printf("select() timed out!\n"); if (FD_ISSET(j, &tempset)) {
} else if (result < 0 && errno != EINTR) { FILE_LOG(logDEBUG5, ("fd %d is set\n",j));
printf("Error in select(): %s\n", strerror(errno));
} else if (result > 0) {
#ifdef VERBOSE
printf("select returned!\n");
#endif
for (j=0; j<maxfd+1; j++) {
if (FD_ISSET(j, &tempset)) {
#ifdef VERBOSE
printf("fd %d is set\n",j);
#endif
FD_CLR(j, &tempset);
// clear the temporary set
FD_CLR(j, &tempset);
if ((file_des = accept(j,(struct sockaddr *) &addressC, &address_length)) < 0) { // accept connection (if error)
printf("Error in accept(): %s\n", strerror(errno)); if ((file_des = accept(j,(struct sockaddr *) &addressC, &address_length)) < 0) {
printf("Error: with server accept, connection refused %d\n", errno); FILE_LOG(logERROR, ("%s socket accept() error. Connection refused.\n",
"Error Number: %d, Message: %s\n",
(isControlServer ? "control":"stop"),
switch(errno) { myport, errno, strerror(errno)));
case EWOULDBLOCK: switch(errno) {
printf("ewouldblock eagain\n"); case EWOULDBLOCK:
break; FILE_LOG(logERROR, ("ewouldblock eagain"));
case EBADF: break;
printf("ebadf\n"); case EBADF:
break; FILE_LOG(logERROR, ("ebadf\n"));
case ECONNABORTED: break;
printf("econnaborted\n"); case ECONNABORTED:
break; FILE_LOG(logERROR, ("econnaborted\n"));
case EFAULT: break;
printf("efault\n"); case EFAULT:
break; FILE_LOG(logERROR, ("efault\n"));
case EINTR: break;
printf("eintr\n"); case EINTR:
break; FILE_LOG(logERROR, ("eintr\n"));
case EINVAL: break;
printf("einval\n"); case EINVAL:
break; FILE_LOG(logERROR, ("einval\n"));
case EMFILE: break;
printf("emfile\n"); case EMFILE:
break; FILE_LOG(logERROR, ("emfile\n"));
case ENFILE: break;
printf("enfile\n"); case ENFILE:
break; FILE_LOG(logERROR, ("enfile\n"));
case ENOTSOCK: break;
printf("enotsock\n"); case ENOTSOCK:
break; FILE_LOG(logERROR, ("enotsock\n"));
case EOPNOTSUPP: break;
printf("eOPNOTSUPP\n"); case EOPNOTSUPP:
break; FILE_LOG(logERROR, ("eOPNOTSUPP\n"));
case ENOBUFS: break;
printf("ENOBUFS\n"); case ENOBUFS:
break; FILE_LOG(logERROR, ("ENOBUFS\n"));
case ENOMEM: break;
printf("ENOMEM\n"); case ENOMEM:
break; FILE_LOG(logERROR, ("ENOMEM\n"));
case ENOSR: break;
printf("ENOSR\n"); case ENOSR:
break; FILE_LOG(logERROR, ("ENOSR\n"));
case EPROTO: break;
printf("EPROTO\n"); case EPROTO:
break; FILE_LOG(logERROR, ("EPROTO\n"));
default: break;
printf("unknown error\n"); default:
} FILE_LOG(logERROR, ("unknown error\n"));
}
// should remove descriptor }
// accept success
socketDescriptor=-1; else {
} else { inet_ntop(AF_INET, &(addressC.sin_addr), dummyClientIP, INET_ADDRSTRLEN);
FILE_LOG(logDEBUG5, ("%s socket accepted connection, fd= %d\n",
inet_ntop(AF_INET, &(addressC.sin_addr), dummyClientIP, INET_ADDRSTRLEN); (isControlServer ? "control":"stop"), file_des));
#ifdef VERBOSE // add the file descriptor from accept
printf("connection accepted %d\n",file_des); FD_SET(file_des, &readset);
#endif maxfd = (maxfd < file_des)?file_des:maxfd;
FD_SET(file_des, &readset); }
maxfd = (maxfd < file_des)?file_des:maxfd; }
} }
}
} return file_des;
}
}
return file_des;
} }
@ -244,22 +235,18 @@ int acceptConnection(int socketDescriptor) {
void closeConnection(int file_des) { void closeConnection(int file_des) {
#ifdef VERY_VERBOSE if(file_des >= 0)
#endif close(file_des);
if(file_des>=0) // remove file descriptor from set
close(file_des); FD_CLR(file_des, &readset);
FD_CLR(file_des, &readset);
} }
void exitServer(int socketDescriptor) { void exitServer(int socketDescriptor) {
if (socketDescriptor>=0) if (socketDescriptor >= 0)
close(socketDescriptor); close(socketDescriptor);
#ifdef VERY_VERBOSE FILE_LOG(logDEBUG5, ("Closing %s server\n", (isControlServer ? "control":"stop")));
printf("Closing server\n"); FD_CLR(socketDescriptor, &readset);
#endif isock--;
FD_CLR(socketDescriptor, &readset);
socketDescriptor=-1;
isock--;
} }
@ -267,18 +254,18 @@ void exitServer(int socketDescriptor) {
void swapData(void* val,int length,intType itype){ void swapData(void* val,int length,intType itype){
int i; int i;
int16_t* c= (int16_t*)val; int16_t* c = (int16_t*)val;
int32_t* a= (int32_t*)val; int32_t* a = (int32_t*)val;
int64_t* b= (int64_t*)val; int64_t* b = (int64_t*)val;
for(i=0; length > 0; i++){ for(i = 0; length > 0; i++){
switch(itype){ switch(itype){
case INT16: case INT16:
c[i] = ((c[i] & 0x00FF) << 8) | ((c[i] & 0xFF00) >> 8); c[i] = ((c[i] & 0x00FF) << 8) | ((c[i] & 0xFF00) >> 8);
length -= sizeof(int16_t); length -= sizeof(int16_t);
break; break;
case INT32: case INT32:
a[i]=((a[i] << 8) & 0xFF00FF00) | ((a[i] >> 8) & 0xFF00FF ); a[i] = ((a[i] << 8) & 0xFF00FF00) | ((a[i] >> 8) & 0xFF00FF );
a[i]=(a[i] << 16) | ((a[i] >> 16) & 0xFFFF); a[i] = (a[i] << 16) | ((a[i] >> 16) & 0xFFFF);
length -= sizeof(int32_t); length -= sizeof(int32_t);
break; break;
case INT64: case INT64:
@ -305,57 +292,59 @@ int sendData(int file_des, void* buf,int length, intType itype){
int receiveData(int file_des, void* buf,int length, intType itype){ int receiveData(int file_des, void* buf,int length, intType itype){
int ret = receiveDataOnly(file_des, buf, length); int lret = receiveDataOnly(file_des, buf, length);
#ifndef PCCOMPILE #ifndef PCCOMPILE
#ifdef EIGERD #ifdef EIGERD
if (ret >= 0) swapData(buf, length, itype); if (lret >= 0) swapData(buf, length, itype);
#endif #endif
#endif #endif
return ret; return lret;
} }
int sendDataOnly(int file_des, void* buf,int length) { int sendDataOnly(int file_des, void* buf,int length) {
if (!length) if (!length)
return 0; return 0;
int ret = write(file_des, buf, length); //value of -1 is other end socket crash as sigpipe is ignored int lret = write(file_des, buf, length); //value of -1 is other end socket crash as sigpipe is ignored
if (ret < 0) cprintf(BG_RED, "Error writing to socket. Possible socket crash\n"); if (lret < 0) {
return ret; FILE_LOG(logERROR, ("Could not write to %s socket. Possible socket crash\n",
(isControlServer ? "control":"stop")));
}
return lret;
} }
int receiveDataOnly(int file_des, void* buf,int length) { int receiveDataOnly(int file_des, void* buf,int length) {
int total_received=0; int total_received = 0;
int nreceiving; int nreceiving;
int nreceived; int nreceived;
if (file_des<0) return -1; if (file_des<0) return -1;
#ifdef VERY_VERBOSE FILE_LOG(logDEBUG5, ("want to receive %d Bytes to %s server\n",
printf("want to receive %d Bytes\n", length); length, (isControlServer ? "control":"stop")));
#endif
while(length > 0) { while(length > 0) {
nreceiving = (length>send_rec_max_size) ? send_rec_max_size:length; // (condition) ? if_true : if_false nreceiving = (length>send_rec_max_size) ? send_rec_max_size:length; // (condition) ? if_true : if_false
nreceived = read(file_des,(char*)buf+total_received,nreceiving); nreceived = read(file_des,(char*)buf+total_received,nreceiving);
if(!nreceived){ if(!nreceived){
if(!total_received) { if(!total_received) {
return -1; //to handle it return -1; //to handle it
} }
break; break;
} }
length-=nreceived; length -= nreceived;
total_received+=nreceived; total_received += nreceived;
} }
if (total_received>0) if (total_received>0)
strcpy(thisClientIP,dummyClientIP); strcpy(thisClientIP,dummyClientIP);
if (strcmp(lastClientIP,thisClientIP)) if (strcmp(lastClientIP,thisClientIP))
differentClients=1; differentClients = 1;
else else
differentClients=0; differentClients = 0;
return total_received; return total_received;
} }
@ -367,55 +356,49 @@ int sendModule(int file_des, sls_detector_module *myMod) {
int sendModuleGeneral(int file_des, sls_detector_module *myMod, int sendAll) { int sendModuleGeneral(int file_des, sls_detector_module *myMod, int sendAll) {
int ts=0; int ts = 0;
#ifdef VERBOSE int nChips = myMod->nchip;
int idac; int nChans = myMod->nchan;
#endif int nAdcs = myMod->nadc;
int nChips=myMod->nchip; int nDacs = myMod->ndac;
int nChans=myMod->nchan;
int nAdcs=myMod->nadc;
int nDacs=myMod->ndac;
//ts+= sendDataOnly(file_des,myMod,sizeof(sls_detector_module));
ts+=sendData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32);
ts+=sendData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32);
ts+=sendData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32);
ts+=sendData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32);
ts+=sendData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32);
ts+=sendData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32);
ts+=sendData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER);
ts+=sendData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER);
#ifdef VERBOSE // send module structure
printf("module of size %d sent\n",ts); ts += sendData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32);
#endif ts += sendData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32);
ts+= sendData(file_des,myMod->dacs,sizeof(int)*nDacs,INT32); ts += sendData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32);
#ifdef VERBOSE ts += sendData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32);
printf("dacs of size %d sent\n",ts); ts += sendData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32);
int idac; ts += sendData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32);
for (idac=0; idac< nDacs; idac++) ts += sendData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER);
printf("dac %d is %d\n",idac,(int)myMod->dacs[idac]); ts += sendData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER);
#endif FILE_LOG(logDEBUG5, ("module of size %d sent\n",ts));
ts+= sendData(file_des,myMod->adcs,sizeof(int)*nAdcs,INT32);
#ifdef VERBOSE
printf("adcs of size %d sent\n", ts);
#endif
/*some detectors dont require sending all trimbits etc.*/ // send dac
if(sendAll){ ts += sendData(file_des,myMod->dacs,sizeof(int)*nDacs,INT32);
ts+=sendData(file_des,myMod->chipregs,sizeof(int)*nChips,INT32); FILE_LOG(logDEBUG5, ("dacs of size %d sent\n",ts));
#ifdef VERBOSE {
printf("chips of size %d sent\n", ts); int idac;
#endif for (idac = 0; idac < nDacs; idac++)
ts+=sendData(file_des,myMod->chanregs,sizeof(int)*nChans,INT32); FILE_LOG(logDEBUG5, ("dac %d is %d\n",idac,(int)myMod->dacs[idac]));
#ifdef VERBOSE }
printf("chans of size %d sent - %d\n", ts, myMod->nchan);
#endif
}
#ifdef VERBOSE // send adc
printf("module of size %d sent register %x\n", ts, myMod->reg); ts += sendData(file_des,myMod->adcs,sizeof(int)*nAdcs,INT32);
#endif FILE_LOG(logDEBUG5, ("adcs of size %d sent\n", ts));
return ts;
// some detectors dont require sending all trimbits etc.
if(sendAll) {
// chips
ts += sendData(file_des,myMod->chipregs,sizeof(int)*nChips,INT32);
FILE_LOG(logDEBUG5, ("chips of size %d sent\n", ts));
// channels
ts += sendData(file_des,myMod->chanregs,sizeof(int)*nChans,INT32);
FILE_LOG(logDEBUG5, ("chans of size %d sent - %d\n", ts, myMod->nchan));
}
FILE_LOG(logDEBUG5, ("module of size %d sent register %x\n", ts, myMod->reg));
return ts;
} }
@ -425,146 +408,163 @@ int receiveModule(int file_des, sls_detector_module* myMod) {
} }
int receiveModuleGeneral(int file_des, sls_detector_module* myMod, int receiveAll) { int receiveModuleGeneral(int file_des, sls_detector_module* myMod, int receiveAll) {
int ts=0; int ts = 0;
int *dacptr=myMod->dacs; int *dacptr = myMod->dacs;
int *adcptr=myMod->adcs; int *adcptr = myMod->adcs;
int *chipptr=myMod->chipregs, *chanptr=myMod->chanregs; int *chipptr = myMod->chipregs, *chanptr = myMod->chanregs;
int nChips, nchipold=myMod->nchip, nchipdiff; int nChips, nchipold = myMod->nchip, nchipdiff;
int nChans, nchanold=myMod->nchan, nchandiff; int nChans, nchanold = myMod->nchan, nchandiff;
int nDacs, ndold=myMod->ndac, ndacdiff; int nDacs, ndold = myMod->ndac, ndacdiff;
int nAdcs, naold=myMod->nadc, nadcdiff; int nAdcs, naold = myMod->nadc, nadcdiff;
ts+=receiveData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32); ts += receiveData(file_des,&(myMod->serialnumber),sizeof(myMod->serialnumber),INT32);
ts+=receiveData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32); ts += receiveData(file_des,&(myMod->nchan),sizeof(myMod->nchan),INT32);
ts+=receiveData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32); ts += receiveData(file_des,&(myMod->nchip),sizeof(myMod->nchip),INT32);
ts+=receiveData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32); ts += receiveData(file_des,&(myMod->ndac),sizeof(myMod->ndac),INT32);
ts+=receiveData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32); ts += receiveData(file_des,&(myMod->nadc),sizeof(myMod->nadc),INT32);
ts+=receiveData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32); ts += receiveData(file_des,&(myMod->reg),sizeof(myMod->reg),INT32);
ts+=receiveData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER); ts += receiveData(file_des,&(myMod->gain), sizeof(myMod->gain),OTHER);
ts+=receiveData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER); ts += receiveData(file_des,&(myMod->offset), sizeof(myMod->offset),OTHER);
myMod->dacs=dacptr; myMod->dacs = dacptr;
myMod->adcs=adcptr; myMod->adcs = adcptr;
myMod->chipregs=chipptr; myMod->chipregs = chipptr;
myMod->chanregs=chanptr; myMod->chanregs = chanptr;
#ifdef EIGERD #ifdef EIGERD
//feature to exclude sending of trimbtis, nchips=0,nchans=0 in that case //exclude sending of trimbtis, nchips = 0,nchans = 0 in that case
if(myMod->nchip == 0 && myMod->nchan == 0) { if(myMod->nchip == 0 && myMod->nchan == 0) {
receiveAll=0; receiveAll = 0;
nchipold=0; nchipold = 0;
nchanold=0; nchanold = 0;
} }
#endif #endif
nChips=myMod->nchip; nChips = myMod->nchip;
nchipdiff=nChips-nchipold; nchipdiff = nChips-nchipold;
if (nchipold!=nChips) { if (nchipold != nChips) {
printf("received wrong number of chips\n"); FILE_LOG(logERROR, ("received wrong number of chips\n"));
} }
#ifdef VERBOSE else
else FILE_LOG(logDEBUG5, ("received %d chips\n",nChips));
printf("received %d chips\n",nChips);
#endif
nChans=myMod->nchan; nChans = myMod->nchan;
nchandiff=nChans-nchanold; nchandiff = nChans-nchanold;
if (nchanold!=nChans) { if (nchanold != nChans) {
printf("received wrong number of channels\n"); FILE_LOG(logERROR, ("received wrong number of channels\n"));
} }
#ifdef VERBOSE else
else FILE_LOG(logDEBUG5, ("received %d chans\n",nChans));
printf("received %d chans\n",nChans);
#endif
nDacs=myMod->ndac; nDacs = myMod->ndac;
ndacdiff=nDacs-ndold; ndacdiff = nDacs-ndold;
if (ndold!=nDacs) { if (ndold != nDacs) {
printf("received wrong number of dacs\n"); FILE_LOG(logERROR, ("received wrong number of dacs\n"));
} }
#ifdef VERBOSE else
else FILE_LOG(logDEBUG5, ("received %d dacs\n",nDacs));
printf("received %d dacs\n",nDacs);
#endif
nAdcs=myMod->nadc; nAdcs = myMod->nadc;
nadcdiff=nAdcs-naold; nadcdiff = nAdcs-naold;
if (naold!=nAdcs) { if (naold != nAdcs) {
printf("received wrong number of adcs\n"); FILE_LOG(logERROR, ("received wrong number of adcs\n"));
} }
#ifdef VERBOSE else
else FILE_LOG(logDEBUG5, ("received %d adcs\n",nAdcs));
printf("received %d adcs\n",nAdcs); if (ndacdiff <= 0) {
#endif ts += receiveData(file_des,myMod->dacs, sizeof(int)*nDacs,INT32);
if (ndacdiff<=0) { FILE_LOG(logDEBUG5, ("dacs received\n"));
ts+=receiveData(file_des,myMod->dacs, sizeof(int)*nDacs,INT32); int id;
#ifdef VERBOSE for (id = 0; id<nDacs; id++)
printf("dacs received\n"); FILE_LOG(logDEBUG5, ("dac %d val %d\n",id, (int)myMod->dacs[id]));
int id; } else {
for (id=0; id<nDacs; id++) dacptr = (int*)malloc(ndacdiff*sizeof(int));
printf("dac %d val %d\n",id, (int)myMod->dacs[id]); myMod->ndac = ndold;
ts += receiveData(file_des,myMod->dacs, sizeof(int)*ndold,INT32);
ts += receiveData(file_des,dacptr, sizeof(int)*ndacdiff,INT32);
free(dacptr);
return FAIL;
}
if (nadcdiff <= 0) {
ts += receiveData(file_des,myMod->adcs, sizeof(int)*nAdcs,INT32);
FILE_LOG(logDEBUG5, ("adcs received\n"));
} else {
adcptr = (int*)malloc(nadcdiff*sizeof(int));
myMod->nadc = naold;
ts += receiveData(file_des,myMod->adcs, sizeof(int)*naold,INT32);
ts += receiveData(file_des,adcptr, sizeof(int)*nadcdiff,INT32);
free(adcptr);
return FAIL;
}
#endif // some detectors dont require sending all trimbits etc.
} else { if(receiveAll){
dacptr=(int*)malloc(ndacdiff*sizeof(int));
myMod->ndac=ndold;
ts+=receiveData(file_des,myMod->dacs, sizeof(int)*ndold,INT32);
ts+=receiveData(file_des,dacptr, sizeof(int)*ndacdiff,INT32);
free(dacptr);
return FAIL;
}
if (nadcdiff<=0) { if (nchipdiff <= 0) {
ts+=receiveData(file_des,myMod->adcs, sizeof(int)*nAdcs,INT32); ts += receiveData(file_des,myMod->chipregs, sizeof(int)*nChips,INT32);
#ifdef VERBOSE FILE_LOG(logDEBUG5, ("chips received\n"));
printf("adcs received\n"); } else {
#endif chipptr = (int*)malloc(nchipdiff*sizeof(int));
} else { myMod->nchip = nchipold;
adcptr=(int*)malloc(nadcdiff*sizeof(int)); ts += receiveData(file_des,myMod->chipregs, sizeof(int)*nchipold,INT32);
myMod->nadc=naold; ts += receiveData(file_des,chipptr, sizeof(int)*nchipdiff,INT32);
ts+=receiveData(file_des,myMod->adcs, sizeof(int)*naold,INT32); free(chipptr);
ts+=receiveData(file_des,adcptr, sizeof(int)*nadcdiff,INT32); return FAIL;
free(adcptr); }
return FAIL;
}
if (nchandiff <= 0) {
/*some detectors dont require sending all trimbits etc.*/ ts += receiveData(file_des,myMod->chanregs, sizeof(int)*nChans,INT32);
if(receiveAll){ FILE_LOG(logDEBUG5, ("chans received\n"));
} else {
if (nchipdiff<=0) { chanptr = (int*)malloc(nchandiff*sizeof(int));
ts+=receiveData(file_des,myMod->chipregs, sizeof(int)*nChips,INT32); myMod->nchan = nchanold;
#ifdef VERBOSE ts += receiveData(file_des,myMod->chanregs, sizeof(int)*nchanold,INT32);
printf("chips received\n"); ts += receiveData(file_des,chanptr, sizeof(int)*nchandiff,INT32);
#endif free(chanptr);
} else { return FAIL;
chipptr=(int*)malloc(nchipdiff*sizeof(int)); }
myMod->nchip=nchipold; }
ts+=receiveData(file_des,myMod->chipregs, sizeof(int)*nchipold,INT32); FILE_LOG(logDEBUG5, ("received module of size %d register %x\n",ts,myMod->reg));
ts+=receiveData(file_des,chipptr, sizeof(int)*nchipdiff,INT32); return ts;
free(chipptr); }
return FAIL;
}
void Server_LockedError() {
if (nchandiff<=0) { ret = FAIL;
ts+=receiveData(file_des,myMod->chanregs, sizeof(int)*nChans,INT32); sprintf(mess,"Detector locked by %s\n", lastClientIP);
#ifdef VERBOSE FILE_LOG(logWARNING, (mess));
printf("chans received\n"); }
#endif
} else {
chanptr=(int*)malloc(nchandiff*sizeof(int)); int Server_VerifyLock() {
myMod->nchan=nchanold; if (differentClients && lockStatus)
ts+=receiveData(file_des,myMod->chanregs, sizeof(int)*nchanold,INT32); Server_LockedError();
ts+=receiveData(file_des,chanptr, sizeof(int)*nchandiff,INT32); return ret;
free(chanptr); }
return FAIL;
}
} void Server_SendResult(int fileDes, intType itype, int update, void* retval, int retvalSize) {
#ifdef VERBOSE
printf("received module of size %d register %x\n",ts,myMod->reg); // update if different clients
#endif if (update && ret == OK && differentClients)
ret = FORCE_UPDATE;
return ts;
// send success of operation
int ret1 = ret;
sendData(fileDes, &ret1,sizeof(ret1), INT32);
if(ret == FAIL) {
// send error message
if (strlen(mess))
sendData(fileDes, mess, MAX_STR_LENGTH, OTHER);
// debugging feature. should not happen.
else
FILE_LOG(logERROR, ("No error message provided for this failure in %s "
"server. Will mess up TCP.\n",
(isControlServer ? "control":"stop")));
}
// send return value
sendData(fileDes, retval, retvalSize, itype);
} }

27
slsDetectorServers/slsDetectorServer/communication_funcs.h
View File

@ -37,11 +37,34 @@ int receiveData(int file_des, void* buf,int length, intType itype);
int sendDataOnly(int file_des, void* buf,int length); int sendDataOnly(int file_des, void* buf,int length);
int receiveDataOnly(int file_des, void* buf,int length); int receiveDataOnly(int file_des, void* buf,int length);
int getServerError(int socketDescriptor);
int sendModule(int file_des, sls_detector_module *myMod); int sendModule(int file_des, sls_detector_module *myMod);
int sendModuleGeneral(int file_des, sls_detector_module *myMod, int sendAll); int sendModuleGeneral(int file_des, sls_detector_module *myMod, int sendAll);
int receiveModule(int file_des, sls_detector_module* myMod); int receiveModule(int file_des, sls_detector_module* myMod);
int receiveModuleGeneral(int file_des, sls_detector_module* myMod, int receiveAll); int receiveModuleGeneral(int file_des, sls_detector_module* myMod, int receiveAll);
/**
* Servers sets and prints error message for locked server
* @returns success of operaton
*/
void Server_LockedError();
/**
* Server verifies if it is unlocked,
* sets and prints appropriate message if it is locked and different clients
* @returns success of operaton
*/
int Server_VerifyLock();
/**
* Server sends result to client (also set ret to force_update if different clients)
* @param fileDes file descriptor for the socket
* @param itype 32 or 64 or others to determine to swap data from big endian to little endian
* @param update 1 if one must update if different clients, else 0
* @param retval pointer to result
* @param retvalSize size of result
*/
void Server_SendResult(int fileDes, intType itype, int update, void* retval, int retvalSize);
#endif #endif

63
slsDetectorServers/slsDetectorServer/logger.h Normal file
View File

@ -0,0 +1,63 @@
#pragma once
#include "ansi.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#ifdef FIFODEBUG
#define FILELOG_MAX_LEVEL logDEBUG5
#elif VERYVERBOSE
#define FILELOG_MAX_LEVEL logDEBUG4
#elif VERBOSE
#define FILELOG_MAX_LEVEL logDEBUG
#endif
#ifndef FILELOG_MAX_LEVEL
#define FILELOG_MAX_LEVEL logINFOBLUE
#endif
typedef enum {
logERROR, logWARNING, logINFO, logINFOBLUE,
logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, logDEBUG5
}TLogLevel;
#define ERROR_MSG_LENGTH 1000
#define FILE_LOG(lvl, fmt, ...) \
if (lvl > FILELOG_MAX_LEVEL); \
else {char* temp = FILELOG_BuildLog fmt; FILELOG_PrintLog(lvl, temp);free(temp);}
static inline void FILELOG_PrintLog(TLogLevel level, char* m) {
switch(level) {
case logERROR: cprintf(RED BOLD, "ERROR: %s", m); break;
case logWARNING: cprintf(YELLOW BOLD, "WARNING: %s", m); break;
case logINFOBLUE: cprintf(BLUE, "INFO: %s", m); break;
case logINFO: cprintf(RESET, "INFO: %s", m); break;
case logDEBUG: cprintf(MAGENTA, "DEBUG: %s", m); break;
case logDEBUG1: cprintf(MAGENTA, "DEBUG1: %s", m); break;
case logDEBUG2: cprintf(MAGENTA, "DEBUG2: %s", m); break;
case logDEBUG3: cprintf(MAGENTA, "DEBUG3: %s", m); break;
case logDEBUG4: cprintf(MAGENTA, "DEBUG4: %s", m); break;
case logDEBUG5: cprintf(MAGENTA, "DEBUG5: %s", m); break;
}
}
static inline char* FILELOG_BuildLog(const char* fmt, ...) {
char* p;
va_list ap;
p = malloc(ERROR_MSG_LENGTH);
va_start(ap, fmt);
int ret = vsnprintf(p, ERROR_MSG_LENGTH, fmt, ap);
va_end(ap);
if (ret < 0 || ret >= ERROR_MSG_LENGTH) {
FILELOG_PrintLog(logERROR, ("Could not print the "
"complete error message in the next print.\n"));
}
return p;
};

12
slsDetectorServers/slsDetectorServer/slsDetectorFunctionList.h
View File

@ -1,7 +1,3 @@
#ifdef SLS_DETECTOR_FUNCTION_LIST
#ifndef SLS_DETECTOR_FUNCTION_LIST_H
#define SLS_DETECTOR_FUNCTION_LIST_H
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include "slsDetectorServer_defs.h" // DAC_INDEX, ADC_INDEX, also include RegisterDefs.h #include "slsDetectorServer_defs.h" // DAC_INDEX, ADC_INDEX, also include RegisterDefs.h
@ -22,7 +18,7 @@ int isFirmwareCheckDone();
int getFirmwareCheckResult(char** mess); int getFirmwareCheckResult(char** mess);
#endif #endif
void checkFirmwareCompatibility(int flag); void checkFirmwareCompatibility();
#if defined(MYTHEN3D) || defined(JUNGFRAUD) #if defined(MYTHEN3D) || defined(JUNGFRAUD)
int checkType(); int checkType();
u_int32_t testFpga(void); u_int32_t testFpga(void);
@ -166,7 +162,8 @@ int setHighVoltage(int val);
// parameters - timing, extsig // parameters - timing, extsig
enum externalCommunicationMode setTiming( enum externalCommunicationMode arg); void setTiming( enum externalCommunicationMode arg);
enum externalCommunicationMode getTiming();
// configure mac // configure mac
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
@ -264,6 +261,3 @@ int getNumberOfOffsets();
int getNumberOfChannelsPerChip(); int getNumberOfChannelsPerChip();
#endif
#endif

100
slsDetectorServers/slsDetectorServer/slsDetectorServer.c
View File

@ -3,7 +3,7 @@
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include "slsDetectorServer_defs.h" #include "slsDetectorServer_defs.h"
#include "logger.h"
#include "communication_funcs.h" #include "communication_funcs.h"
#include "slsDetectorServer_funcs.h" #include "slsDetectorServer_funcs.h"
@ -12,8 +12,13 @@
#include <signal.h> #include <signal.h>
#include <string.h> #include <string.h>
extern int sockfd; // Global variables from communication_funcs
extern int isControlServer;
extern int ret;
// Global variables from slsDetectorServer_funcs
extern int sockfd;
extern int debugflag;
void error(char *msg){ void error(char *msg){
perror(msg); perror(msg);
@ -22,9 +27,7 @@ void error(char *msg){
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
int portno = DEFAULT_PORTNO; int portno = DEFAULT_PORTNO;
int retval = OK; int retval = OK;
int sd, fd; int fd = 0;
int debugflag = 0;
int controlserver = 1;
// if socket crash, ignores SISPIPE, prevents global signal handler // if socket crash, ignores SISPIPE, prevents global signal handler
// subsequent read/write to socket gives error - must handle locally // subsequent read/write to socket gives error - must handle locally
@ -35,21 +38,21 @@ int main(int argc, char *argv[]){
int i; int i;
for (i = 1; i < argc; ++i) { for (i = 1; i < argc; ++i) {
if(!strcasecmp(argv[i],"-stopserver")) { if(!strcasecmp(argv[i],"-stopserver")) {
cprintf(BLUE,"Detected stop server\n"); FILE_LOG(logINFO, ("Detected stop server\n"));
controlserver = 0; isControlServer = 0;
} }
else if(!strcasecmp(argv[i],"-devel")){ else if(!strcasecmp(argv[i],"-devel")){
cprintf(BLUE,"Detected developer mode\n"); FILE_LOG(logINFO, ("Detected developer mode\n"));
debugflag = 1; debugflag = 1;
} }
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
else if(!strcasecmp(argv[i],"-update")){ else if(!strcasecmp(argv[i],"-update")){
cprintf(BLUE,"Detected update mode\n"); FILE_LOG(logINFO, ("Detected update mode\n"));
debugflag = PROGRAMMING_MODE; debugflag = PROGRAMMING_MODE;
} }
#endif #endif
else if(strchr(argv[i],'-') != NULL) { else if(strchr(argv[i],'-') != NULL) {
cprintf(RED,"cannot scan program argument %s\n", argv[1]); FILE_LOG(logERROR, ("cannot scan program argument %s\n", argv[1]));
return -1; return -1;
} }
} }
@ -59,79 +62,60 @@ int main(int argc, char *argv[]){
char cmd[100]; char cmd[100];
memset(cmd, 0, 100); memset(cmd, 0, 100);
#endif #endif
if (controlserver) { if (isControlServer) {
portno = DEFAULT_PORTNO; portno = DEFAULT_PORTNO;
cprintf(BLUE, FILE_LOG(logINFOBLUE,
"********************************************************\n" ("***************************************************\n"
"********* opening control server on port %d **********\n" "********* opening control server on port %d **********\n"
"********************************************************\n\n" "********************************************************\n\n"
, portno); , portno));
#ifdef STOP_SERVER #ifdef STOP_SERVER
{ {
int i; int i;
for (i = 0; i < argc; ++i) for (i = 0; i < argc; ++i)
sprintf(cmd, "%s %s", cmd, argv[i]); sprintf(cmd, "%s %s", cmd, argv[i]);
sprintf(cmd,"%s -stopserver&", cmd); sprintf(cmd,"%s -stopserver&", cmd);
cprintf(BLUE,"cmd:%s\n", cmd); FILE_LOG(logINFO, ("Command to start stop server:%s\n", cmd));
system(cmd); system(cmd);
} }
#endif #endif
} else { } else {
portno = DEFAULT_PORTNO+1; portno = DEFAULT_PORTNO + 1;
cprintf(BLUE, FILE_LOG(logINFOBLUE,
"********************************************************\n" ("***************************************************\n"
"*********** opening stop server on port %d ***********\n" "*********** opening stop server on port %d ***********\n"
"********************************************************\n\n" "********************************************************\n\n"
, portno); , portno));
} }
setModeFlag(debugflag); //defined in slsDetectorServer_funcs init_detector();
init_detector(controlserver); //defined in slsDetectorServer_funcs
sd=bindSocket(portno); //defined in communication_funcs { // bind socket
sockfd=sd; sockfd = bindSocket(portno);
if (getServerError(sd)) { //defined in communication_funcs if (ret == FAIL)
printf("server error!\n"); return -1;
return -1;
} }
/* assign function table */ // assign function table
function_table(); //defined in slsDetectorServer_funcs function_table();
#ifdef VERBOSE
printf("function table assigned \n");
#endif
if (controlserver) if (isControlServer) {
printf("\nControl Server Ready...\n\n"); FILE_LOG(logINFO, ("Control Server Ready...\n\n"));
else } else {
printf("\nStop Server Ready...\n\n"); FILE_LOG(logINFO, ("Stop Server Ready...\n\n"));
}
/* waits for connection */ // waits for connection
while(retval!=GOODBYE) { while(retval != GOODBYE) {
#ifdef VERBOSE fd = acceptConnection(sockfd);
printf("\n"); if (fd > 0) {
#endif retval = decode_function(fd);
#ifdef VERY_VERBOSE closeConnection(fd);
printf("Waiting for client call\n");
#endif
fd=acceptConnection(sockfd); //defined in communication_funcs
#ifdef VERY_VERBOSE
printf("Conenction accepted\n");
#endif
if (fd>0) {
retval=decode_function(fd); //defined in slsDetectorServer_funcs
#ifdef VERY_VERBOSE
printf("function executed\n");
#endif
closeConnection(fd); //defined in communication_funcs
#ifdef VERY_VERBOSE
printf("connection closed\n");
#endif
} }
} }
exitServer(sockfd); //defined in communication_funcs exitServer(sockfd);
printf("Goodbye!\n"); FILE_LOG(logINFO,("Goodbye!\n"));
return 0; return 0;
} }

659
slsDetectorServers/slsDetectorServer/slsDetectorServer_funcs.c
View File

File diff suppressed because it is too large Load Diff

4
slsDetectorServers/slsDetectorServer/slsDetectorServer_funcs.h
View File

@ -6,12 +6,12 @@
// initialization functions // initialization functions
int printSocketReadError(); int printSocketReadError();
void setModeFlag(int);
void basictests(); void basictests();
void init_detector(int); void init_detector();
int decode_function(int); int decode_function(int);
const char* getFunctionName(enum detFuncs func); const char* getFunctionName(enum detFuncs func);
void function_table(); void function_table();
void functionNotImplemented();
int M_nofunc(int); int M_nofunc(int);
int M_nofuncMode(int); int M_nofuncMode(int);

490
slsDetectorSoftware/slsDetector/slsDetector.cpp
View File

@ -27,6 +27,8 @@ slsDetector::slsDetector(detectorType type, int multiId, int id, bool verify)
: detId(id), : detId(id),
sharedMemory(0), sharedMemory(0),
thisDetector(0), thisDetector(0),
thisDetectorControl(0),
thisDetectorStop(0),
thisReceiver(0), thisReceiver(0),
controlSocket(0), controlSocket(0),
stopSocket(0), stopSocket(0),
@ -55,10 +57,13 @@ slsDetector::slsDetector(detectorType type, int multiId, int id, bool verify)
initializeDetectorStructurePointers(); initializeDetectorStructurePointers();
} }
slsDetector::slsDetector(int multiId, int id, bool verify) slsDetector::slsDetector(int multiId, int id, bool verify)
: detId(id), : detId(id),
sharedMemory(0), sharedMemory(0),
thisDetector(0), thisDetector(0),
thisDetectorControl(0),
thisDetectorStop(0),
thisReceiver(0), thisReceiver(0),
controlSocket(0), controlSocket(0),
stopSocket(0), stopSocket(0),
@ -85,6 +90,10 @@ slsDetector::~slsDetector() {
sharedMemory->UnmapSharedMemory(thisDetector); sharedMemory->UnmapSharedMemory(thisDetector);
delete sharedMemory; delete sharedMemory;
} }
if(thisDetectorControl)
delete thisDetectorControl;
if(thisDetectorStop)
delete thisDetectorStop;
if(thisReceiver) if(thisReceiver)
delete thisReceiver; delete thisReceiver;
if(controlSocket) if(controlSocket)
@ -107,8 +116,7 @@ int slsDetector::checkVersionCompatibility(portType t) {
if (t == DATA_PORT) if (t == DATA_PORT)
fnum = F_RECEIVER_CHECK_VERSION; fnum = F_RECEIVER_CHECK_VERSION;
int ret = FAIL; int ret = FAIL;
char mess[MAX_STR_LENGTH]; char mess[MAX_STR_LENGTH] = {0};
memset(mess, 0, MAX_STR_LENGTH);
int64_t arg = 0; int64_t arg = 0;
// detector // detector
@ -205,57 +213,56 @@ int slsDetector::checkVersionCompatibility(portType t) {
int64_t slsDetector::getId( idMode mode) { int64_t slsDetector::getId( idMode mode) {
int fnum = F_GET_ID;
int ret = FAIL;
int arg = (int)mode;
int64_t retval = -1;
int64_t retval=-1; FILE_LOG(logDEBUG5) << "Getting id type " << mode;
int fnum=F_GET_ID,fnum2 = F_GET_RECEIVER_ID;
int ret=FAIL;
char mess[MAX_STR_LENGTH]="";
#ifdef VERBOSE // client version
std::cout<< std::endl << "Getting id type "<< mode << std::endl; if (mode == THIS_SOFTWARE_VERSION) {
#endif ret = OK;
if (mode==THIS_SOFTWARE_VERSION) { retval = GITDATE;
ret=OK; }
retval=GITDATE;
} else if (mode==RECEIVER_VERSION) { // receiver version
else if (mode==RECEIVER_VERSION) {
fnum = F_GET_RECEIVER_ID;
if (thisDetector->receiverOnlineFlag==ONLINE_FLAG) { if (thisDetector->receiverOnlineFlag==ONLINE_FLAG) {
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum2, NULL, 0, &retval, sizeof(retval)); ret=thisReceiver->Client_Send(fnum, NULL, 0, &retval, sizeof(retval));
disconnectData(); disconnectData();
} }
if(ret==FORCE_UPDATE) // handle ret
ret=updateReceiver(); if (ret == FAIL)
setErrorMask((getErrorMask())|(OTHER_ERROR_CODE));
else if(ret == FORCE_UPDATE)
ret = updateReceiver();
} }
} else { }
// detector versions
else {
if (thisDetector->onlineFlag==ONLINE_FLAG) { if (thisDetector->onlineFlag==ONLINE_FLAG) {
if (connectControl() != OK) if (connectControl() == OK){
ret = FAIL; ret = thisDetectorControl->Client_Send(fnum,
else{ &arg, sizeof(arg), &retval, sizeof(retval));
controlSocket->SendDataOnly(&fnum,sizeof(fnum));
controlSocket->SendDataOnly(&mode,sizeof(mode));
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret!=FAIL)
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
else {
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
std::cout<< "Detector returned error: " << mess << std::endl;
}
disconnectControl(); disconnectControl();
if (ret==FORCE_UPDATE) // handle ret
if (ret == FAIL)
setErrorMask((getErrorMask())|(OTHER_ERROR_CODE));
else if (ret == FORCE_UPDATE)
updateDetector(); updateDetector();
} }
} }
} }
if (ret==FAIL) {
std::cout<< "Get id failed " << std::endl; if (ret != FAIL) {
return ret; FILE_LOG(logDEBUG5) << "Id ("<< mode << "): 0x" << std::hex << retval << std::setbase(10);
} else {
#ifdef VERBOSE
std::cout<< "Id "<< mode <<" is " << hex <<retval << std::setbase(10)
<< std::endl;
#endif
return retval;
} }
return retval;
} }
@ -583,10 +590,20 @@ void slsDetector::initializeMembers() {
chanregs = (int*)(goff + thisDetector->chanoff); chanregs = (int*)(goff + thisDetector->chanoff);
gain = (int*)(goff + thisDetector->gainoff); gain = (int*)(goff + thisDetector->gainoff);
offset = (int*)(goff + thisDetector->offsetoff); offset = (int*)(goff + thisDetector->offsetoff);
if (thisDetectorControl) {
delete thisDetectorControl;
thisDetectorControl = 0;
}
if (thisDetectorStop) {
delete thisDetectorStop;
thisDetectorStop = 0;
}
if (thisReceiver) { if (thisReceiver) {
delete thisReceiver; delete thisReceiver;
thisReceiver = 0; thisReceiver = 0;
} }
thisDetectorControl = new ClientInterface(controlSocket, detId, "Detector (Control server)");
thisDetectorStop = new ClientInterface(stopSocket, detId, "Detector (Stop server)");
thisReceiver = new ClientInterface(dataSocket, detId, "Receiver"); thisReceiver = new ClientInterface(dataSocket, detId, "Receiver");
} }
@ -853,43 +870,32 @@ slsDetectorDefs::detectorType slsDetector::getDetectorTypeFromShm(int multiId, b
return type; return type;
} }
// static function
slsDetectorDefs::detectorType slsDetector::getDetectorType(const char *name, int cport) { slsDetectorDefs::detectorType slsDetector::getDetectorType(const char *name, int cport) {
int fnum=F_GET_DETECTOR_TYPE; int fnum = F_GET_DETECTOR_TYPE;
int retval = FAIL; detectorType retval = GENERIC;
detectorType t = GENERIC;
MySocketTCP* mySocket = 0; MySocketTCP* mySocket = 0;
try { try {
mySocket = new MySocketTCP(name, cport); mySocket = new MySocketTCP(name, cport);
} catch(...) { } catch(...) {
std::cout << "Cannot create socket to server " << name << " over port " << cport << std::endl; FILE_LOG(logERROR) << "Cannot create socket to control server " << name << " over port " << cport;
return t; return retval;
} }
FILE_LOG(logINFO) << "Getting detector type ";
#ifdef VERBOSE
std::cout << "Getting detector type " << std::endl;
#endif
if (mySocket->Connect() >= 0) { if (mySocket->Connect() >= 0) {
mySocket->SendDataOnly(&fnum,sizeof(fnum)); mySocket->SendDataOnly(&fnum,sizeof(fnum));
int ret = FAIL; // not needed but is in protocol from server
mySocket->ReceiveDataOnly(&ret,sizeof(ret));
mySocket->ReceiveDataOnly(&retval,sizeof(retval)); mySocket->ReceiveDataOnly(&retval,sizeof(retval));
if (retval!=FAIL) { FILE_LOG(logDEBUG5) << "Detector type is " << retval;
mySocket->ReceiveDataOnly(&t,sizeof(t));
#ifdef VERBOSE
std::cout << "Detector type is "<< t << std::endl;
#endif
} else {
char mess[MAX_STR_LENGTH];
mySocket->ReceiveDataOnly(mess,sizeof(mess));
std::cout<< "Detector returned error: " << mess << std::endl;
}
mySocket->Disconnect(); mySocket->Disconnect();
} else { } else {
std::cout << "Cannot connect to server " << name << " over port " << cport << std::endl; FILE_LOG(logERROR) << "Cannot connect to server " << name << " over port " << cport;
} }
delete mySocket; delete mySocket;
return t; return retval;
} }
@ -897,8 +903,6 @@ int slsDetector::setDetectorType(detectorType const type) {
int ret=FAIL; int ret=FAIL;
int fnum=F_GET_DETECTOR_TYPE,fnum2=F_GET_RECEIVER_TYPE; int fnum=F_GET_DETECTOR_TYPE,fnum2=F_GET_RECEIVER_TYPE;
detectorType retval = type; detectorType retval = type;
char mess[MAX_STR_LENGTH];
memset(mess, 0, MAX_STR_LENGTH);
if (type != GET_DETECTOR_TYPE) { if (type != GET_DETECTOR_TYPE) {
#ifdef VERBOSE #ifdef VERBOSE
@ -1217,7 +1221,8 @@ int slsDetector::setTCPSocket(std::string const name, int const control_port, in
if (retval!=FAIL) { if (retval!=FAIL) {
checkOnline(); checkOnline();
thisDetectorControl->SetSocket(controlSocket);
thisDetectorStop->SetSocket(stopSocket);
// check for version compatibility // check for version compatibility
switch (thisDetector->myDetectorType) { switch (thisDetector->myDetectorType) {
case EIGER: case EIGER:
@ -1352,16 +1357,15 @@ int slsDetector::setPort(portType index, int num) {
if(s==dataSocket) if(s==dataSocket)
fnum = fnum2; fnum = fnum2;
s->SendDataOnly(&fnum,sizeof(fnum)); s->SendDataOnly(&fnum,sizeof(fnum));
s->SendDataOnly(&index,sizeof(index));
s->SendDataOnly(&num,sizeof(num)); s->SendDataOnly(&num,sizeof(num));
s->ReceiveDataOnly(&ret,sizeof(ret)); s->ReceiveDataOnly(&ret,sizeof(ret));
if (ret==FAIL) { if (ret==FAIL) {
char mess[MAX_STR_LENGTH]=""; char mess[MAX_STR_LENGTH]="";
s->ReceiveDataOnly(mess,sizeof(mess)); s->ReceiveDataOnly(mess,sizeof(mess));
std::cout<< "Detector returned error: " << mess << std::endl; std::cout<< "Detector returned error: " << mess << std::endl;
} else {
s->ReceiveDataOnly(&retval,sizeof(retval));
} }
s->ReceiveDataOnly(&retval,sizeof(retval));
s->Disconnect(); s->Disconnect();
}else{ }else{
if (index == CONTROL_PORT){ if (index == CONTROL_PORT){
@ -1539,24 +1543,23 @@ int slsDetector::exitServer() {
int slsDetector::execCommand(std::string cmd) { int slsDetector::execCommand(std::string cmd) {
int fnum = F_EXEC_COMMAND;
int ret = FAIL;
char arg[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH] = {0};
char arg[MAX_STR_LENGTH]="", retval[MAX_STR_LENGTH]="";
int fnum=F_EXEC_COMMAND;
int ret=FAIL;
strcpy(arg,cmd.c_str()); strcpy(arg,cmd.c_str());
FILE_LOG(logDEBUG5) << "Sending command to detector " << arg;
#ifdef VERBOSE
std::cout<< std::endl;
std::cout<< "Sending command " << arg << std::endl;
#endif
if (thisDetector->onlineFlag==ONLINE_FLAG) { if (thisDetector->onlineFlag==ONLINE_FLAG) {
if (connectControl() == OK){ if (connectControl() == OK){
controlSocket->SendDataOnly(&fnum,sizeof(fnum)); ret = thisDetectorControl->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
controlSocket->SendDataOnly(arg,MAX_STR_LENGTH);
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
controlSocket->ReceiveDataOnly(retval,MAX_STR_LENGTH);
std::cout << "Detector returned:" << retval << std::endl;
disconnectControl(); disconnectControl();
// handle ret
if (ret == FAIL)
setErrorMask((getErrorMask())|(OTHER_ERROR_CODE));
else
FILE_LOG(logINFO) << "Detector " << detId << " returned:\n" << retval;
} }
} }
return ret; return ret;
@ -1840,8 +1843,7 @@ slsDetectorDefs::detectorSettings slsDetector::setSettings( detectorSettings ise
slsDetectorDefs::detectorSettings slsDetector::sendSettingsOnly(detectorSettings isettings) { slsDetectorDefs::detectorSettings slsDetector::sendSettingsOnly(detectorSettings isettings) {
int fnum = F_SET_SETTINGS; int fnum = F_SET_SETTINGS;
int ret = FAIL; int ret = FAIL;
char mess[MAX_STR_LENGTH]; char mess[MAX_STR_LENGTH] = {0};
memset(mess, 0, MAX_STR_LENGTH);
int retval = -1; int retval = -1;
int arg = isettings; int arg = isettings;
#ifdef VERBOSE #ifdef VERBOSE
@ -2417,7 +2419,7 @@ int slsDetector::configureMAC() {
int ret=FAIL; int ret=FAIL;
int fnum=F_CONFIGURE_MAC; int fnum=F_CONFIGURE_MAC;
char mess[MAX_STR_LENGTH]=""; char mess[MAX_STR_LENGTH]="";
char arg[6][50];memset(arg,0,sizeof(char)*6*50); char arg[6][50] = {0};
int retval=-1; int retval=-1;
// to send 3d positions to detector // to send 3d positions to detector
@ -2572,8 +2574,7 @@ int slsDetector::configureMAC() {
controlSocket->ReceiveDataOnly(&retval,sizeof(retval)); controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
if (thisDetector->myDetectorType == EIGER) { if (thisDetector->myDetectorType == EIGER) {
//rewrite detectormac, detector ip //rewrite detectormac, detector ip
char arg[2][50]; char arg[2][50] = {0};
memset(arg,0,sizeof(arg));
uint64_t idetectormac = 0; uint64_t idetectormac = 0;
uint32_t idetectorip = 0; uint32_t idetectorip = 0;
controlSocket->ReceiveDataOnly(arg,sizeof(arg)); controlSocket->ReceiveDataOnly(arg,sizeof(arg));
@ -3058,41 +3059,23 @@ int slsDetector::getADC(dacIndex index) {
slsDetectorDefs::externalCommunicationMode slsDetector::setExternalCommunicationMode( slsDetectorDefs::externalCommunicationMode slsDetector::setExternalCommunicationMode(
externalCommunicationMode pol) { externalCommunicationMode pol) {
int fnum = F_SET_EXTERNAL_COMMUNICATION_MODE;
int ret = FAIL;
int arg = pol; int arg = pol;
externalCommunicationMode retval = GET_EXTERNAL_COMMUNICATION_MODE;; externalCommunicationMode retval = GET_EXTERNAL_COMMUNICATION_MODE;;
int fnum=F_SET_EXTERNAL_COMMUNICATION_MODE;
int ret=FAIL;
FILE_LOG(logDEBUG5) << "Setting communication to mode "<< pol;
#ifdef VERBOSE
std::cout<< std::endl;
std::cout<< "Setting communication to mode " << pol << std::endl;
#endif
if (thisDetector->onlineFlag==ONLINE_FLAG) { if (thisDetector->onlineFlag==ONLINE_FLAG) {
if (connectControl() == OK){ if (connectControl() == OK){
controlSocket->SendDataOnly(&fnum,sizeof(fnum)); ret = thisDetectorControl->Client_Send(fnum, &arg, sizeof(arg), &retval, sizeof(retval));
controlSocket->SendDataOnly(&arg,sizeof(arg));
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret!=FAIL)
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
else {
char mess[MAX_STR_LENGTH]="";
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
std::cout<< "Detector returned error: " << mess << std::endl;
}
disconnectControl(); disconnectControl();
if (ret==FORCE_UPDATE) // handle ret
if (ret == FAIL)
setErrorMask((getErrorMask())|(OTHER_ERROR_CODE));
else if (ret == FORCE_UPDATE)
updateDetector(); updateDetector();
} }
} else {
retval=GET_EXTERNAL_COMMUNICATION_MODE;
ret=FAIL;
}
#ifdef VERBOSE
std::cout<< "Communication mode "<< " set to" << retval << std::endl;
#endif
if (ret==FAIL) {
std::cout<< "Setting communication mode failed" << std::endl;
} }
return retval; return retval;
} }
@ -3101,57 +3084,25 @@ slsDetectorDefs::externalCommunicationMode slsDetector::setExternalCommunication
slsDetectorDefs::externalSignalFlag slsDetector::setExternalSignalFlags( slsDetectorDefs::externalSignalFlag slsDetector::setExternalSignalFlags(
externalSignalFlag pol, int signalindex) { externalSignalFlag pol, int signalindex) {
int fnum = F_SET_EXTERNAL_SIGNAL_FLAG;
int ret = FAIL;
int arg[2] = {signalindex, pol};
externalSignalFlag retval = GET_EXTERNAL_SIGNAL_FLAG;
FILE_LOG(logDEBUG5) << "Setting signal "<< signalindex << " to flag" << pol;
int arg[2];
externalSignalFlag retval;
int ret=FAIL;
int fnum=F_SET_EXTERNAL_SIGNAL_FLAG;
char mess[MAX_STR_LENGTH]="";
arg[0]=signalindex;
arg[1]=pol;
retval=GET_EXTERNAL_SIGNAL_FLAG;
#ifdef VERBOSE
std::cout<< std::endl;
std::cout<< "Setting signal "<< signalindex << " to flag" << pol << std::endl;
#endif
if (thisDetector->onlineFlag==ONLINE_FLAG) { if (thisDetector->onlineFlag==ONLINE_FLAG) {
if (connectControl() == OK){ if (connectControl() == OK){
controlSocket->SendDataOnly(&fnum,sizeof(fnum)); ret = thisDetectorControl->Client_Send(fnum, arg, sizeof(arg), &retval, sizeof(retval));
controlSocket->SendDataOnly(&arg,sizeof(arg));
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret!=FAIL)
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
else {
controlSocket->ReceiveDataOnly(mess,sizeof(mess));
std::cout<< "Detector returned error: " << mess << std::endl;
}
disconnectControl(); disconnectControl();
if (ret==FORCE_UPDATE) // handle ret
if (ret == FAIL)
setErrorMask((getErrorMask())|(OTHER_ERROR_CODE));
else if (ret == FORCE_UPDATE)
updateDetector(); updateDetector();
} }
} else {
retval=GET_EXTERNAL_SIGNAL_FLAG;
ret=FAIL;
} }
#ifdef VERBOSE
std::cout<< "Signal "<< signalindex << " flag set to" << retval << std::endl;
if (ret==FAIL) {
std::cout<< "Set signal flag failed " << std::endl;
}
#endif
return retval; return retval;
} }
@ -3833,10 +3784,8 @@ std::string slsDetector::setReceiverStreamingIP(std::string sourceIP) {
int fnum=F_RECEIVER_STREAMING_SRC_IP; int fnum=F_RECEIVER_STREAMING_SRC_IP;
int ret = FAIL; int ret = FAIL;
char arg[MAX_STR_LENGTH]; char arg[MAX_STR_LENGTH] = {0};
memset(arg,0,sizeof(arg)); char retval[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH];
memset(retval,0, sizeof(retval));
// if empty, give rx_hostname // if empty, give rx_hostname
if (sourceIP.empty()) { if (sourceIP.empty()) {
@ -3861,7 +3810,7 @@ std::string slsDetector::setReceiverStreamingIP(std::string sourceIP) {
} }
// on success put IP as std::string into arg // on success put IP as std::string into arg
else { else {
dataSocket->ConvertInternetAddresstoIpString(result, arg, MAX_STR_LENGTH); dataSocket->ConvertInternetAddresstoIpString(result, arg, sizeof(arg));
} }
} }
@ -3881,7 +3830,7 @@ std::string slsDetector::setReceiverStreamingIP(std::string sourceIP) {
std::endl; std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, arg, MAX_STR_LENGTH, retval, MAX_STR_LENGTH); ret=thisReceiver->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
disconnectData(); disconnectData();
} }
if(ret==FAIL) { if(ret==FAIL) {
@ -3901,10 +3850,8 @@ std::string slsDetector::setAdditionalJsonHeader(std::string jsonheader) {
int fnum=F_ADDITIONAL_JSON_HEADER; int fnum=F_ADDITIONAL_JSON_HEADER;
int ret = FAIL; int ret = FAIL;
char arg[MAX_STR_LENGTH]; char arg[MAX_STR_LENGTH] = {0};
memset(arg,0,sizeof(arg)); char retval[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH];
memset(retval,0, sizeof(retval));
strcpy(arg, jsonheader.c_str()); strcpy(arg, jsonheader.c_str());
@ -3913,7 +3860,7 @@ std::string slsDetector::setAdditionalJsonHeader(std::string jsonheader) {
std::cout << "Sending additional json header " << arg << std::endl; std::cout << "Sending additional json header " << arg << std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, arg, MAX_STR_LENGTH, retval, MAX_STR_LENGTH); ret=thisReceiver->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
disconnectData(); disconnectData();
} }
if(ret==FAIL) { if(ret==FAIL) {
@ -4003,10 +3950,8 @@ int slsDetector::setUDPConnection() {
int ret = FAIL; int ret = FAIL;
int fnum = F_SETUP_RECEIVER_UDP; int fnum = F_SETUP_RECEIVER_UDP;
char args[3][MAX_STR_LENGTH]; char args[3][MAX_STR_LENGTH] = {0};
memset(args,0,sizeof(args)); char retval[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH];
memset(retval,0,sizeof(retval));
//called before set up //called before set up
if(!strcmp(thisDetector->receiver_hostname,"none")){ if(!strcmp(thisDetector->receiver_hostname,"none")){
@ -4961,8 +4906,7 @@ int slsDetector::setTemperatureEvent(int val) {
int slsDetector::setStoragecellStart(int pos) { int slsDetector::setStoragecellStart(int pos) {
int ret=FAIL; int ret=FAIL;
int fnum=F_STORAGE_CELL_START; int fnum=F_STORAGE_CELL_START;
char mess[MAX_STR_LENGTH]; char mess[MAX_STR_LENGTH] = {0};
memset(mess, 0, MAX_STR_LENGTH);
int retval=-1; int retval=-1;
#ifdef VERBOSE #ifdef VERBOSE
@ -5929,24 +5873,22 @@ int slsDetector::exitReceiver() {
} }
int slsDetector::execReceiverCommand(std::string cmd) { int slsDetector::execReceiverCommand(std::string cmd) {
int fnum = F_EXEC_RECEIVER_COMMAND;
int fnum=F_EXEC_RECEIVER_COMMAND; int ret = FAIL;
int ret=FAIL; char arg[MAX_STR_LENGTH] = {0};
char arg[MAX_STR_LENGTH]; char retval[MAX_STR_LENGTH] = {0};
memset(arg,0,sizeof(arg));
char retval[MAX_STR_LENGTH];
memset(retval,0, sizeof(retval));
strcpy(arg,cmd.c_str()); strcpy(arg,cmd.c_str());
FILE_LOG(logDEBUG5) << "Sending command to receiver " << arg;
if (thisDetector->receiverOnlineFlag==ONLINE_FLAG) { if (thisDetector->receiverOnlineFlag==ONLINE_FLAG) {
#ifdef VERBOSE
std::cout << "Sending to receiver the command: " << arg << std::endl;
#endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, arg, MAX_STR_LENGTH, retval, MAX_STR_LENGTH); ret=thisReceiver->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
disconnectData(); disconnectData();
} }
if (ret != FAIL) {
FILE_LOG(logINFO) << "Receiver " << detId << " returned:\n" << retval;
}
} }
return ret; return ret;
} }
@ -6157,26 +6099,27 @@ std::string slsDetector::setFilePath(std::string s) {
char retval[MAX_STR_LENGTH] = ""; char retval[MAX_STR_LENGTH] = "";
strcpy(arg,s.c_str()); strcpy(arg,s.c_str());
if(thisDetector->receiverOnlineFlag==ONLINE_FLAG){
#ifdef VERBOSE #ifdef VERBOSE
std::cout << "Sending file path to receiver " << arg << std::endl; std::cout << "Sending file path to receiver " << arg << std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, arg, MAX_STR_LENGTH, retval, MAX_STR_LENGTH); ret=thisReceiver->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
disconnectData(); disconnectData();
}
if(ret!=FAIL){
strcpy(thisDetector->receiver_filePath,retval);
}
else {
if(!s.empty()){
std::cout << "file path does not exist" << std::endl;
setErrorMask((getErrorMask())|(FILE_PATH_DOES_NOT_EXIST));
} else
setErrorMask((getErrorMask())|(RECEIVER_PARAMETER_NOT_SET));
}
if(ret==FORCE_UPDATE)
updateReceiver();
} }
if(ret!=FAIL){
strcpy(thisDetector->receiver_filePath,retval);
}
else {
if(!s.empty()){
std::cout << "file path does not exist" << std::endl;
setErrorMask((getErrorMask())|(FILE_PATH_DOES_NOT_EXIST));
} else
setErrorMask((getErrorMask())|(RECEIVER_PARAMETER_NOT_SET));
}
if(ret==FORCE_UPDATE)
updateReceiver();
return getFilePath(); return getFilePath();
} }
@ -6202,7 +6145,7 @@ std::string slsDetector::setFileName(std::string s) {
std::cout << "Sending file name to receiver " << arg << std::endl; std::cout << "Sending file name to receiver " << arg << std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, arg, MAX_STR_LENGTH, retval, MAX_STR_LENGTH); ret=thisReceiver->Client_Send(fnum, arg, sizeof(arg), retval, sizeof(retval));
disconnectData(); disconnectData();
} }
if (ret == FAIL) if (ret == FAIL)
@ -6309,20 +6252,21 @@ slsDetectorDefs::fileFormat slsDetector::setFileFormat(fileFormat f) {
int ret = FAIL; int ret = FAIL;
int arg = f; int arg = f;
int retval = -1; int retval = -1;
if(thisDetector->receiverOnlineFlag==ONLINE_FLAG){
#ifdef VERBOSE #ifdef VERBOSE
std::cout << "Sending file format to receiver " << arg << std::endl; std::cout << "Sending file format to receiver " << arg << std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, &arg, sizeof(arg), &retval, sizeof(retval)); ret=thisReceiver->Client_Send(fnum, &arg, sizeof(arg), &retval, sizeof(retval));
disconnectData(); disconnectData();
}
if (ret == FAIL)
setErrorMask((getErrorMask())|(RECEIVER_FILE_FORMAT));
else
thisDetector->receiver_fileFormatType = (fileFormat)retval;
if(ret==FORCE_UPDATE)
updateReceiver();
} }
if (ret == FAIL)
setErrorMask((getErrorMask())|(RECEIVER_FILE_FORMAT));
else
thisDetector->receiver_fileFormatType = (fileFormat)retval;
if(ret==FORCE_UPDATE)
updateReceiver();
return getFileFormat(); return getFileFormat();
} }
@ -6346,21 +6290,21 @@ int slsDetector::setFileIndex(int i) {
int retval=-1; int retval=-1;
int arg = i; int arg = i;
if(thisDetector->receiverOnlineFlag==ONLINE_FLAG) {
#ifdef VERBOSE #ifdef VERBOSE
std::cout << "Sending file index to receiver " << arg << std::endl; std::cout << "Sending file index to receiver " << arg << std::endl;
#endif #endif
if (connectData() == OK){ if (connectData() == OK){
ret=thisReceiver->Client_Send(fnum, &arg, sizeof(arg), &retval, sizeof(retval)); ret=thisReceiver->Client_Send(fnum, &arg, sizeof(arg), &retval, sizeof(retval));
disconnectData(); disconnectData();
}
if (ret == FAIL)
setErrorMask((getErrorMask())|(RECEIVER_PARAMETER_NOT_SET));
else
thisDetector->receiver_fileIndex = retval;
if(ret==FORCE_UPDATE)
updateReceiver();
} }
if (ret == FAIL)
setErrorMask((getErrorMask())|(RECEIVER_PARAMETER_NOT_SET));
else
thisDetector->receiver_fileIndex = retval;
if(ret==FORCE_UPDATE)
updateReceiver();
return getFileIndex(); return getFileIndex();
} }
@ -7055,110 +6999,6 @@ int slsDetector::setCTBPatWaitTime(int level, uint64_t t) {
int slsDetector::readCalibrationFile(std::string fname, double &gain, double &offset) {
std::string str;
std::ifstream infile;
#ifdef VERBOSE
std::cout<< "Opening file "<< fname << std::endl;
#endif
infile.open(fname.c_str(), std::ios_base::in);
if (infile.is_open()) {
getline(infile,str);
#ifdef VERBOSE
std::cout<< str << std::endl;
#endif
std::istringstream ssstr(str);
ssstr >> offset >> gain;
infile.close();
std::cout << "Calibration file loaded: " << fname << std::endl;
} else {
std::cout<< "Could not open calibration file "<< fname << std::endl;
gain=0.;
offset=0.;
return FAIL;
}
return OK;
}
int slsDetector::writeCalibrationFile(std::string fname, double gain, double offset) {
std::ofstream outfile;
outfile.open (fname.c_str());
if (outfile.is_open()) {
outfile << offset << " " << gain << std::endl;
} else {
std::cout<< "Could not open calibration file "<< fname << " for writing" << std::endl;
return FAIL;
}
outfile.close();
return OK;
}
int slsDetector::readCalibrationFile(std::string fname, int *gain, int *offset) {
std::string str;
std::ifstream infile;
double o,g;
int ig=0;
#ifdef VERBOSE
std::cout<< "Opening file "<< fname << std::endl;
#endif
infile.open(fname.c_str(), std::ios_base::in);
if (infile.is_open()) {
//get gain and offset
for (ig=0; ig<4; ig++) {
//while ( (getline(infile,str)) > -1) {
getline(infile,str);
#ifdef VERBOSE
std::cout<< str << std::endl;
#endif
std::istringstream ssstr(str);
ssstr >> o >> g;
offset[ig]=(int)(o*1000);
gain[ig]=(int)(g*1000);
// ig++;
if (ig>=4)
break;
}
infile.close();
std::cout << "Calibration file loaded: " << fname << std::endl;
} else {
std::cout << "Could not open calibration file: "<< fname << std::endl;
gain[0]=0;
offset[0]=0;
return FAIL;
}
return OK;
}
int slsDetector::writeCalibrationFile(std::string fname, int *gain, int *offset){
std::ofstream outfile;
outfile.open (fname.c_str());
if (outfile.is_open()) {
for (int ig=0; ig<4; ig++)
outfile << ((double)offset[ig]/1000) << " " << ((double)gain[ig]/1000) << std::endl;
} else {
std::cout<< "Could not open calibration file "<< fname << " for writing" << std::endl;
return FAIL;
}
outfile.close();
return OK;
}
slsDetectorDefs::sls_detector_module* slsDetector::interpolateTrim( slsDetectorDefs::sls_detector_module* slsDetector::interpolateTrim(
sls_detector_module* a, sls_detector_module* b, sls_detector_module* a, sls_detector_module* b,
const int energy, const int e1, const int e2, int tb) { const int energy, const int e1, const int e2, int tb) {

42
slsDetectorSoftware/slsDetector/slsDetector.h
View File

@ -1796,42 +1796,6 @@ private:
*/ */
int setUDPConnection(); int setUDPConnection();
/**
* reads a calibration file
* @param fname file to be read
* @param gain reference to the gain variable
* @param offset reference to the offset variable
* @returns OK if successful, else FAIL or -1
*/
static int readCalibrationFile(std::string fname, double &gain, double &offset);
/**
* writes a calibration file
* @param fname file to be written
* @param gain
* @param offset
* @returns OK if successful, else FAIL or -1
*/
static int writeCalibrationFile(std::string fname, double gain, double offset);
/**
* reads a calibration file
* @param fname file to be read
* @param gain reference to the gain variable
* @param offset reference to the offset variable
* @returns OK if successful, else FAIL or -1
*/
static int readCalibrationFile(std::string fname, int *gain, int *offset);
/**
* writes a calibration file
* @param fname file to be written
* @param gain reference to the gain variable
* @param offset reference to the offset variable
* @returns OK if successful, else FAIL or -1
*/
static int writeCalibrationFile(std::string fname, int *gain, int *offset);
/* /*
* Template function to do linear interpolation between two points (Eiger only) * Template function to do linear interpolation between two points (Eiger only)
*/ */
@ -1893,6 +1857,12 @@ private:
/** Shared memory structure */ /** Shared memory structure */
sharedSlsDetector *thisDetector; sharedSlsDetector *thisDetector;
/** control socket interface */
ClientInterface *thisDetectorControl;
/** stop socket interface */
ClientInterface *thisDetectorStop;
/** receiver interface */ /** receiver interface */
ClientInterface *thisReceiver; ClientInterface *thisReceiver;

27
slsReceiverSoftware/include/GeneralData.h
View File

@ -396,33 +396,6 @@ private:
}; };
class PropixData : public GeneralData {
private:
/**bytes per pixel for calculating image size */
const static uint32_t bytesPerPixel = 2;
public:
/** Constructor */
PropixData(){
myDetectorType = slsDetectorDefs::PROPIX;
nPixelsX = 22;
nPixelsY = 22;
headerSizeinPacket = 4;
dataSize = 1280;
packetSize = 1286;
packetsPerFrame = 2; //not really
imageSize = nPixelsX*nPixelsY*bytesPerPixel;
frameIndexMask = 0xFFFFFFFE;
frameIndexOffset = 1;
packetIndexMask = 1;
maxFramesPerFile = MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize= FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 50000;
};
};
class Moench02Data : public GeneralData { class Moench02Data : public GeneralData {

4
slsReceiverSoftware/src/slsReceiverImplementation.cpp
View File

@ -897,8 +897,6 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
myDetectorType = d; myDetectorType = d;
switch(myDetectorType) { switch(myDetectorType) {
case GOTTHARD: case GOTTHARD:
case PROPIX:
case MOENCH:
case EIGER: case EIGER:
case JUNGFRAUCTB: case JUNGFRAUCTB:
case JUNGFRAU: case JUNGFRAU:
@ -913,8 +911,6 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
//set detector specific variables //set detector specific variables
switch(myDetectorType) { switch(myDetectorType) {
case GOTTHARD: generalData = new GotthardData(); break; case GOTTHARD: generalData = new GotthardData(); break;
case PROPIX: generalData = new PropixData(); break;
case MOENCH: generalData = new Moench02Data(); break;
case EIGER: generalData = new EigerData(); break; case EIGER: generalData = new EigerData(); break;
case JUNGFRAUCTB: generalData = new JCTBData(); break; case JUNGFRAUCTB: generalData = new JCTBData(); break;
case JUNGFRAU: generalData = new JungfrauData(); break; case JUNGFRAU: generalData = new JungfrauData(); break;

78
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

@ -20,8 +20,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <syscall.h> #include <syscall.h>
#include <vector> #include <vector>
#include <array>
#include <memory> //unique_ptr
slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() {
stop(); stop();
@ -241,31 +241,28 @@ int slsReceiverTCPIPInterface::function_table(){
int slsReceiverTCPIPInterface::decode_function(){ int slsReceiverTCPIPInterface::decode_function(){
ret = FAIL; ret = FAIL;
FILE_LOG(logDEBUG1) << "waiting to receive data";
int n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum)); int n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum));
if (n <= 0) { if (n <= 0) {
FILE_LOG(logDEBUG1) << "ERROR reading from socket. " FILE_LOG(logDEBUG5) << "Could not read socket. "
"Received " << n << " bytes," << "Received " << n << " bytes," <<
"fnum:" << fnum << " " "fnum:" << fnum << " "
"(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ")";
return FAIL; return FAIL;
} }
else else
FILE_LOG(logDEBUG1) << "Received " << n << " bytes"; FILE_LOG(logDEBUG5) << "Received " << n << " bytes";
if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) { if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) {
FILE_LOG(logERROR) << "Unknown function enum " << fnum; FILE_LOG(logERROR) << "Unknown function enum " << fnum;
ret = (this->M_nofunc)(); ret = (this->M_nofunc)();
} else{ } else{
FILE_LOG(logDEBUG1) << "calling function fnum: "<< fnum << " " FILE_LOG(logDEBUG5) << "calling function fnum: "<< fnum << " "
"(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ") " "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ") "
"located at " << flist[fnum]; "located at " << flist[fnum];
ret = (this->*flist[fnum])(); ret = (this->*flist[fnum])();
if (ret == FAIL) { if (ret == FAIL) {
FILE_LOG(logERROR) << "Failed to execute function = " << fnum << " (" FILE_LOG(logDEBUG5) << "Failed to execute function = " << fnum << " ("
<< getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; << getFunctionNameFromEnum((enum detFuncs)fnum) << ")";
} }
} }
@ -281,7 +278,7 @@ void slsReceiverTCPIPInterface::functionNotImplemented() {
} }
int slsReceiverTCPIPInterface::M_nofunc(){printf("111 \n"); int slsReceiverTCPIPInterface::M_nofunc(){
ret = FAIL; ret = FAIL;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
int n = 0; int n = 0;
@ -302,9 +299,10 @@ int slsReceiverTCPIPInterface::M_nofunc(){printf("111 \n");
int slsReceiverTCPIPInterface::exec_command() { int slsReceiverTCPIPInterface::exec_command() {
ret = FAIL;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char cmd[MAX_STR_LENGTH]; char cmd[MAX_STR_LENGTH] = {0};
memset(cmd,0,sizeof(cmd)); char retval[MAX_STR_LENGTH] = {0};
// get args, return if socket crashed // get args, return if socket crashed
if (interface->Server_ReceiveArg(ret, mess, cmd, MAX_STR_LENGTH) == FAIL) if (interface->Server_ReceiveArg(ret, mess, cmd, MAX_STR_LENGTH) == FAIL)
@ -312,14 +310,26 @@ int slsReceiverTCPIPInterface::exec_command() {
// verify if receiver is unlocked // verify if receiver is unlocked
if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) {
ret = (system(cmd) == 0) ? OK : FAIL;
if(ret == FAIL) { const size_t tempsize = 256;
std::array<char, tempsize> temp;
std::string sresult;
std::shared_ptr<FILE> pipe(popen(cmd, "r"), pclose);
if (!pipe) {
ret = FAIL;
strcpy(mess, "Executing Command failed\n"); strcpy(mess, "Executing Command failed\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
} else {
while (!feof(pipe.get())) {
if (fgets(temp.data(), tempsize, pipe.get()) != NULL)
sresult += temp.data();
}
strncpy(retval, sresult.c_str(), MAX_STR_LENGTH);
ret = OK;
} }
} }
interface->Server_SendResult(false, ret, NULL, 0, mess); interface->Server_SendResult(false, ret, retval, MAX_STR_LENGTH, mess);
return ret; return ret;
} }
@ -378,17 +388,13 @@ int slsReceiverTCPIPInterface::get_last_client_ip() {
int slsReceiverTCPIPInterface::set_port() { int slsReceiverTCPIPInterface::set_port() {
ret = OK; ret = OK;
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
int p_type = 0;
int p_number = -1; int p_number = -1;
MySocketTCP* mySocket = 0; MySocketTCP* mySocket = 0;
char oldLastClientIP[INET_ADDRSTRLEN]; char oldLastClientIP[INET_ADDRSTRLEN] = {0};
memset(oldLastClientIP, 0, sizeof(oldLastClientIP));
// receive arguments // get args, return if socket crashed
if (mySock->ReceiveDataOnly(&p_type,sizeof(p_type)) < 0 ) if (interface->Server_ReceiveArg(ret, mess, &p_number, sizeof(p_number)) == FAIL)
return interface->Server_SocketCrash(); return FAIL;
if (mySock->ReceiveDataOnly(&p_number,sizeof(p_number)) < 0 )
return interface->Server_SocketCrash();
// verify if receiver is unlocked // verify if receiver is unlocked
if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) {
@ -450,8 +456,7 @@ int slsReceiverTCPIPInterface::update_client() {
int slsReceiverTCPIPInterface::send_update() { int slsReceiverTCPIPInterface::send_update() {
int ind = -1; int ind = -1;
char defaultVal[MAX_STR_LENGTH]; char defaultVal[MAX_STR_LENGTH] = {0};
memset(defaultVal, 0, sizeof(defaultVal));
char* path = NULL; char* path = NULL;
int n = 0; int n = 0;
@ -581,8 +586,6 @@ int slsReceiverTCPIPInterface::set_detector_type(){
if (ret == OK) { if (ret == OK) {
switch(dr) { switch(dr) {
case GOTTHARD: case GOTTHARD:
case PROPIX:
case MOENCH:
case EIGER: case EIGER:
case JUNGFRAUCTB: case JUNGFRAUCTB:
case JUNGFRAU: case JUNGFRAU:
@ -628,8 +631,7 @@ int slsReceiverTCPIPInterface::set_detector_type(){
int slsReceiverTCPIPInterface::set_detector_hostname() { int slsReceiverTCPIPInterface::set_detector_hostname() {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char hostname[MAX_STR_LENGTH]; char hostname[MAX_STR_LENGTH] = {0};
memset(hostname, 0, sizeof(hostname));
char* retval = NULL; char* retval = NULL;
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
@ -706,10 +708,8 @@ int slsReceiverTCPIPInterface::set_roi() {
int slsReceiverTCPIPInterface::setup_udp(){ int slsReceiverTCPIPInterface::setup_udp(){
char args[3][MAX_STR_LENGTH]; char args[3][MAX_STR_LENGTH] = {0};
memset(args,0,sizeof(args)); char retval[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH];
memset(retval,0,sizeof(retval));
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL) if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL)
@ -1062,8 +1062,7 @@ int slsReceiverTCPIPInterface::stop_receiver(){
int slsReceiverTCPIPInterface::set_file_dir() { int slsReceiverTCPIPInterface::set_file_dir() {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char fPath[MAX_STR_LENGTH]; char fPath[MAX_STR_LENGTH] = {0};
memset(fPath, 0, sizeof(fPath));
char* retval=NULL; char* retval=NULL;
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
@ -1100,8 +1099,7 @@ int slsReceiverTCPIPInterface::set_file_dir() {
int slsReceiverTCPIPInterface::set_file_name() { int slsReceiverTCPIPInterface::set_file_name() {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char fName[MAX_STR_LENGTH]; char fName[MAX_STR_LENGTH] = {0};
memset(fName, 0, sizeof(fName));
char* retval = NULL; char* retval = NULL;
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
@ -1672,8 +1670,7 @@ int slsReceiverTCPIPInterface::set_streaming_port() {
int slsReceiverTCPIPInterface::set_streaming_source_ip() { int slsReceiverTCPIPInterface::set_streaming_source_ip() {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char arg[MAX_STR_LENGTH]; char arg[MAX_STR_LENGTH] = {0};
memset(arg, 0, sizeof(arg));
char* retval=NULL; char* retval=NULL;
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null
@ -1813,8 +1810,7 @@ int slsReceiverTCPIPInterface::restream_stop(){
int slsReceiverTCPIPInterface::set_additional_json_header() { int slsReceiverTCPIPInterface::set_additional_json_header() {
memset(mess, 0, sizeof(mess)); memset(mess, 0, sizeof(mess));
char arg[MAX_STR_LENGTH]; char arg[MAX_STR_LENGTH] = {0};
memset(arg, 0, sizeof(arg));
char* retval=NULL; char* retval=NULL;
// get args, return if socket crashed, ret is fail if receiver is not null // get args, return if socket crashed, ret is fail if receiver is not null

43
slsSupportLib/include/ClientInterface.cpp
View File

@ -1,16 +1,6 @@
#include "ClientInterface.h" #include "ClientInterface.h"
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <bitset>
#include <cstdlib>
#include <iostream>
ClientInterface::ClientInterface(MySocketTCP *socket, int n, std::string t): ClientInterface::ClientInterface(MySocketTCP *socket, int n, std::string t):
mySocket(socket), mySocket(socket),
index(n), index(n),
@ -55,29 +45,7 @@ int ClientInterface::Client_Send(int fnum,
mySocket->ReceiveDataOnly(&ret,sizeof(ret)); mySocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret == FAIL) { if (ret == FAIL) {
if (Client_GetMesage(mess) == FAIL) if (Client_GetMesage(mess) == FAIL)
return FAIL; return FAIL;
}
mySocket->ReceiveDataOnly(retval, sizeOfRetval);
return ret;
}
int ClientInterface::Client_Send(int fnum,
void* args, int sizeOfArgs,
void* args2, int sizeOfArgs2,
void* retval, int sizeOfRetval,
char* mess) {
mySocket->SendDataOnly(&fnum,sizeof(fnum));
mySocket->SendDataOnly(args, sizeOfArgs);
mySocket->SendDataOnly(args2, sizeOfArgs2);
int ret = FAIL;
mySocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret == FAIL) {
if (Client_GetMesage(mess) == FAIL)
return FAIL;
} }
mySocket->ReceiveDataOnly(retval, sizeOfRetval); mySocket->ReceiveDataOnly(retval, sizeOfRetval);
@ -89,7 +57,7 @@ void ClientInterface::Server_SendResult(bool update, int ret,
void* retval, int retvalSize, char* mess) { void* retval, int retvalSize, char* mess) {
// update if different clients // update if different clients
if (update && mySocket->differentClients) if (update && ret == OK && mySocket->differentClients)
ret = FORCE_UPDATE; ret = FORCE_UPDATE;
// send success of operation // send success of operation
@ -143,7 +111,6 @@ int ClientInterface::Server_VerifyLockAndIdle(int& ret, char* mess, int lockstat
void ClientInterface::Server_NullObjectError(int& ret, char* mess) { void ClientInterface::Server_NullObjectError(int& ret, char* mess) {
// only for receiver
ret=FAIL; ret=FAIL;
strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n"); strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n");
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
@ -158,7 +125,7 @@ int ClientInterface::Server_SocketCrash() {
int ClientInterface::Server_LockedError(int& ret, char* mess) { int ClientInterface::Server_LockedError(int& ret, char* mess) {
ret = FAIL; ret = FAIL;
sprintf(mess,"%s locked by %s\n",type.c_str(), mySocket->lastClientIP); sprintf(mess,"Receiver locked by %s\n", mySocket->lastClientIP);
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
return ret; return ret;
} }
@ -166,8 +133,8 @@ int ClientInterface::Server_LockedError(int& ret, char* mess) {
int ClientInterface::Server_NotIdleError(int& ret, char* mess, int fnum) { int ClientInterface::Server_NotIdleError(int& ret, char* mess, int fnum) {
ret = FAIL; ret = FAIL;
sprintf(mess,"Can not execute %s when %s is not idle\n", sprintf(mess,"Can not execute %s when receiver is not idle\n",
getFunctionNameFromEnum((enum detFuncs)fnum), type.c_str()); getFunctionNameFromEnum((enum detFuncs)fnum));
FILE_LOG(logERROR) << mess; FILE_LOG(logERROR) << mess;
return ret; return ret;
} }

40
slsSupportLib/include/ClientInterface.h
View File

@ -57,24 +57,8 @@ public:
void* retval, int sizeOfRetval, void* retval, int sizeOfRetval,
char* mess = 0); char* mess = 0);
/**
* Send Arguments (second set) to server and get result back
* @param fnum function enum to determine what parameter
* @param args pointer to arguments
* @param sizeOfArgs argument size
* @param args2 pointer to arguments 2
* @param sizeOfArgs2 argument size 2
* @param retval pointer to return value
* @param sizeOfRetval return value size
* @param mess pointer to message if message required externally
*/
int Client_Send(int fnum,
void* args, int sizeOfArgs,
void* args2, int sizeOfArgs2,
void* retval, int sizeOfRetval,
char* mess = 0);
/** /** only Receiver
* Server sends result to client (also set ret to force_update if different clients) * Server sends result to client (also set ret to force_update if different clients)
* @param update true if one must update if different clients, else false * @param update true if one must update if different clients, else false
* @param ret success of operation * @param ret success of operation
@ -84,7 +68,7 @@ public:
*/ */
void Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0); void Server_SendResult(bool update, int ret, void* retval, int retvalSize, char* mess = 0);
/** /** only Receiver
* Server receives arguments and checks if base object is null (if checkbase is true) * Server receives arguments and checks if base object is null (if checkbase is true)
* checking base object is null (for reciever only when it has not been configured yet) * checking base object is null (for reciever only when it has not been configured yet)
* @param ret pointer to success of operation * @param ret pointer to success of operation
@ -97,8 +81,9 @@ public:
*/ */
int Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg,bool checkbase=false, void* base=NULL); int Server_ReceiveArg(int& ret, char* mess, void* arg, int sizeofArg,bool checkbase=false, void* base=NULL);
/** /** only Receiver
* Server verifies if it is locked, sets and prints appropriate message if it is * Server verifies if it is unlocked,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to sucess * @param ret pointer to sucess
* @param mess message * @param mess message
* @param lockstatus status of lock * @param lockstatus status of lock
@ -106,8 +91,9 @@ public:
*/ */
int Server_VerifyLock(int& ret, char* mess, int lockstatus); int Server_VerifyLock(int& ret, char* mess, int lockstatus);
/** /** only Receiver
* Server verifies if it is locked and idle, sets and prints appropriate message if it is * Server verifies if it is unlocked and idle,
* sets and prints appropriate message if it is locked and different clients
* @param ret pointer to sucess * @param ret pointer to sucess
* @param mess message * @param mess message
* @param lockstatus status of lock * @param lockstatus status of lock
@ -117,20 +103,20 @@ public:
*/ */
int Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum); int Server_VerifyLockAndIdle(int& ret, char* mess, int lockstatus, slsDetectorDefs::runStatus status, int fnum);
/** /** only Receiver
* Server sets and prints error message for null object error (receiver only) * Server sets and prints error message for null object error (receiver only)
* @param ret pointer to sucess that will be set to FAIL * @param ret pointer to sucess that will be set to FAIL
* @param mess message * @param mess message
*/ */
void Server_NullObjectError(int& ret, char* mess); void Server_NullObjectError(int& ret, char* mess);
/** /** only Receiver
* Servers prints error message for socket crash when reading * Servers prints error message for socket crash when reading
* @returns always FAIL * @returns always FAIL
*/ */
int Server_SocketCrash(); int Server_SocketCrash();
/** /** only Receiver
* Servers sets and prints error message for locked server * Servers sets and prints error message for locked server
* @param ret pointer to sucess that will be set to FAIL * @param ret pointer to sucess that will be set to FAIL
* @param mess message * @param mess message
@ -138,7 +124,7 @@ public:
*/ */
int Server_LockedError(int& ret, char* mess); int Server_LockedError(int& ret, char* mess);
/** /** only Receiver
* Servers sets and prints error message for server not being idle * Servers sets and prints error message for server not being idle
* @param ret pointer to sucess that will be set to FAIL * @param ret pointer to sucess that will be set to FAIL
* @param mess message * @param mess message
@ -154,7 +140,7 @@ private:
*/ */
MySocketTCP *mySocket; MySocketTCP *mySocket;
/** index for debugging purposes */ /** index for client debugging purposes */
int index; int index;
/** string for type to differentiate between Detector & Receiver in printouts */ /** string for type to differentiate between Detector & Receiver in printouts */

5
slsSupportLib/include/sls_detector_defs.h
View File

@ -81,11 +81,10 @@ public:
GENERIC, /**< generic sls detector */ GENERIC, /**< generic sls detector */
EIGER, /**< eiger */ EIGER, /**< eiger */
GOTTHARD, /**< gotthard */ GOTTHARD, /**< gotthard */
MOENCH, /**< moench */
JUNGFRAU, /**< jungfrau */ JUNGFRAU, /**< jungfrau */
JUNGFRAUCTB, /**< jungfrauCTBversion */ JUNGFRAUCTB, /**< jungfrauCTBversion */
PROPIX, /**< propix */ MYTHEN3, /**< mythen 3 */
MYTHEN3 /**< mythen 3 */ MOENCH /**< moench */
}; };