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

10Gbe, some functions in gotthard and eiger servers including mv in dacs, mv in dacs, changing settings file

Browse Source
This commit is contained in:
Maliakal Dhanya 2014-07-11 13:06:48 +02:00
parent 018b800117
commit 828a2dbd17
21 changed files with 867 additions and 863 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
slsDetectorSoftware/commonFiles/error_defs.h
View File

@ -101,6 +101,9 @@ public:
if(slsErrorMask&RECEIVER_DET_HOSTTYPE_NOT_SET)
retval.append("Could not send the detector type to the receiver.\n");
if(slsErrorMask&DETECTOR_TEN_GIGA)
retval.append("Could not enable/disable 10GbE in the detector.\n");
@ -140,6 +143,10 @@ public:
if(slsErrorMask&RECEIVER_DYNAMIC_RANGE)
retval.append("Could not set dynamic range in receiver.\n");
if(slsErrorMask&RECEIVER_TEN_GIGA)
retval.append("Could not enable/disable 10GbE in the receiver.\n");
return retval;

23
slsDetectorSoftware/eigerDetectorServer/EigerBackEndFunctions.c
View File

@ -124,13 +124,6 @@ int EigerSetupTableEntryLeft(int ipad, long long int macad, long long int detect
(unsigned int)((macad>>8)&0xFF),
(unsigned int)((macad>>0)&0xFF));
/*
if(((detectormacadd>>40)&0xFF)<9)
sprintf(src_mac,"0%s",detectormacadd);
if(((macad>>40)&0xFF)<9)
sprintf(dst_mac,"0%s",macad);
*/
//strcpy(src_mac,"00:aa:bb:cc:dd:ee");
printf("Seting up Table Entry Left:\n");
printf("src_port:%d\n",src_port);
printf("dst_port:%d\n",dst_port);
@ -167,7 +160,6 @@ int EigerSetupTableEntryRight(int ipad, long long int macad, long long int detec
(unsigned int)((macad>>8)&0xFF),
(unsigned int)((macad>>0)&0xFF));
//strcpy(src_mac,"00:aa:bb:cc:dd:ee");
printf("Seting up Table Entry Right:\n");
printf("src_port:%d\n",src_port);
printf("dst_port:%d\n",dst_port);
@ -187,24 +179,13 @@ int EigerSetupTableEntryRight(int ipad, long long int macad, long long int detec
int RequestImages(){
printf("Going to request images\n");
eiger_back_ret_val=0;
eiger_back_message_length = sprintf(eiger_back_message,"requestimages %d",0);
eiger_back_message_length = sprintf(eiger_back_message,"requestimages %d",0); // dst_number
return EigerBackSendCMD();
}
int SetDestinationParameters(int i){
SetLeftDestinationParameters(i);
return SetRightDestinationParameters(i);
}
int SetLeftDestinationParameters(int i){
eiger_back_ret_val=0;
eiger_back_message_length = sprintf(eiger_back_message,"setdstparameters %d %d %d",ten_giga,1,i);
return EigerBackSendCMD();
}
int SetRightDestinationParameters(int i){
eiger_back_ret_val=0;
eiger_back_message_length = sprintf(eiger_back_message,"setdstparameters %d %d %d",ten_giga,32,i);
eiger_back_message_length = sprintf(eiger_back_message,"setdstparameters %d %d %d",ten_giga,32,i);// number of dsts
return EigerBackSendCMD();
}

300
slsDetectorSoftware/eigerDetectorServer/EigerHighLevelFunctions.c
View File

@ -18,10 +18,10 @@ char eiger_message[1024];
int eiger_message_length = 0;
int eiger_ret_val=0;
int eiger_nexposures = 0;
int eiger_nexposures = 1;
float eiger_exposuretime = 0;
float eiger_exposureperiod = 0;
int eiger_ncycles = 0;
int eiger_ncycles = 1;
int eiger_ngates = 0;
int eiger_getphotonenergy = 0;
int eiger_dynamicrange = 0;
@ -30,6 +30,8 @@ int eiger_readoutmode = 0;
int eiger_highvoltage = 0;
int eiger_iodelay = 0;
int eiger_triggermode = 0;
int eiger_extgating = 0;
int eiger_extgatingpolarity = 0;
const unsigned int ndacs = 16;
const char* dac_names[16] = {"SvP","Vtr","Vrf","Vrs","SvN","Vtgstv","Vcmp_ll","Vcmp_lr","cal","Vcmp_rl","rxb_rb","rxb_lb","Vcmp_rr","Vcp","Vcn","Vis"};
@ -49,123 +51,133 @@ int EigerGetReadoutMode(){return eiger_readoutmode;}
int EigerGetHighVoltage(){return eiger_highvoltage;}
int EigerGetIODelay(){return eiger_iodelay;}
int EigerGetTriggerMode(){return eiger_triggermode;}
int EigerGetExternalGating(){return eiger_extgating;}
int EigerGetExternalGatingPolarity(){return eiger_extgatingpolarity;}
int EigerInit(){
static int passed = 0;
static int passed = 0;
if(!passed){
struct hostent *dst_host;
if((dst_host = gethostbyname("localhost")) == NULL){ //or look into getaddrinfo(3)
fprintf(stderr,"ERROR, no such host\n");
return 0;
}else{
//struct sockaddr_in eiger_socket_addr;
int port = FEB_PORT;
bzero((char *) &eiger_socket_addr, sizeof(eiger_socket_addr));
eiger_socket_addr.sin_family = AF_INET;
bcopy((char *)dst_host->h_addr,(char *)&eiger_socket_addr.sin_addr.s_addr,dst_host->h_length);
eiger_socket_addr.sin_port = htons(port);
passed = 1;
}
}
if(!passed){
struct hostent *dst_host;
if((dst_host = gethostbyname("localhost")) == NULL){ //or look into getaddrinfo(3)
fprintf(stderr,"ERROR, no such host\n");
return 0;
}else{
//struct sockaddr_in eiger_socket_addr;
int port = FEB_PORT;
bzero((char *) &eiger_socket_addr, sizeof(eiger_socket_addr));
eiger_socket_addr.sin_family = AF_INET;
bcopy((char *)dst_host->h_addr,(char *)&eiger_socket_addr.sin_addr.s_addr,dst_host->h_length);
eiger_socket_addr.sin_port = htons(port);
passed = 1;
}
}
return passed;
return passed;
}
int EigerSendCMD(){
if(!EigerInit()||eiger_message_length<=0) return 0;
if(!EigerInit()||eiger_message_length<=0) return 0;
int sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0){
fprintf(stderr,"ERROR opening socket\n");
return 0;
}
int sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0){
fprintf(stderr,"ERROR opening socket\n");
return 0;
}
if(connect(sockfd,(struct sockaddr *) &eiger_socket_addr,sizeof(eiger_socket_addr))<0){
fprintf(stderr,"ERROR connecting\n");
return 0;
}
if(connect(sockfd,(struct sockaddr *) &eiger_socket_addr,sizeof(eiger_socket_addr))<0){
fprintf(stderr,"ERROR connecting\n");
return 0;
}
int n = write(sockfd,eiger_message,eiger_message_length);
int ret_length = read(sockfd,eiger_message,eiger_max_message_length);
int n = write(sockfd,eiger_message,eiger_message_length);
int ret_length = read(sockfd,eiger_message,eiger_max_message_length);
close(sockfd);
close(sockfd);
if(n<0||ret_length<0) return 0;
if(n<0||ret_length<0) return 0;
//fprintf(stdout,"%s\n",eiger_message);
if(eiger_ret_val>0){
int i=0;
eiger_message[1]='\0';
if(atoi(eiger_message)!=0) return 0;
//fprintf(stdout,"%s\n",eiger_message);
if(eiger_ret_val>0){
int i=0;
eiger_message[1]='\0';
if(atoi(eiger_message)!=0) return 0;
for(i=2;i<ret_length;i++){
if(eiger_message[i] == ' '){
//fprintf(stdout," in : %d \n",i);
eiger_message[i]='\0';
break;
}
}
eiger_ret_val = atoi(&eiger_message[2]);
//fprintf(stdout," the \"%s\" %d\n",&eiger_message[2],eiger_ret_val);
}
for(i=2;i<ret_length;i++){
if(eiger_message[i] == ' '){
//fprintf(stdout," in : %d \n",i);
eiger_message[i]='\0';
break;
}
}
eiger_ret_val = atoi(&eiger_message[2]);
//fprintf(stdout," the \"%s\" %d\n",&eiger_message[2],eiger_ret_val);
}
eiger_message_length = 0;
eiger_message_length = 0;
return 1;
return 1;
}
const char* EigerGetDACName(int i){
if(i>0&&i<ndacs) return dac_names[i];
return dac_names[0];
if(i>0&&i<ndacs) return dac_names[i];
return dac_names[0];
}
int EigerSetDAC(const char* iname,int v){
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setdacvoltage %s %d",iname,v); //setdacvoltage
return EigerSendCMD();
int EigerSetDAC(const char* iname,int v, int mV){
eiger_ret_val=0;
if(mV)
eiger_message_length = sprintf(eiger_message,"setdacvoltage %s %d",iname,v);
else
eiger_message_length = sprintf(eiger_message,"setdacvalue %s %d",iname,v);
return EigerSendCMD();
}
int EigerGetDAC(const char* iname){
eiger_ret_val=1;
eiger_message_length = sprintf(eiger_message,"getdacvoltage %s",iname);//getdacvoltage
if(!EigerSendCMD()) return -1;
return eiger_ret_val;
eiger_ret_val=1;
eiger_message_length = sprintf(eiger_message,"getdacvalue %s",iname);
if(!EigerSendCMD()) return -1;
return eiger_ret_val;
}
int EigerGetDACmV(const char* iname){
eiger_ret_val=1;
eiger_message_length = sprintf(eiger_message,"getdacvoltage %s",iname);
if(!EigerSendCMD()) return -1;
return eiger_ret_val;
}
int EigerSetNumberOfExposures(unsigned int n){
eiger_nexposures = n;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setnumberofexposures %u",n);
return EigerSendCMD();
eiger_nexposures = n;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setnumberofexposures %u",eiger_nexposures*eiger_ncycles);
return EigerSendCMD();
}
int EigerSetExposureTime(float v){
eiger_exposuretime = v;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setexposuretime %f",v);
return EigerSendCMD();
eiger_exposuretime = v;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setexposuretime %f",v);
return EigerSendCMD();
}
int EigerSetExposurePeriod(float v){
eiger_exposureperiod = v;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setexposureperiod %f",v);
return EigerSendCMD();
eiger_exposureperiod = v;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setexposureperiod %f",v);
return EigerSendCMD();
}
int EigerSetNumberOfCycles(unsigned int n){
eiger_ncycles = n;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setnumberofexposures %u",n);
return EigerSendCMD();
eiger_ncycles = n;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setnumberofexposures %u",eiger_nexposures*eiger_ncycles);
return EigerSendCMD();
}
/*
int EigerSetNumberOfGates(unsigned int n){
@ -174,107 +186,119 @@ int EigerSetNumberOfGates(unsigned int n){
eiger_message_length = sprintf(eiger_message,"setnumberofexposures %u",n);
return EigerSendCMD();
}
*/
*/
int EigerSetDynamicRange(unsigned int i){
eiger_dynamicrange = i;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setbitmode %u",i);
return EigerSendCMD();
eiger_dynamicrange = i;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setbitmode %u",i);
return EigerSendCMD();
}
int EigerSetPhotonEnergy(int in_eV){
eiger_getphotonenergy = in_eV;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setphotonenergy %d",in_eV);
return EigerSendCMD();
eiger_getphotonenergy = in_eV;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setphotonenergy %d",in_eV);
return EigerSendCMD();
}
int EigerSetReadoutSpeed(int speed){
eiger_readoutspeed = speed;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setreadoutspeed %d",speed);
return EigerSendCMD();
eiger_readoutspeed = speed;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setreadoutspeed %d",speed);
return EigerSendCMD();
}
int EigerSetReadoutMode(int mode){
eiger_readoutmode = mode;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setreadoutmode %d",mode);
return EigerSendCMD();
eiger_readoutmode = mode;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setreadoutmode %d",mode);
return EigerSendCMD();
}
int EigerSetHighVoltage(int hv){
eiger_highvoltage = hv;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"sethighvoltage %d",hv);
return EigerSendCMD();
eiger_highvoltage = hv;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"sethighvoltage %d",hv);
return EigerSendCMD();
}
int EigerSetIODelay(int io){
eiger_iodelay = io;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setinputdelays %d",io);
return EigerSendCMD();
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setinputdelays %d",io);
return EigerSendCMD();
}
int EigerSetTriggerMode(int m){
eiger_triggermode = m;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"settriggermode %d",m);
return EigerSendCMD();
eiger_triggermode = m;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"settriggermode %d",m);
return EigerSendCMD();
}
int EigerSetExternalGating(int e, int p){
eiger_extgating = e;
eiger_extgatingpolarity = p;
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"setexternalgating %d %d",e,p);
return EigerSendCMD();
}
int EigerStartAcquisition(){
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"startacquisition");
return EigerSendCMD();
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"startacquisition");
return EigerSendCMD();
}
int EigerRunStatus(){
eiger_ret_val=1;
eiger_message_length = sprintf(eiger_message,"isdaqstillrunning");
if(!EigerSendCMD()) return -1;
return eiger_ret_val;
eiger_ret_val=1;
eiger_message_length = sprintf(eiger_message,"isdaqstillrunning");
if(!EigerSendCMD()) return -1;
return eiger_ret_val;
}
int EigerStopAcquisition(){
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"stopacquisition");
return EigerSendCMD();
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"stopacquisition");
return EigerSendCMD();
}
int EigerWaitForAcquisitionFinish(){
eiger_ret_val=0;
eiger_message_length = sprintf(eiger_message,"waituntildaqfinished");
return EigerSendCMD();
}
#ifdef TESTEIGERFUNCTIONS
int main(){
int v=220;
char n[2000] = "Vcmp_lr";
int v=220;
char n[2000] = "Vcmp_lr";
fprintf(stdout," ret : %d\n",EigerSetDAC(EigerGetDACName(7),2200));
int t = EigerGetDAC(EigerGetDACName(7));
fprintf(stdout," v : %d\n",t);
fprintf(stdout," ret : %d\n",EigerSetDAC(EigerGetDACName(7),2200));
int t = EigerGetDAC(EigerGetDACName(7));
fprintf(stdout," v : %d\n",t);
fprintf(stdout," ret : %d\n",EigerSetDAC(n,v));
t = EigerGetDAC(n);
fprintf(stdout," ret : %d\n",t);
float f=0.12;
fprintf(stdout," ret : %d\n",EigerSetNumberOfExposures(120));
fprintf(stdout," ret : %d\n",EigerSetExposureTime(0.12));
fprintf(stdout," ret : %d\n",EigerSetExposurePeriod(0.22));
fprintf(stdout," ret : %d\n",EigerSetPhotonEnergy(9200));
fprintf(stdout," ret : %d\n",EigerSetDynamicRange(16));
fprintf(stdout," ret : %d\n",EigerStartAcquisition());
fprintf(stdout," aret : %d\n",EigerRunStatus());
sleep(1);
fprintf(stdout," ret : %d\n",EigerStopAcquisition());
fprintf(stdout," bret : %d\n",EigerRunStatus());
return 0;
fprintf(stdout," ret : %d\n",EigerSetDAC(n,v));
t = EigerGetDAC(n);
fprintf(stdout," ret : %d\n",t);
float f=0.12;
fprintf(stdout," ret : %d\n",EigerSetNumberOfExposures(120));
fprintf(stdout," ret : %d\n",EigerSetExposureTime(0.12));
fprintf(stdout," ret : %d\n",EigerSetExposurePeriod(0.22));
fprintf(stdout," ret : %d\n",EigerSetPhotonEnergy(9200));
fprintf(stdout," ret : %d\n",EigerSetDynamicRange(16));
fprintf(stdout," ret : %d\n",EigerStartAcquisition());
fprintf(stdout," aret : %d\n",EigerRunStatus());
sleep(1);
fprintf(stdout," ret : %d\n",EigerStopAcquisition());
fprintf(stdout," bret : %d\n",EigerRunStatus());
return 0;
}
#endif

825
slsDetectorSoftware/eigerDetectorServer/FebServer.cxx
View File

@ -24,79 +24,66 @@
using namespace std;
enum cmd_string {evNotFound,
evReinitialize,evReset,
evReinitialize,evReset,
evSetInputDelays,
evSetDACValue,evGetDACValue,evSetDACVoltage,evGetDACVoltage,evSetHighVoltage,//evGetHighVoltage,
evSetInputDelays,
evSetDACValue,evGetDACValue,evSetDACVoltage,evGetDACVoltage,evSetHighVoltage,//evGetHighVoltage,
evSetTrimBits,
//evLoadTrimBitFile,
evSetTrimBits,
//evLoadTrimBitFile,
evSetBitMode,
evSetPhotonEnergy,
// evSetPhotonEnergyCalibrationParameters,evActivateRateCorrection,evDeactivateRateCorrection,evSetRateCorrectionTau,
evSetBitMode,
evSetPhotonEnergy,
// evSetPhotonEnergyCalibrationParameters,evActivateRateCorrection,evDeactivateRateCorrection,evSetRateCorrectionTau,
evSetReadoutSpeed,evSetReadoutMode,
evSetReadoutSpeed,evSetReadoutMode,
//temp solution
// evNotFound1,evNotFound2,evNotFound3,
evSetNumberOfExposures,evSetExposureTime,evSetExposurePeriod,
// evSetTriggerPolarityToPositive,evSetTriggerPolarityToNegative,
evSetTriggerMode,
// evEnableExternalGatingWhenSignalsPositive,evEnableExternalGatingWhenSignalsNegative,evDisableExternalGating,
evStartAcquisition,evStopAcquisition,evIsDaqStillRunning};
// evWaitUntilDaqFinished,evExitServer
//temp solution
// evNotFound1,evNotFound2,evNotFound3,
evSetNumberOfExposures,evSetExposureTime,evSetExposurePeriod,
// evSetTriggerPolarityToPositive,evSetTriggerPolarityToNegative,
evSetTriggerMode,
evSetExternalGating,
evStartAcquisition,evStopAcquisition,evIsDaqStillRunning,
evWaitUntilDaqFinished,
evExitServer
};
map<string, cmd_string> enum_map;
void init(){
enum_map["reinitialize"] = evReinitialize;
enum_map["reset"] = evReset;
enum_map["setinputdelays"] = evSetInputDelays;
enum_map["setdacvalue"] = evSetDACValue;
enum_map["getdacvalue"] = evGetDACValue;
enum_map["setdacvoltage"] = evSetDACVoltage;
enum_map["getdacvoltage"] = evGetDACVoltage;
enum_map["sethighvoltage"] = evSetHighVoltage;
enum_map["settrimbits"] = evSetTrimBits;
// enum_map["loadtrimbitfile"] = evLoadTrimBitFile;
enum_map["setbitmode"] = evSetBitMode;
enum_map["setphotonenergy"] = evSetPhotonEnergy;
// enum_map["setphotonenergycalibrationparameters"] = evSetPhotonEnergyCalibrationParameters;
// enum_map["activateratecorrection"] = evActivateRateCorrection;
// enum_map["deactivateratecorrection"] = evDeactivateRateCorrection;
// enum_map["setratecorrectiontau"] = evSetRateCorrectionTau;
enum_map["setreadoutspeed"] = evSetReadoutSpeed;
enum_map["setreadoutmode"] = evSetReadoutMode;
enum_map["setnumberofexposures"] = evSetNumberOfExposures;
enum_map["setexposuretime"] = evSetExposureTime;
enum_map["setexposureperiod"] = evSetExposurePeriod;
/*
enum_map["settriggerpolaritytopositive"] = evSetTriggerPolarityToPositive;
enum_map["settriggerpolaritytonegative"] = evSetTriggerPolarityToNegative;
*/
enum_map["settriggermode"] = evSetTriggerMode;
/*
enum_map["enableexternalgatingwhensignalspositive"] = evEnableExternalGatingWhenSignalsPositive;
enum_map["enableexternalgatingwhensignalsnegative"] = evEnableExternalGatingWhenSignalsNegative;
enum_map["disableexternalgating"] = evDisableExternalGating;
*/
enum_map["startacquisition"] = evStartAcquisition;
enum_map["stopacquisition"] = evStopAcquisition;
enum_map["isdaqstillrunning"] = evIsDaqStillRunning;
// enum_map["waituntildaqfinished"] = evWaitUntilDaqFinished;
// enum_map["exitserver"] = evExitServer;
enum_map["reinitialize"] = evReinitialize;
enum_map["reset"] = evReset;
enum_map["setinputdelays"] = evSetInputDelays;
enum_map["setdacvalue"] = evSetDACValue;
enum_map["getdacvalue"] = evGetDACValue;
enum_map["setdacvoltage"] = evSetDACVoltage;
enum_map["getdacvoltage"] = evGetDACVoltage;
enum_map["sethighvoltage"] = evSetHighVoltage;
enum_map["settrimbits"] = evSetTrimBits;
// enum_map["loadtrimbitfile"] = evLoadTrimBitFile;
enum_map["setbitmode"] = evSetBitMode;
enum_map["setphotonenergy"] = evSetPhotonEnergy;
// enum_map["setphotonenergycalibrationparameters"] = evSetPhotonEnergyCalibrationParameters;
// enum_map["activateratecorrection"] = evActivateRateCorrection;
// enum_map["deactivateratecorrection"] = evDeactivateRateCorrection;
// enum_map["setratecorrectiontau"] = evSetRateCorrectionTau;
enum_map["setreadoutspeed"] = evSetReadoutSpeed;
enum_map["setreadoutmode"] = evSetReadoutMode;
enum_map["setnumberofexposures"] = evSetNumberOfExposures;
enum_map["setexposuretime"] = evSetExposureTime;
enum_map["setexposureperiod"] = evSetExposurePeriod;
// enum_map["settriggerpolaritytopositive"] = evSetTriggerPolarityToPositive;
// enum_map["settriggerpolaritytonegative"] = evSetTriggerPolarityToNegative;
enum_map["settriggermode"] = evSetTriggerMode;
enum_map["setexternalgating"] = evSetExternalGating;
enum_map["startacquisition"] = evStartAcquisition;
enum_map["stopacquisition"] = evStopAcquisition;
enum_map["isdaqstillrunning"] = evIsDaqStillRunning;
enum_map["waituntildaqfinished"] = evWaitUntilDaqFinished;
enum_map["exitserver"] = evExitServer;
}
int server_list_s;
@ -112,458 +99,466 @@ void AddNumber(string& str, int n, int location=-1, bool space_after=0);//-1 mea
void AddNumber(string& str, float v, int location=-1, bool space_after=0);//-1 means append
int main(int argc, char* argv[]){
cout<<endl<<endl;
cout<<endl<<endl;
/*
/*
if(argc<2){
cout<<"Usage: feb_server port_number"<<endl<<endl;
return 1;
}
*/
*/
init();
init();
FebControl *feb_controler = new FebControl();
FebControl *feb_controler = new FebControl();
unsigned short int port_number = FEB_PORT;
if(!SetupListenSocket(port_number)) return 1;
int length=1000;
char data[1000];
int stop = 0;
time_t rawtime;
struct tm *timeinfo;
unsigned short int port_number = FEB_PORT;
if(!SetupListenSocket(port_number)) return 1;
while(!stop){
int length=1000;
char data[1000];
cout<<endl<<"\n\n\n\nWaiting for command -> "<<flush;
int nread = AccpetConnectionAndWaitForData(data,length);
if(nread<=0) return 0;
int stop = 0;
time_t rawtime;
struct tm *timeinfo;
time(&rawtime); timeinfo=localtime(&rawtime);
cout<<asctime(timeinfo);
cout<<" Command received: "<<data<<endl<<endl;
while(!stop){
cout<<endl<<"\n\n\n\nWaiting for command -> "<<flush;
int nread = AccpetConnectionAndWaitForData(data,length);
if(nread<=0) return 0;
time(&rawtime); timeinfo=localtime(&rawtime);
cout<<asctime(timeinfo);
cout<<" Command received: "<<data<<endl<<endl;
string tmp_str[5];
float v[4];//,v2,v3,v4,v5;
int n[5];
string tmp_str[5];
float v[4];//,v2,v3,v4,v5;
int n[5];
string cmd = GetNextString(data,1);
int ret_val = 1;
string cmd = GetNextString(data,1);
int ret_val = 1;
string return_message = "\n\n\tCommand recieved: ";
return_message.append(data);
return_message.append("\n");
string return_message = "\n\n\tCommand recieved: ";
return_message.append(data);
return_message.append("\n");
int return_start_pos;
while(cmd.length()>0){
int ret_parameter = 0;
return_start_pos = return_message.length();
int return_start_pos;
while(cmd.length()>0){
int ret_parameter = 0;
return_start_pos = return_message.length();
switch(enum_map.find(LowerCase(cmd))->second){
switch(enum_map.find(LowerCase(cmd))->second){
case evReinitialize :
if(feb_controler->Init()){
return_message.append("\tExecuted: Reinitialize\n");
ret_val = 0;
}else{
return_message.append("\tError executing: Reinitialize\n");
ret_val = 1;
}
break;
case evReinitialize :
if(feb_controler->Init()){
return_message.append("\tExecuted: Reinitialize\n");
ret_val = 0;
}else{
return_message.append("\tError executing: Reinitialize\n");
ret_val = 1;
}
break;
case evReset :
if(feb_controler->Reset()){
return_message.append("\tExecuted: Reset\n");
ret_val = 0;
}else{
return_message.append("\tError executing: Reset\n");
ret_val = 1;
}
break;
case evReset :
if(feb_controler->Reset()){
return_message.append("\tExecuted: Reset\n");
ret_val = 0;
}else{
return_message.append("\tError executing: Reset\n");
ret_val = 1;
}
break;
case evSetInputDelays :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
case evSetInputDelays :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetIDelays(0,n[0])){
return_message.append("\tExecuted: SetInputDelays "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetInputDelays <delay>\n");
ret_val = 1;
}
break;
if(tmp_str[0].length()>0&&feb_controler->SetIDelays(0,n[0])){
return_message.append("\tExecuted: SetInputDelays "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetInputDelays <delay>\n");
ret_val = 1;
}
break;
case evSetDACValue :
tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[1].data());
if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0])){
return_message.append("\tExecuted: SetDACValue "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetDACValue <dac_name> <value>\n");
ret_val = 1;
}
break;
case evSetDACValue :
tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[1].data());
case evGetDACValue :
tmp_str[0] = GetNextString(data);
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter)){
return_message.append("\tExecuted: GetDACValue "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
ret_val = 0;
}else{
return_message.append("\tError executing: GetDACValue <dac_name>\n");
ret_val = 1;
}
break;
if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0])){
return_message.append("\tExecuted: SetDACValue "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetDACValue <dac_name> <value>\n");
ret_val = 1;
}
break;
case evSetDACVoltage :
tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[1].data());
case evGetDACValue :
tmp_str[0] = GetNextString(data);
if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0],1)){
return_message.append("\tExecuted: SetDACVoltage "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetDACVoltage <dac_name> <voltage_mV>\n");
ret_val = 1;
}
break;
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter)){
return_message.append("\tExecuted: GetDACValue "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
ret_val = 0;
}else{
return_message.append("\tError executing: GetDACValue <dac_name>\n");
ret_val = 1;
}
break;
case evGetDACVoltage :
tmp_str[0] = GetNextString(data);
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter,1)){
return_message.append("\tExecuted: GetDACVoltage "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
ret_val = 0;
}else{
return_message.append("\tError executing: GetDACVoltage <dac_name>\n");
ret_val = 1;
}
break;
case evSetDACVoltage :
tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[1].data());
case evSetHighVoltage :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetHighVoltage(v[0])){
return_message.append("\tExecuted: SetHighVoltage "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetHighVoltage <voltage>\n");
ret_val = 1;
}
break;
if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0],1)){
return_message.append("\tExecuted: SetDACVoltage "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetDACVoltage <dac_name> <voltage_mV>\n");
ret_val = 1;
}
break;
case evSetTrimBits :
/*if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){*/
feb_controler->SetTrimbits(0,(unsigned char*)data);
return_message.append("\tExecuted: SetTrimBits "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
/*}else{
case evGetDACVoltage :
tmp_str[0] = GetNextString(data);
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter,1)){
return_message.append("\tExecuted: GetDACVoltage "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
ret_val = 0;
}else{
return_message.append("\tError executing: GetDACVoltage <dac_name>\n");
ret_val = 1;
}
break;
case evSetHighVoltage :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetHighVoltage(v[0])){
return_message.append("\tExecuted: SetHighVoltage "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetHighVoltage <voltage>\n");
ret_val = 1;
}
break;
case evSetTrimBits :
/*if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){*/
feb_controler->SetTrimbits(0,(unsigned char*)data);
return_message.append("\tExecuted: SetTrimBits "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
/*}else{
return_message.append("\tError executing: SetTrimBits \n");
ret_val = 1;
} */
break;
break;
// case evLoadTrimBitFile :
// case evLoadTrimBitFile :
case evSetBitMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
case evSetBitMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){
return_message.append("\tExecuted: SetBitMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetBitMode <mode 4,8,16,32>\n");
ret_val = 1;
}
break;
if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){
return_message.append("\tExecuted: SetBitMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetBitMode <mode 4,8,16,32>\n");
ret_val = 1;
}
break;
case evSetPhotonEnergy :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetPhotonEnergy(n[0])){
return_message.append("\tExecuted: SetPhotonEnergy "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetPhotonEnergy <energy eV>\n");
ret_val = 1;
}
break;
case evSetPhotonEnergy :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetPhotonEnergy(n[0])){
return_message.append("\tExecuted: SetPhotonEnergy "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetPhotonEnergy <energy eV>\n");
ret_val = 1;
}
break;
// case evSetPhotonEnergyCalibrationParameters :
// case evActivateRateCorrection :
// case evDeactivateRateCorrection :
// case evSetRateCorrectionTau :
// case evSetPhotonEnergyCalibrationParameters :
// case evActivateRateCorrection :
// case evDeactivateRateCorrection :
// case evSetRateCorrectionTau :
case evSetReadoutSpeed :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutSpeed(n[0])){
return_message.append("\tExecuted: SetReadoutSpeed "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetReadoutSpeed <speed 0-full 1-half 2-quarter 3-super_slow>\n");
ret_val = 1;
}
break;
case evSetReadoutSpeed :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutSpeed(n[0])){
return_message.append("\tExecuted: SetReadoutSpeed "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetReadoutSpeed <speed 0-full 1-half 2-quarter 3-super_slow>\n");
ret_val = 1;
}
break;
case evSetReadoutMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutMode(n[0])){
return_message.append("\tExecuted: SetReadoutMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetReadoutMode <mode 0->parallel,1->non-parallel,2-> safe_mode>\n");
ret_val = 1;
}
break;
case evSetReadoutMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutMode(n[0])){
return_message.append("\tExecuted: SetReadoutMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetReadoutMode <mode 0->parallel,1->non-parallel,2-> safe_mode>\n");
ret_val = 1;
}
break;
case evSetNumberOfExposures :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetNExposures(n[0])){
return_message.append("\tExecuted: SetNumberOfExposures "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetNumberOfExposures <n>\n");
ret_val = 1;
}
break;
case evSetExposureTime :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetExposureTime(v[0])){
return_message.append("\tExecuted: SetExposureTime "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetExposureTime <t_seconds>\n");
ret_val = 1;
}
break;
case evSetNumberOfExposures :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetNExposures(n[0])){
return_message.append("\tExecuted: SetNumberOfExposures "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetNumberOfExposures <n>\n");
ret_val = 1;
}
break;
case evSetExposurePeriod :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetExposurePeriod(v[0])){
return_message.append("\tExecuted: SetExposurePeriod "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetExposurePeriod <t_seconds>\n");
ret_val = 1;
}
break;
// case evSetTriggerPolarityToPositive :
// case evSetTriggerPolarityToNegative :
case evSetTriggerMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetTriggerMode(n[0])){
return_message.append("\tExecuted: SetTriggerMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetTriggerMode <n>\n");
ret_val = 1;
}
break;
case evSetExposureTime :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetExposureTime(v[0])){
return_message.append("\tExecuted: SetExposureTime "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetExposureTime <t_seconds>\n");
ret_val = 1;
}
break;
// case evEnableExternalGatingWhenSignalsPositive :
// case evEnableExternalGatingWhenSignalsNegative :
// case evDisableExternalGating :
case evSetExposurePeriod :
tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetExposurePeriod(v[0])){
return_message.append("\tExecuted: SetExposurePeriod "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetExposurePeriod <t_seconds>\n");
ret_val = 1;
}
break;
// case evSetTriggerPolarityToPositive :
// case evSetTriggerPolarityToNegative :
case evSetTriggerMode :
tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetTriggerMode(n[0])){
return_message.append("\tExecuted: SetTriggerMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
}else{
return_message.append("\tError executing: SetTriggerMode <n>\n");
ret_val = 1;
}
break;
case evSetExternalGating :
tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[0].data());
n[1] = atoi(tmp_str[1].data());
if(tmp_str[0].length()<1 || tmp_str[1].length()<1 || (n[0]!=0&&n[0]!=1) || (n[1]!=0&&n[1]!=1)){
return_message.append("\tError executing: setexternalgating <enable> <polarity>\n");
ret_val = 1;
}
feb_controler->SetExternalEnableMode(n[0],n[1]);
ret_val = 0;
break;
case evStartAcquisition :
if(feb_controler->StartAcquisition()){
return_message.append("\tExecuted: StartAcquisition\n");
ret_val = 0;
}else{
return_message.append("\tError executing: StartAcquisition\n");
ret_val = 1;
}
break;
case evStopAcquisition :
if(feb_controler->StopAcquisition()){
return_message.append("\tExecuted: StopAcquisition\n");
ret_val = 0;
}else{
return_message.append("\tError executing: StopAcquisition\n");
ret_val = 1;
}
break;
case evStartAcquisition :
if(feb_controler->StartAcquisition()){
return_message.append("\tExecuted: StartAcquisition\n");
ret_val = 0;
}else{
return_message.append("\tError executing: StartAcquisition\n");
ret_val = 1;
}
break;
case evStopAcquisition :
if(feb_controler->StopAcquisition()){
return_message.append("\tExecuted: StopAcquisition\n");
ret_val = 0;
}else{
return_message.append("\tError executing: StopAcquisition\n");
ret_val = 1;
}
break;
case evIsDaqStillRunning :
return_message.append("\tExecuted: evIsDaqStillRunning\n");
ret_parameter = feb_controler->AcquisitionInProgress();
ret_val = 0;
break;
case evIsDaqStillRunning :
return_message.append("\tExecuted: evIsDaqStillRunning\n");
ret_parameter = feb_controler->AcquisitionInProgress();
ret_val = 0;
break;
/*
case evWaitUntilDaqFinished :
if(feb_controler->WaitForFinishedFlag()){
return_message.append("\tExecuted: WaitUntilDaqFinished\n");
ret_val = 0;
}else{
return_message.append("\tError executing: WaitUntilDaqFinished\n");
ret_val = 1;
}
break;
case evWaitUntilDaqFinished :
if(feb_controler->WaitForFinishedFlag()){
return_message.append("\tExecuted: WaitUntilDaqFinished\n");
ret_val = 0;
}else{
return_message.append("\tError executing: WaitUntilDaqFinished\n");
ret_val = 1;
}
break;
case evExitServer :
return_message.append("\tExiting Server ....\n");
stop = 1;
ret_val = -200;
break;
*/
case evExitServer :
return_message.append("\tExiting Server ....\n");
stop = 1;
ret_val = -200;
break;
default :
return_message.append("\tWarning command \"");
return_message.append(cmd);
return_message.append("\" not found.\n");
return_message.append("\t\tValid commands: ");
map<string, cmd_string>::iterator it = enum_map.begin();
while(it!=enum_map.end()){
return_message.append((it++)->first);
return_message.append(" ");
}
ret_val=-100;
break;
}
default :
return_message.append("\tWarning command \"");
return_message.append(cmd);
return_message.append("\" not found.\n");
return_message.append("\t\tValid commands: ");
map<string, cmd_string>::iterator it = enum_map.begin();
while(it!=enum_map.end()){
return_message.append((it++)->first);
return_message.append(" ");
}
// return_message.append("\n");
//AddNumber(return_message,ret_parameter,return_start_pos);
AddNumber(return_message,ret_val,return_start_pos,1);
AddNumber(return_message,ret_parameter,0,1);
if(ret_val!=0) break;
ret_val=-100;
break;
}
cmd = GetNextString(data);
}
return_message.append("\n\n\n");
// return_message.append("\n");
//AddNumber(return_message,ret_parameter,return_start_pos);
AddNumber(return_message,ret_val,return_start_pos,1);
AddNumber(return_message,ret_parameter,0,1);
if(ret_val!=0) break;
AddNumber(return_message,ret_val,0,1);
cout<<return_message.c_str()<<endl;
cout<<"\treturn: "<<ret_val<<endl;
cmd = GetNextString(data);
}
return_message.append("\n\n\n");
if(!WriteNClose(return_message.c_str(),return_message.length())) return 0;
}
AddNumber(return_message,ret_val,0,1);
cout<<return_message.c_str()<<endl;
cout<<"\treturn: "<<ret_val<<endl;
delete feb_controler;
if(!WriteNClose(return_message.c_str(),return_message.length())) return 0;
}
return 0;
delete feb_controler;
return 0;
}
string LowerCase(string str){
string s = str;
string::iterator i = s.begin();
while(i!=s.end()) *i=tolower(*(i++));
return s;
string s = str;
string::iterator i = s.begin();
while(i!=s.end()) *i=tolower(*(i++));
return s;
}
string GetNextString(string str,bool start_from_beginning){
static string::size_type start_pos = 0;
if(start_from_beginning) start_pos = 0;
while(start_pos != string::npos){
string::size_type found = str.find_first_of(" ",start_pos);
string sub = str.substr(start_pos,found-start_pos);
static string::size_type start_pos = 0;
if(start_from_beginning) start_pos = 0;
start_pos = found;
if(start_pos != string::npos) start_pos+=1;
while(start_pos != string::npos){
string::size_type found = str.find_first_of(" ",start_pos);
string sub = str.substr(start_pos,found-start_pos);
sub.erase(remove_if(sub.begin(),sub.end(), ::isspace ),sub.end());
start_pos = found;
if(start_pos != string::npos) start_pos+=1;
if(sub.length()>0) return sub;
}
return "";
sub.erase(remove_if(sub.begin(),sub.end(), ::isspace ),sub.end());
if(sub.length()>0) return sub;
}
return "";
}
void AddNumber(string& str, int n, int location, bool space_after){
static char retval_st[100];
if(space_after) sprintf(retval_st,"%d ",n);
else sprintf(retval_st,"%d",n);
static char retval_st[100];
if(space_after) sprintf(retval_st,"%d ",n);
else sprintf(retval_st,"%d",n);
if(location<0) str.append(retval_st);
else str.insert(location,retval_st);
if(location<0) str.append(retval_st);
else str.insert(location,retval_st);
}
void AddNumber(string& str, float v, int location, bool space_after){
static char retval_st[100];
if(space_after) sprintf(retval_st,"%f ",v);
else sprintf(retval_st,"%f",v);
static char retval_st[100];
if(space_after) sprintf(retval_st,"%f ",v);
else sprintf(retval_st,"%f",v);
if(location<0) str.append(retval_st);
else str.insert(location,retval_st);
if(location<0) str.append(retval_st);
else str.insert(location,retval_st);
}
bool SetupListenSocket(unsigned short int port){
server_list_s=0;
server_conn_s=0;
server_list_s=0;
server_conn_s=0;
if((server_list_s = socket(AF_INET, SOCK_STREAM, 0))<0) return 0;
struct sockaddr_in servaddr; /* socket address structure */
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
if((server_list_s = socket(AF_INET, SOCK_STREAM, 0))<0) return 0;
if(bind(server_list_s,(struct sockaddr *) &servaddr,sizeof(servaddr))<0) return 0;
struct sockaddr_in servaddr; /* socket address structure */
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
if(listen(server_list_s,32) < 0){ // 1024 /* Backlog for listen() */
return 0;
}
if(bind(server_list_s,(struct sockaddr *) &servaddr,sizeof(servaddr))<0) return 0;
return 1;
if(listen(server_list_s,32) < 0){ // 1024 /* Backlog for listen() */
return 0;
}
return 1;
}
int AccpetConnectionAndWaitForData(char* buffer, int maxlength){
if(server_list_s==0||maxlength<=0) return 0;
if(server_list_s==0||maxlength<=0) return 0;
if((server_conn_s = accept(server_list_s,NULL,NULL))< 0) return 0;
if((server_conn_s = accept(server_list_s,NULL,NULL))< 0) return 0;
int nread = read(server_conn_s,buffer,maxlength-1);
int nread = read(server_conn_s,buffer,maxlength-1);
if(nread<0) return 0;
if(nread<0) return 0;
buffer[nread]='\0';
return nread;
buffer[nread]='\0';
return nread;
}
bool WriteNClose(const char* buffer, int length){
if(server_conn_s==0||length<=0) return 0;
int nsent = write(server_conn_s,buffer,length);
if(close(server_conn_s)<0) return 0;
server_conn_s=0;
return (nsent==length);
if(server_conn_s==0||length<=0) return 0;
int nsent = write(server_conn_s,buffer,length);
if(close(server_conn_s)<0) return 0;
server_conn_s=0;
return (nsent==length);
}

BIN
slsDetectorSoftware/eigerDetectorServer/bin/eigerDetectorServer
View File

Binary file not shown.

BIN
slsDetectorSoftware/eigerDetectorServer/bin/feb_debug
View File

Binary file not shown.

55
slsDetectorSoftware/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -71,8 +71,11 @@ int initDetector(){
*/
//get dac values
for(i=0;i<(detectorModules)->ndac;i++)
(detectorModules)->dacs[i] = setDAC((enum detDacIndex)i,-1,(detectorModules)->module);
int retval[2];
for(i=0;i<(detectorModules)->ndac;i++){
setDAC((enum detDacIndex)i,-1,(detectorModules)->module,0,retval);
(detectorModules)->dacs[i] = retval[0];
}
/* initialize dynamic range etc. */
@ -88,6 +91,8 @@ int initDetector(){
setHighVolage(150,0);
setIODelay(675,0);
setTiming(AUTO_TIMING);
int enable[2] = {0,1};
setExternalGating(enable);//disable external gating
return 1;
}
@ -214,19 +219,26 @@ int detectorTest( enum digitalTestMode arg){
int setDAC(enum detDacIndex ind, int val, int imod){
void setDAC(enum detDacIndex ind, int val, int imod, int mV, int retval[]){
char iname[10];
strcpy(iname,EigerGetDACName((int)ind));
//#ifdef VERBOSE
#ifdef VERBOSE
if(val >= 0)
printf("Setting dac %d: %s to %d mV\n",ind, iname,val);
printf("Setting dac %d: %s to %d ",ind, iname,val);
else
printf("Getting dac %d: %s\n",ind, iname);
//#endif
printf("Getting dac %d: %s ",ind, iname);
if(mV)
printf("in mV\n");
else
printf("in dac units\n");
#endif
if(val >= 0)
EigerSetDAC(iname,val);
EigerSetDAC(iname,val,mV);
retval[0] = EigerGetDAC(iname);
retval[1] = EigerGetDACmV(iname);
(detectorModules)->dacs[ind] = retval[0];
return EigerGetDAC(iname);
}
@ -260,7 +272,6 @@ int enableTenGigabitEthernet(int val){
SetTenGigbaBitEthernet(1);
else
SetTenGigbaBitEthernet(0);
SetDestinationParameters(EigerGetNumberOfExposures()*EigerGetNumberOfCycles());
//configuremac called from client
}
return GetTenGigbaBitEthernet();
@ -268,12 +279,13 @@ int enableTenGigabitEthernet(int val){
int setModule(sls_detector_module myMod){
int retval[2];
#ifdef VERBOSE
printf("Setting module with settings %d\n",myMod.reg);
#endif
int i;
for(i=0;i<myMod.ndac;i++)
setDAC((enum detDacIndex)i,myMod.dacs[i],myMod.module);
setDAC((enum detDacIndex)i,myMod.dacs[i],myMod.module,0,retval);
thisSettings = (enum detectorSettings)myMod.reg;
@ -357,11 +369,14 @@ enum runStatus getRunStatus(){
char *readFrame(int *ret, char *mess){
EigerWaitForAcquisitionFinish();
/*
int i = EigerRunStatus();
while(i){
i = EigerRunStatus();
usleep(1000);/* should be watiing in server*/
}*ret = (int)FINISHED;
usleep(1000);
}*/
*ret = (int)FINISHED;
return NULL;
}
@ -494,6 +509,7 @@ int executeTrimming(enum trimMode mode, int par1, int par2, int imod){
int configureMAC(int ipad, long long int macad, long long int detectormacadd, int detipad, int udpport, int ival){
EigerSetupTableEntryLeft(ipad, macad, detectormacadd, detipad, udpport);
EigerSetupTableEntryRight(ipad, macad, detectormacadd, detipad, udpport);
SetDestinationParameters(EigerGetNumberOfExposures()*EigerGetNumberOfCycles());
return 0;
}
@ -622,10 +638,10 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg){
case GATE_FIX_NUMBER: ret = 3; break;
}
printf(" Setting Triggering Mode: %d\n",(int)ret);
//EigerSetTriggerMode(ret);
EigerSetTriggerMode(ret);
}
ret=0;
//ret = EigerGetTriggerMode();
ret = EigerGetTriggerMode();
switch((int)ret){
case 0: ret = AUTO_TIMING; break;
case 2: ret = TRIGGER_EXPOSURE; break;
@ -639,6 +655,13 @@ ret=0;
}
void setExternalGating(int enable[]){
if(enable>=0)
EigerSetExternalGating(enable[0], enable[1]);//enable = 0 or 1, polarity = 0 or 1 , where 1 is positive
enable[0] = EigerGetExternalGatingPolarity();
enable[1] = EigerGetExternalGating();
}
enum masterFlags setMaster(enum masterFlags arg){
return NO_MASTER;

165
slsDetectorSoftware/gotthardDetectorServer/mcb_funcs.c
View File

@ -500,47 +500,6 @@ int program_one_dac(int addr, int value, int imod) {
int set_one_dac(int imod) {
int control, ibit;
int bit, value;
control=13;
value=(DAC_REFOUT<<10) | (control<< 12);
#ifdef DEBUGOUT
fprintf(stdout,"value=%d\n",value);
#endif
for (ibit=0; ibit<6; ibit++) {
bit=value & (1<<(15-ibit));
if (bit) {
putout("0000010001000000",imod);
putout("0000011001000000",imod);
putout("0000010001000000",imod);
#ifdef DEBUGOUT
fprintf(stdout,"1");
#endif
} else {
putout("0000000001000000",imod);
putout("0000001001000000",imod);
putout("0000000001000000",imod);
#ifdef DEBUGOUT
fprintf(stdout,"0");
#endif
}
}
for (ibit=0; ibit<10; ibit++) {
putout("0000000001000000",imod);
putout("0000001001000000",imod);
putout("0000000001000000",imod);
#ifdef DEBUGOUT
fprintf(stdout,"0");
#endif
}
#ifdef DEBUGOUT
fprintf(stdout,"\n");
#endif
return OK;
}
int initDACbyIndex(int ind,int val, int imod) {
int v;
const int partref[NDAC]=PARTREF;
@ -550,15 +509,16 @@ int initDACbyIndex(int ind,int val, int imod) {
int ref=partref[ind];
int r1=partr1[ind];
int r2=partr2[ind];
int retval[2];
v=(val+(val-ref)*r1/r2)*DAC_DR/DAC_MAX;
v=initDACbyIndexDACU(ind,v,imod);
v=initDACbyIndexDACU(ind,v,imod,0,retval);
return (v*DAC_MAX/DAC_DR+ref*r1/r2)/(1+r1/r2);
}
int initDACbyIndexDACU(int ind, int val, int imod) {
int initDACbyIndexDACU(int ind, int val, int imod, int mV, int retval[]) {
// const double daccs[NDAC]=DACCS;
// const double dacaddr[NDAC]=DACADDR;
@ -567,6 +527,8 @@ int initDACbyIndexDACU(int ind, int val, int imod) {
// int addr=dacaddr[ind];
// int iv;
int im;
if(mV)
val = (val*4096)/2500;
if (val>=0)
initDAC(ind,val, imod);
@ -597,123 +559,12 @@ int initDACbyIndexDACU(int ind, int val, int imod) {
#ifdef VERBOSE
printf("returning %d\n",setDACRegister(ind, -1, 0));
#endif
return setDACRegister(ind, -1, 0);
retval[0] = setDACRegister(ind, -1, 0);
retval[1] = (retval[0]*2500)/4096;
return retval[0];
}
}
int getThresholdEnergy() {
double g[3]=DEFAULTGAIN;
double o[3]=DEFAULTOFFSET;
double myg=-1, myo=-1;
// int dacu;
int imod;
int ethr=-1;
int ret=FAIL;
if (detectorModules) {
// for (imod=0; imod<getNModBoard(); imod++) {
for (imod=0; imod<nModX; imod++) {
#ifdef VERBOSE
printf("module=%d settings=%d, gain=%f, offset=%f\n",imod,thisSettings, (detectorModules+imod)->gain,(detectorModules+imod)->offset);
#endif
if ((detectorModules+imod)->gain>0)
myg=(detectorModules+imod)->gain;
else {
if (thisSettings>=0 && thisSettings<3)
myg=g[thisSettings];
// else
//myg=-1;
}
if ((detectorModules+imod)->offset>0)
myo=(detectorModules+imod)->offset;
else {
if (thisSettings>=0 && thisSettings<3)
myo=o[thisSettings];
// else
//myo=-1;
}
if (myg>0 && myo>0) {
//ethr=(myo-detectorDacs[VTHRESH+imod*NDAC])*1000/myg;
ethr=(myo-setDACRegister(VREF_DS,-1,imod))*1000/myg;//edited by dhanya
// else
// ethr=-1;
}
#ifdef VERBOSE
//printf("module=%d gain=%f, offset=%f, dacu=%f\n",imod, myg, myo, detectorDacs[VTHRESH+imod*NDAC]);
printf("module=%d gain=%f, offset=%f, dacu=%d\n",imod, myg, myo,(int)(setDACRegister(VREF_DS,-1,imod)));//edited by dhanya
printf("Threshold energy of module %d is %d eV\n", imod, ethr);
#endif
if (imod==0)
ret=ethr;
else {
if (ethr>(ret+100) || ethr<(ret-100))
return FAIL;
}
}
}
return ret;
}
int setThresholdEnergy(int ethr) {
double g[3]=DEFAULTGAIN;
double o[3]=DEFAULTOFFSET;
double myg=-1, myo=-1;
int dacu;
int imod;
int ret=ethr;
setSettings(GET_SETTINGS,-1);//-1 added by dhanya
if (thisSettings>=0 || thisSettings<3){
myg=g[thisSettings];
myo=o[thisSettings];
}
for (imod=0; imod<nModX; imod++) {
if (detectorModules) {
if ((detectorModules+imod)->gain>0)
myg=(detectorModules+imod)->gain;
else
if (thisSettings>=0 && thisSettings<3)
myg=g[thisSettings];
else
myg=-1;
if ((detectorModules+imod)->offset>0)
myo=(detectorModules+imod)->offset;
else
if (thisSettings>=0 && thisSettings<3)
myo=o[thisSettings];
else
myo=-1;
} else {
if (thisSettings>=0 && thisSettings<3)
myo=o[thisSettings];
else
myo=-1;
if (thisSettings>=0 && thisSettings<3)
myg=g[thisSettings];
else
myg=-1;
}
if (myg>0 && myo>0) {
dacu=myo-myg*((double)ethr)/1000.;
#ifdef VERBOSE
printf("module %d (%x): gain %f, off %f, energy %d eV, dac %d\n",imod,(unsigned int)((detectorModules+imod)),(detectorModules+imod)->gain,(detectorModules+imod)->offset, ethr,dacu);
#endif
} else {
dacu=ethr;
#ifdef VERBOSE
printf("could not set threshold energy for module %d, settings %d (offset is %f; gain is %f)\n",imod,thisSettings,myo,myg);
#endif
}
initDACbyIndexDACU(VREF_DS, dacu, imod); ///needs to be fixed dhanya
}
return ret;
}
int getDACbyIndexDACU(int ind, int imod) {

4
slsDetectorSoftware/gotthardDetectorServer/mcb_funcs.h
View File

@ -109,10 +109,8 @@ int initDAC(int dac_addr, int value,int imod );
int initDACs(int* v,int imod );
int setSettings(int i,int imod);
int initDACbyIndex(int ind,int val, int imod);
int initDACbyIndexDACU(int ind,int val, int imod);
int initDACbyIndexDACU(int ind,int val, int imod, int mV, int retval[]);
int getDACbyIndexDACU(int ind, int imod);
int getThresholdEnergy();
int setThresholdEnergy(int ethr);
/* Other DAC index routines*/
int getTemperatureByModule(int tempSensor, int imod);

53
slsDetectorSoftware/gotthardDetectorServer/server_funcs.c
View File

@ -891,13 +891,15 @@ int read_register(int file_des) {
int set_dac(int file_des) {
//default:all mods
int retval;
int retval[2];retval[1]=-1;
int temp;
int ret=OK;
int arg[2];
int arg[3];
enum dacIndex ind;
int imod;
int n;
int val;
int mV;
int idac=0;
sprintf(mess,"Can't set DAC\n");
@ -909,6 +911,7 @@ int set_dac(int file_des) {
}
ind=arg[0];
imod=arg[1];
mV=arg[2];
n = receiveDataOnly(file_des,&val,sizeof(val));
if (n < 0) {
@ -967,33 +970,37 @@ int set_dac(int file_des) {
ret=FAIL;
sprintf(mess,"Detector locked by %s\n",lastClientIP);
} else{
if(idac==HIGH_VOLTAGE)
retval=initHighVoltageByModule(val,imod);
else
retval=initDACbyIndexDACU(idac,val,imod);
if(idac==HIGH_VOLTAGE){
retval[0]=initHighVoltageByModule(val,imod);
ret=FAIL;
if(retval[0]==-2)
strcpy(mess,"Invalid Voltage.Valid values are 0,90,110,120,150,180,200");
else if(retval[0]==-3)
strcpy(mess,"Weird value read back or it has not been set yet\n");
else
ret=OK;
}else{
initDACbyIndexDACU(idac,val,imod,mV,retval);
ret=FAIL;
if(mV)
temp = retval[1];
else
temp = retval[0];
if ((abs(temp-val)<=3) || val==-1) {
ret=OK;
#ifdef VERBOSE
printf("DAC set to %d in dac units and %d mV\n", retval[0],retval[1]);
#endif
}
}
}
}
if(ret==OK){
ret=FAIL;
if(idac==HIGH_VOLTAGE){
if(retval==-2)
strcpy(mess,"Invalid Voltage.Valid values are 0,90,110,120,150,180,200");
else if(retval==-3)
strcpy(mess,"Weird value read back or it has not been set yet\n");
else
ret=OK;
}//since v r saving only msb
else if ((retval-val)<=3 || val==-1)
ret=OK;
}
#endif
#ifdef VERBOSE
printf("DAC set to %d V\n", retval);
#endif
if(ret==FAIL)
printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, retval);
printf("Setting dac %d of module %d: wrote %d but read %d\n", ind, imod, val, temp);
else{
if (differentClients)
ret=FORCE_UPDATE;

4
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp
View File

@ -2690,7 +2690,7 @@ int multiSlsDetector::getAngularConversion(int &direction, angleConversionCons
dacs_t multiSlsDetector::setDAC(dacs_t val, dacIndex idac, int imod) {
dacs_t multiSlsDetector::setDAC(dacs_t val, dacIndex idac, int mV, int imod) {
dacs_t ret, ret1=-100;
int id=-1, im=-1;
@ -2703,7 +2703,7 @@ dacs_t multiSlsDetector::setDAC(dacs_t val, dacIndex idac, int imod) {
for (int idet=dmi; idet<dma; idet++) {
if (detectors[idet]) {
ret=detectors[idet]->setDAC(val, idac, im);
ret=detectors[idet]->setDAC(val, idac, mV, im);
if(detectors[idet]->getErrorMask())
setErrorMask(getErrorMask()|(1<<idet));
if (ret1==-100)

4
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.h
View File

@ -856,10 +856,12 @@ class multiSlsDetector : public slsDetectorUtils {
set dacs value
\param val value (in V)
\param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules)
\returns current DAC value
*/
dacs_t setDAC(dacs_t val, dacIndex index, int imod=-1);
dacs_t setDAC(dacs_t val, dacIndex index , int mV, int imod=-1);
/**
set dacs value
\param val value (in V)

52
slsDetectorSoftware/slsDetector/slsDetector.cpp
View File

@ -655,6 +655,7 @@ int slsDetector::initializeDetectorSize(detectorType type) {
thisDetector->actionMask=0;
thisDetector->tenGigaEnable=0;
for (int ia=0; ia<MAX_ACTIONS; ia++) {
strcpy(thisDetector->actionScript[ia],"none");
@ -2000,16 +2001,17 @@ int slsDetector::readRegister(int addr){
}{};
*/
dacs_t slsDetector::setDAC(dacs_t val, dacIndex index, int imod){
dacs_t slsDetector::setDAC(dacs_t val, dacIndex index, int mV, int imod){
dacs_t retval;
dacs_t retval[2];
int fnum=F_SET_DAC;
int ret=FAIL;
char mess[100];
int arg[2];
int arg[3];
arg[0]=index;
arg[1]=imod;
arg[2]=mV;
#ifdef VERBOSE
std::cout<< std::endl;
@ -2022,16 +2024,16 @@ dacs_t slsDetector::setDAC(dacs_t val, dacIndex index, int imod){
controlSocket->SendDataOnly(&val,sizeof(val));
controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret!=FAIL) {
controlSocket->ReceiveDataOnly(&retval,sizeof(retval));
controlSocket->ReceiveDataOnly(retval,sizeof(retval));
if (index < thisDetector->nDacs){
if (dacs) {
if (imod>=0) {
*(dacs+index+imod*thisDetector->nDacs)=retval;
*(dacs+index+imod*thisDetector->nDacs)=retval[0];
}
else {
for (imod=0; imod<thisDetector->nModsMax; imod++)
*(dacs+index+imod*thisDetector->nDacs)=retval;
*(dacs+index+imod*thisDetector->nDacs)=retval[0];
}
}
}
@ -2046,12 +2048,15 @@ dacs_t slsDetector::setDAC(dacs_t val, dacIndex index, int imod){
}
}
#ifdef VERBOSE
std::cout<< "Dac set to "<< retval << std::endl;
std::cout<< "Dac set to "<< retval[0] << " dac units (" << retval[1] << "mV)" << std::endl;
#endif
if (ret==FAIL) {
std::cout<< "Set dac failed " << std::endl;
}
return retval;
if(mV)
return retval[1];
return retval[0];
};
@ -4930,6 +4935,7 @@ char* slsDetector::setReceiver(string receiverIP){
std::cout << "frame period:" << thisDetector->timerValue[FRAME_PERIOD] << endl;
std::cout << "frame number:" << thisDetector->timerValue[FRAME_NUMBER] << endl;
std::cout << "dynamic range:" << thisDetector->dynamicRange << endl << endl;
std::cout << "10GbE:" << thisDetector->tenGigaEnable << endl << endl;
/** enable compresison, */
#endif
if(setDetectorType()!= GENERIC){
@ -4950,6 +4956,8 @@ char* slsDetector::setReceiver(string receiverIP){
setDynamicRange(thisDetector->dynamicRange);
//set scan tag
setUDPConnection();
if(thisDetector->myDetectorType == EIGER)
enableTenGigabitEthernet(thisDetector->tenGigaEnable);
}
}
@ -6707,20 +6715,22 @@ int slsDetector::enableTenGigabitEthernet(int i){
if(ret!=FAIL){
//must also configuremac
if((i != -1)&&(retval == i))
configureMAC();
ret = FAIL;
retval=-1;
if(setReceiverOnline(ONLINE_FLAG)==ONLINE_FLAG){
#ifdef VERBOSE
std::cout << "Enabling / Disabling 10Gbe in receiver: " << i << std::endl;
#endif
if (connectData() == OK)
ret=thisReceiver->sendInt(fnum,retval,i);
if(ret==FAIL)
setErrorMask((getErrorMask())|(RECEIVER_TEN_GIGA));
}
if(configureMAC() != FAIL){
ret = FAIL;
retval=-1;
if(setReceiverOnline(ONLINE_FLAG)==ONLINE_FLAG){
#ifdef VERBOSE
std::cout << "Enabling / Disabling 10Gbe in receiver: " << i << std::endl;
#endif
if (connectData() == OK)
ret=thisReceiver->sendInt(fnum2,retval,i);
if(ret==FAIL)
setErrorMask((getErrorMask())|(RECEIVER_TEN_GIGA));
}
}
}
if(ret != FAIL)
thisDetector->tenGigaEnable=retval;
return retval;
}

6
slsDetectorSoftware/slsDetector/slsDetector.h
View File

@ -251,6 +251,9 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
/** online flag - is set if the receiver is connected, unset if socket connection is not possible */
int receiverOnlineFlag;
/** 10 Gbe enable*/
int tenGigaEnable;
} sharedSlsDetector;
@ -779,10 +782,11 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
set dacs value
\param val value (in V)
\param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules)
\returns current DAC value
*/
dacs_t setDAC(dacs_t val, dacIndex index, int imod=-1);
dacs_t setDAC(dacs_t val, dacIndex index , int mV, int imod=-1);
/**
set dacs value

2
slsDetectorSoftware/slsDetector/slsDetectorActions.cpp
View File

@ -423,7 +423,7 @@ int slsDetectorActions::executeScan(int level, int istep) {
setThresholdEnergy((int)currentScanVariable[level]); //energy scan
break;
case thresholdScan:
setDAC((dacs_t)currentScanVariable[level],THRESHOLD); // threshold scan
setDAC((dacs_t)currentScanVariable[level],THRESHOLD,0); // threshold scan
break;
case trimbitsScan:
trimbit=(int)currentScanVariable[level];

13
slsDetectorSoftware/slsDetector/slsDetectorActions.h
View File

@ -188,13 +188,14 @@ class slsDetectorActions : public virtual slsDetectorBase
/**
set dacs value
\param val value (in V)
\param index DAC index
\param imod module number (if -1 alla modules)
\returns current DAC value
set dacs value
\param val value (in V)
\param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules)
\returns current DAC value
*/
virtual dacs_t setDAC(dacs_t val, dacIndex index , int imod=-1)=0;
virtual dacs_t setDAC(dacs_t val, dacIndex index , int mV, int imod=-1)=0;
virtual int setThresholdEnergy(int, int im=-1, detectorSettings isettings=GET_SETTINGS)=0;

23
slsDetectorSoftware/slsDetector/slsDetectorCommand.cpp
View File

@ -3229,10 +3229,12 @@ string slsDetectorCommand::cmdDAC(int narg, char *args[], int action) {
if (action==HELP_ACTION)
return helpDAC(narg, args, action);
dacIndex dac;
dacs_t val=-1;
char answer[1000];
int mode=0;
if (cmd=="vthreshold")
dac=THRESHOLD;
else if (cmd=="vcalibration")
@ -3327,23 +3329,30 @@ string slsDetectorCommand::cmdDAC(int narg, char *args[], int action) {
myDet->setOnline(ONLINE_FLAG);
if (action==PUT_ACTION) {
if(narg > 2)
if(!strcasecmp(args[2],"mv"))
mode = 1;
#ifdef DACS_INT
if (sscanf(args[1],"%d", &val))
if (sscanf(args[1],"%d", &val))
#else
if (sscanf(args[1],"%f", &val))
if (sscanf(args[1],"%f", &val))
#endif
;
else
return string("cannot scan DAC value ")+string(args[1]);
myDet->setDAC(val,dac);
myDet->setDAC(val,dac,mode);
}
#ifdef DACS_INT
sprintf(answer,"%d",myDet->setDAC(-1,dac));
sprintf(answer,"%d",myDet->setDAC(-1,dac,mode));
#else
sprintf(answer,"%f",myDet->setDAC(-1,dac));
sprintf(answer,"%f",myDet->setDAC(-1,dac,mode));
#endif
if(mode)
strcat(answer,"mV");
return string(answer);
}
@ -3414,6 +3423,8 @@ string slsDetectorCommand::helpDAC(int narg, char *args[], int action) {
os << "vcn" << "dacu\t sets vcn " << std::endl;
os << "vis" << "dacu\t sets vis " << std::endl;
os << "<dac name> mv <value> if you want in mV else <dac name> <value> in dac units " << std::endl;
}
if (action==GET_ACTION || action==HELP_ACTION) {

151
slsDetectorSoftware/slsDetector/slsDetectorUtils.cpp
View File

@ -237,7 +237,7 @@ void slsDetectorUtils::acquire(int delflag){
aclog->addStep(getCurrentPosition(), getCurrentFileName());
if (eclog)
eclog->addStep(setDAC(-1,THRESHOLD), getCurrentFileName());
eclog->addStep(setDAC(-1,THRESHOLD,0), getCurrentFileName());
if (*correctionMask&(1<< I0_NORMALIZATION)) {
@ -773,45 +773,118 @@ int slsDetectorUtils::retrieveDetectorSetup(string const fname1, int level){
int slsDetectorUtils::dumpDetectorSetup(string const fname, int level){
slsDetectorCommand *cmd;
string names[100];
int nvar=0;
switch (getDetectorsType()) {
case EIGER:
names[nvar++]="fname";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="threshold";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="timing";
names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
break;
case GOTTHARD:
names[nvar++]="fname";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="delay";
names[nvar++]="gates";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="timing";
names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
break;
case MYTHEN:
names[nvar++]="fname";
names[nvar++]="index";
names[nvar++]="flags";
names[nvar++]="dr";
names[nvar++]="settings";
names[nvar++]="threshold";
names[nvar++]="exptime";
names[nvar++]="period";
names[nvar++]="delay";
names[nvar++]="gates";
names[nvar++]="frames";
names[nvar++]="cycles";
names[nvar++]="probes";
names[nvar++]="timing";
names[nvar++]="fineoff";
names[nvar++]="startscript";
names[nvar++]="startscriptpar";
names[nvar++]="stopscript";
names[nvar++]="stopscriptpar";
names[nvar++]="scriptbefore";
names[nvar++]="scriptbeforepar";
names[nvar++]="scriptafter";
names[nvar++]="scriptafterpar";
names[nvar++]="scan0script";
names[nvar++]="scan0par";
names[nvar++]="scan0prec";
names[nvar++]="scan0steps";
names[nvar++]="scan1script";
names[nvar++]="scan1par";
names[nvar++]="scan1prec";
names[nvar++]="scan1steps";
names[nvar++]="ratecorr";
names[nvar++]="flatfield";
names[nvar++]="badchannels";
names[nvar++]="trimbits";
break;
}
string names[]={
"fname",\
"index",\
"flags",\
"dr",\
"settings",\
"threshold",\
"exptime",\
"period",\
"delay",\
"gates",\
"frames",\
"cycles",\
"probes",\
"timing",\
"fineoff",\
"startscript",\
"startscriptpar",\
"stopscript",\
"stopscriptpar",\
"scriptbefore",\
"scriptbeforepar",\
"scriptafter",\
"scriptafterpar",\
"scan0script",\
"scan0par",\
"scan0prec",\
"scan0steps",\
"scan1script",\
"scan1par",\
"scan1prec",\
"scan1steps",\
"ratecorr",\
"flatfield",\
"badchannels",\
"trimbits"
};
int nvar=35;

3
slsDetectorSoftware/slsDetector/slsDetectorUtils.h
View File

@ -496,10 +496,11 @@ class slsDetectorUtils : public slsDetectorActions, public postProcessing {
set dacs value
\param val value (in V)
\param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules)
\returns current DAC value
*/
virtual dacs_t setDAC(dacs_t val, dacIndex index , int imod=-1)=0;
virtual dacs_t setDAC(dacs_t val, dacIndex index , int mV, int imod=-1)=0;
/**

6
slsDetectorSoftware/slsDetectorServer/slsDetectorFunctionList.h
View File

@ -34,9 +34,10 @@ int moduleTest( enum digitalTestMode arg, int imod);
int detectorTest( enum digitalTestMode arg);
int setDAC(enum detDacIndex ind, int val, int imod);
void setDAC(enum detDacIndex ind, int val, int imod, int mV, int retval[]);
int getADC(enum detDacIndex ind, int imod);
#if defined(EIGERD) || defined(GOTTHARD)
int setHighVolage(int val, int imod);
#endif
@ -125,6 +126,9 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg);
enum masterFlags setMaster(enum masterFlags arg);
enum synchronizationMode setSynchronization(enum synchronizationMode arg);
#ifdef EIGERD
void setExternalGating(int enable[]);
#endif
#endif

34
slsDetectorSoftware/slsDetectorServer/slsDetectorServer_funcs.c
View File

@ -1043,13 +1043,15 @@ int digital_test(int file_des) {
int set_dac(int file_des) {
int retval;
int retval[2];retval[1]=-1;
int temp;
int ret=OK,ret1=OK;
int arg[2];
int arg[3];
enum dacIndex ind;
int imod;
int n;
int val;
int mV;
enum detDacIndex idac=0;
sprintf(mess,"Can't set DAC\n");
@ -1062,6 +1064,7 @@ int set_dac(int file_des) {
}
ind=arg[0];
imod=arg[1];
mV=arg[2];
n = receiveData(file_des,&val,sizeof(val),INT32);
if (n < 0) {
@ -1182,25 +1185,33 @@ int set_dac(int file_des) {
sprintf(mess,"Detector locked by %s\n",lastClientIP);
} else{
if(ind == HV_POT)
retval = setHighVolage(val,imod);
retval[0] = setHighVolage(val,imod);
else if(ind == IO_DELAY)
retval = setIODelay(val,imod);
retval[0] = setIODelay(val,imod);
else
retval=setDAC(idac,val,imod);
setDAC(idac,val,imod,mV,retval);
}
}
#endif
#ifdef VERBOSE
printf("DAC set to %d V\n", retval);
printf("DAC set to %d in dac units and %d mV\n", retval[0],retval[1]);
#endif
if(ret == OK){
if ((abs(retval-val)<=5) || val==-1) {
if(mV)
temp = retval[1];
else
temp = retval[0];
if ((abs(temp-val)<=5) || val==-1) {
ret=OK;
if (differentClients)
ret=FORCE_UPDATE;
} else {
ret=FAIL;
printf("Setting dac %d of module %d: wrote %d but read %d\n", idac, imod, val, retval);
printf("Setting dac %d of module %d: wrote %d but read %d\n", idac, imod, val, temp);
}
}
@ -2977,6 +2988,7 @@ int configure_mac(int file_des) {
if (imod>=getTotalNumberOfModules()) {
ret=FAIL;
sprintf(mess,"Module number out of range %d\n",imod);
printf("mess:%s\n",mess);
}
#endif
#ifdef VERBOSE
@ -3384,14 +3396,14 @@ int enable_ten_giga(int file_des) {
}
/* execute action */
if(ret != FAIL){
#ifdef VERBOSE
//#ifdef VERBOSE
printf("Enabling 10Gbe :%d \n",arg);
#endif
//#endif
#ifdef SLS_DETECTOR_FUNCTION_LIST
retval=enableTenGigabitEthernet(arg);
if((arg != -1) && (retval != arg))
ret=FAIL;
else if (differentClients==1 && ret==OK) {
else if (differentClients==1) {
ret=FORCE_UPDATE;
}
#endif