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

wip

Browse Source
This commit is contained in:
maliakal_d 2021-06-17 07:13:27 +02:00
parent a9f892483d
commit 028edd0d08
8 changed files with 468 additions and 416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

594
slsDetectorServers/mythen3DetectorServer/mythen3.c
View File

@ -1,7 +1,7 @@
#include "mythen3.h"
#include "clogger.h" #include "clogger.h"
#include "common.h" #include "common.h"
#include "mythen3.h"
#include "sls/ansi.h" #include "sls/ansi.h"
#include "sls/sls_detector_defs.h" #include "sls/sls_detector_defs.h"
#include "slsDetectorServer_defs.h" #include "slsDetectorServer_defs.h"
@ -22,353 +22,343 @@ typedef struct __attribute__((packed)) {
} patternParameters; } patternParameters;
*/ */
int chipStatusRegister=0; int chipStatusRegister = 0;
int setBit(int ibit, int patword) { return patword |= (1 << ibit); } int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); } int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
extern enum TLogLevel trimmingPrint ; int getChipStatusRegister() { return chipStatusRegister; }
int gainCapsToCsr(int caps) {
// Translates bit representation
int csr = 0;
if (!(caps & M3_C10pre))
csr |= 1 << _CSR_C10pre;
if (caps & M3_C15sh)
csr |= 1 << CSR_C15sh;
if (caps & M3_C30sh)
csr |= 1 << CSR_C30sh;
if (caps & M3_C50sh)
csr |= 1 << CSR_C50sh;
if (caps & M3_C225ACsh)
csr |= 1 << CSR_C225ACsh;
if (!(caps & M3_C15pre))
csr |= 1 << _CSR_C15pre;
int getChipStatusRegister(){ return csr;
return chipStatusRegister;
} }
int gainCapsToCsr(int caps){ int csrToGainCaps(int csr) {
//Translates bit representation // Translates bit representation
int csr = 0; int caps = 0;
if (!(caps & M3_C10pre)) if (!(csr & (1 << _CSR_C10pre)))
csr |= 1 << _CSR_C10pre; caps |= M3_C10pre;
if (caps & M3_C15sh) if (csr & (1 << CSR_C15sh))
csr |= 1 << CSR_C15sh; caps |= M3_C15sh;
if (caps & M3_C30sh) if (csr & (1 << CSR_C30sh))
csr |= 1 << CSR_C30sh; caps |= M3_C30sh;
if (caps & M3_C50sh) if (csr & (1 << CSR_C50sh))
csr |= 1 << CSR_C50sh; caps |= M3_C50sh;
if (caps & M3_C225ACsh) if (csr & (1 << CSR_C225ACsh))
csr |= 1 << CSR_C225ACsh; caps |= M3_C225ACsh;
if (!(caps & M3_C15pre)) if (!(csr & (1 << _CSR_C15pre)))
csr |= 1 << _CSR_C15pre; caps |= M3_C15pre;
return csr; return caps;
}
int csrToGainCaps(int csr){
//Translates bit representation
int caps = 0;
if (!(csr & (1 << _CSR_C10pre)))
caps |= M3_C10pre;
if (csr & (1 << CSR_C15sh))
caps |= M3_C15sh;
if (csr & (1 << CSR_C30sh))
caps |= M3_C30sh;
if (csr & (1 << CSR_C50sh))
caps |= M3_C50sh;
if (csr & (1 << CSR_C225ACsh))
caps |= M3_C225ACsh;
if (!(csr & (1 << _CSR_C15pre)))
caps |= M3_C15pre;
return caps;
} }
patternParameters *setChipStatusRegisterPattern(int csr) { patternParameters *setChipStatusRegisterPattern(int csr) {
int iaddr=0; int iaddr = 0;
int nbits=18; int nbits = 18;
int error=0; int error = 0;
//int start=0, stop=MAX_PATTERN_LENGTH, loop=0; // int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
int patword=0; int patword = 0;
patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters));
patword=setBit(SIGNAL_STATLOAD,patword);
for (int i=0; i<2; i++)
pat->word[iaddr++]=patword;
patword=setBit(SIGNAL_resStorage,patword);
patword=setBit(SIGNAL_resCounter,patword);
for (int i=0; i<8; i++)
pat->word[iaddr++]=patword;
patword=clearBit(SIGNAL_resStorage,patword);
patword=clearBit(SIGNAL_resCounter,patword);
for (int i=0; i<8; i++)
pat->word[iaddr++]=patword;
//#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
for (int ib=nbits-1; ib>=0; ib--) {
if (csr&(1<<ib))
patword=setBit(SIGNAL_serialIN,patword);
else
patword=clearBit(SIGNAL_serialIN,patword);
for (int i=0; i<4; i++)
pat->word[iaddr++]=patword;
patword=setBit(SIGNAL_CHSclk,patword);
pat->word[iaddr++]=patword;
patword=clearBit(SIGNAL_CHSclk,patword);
pat->word[iaddr++]=patword;
}
patword=clearBit(SIGNAL_serialIN,patword); patternParameters *pat = malloc(sizeof(patternParameters));
for (int i=0; i<2; i++) memset(pat, 0, sizeof(patternParameters));
pat->word[iaddr++]=patword;
patword=setBit(SIGNAL_STO,patword);
for (int i=0; i<5; i++)
pat->word[iaddr++]=patword;
patword=clearBit(SIGNAL_STO,patword);
for (int i=0; i<5; i++)
pat->word[iaddr++]=patword;
patword=clearBit(SIGNAL_STATLOAD,patword);
for (int i=0; i<5; i++)
pat->word[iaddr++]=patword;
if (iaddr >= MAX_PATTERN_LENGTH) { patword = setBit(SIGNAL_STATLOAD, patword);
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", for (int i = 0; i < 2; i++)
iaddr, MAX_PATTERN_LENGTH)); pat->word[iaddr++] = patword;
error = 1; patword = setBit(SIGNAL_resStorage, patword);
} patword = setBit(SIGNAL_resCounter, patword);
// set pattern wait address for (int i = 0; i < 8; i++)
for (int i = 0; i <= 2; i++) pat->word[iaddr++] = patword;
pat->wait[i]=MAX_PATTERN_LENGTH - 1; patword = clearBit(SIGNAL_resStorage, patword);
// pattern loop patword = clearBit(SIGNAL_resCounter, patword);
for (int i = 0; i <= 2; i++) { for (int i = 0; i < 8; i++)
//int stop = MAX_PATTERN_LENGTH - 1, nloop = 0; pat->word[iaddr++] = patword;
pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1; //#This version of the serializer pushes in the MSB first (compatible with
pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1; //the CSR bit numbering)
pat->nloop[i]=0; for (int ib = nbits - 1; ib >= 0; ib--) {
} if (csr & (1 << ib))
patword = setBit(SIGNAL_serialIN, patword);
// pattern limits else
{ patword = clearBit(SIGNAL_serialIN, patword);
pat->limits[0]=0; for (int i = 0; i < 4; i++)
pat->limits[1]=iaddr; pat->word[iaddr++] = patword;
} patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++] = patword;
if (error != 0) { patword = clearBit(SIGNAL_CHSclk, patword);
free(pat); pat->word[iaddr++] = patword;
return NULL; }
}
chipStatusRegister=csr;
return pat;
patword = clearBit(SIGNAL_serialIN, patword);
for (int i = 0; i < 2; i++)
pat->word[iaddr++] = patword;
patword = setBit(SIGNAL_STO, patword);
for (int i = 0; i < 5; i++)
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_STO, patword);
for (int i = 0; i < 5; i++)
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_STATLOAD, patword);
for (int i = 0; i < 5; i++)
pat->word[iaddr++] = patword;
if (iaddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", iaddr,
MAX_PATTERN_LENGTH));
error = 1;
}
// set pattern wait address
for (int i = 0; i <= 2; i++)
pat->wait[i] = MAX_PATTERN_LENGTH - 1;
// pattern loop
for (int i = 0; i <= 2; i++) {
// int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
pat->loop[i * 2 + 0] = MAX_PATTERN_LENGTH - 1;
pat->loop[i * 2 + 1] = MAX_PATTERN_LENGTH - 1;
pat->nloop[i] = 0;
}
// pattern limits
{
pat->limits[0] = 0;
pat->limits[1] = iaddr;
}
if (error != 0) {
free(pat);
return NULL;
}
chipStatusRegister = csr;
return pat;
} }
patternParameters *setInterpolation(int mask) { patternParameters *setInterpolation(int mask) {
int csr; int csr;
if (mask) if (mask)
csr=chipStatusRegister|(1<< CSR_interp); csr = chipStatusRegister | (1 << CSR_interp);
else else
csr=chipStatusRegister & ~(1<< CSR_interp); csr = chipStatusRegister & ~(1 << CSR_interp);
return setChipStatusRegisterPattern(csr); return setChipStatusRegisterPattern(csr);
} }
patternParameters *setPumpProbe(int mask) { patternParameters *setPumpProbe(int mask) {
int csr; int csr;
if (mask) if (mask)
csr=chipStatusRegister|(1<< CSR_pumprobe); csr = chipStatusRegister | (1 << CSR_pumprobe);
else else
csr=chipStatusRegister & ~(1<< CSR_pumprobe); csr = chipStatusRegister & ~(1 << CSR_pumprobe);
return setChipStatusRegisterPattern(csr);
return setChipStatusRegisterPattern(csr);
} }
patternParameters *setDigitalPulsing(int mask) { patternParameters *setDigitalPulsing(int mask) {
int csr; int csr;
if (mask) if (mask)
csr=chipStatusRegister|(1<< CSR_dpulse); csr = chipStatusRegister | (1 << CSR_dpulse);
else else
csr=chipStatusRegister & ~(1<< CSR_dpulse); csr = chipStatusRegister & ~(1 << CSR_dpulse);
return setChipStatusRegisterPattern(csr); return setChipStatusRegisterPattern(csr);
} }
patternParameters *setAnalogPulsing(int mask){ patternParameters *setAnalogPulsing(int mask) {
int csr; int csr;
if (mask) if (mask)
csr=chipStatusRegister|(1<< CSR_apulse); csr = chipStatusRegister | (1 << CSR_apulse);
else else
csr=chipStatusRegister & ~(1<< CSR_apulse); csr = chipStatusRegister & ~(1 << CSR_apulse);
return setChipStatusRegisterPattern(csr); return setChipStatusRegisterPattern(csr);
} }
patternParameters *setNegativePolarity(int mask){ patternParameters *setNegativePolarity(int mask) {
int csr; int csr;
if (mask) if (mask)
csr=chipStatusRegister|(1<< CSR_invpol); csr = chipStatusRegister | (1 << CSR_invpol);
else else
csr=chipStatusRegister & ~(1<< CSR_invpol); csr = chipStatusRegister & ~(1 << CSR_invpol);
return setChipStatusRegisterPattern(csr); return setChipStatusRegisterPattern(csr);
} }
patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) { patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {
patternParameters *pat = malloc(sizeof(patternParameters)); patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters)); memset(pat, 0, sizeof(patternParameters));
// validate // validate
for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS; ichan < ichip * NCHAN_1_COUNTER * NCOUNTERS+NCHAN_1_COUNTER*NCOUNTERS; ichan++) { for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS;
if (trimbits[ichan]<0) { ichan <
LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - setting it to 0\n", ichip * NCHAN_1_COUNTER * NCOUNTERS + NCHAN_1_COUNTER * NCOUNTERS;
trimbits[ichan], ichan)); ichan++) {
trimbits[ichan]=0; if (trimbits[ichan] < 0) {
LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - "
"setting it to 0\n",
trimbits[ichan], ichan));
trimbits[ichan] = 0;
}
if (trimbits[ichan] > 63) {
LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - "
"settings it to 63\n",
trimbits[ichan], ichan));
trimbits[ichan] = 63;
}
} }
if (trimbits[ichan] > 63) { LOG(logINFO, ("Trimbits validated\n"));
LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - settings it to 63\n",
trimbits[ichan], ichan));
trimbits[ichan]=63;
}
}
LOG(logINFO, ("Trimbits validated\n"));
trimmingPrint = logDEBUG5;
// trimming
// trimming int error = 0;
int error = 0; uint64_t patword = 0;
uint64_t patword = 0; int iaddr = 0;
int iaddr = 0;
LOG(logDEBUG1, (" Chip %d\n", ichip));
LOG(logDEBUG1, (" Chip %d\n", ichip)); iaddr = 0;
iaddr = 0; patword = 0;
patword = 0; pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword;
// chip select
// chip select patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
patword = setBit(SIGNAL_TBLoad_1 + ichip, patword); pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword;
// reset trimbits
// reset trimbits patword = setBit(SIGNAL_resStorage, patword);
patword = setBit(SIGNAL_resStorage, patword); patword = setBit(SIGNAL_resCounter, patword);
patword = setBit(SIGNAL_resCounter, patword); pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword; pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword; patword = clearBit(SIGNAL_resStorage, patword);
patword = clearBit(SIGNAL_resStorage, patword); patword = clearBit(SIGNAL_resCounter, patword);
patword = clearBit(SIGNAL_resCounter, patword); pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword; pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword;
// select first channel
// select first channel patword = setBit(SIGNAL_CHSserialIN, patword);
patword = setBit(SIGNAL_CHSserialIN, patword); pat->word[iaddr++] = patword;
pat->word[iaddr++]=patword; // 1 clk pulse
// 1 clk pulse
patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword;
patword = clearBit(SIGNAL_CHSclk, patword);
// clear 1st channel
pat->word[iaddr++]=patword;
patword = clearBit(SIGNAL_CHSserialIN, patword);
// 2 clk pulses
for (int i = 0; i < 2; i++) {
patword = setBit(SIGNAL_CHSclk, patword); patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword; pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_CHSclk, patword); patword = clearBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword; // clear 1st channel
} pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_CHSserialIN, patword);
// for each channel (all chips) // 2 clk pulses
for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) { for (int i = 0; i < 2; i++) {
LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich)); patword = setBit(SIGNAL_CHSclk, patword);
int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + pat->word[iaddr++] = patword;
NCOUNTERS * ich] + patword = clearBit(SIGNAL_CHSclk, patword);
trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + pat->word[iaddr++] = patword;
NCOUNTERS * ich + 1] *
64 +
trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
NCOUNTERS * ich + 2] *
64 * 64;
// push 6 0 bits
for (int i = 0; i < 3; i++) {
patword = clearBit(SIGNAL_serialIN, patword);
patword = clearBit(SIGNAL_clk, patword);
pat->word[iaddr++]=patword;
patword = setBit(SIGNAL_clk, patword);
pat->word[iaddr++]=patword;
} }
for (int i = 0; i < 3; i++) { // for each channel (all chips)
if (mask[i]) for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
patword = setBit(SIGNAL_serialIN, patword); LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
else int val =
patword = clearBit(SIGNAL_serialIN, patword); trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + NCOUNTERS * ich] +
patword = clearBit(SIGNAL_clk, patword); trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + NCOUNTERS * ich +
pat->word[iaddr++]=patword; 1] *
patword = setBit(SIGNAL_clk, patword); 64 +
pat->word[iaddr++]=patword; trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + NCOUNTERS * ich +
2] *
64 * 64;
// push 6 0 bits
for (int i = 0; i < 3; i++) {
patword = clearBit(SIGNAL_serialIN, patword);
patword = clearBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
patword = setBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
}
for (int i = 0; i < 3; i++) {
if (mask[i])
patword = setBit(SIGNAL_serialIN, patword);
else
patword = clearBit(SIGNAL_serialIN, patword);
patword = clearBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
patword = setBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
}
// deserialize
for (int i = 0; i < 18; i++) {
if (val & (1 << i)) {
patword = setBit(SIGNAL_serialIN, patword);
} else {
patword = clearBit(SIGNAL_serialIN, patword);
}
patword = clearBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
patword = setBit(SIGNAL_clk, patword);
pat->word[iaddr++] = patword;
}
pat->word[iaddr++] = patword;
pat->word[iaddr++] = patword;
// move to next channel
for (int i = 0; i < 3; i++) {
patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++] = patword;
}
} }
// chip unselect
// deserialize patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
for (int i = 0; i < 18; i++) { pat->word[iaddr++] = patword;
if (val & (1 << i)) {
patword = setBit(SIGNAL_serialIN, patword); // last iaddr check
} else { if (iaddr >= MAX_PATTERN_LENGTH) {
patword = clearBit(SIGNAL_serialIN, patword); LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", iaddr,
} MAX_PATTERN_LENGTH));
patword = clearBit(SIGNAL_clk, patword); error = 1;
pat->word[iaddr++]=patword;
patword = setBit(SIGNAL_clk, patword);
pat->word[iaddr++]=patword;
} }
pat->word[iaddr++]=patword;
pat->word[iaddr++]=patword; if (iaddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", iaddr,
// move to next channel MAX_PATTERN_LENGTH));
for (int i = 0; i < 3; i++) { error = 1;
patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword;
patword = clearBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword;
} }
} // set pattern wait address
// chip unselect for (int i = 0; i <= 2; i++)
patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword); pat->wait[i] = MAX_PATTERN_LENGTH - 1;
pat->word[iaddr++]=patword; // pattern loop
for (int i = 0; i <= 2; i++) {
// last iaddr check // int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
if (iaddr >= MAX_PATTERN_LENGTH) { pat->loop[i * 2 + 0] = MAX_PATTERN_LENGTH - 1;
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", pat->loop[i * 2 + 1] = MAX_PATTERN_LENGTH - 1;
iaddr, MAX_PATTERN_LENGTH)); pat->nloop[i] = 0;
error = 1; }
}
// pattern limits
if (iaddr >= MAX_PATTERN_LENGTH) { {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", pat->limits[0] = 0;
iaddr, MAX_PATTERN_LENGTH)); pat->limits[1] = iaddr;
error = 1; }
}
// set pattern wait address if (error == 0) {
for (int i = 0; i <= 2; i++)
pat->wait[i]=MAX_PATTERN_LENGTH - 1; LOG(logINFO, ("All trimbits have been loaded\n"));
// pattern loop } else {
for (int i = 0; i <= 2; i++) { free(pat);
//int stop = MAX_PATTERN_LENGTH - 1, nloop = 0; return NULL;
pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1; }
pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1; return pat;
pat->nloop[i]=0;
}
// pattern limits
{
pat->limits[0]=0;
pat->limits[1]=iaddr;
}
trimmingPrint = logINFO;
if (error == 0) {
LOG(logINFO, ("All trimbits have been loaded\n"));
} else {
free(pat);
return NULL;
}
return pat;
} }

72
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -1118,48 +1118,50 @@ int setModule(sls_detector_module myMod, char *mess) {
int setTrimbits(int *trimbits) { int setTrimbits(int *trimbits) {
LOG(logINFOBLUE, ("Setting trimbits\n")); LOG(logINFOBLUE, ("Setting trimbits\n"));
// remember previous run clock // remember previous run clock
uint32_t prevRunClk = clkDivider[SYSTEM_C0]; uint32_t prevRunClk = clkDivider[SYSTEM_C0];
patternParameters *pat = NULL;
int error = 0;
// set to trimming clock // set to trimming clock
if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) { if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
LOG(logERROR, LOG(logERROR,
("Could not start trimming. Could not set to trimming clock\n")); ("Could not start trimming. Could not set to trimming clock\n"));
return FAIL; return FAIL;
} }
/////////////////////////////////////////////////////////////////
for (int ichip = 0; ichip < NCHIP; ichip++) {
pat = setChannelRegisterChip(ichip, channelMask, // for every chip
trimbits); // change here!!! int error = 0;
if (pat) { char cmess[MAX_STR_LENGTH];
error |= loadPattern(logDEBUG5, pat); for (int ichip = 0; ichip < NCHIP; ichip++) {
if (error == 0) patternParameters *pat = setChannelRegisterChip(
ichip, channelMask,
trimbits); // change here!!! @who: Change what?
if (pat == NULL) {
error = 1;
} else {
memset(cmess, 0, MAX_STR_LENGTH);
error |= loadPattern(cmess, logDEBUG5, pat);
if (!error)
startPattern(); startPattern();
free(pat); free(pat);
} else }
error = 1;
} }
/////////////////////////////////////////////////////////////////
// copy trimbits locally
if (error == 0) { if (error == 0) {
// copy trimbits locally
for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) { for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
detectorChans[ichan] = trimbits[ichan]; detectorChans[ichan] = trimbits[ichan];
} }
LOG(logINFO, ("All trimbits have been loaded\n")); LOG(logINFO, ("All trimbits have been loaded\n"));
} }
trimmingPrint = logINFO;
// set back to previous clock // set back to previous clock
if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) { if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
LOG(logERROR, ("Could not set to previous run clock after trimming\n")); LOG(logERROR, ("Could not set to previous run clock after trimming\n"));
return FAIL; return FAIL;
} }
if (error != 0) { return (error ? FAIL : OK);
return FAIL;
}
return OK;
} }
int setAllTrimbits(int val) { int setAllTrimbits(int val) {
@ -2652,36 +2654,40 @@ int getNumberOfDACs() { return NDAC; }
int getNumberOfChannelsPerChip() { return NCHAN; } int getNumberOfChannelsPerChip() { return NCHAN; }
int setChipStatusRegister(int csr) { int setChipStatusRegister(int csr) {
uint32_t prevRunClk = clkDivider[SYSTEM_C0];
patternParameters *pat = NULL;
int error = 0; // remember previous run clock
uint32_t prevRunClk = clkDivider[SYSTEM_C0];
// set to trimming clock
if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) { if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
LOG(logERROR, LOG(logERROR,
("Could not set to trimming clock in order to change CSR\n")); ("Could not set to trimming clock in order to change CSR\n"));
return FAIL; return FAIL;
} }
pat = setChipStatusRegisterPattern(csr);
if (pat) { int iret = OK;
error |= loadPattern(logDEBUG5, pat); char cmess[MAX_STR_LENGTH];
if (!error) patternParameters *pat = setChipStatusRegisterPattern(csr);
startPattern(); if (pat == NULL) {
free(pat); iret = FAIL;
} else { } else {
error = 1; memset(cmess, 0, MAX_STR_LENGTH);
} iret = loadPattern(cmess, logDEBUG5, pat);
if (iret == OK) {
if (!error) { startPattern();
LOG(logINFO, ("CSR is now: 0x%x\n", csr)); LOG(logINFO, ("CSR is now: 0x%x\n", csr));
}
free(pat);
} }
// set back to previous clock
if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) { if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
LOG(logERROR, LOG(logERROR,
("Could not set to previous run clock after changing CSR\n")); ("Could not set to previous run clock after changing CSR\n"));
return FAIL; return FAIL;
} }
return OK;
return iret;
} }
int setGainCaps(int caps) { int setGainCaps(int caps) {

7
slsDetectorServers/slsDetectorServer/include/common.h
View File

@ -24,6 +24,7 @@ int getAbsPath(char *buf, size_t bufSize, char *fname);
int GetTimeFromString(char *buf, time_t *result); int GetTimeFromString(char *buf, time_t *result);
void validate(int arg, int retval, char *modename, enum numberMode nummode); void validate(int *ret, char *mess, int arg, int retval, char *modename,
void validate64(int64_t arg, int64_t retval, char *modename, enum numberMode nummode);
enum numberMode nummode); void validate64(int *ret, char *mess, int64_t arg, int64_t retval,
char *modename, enum numberMode nummode);

2
slsDetectorServers/slsDetectorServer/include/loadPattern.h
View File

@ -3,5 +3,5 @@
#include "Pattern.h" #include "Pattern.h"
#include "clogger.h" #include "clogger.h"
int loadPattern(enum TLogLevel printLevel, patternParameters *pat); int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat);
#endif #endif

15
slsDetectorServers/slsDetectorServer/src/common.c
View File

@ -74,9 +74,10 @@ int GetTimeFromString(char *buf, time_t *result) {
return OK; return OK;
} }
void validate(int arg, int retval, char *modename, enum numberMode nummode) { void validate(int *ret, char *mess, int arg, int retval, char *modename,
if (ret == OK && arg != GET_FLAG && retval != arg) { enum numberMode nummode) {
ret = FAIL; if (*ret == OK && arg != GET_FLAG && retval != arg) {
*ret = FAIL;
if (nummode == HEX) if (nummode == HEX)
sprintf(mess, "Could not %s. Set 0x%x, but read 0x%x\n", modename, sprintf(mess, "Could not %s. Set 0x%x, but read 0x%x\n", modename,
arg, retval); arg, retval);
@ -87,10 +88,10 @@ void validate(int arg, int retval, char *modename, enum numberMode nummode) {
} }
} }
void validate64(int64_t arg, int64_t retval, char *modename, void validate64(int *ret, char *mess, int64_t arg, int64_t retval,
enum numberMode nummode) { char *modename, enum numberMode nummode) {
if (ret == OK && arg != GET_FLAG && retval != arg) { if (*ret == OK && arg != GET_FLAG && retval != arg) {
ret = FAIL; *ret = FAIL;
if (nummode == HEX) if (nummode == HEX)
sprintf(mess, "Could not %s. Set 0x%llx, but read 0x%llx\n", sprintf(mess, "Could not %s. Set 0x%llx, but read 0x%llx\n",
modename, (long long unsigned int)arg, modename, (long long unsigned int)arg,

38
slsDetectorServers/slsDetectorServer/src/loadPattern.c
View File

@ -25,7 +25,7 @@ extern uint64_t setPatternWaitTime(int level, uint64_t t);
extern void setPatternLoop(int level, int *startAddr, int *stopAddr, extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
int *nLoop); int *nLoop);
int loadPattern(enum TLogLevel printLevel, patternParameters *pat) { int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
LOG(logINFOBLUE, ("Loading Pattern\n")); LOG(logINFOBLUE, ("Loading Pattern\n"));
int ret = OK; int ret = OK;
trimmingPrint = printLevel; trimmingPrint = printLevel;
@ -92,6 +92,10 @@ int loadPattern(enum TLogLevel printLevel, patternParameters *pat) {
} }
// patwaittime // patwaittime
if (pattern_setWaitTime(mess, i, pat->waittime[i]) == FAIL) {
break;
}
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait time", i); sprintf(msg, "set pattern Loop %d wait time", i);
retval64 = setPatternWaitTime(i, pat->waittime[i]); retval64 = setPatternWaitTime(i, pat->waittime[i]);
@ -105,3 +109,35 @@ int loadPattern(enum TLogLevel printLevel, patternParameters *pat) {
return ret; return ret;
} }
int pattern_setWaitTime(char *mess, int level, uint64_t waittime) {
memset(mess, 0, sizeof(mess));
char msg[128];
memset(msg, 0, sizeof(msg));
// validations
if (level < 0 || level > 2) {
sprintf(initErrorMessage,
"Cannot set patwaittime from default "
"pattern file. Level must be between 0 and 2. Line:[%s]\n",
line);
return FAIL;
}
uint64_t retval = setPatternWaitTime(level, waittime);
// validate
if (retval != waittime) {
#ifdef VIRTUAL
sprintf(initErrorMessage,
"Could not set patwaittime (level: %d) from default "
"pattern file. Read %ld wait time. Line:[%s]\n",
level, retval, line);
#else
sprintf(initErrorMessage,
"Could not set patwaittime (level: %d) from default "
"pattern file. Read %lld wait time. Line:[%s]\n",
level, retval, line);
#endif
return FAIL;
}
return OK;
}

13
slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c
View File

@ -1,7 +1,7 @@
#include "readDefaultPattern.h" #include "readDefaultPattern.h"
#include "loadPattern.h"
#include "clogger.h" #include "clogger.h"
#include "common.h" #include "common.h"
#include "loadPattern.h"
#include "sls/ansi.h" #include "sls/ansi.h"
#include "sls/sls_detector_defs.h" #include "sls/sls_detector_defs.h"
#include "slsDetectorServer_defs.h" #include "slsDetectorServer_defs.h"
@ -19,7 +19,9 @@ extern uint64_t setPatternWaitTime(int level, uint64_t t);
extern void setPatternLoop(int level, int *startAddr, int *stopAddr, extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
int *nLoop); int *nLoop);
int loadDefaultPattern(char *patFname, char *errMessage) { int loadDefaultPattern(char *patFname,
char *errMessage) { // this needs to be copied to
// initeerrormessage at function call
char fname[128]; char fname[128];
if (getAbsPath(fname, 128, patFname) == FAIL) { if (getAbsPath(fname, 128, patFname) == FAIL) {
return FAIL; return FAIL;
@ -274,8 +276,11 @@ int loadDefaultPattern(char *patFname, char *errMessage) {
break; break;
} }
if (default_setPatternWaitTime(line, level, waittime) == FAIL) { if (pattern_setWaitTime(errMessage, level, waittime) == FAIL) {
break; sprintf(initErrorMessage,
"%s(Default pattern file. Line: %s)\n", errMessage,
line);
return FAIL;
} }
} }

143
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -574,7 +574,8 @@ int set_external_signal_flag(int file_des) {
if (ret == OK) { if (ret == OK) {
setExtSignal(signalIndex, flag); setExtSignal(signalIndex, flag);
retval = getExtSignal(signalIndex); retval = getExtSignal(signalIndex);
validate((int)flag, (int)retval, "set external signal flag", DEC); validate(&ret, mess, &ret, mess, (int)flag, (int)retval,
"set external signal flag", DEC);
LOG(logDEBUG1, ("External Signal Flag: %d\n", retval)); LOG(logDEBUG1, ("External Signal Flag: %d\n", retval));
} }
} }
@ -614,7 +615,7 @@ int set_timing_mode(int file_des) {
// get // get
retval = getTiming(); retval = getTiming();
#ifndef MYTHEN3D #ifndef MYTHEN3D
validate((int)arg, (int)retval, "set timing mode", DEC); validate(&ret, mess, (int)arg, (int)retval, "set timing mode", DEC);
#endif #endif
LOG(logDEBUG1, ("Timing Mode: %d\n", retval)); LOG(logDEBUG1, ("Timing Mode: %d\n", retval));
@ -1025,7 +1026,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
case IO_DELAY: case IO_DELAY:
retval = setIODelay(val); retval = setIODelay(val);
LOG(logDEBUG1, ("IODelay: %d\n", retval)); LOG(logDEBUG1, ("IODelay: %d\n", retval));
validate(val, retval, "set iodelay", DEC); validate(&ret, mess, val, retval, "set iodelay", DEC);
break; break;
#endif #endif
@ -1035,7 +1036,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
LOG(logDEBUG1, ("High Voltage: %d\n", retval)); LOG(logDEBUG1, ("High Voltage: %d\n", retval));
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || \ #if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || \
defined(GOTTHARD2D) || defined(MYTHEN3D) defined(GOTTHARD2D) || defined(MYTHEN3D)
validate(val, retval, "set high voltage", DEC); validate(&ret, mess, val, retval, "set high voltage", DEC);
#endif #endif
#ifdef GOTTHARDD #ifdef GOTTHARDD
if (retval == -1) { if (retval == -1) {
@ -1044,7 +1045,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
"110, 120, 150, 180, 200\n"); "110, 120, 150, 180, 200\n");
LOG(logERROR, (mess)); LOG(logERROR, (mess));
} else } else
validate(val, retval, "set high voltage", DEC); validate(&ret, mess, val, retval, "set high voltage", DEC);
#elif EIGERD #elif EIGERD
if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) { if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) {
ret = FAIL; ret = FAIL;
@ -1102,7 +1103,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
} }
retval = getPower(serverDacIndex); retval = getPower(serverDacIndex);
LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval)); LOG(logDEBUG1, ("Power regulator(%d): %d\n", ind, retval));
validate(val, retval, "set power regulator", DEC); validate(&ret, mess, val, retval, "set power regulator", DEC);
break; break;
case V_POWER_CHIP: case V_POWER_CHIP:
@ -1148,7 +1149,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
} }
retval = getVLimit(); retval = getVLimit();
LOG(logDEBUG1, ("VLimit: %d\n", retval)); LOG(logDEBUG1, ("VLimit: %d\n", retval));
validate(val, retval, "set vlimit", DEC); validate(&ret, mess, val, retval, "set vlimit", DEC);
break; break;
#endif #endif
// dacs // dacs
@ -1548,7 +1549,8 @@ int set_module(int file_des) {
ret = setModule(module, mess); ret = setModule(module, mess);
enum detectorSettings retval = getSettings(); enum detectorSettings retval = getSettings();
#if !(defined(EIGERD) || defined(MYTHEN3D)) #if !(defined(EIGERD) || defined(MYTHEN3D))
validate(module.reg, (int)retval, "set module (settings)", DEC); validate(&ret, mess, module.reg, (int)retval, "set module (settings)",
DEC);
#endif #endif
LOG(logDEBUG1, ("Settings: %d\n", retval)); LOG(logDEBUG1, ("Settings: %d\n", retval));
} }
@ -1630,7 +1632,7 @@ int set_settings(int file_des) {
LOG(logDEBUG1, ("Settings: %d\n", retval)); LOG(logDEBUG1, ("Settings: %d\n", retval));
if ((int)isett != GET_FLAG) { if ((int)isett != GET_FLAG) {
validate((int)isett, (int)retval, "set settings", DEC); validate(&ret, mess, (int)isett, (int)retval, "set settings", DEC);
#ifdef GOTTHARDD #ifdef GOTTHARDD
if (ret == OK) { if (ret == OK) {
ret = setDefaultDacs(); ret = setDefaultDacs();
@ -1966,7 +1968,8 @@ int set_num_frames(int file_des) {
int64_t retval = getNumFrames(); int64_t retval = getNumFrames();
LOG(logDEBUG1, LOG(logDEBUG1,
("retval num frames %lld\n", (long long int)retval)); ("retval num frames %lld\n", (long long int)retval));
validate64(arg, retval, "set number of frames", DEC); validate64(&ret, mess, arg, retval, "set number of frames",
DEC);
} }
} }
} }
@ -2041,8 +2044,8 @@ int set_num_additional_storage_cells(int file_des) {
setNumAdditionalStorageCells(arg); setNumAdditionalStorageCells(arg);
int retval = getNumAdditionalStorageCells(); int retval = getNumAdditionalStorageCells();
LOG(logDEBUG1, ("retval num addl. storage cells %d\n", retval)); LOG(logDEBUG1, ("retval num addl. storage cells %d\n", retval));
validate(arg, retval, "set number of additional storage cells", validate(&ret, mess, arg, retval,
DEC); "set number of additional storage cells", DEC);
} }
} }
#endif #endif
@ -2099,7 +2102,8 @@ int set_num_analog_samples(int file_des) {
} else { } else {
int retval = getNumAnalogSamples(); int retval = getNumAnalogSamples();
LOG(logDEBUG1, ("retval num analog samples %d\n", retval)); LOG(logDEBUG1, ("retval num analog samples %d\n", retval));
validate(arg, retval, "set number of analog samples", DEC); validate(&ret, mess, arg, retval,
"set number of analog samples", DEC);
} }
} }
} }
@ -2146,7 +2150,8 @@ int set_num_digital_samples(int file_des) {
} else { } else {
int retval = getNumDigitalSamples(); int retval = getNumDigitalSamples();
LOG(logDEBUG1, ("retval num digital samples %d\n", retval)); LOG(logDEBUG1, ("retval num digital samples %d\n", retval));
validate(arg, retval, "set number of digital samples", DEC); validate(&ret, mess, arg, retval, "set number of digital samples",
DEC);
} }
} }
#endif #endif
@ -2720,7 +2725,7 @@ int set_dynamic_range(int file_des) {
sprintf(mess, "Could not get dynamic range.\n"); sprintf(mess, "Could not get dynamic range.\n");
LOG(logERROR, (mess)); LOG(logERROR, (mess));
} }
validate(dr, retval, "set dynamic range", DEC); validate(&ret, mess, dr, retval, "set dynamic range", DEC);
break; break;
default: default:
modeNotImplemented("Dynamic range", dr); modeNotImplemented("Dynamic range", dr);
@ -2892,7 +2897,7 @@ int enable_ten_giga(int file_des) {
} }
retval = enableTenGigabitEthernet(GET_FLAG); retval = enableTenGigabitEthernet(GET_FLAG);
LOG(logDEBUG1, ("10GbE: %d\n", retval)); LOG(logDEBUG1, ("10GbE: %d\n", retval));
validate(arg, retval, "enable/disable 10GbE", DEC); validate(&ret, mess, arg, retval, "enable/disable 10GbE", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -2927,7 +2932,7 @@ int validateAndSetAllTrimbits(int arg) {
// get // get
retval = getAllTrimbits(); retval = getAllTrimbits();
LOG(logDEBUG1, ("All trimbits: %d\n", retval)); LOG(logDEBUG1, ("All trimbits: %d\n", retval));
validate(arg, retval, "set all trimbits", DEC); validate(&ret, mess, arg, retval, "set all trimbits", DEC);
#endif #endif
return retval; return retval;
} }
@ -2966,7 +2971,7 @@ int set_pattern_io_control(int file_des) {
retval = writePatternIOControl(arg); retval = writePatternIOControl(arg);
LOG(logDEBUG1, LOG(logDEBUG1,
("Pattern IO Control retval: 0x%llx\n", (long long int)retval)); ("Pattern IO Control retval: 0x%llx\n", (long long int)retval));
validate64(arg, retval, "set Pattern IO Control", HEX); validate64(&ret, mess, arg, retval, "set Pattern IO Control", HEX);
} }
#endif #endif
return Server_SendResult(file_des, INT64, &retval, sizeof(retval)); return Server_SendResult(file_des, INT64, &retval, sizeof(retval));
@ -3056,9 +3061,10 @@ int set_pattern_loop_addresses(int file_des) {
startAddr, stopAddr)); startAddr, stopAddr));
retvals[0] = startAddr; retvals[0] = startAddr;
retvals[1] = stopAddr; retvals[1] = stopAddr;
validate(args[1], startAddr, "set Pattern loops' start address", validate(&ret, mess, args[1], startAddr,
HEX); "set Pattern loops' start address", HEX);
validate(args[2], stopAddr, "set Pattern loops' stop address", HEX); validate(&ret, mess, args[2], stopAddr,
"set Pattern loops' stop address", HEX);
} }
} }
#endif #endif
@ -3096,8 +3102,8 @@ int set_pattern_loop_cycles(int file_des) {
retval = numLoops; retval = numLoops;
LOG(logDEBUG1, LOG(logDEBUG1,
("Pattern loop cycles retval: (ncycles:%d)\n", retval)); ("Pattern loop cycles retval: (ncycles:%d)\n", retval));
validate(args[1], retval, "set Pattern loops' number of cycles", validate(&ret, mess, args[1], retval,
DEC); "set Pattern loops' number of cycles", DEC);
} }
} }
#endif #endif
@ -3140,7 +3146,7 @@ int set_pattern_wait_addr(int file_des) {
} else { } else {
retval = setPatternWaitAddress(loopLevel, addr); retval = setPatternWaitAddress(loopLevel, addr);
LOG(logDEBUG1, ("Pattern wait address retval: 0x%x\n", retval)); LOG(logDEBUG1, ("Pattern wait address retval: 0x%x\n", retval));
validate(addr, retval, "set Pattern wait address", HEX); validate(&ret, mess, addr, retval, "set Pattern wait address", HEX);
} }
} }
#endif #endif
@ -3175,7 +3181,8 @@ int set_pattern_wait_time(int file_des) {
retval = setPatternWaitTime(loopLevel, timeval); retval = setPatternWaitTime(loopLevel, timeval);
LOG(logDEBUG1, LOG(logDEBUG1,
("Pattern wait time retval: 0x%llx\n", (long long int)retval)); ("Pattern wait time retval: 0x%llx\n", (long long int)retval));
validate64(timeval, retval, "set Pattern wait time", HEX); validate64(&ret, mess, timeval, retval, "set Pattern wait time",
HEX);
} }
} }
#endif #endif
@ -3200,7 +3207,7 @@ int set_pattern_mask(int file_des) {
uint64_t retval64 = getPatternMask(); uint64_t retval64 = getPatternMask();
LOG(logDEBUG1, LOG(logDEBUG1,
("Pattern mask: 0x%llx\n", (long long unsigned int)retval64)); ("Pattern mask: 0x%llx\n", (long long unsigned int)retval64));
validate64(arg, retval64, "set Pattern Mask", HEX); validate64(&ret, mess, arg, retval64, "set Pattern Mask", HEX);
} }
#endif #endif
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
@ -3243,7 +3250,7 @@ int set_pattern_bit_mask(int file_des) {
uint64_t retval64 = getPatternBitMask(); uint64_t retval64 = getPatternBitMask();
LOG(logDEBUG1, LOG(logDEBUG1,
("Pattern bit mask: 0x%llx\n", (long long unsigned int)retval64)); ("Pattern bit mask: 0x%llx\n", (long long unsigned int)retval64));
validate64(arg, retval64, "set Pattern Bit Mask", HEX); validate64(&ret, mess, arg, retval64, "set Pattern Bit Mask", HEX);
} }
#endif #endif
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
@ -3321,7 +3328,7 @@ int set_counter_bit(int file_des) {
// get // get
retval = setCounterBit(GET_FLAG); retval = setCounterBit(GET_FLAG);
LOG(logDEBUG1, ("Set counter bit retval: %d\n", retval)); LOG(logDEBUG1, ("Set counter bit retval: %d\n", retval));
validate(arg, retval, "set counter bit", DEC); validate(&ret, mess, arg, retval, "set counter bit", DEC);
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
} }
@ -3421,7 +3428,7 @@ int set_rate_correct(int file_des) {
strcpy(mess, "Rate correction failed\n"); strcpy(mess, "Rate correction failed\n");
LOG(logERROR, (mess)); LOG(logERROR, (mess));
} else { } else {
validate64(tau_ns, retval, "set rate correction", DEC); validate64(&ret, mess, tau_ns, retval, "set rate correction", DEC);
} }
} }
#endif #endif
@ -3464,7 +3471,7 @@ int set_ten_giga_flow_control(int file_des) {
} else { } else {
int retval = getTenGigaFlowControl(); int retval = getTenGigaFlowControl();
LOG(logDEBUG1, ("ten giga flow control retval: %d\n", retval)); LOG(logDEBUG1, ("ten giga flow control retval: %d\n", retval));
validate(arg, retval, "set ten giga flow control", DEC); validate(&ret, mess, arg, retval, "set ten giga flow control", DEC);
} }
} }
#endif #endif
@ -3523,7 +3530,8 @@ int set_transmission_delay_frame(int file_des) {
int retval = getTransmissionDelayFrame(); int retval = getTransmissionDelayFrame();
LOG(logDEBUG1, LOG(logDEBUG1,
("transmission delay frame retval: %d\n", retval)); ("transmission delay frame retval: %d\n", retval));
validate(arg, retval, "set transmission delay frame", DEC); validate(&ret, mess, arg, retval,
"set transmission delay frame", DEC);
} }
} }
} }
@ -3573,7 +3581,8 @@ int set_transmission_delay_left(int file_des) {
} else { } else {
int retval = getTransmissionDelayLeft(); int retval = getTransmissionDelayLeft();
LOG(logDEBUG1, ("transmission delay left retval: %d\n", retval)); LOG(logDEBUG1, ("transmission delay left retval: %d\n", retval));
validate(arg, retval, "set transmission delay left", DEC); validate(&ret, mess, arg, retval, "set transmission delay left",
DEC);
} }
} }
#endif #endif
@ -3622,7 +3631,8 @@ int set_transmission_delay_right(int file_des) {
} else { } else {
int retval = getTransmissionDelayRight(); int retval = getTransmissionDelayRight();
LOG(logDEBUG1, ("transmission delay right retval: %d\n", retval)); LOG(logDEBUG1, ("transmission delay right retval: %d\n", retval));
validate(arg, retval, "set transmission delay right", DEC); validate(&ret, mess, arg, retval, "set transmission delay right",
DEC);
} }
} }
#endif #endif
@ -3873,7 +3883,7 @@ int power_chip(int file_des) {
retval = powerChip(arg); retval = powerChip(arg);
LOG(logDEBUG1, ("Power chip: %d\n", retval)); LOG(logDEBUG1, ("Power chip: %d\n", retval));
} }
validate(arg, retval, "power on/off chip", DEC); validate(&ret, mess, arg, retval, "power on/off chip", DEC);
#ifdef JUNGFRAUD #ifdef JUNGFRAUD
// narrow down error when powering on // narrow down error when powering on
if (ret == FAIL && arg > 0) { if (ret == FAIL && arg > 0) {
@ -3920,7 +3930,7 @@ int set_activate(int file_des) {
LOG(logERROR, (mess)); LOG(logERROR, (mess));
} else { } else {
LOG(logDEBUG1, ("Activate: %d\n", retval)); LOG(logDEBUG1, ("Activate: %d\n", retval));
validate(arg, retval, "set/get activate", DEC); validate(&ret, mess, arg, retval, "set/get activate", DEC);
} }
} }
} }
@ -3979,7 +3989,7 @@ int temp_control(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) { if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setTemperatureControl(arg); retval = setTemperatureControl(arg);
LOG(logDEBUG1, ("Temperature control: %d\n", retval)); LOG(logDEBUG1, ("Temperature control: %d\n", retval));
validate(arg, retval, "set temperature control", DEC); validate(&ret, mess, arg, retval, "set temperature control", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4003,7 +4013,7 @@ int temp_event(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) { if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setTemperatureEvent(arg); retval = setTemperatureEvent(arg);
LOG(logDEBUG1, ("Temperature event: %d\n", retval)); LOG(logDEBUG1, ("Temperature event: %d\n", retval));
validate(arg, retval, "set temperature event", DEC); validate(&ret, mess, arg, retval, "set temperature event", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4026,7 +4036,7 @@ int auto_comp_disable(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) { if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = autoCompDisable(arg); retval = autoCompDisable(arg);
LOG(logDEBUG1, ("Auto comp disable: %d\n", retval)); LOG(logDEBUG1, ("Auto comp disable: %d\n", retval));
validate(arg, retval, "set auto comp disable", DEC); validate(&ret, mess, arg, retval, "set auto comp disable", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4054,7 +4064,7 @@ int storage_cell_start(int file_des) {
} else { } else {
retval = selectStoragecellStart(arg); retval = selectStoragecellStart(arg);
LOG(logDEBUG1, ("Storage cell start: %d\n", retval)); LOG(logDEBUG1, ("Storage cell start: %d\n", retval));
validate(arg, retval, "set storage cell start", DEC); validate(&ret, mess, arg, retval, "set storage cell start", DEC);
} }
} }
#endif #endif
@ -4169,7 +4179,7 @@ int led(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) { if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setLEDEnable(arg); retval = setLEDEnable(arg);
LOG(logDEBUG1, ("LED Enable: %d\n", retval)); LOG(logDEBUG1, ("LED Enable: %d\n", retval));
validate(arg, retval, "enable/disable LED", DEC); validate(&ret, mess, arg, retval, "enable/disable LED", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4473,7 +4483,8 @@ int set_external_sampling_source(int file_des) {
} else { } else {
retval = setExternalSamplingSource(arg); retval = setExternalSamplingSource(arg);
LOG(logDEBUG1, ("External Sampling source: %d\n", retval)); LOG(logDEBUG1, ("External Sampling source: %d\n", retval));
validate(arg, retval, "set external sampling source", DEC); validate(&ret, mess, arg, retval, "set external sampling source",
DEC);
} }
} }
#endif #endif
@ -4498,7 +4509,7 @@ int set_external_sampling(int file_des) {
arg = (arg > 0) ? 1 : arg; arg = (arg > 0) ? 1 : arg;
retval = setExternalSampling(arg); retval = setExternalSampling(arg);
LOG(logDEBUG1, ("External Sampling enable: %d\n", retval)); LOG(logDEBUG1, ("External Sampling enable: %d\n", retval));
validate(arg, retval, "set external sampling enable", DEC); validate(&ret, mess, arg, retval, "set external sampling enable", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval)); return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -5587,7 +5598,7 @@ int set_readout_mode(int file_des) {
} else { } else {
LOG(logDEBUG1, ("readout mode retval: %u\n", retval)); LOG(logDEBUG1, ("readout mode retval: %u\n", retval));
} }
validate(arg, retval, "set readout mode", DEC); validate(&ret, mess, arg, retval, "set readout mode", DEC);
} }
} }
} }
@ -5672,7 +5683,7 @@ int set_clock_frequency(int file_des) {
int retval = getFrequency(c); int retval = getFrequency(c);
LOG(logDEBUG1, ("retval %s: %d %s\n", modeName, retval, LOG(logDEBUG1, ("retval %s: %d %s\n", modeName, retval,
myDetectorType == GOTTHARD2 ? "Hz" : "MHz")); myDetectorType == GOTTHARD2 ? "Hz" : "MHz"));
validate(val, retval, modeName, DEC); validate(&ret, mess, val, retval, modeName, DEC);
} }
} }
} }
@ -5824,7 +5835,7 @@ int set_clock_phase(int file_des) {
int retval = getPhase(c, inDegrees); int retval = getPhase(c, inDegrees);
LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval)); LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval));
if (!inDegrees) { if (!inDegrees) {
validate(val, retval, modeName, DEC); validate(&ret, mess, val, retval, modeName, DEC);
} else { } else {
ret = validatePhaseinDegrees(c, val, retval); ret = validatePhaseinDegrees(c, val, retval);
if (ret == FAIL) { if (ret == FAIL) {
@ -6027,7 +6038,7 @@ int set_clock_divider(int file_des) {
} else { } else {
int retval = getClockDivider(c); int retval = getClockDivider(c);
LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval)); LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval));
validate(val, retval, modeName, DEC); validate(&ret, mess, val, retval, modeName, DEC);
} }
} }
} }
@ -6118,7 +6129,7 @@ int set_pipeline(int file_des) {
setPipeline(c, val); setPipeline(c, val);
int retval = getPipeline(c); int retval = getPipeline(c);
LOG(logDEBUG1, ("retval %s: %d\n", modeName, retval)); LOG(logDEBUG1, ("retval %s: %d\n", modeName, retval));
validate(val, retval, modeName, DEC); validate(&ret, mess, val, retval, modeName, DEC);
} }
} }
#endif #endif
@ -6234,7 +6245,7 @@ int set_on_chip_dac(int file_des) {
} else { } else {
int retval = getOnChipDAC(dacIndex, chipIndex); int retval = getOnChipDAC(dacIndex, chipIndex);
LOG(logDEBUG1, ("retval %s: 0x%x\n", modeName, retval)); LOG(logDEBUG1, ("retval %s: 0x%x\n", modeName, retval));
validate(val, retval, modeName, DEC); validate(&ret, mess, val, retval, modeName, DEC);
} }
} }
} }
@ -6703,7 +6714,7 @@ int set_num_bursts(int file_des) {
setNumBursts(arg); setNumBursts(arg);
int64_t retval = getNumBursts(); int64_t retval = getNumBursts();
LOG(logDEBUG1, ("retval num bursts %lld\n", (long long int)retval)); LOG(logDEBUG1, ("retval num bursts %lld\n", (long long int)retval));
validate64(arg, retval, "set number of bursts", DEC); validate64(&ret, mess, arg, retval, "set number of bursts", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT64, NULL, 0); return Server_SendResult(file_des, INT64, NULL, 0);
@ -6770,7 +6781,7 @@ int set_current_source(int file_des) {
setCurrentSource(arg); setCurrentSource(arg);
int retval = getCurrentSource(); int retval = getCurrentSource();
LOG(logDEBUG1, ("current source enable retval: %u\n", retval)); LOG(logDEBUG1, ("current source enable retval: %u\n", retval));
validate(arg, retval, "set current source enable", DEC); validate(&ret, mess, arg, retval, "set current source enable", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
@ -7332,7 +7343,7 @@ int set_num_gates(int file_des) {
setNumGates(arg); setNumGates(arg);
int retval = getNumGates(); int retval = getNumGates();
LOG(logDEBUG1, ("retval num gates %d\n", retval)); LOG(logDEBUG1, ("retval num gates %d\n", retval));
validate(arg, retval, "set number of gates", DEC); validate(&ret, mess, arg, retval, "set number of gates", DEC);
} }
#endif #endif
return Server_SendResult(file_des, INT32, NULL, 0); return Server_SendResult(file_des, INT32, NULL, 0);
@ -7530,7 +7541,7 @@ int set_veto(int file_des) {
if (ret == OK) { if (ret == OK) {
int retval = getVeto(); int retval = getVeto();
LOG(logDEBUG1, ("veto mode retval: %u\n", retval)); LOG(logDEBUG1, ("veto mode retval: %u\n", retval));
validate(arg, retval, "set veto mode", DEC); validate(&ret, mess, arg, retval, "set veto mode", DEC);
} }
} }
#endif #endif
@ -7575,7 +7586,8 @@ int set_pattern(int file_des) {
#ifndef MYTHEN3D #ifndef MYTHEN3D
if (ret == OK) { if (ret == OK) {
uint64_t retval64 = writePatternIOControl(pat->ioctrl); uint64_t retval64 = writePatternIOControl(pat->ioctrl);
validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX); validate64(&ret, mess, pat->ioctrl, retval64,
"set pattern IO Control", HEX);
} }
#endif #endif
if (ret == OK) { if (ret == OK) {
@ -7583,9 +7595,9 @@ int set_pattern(int file_des) {
int retval0 = pat->limits[0]; int retval0 = pat->limits[0];
int retval1 = pat->limits[1]; int retval1 = pat->limits[1];
setPatternLoop(-1, &retval0, &retval1, &numLoops); setPatternLoop(-1, &retval0, &retval1, &numLoops);
validate(pat->limits[0], retval0, validate(&ret, mess, pat->limits[0], retval0,
"set pattern Limits start address", HEX); "set pattern Limits start address", HEX);
validate(pat->limits[1], retval1, validate(&ret, mess, pat->limits[1], retval1,
"set pattern Limits start address", HEX); "set pattern Limits start address", HEX);
} }
if (ret == OK) { if (ret == OK) {
@ -7601,19 +7613,19 @@ int set_pattern(int file_des) {
setPatternLoop(i, &retval0, &retval1, &numLoops); setPatternLoop(i, &retval0, &retval1, &numLoops);
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d start address", i); sprintf(msg, "set pattern Loop %d start address", i);
validate(pat->loop[i * 2 + 0], retval0, msg, HEX); validate(&ret, mess, pat->loop[i * 2 + 0], retval0, msg, HEX);
if (ret == FAIL) { if (ret == FAIL) {
break; break;
} }
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d stop address", i); sprintf(msg, "set pattern Loop %d stop address", i);
validate(pat->loop[i * 2 + 1], retval1, msg, HEX); validate(&ret, mess, pat->loop[i * 2 + 1], retval1, msg, HEX);
if (ret == FAIL) { if (ret == FAIL) {
break; break;
} }
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d num loops", i); sprintf(msg, "set pattern Loop %d num loops", i);
validate(pat->nloop[i], numLoops, msg, HEX); validate(&ret, mess, pat->nloop[i], numLoops, msg, HEX);
if (ret == FAIL) { if (ret == FAIL) {
break; break;
} }
@ -7622,7 +7634,7 @@ int set_pattern(int file_des) {
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait address", i); sprintf(msg, "set pattern Loop %d wait address", i);
retval0 = setPatternWaitAddress(i, pat->wait[i]); retval0 = setPatternWaitAddress(i, pat->wait[i]);
validate(pat->wait[i], retval0, msg, HEX); validate(&ret, mess, pat->wait[i], retval0, msg, HEX);
if (ret == FAIL) { if (ret == FAIL) {
break; break;
} }
@ -7631,7 +7643,7 @@ int set_pattern(int file_des) {
memset(msg, 0, sizeof(msg)); memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait time", i); sprintf(msg, "set pattern Loop %d wait time", i);
retval64 = setPatternWaitTime(i, pat->waittime[i]); retval64 = setPatternWaitTime(i, pat->waittime[i]);
validate64(pat->waittime[i], retval64, msg, HEX); validate64(&ret, mess, pat->waittime[i], retval64, msg, HEX);
if (ret == FAIL) { if (ret == FAIL) {
break; break;
} }
@ -7820,7 +7832,7 @@ int set_scan(int file_des) {
setNumFrames(arg); setNumFrames(arg);
retval = getNumFrames(); retval = getNumFrames();
LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval)); LOG(logDEBUG1, ("retval num frames %lld\n", (long long int)retval));
validate64(arg, retval, "set number of frames", DEC); validate64(&ret, mess, arg, retval, "set number of frames", DEC);
} }
// enable scan // enable scan
else { else {
@ -7870,7 +7882,8 @@ int set_scan(int file_des) {
retval = getNumFrames(); retval = getNumFrames();
LOG(logDEBUG1, LOG(logDEBUG1,
("retval num frames %lld\n", (long long int)retval)); ("retval num frames %lld\n", (long long int)retval));
validate64(arg, retval, "set number of frames", DEC); validate64(&ret, mess, arg, retval, "set number of frames",
DEC);
retval = numScanSteps; retval = numScanSteps;
} }
} }
@ -7935,7 +7948,7 @@ int set_cds_gain(int file_des) {
setCDSGain(arg); setCDSGain(arg);
int retval = getCDSGain(); int retval = getCDSGain();
LOG(logDEBUG1, ("cds gain enable retval: %u\n", retval)); LOG(logDEBUG1, ("cds gain enable retval: %u\n", retval));
validate(arg, retval, "set cds gain enable", DEC); validate(&ret, mess, arg, retval, "set cds gain enable", DEC);
} }
} }
#endif #endif
@ -7984,7 +7997,7 @@ int set_filter(int file_des) {
setFilter(arg); setFilter(arg);
int retval = getFilter(); int retval = getFilter();
LOG(logDEBUG1, ("filter retval: %u\n", retval)); LOG(logDEBUG1, ("filter retval: %u\n", retval));
validate(arg, retval, "set filter", DEC); validate(&ret, mess, arg, retval, "set filter", DEC);
} }
} }
#endif #endif
@ -8087,7 +8100,7 @@ int set_adc_config(int file_des) {
} else { } else {
int retval = getADCConfiguration(chipIndex, adcIndex); int retval = getADCConfiguration(chipIndex, adcIndex);
LOG(logDEBUG1, ("adc config retval: %u\n", retval)); LOG(logDEBUG1, ("adc config retval: %u\n", retval));
validate(value, retval, "configure adc", HEX); validate(&ret, mess, value, retval, "configure adc", HEX);
} }
} }
} }