detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-23 23:10:02 +02:00
Code Issues Actions Packages Releases Activity
slsDetectorPackage/slsDetectorServers/slsDetectorServer/slsDetectorServer_funcs.c
Dhanya Thattil f80483de6e ctb server: (bug fixes, udp sending feature instead of tcp, better debugging prints, 
digital readout mode (fifoempty flag in status register is always up, so it is idle for this readout mode),
pattern loop bugs, max_pattern_length redefined in server side, do not update period for ctb and moench in setreceiver
2019-02-28 08:46:26 +01:00

3494 lines
96 KiB
C
Executable File
Raw Blame History

#include "slsDetectorServer_funcs.h"
#include "slsDetectorFunctionList.h"
#include "communication_funcs.h"
#include "logger.h"
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
#include "communication_funcs_UDP.h"
#include "UDPPacketHeaderGenerator.h"
extern uint64_t udpFrameNumber;
extern uint32_t udpPacketNumber;
#endif
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
//defined in the detector specific Makefile
#ifdef GOTTHARDD
const enum detectorType myDetectorType = GOTTHARD;
#elif EIGERD
const enum detectorType myDetectorType = EIGER;
#elif JUNGFRAUD
const enum detectorType myDetectorType = JUNGFRAU;
#elif CHIPTESTBOARDD
const enum detectorType myDetectorType = CHIPTESTBOARD;
#elif MOENCHD
const enum detectorType myDetectorType = MOENCH;
#else
const enum detectorType myDetectorType = GENERIC;
#endif
// Global variables from communication_funcs
extern int lockStatus;
extern char lastClientIP[INET_ADDRSTRLEN];
extern char thisClientIP[INET_ADDRSTRLEN];
extern int differentClients;
extern int isControlServer;
extern int ret;
extern int fnum;
extern char mess[MAX_STR_LENGTH];
// Variables that will be exported
int sockfd = 0;
int debugflag = 0;
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
int dataBytes = 0;
char* ramValues = 0;
#endif
// Local variables
int (*flist[NUM_DET_FUNCTIONS])(int);
#ifdef EIGERD
uint32_t dhcpipad = 0;
#endif
enum updateRet {NO_UPDATE, UPDATE};
/* initialization functions */
int printSocketReadError() {
FILE_LOG(logERROR, ("Error reading from socket. Possible socket crash.\n"));
return FAIL;
}
void init_detector() {
#ifdef VIRTUAL
FILE_LOG(logINFO, ("This is a VIRTUAL detector\n"));
#endif
if (isControlServer) {
basictests();
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
if (debugflag != PROGRAMMING_MODE)
#endif
initControlServer();
#ifdef EIGERD
dhcpipad = getDetectorIP();
#endif
}
else initStopServer();
strcpy(mess,"dummy message");
strcpy(lastClientIP,"none");
strcpy(thisClientIP,"none1");
lockStatus=0;
}
int decode_function(int file_des) {
ret = FAIL;
int n = receiveData(file_des,&fnum,sizeof(fnum),INT32);
if (n <= 0) {
FILE_LOG(logDEBUG3, ("ERROR reading from socket n=%d, fnum=%d, file_des=%d, fname=%s\n",
n, fnum, file_des, getFunctionName((enum detFuncs)fnum)));
return FAIL;
} else
FILE_LOG(logDEBUG3, ("Received %d bytes\n", n ));
// jungfrau in programming mode
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
if ((debugflag == PROGRAMMING_MODE) &&
(fnum != F_PROGRAM_FPGA) &&
(fnum != F_GET_DETECTOR_TYPE) &&
(fnum != F_RESET_FPGA) &&
(fnum != F_UPDATE_CLIENT) &&
(fnum != F_CHECK_VERSION)) {
ret = (M_nofuncMode)(file_des);
}
else
#endif
if (fnum < 0 || fnum >= NUM_DET_FUNCTIONS) {
FILE_LOG(logERROR, ("Unknown function enum %d\n", fnum));
ret=(M_nofunc)(file_des);
} else {
FILE_LOG(logDEBUG1, (" calling function fnum=%d, (%s)\n",
fnum, getFunctionName((enum detFuncs)fnum)));
ret = (*flist[fnum])(file_des);
if (ret == FAIL) {
FILE_LOG(logDEBUG1, ("Error executing the function = %d (%s)\n",
fnum, getFunctionName((enum detFuncs)fnum)));
} else FILE_LOG(logDEBUG1, ("Function (%s) executed %s\n",
getFunctionName((enum detFuncs)fnum), (ret == OK)?"OK":"FORCE_UPDATE"));
}
return ret;
}
const char* getTimerName(enum timerIndex ind) {
switch (ind) {
case FRAME_NUMBER: return "frame_number";
case ACQUISITION_TIME: return "acquisition_time";
case FRAME_PERIOD: return "frame_period";
case DELAY_AFTER_TRIGGER: return "delay_after_trigger";
case GATES_NUMBER: return "gates_number";
case CYCLES_NUMBER: return "cycles_number";
case ACTUAL_TIME: return "actual_time";
case MEASUREMENT_TIME: return "measurement_time";
case PROGRESS: return "progress";
case MEASUREMENTS_NUMBER: return "measurements_number";
case FRAMES_FROM_START: return "frames_from_start";
case FRAMES_FROM_START_PG: return "frames_from_start_pg";
case SAMPLES: return "samples";
case SUBFRAME_ACQUISITION_TIME: return "subframe_acquisition_time";
case SUBFRAME_DEADTIME: return "subframe_deadtime";
case STORAGE_CELL_NUMBER: return "storage_cell_number";
default: return "unknown_timer";
}
}
const char* getSpeedName(enum speedVariable ind) {
switch (ind) {
case CLOCK_DIVIDER: return "clock_divider";
case PHASE_SHIFT: return "phase_shift";
case OVERSAMPLING: return "oversampling";
case ADC_CLOCK: return "adc_clock";
case ADC_PHASE: return "adc_phase";
case ADC_PIPELINE: return "adc_pipeline";
case DBIT_CLOCK: return "dbit_clock";
case DBIT_PHASE: return "dbit_phase";
case DBIT_PIPELINE: return "dbit_pipeline";
default: return "unknown_speed";
}
}
const char* getFunctionName(enum detFuncs func) {
switch (func) {
case F_EXEC_COMMAND: return "F_EXEC_COMMAND";
case F_GET_DETECTOR_TYPE: return "F_GET_DETECTOR_TYPE";
case F_SET_EXTERNAL_SIGNAL_FLAG: return "F_SET_EXTERNAL_SIGNAL_FLAG";
case F_SET_EXTERNAL_COMMUNICATION_MODE: return "F_SET_EXTERNAL_COMMUNICATION_MODE";
case F_GET_ID: return "F_GET_ID";
case F_DIGITAL_TEST: return "F_DIGITAL_TEST";
case F_SET_DAC: return "F_SET_DAC";
case F_GET_ADC: return "F_GET_ADC";
case F_WRITE_REGISTER: return "F_WRITE_REGISTER";
case F_READ_REGISTER: return "F_READ_REGISTER";
case F_SET_MODULE: return "F_SET_MODULE";
case F_GET_MODULE: return "F_GET_MODULE";
case F_SET_SETTINGS: return "F_SET_SETTINGS";
case F_GET_THRESHOLD_ENERGY: return "F_GET_THRESHOLD_ENERGY";
case F_START_ACQUISITION: return "F_START_ACQUISITION";
case F_STOP_ACQUISITION: return "F_STOP_ACQUISITION";
case F_START_READOUT: return "F_START_READOUT";
case F_GET_RUN_STATUS: return "F_GET_RUN_STATUS";
case F_START_AND_READ_ALL: return "F_START_AND_READ_ALL";
case F_READ_ALL: return "F_READ_ALL";
case F_SET_TIMER: return "F_SET_TIMER";
case F_GET_TIME_LEFT: return "F_GET_TIME_LEFT";
case F_SET_DYNAMIC_RANGE: return "F_SET_DYNAMIC_RANGE";
case F_SET_READOUT_FLAGS: return "F_SET_READOUT_FLAGS";
case F_SET_ROI: return "F_SET_ROI";
case F_SET_SPEED: return "F_SET_SPEED";
case F_EXIT_SERVER: return "F_EXIT_SERVER";
case F_LOCK_SERVER: return "F_LOCK_SERVER";
case F_GET_LAST_CLIENT_IP: return "F_GET_LAST_CLIENT_IP";
case F_SET_PORT: return "F_SET_PORT";
case F_UPDATE_CLIENT: return "F_UPDATE_CLIENT";
case F_CONFIGURE_MAC: return "F_CONFIGURE_MAC";
case F_LOAD_IMAGE: return "F_LOAD_IMAGE";
case F_READ_COUNTER_BLOCK: return "F_READ_COUNTER_BLOCK";
case F_RESET_COUNTER_BLOCK: return "F_RESET_COUNTER_BLOCK";
case F_ENABLE_TEN_GIGA: return "F_ENABLE_TEN_GIGA";
case F_SET_ALL_TRIMBITS: return "F_SET_ALL_TRIMBITS";
case F_SET_CTB_PATTERN: return "F_SET_CTB_PATTERN";
case F_WRITE_ADC_REG: return "F_WRITE_ADC_REG";
case F_SET_COUNTER_BIT: return "F_SET_COUNTER_BIT";
case F_PULSE_PIXEL: return "F_PULSE_PIXEL";
case F_PULSE_PIXEL_AND_MOVE: return "F_PULSE_PIXEL_AND_MOVE";
case F_PULSE_CHIP: return "F_PULSE_CHIP";
case F_SET_RATE_CORRECT: return "F_SET_RATE_CORRECT";
case F_GET_RATE_CORRECT: return "F_GET_RATE_CORRECT";
case F_SET_NETWORK_PARAMETER: return "F_SET_NETWORK_PARAMETER";
case F_PROGRAM_FPGA: return "F_PROGRAM_FPGA";
case F_RESET_FPGA: return "F_RESET_FPGA";
case F_POWER_CHIP: return "F_POWER_CHIP";
case F_ACTIVATE: return "F_ACTIVATE";
case F_PREPARE_ACQUISITION: return "F_PREPARE_ACQUISITION";
case F_THRESHOLD_TEMP: return "F_THRESHOLD_TEMP";
case F_TEMP_CONTROL: return "F_TEMP_CONTROL";
case F_TEMP_EVENT: return "F_TEMP_EVENT";
case F_AUTO_COMP_DISABLE: return "F_AUTO_COMP_DISABLE";
case F_STORAGE_CELL_START: return "F_STORAGE_CELL_START";
case F_CHECK_VERSION: return "F_CHECK_VERSION";
case F_SOFTWARE_TRIGGER: return "F_SOFTWARE_TRIGGER";
default: return "Unknown Function";
}
}
void function_table() {
flist[F_EXEC_COMMAND] = &exec_command;
flist[F_GET_DETECTOR_TYPE] = &get_detector_type;
flist[F_SET_EXTERNAL_SIGNAL_FLAG] = &set_external_signal_flag;
flist[F_SET_EXTERNAL_COMMUNICATION_MODE] = &set_external_communication_mode;
flist[F_GET_ID] = &get_id;
flist[F_DIGITAL_TEST] = &digital_test;
flist[F_SET_DAC] = &set_dac;
flist[F_GET_ADC] = &get_adc;
flist[F_WRITE_REGISTER] = &write_register;
flist[F_READ_REGISTER] = &read_register;
flist[F_SET_MODULE] = &set_module;
flist[F_GET_MODULE] = &get_module;
flist[F_SET_SETTINGS] = &set_settings;
flist[F_GET_THRESHOLD_ENERGY] = &get_threshold_energy;
flist[F_START_ACQUISITION] = &start_acquisition;
flist[F_STOP_ACQUISITION] = &stop_acquisition;
flist[F_START_READOUT] = &start_readout;
flist[F_GET_RUN_STATUS] = &get_run_status;
flist[F_START_AND_READ_ALL] = &start_and_read_all;
flist[F_READ_ALL] = &read_all;
flist[F_SET_TIMER] = &set_timer;
flist[F_GET_TIME_LEFT] = &get_time_left;
flist[F_SET_DYNAMIC_RANGE] = &set_dynamic_range;
flist[F_SET_READOUT_FLAGS] = &set_readout_flags;
flist[F_SET_ROI] = &set_roi;
flist[F_SET_SPEED] = &set_speed;
flist[F_EXIT_SERVER] = &exit_server;
flist[F_LOCK_SERVER] = &lock_server;
flist[F_GET_LAST_CLIENT_IP] = &get_last_client_ip;
flist[F_SET_PORT] = &set_port;
flist[F_UPDATE_CLIENT] = &update_client;
flist[F_CONFIGURE_MAC] = &configure_mac;
flist[F_LOAD_IMAGE] = &load_image;
flist[F_READ_COUNTER_BLOCK] = &read_counter_block;
flist[F_RESET_COUNTER_BLOCK] = &reset_counter_block;
flist[F_ENABLE_TEN_GIGA] = &enable_ten_giga;
flist[F_SET_ALL_TRIMBITS] = &set_all_trimbits;
flist[F_SET_CTB_PATTERN] = &set_ctb_pattern;
flist[F_WRITE_ADC_REG] = &write_adc_register;
flist[F_SET_COUNTER_BIT] = &set_counter_bit;
flist[F_PULSE_PIXEL] = &pulse_pixel;
flist[F_PULSE_PIXEL_AND_MOVE] = &pulse_pixel_and_move;
flist[F_PULSE_CHIP] = &pulse_chip;
flist[F_SET_RATE_CORRECT] = &set_rate_correct;
flist[F_GET_RATE_CORRECT] = &get_rate_correct;
flist[F_SET_NETWORK_PARAMETER] = &set_network_parameter;
flist[F_PROGRAM_FPGA] = &program_fpga;
flist[F_RESET_FPGA] = &reset_fpga;
flist[F_POWER_CHIP] = &power_chip;
flist[F_ACTIVATE] = &set_activate;
flist[F_PREPARE_ACQUISITION] = &prepare_acquisition;
flist[F_THRESHOLD_TEMP] = &threshold_temp;
flist[F_TEMP_CONTROL] = &temp_control;
flist[F_TEMP_EVENT] = &temp_event;
flist[F_AUTO_COMP_DISABLE] = &auto_comp_disable;
flist[F_STORAGE_CELL_START] = &storage_cell_start;
flist[F_CHECK_VERSION] = &check_version;
flist[F_SOFTWARE_TRIGGER] = &software_trigger;
// check
if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
FILE_LOG(logERROR, ("The last detector function enum has reached its limit\nGoodbye!\n"));
exit(EXIT_FAILURE);
}
int iloop = 0;
for (iloop = 0; iloop < NUM_DET_FUNCTIONS ; ++iloop) {
FILE_LOG(logDEBUG1, ("function fnum=%d, (%s)\n", iloop,
getFunctionName((enum detFuncs)iloop)));
}
}
void functionNotImplemented() {
ret = FAIL;
sprintf(mess, "Function (%s) is not implemented for this detector\n",
getFunctionName((enum detFuncs)fnum));
FILE_LOG(logERROR, (mess));
}
void modeNotImplemented(char* modename, int mode) {
ret = FAIL;
sprintf(mess, "%s (%d) is not implemented for this detector\n", modename, mode);
FILE_LOG(logERROR,(mess));
}
void validate(int arg, int retval, char* modename, enum numberMode nummode) {
if (ret == OK && arg != -1 && retval != arg) {
ret = FAIL;
if (nummode == HEX)
sprintf(mess, "Could not %s. Set 0x%x, but read 0x%x\n",
modename, arg, retval);
else
sprintf(mess, "Could not %s. Set %d, but read %d\n",
modename, arg, retval);
FILE_LOG(logERROR,(mess));
}
}
void validate64(int64_t arg, int64_t retval, char* modename, enum numberMode nummode) {
if (ret == OK && arg != -1 && retval != arg) {
ret = FAIL;
if (nummode == HEX)
sprintf(mess, "Could not %s. Set 0x%llx, but read 0x%llx\n",
modename, (long long unsigned int)arg, (long long unsigned int)retval);
else
sprintf(mess, "Could not %s. Set %lld, but read %lld\n",
modename, (long long unsigned int)arg, (long long unsigned int)retval);
FILE_LOG(logERROR,(mess));
}
}
int M_nofunc(int file_des) {
ret = FAIL;
memset(mess, 0, sizeof(mess));
// to receive any arguments
int n = 1;
while (n > 0)
n = receiveData(file_des,mess,MAX_STR_LENGTH,OTHER);
sprintf(mess,"Unrecognized Function enum %d. Please do not proceed.\n", fnum);
FILE_LOG(logERROR, (mess));
return Server_SendResult(file_des, OTHER, NO_UPDATE, NULL, 0);
}
// Jungfrau program mode
int M_nofuncMode(int file_des) {
ret = FAIL;
memset(mess, 0, sizeof(mess));
// to receive any arguments
int n = 1;
while (n > 0)
n = receiveData(file_des,mess,MAX_STR_LENGTH,OTHER);
sprintf(mess,"This Function %s cannot be executed as the "
"On-board detector server in update mode.\n"
"Restart detector server in normal mode (without any arguments) to continue.\n",
getFunctionName((enum detFuncs)fnum));
FILE_LOG(logERROR, (mess));
return Server_SendResult(file_des, OTHER, NO_UPDATE, NULL, 0);
}
int exec_command(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
char cmd[MAX_STR_LENGTH] = {0};
char retval[MAX_STR_LENGTH] = {0};
if (receiveData(file_des, cmd, MAX_STR_LENGTH, OTHER) < 0)
return printSocketReadError();
FILE_LOG(logINFO, ("Executing command (%s)\n", cmd));
// set
if (Server_VerifyLock() == OK) {
FILE* sysFile = popen(cmd, "r");
const size_t tempsize = 256;
char temp[tempsize];
memset(temp, 0, tempsize);
while(fgets(temp, tempsize, sysFile) != NULL) {
// size left excludes terminating character
size_t sizeleft = MAX_STR_LENGTH - strlen(retval) - 1;
// more than the command
if (tempsize > sizeleft) {
strncat(retval, temp, sizeleft);
break;
}
strncat(retval, temp, tempsize);
memset(temp, 0, tempsize);
}
pclose(sysFile);
FILE_LOG(logINFO, ("Result of cmd (%s):\n%s\n", cmd, retval));
}
return Server_SendResult(file_des, OTHER, NO_UPDATE, retval, sizeof(retval));
}
int get_detector_type(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum detectorType retval = myDetectorType;
FILE_LOG(logDEBUG1,("Returning detector type %d\n", retval));
return Server_SendResult(file_des, INT32, NO_UPDATE, &retval, sizeof(retval));
}
int set_external_signal_flag(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1,-1};
enum externalSignalFlag retval= GET_EXTERNAL_SIGNAL_FLAG;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
int signalindex = args[0];
enum externalSignalFlag flag = args[1];
FILE_LOG(logDEBUG1, ("Setting external signal %d to flag %d\n", signalindex, flag));
#ifndef GOTTHARDD
functionNotImplemented();
#else
if (signalindex > 0)
modeNotImplemented("Signal index", signalindex);
else {
// set
if ((flag != GET_EXTERNAL_SIGNAL_FLAG) && (Server_VerifyLock() == OK)) {
setExtSignal(flag);
}
// get
retval = getExtSignal();
validate((int)flag, (int)retval, "set external signal flag", DEC);
FILE_LOG(logDEBUG1, ("External Signal Flag: %d\n", retval));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_external_communication_mode(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum externalCommunicationMode arg = GET_EXTERNAL_COMMUNICATION_MODE;
enum externalCommunicationMode retval = GET_EXTERNAL_COMMUNICATION_MODE;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting external communication mode to %d\n", arg));
// set
if ((arg != GET_EXTERNAL_COMMUNICATION_MODE) && (Server_VerifyLock() == OK)) {
switch (arg) {
case AUTO_TIMING:
case TRIGGER_EXPOSURE:
#ifdef EIGERD
case GATE_FIX_NUMBER:
case BURST_TRIGGER:
#endif
setTiming(arg);
break;
default:
modeNotImplemented("Timing mode", (int)arg);
break;
}
}
// get
retval = getTiming();
validate((int)arg, (int)retval, "set timing mode", DEC);
FILE_LOG(logDEBUG1, ("Timing Mode: %d\n",retval));
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int get_id(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum idMode arg = 0;
int64_t retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Getting Id %d\n", arg));
// get
switch (arg) {
#ifndef GOTTHARDD
case SOFTWARE_FIRMWARE_API_VERSION:
case DETECTOR_SERIAL_NUMBER:
#endif
case DETECTOR_FIRMWARE_VERSION:
case DETECTOR_SOFTWARE_VERSION:
retval = getDetectorId(arg);
FILE_LOG(logDEBUG1, ("Id(%d): %lld\n", retval));
break;
default:
modeNotImplemented("ID Index", (int)arg);
break;
}
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
int digital_test(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1, -1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum digitalTestMode mode = args[0];
#ifdef GOTTHARDD
int ival = args[1];
FILE_LOG(logDEBUG1, ("Digital test, mode = %d, ival:%d\n", mode, ival));
#else
FILE_LOG(logDEBUG1, ("Digital test, mode = %d\n", mode));
#endif
#ifdef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
switch (mode) {
case DETECTOR_FIRMWARE_TEST:
case DETECTOR_BUS_TEST:
#ifdef GOTTHARDD
case DIGITAL_BIT_TEST:
retval = detectorTest(mode, ival);
break;
#else
retval = detectorTest(mode);
#endif
FILE_LOG(logDEBUG1, ("Digital Test (%d): %d\n", mode, retval));
break;
default:
modeNotImplemented("Digital Test Mode", (int)mode);
break;
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_dac(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[3] = {-1, -1, -1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum dacIndex ind = args[0];
int mV = args[1];
int val = args[2];
enum DACINDEX serverDacIndex = 0;
// check if dac exists for this detector
switch (ind) {
#ifdef GOTTHARDD
case G_VREF_DS :
serverDacIndex = VREF_DS;
break;
case G_VCASCN_PB:
serverDacIndex = VCASCN_PB;
break;
case G_VCASCP_PB:
serverDacIndex = VCASCP_PB;
break;
case G_VOUT_CM:
serverDacIndex = VOUT_CM;
break;
case G_VCASC_OUT:
serverDacIndex = VCASC_OUT;
break;
case G_VIN_CM:
serverDacIndex = VIN_CM;
break;
case G_VREF_COMP:
serverDacIndex = VREF_COMP;
break;
case G_IB_TESTC:
serverDacIndex = IB_TESTC;
break;
case HIGH_VOLTAGE:
break;
#elif EIGERD
case TRIMBIT_SIZE:
serverDacIndex = VTR;
break;
case THRESHOLD:
serverDacIndex = VTHRESHOLD;
break;
case E_SvP:
serverDacIndex = SVP;
break;
case E_SvN:
serverDacIndex = SVN;
break;
case E_Vtr:
serverDacIndex = VTR;
break;
case E_Vrf:
serverDacIndex = VRF;
break;
case E_Vrs:
serverDacIndex = VRS;
break;
case E_Vtgstv:
serverDacIndex = VTGSTV;
break;
case E_Vcmp_ll:
serverDacIndex = VCMP_LL;
break;
case E_Vcmp_lr:
serverDacIndex = VCMP_LR;
break;
case E_cal:
serverDacIndex = CAL;
break;
case E_Vcmp_rl:
serverDacIndex = VCMP_RL;
break;
case E_Vcmp_rr:
serverDacIndex = VCMP_RR;
break;
case E_rxb_rb:
serverDacIndex = RXB_RB;
break;
case E_rxb_lb:
serverDacIndex = RXB_LB;
break;
case E_Vcp:
serverDacIndex = VCP;
break;
case E_Vcn:
serverDacIndex = VCN;
break;
case E_Vis:
serverDacIndex = VIS;
break;
case HIGH_VOLTAGE:
case IO_DELAY:
break;
#elif CHIPTESTBOARDD
case ADC_VPP:
case HIGH_VOLTAGE:
break;
case V_POWER_A:
serverDacIndex = D_PWR_A;
break;
case V_POWER_B:
serverDacIndex = D_PWR_B;
break;
case V_POWER_C:
serverDacIndex = D_PWR_C;
break;
case V_POWER_D:
serverDacIndex = D_PWR_D;
break;
case V_POWER_IO:
serverDacIndex = D_PWR_IO;
break;
case V_POWER_CHIP:
serverDacIndex = D_PWR_CHIP;
break;
case V_LIMIT:
break;
#elif MOENCHD
case ADC_VPP:
case HIGH_VOLTAGE:
case V_LIMIT:
break;
#endif
default:
#ifdef JUNGFRAUD
if ((ind == HIGH_VOLTAGE) || (ind < NDAC_OLDBOARD)) { //for compatibility with old board
serverDacIndex = ind;
break;
}
#elif CHIPTESTBOARDD
if (ind < NDAC_ONLY) {
serverDacIndex = ind;
break;
}
#elif MOENCHD
if (ind < NDAC) {
serverDacIndex = ind;
break;
}
#endif
modeNotImplemented("Dac Index", (int)ind);
break;
}
// index exists
if (ret == OK) {
FILE_LOG(logDEBUG1, ("Setting DAC %d to %d %s\n", serverDacIndex, val,
(mV ? "mV" : "dac units")));
// set & get
if ((val == -1) || (Server_VerifyLock() == OK)) {
switch(ind) {
// adc vpp
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
case ADC_VPP:
if (val < 0 || val > AD9257_GetMaxValidVref()) {
ret = FAIL;
sprintf(mess,"Could not set dac. Adc Vpp value should be between 0 and %d\n", AD9257_GetMaxValidVref());
FILE_LOG(logERROR,(mess));
} else {
AD9257_SetVrefVoltage(val);
retval = val; // cannot read
}
break;
#endif
// io delay
#ifdef EIGERD
case IO_DELAY:
retval = setIODelay(val);
FILE_LOG(logDEBUG1, ("IODelay: %d\n", retval));
validate(val, retval, "set iodelay", DEC);
break;
#endif
// high voltage
case HIGH_VOLTAGE:
retval = setHighVoltage(val);
FILE_LOG(logDEBUG1, ("High Voltage: %d\n", retval));
#if defined(JUNGFRAUD) || defined (CHIPTESTBOARDD) || defined(MOENCHD)
validate(val, retval, "set high voltage", DEC);
#endif
#ifdef GOTTHARDD
if (retval == -1) {
ret = FAIL;
strcpy(mess,"Invalid Voltage. Valid values are 0, 90, 110, 120, 150, 180, 200\n");
FILE_LOG(logERROR,(mess));
} else
validate(val, retval, "set high voltage", DEC);
#elif EIGERD
if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) {
ret = FAIL;
if (retval == -1)
sprintf(mess, "Setting high voltage failed. Bad value %d. "
"The range is from 0 to 200 V.\n",val);
else if (retval == -2)
strcpy(mess, "Setting high voltage failed. "
"Serial/i2c communication failed.\n");
else if (retval == -3)
strcpy(mess, "Getting high voltage failed. "
"Serial/i2c communication failed.\n");
FILE_LOG(logERROR,(mess));
}
#endif
break;
// power, vlimit
#ifdef CHIPTESTBOARDD
case V_POWER_A:
case V_POWER_B:
case V_POWER_C:
case V_POWER_D:
case V_POWER_IO:
if (val != -1) {
if (!mV) {
ret = FAIL;
sprintf(mess,"Could not set power. Power regulator %d should be in mV and not dac units.\n", ind);
FILE_LOG(logERROR,(mess));
} else if (checkVLimitCompliant(val) == FAIL) {
ret = FAIL;
sprintf(mess,"Could not set power. Power regulator %d exceeds voltage limit %d.\n", ind, getVLimit());
FILE_LOG(logERROR,(mess));
} else if (!isPowerValid(serverDacIndex, val)) {
ret = FAIL;
sprintf(mess,"Could not set power. Power regulator %d should be between %d and %d mV\n",
ind, (serverDacIndex == D_PWR_IO ? VIO_MIN_MV : POWER_RGLTR_MIN), (VCHIP_MAX_MV - VCHIP_POWER_INCRMNT));
FILE_LOG(logERROR,(mess));
} else {
setPower(serverDacIndex, val);
}
}
retval = getPower(serverDacIndex);
FILE_LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval));
validate(val, retval, "set power regulator", DEC);
break;
case V_POWER_CHIP:
if (val >= 0) {
ret = FAIL;
sprintf(mess,"Can not set Vchip. Can only be set automatically in the background (+200mV from highest power regulator voltage).\n");
FILE_LOG(logERROR,(mess));
/* restrict users from setting vchip
if (!mV) {
ret = FAIL;
sprintf(mess,"Could not set Vchip. Should be in mV and not dac units.\n");
FILE_LOG(logERROR,(mess));
} else if (!isVchipValid(val)) {
ret = FAIL;
sprintf(mess,"Could not set Vchip. Should be between %d and %d mV\n", VCHIP_MIN_MV, VCHIP_MAX_MV);
FILE_LOG(logERROR,(mess));
} else {
setVchip(val);
}
*/
}
retval = getVchip();
FILE_LOG(logDEBUG1, ("Vchip: %d\n", retval));
if (ret == OK && val != -1 && val != -100 && retval != val) {
ret = FAIL;
sprintf(mess, "Could not set vchip. Set %d, but read %d\n", val, retval);
FILE_LOG(logERROR,(mess));
}
break;
#endif
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
case V_LIMIT:
if (val >= 0) {
if (!mV) {
ret = FAIL;
strcpy(mess,"Could not set power. VLimit should be in mV and not dac units.\n");
FILE_LOG(logERROR,(mess));
} else {
setVLimit(val);
}
}
retval = getVLimit();
FILE_LOG(logDEBUG1, ("VLimit: %d\n", retval));
validate(val, retval, "set vlimit", DEC);
break;
#endif
// dacs
default:
if (mV && val > DAC_MAX_MV) {
ret = FAIL;
sprintf(mess,"Could not set dac %d to value %d. Allowed limits (0 - %d mV).\n", ind, val, DAC_MAX_MV);
FILE_LOG(logERROR,(mess));
} else if (!mV && val > getMaxDacSteps() ) {
ret = FAIL;
sprintf(mess,"Could not set dac %d to value %d. Allowed limits (0 - %d dac units).\n", ind, val, getMaxDacSteps());
FILE_LOG(logERROR,(mess));
} else {
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
if ((val != -1 && mV && checkVLimitCompliant(val) == FAIL) ||
(val != -1 && !mV && checkVLimitDacCompliant(val) == FAIL)) {
ret = FAIL;
sprintf(mess,"Could not set dac %d to value %d. "
"Exceeds voltage limit %d.\n",
ind, (mV ? val : dacToVoltage(val)), getVLimit());
FILE_LOG(logERROR,(mess));
} else
#endif
setDAC(serverDacIndex, val, mV);
retval = getDAC(serverDacIndex, mV);
}
#ifdef EIGERD
if (val != -1) {
//changing dac changes settings to undefined
switch(serverDacIndex) {
case VCMP_LL:
case VCMP_LR:
case VCMP_RL:
case VCMP_RR:
case VRF:
case VCP:
setSettings(UNDEFINED);
FILE_LOG(logERROR, ("Settings has been changed "
"to undefined (changed specific dacs)\n"));
break;
default:
break;
}
}
#endif
//check
if (ret == OK) {
if ((abs(retval - val) <= 5) || val == -1) {
ret = OK;
} else {
ret = FAIL;
sprintf(mess,"Setting dac %d : wrote %d but read %d\n", serverDacIndex, val, retval);
FILE_LOG(logERROR,(mess));
}
}
FILE_LOG(logDEBUG1, ("Dac (%d): %d %s\n\n", serverDacIndex, retval, (mV ? "mV" : "dac units")));
break;
}
}
}
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int get_adc(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum dacIndex ind = 0;
int retval = -1;
if (receiveData(file_des, &ind, sizeof(ind), INT32) < 0)
return printSocketReadError();
#ifdef MOENCHD
functionNotImplemented();
#else
enum ADCINDEX serverAdcIndex = 0;
// get
switch (ind) {
#if defined(GOTTHARDD) || defined(JUNGFRAUD)
case TEMPERATURE_FPGA:
serverAdcIndex = TEMP_FPGA;
break;
case TEMPERATURE_ADC:
serverAdcIndex = TEMP_ADC;
break;
#elif EIGERD
case TEMPERATURE_FPGAEXT:
serverAdcIndex = TEMP_FPGAEXT;
break;
case TEMPERATURE_10GE:
serverAdcIndex = TEMP_10GE;
break;
case TEMPERATURE_DCDC:
serverAdcIndex = TEMP_DCDC;
break;
case TEMPERATURE_SODL:
serverAdcIndex = TEMP_SODL;
break;
case TEMPERATURE_SODR:
serverAdcIndex = TEMP_SODR;
break;
case TEMPERATURE_FPGA:
serverAdcIndex = TEMP_FPGA;
break;
case TEMPERATURE_FPGA2:
serverAdcIndex = TEMP_FPGAFEBL;
break;
case TEMPERATURE_FPGA3:
serverAdcIndex = TEMP_FPGAFEBR;
break;
#elif CHIPTESTBOARDD
case V_POWER_A:
serverAdcIndex = V_PWR_A;
break;
case V_POWER_B:
serverAdcIndex = V_PWR_B;
break;
case V_POWER_C:
serverAdcIndex = V_PWR_C;
break;
case V_POWER_D:
serverAdcIndex = V_PWR_D;
break;
case V_POWER_IO:
serverAdcIndex = V_PWR_IO;
break;
case I_POWER_A:
serverAdcIndex = I_PWR_A;
break;
case I_POWER_B:
serverAdcIndex = I_PWR_B;
break;
case I_POWER_C:
serverAdcIndex = I_PWR_C;
break;
case I_POWER_D:
serverAdcIndex = I_PWR_D;
break;
case I_POWER_IO:
serverAdcIndex = I_PWR_IO;
break;
#endif
default:
#ifdef CHIPTESTBOARDD
if (ind >= SLOW_ADC0 && ind <= SLOW_ADC_TEMP) {
serverAdcIndex = ind;
break;
}
#endif
modeNotImplemented("Adc Index", (int)ind);
break;
}
// valid index
if (ret == OK) {
FILE_LOG(logDEBUG1, ("Getting ADC %d\n", serverAdcIndex));
retval = getADC(serverAdcIndex);
FILE_LOG(logDEBUG1, ("ADC(%d): %d\n", serverAdcIndex, retval));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int write_register(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
uint32_t args[2] = {-1, -1};
uint32_t retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
uint32_t addr = args[0];
uint32_t val = args[1];
FILE_LOG(logDEBUG1, ("Writing to register 0x%x, data 0x%x\n", addr, val));
// only set
if (Server_VerifyLock() == OK) {
#ifdef GOTTHARDD
retval = writeRegister16And32(addr, val);
#else
retval = writeRegister(addr, val);
#endif
// validate
if (retval != val) {
ret = FAIL;
sprintf(mess,"Could not write to register 0x%x. Wrote 0x%x but read 0x%x\n", addr, val, retval);
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Write register (0x%x): 0x%x\n", retval));
}
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int read_register(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
uint32_t addr = -1;
uint32_t retval = -1;
if (receiveData(file_des, &addr, sizeof(addr), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Reading from register 0x%x\n", addr));
// get
#ifdef GOTTHARDD
retval = readRegister16And32(addr);
#else
retval = readRegister(addr);
#endif
FILE_LOG(logINFO, ("Read register (0x%x): 0x%x\n", addr, retval));
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_module(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum detectorSettings retval = -1;
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
functionNotImplemented();
#else
sls_detector_module module;
int *myDac = NULL;
int *myChan = NULL;
module.dacs = NULL;
module.chanregs = NULL;
// allocate to receive arguments
// allocate dacs
myDac = (int*)malloc(getNumberOfDACs() * sizeof(int));
// error
if (getNumberOfDACs() > 0 && myDac == NULL) {
ret = FAIL;
sprintf(mess, "Could not allocate dacs\n");
FILE_LOG(logERROR,(mess));
} else
module.dacs = myDac;
#ifdef EIGERD
// allocate chans
if (ret == OK) {
myChan = (int*)malloc(getTotalNumberOfChannels() * sizeof(int));
if (getTotalNumberOfChannels() > 0 && myChan == NULL) {
ret = FAIL;
sprintf(mess,"Could not allocate chans\n");
FILE_LOG(logERROR,(mess));
} else
module.chanregs = myChan;
}
#endif
// receive arguments
if (ret == OK) {
module.nchip = getNumberOfChips();
module.nchan = getTotalNumberOfChannels();
module.ndac = getNumberOfDACs();
int ts = receiveModule(file_des, &module);
if (ts < 0) {
if (myChan != NULL) free(myChan);
if (myDac != NULL) free(myDac);
return printSocketReadError();
}
FILE_LOG(logDEBUG1, ("module register is %d, nchan %d, nchip %d, "
"ndac %d, iodelay %d, tau %d, eV %d\n",
module.reg, module.nchan, module.nchip,
module.ndac, module.iodelay, module.tau, module.eV));
// should at least have a dac
if (ts <= sizeof(sls_detector_module)) {
ret = FAIL;
sprintf(mess, "Cannot set module. Received incorrect number of dacs or channels\n");
FILE_LOG(logERROR,(mess));
}
}
// receive all arguments
if (ret == FAIL) {
int n = 1;
while (n > 0)
n = receiveData(file_des, mess, MAX_STR_LENGTH, OTHER);
}
// only set
else if (Server_VerifyLock() == OK) {
// check index
switch (module.reg) {
#ifdef EIGERD
case STANDARD:
case HIGHGAIN:
case LOWGAIN:
case VERYHIGHGAIN:
case VERYLOWGAIN:
#elif JUNGFRAUD
case GET_SETTINGS:
case DYNAMICGAIN:
case DYNAMICHG0:
case FIXGAIN1:
case FIXGAIN2:
case FORCESWITCHG1:
case FORCESWITCHG2:
#elif GOTTHARDD
case DYNAMICGAIN:
case HIGHGAIN:
case LOWGAIN:
case MEDIUMGAIN:
case VERYHIGHGAIN:
#endif
break;
default:
modeNotImplemented("Settings", (int)module.reg);
break;
}
ret = setModule(module, mess);
retval = getSettings();
validate(module.reg, (int)retval, "set module (settings)", DEC);
FILE_LOG(logDEBUG1, ("Settings: %d\n", retval));
}
if (myChan != NULL) free(myChan);
if (myDac != NULL) free(myDac);
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int get_module(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
sls_detector_module module;
int *myDac = NULL;
int *myChan = NULL;
module.dacs = NULL;
module.chanregs = NULL;
// allocate to send arguments
// allocate dacs
myDac = (int*)malloc(getNumberOfDACs() * sizeof(int));
// error
if (getNumberOfDACs() > 0 && myDac == NULL) {
ret = FAIL;
sprintf(mess, "Could not allocate dacs\n");
FILE_LOG(logERROR,(mess));
} else
module.dacs = myDac;
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
functionNotImplemented();
#endif
#ifdef EIGERD
// allocate chans
if (ret == OK) {
myChan = (int*)malloc(getTotalNumberOfChannels() * sizeof(int));
if (getTotalNumberOfChannels() > 0 && myChan == NULL) {
ret = FAIL;
sprintf(mess,"Could not allocate chans\n");
FILE_LOG(logERROR,(mess));
} else
module.chanregs=myChan;
}
#endif
// get module
if (ret == OK) {
module.nchip = getNumberOfChips();
module.nchan = getTotalNumberOfChannels();
module.ndac = getNumberOfDACs();
// only get
FILE_LOG(logDEBUG1, ("Getting module\n"));
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD)
getModule(&module);
#endif
FILE_LOG(logDEBUG1, ("Getting module. Settings:%d\n", module.reg));
}
Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
// send module, 0 is to receive partially (without trimbits etc)
if (ret != FAIL) {
ret = sendModule(file_des, &module);
}
if (myChan != NULL) free(myChan);
if (myDac != NULL) free(myDac);
return ret;
}
int set_settings(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum detectorSettings isett = GET_SETTINGS;
enum detectorSettings retval = GET_SETTINGS;
if (receiveData(file_des, &isett, sizeof(isett), INT32) < 0)
return printSocketReadError();
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
functionNotImplemented();
#else
FILE_LOG(logDEBUG1, ("Setting settings %d\n", isett));
//set & get
if ((isett == GET_SETTINGS) || (Server_VerifyLock() == OK)) {
// check index
switch(isett) {
case GET_SETTINGS:
#ifdef JUNGFRAUD
case DYNAMICGAIN:
case DYNAMICHG0:
case FIXGAIN1:
case FIXGAIN2:
case FORCESWITCHG1:
case FORCESWITCHG2:
#elif GOTTHARDD
case DYNAMICGAIN:
case HIGHGAIN:
case LOWGAIN:
case MEDIUMGAIN:
case VERYHIGHGAIN:
#endif
break;
default:
if (myDetectorType == EIGER) {
ret = FAIL;
sprintf(mess, "Cannot set settings via SET_SETTINGS, use SET_MODULE\n");
FILE_LOG(logERROR,(mess));
} else
modeNotImplemented("Settings Index", (int)isett);
break;
}
// if index is okay, set & get
if (ret == OK) {
retval = setSettings(isett);
FILE_LOG(logDEBUG1, ("Settings: %d\n", retval));
validate((int)isett, (int)retval, "set settings", DEC);
#if defined(JUNGFRAUD) || defined (GOTTHARDD)
if (ret == OK && isett >= 0) {
ret = setDefaultDacs();
if (ret == FAIL) {
strcpy(mess,"Could change settings, but could not set to default dacs\n");
FILE_LOG(logERROR,(mess));
}
}
#endif
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int get_threshold_energy(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int retval = -1;
FILE_LOG(logDEBUG1, ("Getting Threshold energy\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// only get
retval = getThresholdEnergy();
FILE_LOG(logDEBUG1, ("Threshold energy: %d eV\n", retval));
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int start_acquisition(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Starting Acquisition\n"));
// only set
if (Server_VerifyLock() == OK) {
ret = startStateMachine();
if (ret == FAIL) {
sprintf(mess, "Could not start acquisition\n");
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Starting Acquisition ret: %d\n", ret));
}
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int stop_acquisition(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Stopping Acquisition\n"));
// only set
if (Server_VerifyLock() == OK) {
ret = stopStateMachine();
if (ret == FAIL) {
sprintf(mess, "Could not stop acquisition\n");
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Stopping Acquisition ret: %d\n", ret));
}
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int start_readout(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Starting readout\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = startReadOut();
if (ret == FAIL) {
sprintf(mess, "Could not start readout\n");
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Starting readout ret: %d\n", ret));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_run_status(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum runStatus retval = ERROR;
FILE_LOG(logDEBUG1, ("Getting status\n"));
// only get
retval = getRunStatus();
FILE_LOG(logDEBUG1, ("Status: %d\n", retval));
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int start_and_read_all(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Starting Acquisition and read all frames\n"));
// start state machine
FILE_LOG(logDEBUG1, ("Starting Acquisition\n"));
// only set
if (Server_VerifyLock() == OK) {
ret = startStateMachine();
if (ret == FAIL) {
sprintf(mess, "Could not start acquisition\n");
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Starting Acquisition ret: %d\n", ret));
}
// lock or acquisition start error
if (ret == FAIL)
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
// read all (again validate lock, but should pass and not fail)
return read_all(file_des);
}
int read_all(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Reading all frames\n"));
// only set
if (Server_VerifyLock() == OK) {
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
// read from fifo enabled
if (!sendUDP(-1)) {
FILE_LOG(logDEBUG1, ("Reading from 1G UDP\n"));
if (setUDPDestinationDetails("129.129.205.171", 50001) == OK) { // 10g,1 g
if (createUDPSocket() == OK) {
char buffer[UDP_PACKET_MAX_DATA_BYTES + sizeof(sls_detector_header)];
createUDPPacketHeader(buffer, getHardwareSerialNumber());
calculateDataBytesPerSample();
// keep reading frames
while(readFrameFromFifo() == OK) {
int bytesToSend = 0;
int n = 0;
// fill packet with pnum, nsamples per packet and data
while((bytesToSend = fillUDPPacket(buffer))) {
n += sendUDPPacket(buffer, bytesToSend);
}
if (n >= dataBytes)
FILE_LOG(logINFO, (" Frame %lld sent (%d packets, %d databytes, n:%d bytes sent)\n",
udpFrameNumber, udpPacketNumber + 1, dataBytes, n));
}
closeUDPSocket();
}
}
// finished readng frames
// frames left to give status
int64_t retval = getTimeLeft(FRAME_NUMBER) + 2;
if ( retval > 1) {
ret = FAIL;
sprintf(mess,"No data and run stopped: %lld frames left\n",(long long int)retval);
FILE_LOG(logERROR, (mess));
} else {
ret = OK; // send number of bytes (8) first to acknowledge finish of acquisition //FIXME
FILE_LOG(logINFOGREEN, ("Acquisition successfully finished\n"));
}
Server_SendResult(file_des, INT32, UPDATE, NULL, 0); // to the client
}
// read from receiver
else {
FILE_LOG(logDEBUG1, ("Reading via UDP\n"));
readFrame(&ret, mess);
}
#else
readFrame(&ret, mess);
#endif
}
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int set_timer(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int64_t args[2] = {-1,-1};
int64_t retval = -1;
if (receiveData(file_des, args, sizeof(args), INT64) < 0)
return printSocketReadError();
enum timerIndex ind = (int)args[0];
int64_t tns = args[1];
char timerName[50] = {0};
strcpy(timerName, getTimerName(ind));
#ifdef EIGERD
int64_t subexptime = 0;
#endif
FILE_LOG(logDEBUG1, ("Setting timer %s(%d) to %lld ns\n", timerName, (int)ind, tns));
// set & get
if ((tns == -1) || (Server_VerifyLock() == OK)) {
// check index
switch (ind) {
case FRAME_NUMBER:
#if ((!defined(CHIPTESTBOARDD)) && (!defined(MOENCHD)))
case ACQUISITION_TIME:
#endif
case FRAME_PERIOD:
case CYCLES_NUMBER:
case SAMPLES:
#ifndef EIGERD
case DELAY_AFTER_TRIGGER:
#endif
retval = setTimer(ind, tns);
break;
#ifdef JUNGFRAUD
case STORAGE_CELL_NUMBER:
if (tns > MAX_STORAGE_CELL_VAL) {
ret = FAIL;
strcpy(mess,"Max Storage cell number should not exceed 15\n");
FILE_LOG(logERROR,(mess));
break;
}
retval = setTimer(ind,tns);
break;
#endif
#ifdef EIGERD
case SUBFRAME_ACQUISITION_TIME:
if (tns > ((int64_t)MAX_SUBFRAME_EXPOSURE_VAL_IN_10NS*10) ) {
ret = FAIL;
strcpy(mess,"Sub Frame exposure time should not exceed 5.368 seconds\n");
FILE_LOG(logERROR,(mess));
break;
}
retval = setTimer(ind,tns);
break;
case SUBFRAME_DEADTIME:
subexptime = setTimer(SUBFRAME_ACQUISITION_TIME, -1);
if ((tns + subexptime) > ((int64_t)MAX_SUBFRAME_EXPOSURE_VAL_IN_10NS*10) ) {
ret = FAIL;
sprintf(mess,"Sub Frame Period should not exceed 5.368 seconds. "
"So sub frame dead time should not exceed %lfu seconds "
"(subexptime = %lf seconds)\n",
((((int64_t)MAX_SUBFRAME_EXPOSURE_VAL_IN_10NS*10) - subexptime)/1E9),
(subexptime/1E9));
FILE_LOG(logERROR,(mess));
break;
}
retval = setTimer(ind,tns);
break;
#endif
default:
modeNotImplemented(timerName, (int)ind);
break;
}
// validate
if (ret != FAIL) {
char vtimerName[50] = {0};
sprintf(vtimerName, "set %s", timerName);
#ifdef EIGERD
validate64(tns, retval, vtimerName, DEC); // copied to server, not read from detector register
#else
switch(ind) {
case FRAME_NUMBER:
case CYCLES_NUMBER:
case STORAGE_CELL_NUMBER:
validate64(tns, retval, vtimerName, DEC); // no conversion, so all good
break;
case SAMPLES:
if (retval == -1) {
ret = FAIL;
retval = setTimer(ind, -1);
sprintf(mess, "Could not set samples to %lld. Could not allocate RAM\n",
(long long unsigned int)tns);
FILE_LOG(logERROR,(mess));
} else
validate64(tns, retval, vtimerName, DEC); // no conversion, so all good
case ACQUISITION_TIME:
case FRAME_PERIOD:
case DELAY_AFTER_TRIGGER:
case SUBFRAME_ACQUISITION_TIME:
case SUBFRAME_DEADTIME:
// losing precision due to conversion to clock (also gotthard master delay is different)
if (validateTimer(ind, tns, retval) == FAIL) {
ret = FAIL;
sprintf(mess, "Could not %s. Set %lld, but read %lld\n", vtimerName,
(long long unsigned int)tns, (long long unsigned int)retval);
FILE_LOG(logERROR,(mess));
}
break;
default:
break;
}
#endif
}
}
if (ret != FAIL) {
FILE_LOG(logDEBUG1, ("Timer index %d: %lld\n", ind, retval));
}
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
int get_time_left(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum timerIndex ind = -1;
int64_t retval = -1;
if (receiveData(file_des, &ind, sizeof(ind), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Getting timer left index %d\n", ind));
// only get
// check index
#ifdef JUNGFRAUD
if (ind == DELAY_AFTER_TRIGGER) {
ret = FAIL;
sprintf(mess,"Timer Left Index (%d) is not implemented for this release.\n", (int)ind);
FILE_LOG(logERROR,(mess));
}
#endif
if (ret == OK) {
switch(ind) {
#ifdef EIGERD
case MEASURED_PERIOD:
case MEASURED_SUBPERIOD:
#elif JUNGFRAUD
case FRAMES_FROM_START:
case FRAMES_FROM_START_PG:
case ACTUAL_TIME:
case MEASUREMENT_TIME:
case FRAME_NUMBER:
case FRAME_PERIOD:
case DELAY_AFTER_TRIGGER:
case CYCLES_NUMBER:
#elif GOTTHARDD
case ACQUISITION_TIME:
case FRAME_NUMBER:
case FRAME_PERIOD:
case DELAY_AFTER_TRIGGER:
case CYCLES_NUMBER:
#elif CHIPTESTBOARDD
case FRAMES_FROM_START:
case FRAMES_FROM_START_PG:
case ACTUAL_TIME:
case MEASUREMENT_TIME:
case FRAME_NUMBER:
case FRAME_PERIOD:
case DELAY_AFTER_TRIGGER:
case CYCLES_NUMBER:
#elif MOENCHD
case FRAMES_FROM_START:
case FRAMES_FROM_START_PG:
case ACTUAL_TIME:
case MEASUREMENT_TIME:
case FRAME_NUMBER:
case FRAME_PERIOD:
case DELAY_AFTER_TRIGGER:
case CYCLES_NUMBER:
#endif
retval = getTimeLeft(ind);
FILE_LOG(logDEBUG1, ("Timer left index %d: %lld\n", ind, retval));
break;
default:
modeNotImplemented("Timer left index", (int)ind);
break;
}
}
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
int set_dynamic_range(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int dr = -1;
int retval = -1;
if (receiveData(file_des, &dr, sizeof(dr), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting dr to %d\n", dr));
// set & get
if ((dr == -1) || (Server_VerifyLock() == OK)) {
#ifdef EIGERD
int old_dr = setDynamicRange(-1);
#endif
// check dr
switch(dr) {
case -1:
case 16:
#ifdef EIGERD
case 4: case 8: case 32:
#endif
retval = setDynamicRange(dr);
FILE_LOG(logDEBUG1, ("Dynamic range: %d\n", retval));
validate(dr, retval, "set dynamic range", DEC);
break;
default:
modeNotImplemented("Dynamic range", dr);
break;
}
#ifdef EIGERD
if (dr != -1 && getRateCorrectionEnable()) {
// 4 or 8 bit, switch off rate corr (only if dr worked)
if ((dr != 32) && (dr != 16) && (ret == OK)) {
setRateCorrection(0);
ret = FAIL;
strcpy(mess,"Switching off Rate Correction. Must be in 32 or 16 bit mode\n");
FILE_LOG(logERROR,(mess));
}
// 16, 32 (diff from old value), set new tau in rate table(-1), if it didnt work, give error
else if ((dr == 16 || dr == 32) && (old_dr != dr)) {
setRateCorrection(-1); //tau_ns will not be -1 here
// it didnt work
if (!getRateCorrectionEnable()) {
ret = FAIL;
strcpy(mess,"Deactivating Rate Correction. Could not set it.\n");
FILE_LOG(logERROR,(mess));
}
}
}
#endif
}
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_readout_flags(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
enum readOutFlags arg = GET_READOUT_FLAGS;
enum readOutFlags retval = GET_READOUT_FLAGS;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting readout flags to %d\n", arg));
#if defined(JUNGFRAUD) || defined(GOTTHARDD)
functionNotImplemented();
#else
// set & get
if ((arg == GET_READOUT_FLAGS) || (Server_VerifyLock() == OK)) {
switch(arg) {
case STORE_IN_RAM:
case CONTINOUS_RO:
case PARALLEL:
case NONPARALLEL:
case SAFE:
case SHOW_OVERFLOW:
case NOOVERFLOW:
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
case NORMAL_READOUT:
case DIGITAL_ONLY:
case ANALOG_AND_DIGITAL:
#endif
retval = setReadOutFlags(arg);
FILE_LOG(logDEBUG1, ("Read out flags: 0x%x\n", retval));
validate((int)arg, (int)(retval & arg), "set readout flag", HEX);
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
if (retval == -2) {
ret = FAIL;
sprintf(mess, "Readout Flags failed. Cannot allocate RAM\n");
FILE_LOG(logERROR,(mess));
}
#endif
break;
default:
modeNotImplemented("Read out flag index", (int)arg);
break;
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_roi(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int narg = -1;
ROI arg[MAX_ROIS];
int nretval = -1;
ROI* retval = NULL;
// receive number of ROIs
if (receiveData(file_des, &narg, sizeof(narg), INT32) < 0)
return printSocketReadError();
// receive ROIs
{
int iloop = 0;
for (iloop = 0; iloop < narg; ++iloop) {
if (receiveData(file_des, &arg[iloop].xmin, sizeof(int), INT32) < 0)
return printSocketReadError();
if (receiveData(file_des, &arg[iloop].xmax, sizeof(int), INT32) < 0)
return printSocketReadError();
if (receiveData(file_des, &arg[iloop].ymin, sizeof(int), INT32) < 0)
return printSocketReadError();
if (receiveData(file_des, &arg[iloop].ymax, sizeof(int), INT32) < 0)
return printSocketReadError();
}
}
FILE_LOG(logDEBUG1, ("Set ROI (narg:%d)\n", narg));
{
int iloop = 0;
for (iloop = 0; iloop < narg; ++iloop) {
FILE_LOG(logDEBUG1, ("%d: %d\t%d\t%d\t%d\n",
arg[iloop].xmin, arg[iloop].xmax, arg[iloop].ymin, arg[iloop].ymax));
}
}
#if defined(JUNGFRAUD) || defined(EIGERD)
functionNotImplemented();
#else
// set & get
if ((narg == GET_READOUT_FLAGS) || (Server_VerifyLock() == OK)) {
if (myDetectorType == GOTTHARD && narg > 1) {
ret = FAIL;
strcpy(mess,"Can not set more than one ROI per module.\n");
FILE_LOG(logERROR,(mess));
} else {
retval = setROI(narg, arg, &nretval, &ret);
if (ret == FAIL) {
if (nretval == -1) // chip test board
sprintf(mess,"Could not set ROI. Max ROI level (100) reached!\n");
else if (nretval == -2)
sprintf(mess, "Could not set ROI. Could not allocate RAM\n");
else
sprintf(mess,"Could not set all roi. "
"Set %d rois, but read %d rois\n", narg, nretval);
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("nRois: %d\n", nretval));
}
}
#endif
Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
if (ret != FAIL) {
//retvalsize could be swapped during sendData
int nretval1 = nretval;
sendData(file_des, &nretval1, sizeof(nretval1), INT32);
int iloop = 0;
for(iloop = 0; iloop < nretval; ++iloop) {
sendData(file_des, &retval[iloop].xmin, sizeof(int), INT32);
sendData(file_des, &retval[iloop].xmax, sizeof(int), INT32);
sendData(file_des, &retval[iloop].ymin, sizeof(int), INT32);
sendData(file_des, &retval[iloop].ymax, sizeof(int), INT32);
}
}
return ret;
}
int set_speed(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1,-1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
#ifdef GOTTHARDD
functionNotImplemented();
#else
enum speedVariable ind = args[0];
int val = args[1];
int GET_VAL = -1;
if ((ind == PHASE_SHIFT) || (ind == ADC_PHASE) || (ind == DBIT_PHASE))
GET_VAL = 100000;
char speedName[20] = {0};
strcpy(speedName, getSpeedName(ind));
FILE_LOG(logDEBUG1, ("Setting speed index %s (%d) to %d\n", speedName, ind, val));
// check index
switch(ind) {
#ifdef JUNGFRAUD
case ADC_PHASE:
#elif CHIPTESTBOARDD
case ADC_PHASE:
case PHASE_SHIFT:
case DBIT_PHASE:
case ADC_CLOCK:
case DBIT_CLOCK:
case ADC_PIPELINE:
case DBIT_PIPELINE:
#elif MOENCHD
case ADC_PHASE:
case PHASE_SHIFT:
case DBIT_PHASE:
case ADC_CLOCK:
case DBIT_CLOCK:
case ADC_PIPELINE:
case DBIT_PIPELINE:
#endif
case CLOCK_DIVIDER:
break;
default:
modeNotImplemented(speedName, (int)ind);
break;
}
if (ret == OK) {
// set
if ((val != GET_VAL) && (Server_VerifyLock() == OK)) {
setSpeed(ind, val);
}
// get
retval = getSpeed(ind);
FILE_LOG(logDEBUG1, ("%s: %d\n", speedName, retval));
// validate
if (GET_VAL == -1) {
char validateName[20] = {0};
sprintf(validateName, "set %s", speedName);
validate(val, retval, validateName, DEC);
} else if (ret == OK && val != GET_VAL && retval != val ) {
ret = FAIL;
sprintf(mess, "Could not set %s. Set %d, but read %d\n", speedName, val, retval);
FILE_LOG(logERROR,(mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int exit_server(int file_des) {
FILE_LOG(logINFORED, ("Closing Server\n"));
ret = OK;
memset(mess, 0, sizeof(mess));
Server_SendResult(file_des, INT32, NO_UPDATE, NULL, 0);
return GOODBYE;
}
int lock_server(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int lock = 0;
if (receiveData(file_des, &lock, sizeof(lock), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Locking Server to %d\n", lock));
// set
if (lock >= 0) {
if (!lockStatus || // if it was unlocked, anyone can lock
(!strcmp(lastClientIP, thisClientIP)) || // if it was locked, need same ip
(!strcmp(lastClientIP,"none"))) { // if it was locked, must be by "none"
lockStatus = lock;
strcpy(lastClientIP, thisClientIP);
} else {
Server_LockedError();
}
}
return Server_SendResult(file_des, INT32, UPDATE, &lockStatus, sizeof(lockStatus));
}
int get_last_client_ip(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
return Server_SendResult(file_des, INT32, UPDATE, lastClientIP, sizeof(lastClientIP));
}
int set_port(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int p_number = -1;
char oldLastClientIP[INET_ADDRSTRLEN] = {0};
if (receiveData(file_des, &p_number, sizeof(p_number), INT32) < 0)
return printSocketReadError();
// set only
int sd = -1;
if ((Server_VerifyLock() == OK)) {
// port number too low
if (p_number < 1024) {
ret = FAIL;
sprintf(mess,"%s port Number (%d) too low\n",
(isControlServer ? "control":"stop"), p_number);
FILE_LOG(logERROR,(mess));
} else {
FILE_LOG(logINFO, ("Setting %s port to %d\n",
(isControlServer ? "control":"stop"), p_number));
strcpy(oldLastClientIP, lastClientIP);
sd = bindSocket(p_number);
}
}
Server_SendResult(file_des, INT32, UPDATE, &p_number, sizeof(p_number));
// delete old socket
if (ret != FAIL) {
closeConnection(file_des);
exitServer(sockfd);
sockfd = sd;
strcpy(lastClientIP, oldLastClientIP);
}
return ret;
}
int update_client(int file_des) {
ret = FORCE_UPDATE;
memset(mess, 0, sizeof(mess));
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
if (debugflag == PROGRAMMING_MODE) {
ret = OK;
}
#endif
Server_SendResult(file_des, INT32, NO_UPDATE, NULL, 0);
if (ret == OK)
return ret;
return send_update(file_des);
}
int send_update(int file_des) {
ret = OK;
int n = 0;
int i32 = -1;
int64_t i64 = -1;
n = sendData(file_des,lastClientIP,sizeof(lastClientIP),OTHER);
if (n < 0) return printSocketReadError();
i32 = setDynamicRange(GET_FLAG);
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
i32 = calculateDataBytes();
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
#if defined(EIGERD) || defined(JUNGFRAUD) || defined(GOTTHARDD)
i32 = (int)getSettings();
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
#endif
#ifdef EIGERD
i32 = getThresholdEnergy(GET_FLAG);
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
#endif
i64 = setTimer(FRAME_NUMBER,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#if defined(EIGERD) || defined(JUNGFRAUD) || defined(GOTTHARDD)
i64 = setTimer(ACQUISITION_TIME,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#endif
#ifdef EIGERD
i64 = setTimer(SUBFRAME_ACQUISITION_TIME,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
i64 = setTimer(SUBFRAME_DEADTIME,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#endif
i64 = setTimer(FRAME_PERIOD,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#ifndef EIGERD
i64 = setTimer(DELAY_AFTER_TRIGGER,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#endif
i64 = setTimer(CYCLES_NUMBER,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#if defined(EIGERD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
i32 = setReadOutFlags(GET_READOUT_FLAGS);
n = sendData(file_des,&i32,sizeof(i32),INT32);
if (n < 0) return printSocketReadError();
#endif
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
i64 = setTimer(SAMPLES,GET_FLAG);
n = sendData(file_des,&i64,sizeof(i64),INT64);
if (n < 0) return printSocketReadError();
#endif
if (lockStatus == 0) {
strcpy(lastClientIP,thisClientIP);
}
return ret;
}
int configure_mac(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
char args[9][50];
memset(args, 0, sizeof(args));
char retvals[2][50];
memset(retvals, 0, sizeof(retvals));
if (receiveData(file_des, args, sizeof(args), OTHER) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("\n Configuring MAC\n"));
uint32_t dstIp = 0;
sscanf(args[0], "%x", &dstIp);
FILE_LOG(logDEBUG1, ("Dst Ip Addr: %d.%d.%d.%d = 0x%x \n",
(dstIp >> 24) & 0xff, (dstIp >> 16) & 0xff, (dstIp >> 8) & 0xff, (dstIp) & 0xff,
dstIp));
uint64_t dstMac = 0;
#ifdef VIRTUAL
sscanf(args[1], "%lx", &dstMac);
#else
sscanf(args[1], "%llx", &dstMac);
#endif
FILE_LOG(logDEBUG1, ("Dst Mac Addr: (0x) "));
{
int iloop = 5;
for (iloop = 5; iloop >= 0; --iloop) {
FILE_LOG(logDEBUG1, ("%x", (unsigned int)(((dstMac >> (8 * iloop)) & 0xFF))));
if (iloop > 0) {
FILE_LOG(logDEBUG1, (":"));
}
}
}
FILE_LOG(logDEBUG1, (" = %llx\n", dstMac));
uint32_t dstPort = 0;
sscanf(args[2], "%x", &dstPort);
FILE_LOG(logDEBUG1, ("Dst Port: %x\n", dstPort));
uint32_t dstPort2 = 0;
sscanf(args[5], "%x", &dstPort2);
FILE_LOG(logDEBUG1, ("Dst Port2: %x\n", dstPort2));
uint64_t srcMac = 0;
#ifdef VIRTUAL
sscanf(args[3], "%lx", &srcMac);
#else
sscanf(args[3], "%llx", &srcMac);
#endif
FILE_LOG(logDEBUG1, ("Src Mac Addr: (0x) "));
{
int iloop = 5;
for (iloop = 5; iloop >= 0; --iloop) {
FILE_LOG(logDEBUG1, ("%x", (unsigned int)(((srcMac >> (8 * iloop)) & 0xFF))));
if (iloop > 0) {
FILE_LOG(logDEBUG1, (":"));
}
}
}
FILE_LOG(logDEBUG1, (" = %llx\n", srcMac));
uint32_t srcIp = 0;
sscanf(args[4], "%x", &srcIp);
FILE_LOG(logDEBUG1, ("Src Ip Addr: %d.%d.%d.%d = 0x%x \n",
(srcIp >> 24) & 0xff, (srcIp >> 16) & 0xff, (srcIp >> 8) & 0xff, (srcIp) & 0xff,
srcIp));
#if defined(JUNGFRAUD) || defined(EIGERD)
int pos[3] = {0, 0, 0};
sscanf(args[6], "%x", &pos[0]);
sscanf(args[7], "%x", &pos[1]);
sscanf(args[8], "%x", &pos[2]);
FILE_LOG(logDEBUG1, ("Position: [%d, %d, %d]\n", pos[0], pos[1], pos[2]));
#endif
// set only
if ((Server_VerifyLock() == OK)) {
// stop detector if it was running
if (getRunStatus() != IDLE) {
ret = FAIL;
sprintf(mess, "Cannot configure mac when detector is not idle\n");
FILE_LOG(logERROR,(mess));
}
else {
#ifdef EIGERD
// change mac to hardware mac
if (srcMac != getDetectorMAC()) {
FILE_LOG(logWARNING, ("actual detector mac address %llx does not match "
"the one from client %llx\n",
(long long unsigned int)getDetectorMAC(),
(long long unsigned int)srcMac));
srcMac = getDetectorMAC();
FILE_LOG(logWARNING,("matched detectormac to the hardware mac now\n"));
}
// always remember the ip sent from the client (could be for 10g(if not dhcp))
if (srcIp != getDetectorIP())
dhcpipad = srcIp;
//only for 1Gbe, change ip to hardware ip
if (!enableTenGigabitEthernet(-1)) {
FILE_LOG(logWARNING, ("Using DHCP IP for Configuring MAC\n"));
srcIp = getDetectorIP();
}
// 10 gbe (use ip given from client)
else
srcIp = dhcpipad;
#endif
ret = configureMAC(dstIp, dstMac, srcMac, srcIp, dstPort, dstPort2);
if (ret == FAIL) {
sprintf(mess,"Configure Mac failed\n");
FILE_LOG(logERROR,(mess));
} else {
FILE_LOG(logINFO, ("\tConfigure MAC successful\n"));
}
#if defined(EIGERD) || defined (JUNGFRAUD)
if (ret != FAIL) {
ret = setDetectorPosition(pos);
if (ret == FAIL) {
sprintf(mess, "Could not set detector position\n");
FILE_LOG(logERROR,(mess));
}
}
#endif
// set retval vals
if (ret != FAIL) {
sprintf(retvals[0],"%llx", (long long unsigned int)srcMac);
sprintf(retvals[1],"%x", srcIp);
}
}
}
return Server_SendResult(file_des, OTHER, UPDATE, retvals, sizeof(retvals));
}
int load_image(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum imageType index = args[0];
int numChannels = args[1];
short int imageVals[numChannels];
memset(imageVals, 0, numChannels * sizeof(short int));
if (numChannels > 0) {
if (receiveData(file_des, imageVals, numChannels * sizeof(short int), OTHER) < 0) {
return printSocketReadError();
}
}
FILE_LOG(logDEBUG1, ("Loading %s image (ind:%d)\n", (index == DARK_IMAGE) ? "dark" :
((index == GAIN_IMAGE) ? "gain" : "unknown"), index));
#ifndef GOTTHARDD
functionNotImplemented();
#else
// set only
if (Server_VerifyLock() == OK) {
switch (index) {
case DARK_IMAGE :
case GAIN_IMAGE :
// size of image does not match expected size
if (numChannels != (calculateDataBytes()/sizeof(short int))) {
ret = FAIL;
sprintf(mess, "Could not load image. "
"Number of Channels do not match. Expected %d, got %d\n",
calculateDataBytes(), numChannels);
FILE_LOG(logERROR,(mess));
} else
loadImage(index, imageVals);
break;
default:
modeNotImplemented("Image index", (int)index);
break;
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int read_counter_block(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
int startACQ = args[0];
int numChannels = args[1];
short int retval[numChannels];
memset(retval, 0, numChannels * sizeof(short int));
FILE_LOG(logDEBUG1, ("Read counter block with start acq bit: %d\n", startACQ));
#ifndef GOTTHARDD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
// size of image does not match expected size
if (numChannels != (calculateDataBytes()/sizeof(short int))) {
ret = FAIL;
sprintf(mess, "Could not load image. "
"Number of Channels do not match. Expected %d, got %d\n",
calculateDataBytes(), numChannels);
FILE_LOG(logERROR,(mess));
} else {
ret = readCounterBlock(startACQ, retval);
if (ret == FAIL) {
strcpy(mess, "Could not read counter block\n");
FILE_LOG(logERROR,(mess));
}
}
}
#endif
return Server_SendResult(file_des, OTHER, UPDATE, retval, numChannels * sizeof(short int));
}
int reset_counter_block(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int startACQ = -1;
if (receiveData(file_des, &startACQ, sizeof(startACQ), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Reset counter block with start acq bit: %d\n", startACQ));
#ifndef GOTTHARDD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = resetCounterBlock(startACQ);
if (ret == FAIL) {
strcpy(mess, "Could not reset counter block\n");
FILE_LOG(logERROR, (mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int enable_ten_giga(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Enable/ Disable 10GbE : %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = enableTenGigabitEthernet(arg);
FILE_LOG(logDEBUG1, ("10GbE: %d\n", retval));
validate(arg, retval, "enable/disable 10GbE", DEC);
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_all_trimbits(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Set all trmbits to %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// set
if (arg >= 0 && Server_VerifyLock() == OK) {
ret = setAllTrimbits(arg);
//changes settings to undefined
setSettings(UNDEFINED);
FILE_LOG(logERROR, ("Settings has been changed to undefined (change all trimbits)\n"));
}
// get
retval = getAllTrimbits();
FILE_LOG(logDEBUG1, ("All trimbits: %d\n", retval));
validate(arg, retval, "set all trimbits", DEC);
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_ctb_pattern(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
// receive mode
uint64_t arg = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT64) < 0)
return printSocketReadError();
int mode = (int)arg;
FILE_LOG(logDEBUG1, ("Setting Pattern: mode %d\n", mode));
// mode 0: control or word
if (mode == 0) {
// receive arguments
uint64_t args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT64) < 0)
return printSocketReadError();
int64_t retval64 = -1;
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD)
functionNotImplemented();
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
#else
int addr = (int)args[0];
uint64_t word = args[1];
FILE_LOG(logDEBUG1, (" addr:0x%x word:0x%llx\n", addr, word));
if ((word == -1) || (Server_VerifyLock() == OK)) {
// address for set word should be valid (if not -1 or -2, it goes to setword)
if (addr < -2 || addr > MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess, "Cannot set Pattern (Word, addr:0x%x). Addr must be less than 0x%x\n",
addr, MAX_PATTERN_LENGTH);
FILE_LOG(logERROR, (mess));
} else {
char tempName[100];
memset(tempName, 0, 100);
switch (addr) {
case -1:
strcpy(tempName, "Pattern (I/O Control Register)");
FILE_LOG(logDEBUG1, (" Setting %s, word to 0x%llx\n", tempName, (long long int) word));
retval64 = writePatternIOControl(word);
break;
case -2:
strcpy(tempName, "Pattern (Clock Control Register)");
FILE_LOG(logDEBUG1, (" Setting %s, word to 0x%llx\n", tempName, (long long int) word));
retval64 = writePatternClkControl(word);
break;
default:
sprintf(tempName, "Pattern (Word, addr:0x%x)", addr);
FILE_LOG(logDEBUG1, (" Setting %s, word to 0x%llx\n", tempName, (long long int) word));
retval64 = writePatternWord(addr, word);
break;
}
FILE_LOG(logDEBUG1, (" %s: 0x%llx\n", tempName, (long long int)retval64));
validate64(word, retval64, tempName, HEX);
}
}
#endif
return Server_SendResult(file_des, INT64, UPDATE, &retval64, sizeof(retval64));
}
// mode 1: pattern loop
else if (mode == 1) {
// receive arguments
uint64_t args[4] = {-1, -1, -1, -1};
if (receiveData(file_des, args, sizeof(args), INT64) < 0)
return printSocketReadError();
int retvals[3] = {-1, -1, -1};
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD)
functionNotImplemented();
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
#else
int loopLevel = (int)args[0];
int startAddr = (int)args[1];
int stopAddr = (int)args[2];
int numLoops = (int)args[3];
FILE_LOG(logDEBUG1, (" loopLevel:%d startAddr:0x%x stopAddr:0x%x numLoops:%d\n", loopLevel, startAddr, stopAddr, numLoops));
if (loopLevel < -1 || loopLevel > 2) { // -1 complete pattern
ret = FAIL;
sprintf(mess, "Pattern (Pattern Loop) Level (%d) is not implemented for this detector\n", loopLevel);
FILE_LOG(logERROR,(mess));
}
// level 0-2, addr upto patternlength + 1
else if ((loopLevel != -1) && (startAddr > MAX_PATTERN_LENGTH || stopAddr > MAX_PATTERN_LENGTH )) {
ret = FAIL;
sprintf(mess, "Cannot set Pattern (Pattern Loop, level:%d, startaddr:0x%x, stopaddr:0x%x). "
"Addr must be less than 0x%x\n",
loopLevel, startAddr, stopAddr, MAX_PATTERN_LENGTH);
FILE_LOG(logERROR, (mess));
}
//level -1, addr upto patternlength
else if ((loopLevel == -1) && (startAddr > MAX_PATTERN_LENGTH || stopAddr > MAX_PATTERN_LENGTH)) {
ret = FAIL;
sprintf(mess, "Cannot set Pattern (Pattern Loop, complete pattern, startaddr:0x%x, stopaddr:0x%x). "
"Addr must be less than 0x%x\n",
startAddr, stopAddr, MAX_PATTERN_LENGTH);
FILE_LOG(logERROR, (mess));
}
else if ((startAddr == -1 && stopAddr == -1 && numLoops == -1) || (Server_VerifyLock() == OK)) {
setPatternLoop(loopLevel, &startAddr, &stopAddr, &numLoops);
}
retvals[0] = startAddr;
retvals[1] = stopAddr;
retvals[2] = numLoops;
#endif
return Server_SendResult(file_des, INT32, UPDATE, retvals, sizeof(retvals));
}
// mode 2: wait address
else if (mode == 2) {
// receive arguments
uint64_t args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT64) < 0)
return printSocketReadError();
int retval32 = -1;
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD)
functionNotImplemented();
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
#else
int loopLevel = (int)args[0];
int addr = (int)args[1];
FILE_LOG(logDEBUG1, (" loopLevel:%d addr:0x%x\n", loopLevel, addr));
if ((addr == -1) || (Server_VerifyLock() == OK)) {
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess, "Pattern (Wait Address) Level (0x%x) is not implemented for this detector\n", loopLevel);
FILE_LOG(logERROR,(mess));
} else if (addr > MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess, "Cannot set Pattern (Wait Address, addr:0x%x). Addr must be less than 0x%x\n",
addr, MAX_PATTERN_LENGTH);
FILE_LOG(logERROR, (mess));
} else {
char tempName[100];
memset(tempName, 0, 100);
sprintf(tempName, "Pattern (Wait Address, Level:%d)", loopLevel);
FILE_LOG(logDEBUG1, (" Setting %s to 0x%x\n", tempName, addr));
retval32 = setPatternWaitAddress(loopLevel, addr);
FILE_LOG(logDEBUG1, (" %s: 0x%x\n", tempName, retval32));
validate(addr, retval32, tempName, HEX);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval32, sizeof(retval32));
}
// mode 3: wait time
else if (mode == 3) {
// receive arguments
uint64_t args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT64) < 0)
return printSocketReadError();
int64_t retval64 = -1;
#if !defined(CHIPTESTBOARDD) && !defined(MOENCHD)
functionNotImplemented();
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
#else
int loopLevel = (int)args[0];
uint64_t timeval = args[1];
FILE_LOG(logDEBUG1, (" loopLevel:%d timeval:0x%lld\n", loopLevel, timeval));
if ((timeval == -1) || (Server_VerifyLock() == OK)) {
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess, "Pattern (Wait Time) Level (%d) is not implemented for this detector\n", loopLevel);
FILE_LOG(logERROR,(mess));
} else {
char tempName[100];
memset(tempName, 0, 100);
sprintf(tempName, "Pattern (Wait Time, Level:%d)", loopLevel);
FILE_LOG(logDEBUG1, (" Setting %s to 0x%lld\n", tempName, (long long int)timeval));
retval64 = setPatternWaitTime(loopLevel, timeval);
FILE_LOG(logDEBUG1, (" %s: 0x%lld\n", tempName, (long long int)retval64));
validate64(timeval, retval64, tempName, HEX);
}
}
#endif
return Server_SendResult(file_des, INT64, UPDATE, &retval64, sizeof(retval64));
}
// mode not defined
else {
ret = FAIL;
sprintf(mess, "Pattern mode index (%d) is not implemented for this detector\n", mode);
FILE_LOG(logERROR,(mess));
return Server_SendResult(file_des, INT64, UPDATE, NULL, 0);
}
}
int write_adc_register(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
uint32_t args[2] = {-1, -1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
uint32_t addr = args[0];
uint32_t val = args[1];
FILE_LOG(logDEBUG1, ("Writing 0x%x to ADC Register 0x%x\n", val, addr));
#ifdef EIGERD
functionNotImplemented();
#else
#ifndef VIRTUAL
// only set
if (Server_VerifyLock() == OK) {
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD)
AD9257_Set(addr, val);
#elif GOTTHARDD
if (getBoardRevision() == 1) {
AD9252_Set(addr, val);
} else {
AD9257_Set(addr, val);
}
#endif
}
#endif
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int set_counter_bit(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Set counter bit with value: %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// set
if (arg >= 0 && Server_VerifyLock() == OK) {
setCounterBit(arg);
}
// get
retval = setCounterBit(-1);
FILE_LOG(logDEBUG1, ("Set counter bit retval: %d\n", retval));
validate(arg, retval, "set counter bit", DEC);
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int pulse_pixel(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[3] = {-1,-1,-1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Pulse pixel, n: %d, x: %d, y: %d\n", args[0], args[1], args[2]));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = pulsePixel(args[0], args[1], args[2]);
if (ret == FAIL) {
strcpy(mess, "Could not pulse pixel\n");
FILE_LOG(logERROR,(mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int pulse_pixel_and_move(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[3] = {-1,-1,-1};
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Pulse pixel and move, n: %d, x: %d, y: %d\n",
args[0], args[1], args[2]));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = pulsePixelNMove(args[0], args[1], args[2]);
if (ret == FAIL) {
strcpy(mess, "Could not pulse pixel and move\n");
FILE_LOG(logERROR,(mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int pulse_chip(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Pulse chip: %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = pulseChip(arg);
if (ret == FAIL) {
strcpy(mess, "Could not pulse chip\n");
FILE_LOG(logERROR,(mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int set_rate_correct(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int64_t tau_ns = -1;
if (receiveData(file_des, &tau_ns, sizeof(tau_ns), INT64) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Set rate correct with tau %lld\n", (long long int)tau_ns));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
int dr = setDynamicRange(-1);
// switching on in wrong bit mode
if ((tau_ns != 0) && (dr != 32) && (dr != 16)) {
ret = FAIL;
strcpy(mess,"Rate correction Deactivated, must be in 32 or 16 bit mode\n");
FILE_LOG(logERROR,(mess));
}
// switching on in right mode
else {
if (tau_ns < 0)
tau_ns = getDefaultSettingsTau_in_nsec();
else if (tau_ns > 0) {
//changing tau to a user defined value changes settings to undefined
setSettings(UNDEFINED);
FILE_LOG(logERROR, ("Settings has been changed to undefined (tau changed)\n"));
}
int64_t retval = setRateCorrection(tau_ns);
validate64(tau_ns, retval, "set rate correction", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int get_rate_correct(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int64_t retval = -1;
FILE_LOG(logDEBUG1, ("Getting rate correction\n"));
#ifndef EIGERD
functionNotImplemented();
#else
retval = getCurrentTau();
FILE_LOG(logDEBUG1, ("Tau: %lld\n", (long long int)retval));
#endif
return Server_SendResult(file_des, INT64, UPDATE, &retval, sizeof(retval));
}
int set_network_parameter(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int args[2] = {-1,-1};
int retval = -1;
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
return printSocketReadError();
enum networkParameter mode = args[0];
int value = args[1];
FILE_LOG(logDEBUG1, ("Set network parameter index %d to %d\n", mode, value));
#if defined(GOTTHARDD) || defined (CHIPTESTBOARDD) || defined(MOENCHD)
functionNotImplemented();
#else
enum NETWORKINDEX serverIndex = 0;
// set & get
if ((value == -1) || (Server_VerifyLock() == OK)) {
// check index
switch (mode) {
#ifdef EIGERD
case FLOW_CONTROL_10G:
serverIndex = FLOWCTRL_10G;
break;
case DETECTOR_TXN_DELAY_LEFT:
serverIndex = TXN_LEFT;
break;
case DETECTOR_TXN_DELAY_RIGHT:
serverIndex = TXN_RIGHT;
break;
#endif
case DETECTOR_TXN_DELAY_FRAME:
serverIndex = TXN_FRAME;
#ifdef JUNGFRAUD
if (value > MAX_TIMESLOT_VAL) {
ret = FAIL;
sprintf(mess,"Transmission delay %d should be in range: 0 - %d\n",
value, MAX_TIMESLOT_VAL);
FILE_LOG(logERROR, (mess));
}
#endif
break;
default:
modeNotImplemented("Image index", (int)serverIndex);
break;
}
// valid index
if (ret == OK) {
retval = setNetworkParameter(serverIndex, value);
FILE_LOG(logDEBUG1, ("Network Parameter index %d: %d\n", serverIndex, retval));
validate(value, retval, "set network parameter", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int program_fpga(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
#if defined(EIGERD) || defined(GOTTHARDD)
//to receive any arguments
int n = 1;
while (n > 0)
n = receiveData(file_des,mess,MAX_STR_LENGTH,OTHER);
functionNotImplemented();
#else
#ifndef VIRTUAL
// only set
if (Server_VerifyLock() == OK) {
// not in programming mode
if (debugflag != PROGRAMMING_MODE) {
//to receive any arguments
int n = 1;
while (n > 0)
n = receiveData(file_des, mess, MAX_STR_LENGTH, OTHER);
ret = FAIL;
sprintf(mess,"FPGA cannot be programmed in this mode. "
"Restart on-board detector server with -update for programming mode.\n");
FILE_LOG(logERROR,(mess));
}
else {
FILE_LOG(logINFOBLUE, ("Programming FPGA...\n"));
size_t filesize = 0;
size_t totalsize = 0;
size_t unitprogramsize = 0;
char* fpgasrc = NULL;
FILE* fp = NULL;
// filesize
if (receiveData(file_des,&filesize,sizeof(filesize),INT32) < 0)
return printSocketReadError();
totalsize = filesize;
FILE_LOG(logDEBUG1, ("Total program size is: %d\n", totalsize));
// opening file pointer to flash and telling FPGA to not touch flash
if (startWritingFPGAprogram(&fp) != OK) {
ret = FAIL;
sprintf(mess,"Could not write to flash. Error at startup.\n");
FILE_LOG(logERROR,(mess));
}
//---------------- first ret ----------------
Server_SendResult(file_des, INT32, NO_UPDATE, NULL, 0);
if (ret != FAIL) {
//erasing flash
eraseFlash();
fpgasrc = (char*)malloc(MAX_FPGAPROGRAMSIZE);
}
//writing to flash part by part
while(ret != FAIL && filesize) {
unitprogramsize = MAX_FPGAPROGRAMSIZE; //2mb
if (unitprogramsize > filesize) //less than 2mb
unitprogramsize = filesize;
FILE_LOG(logDEBUG1, ("unit size to receive is:%d\n"
"filesize:%d\n", unitprogramsize, filesize));
//receive part of program
if (receiveData(file_des,fpgasrc,unitprogramsize,OTHER) < 0)
return printSocketReadError();
if (!(unitprogramsize - filesize)) {
fpgasrc[unitprogramsize] = '\0';
filesize -= unitprogramsize;
unitprogramsize++;
} else
filesize -= unitprogramsize;
// write part to flash
ret = writeFPGAProgram(fpgasrc, unitprogramsize, fp);
//---------------- middle rets ----------------
Server_SendResult(file_des, INT32, NO_UPDATE, NULL, 0);
if (ret == FAIL) {
FILE_LOG(logERROR, ("Failure: Breaking out of program receiving\n"));
} else {
//print progress
FILE_LOG(logINFO, ("Writing to Flash:%d%%\r",
(int) (((double)(totalsize-filesize)/totalsize)*100) ));
fflush(stdout);
}
}
printf("\n");
FILE_LOG(logINFO, ("Done copying program or due to failure earlier\n"));
// closing file pointer to flash and informing FPGA
stopWritingFPGAprogram(fp);
//free resources
if (fpgasrc != NULL)
free(fpgasrc);
if (fp != NULL)
fclose(fp);
FILE_LOG(logDEBUG1, ("Done with program receiving command\n"));
if (ret != FAIL && isControlServer) {
basictests();
initControlServer();
}
}
}
#endif
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int reset_fpga(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Reset FPGA\n"));
#if defined(EIGERD) || defined(GOTTHARDD)
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
if (isControlServer) {
basictests(); // mapping of control server at least
if (debugflag != PROGRAMMING_MODE)
initControlServer();
}
else initStopServer(); //remapping of stop server
ret = FORCE_UPDATE;
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
int power_chip(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Powering chip to %d\n", arg));
#if (!defined(JUNGFRAUD)) && (!defined(MOENCHD))
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = powerChip(arg);
FILE_LOG(logDEBUG1, ("Power chip: %d\n", retval));
validate(arg, retval, "power on/off chip", DEC);
// narrow down error when powering on
if (ret == FAIL && arg > 0) {
if (setTemperatureEvent(-1) == 1)
sprintf(mess,"Powering chip failed due to over-temperature event. "
"Clear event & power chip again. Set %d, read %d \n", arg, retval);
FILE_LOG(logERROR, (mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int set_activate(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting activate mode to %d\n", arg));
#ifndef EIGERD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = activate(arg);
FILE_LOG(logDEBUG1, ("Activate: %d\n", retval));
validate(arg, retval, "set activate", DEC);
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int prepare_acquisition(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Preparing Acquisition\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = prepareAcquisition();
if (ret == FAIL) {
strcpy(mess, "Could not prepare acquisition\n");
FILE_LOG(logERROR, (mess));
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
// stop server
int threshold_temp(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting threshold temperature to %d\n", arg));
#ifndef JUNGFRAUD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
if (arg > MAX_THRESHOLD_TEMP_VAL) {
ret = FAIL;
sprintf(mess,"Threshold Temp %d should be in range: 0 - %d\n",
arg, MAX_THRESHOLD_TEMP_VAL);
FILE_LOG(logERROR, (mess));
}
// valid temp
else {
retval = setThresholdTemperature(arg);
FILE_LOG(logDEBUG1, ("Threshold temperature: %d\n", retval));
validate(arg, retval, "set threshold temperature", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, NO_UPDATE, &retval, sizeof(retval));
}
// stop server
int temp_control(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting temperature control to %d\n", arg));
#ifndef JUNGFRAUD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = setTemperatureControl(arg);
FILE_LOG(logDEBUG1, ("Temperature control: %d\n", retval));
validate(arg, retval, "set temperature control", DEC);
}
#endif
return Server_SendResult(file_des, INT32, NO_UPDATE, &retval, sizeof(retval));
}
// stop server
int temp_event(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting temperature event to %d\n", arg));
#ifndef JUNGFRAUD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = setTemperatureEvent(arg);
FILE_LOG(logDEBUG1, ("Temperature event: %d\n", retval));
validate(arg, retval, "set temperature event", DEC);
}
#endif
return Server_SendResult(file_des, INT32, NO_UPDATE, &retval, sizeof(retval));
}
int auto_comp_disable(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting Auto comp disable to %d\n", arg));
#ifndef JUNGFRAUD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
retval = autoCompDisable(arg);
FILE_LOG(logDEBUG1, ("Auto comp disable: %d\n", retval));
validate(arg, retval, "set auto comp disable", DEC);
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int storage_cell_start(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int arg = -1;
int retval = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
return printSocketReadError();
FILE_LOG(logDEBUG1, ("Setting Storage cell start to %d\n", arg));
#ifndef JUNGFRAUD
functionNotImplemented();
#else
// set & get
if ((arg == -1) || (Server_VerifyLock() == OK)) {
if (arg > MAX_STORAGE_CELL_VAL) {
ret = FAIL;
strcpy(mess,"Max Storage cell number should not exceed 15\n");
FILE_LOG(logERROR, (mess));
} else {
retval = selectStoragecellStart(arg);
FILE_LOG(logDEBUG1, ("Storage cell start: %d\n", retval));
validate(arg, retval, "set storage cell start", DEC);
}
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, &retval, sizeof(retval));
}
int check_version(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
int64_t arg = -1;
if (receiveData(file_des, &arg, sizeof(arg), INT64) < 0)
return printSocketReadError();
// check software- firmware compatibility and basic tests
if (isControlServer) {
FILE_LOG(logDEBUG1, ("Checking software-firmware compatibility and basic test result\n"));
// check if firmware check is done
if (!isFirmwareCheckDone()) {
usleep(3 * 1000 * 1000);
if (!isFirmwareCheckDone()) {
ret = FAIL;
strcpy(mess,"Firmware Software Compatibility Check (Server Initialization) "
"still not done done in server. Unexpected.\n");
FILE_LOG(logERROR,(mess));
}
}
// check firmware check result
if (ret == OK) {
char* firmware_message = NULL;
if (getFirmwareCheckResult(&firmware_message) == FAIL) {
ret = FAIL;
strcpy(mess, firmware_message);
FILE_LOG(logERROR,(mess));
}
}
}
if (ret == OK) {
FILE_LOG(logDEBUG1, ("Checking versioning compatibility with value 0x%llx\n",arg));
int64_t client_requiredVersion = arg;
int64_t det_apiVersion = getDetectorId(CLIENT_SOFTWARE_API_VERSION);
int64_t det_version = getDetectorId(DETECTOR_SOFTWARE_VERSION);
// old client
if (det_apiVersion > client_requiredVersion) {
ret = FAIL;
sprintf(mess,"Client's detector SW API version: (0x%llx). "
"Detector's SW API Version: (0x%llx). "
"Incompatible, update client!\n",
(long long int)client_requiredVersion, (long long int)det_apiVersion);
FILE_LOG(logERROR,(mess));
}
// old software
else if (client_requiredVersion > det_version) {
ret = FAIL;
sprintf(mess,"Detector SW Version: (0x%llx). "
"Client's detector SW API Version: (0x%llx). "
"Incompatible, update detector software!\n",
(long long int)det_version, (long long int)client_requiredVersion);
FILE_LOG(logERROR,(mess));
}
}
return Server_SendResult(file_des, INT32, NO_UPDATE, NULL, 0);
}
int software_trigger(int file_des) {
ret = OK;
memset(mess, 0, sizeof(mess));
FILE_LOG(logDEBUG1, ("Software Trigger\n"));
#ifndef EIGERD
functionNotImplemented();
#else
// only set
if (Server_VerifyLock() == OK) {
ret = softwareTrigger();
if (ret == FAIL) {
sprintf(mess, "Could not send software trigger\n");
FILE_LOG(logERROR,(mess));
}
FILE_LOG(logDEBUG1, ("Software trigger ret: %d\n", ret));
}
#endif
return Server_SendResult(file_des, INT32, UPDATE, NULL, 0);
}
View Git Blame Copy Permalink