detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-12 12:57:13 +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
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) if(slsErrorMask&RECEIVER_DET_HOSTTYPE_NOT_SET)
retval.append("Could not send the detector type to the receiver.\n"); 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) if(slsErrorMask&RECEIVER_DYNAMIC_RANGE)
retval.append("Could not set dynamic range in receiver.\n"); 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; 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>>8)&0xFF),
(unsigned int)((macad>>0)&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("Seting up Table Entry Left:\n");
printf("src_port:%d\n",src_port); printf("src_port:%d\n",src_port);
printf("dst_port:%d\n",dst_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>>8)&0xFF),
(unsigned int)((macad>>0)&0xFF)); (unsigned int)((macad>>0)&0xFF));
//strcpy(src_mac,"00:aa:bb:cc:dd:ee");
printf("Seting up Table Entry Right:\n"); printf("Seting up Table Entry Right:\n");
printf("src_port:%d\n",src_port); printf("src_port:%d\n",src_port);
printf("dst_port:%d\n",dst_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(){ int RequestImages(){
printf("Going to request images\n"); printf("Going to request images\n");
eiger_back_ret_val=0; 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(); return EigerBackSendCMD();
} }
int SetDestinationParameters(int i){ int SetDestinationParameters(int i){
SetLeftDestinationParameters(i);
return SetRightDestinationParameters(i);
}
int SetLeftDestinationParameters(int i){
eiger_back_ret_val=0; eiger_back_ret_val=0;
eiger_back_message_length = sprintf(eiger_back_message,"setdstparameters %d %d %d",ten_giga,1,i); eiger_back_message_length = sprintf(eiger_back_message,"setdstparameters %d %d %d",ten_giga,32,i);// number of dsts
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);
return EigerBackSendCMD(); return EigerBackSendCMD();
} }

300
slsDetectorSoftware/eigerDetectorServer/EigerHighLevelFunctions.c
View File

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

825
slsDetectorSoftware/eigerDetectorServer/FebServer.cxx
View File

@ -24,79 +24,66 @@
using namespace std; using namespace std;
enum cmd_string {evNotFound, enum cmd_string {evNotFound,
evReinitialize,evReset, evReinitialize,evReset,
evSetInputDelays, evSetInputDelays,
evSetDACValue,evGetDACValue,evSetDACVoltage,evGetDACVoltage,evSetHighVoltage,//evGetHighVoltage, evSetDACValue,evGetDACValue,evSetDACVoltage,evGetDACVoltage,evSetHighVoltage,//evGetHighVoltage,
evSetTrimBits, evSetTrimBits,
//evLoadTrimBitFile, //evLoadTrimBitFile,
evSetBitMode, evSetBitMode,
evSetPhotonEnergy, evSetPhotonEnergy,
// evSetPhotonEnergyCalibrationParameters,evActivateRateCorrection,evDeactivateRateCorrection,evSetRateCorrectionTau, // evSetPhotonEnergyCalibrationParameters,evActivateRateCorrection,evDeactivateRateCorrection,evSetRateCorrectionTau,
evSetReadoutSpeed,evSetReadoutMode, evSetReadoutSpeed,evSetReadoutMode,
//temp solution //temp solution
// evNotFound1,evNotFound2,evNotFound3, // evNotFound1,evNotFound2,evNotFound3,
evSetNumberOfExposures,evSetExposureTime,evSetExposurePeriod,
// evSetTriggerPolarityToPositive,evSetTriggerPolarityToNegative,
evSetTriggerMode,
// evEnableExternalGatingWhenSignalsPositive,evEnableExternalGatingWhenSignalsNegative,evDisableExternalGating,
evStartAcquisition,evStopAcquisition,evIsDaqStillRunning};
// evWaitUntilDaqFinished,evExitServer
evSetNumberOfExposures,evSetExposureTime,evSetExposurePeriod,
// evSetTriggerPolarityToPositive,evSetTriggerPolarityToNegative,
evSetTriggerMode,
evSetExternalGating,
evStartAcquisition,evStopAcquisition,evIsDaqStillRunning,
evWaitUntilDaqFinished,
evExitServer
};
map<string, cmd_string> enum_map; map<string, cmd_string> enum_map;
void init(){ void init(){
enum_map["reinitialize"] = evReinitialize; enum_map["reinitialize"] = evReinitialize;
enum_map["reset"] = evReset; enum_map["reset"] = evReset;
enum_map["setinputdelays"] = evSetInputDelays;
enum_map["setinputdelays"] = evSetInputDelays; enum_map["setdacvalue"] = evSetDACValue;
enum_map["setdacvalue"] = evSetDACValue; enum_map["getdacvalue"] = evGetDACValue;
enum_map["getdacvalue"] = evGetDACValue; enum_map["setdacvoltage"] = evSetDACVoltage;
enum_map["setdacvoltage"] = evSetDACVoltage; enum_map["getdacvoltage"] = evGetDACVoltage;
enum_map["getdacvoltage"] = evGetDACVoltage; enum_map["sethighvoltage"] = evSetHighVoltage;
enum_map["sethighvoltage"] = evSetHighVoltage; enum_map["settrimbits"] = evSetTrimBits;
// enum_map["loadtrimbitfile"] = evLoadTrimBitFile;
enum_map["settrimbits"] = evSetTrimBits; enum_map["setbitmode"] = evSetBitMode;
// enum_map["loadtrimbitfile"] = evLoadTrimBitFile; enum_map["setphotonenergy"] = evSetPhotonEnergy;
// enum_map["setphotonenergycalibrationparameters"] = evSetPhotonEnergyCalibrationParameters;
enum_map["setbitmode"] = evSetBitMode; // enum_map["activateratecorrection"] = evActivateRateCorrection;
enum_map["setphotonenergy"] = evSetPhotonEnergy; // enum_map["deactivateratecorrection"] = evDeactivateRateCorrection;
// enum_map["setphotonenergycalibrationparameters"] = evSetPhotonEnergyCalibrationParameters; // enum_map["setratecorrectiontau"] = evSetRateCorrectionTau;
// enum_map["activateratecorrection"] = evActivateRateCorrection; enum_map["setreadoutspeed"] = evSetReadoutSpeed;
// enum_map["deactivateratecorrection"] = evDeactivateRateCorrection; enum_map["setreadoutmode"] = evSetReadoutMode;
// enum_map["setratecorrectiontau"] = evSetRateCorrectionTau; enum_map["setnumberofexposures"] = evSetNumberOfExposures;
enum_map["setexposuretime"] = evSetExposureTime;
enum_map["setreadoutspeed"] = evSetReadoutSpeed; enum_map["setexposureperiod"] = evSetExposurePeriod;
enum_map["setreadoutmode"] = evSetReadoutMode; // enum_map["settriggerpolaritytopositive"] = evSetTriggerPolarityToPositive;
// enum_map["settriggerpolaritytonegative"] = evSetTriggerPolarityToNegative;
enum_map["settriggermode"] = evSetTriggerMode;
enum_map["setnumberofexposures"] = evSetNumberOfExposures; enum_map["setexternalgating"] = evSetExternalGating;
enum_map["setexposuretime"] = evSetExposureTime; enum_map["startacquisition"] = evStartAcquisition;
enum_map["setexposureperiod"] = evSetExposurePeriod; enum_map["stopacquisition"] = evStopAcquisition;
enum_map["isdaqstillrunning"] = evIsDaqStillRunning;
/* enum_map["waituntildaqfinished"] = evWaitUntilDaqFinished;
enum_map["settriggerpolaritytopositive"] = evSetTriggerPolarityToPositive; enum_map["exitserver"] = evExitServer;
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;
} }
int server_list_s; 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 void AddNumber(string& str, float v, int location=-1, bool space_after=0);//-1 means append
int main(int argc, char* argv[]){ int main(int argc, char* argv[]){
cout<<endl<<endl; cout<<endl<<endl;
/* /*
if(argc<2){ if(argc<2){
cout<<"Usage: feb_server port_number"<<endl<<endl; cout<<"Usage: feb_server port_number"<<endl<<endl;
return 1; return 1;
} }
*/ */
init(); init();
FebControl *feb_controler = new FebControl(); FebControl *feb_controler = new FebControl();
unsigned short int port_number = FEB_PORT; unsigned short int port_number = FEB_PORT;
if(!SetupListenSocket(port_number)) return 1; if(!SetupListenSocket(port_number)) return 1;
int length=1000;
char data[1000];
int stop = 0;
time_t rawtime;
struct tm *timeinfo;
while(!stop){ int length=1000;
char data[1000];
cout<<endl<<"\n\n\n\nWaiting for command -> "<<flush; int stop = 0;
int nread = AccpetConnectionAndWaitForData(data,length); time_t rawtime;
if(nread<=0) return 0; struct tm *timeinfo;
time(&rawtime); timeinfo=localtime(&rawtime);
cout<<asctime(timeinfo); while(!stop){
cout<<" Command received: "<<data<<endl<<endl;
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]; string tmp_str[5];
float v[4];//,v2,v3,v4,v5; float v[4];//,v2,v3,v4,v5;
int n[5]; int n[5];
string cmd = GetNextString(data,1); string cmd = GetNextString(data,1);
int ret_val = 1; int ret_val = 1;
string return_message = "\n\n\tCommand recieved: "; string return_message = "\n\n\tCommand recieved: ";
return_message.append(data); return_message.append(data);
return_message.append("\n"); return_message.append("\n");
int return_start_pos; int return_start_pos;
while(cmd.length()>0){ while(cmd.length()>0){
int ret_parameter = 0; int ret_parameter = 0;
return_start_pos = return_message.length(); return_start_pos = return_message.length();
switch(enum_map.find(LowerCase(cmd))->second){ switch(enum_map.find(LowerCase(cmd))->second){
case evReinitialize : case evReinitialize :
if(feb_controler->Init()){ if(feb_controler->Init()){
return_message.append("\tExecuted: Reinitialize\n"); return_message.append("\tExecuted: Reinitialize\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: Reinitialize\n"); return_message.append("\tError executing: Reinitialize\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evReset : case evReset :
if(feb_controler->Reset()){ if(feb_controler->Reset()){
return_message.append("\tExecuted: Reset\n"); return_message.append("\tExecuted: Reset\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: Reset\n"); return_message.append("\tError executing: Reset\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evSetInputDelays : case evSetInputDelays :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetIDelays(0,n[0])){ 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"); return_message.append("\tExecuted: SetInputDelays "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetInputDelays <delay>\n"); return_message.append("\tError executing: SetInputDelays <delay>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evSetDACValue : case evSetDACValue :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data); tmp_str[1] = GetNextString(data);
n[0] = atoi(tmp_str[1].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 evGetDACValue : if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0])){
tmp_str[0] = GetNextString(data); return_message.append("\tExecuted: SetDACValue "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0;
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter)){ }else{
return_message.append("\tExecuted: GetDACValue "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n"); return_message.append("\tError executing: SetDACValue <dac_name> <value>\n");
ret_val = 0; ret_val = 1;
}else{ }
return_message.append("\tError executing: GetDACValue <dac_name>\n"); break;
ret_val = 1;
}
break;
case evSetDACVoltage : case evGetDACValue :
tmp_str[0] = GetNextString(data); 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],1)){ if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter)){
return_message.append("\tExecuted: SetDACVoltage "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n"); return_message.append("\tExecuted: GetDACValue "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetDACVoltage <dac_name> <voltage_mV>\n"); return_message.append("\tError executing: GetDACValue <dac_name>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evGetDACVoltage : case evSetDACVoltage :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
tmp_str[1] = GetNextString(data);
if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter,1)){ n[0] = atoi(tmp_str[1].data());
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 : if(tmp_str[0].length()>0&&tmp_str[1].length()>0&&feb_controler->SetDAC(tmp_str[0],n[0],1)){
tmp_str[0] = GetNextString(data); return_message.append("\tExecuted: SetDACVoltage "); return_message.append(tmp_str[0]+" "); AddNumber(return_message,n[0]); return_message.append("\n");
v[0] = atof(tmp_str[0].data()); ret_val = 0;
}else{
if(tmp_str[0].length()>0&&feb_controler->SetHighVoltage(v[0])){ return_message.append("\tError executing: SetDACVoltage <dac_name> <voltage_mV>\n");
return_message.append("\tExecuted: SetHighVoltage "); AddNumber(return_message,v[0]); return_message.append("\n"); ret_val = 1;
ret_val = 0; }
}else{ break;
return_message.append("\tError executing: SetHighVoltage <voltage>\n");
ret_val = 1;
}
break;
case evSetTrimBits : case evGetDACVoltage :
/*if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){*/ tmp_str[0] = GetNextString(data);
feb_controler->SetTrimbits(0,(unsigned char*)data);
return_message.append("\tExecuted: SetTrimBits "); AddNumber(return_message,n[0]); return_message.append("\n"); if(tmp_str[0].length()>0&&feb_controler->GetDAC(tmp_str[0],ret_parameter,1)){
ret_val = 0; return_message.append("\tExecuted: GetDACVoltage "); return_message.append(tmp_str[0]+" -> ");AddNumber(return_message,ret_parameter); return_message.append(" mV\n");
/*}else{ 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"); return_message.append("\tError executing: SetTrimBits \n");
ret_val = 1; ret_val = 1;
} */ } */
break; break;
// case evLoadTrimBitFile : // case evLoadTrimBitFile :
case evSetBitMode : case evSetBitMode :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetDynamicRange(n[0])){ 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"); return_message.append("\tExecuted: SetBitMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetBitMode <mode 4,8,16,32>\n"); return_message.append("\tError executing: SetBitMode <mode 4,8,16,32>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evSetPhotonEnergy : case evSetPhotonEnergy :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetPhotonEnergy(n[0])){ 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"); return_message.append("\tExecuted: SetPhotonEnergy "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetPhotonEnergy <energy eV>\n"); return_message.append("\tError executing: SetPhotonEnergy <energy eV>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
// case evSetPhotonEnergyCalibrationParameters : // case evSetPhotonEnergyCalibrationParameters :
// case evActivateRateCorrection : // case evActivateRateCorrection :
// case evDeactivateRateCorrection : // case evDeactivateRateCorrection :
// case evSetRateCorrectionTau : // case evSetRateCorrectionTau :
case evSetReadoutSpeed : case evSetReadoutSpeed :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutSpeed(n[0])){ 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"); return_message.append("\tExecuted: SetReadoutSpeed "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetReadoutSpeed <speed 0-full 1-half 2-quarter 3-super_slow>\n"); return_message.append("\tError executing: SetReadoutSpeed <speed 0-full 1-half 2-quarter 3-super_slow>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evSetReadoutMode : case evSetReadoutMode :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetReadoutMode(n[0])){ 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"); return_message.append("\tExecuted: SetReadoutMode "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetReadoutMode <mode 0->parallel,1->non-parallel,2-> safe_mode>\n"); return_message.append("\tError executing: SetReadoutMode <mode 0->parallel,1->non-parallel,2-> safe_mode>\n");
ret_val = 1; ret_val = 1;
} }
break; break;
case evSetNumberOfExposures : case evSetNumberOfExposures :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
n[0] = atoi(tmp_str[0].data()); n[0] = atoi(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetNExposures(n[0])){ 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"); return_message.append("\tExecuted: SetNumberOfExposures "); AddNumber(return_message,n[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetNumberOfExposures <n>\n"); return_message.append("\tError executing: SetNumberOfExposures <n>\n");
ret_val = 1; ret_val = 1;
} }
break; 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 evSetExposurePeriod : case evSetExposureTime :
tmp_str[0] = GetNextString(data); tmp_str[0] = GetNextString(data);
v[0] = atof(tmp_str[0].data()); v[0] = atof(tmp_str[0].data());
if(tmp_str[0].length()>0&&feb_controler->SetExposurePeriod(v[0])){ if(tmp_str[0].length()>0&&feb_controler->SetExposureTime(v[0])){
return_message.append("\tExecuted: SetExposurePeriod "); AddNumber(return_message,v[0]); return_message.append("\n"); return_message.append("\tExecuted: SetExposureTime "); AddNumber(return_message,v[0]); return_message.append("\n");
ret_val = 0; ret_val = 0;
}else{ }else{
return_message.append("\tError executing: SetExposurePeriod <t_seconds>\n"); return_message.append("\tError executing: SetExposureTime <t_seconds>\n");
ret_val = 1; ret_val = 1;
} }
break; 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 evEnableExternalGatingWhenSignalsPositive : case evSetExposurePeriod :
// case evEnableExternalGatingWhenSignalsNegative : tmp_str[0] = GetNextString(data);
// case evDisableExternalGating : 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 : case evIsDaqStillRunning :
if(feb_controler->StartAcquisition()){ return_message.append("\tExecuted: evIsDaqStillRunning\n");
return_message.append("\tExecuted: StartAcquisition\n"); ret_parameter = feb_controler->AcquisitionInProgress();
ret_val = 0; ret_val = 0;
}else{ break;
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 : case evWaitUntilDaqFinished :
return_message.append("\tExecuted: evIsDaqStillRunning\n"); if(feb_controler->WaitForFinishedFlag()){
ret_parameter = feb_controler->AcquisitionInProgress(); return_message.append("\tExecuted: WaitUntilDaqFinished\n");
ret_val = 0; ret_val = 0;
break; }else{
return_message.append("\tError executing: WaitUntilDaqFinished\n");
/* ret_val = 1;
case evWaitUntilDaqFinished : }
if(feb_controler->WaitForFinishedFlag()){ break;
return_message.append("\tExecuted: WaitUntilDaqFinished\n");
ret_val = 0;
}else{
return_message.append("\tError executing: WaitUntilDaqFinished\n");
ret_val = 1;
}
break;
case evExitServer : case evExitServer :
return_message.append("\tExiting Server ....\n"); return_message.append("\tExiting Server ....\n");
stop = 1; stop = 1;
ret_val = -200; ret_val = -200;
break; 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; default :
break; 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"); ret_val=-100;
//AddNumber(return_message,ret_parameter,return_start_pos); break;
AddNumber(return_message,ret_val,return_start_pos,1); }
AddNumber(return_message,ret_parameter,0,1);
if(ret_val!=0) break;
cmd = GetNextString(data); // return_message.append("\n");
} //AddNumber(return_message,ret_parameter,return_start_pos);
return_message.append("\n\n\n"); 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); cmd = GetNextString(data);
cout<<return_message.c_str()<<endl; }
cout<<"\treturn: "<<ret_val<<endl; 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;
if(!WriteNClose(return_message.c_str(),return_message.length())) return 0;
delete feb_controler; }
return 0;
delete feb_controler;
return 0;
} }
string LowerCase(string str){ string LowerCase(string str){
string s = str; string s = str;
string::iterator i = s.begin(); string::iterator i = s.begin();
while(i!=s.end()) *i=tolower(*(i++)); while(i!=s.end()) *i=tolower(*(i++));
return s; return s;
} }
string GetNextString(string str,bool start_from_beginning){ string GetNextString(string str,bool start_from_beginning){
static string::size_type start_pos = 0; static string::size_type start_pos = 0;
if(start_from_beginning) 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);
start_pos = found; while(start_pos != string::npos){
if(start_pos != string::npos) start_pos+=1; 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; sub.erase(remove_if(sub.begin(),sub.end(), ::isspace ),sub.end());
}
if(sub.length()>0) return sub;
return ""; }
return "";
} }
void AddNumber(string& str, int n, int location, bool space_after){ void AddNumber(string& str, int n, int location, bool space_after){
static char retval_st[100]; static char retval_st[100];
if(space_after) sprintf(retval_st,"%d ",n); if(space_after) sprintf(retval_st,"%d ",n);
else sprintf(retval_st,"%d",n); else sprintf(retval_st,"%d",n);
if(location<0) str.append(retval_st); if(location<0) str.append(retval_st);
else str.insert(location,retval_st); else str.insert(location,retval_st);
} }
void AddNumber(string& str, float v, int location, bool space_after){ void AddNumber(string& str, float v, int location, bool space_after){
static char retval_st[100]; static char retval_st[100];
if(space_after) sprintf(retval_st,"%f ",v); if(space_after) sprintf(retval_st,"%f ",v);
else sprintf(retval_st,"%f",v); else sprintf(retval_st,"%f",v);
if(location<0) str.append(retval_st); if(location<0) str.append(retval_st);
else str.insert(location,retval_st); else str.insert(location,retval_st);
} }
bool SetupListenSocket(unsigned short int port){ bool SetupListenSocket(unsigned short int port){
server_list_s=0; server_list_s=0;
server_conn_s=0; server_conn_s=0;
if((server_list_s = socket(AF_INET, SOCK_STREAM, 0))<0) return 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(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() */ if(bind(server_list_s,(struct sockaddr *) &servaddr,sizeof(servaddr))<0) return 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){ 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'; buffer[nread]='\0';
return nread; return nread;
} }
bool WriteNClose(const char* buffer, int length){ bool WriteNClose(const char* buffer, int length){
if(server_conn_s==0||length<=0) return 0; if(server_conn_s==0||length<=0) return 0;
int nsent = write(server_conn_s,buffer,length); int nsent = write(server_conn_s,buffer,length);
if(close(server_conn_s)<0) return 0; if(close(server_conn_s)<0) return 0;
server_conn_s=0; server_conn_s=0;
return (nsent==length); 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 //get dac values
for(i=0;i<(detectorModules)->ndac;i++) int retval[2];
(detectorModules)->dacs[i] = setDAC((enum detDacIndex)i,-1,(detectorModules)->module); 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. */ /* initialize dynamic range etc. */
@ -88,6 +91,8 @@ int initDetector(){
setHighVolage(150,0); setHighVolage(150,0);
setIODelay(675,0); setIODelay(675,0);
setTiming(AUTO_TIMING); setTiming(AUTO_TIMING);
int enable[2] = {0,1};
setExternalGating(enable);//disable external gating
return 1; 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]; char iname[10];
strcpy(iname,EigerGetDACName((int)ind)); strcpy(iname,EigerGetDACName((int)ind));
//#ifdef VERBOSE #ifdef VERBOSE
if(val >= 0) 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 else
printf("Getting dac %d: %s\n",ind, iname); printf("Getting dac %d: %s ",ind, iname);
//#endif if(mV)
printf("in mV\n");
else
printf("in dac units\n");
#endif
if(val >= 0) 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); SetTenGigbaBitEthernet(1);
else else
SetTenGigbaBitEthernet(0); SetTenGigbaBitEthernet(0);
SetDestinationParameters(EigerGetNumberOfExposures()*EigerGetNumberOfCycles());
//configuremac called from client //configuremac called from client
} }
return GetTenGigbaBitEthernet(); return GetTenGigbaBitEthernet();
@ -268,12 +279,13 @@ int enableTenGigabitEthernet(int val){
int setModule(sls_detector_module myMod){ int setModule(sls_detector_module myMod){
int retval[2];
#ifdef VERBOSE #ifdef VERBOSE
printf("Setting module with settings %d\n",myMod.reg); printf("Setting module with settings %d\n",myMod.reg);
#endif #endif
int i; int i;
for(i=0;i<myMod.ndac;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; thisSettings = (enum detectorSettings)myMod.reg;
@ -357,11 +369,14 @@ enum runStatus getRunStatus(){
char *readFrame(int *ret, char *mess){ char *readFrame(int *ret, char *mess){
EigerWaitForAcquisitionFinish();
/*
int i = EigerRunStatus(); int i = EigerRunStatus();
while(i){ while(i){
i = EigerRunStatus(); i = EigerRunStatus();
usleep(1000);/* should be watiing in server*/ usleep(1000);
}*ret = (int)FINISHED; }*/
*ret = (int)FINISHED;
return NULL; 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){ int configureMAC(int ipad, long long int macad, long long int detectormacadd, int detipad, int udpport, int ival){
EigerSetupTableEntryLeft(ipad, macad, detectormacadd, detipad, udpport); EigerSetupTableEntryLeft(ipad, macad, detectormacadd, detipad, udpport);
EigerSetupTableEntryRight(ipad, macad, detectormacadd, detipad, udpport); EigerSetupTableEntryRight(ipad, macad, detectormacadd, detipad, udpport);
SetDestinationParameters(EigerGetNumberOfExposures()*EigerGetNumberOfCycles());
return 0; return 0;
} }
@ -622,10 +638,10 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg){
case GATE_FIX_NUMBER: ret = 3; break; case GATE_FIX_NUMBER: ret = 3; break;
} }
printf(" Setting Triggering Mode: %d\n",(int)ret); printf(" Setting Triggering Mode: %d\n",(int)ret);
//EigerSetTriggerMode(ret); EigerSetTriggerMode(ret);
} }
ret=0;
//ret = EigerGetTriggerMode(); ret = EigerGetTriggerMode();
switch((int)ret){ switch((int)ret){
case 0: ret = AUTO_TIMING; break; case 0: ret = AUTO_TIMING; break;
case 2: ret = TRIGGER_EXPOSURE; 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){ enum masterFlags setMaster(enum masterFlags arg){
return NO_MASTER; 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 initDACbyIndex(int ind,int val, int imod) {
int v; int v;
const int partref[NDAC]=PARTREF; const int partref[NDAC]=PARTREF;
@ -550,15 +509,16 @@ int initDACbyIndex(int ind,int val, int imod) {
int ref=partref[ind]; int ref=partref[ind];
int r1=partr1[ind]; int r1=partr1[ind];
int r2=partr2[ind]; int r2=partr2[ind];
int retval[2];
v=(val+(val-ref)*r1/r2)*DAC_DR/DAC_MAX; 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); 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 daccs[NDAC]=DACCS;
// const double dacaddr[NDAC]=DACADDR; // const double dacaddr[NDAC]=DACADDR;
@ -567,6 +527,8 @@ int initDACbyIndexDACU(int ind, int val, int imod) {
// int addr=dacaddr[ind]; // int addr=dacaddr[ind];
// int iv; // int iv;
int im; int im;
if(mV)
val = (val*4096)/2500;
if (val>=0) if (val>=0)
initDAC(ind,val, imod); initDAC(ind,val, imod);
@ -597,123 +559,12 @@ int initDACbyIndexDACU(int ind, int val, int imod) {
#ifdef VERBOSE #ifdef VERBOSE
printf("returning %d\n",setDACRegister(ind, -1, 0)); printf("returning %d\n",setDACRegister(ind, -1, 0));
#endif #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) { 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 initDACs(int* v,int imod );
int setSettings(int i,int imod); int setSettings(int i,int imod);
int initDACbyIndex(int ind,int val, 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 getDACbyIndexDACU(int ind, int imod);
int getThresholdEnergy();
int setThresholdEnergy(int ethr);
/* Other DAC index routines*/ /* Other DAC index routines*/
int getTemperatureByModule(int tempSensor, int imod); 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) { int set_dac(int file_des) {
//default:all mods //default:all mods
int retval; int retval[2];retval[1]=-1;
int temp;
int ret=OK; int ret=OK;
int arg[2]; int arg[3];
enum dacIndex ind; enum dacIndex ind;
int imod; int imod;
int n; int n;
int val; int val;
int mV;
int idac=0; int idac=0;
sprintf(mess,"Can't set DAC\n"); sprintf(mess,"Can't set DAC\n");
@ -909,6 +911,7 @@ int set_dac(int file_des) {
} }
ind=arg[0]; ind=arg[0];
imod=arg[1]; imod=arg[1];
mV=arg[2];
n = receiveDataOnly(file_des,&val,sizeof(val)); n = receiveDataOnly(file_des,&val,sizeof(val));
if (n < 0) { if (n < 0) {
@ -967,33 +970,37 @@ int set_dac(int file_des) {
ret=FAIL; ret=FAIL;
sprintf(mess,"Detector locked by %s\n",lastClientIP); sprintf(mess,"Detector locked by %s\n",lastClientIP);
} else{ } else{
if(idac==HIGH_VOLTAGE) if(idac==HIGH_VOLTAGE){
retval=initHighVoltageByModule(val,imod); retval[0]=initHighVoltageByModule(val,imod);
else ret=FAIL;
retval=initDACbyIndexDACU(idac,val,imod); 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 #endif
#ifdef VERBOSE
printf("DAC set to %d V\n", retval);
#endif
if(ret==FAIL) 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{ else{
if (differentClients) if (differentClients)
ret=FORCE_UPDATE; 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; dacs_t ret, ret1=-100;
int id=-1, im=-1; 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++) { for (int idet=dmi; idet<dma; idet++) {
if (detectors[idet]) { if (detectors[idet]) {
ret=detectors[idet]->setDAC(val, idac, im); ret=detectors[idet]->setDAC(val, idac, mV, im);
if(detectors[idet]->getErrorMask()) if(detectors[idet]->getErrorMask())
setErrorMask(getErrorMask()|(1<<idet)); setErrorMask(getErrorMask()|(1<<idet));
if (ret1==-100) if (ret1==-100)

4
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.h
View File

@ -856,10 +856,12 @@ class multiSlsDetector : public slsDetectorUtils {
set dacs value set dacs value
\param val value (in V) \param val value (in V)
\param index DAC index \param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules) \param imod module number (if -1 alla modules)
\returns current DAC value \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 set dacs value
\param val value (in V) \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->actionMask=0;
thisDetector->tenGigaEnable=0;
for (int ia=0; ia<MAX_ACTIONS; ia++) { for (int ia=0; ia<MAX_ACTIONS; ia++) {
strcpy(thisDetector->actionScript[ia],"none"); 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 fnum=F_SET_DAC;
int ret=FAIL; int ret=FAIL;
char mess[100]; char mess[100];
int arg[2]; int arg[3];
arg[0]=index; arg[0]=index;
arg[1]=imod; arg[1]=imod;
arg[2]=mV;
#ifdef VERBOSE #ifdef VERBOSE
std::cout<< std::endl; 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->SendDataOnly(&val,sizeof(val));
controlSocket->ReceiveDataOnly(&ret,sizeof(ret)); controlSocket->ReceiveDataOnly(&ret,sizeof(ret));
if (ret!=FAIL) { if (ret!=FAIL) {
controlSocket->ReceiveDataOnly(&retval,sizeof(retval)); controlSocket->ReceiveDataOnly(retval,sizeof(retval));
if (index < thisDetector->nDacs){ if (index < thisDetector->nDacs){
if (dacs) { if (dacs) {
if (imod>=0) { if (imod>=0) {
*(dacs+index+imod*thisDetector->nDacs)=retval; *(dacs+index+imod*thisDetector->nDacs)=retval[0];
} }
else { else {
for (imod=0; imod<thisDetector->nModsMax; imod++) 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 #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 #endif
if (ret==FAIL) { if (ret==FAIL) {
std::cout<< "Set dac failed " << std::endl; 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 period:" << thisDetector->timerValue[FRAME_PERIOD] << endl;
std::cout << "frame number:" << thisDetector->timerValue[FRAME_NUMBER] << endl; std::cout << "frame number:" << thisDetector->timerValue[FRAME_NUMBER] << endl;
std::cout << "dynamic range:" << thisDetector->dynamicRange << endl << endl; std::cout << "dynamic range:" << thisDetector->dynamicRange << endl << endl;
std::cout << "10GbE:" << thisDetector->tenGigaEnable << endl << endl;
/** enable compresison, */ /** enable compresison, */
#endif #endif
if(setDetectorType()!= GENERIC){ if(setDetectorType()!= GENERIC){
@ -4950,6 +4956,8 @@ char* slsDetector::setReceiver(string receiverIP){
setDynamicRange(thisDetector->dynamicRange); setDynamicRange(thisDetector->dynamicRange);
//set scan tag //set scan tag
setUDPConnection(); setUDPConnection();
if(thisDetector->myDetectorType == EIGER)
enableTenGigabitEthernet(thisDetector->tenGigaEnable);
} }
} }
@ -6707,20 +6715,22 @@ int slsDetector::enableTenGigabitEthernet(int i){
if(ret!=FAIL){ if(ret!=FAIL){
//must also configuremac //must also configuremac
if((i != -1)&&(retval == i)) if((i != -1)&&(retval == i))
configureMAC(); if(configureMAC() != FAIL){
ret = FAIL;
ret = FAIL; retval=-1;
retval=-1; if(setReceiverOnline(ONLINE_FLAG)==ONLINE_FLAG){
if(setReceiverOnline(ONLINE_FLAG)==ONLINE_FLAG){ #ifdef VERBOSE
#ifdef VERBOSE std::cout << "Enabling / Disabling 10Gbe in receiver: " << i << std::endl;
std::cout << "Enabling / Disabling 10Gbe in receiver: " << i << std::endl; #endif
#endif if (connectData() == OK)
if (connectData() == OK) ret=thisReceiver->sendInt(fnum2,retval,i);
ret=thisReceiver->sendInt(fnum,retval,i); if(ret==FAIL)
if(ret==FAIL) setErrorMask((getErrorMask())|(RECEIVER_TEN_GIGA));
setErrorMask((getErrorMask())|(RECEIVER_TEN_GIGA)); }
} }
} }
if(ret != FAIL)
thisDetector->tenGigaEnable=retval;
return 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 */ /** online flag - is set if the receiver is connected, unset if socket connection is not possible */
int receiverOnlineFlag; int receiverOnlineFlag;
/** 10 Gbe enable*/
int tenGigaEnable;
} sharedSlsDetector; } sharedSlsDetector;
@ -779,10 +782,11 @@ class slsDetector : public slsDetectorUtils, public energyConversion {
set dacs value set dacs value
\param val value (in V) \param val value (in V)
\param index DAC index \param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules) \param imod module number (if -1 alla modules)
\returns current DAC value \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 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 setThresholdEnergy((int)currentScanVariable[level]); //energy scan
break; break;
case thresholdScan: case thresholdScan:
setDAC((dacs_t)currentScanVariable[level],THRESHOLD); // threshold scan setDAC((dacs_t)currentScanVariable[level],THRESHOLD,0); // threshold scan
break; break;
case trimbitsScan: case trimbitsScan:
trimbit=(int)currentScanVariable[level]; trimbit=(int)currentScanVariable[level];

13
slsDetectorSoftware/slsDetector/slsDetectorActions.h
View File

@ -188,13 +188,14 @@ class slsDetectorActions : public virtual slsDetectorBase
/** /**
set dacs value set dacs value
\param val value (in V) \param val value (in V)
\param index DAC index \param index DAC index
\param imod module number (if -1 alla modules) \param mV 0 in dac units or 1 in mV
\returns current DAC value \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; 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) if (action==HELP_ACTION)
return helpDAC(narg, args, action); return helpDAC(narg, args, action);
dacIndex dac; dacIndex dac;
dacs_t val=-1; dacs_t val=-1;
char answer[1000]; char answer[1000];
int mode=0;
if (cmd=="vthreshold") if (cmd=="vthreshold")
dac=THRESHOLD; dac=THRESHOLD;
else if (cmd=="vcalibration") else if (cmd=="vcalibration")
@ -3327,23 +3329,30 @@ string slsDetectorCommand::cmdDAC(int narg, char *args[], int action) {
myDet->setOnline(ONLINE_FLAG); myDet->setOnline(ONLINE_FLAG);
if (action==PUT_ACTION) { if (action==PUT_ACTION) {
if(narg > 2)
if(!strcasecmp(args[2],"mv"))
mode = 1;
#ifdef DACS_INT #ifdef DACS_INT
if (sscanf(args[1],"%d", &val))
if (sscanf(args[1],"%d", &val))
#else #else
if (sscanf(args[1],"%f", &val)) if (sscanf(args[1],"%f", &val))
#endif #endif
; ;
else else
return string("cannot scan DAC value ")+string(args[1]); return string("cannot scan DAC value ")+string(args[1]);
myDet->setDAC(val,dac); myDet->setDAC(val,dac,mode);
} }
#ifdef DACS_INT #ifdef DACS_INT
sprintf(answer,"%d",myDet->setDAC(-1,dac)); sprintf(answer,"%d",myDet->setDAC(-1,dac,mode));
#else #else
sprintf(answer,"%f",myDet->setDAC(-1,dac)); sprintf(answer,"%f",myDet->setDAC(-1,dac,mode));
#endif #endif
if(mode)
strcat(answer,"mV");
return string(answer); 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 << "vcn" << "dacu\t sets vcn " << std::endl;
os << "vis" << "dacu\t sets vis " << 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) { 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()); aclog->addStep(getCurrentPosition(), getCurrentFileName());
if (eclog) if (eclog)
eclog->addStep(setDAC(-1,THRESHOLD), getCurrentFileName()); eclog->addStep(setDAC(-1,THRESHOLD,0), getCurrentFileName());
if (*correctionMask&(1<< I0_NORMALIZATION)) { 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){ int slsDetectorUtils::dumpDetectorSetup(string const fname, int level){
slsDetectorCommand *cmd; 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 set dacs value
\param val value (in V) \param val value (in V)
\param index DAC index \param index DAC index
\param mV 0 in dac units or 1 in mV
\param imod module number (if -1 alla modules) \param imod module number (if -1 alla modules)
\returns current DAC value \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 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); int getADC(enum detDacIndex ind, int imod);
#if defined(EIGERD) || defined(GOTTHARD) #if defined(EIGERD) || defined(GOTTHARD)
int setHighVolage(int val, int imod); int setHighVolage(int val, int imod);
#endif #endif
@ -125,6 +126,9 @@ enum externalCommunicationMode setTiming( enum externalCommunicationMode arg);
enum masterFlags setMaster(enum masterFlags arg); enum masterFlags setMaster(enum masterFlags arg);
enum synchronizationMode setSynchronization(enum synchronizationMode arg); enum synchronizationMode setSynchronization(enum synchronizationMode arg);
#ifdef EIGERD
void setExternalGating(int enable[]);
#endif
#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 set_dac(int file_des) {
int retval; int retval[2];retval[1]=-1;
int temp;
int ret=OK,ret1=OK; int ret=OK,ret1=OK;
int arg[2]; int arg[3];
enum dacIndex ind; enum dacIndex ind;
int imod; int imod;
int n; int n;
int val; int val;
int mV;
enum detDacIndex idac=0; enum detDacIndex idac=0;
sprintf(mess,"Can't set DAC\n"); sprintf(mess,"Can't set DAC\n");
@ -1062,6 +1064,7 @@ int set_dac(int file_des) {
} }
ind=arg[0]; ind=arg[0];
imod=arg[1]; imod=arg[1];
mV=arg[2];
n = receiveData(file_des,&val,sizeof(val),INT32); n = receiveData(file_des,&val,sizeof(val),INT32);
if (n < 0) { if (n < 0) {
@ -1182,25 +1185,33 @@ int set_dac(int file_des) {
sprintf(mess,"Detector locked by %s\n",lastClientIP); sprintf(mess,"Detector locked by %s\n",lastClientIP);
} else{ } else{
if(ind == HV_POT) if(ind == HV_POT)
retval = setHighVolage(val,imod); retval[0] = setHighVolage(val,imod);
else if(ind == IO_DELAY) else if(ind == IO_DELAY)
retval = setIODelay(val,imod); retval[0] = setIODelay(val,imod);
else else
retval=setDAC(idac,val,imod); setDAC(idac,val,imod,mV,retval);
} }
} }
#endif #endif
#ifdef VERBOSE #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 #endif
if(ret == OK){ 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; ret=OK;
if (differentClients) if (differentClients)
ret=FORCE_UPDATE; ret=FORCE_UPDATE;
} else { } else {
ret=FAIL; 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()) { if (imod>=getTotalNumberOfModules()) {
ret=FAIL; ret=FAIL;
sprintf(mess,"Module number out of range %d\n",imod); sprintf(mess,"Module number out of range %d\n",imod);
printf("mess:%s\n",mess);
} }
#endif #endif
#ifdef VERBOSE #ifdef VERBOSE
@ -3384,14 +3396,14 @@ int enable_ten_giga(int file_des) {
} }
/* execute action */ /* execute action */
if(ret != FAIL){ if(ret != FAIL){
#ifdef VERBOSE //#ifdef VERBOSE
printf("Enabling 10Gbe :%d \n",arg); printf("Enabling 10Gbe :%d \n",arg);
#endif //#endif
#ifdef SLS_DETECTOR_FUNCTION_LIST #ifdef SLS_DETECTOR_FUNCTION_LIST
retval=enableTenGigabitEthernet(arg); retval=enableTenGigabitEthernet(arg);
if((arg != -1) && (retval != arg)) if((arg != -1) && (retval != arg))
ret=FAIL; ret=FAIL;
else if (differentClients==1 && ret==OK) { else if (differentClients==1) {
ret=FORCE_UPDATE; ret=FORCE_UPDATE;
} }
#endif #endif