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

Merge pull request #254 from slsdetectorgroup/patternrefactor

Browse Source 
RefactorPatternRedundancy
This commit is contained in:
Dhanya Thattil 2021-06-21 16:29:25 +02:00 committed by GitHub
commit 1a88cbd266
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 1500 additions and 2145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
slsDetectorServers/ctbDetectorServer/CMakeLists.txt
View File

@ -17,6 +17,7 @@ add_executable(ctbDetectorServer_virtual
../slsDetectorServer/src/MAX1932.c
../slsDetectorServer/src/programFpgaBlackfin.c
../slsDetectorServer/src/sharedMemory.c
../slsDetectorServer/src/loadPattern.c
)
include_directories(

2
slsDetectorServers/ctbDetectorServer/Makefile
View File

@ -13,7 +13,7 @@ DESTDIR ?= bin
INSTMODE = 0777
SRCS = slsDetectorFunctionList.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD7689.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)I2C.c $(main_src)INA226.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)/sharedMemory.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD7689.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)I2C.c $(main_src)INA226.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c
OBJS = $(SRCS:.c=.o)

BIN
slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
View File

Binary file not shown.

289
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -11,6 +11,7 @@
#include "UDPPacketHeaderGenerator.h"
#include "common.h"
#include "communication_funcs_UDP.h"
#include "loadPattern.h"
#include <netinet/in.h>
#include <string.h>
@ -42,7 +43,6 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif
@ -478,7 +478,7 @@ void setupDetector() {
ndSamples = 1;
#ifdef VIRTUAL
sharedMemory_setStatus(IDLE);
memset(virtual_pattern, 0, sizeof(virtual_pattern));
initializePatternWord();
#endif
ALTERA_PLL_ResetPLLAndReconfiguration();
@ -969,7 +969,7 @@ int setExpTime(int64_t val) {
}
int64_t getExpTime() {
return setPatternWaitTime(0, -1) / (1E-3 * clkFrequency[RUN_CLK]);
return getPatternWaitTime(0) / (1E-3 * clkFrequency[RUN_CLK]);
}
int setPeriod(int64_t val) {
@ -1880,273 +1880,6 @@ int getPipeline(enum CLKINDEX ind) {
ADC_OFFSET_ADC_PPLN_OFST);
}
// patterns
uint64_t writePatternIOControl(uint64_t word) {
if ((int64_t)word != -1) {
LOG(logINFO,
("Setting Pattern I/O Control: 0x%llx\n", (long long int)word));
set64BitReg(word, PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
uint64_t retval =
get64BitReg(PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
LOG(logDEBUG1, (" I/O Control retval: 0x%llx\n", (long long int)retval));
return retval;
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logINFORED, (" Reading (Executing) Pattern Word (addr:0x%x)\n", addr));
uint32_t reg = PATTERN_CNTRL_REG;
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set read strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_RD_MSK);
// unset read strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_RD_MSK));
usleep(WAIT_TIME_PATTERN_READ);
// read value
uint64_t retval = get64BitReg(PATTERN_OUT_LSB_REG, PATTERN_OUT_MSB_REG);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
#ifdef VIRTUAL
retval = virtual_pattern[addr];
#endif
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
uint32_t reg = PATTERN_CNTRL_REG;
// write word
set64BitReg(word, PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG)));
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set write strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_WR_MSK);
// unset write strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_WR_MSK));
#ifdef VIRTUAL
virtual_pattern[addr] = word;
#endif
return word;
// return readPatternWord(addr); // will start executing the pattern
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(logINFO, ("Setting Pattern Wait Address (level:%d, addr:0x%x)\n",
level, addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(logINFO, ("Setting Pattern Wait Time (level:%d, t:%lld)\n", level,
(long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(logINFO,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(logINFO,
("Setting Pattern Loop (level:%d, startaddr:0x%x, stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
LOG(logDEBUG1, ("Addr:0x%x, val:0x%x\n", addr, bus_r(addr)));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
int setLEDEnable(int enable) {
uint32_t addr = CONFIG_REG;
@ -2189,22 +1922,6 @@ void setDigitalIODelay(uint64_t pinMask, int delay) {
bus_w(addr, bus_r(addr) & (~OUTPUT_DELAY_0_OTPT_TRGGR_MSK));
}
void setPatternMask(uint64_t mask) {
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
/* aquisition */
int startStateMachine() {

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
View File

Binary file not shown.

2
slsDetectorServers/moenchDetectorServer/CMakeLists.txt
View File

@ -13,7 +13,7 @@ add_executable(moenchDetectorServer_virtual
../slsDetectorServer/src/LTC2620.c
../slsDetectorServer/src/MAX1932.c
../slsDetectorServer/src/programFpgaBlackfin.c
../slsDetectorServer/src/readDefaultPattern.c
../slsDetectorServer/src/loadPattern.c
../slsDetectorServer/src/sharedMemory.c
)

2
slsDetectorServers/moenchDetectorServer/Makefile
View File

@ -13,7 +13,7 @@ DESTDIR ?= bin
INSTMODE = 0777
SRCS = slsDetectorFunctionList.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)blackfin.c $(main_src)common.c $(main_src)commonServerFunctions.c $(main_src)communication_funcs_UDP.c $(main_src)UDPPacketHeaderGenerator.c $(main_src)AD9257.c $(main_src)ALTERA_PLL.c $(main_src)LTC2620.c $(main_src)MAX1932.c $(main_src)programFpgaBlackfin.c $(main_src)loadPattern.c $(main_src)/sharedMemory.c
OBJS = $(SRCS:.c=.o)

BIN
slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
View File

Binary file not shown.

292
slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
View File

@ -9,6 +9,7 @@
#include "UDPPacketHeaderGenerator.h"
#include "common.h"
#include "communication_funcs_UDP.h"
#include "loadPattern.h"
#include <netinet/in.h>
#include <string.h>
@ -40,7 +41,6 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
uint64_t virtual_pattern[MAX_PATTERN_LENGTH];
int64_t virtual_currentFrameNumber = 2;
#endif
@ -484,7 +484,7 @@ void setupDetector() {
nSamples = 1;
#ifdef VIRTUAL
sharedMemory_setStatus(IDLE);
memset(virtual_pattern, 0, sizeof(virtual_pattern));
initializePatternWord();
#endif
ALTERA_PLL_ResetPLLAndReconfiguration();
@ -551,7 +551,7 @@ void setupDetector() {
}
setPipeline(ADC_CLK, DEFAULT_PIPELINE);
if (initError != FAIL) {
initError = loadDefaultPattern(DEFAULT_PATTERN_FILE, initErrorMessage);
initError = loadPatternFile(DEFAULT_PATTERN_FILE, initErrorMessage);
}
setSettings(DEFAULT_SETTINGS);
@ -818,7 +818,7 @@ int setExpTime(int64_t val) {
}
int64_t getExpTime() {
return setPatternWaitTime(0, -1) / (1E-3 * clkFrequency[RUN_CLK]);
return getPatternWaitTime(0) / (1E-3 * clkFrequency[RUN_CLK]);
}
int setPeriod(int64_t val) {
@ -1559,290 +1559,6 @@ int getPipeline(enum CLKINDEX ind) {
ADC_OFFSET_ADC_PPLN_OFST);
}
// patterns
uint64_t writePatternIOControl(uint64_t word) {
if ((int64_t)word != -1) {
LOG(logINFO,
("Setting Pattern I/O Control: 0x%llx\n", (long long int)word));
set64BitReg(word, PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
}
uint64_t retval =
get64BitReg(PATTERN_IO_CNTRL_LSB_REG, PATTERN_IO_CNTRL_MSB_REG);
LOG(logDEBUG1, (" I/O Control retval: 0x%llx\n", (long long int)retval));
return retval;
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logINFORED, (" Reading (Executing) Pattern Word (addr:0x%x)\n", addr));
uint32_t reg = PATTERN_CNTRL_REG;
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set read strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_RD_MSK);
// unset read strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_RD_MSK));
usleep(WAIT_TIME_PATTERN_READ);
// read value
uint64_t retval = get64BitReg(PATTERN_OUT_LSB_REG, PATTERN_OUT_MSB_REG);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
#ifdef VIRTUAL
retval = virtual_pattern[addr];
#endif
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
uint32_t reg = PATTERN_CNTRL_REG;
// write word
set64BitReg(word, PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(PATTERN_IN_LSB_REG, PATTERN_IN_MSB_REG)));
// overwrite with only addr
bus_w(reg, ((addr << PATTERN_CNTRL_ADDR_OFST) & PATTERN_CNTRL_ADDR_MSK));
// set write strobe
bus_w(reg, bus_r(reg) | PATTERN_CNTRL_WR_MSK);
// unset write strobe
bus_w(reg, bus_r(reg) & (~PATTERN_CNTRL_WR_MSK));
#ifdef VIRTUAL
virtual_pattern[addr] = word;
#endif
return word;
// return readPatternWord(addr); // will start executing the pattern
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(logINFO, ("Setting Pattern Wait Address (level:%d, addr:0x%x)\n",
level, addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(logINFO, ("Setting Pattern Wait Time (level:%d, t:%lld)\n", level,
(long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(logINFO,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(logINFO,
("Setting Pattern Loop (level:%d, startaddr:0x%x, stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
LOG(logDEBUG1, ("Addr:0x%x, val:0x%x\n", addr, bus_r(addr)));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
void setPatternMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
LOG(logINFO, ("Setting pattern bit mask to 0x%llx\n", mask));
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
/* aquisition */
int startStateMachine() {

3
slsDetectorServers/mythen3DetectorServer/CMakeLists.txt
View File

@ -11,8 +11,7 @@ add_executable(mythen3DetectorServer_virtual
../slsDetectorServer/src/LTC2620_Driver.c
../slsDetectorServer/src/ALTERA_PLL_CYCLONE10.c
../slsDetectorServer/src/programFpgaNios.c
../slsDetectorServer/src/readDefaultPattern.c
../slsDetectorServer/src/loadPattern.c
../slsDetectorServer/src/loadPattern.c
../slsDetectorServer/src/sharedMemory.c
)

2
slsDetectorServers/mythen3DetectorServer/Makefile
View File

@ -13,7 +13,7 @@ DESTDIR ?= bin
INSTMODE = 0777
SRCS = slsDetectorFunctionList.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c mythen3.c
SRCS += $(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c mythen3.c
OBJS = $(SRCS:.c=.o)

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

594
slsDetectorServers/mythen3DetectorServer/mythen3.c
View File

@ -1,7 +1,7 @@
#include "mythen3.h"
#include "clogger.h"
#include "common.h"
#include "mythen3.h"
#include "sls/ansi.h"
#include "sls/sls_detector_defs.h"
#include "slsDetectorServer_defs.h"
@ -22,353 +22,343 @@ typedef struct __attribute__((packed)) {
} patternParameters;
*/
int chipStatusRegister=0;
int chipStatusRegister = 0;
int setBit(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 chipStatusRegister;
return csr;
}
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 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 csr;
}
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;
return caps;
}
patternParameters *setChipStatusRegisterPattern(int csr) {
int iaddr=0;
int nbits=18;
int error=0;
//int start=0, stop=MAX_PATTERN_LENGTH, loop=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;
}
int iaddr = 0;
int nbits = 18;
int error = 0;
// int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
int patword = 0;
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;
patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters));
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;
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);
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) {
int csr;
if (mask)
csr=chipStatusRegister|(1<< CSR_interp);
else
csr=chipStatusRegister & ~(1<< CSR_interp);
int csr;
if (mask)
csr = chipStatusRegister | (1 << CSR_interp);
else
csr = chipStatusRegister & ~(1 << CSR_interp);
return setChipStatusRegisterPattern(csr);
return setChipStatusRegisterPattern(csr);
}
patternParameters *setPumpProbe(int mask) {
int csr;
if (mask)
csr=chipStatusRegister|(1<< CSR_pumprobe);
else
csr=chipStatusRegister & ~(1<< CSR_pumprobe);
return setChipStatusRegisterPattern(csr);
int csr;
if (mask)
csr = chipStatusRegister | (1 << CSR_pumprobe);
else
csr = chipStatusRegister & ~(1 << CSR_pumprobe);
return setChipStatusRegisterPattern(csr);
}
patternParameters *setDigitalPulsing(int mask) {
int csr;
if (mask)
csr=chipStatusRegister|(1<< CSR_dpulse);
else
csr=chipStatusRegister & ~(1<< CSR_dpulse);
int csr;
if (mask)
csr = chipStatusRegister | (1 << CSR_dpulse);
else
csr = chipStatusRegister & ~(1 << CSR_dpulse);
return setChipStatusRegisterPattern(csr);
return setChipStatusRegisterPattern(csr);
}
patternParameters *setAnalogPulsing(int mask){
patternParameters *setAnalogPulsing(int mask) {
int csr;
if (mask)
csr=chipStatusRegister|(1<< CSR_apulse);
else
csr=chipStatusRegister & ~(1<< CSR_apulse);
int csr;
if (mask)
csr = chipStatusRegister | (1 << CSR_apulse);
else
csr = chipStatusRegister & ~(1 << CSR_apulse);
return setChipStatusRegisterPattern(csr);
return setChipStatusRegisterPattern(csr);
}
patternParameters *setNegativePolarity(int mask){
patternParameters *setNegativePolarity(int mask) {
int csr;
if (mask)
csr=chipStatusRegister|(1<< CSR_invpol);
else
csr=chipStatusRegister & ~(1<< CSR_invpol);
int csr;
if (mask)
csr = chipStatusRegister | (1 << CSR_invpol);
else
csr = chipStatusRegister & ~(1 << CSR_invpol);
return setChipStatusRegisterPattern(csr);
return setChipStatusRegisterPattern(csr);
}
patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {
patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters));
patternParameters *pat = malloc(sizeof(patternParameters));
memset(pat, 0, sizeof(patternParameters));
// validate
for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS; ichan < ichip * NCHAN_1_COUNTER * NCOUNTERS+NCHAN_1_COUNTER*NCOUNTERS; ichan++) {
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;
for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS;
ichan <
ichip * NCHAN_1_COUNTER * NCOUNTERS + NCHAN_1_COUNTER * NCOUNTERS;
ichan++) {
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(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;
LOG(logINFO, ("Trimbits validated\n"));
// trimming
int error = 0;
uint64_t patword = 0;
int iaddr = 0;
LOG(logDEBUG1, (" Chip %d\n", ichip));
iaddr = 0;
patword = 0;
pat->word[iaddr++]=patword;
// chip select
patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
pat->word[iaddr++]=patword;
// reset trimbits
patword = setBit(SIGNAL_resStorage, patword);
patword = setBit(SIGNAL_resCounter, patword);
pat->word[iaddr++]=patword;
pat->word[iaddr++]=patword;
patword = clearBit(SIGNAL_resStorage, patword);
patword = clearBit(SIGNAL_resCounter, patword);
pat->word[iaddr++]=patword;
pat->word[iaddr++]=patword;
// select first channel
patword = setBit(SIGNAL_CHSserialIN, patword);
pat->word[iaddr++]=patword;
// 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++) {
// trimming
int error = 0;
uint64_t patword = 0;
int iaddr = 0;
LOG(logDEBUG1, (" Chip %d\n", ichip));
iaddr = 0;
patword = 0;
pat->word[iaddr++] = patword;
// chip select
patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
pat->word[iaddr++] = patword;
// reset trimbits
patword = setBit(SIGNAL_resStorage, patword);
patword = setBit(SIGNAL_resCounter, patword);
pat->word[iaddr++] = patword;
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_resStorage, patword);
patword = clearBit(SIGNAL_resCounter, patword);
pat->word[iaddr++] = patword;
pat->word[iaddr++] = patword;
// select first channel
patword = setBit(SIGNAL_CHSserialIN, patword);
pat->word[iaddr++] = patword;
// 1 clk pulse
patword = setBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword;
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_CHSclk, patword);
pat->word[iaddr++]=patword;
}
// for each channel (all chips)
for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
NCOUNTERS * ich] +
trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
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;
// 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);
pat->word[iaddr++] = patword;
patword = clearBit(SIGNAL_CHSclk, 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;
// for each channel (all chips)
for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
int val =
trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + NCOUNTERS * ich] +
trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS + 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++) {
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;
}
}
// 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;
// chip unselect
patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
pat->word[iaddr++] = patword;
// last iaddr check
if (iaddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", iaddr,
MAX_PATTERN_LENGTH));
error = 1;
}
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;
if (iaddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n", iaddr,
MAX_PATTERN_LENGTH));
error = 1;
}
}
// chip unselect
patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
pat->word[iaddr++]=patword;
// last iaddr check
if (iaddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
iaddr, MAX_PATTERN_LENGTH));
error = 1;
}
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;
}
trimmingPrint = logINFO;
if (error == 0) {
LOG(logINFO, ("All trimbits have been loaded\n"));
} else {
free(pat);
return NULL;
}
return pat;
// 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) {
LOG(logINFO, ("All trimbits have been loaded\n"));
} else {
free(pat);
return NULL;
}
return pat;
}

339
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -1118,48 +1118,50 @@ int setModule(sls_detector_module myMod, char *mess) {
int setTrimbits(int *trimbits) {
LOG(logINFOBLUE, ("Setting trimbits\n"));
// remember previous run clock
uint32_t prevRunClk = clkDivider[SYSTEM_C0];
patternParameters *pat = NULL;
int error = 0;
// set to trimming clock
if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
LOG(logERROR,
("Could not start trimming. Could not set to trimming clock\n"));
return FAIL;
}
/////////////////////////////////////////////////////////////////
for (int ichip = 0; ichip < NCHIP; ichip++) {
pat = setChannelRegisterChip(ichip, channelMask,
trimbits); // change here!!!
if (pat) {
error |= loadPattern(logDEBUG5, pat);
if (error == 0)
// for every chip
int error = 0;
char cmess[MAX_STR_LENGTH];
for (int ichip = 0; ichip < NCHIP; ichip++) {
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();
free(pat);
} else
error = 1;
}
}
/////////////////////////////////////////////////////////////////
// copy trimbits locally
if (error == 0) {
// copy trimbits locally
for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
detectorChans[ichan] = trimbits[ichan];
}
LOG(logINFO, ("All trimbits have been loaded\n"));
}
trimmingPrint = logINFO;
// set back to previous clock
if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
LOG(logERROR, ("Could not set to previous run clock after trimming\n"));
return FAIL;
}
if (error != 0) {
return FAIL;
}
return OK;
return (error ? FAIL : OK);
}
int setAllTrimbits(int val) {
@ -1746,273 +1748,6 @@ int enableTenGigabitEthernet(int val) {
return oneG ? 0 : 1;
}
/* pattern */
void startPattern() {
LOG(logINFOBLUE, ("Starting Pattern\n"));
bus_w(CONTROL_REG, bus_r(CONTROL_REG) | CONTROL_STRT_PATTERN_MSK);
usleep(1);
while (bus_r(PAT_STATUS_REG) & PAT_STATUS_RUN_BUSY_MSK) {
usleep(1);
}
LOG(logINFOBLUE, ("Pattern done\n"));
}
uint64_t readPatternWord(int addr) {
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot get Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, (" Reading Pattern Word (addr:0x%x)\n", addr));
uint32_t reg_lsb =
PATTERN_STEP0_LSB_REG +
addr * REG_OFFSET * 2; // the first word in RAM as base plus the
// offset of the word to write (addr)
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
// read value
uint64_t retval = get64BitReg(reg_lsb, reg_msb);
LOG(logDEBUG1,
(" Word(addr:0x%x) retval: 0x%llx\n", addr, (long long int)retval));
return retval;
}
uint64_t writePatternWord(int addr, uint64_t word) {
// get
if ((int64_t)word == -1)
return readPatternWord(addr);
// error (handled in tcp)
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern - Word. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
LOG(logDEBUG1, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n", addr,
(long long int)word));
// write word
uint32_t reg_lsb =
PATTERN_STEP0_LSB_REG +
addr * REG_OFFSET * 2; // the first word in RAM as base plus the
// offset of the word to write (addr)
uint32_t reg_msb = PATTERN_STEP0_MSB_REG + addr * REG_OFFSET * 2;
set64BitReg(word, reg_lsb, reg_msb);
LOG(logDEBUG1, (" Wrote word. PatternIn Reg: 0x%llx\n",
get64BitReg(reg_lsb, reg_msb)));
return readPatternWord(addr);
}
int setPatternWaitAddress(int level, int addr) {
// error (handled in tcp)
if (addr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid addr 0x%x. "
"Should be between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH));
return -1;
}
uint32_t reg = 0;
uint32_t offset = 0;
uint32_t mask = 0;
switch (level) {
case 0:
reg = PATTERN_WAIT_0_ADDR_REG;
offset = PATTERN_WAIT_0_ADDR_OFST;
mask = PATTERN_WAIT_0_ADDR_MSK;
break;
case 1:
reg = PATTERN_WAIT_1_ADDR_REG;
offset = PATTERN_WAIT_1_ADDR_OFST;
mask = PATTERN_WAIT_1_ADDR_MSK;
break;
case 2:
reg = PATTERN_WAIT_2_ADDR_REG;
offset = PATTERN_WAIT_2_ADDR_OFST;
mask = PATTERN_WAIT_2_ADDR_MSK;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Address. Invalid level 0x%x. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if (addr >= 0) {
LOG(trimmingPrint,
("Setting Pattern Wait Address (level:%d, addr:0x%x)\n", level,
addr));
bus_w(reg, ((addr << offset) & mask));
}
// get
uint32_t regval = ((bus_r(reg) & mask) >> offset);
LOG(logDEBUG1,
(" Wait Address retval (level:%d, addr:0x%x)\n", level, regval));
return regval;
}
uint64_t setPatternWaitTime(int level, uint64_t t) {
uint32_t regl = 0;
uint32_t regm = 0;
switch (level) {
case 0:
regl = PATTERN_WAIT_TIMER_0_LSB_REG;
regm = PATTERN_WAIT_TIMER_0_MSB_REG;
break;
case 1:
regl = PATTERN_WAIT_TIMER_1_LSB_REG;
regm = PATTERN_WAIT_TIMER_1_MSB_REG;
break;
case 2:
regl = PATTERN_WAIT_TIMER_2_LSB_REG;
regm = PATTERN_WAIT_TIMER_2_MSB_REG;
break;
default:
LOG(logERROR, ("Cannot set Pattern Wait Time. Invalid level %d. "
"Should be between 0 and 2.\n",
level));
return -1;
}
// set
if ((int64_t)t >= 0) {
LOG(trimmingPrint, ("Setting Pattern Wait Time (level:%d, t:%lld)\n",
level, (long long int)t));
set64BitReg(t, regl, regm);
}
// get
uint64_t regval = get64BitReg(regl, regm);
LOG(logDEBUG1, (" Wait Time retval (level:%d, t:%lld)\n", level,
(long long int)regval));
return regval;
}
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop) {
// (checked at tcp)
if (*startAddr >= MAX_PATTERN_LENGTH || *stopAddr >= MAX_PATTERN_LENGTH) {
LOG(logERROR, ("Cannot set Pattern Loop, Address (startaddr:0x%x, "
"stopaddr:0x%x) must be "
"less than 0x%x\n",
*startAddr, *stopAddr, MAX_PATTERN_LENGTH));
*startAddr = -1;
*stopAddr = -1;
*nLoop = -1;
return;
}
uint32_t addr = 0;
uint32_t nLoopReg = 0;
uint32_t startOffset = 0;
uint32_t startMask = 0;
uint32_t stopOffset = 0;
uint32_t stopMask = 0;
switch (level) {
case 0:
addr = PATTERN_LOOP_0_ADDR_REG;
nLoopReg = PATTERN_LOOP_0_ITERATION_REG;
startOffset = PATTERN_LOOP_0_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_0_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_0_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_0_ADDR_STP_MSK;
break;
case 1:
addr = PATTERN_LOOP_1_ADDR_REG;
nLoopReg = PATTERN_LOOP_1_ITERATION_REG;
startOffset = PATTERN_LOOP_1_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_1_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_1_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_1_ADDR_STP_MSK;
break;
case 2:
addr = PATTERN_LOOP_2_ADDR_REG;
nLoopReg = PATTERN_LOOP_2_ITERATION_REG;
startOffset = PATTERN_LOOP_2_ADDR_STRT_OFST;
startMask = PATTERN_LOOP_2_ADDR_STRT_MSK;
stopOffset = PATTERN_LOOP_2_ADDR_STP_OFST;
stopMask = PATTERN_LOOP_2_ADDR_STP_MSK;
break;
case -1:
// complete pattern
addr = PATTERN_LIMIT_REG;
nLoopReg = -1;
startOffset = PATTERN_LIMIT_STRT_OFST;
startMask = PATTERN_LIMIT_STRT_MSK;
stopOffset = PATTERN_LIMIT_STP_OFST;
stopMask = PATTERN_LIMIT_STP_MSK;
break;
default:
// already checked at tcp interface
LOG(logERROR, ("Cannot set Pattern loop. Invalid level %d. "
"Should be between -1 and 2.\n",
level));
*startAddr = 0;
*stopAddr = 0;
*nLoop = 0;
}
// set iterations
if (level >= 0) {
// set iteration
if (*nLoop >= 0) {
LOG(trimmingPrint,
("Setting Pattern Loop (level:%d, nLoop:%d)\n", level, *nLoop));
bus_w(nLoopReg, *nLoop);
}
*nLoop = bus_r(nLoopReg);
}
// set
if (*startAddr >= 0 && *stopAddr >= 0) {
// writing start and stop addr
LOG(trimmingPrint, ("Setting Pattern Loop (level:%d, startaddr:0x%x, "
"stopaddr:0x%x)\n",
level, *startAddr, *stopAddr));
bus_w(addr, ((*startAddr << startOffset) & startMask) |
((*stopAddr << stopOffset) & stopMask));
}
*startAddr = ((bus_r(addr) & startMask) >> startOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Start Address (level:%d, Read "
"startAddr:0x%x)\n",
level, *startAddr));
*stopAddr = ((bus_r(addr) & stopMask) >> stopOffset);
LOG(logDEBUG1, ("Getting Pattern Loop Stop Address (level:%d, Read "
"stopAddr:0x%x)\n",
level, *stopAddr));
}
void setPatternMask(uint64_t mask) {
set64BitReg(mask, PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
uint64_t getPatternMask() {
return get64BitReg(PATTERN_MASK_LSB_REG, PATTERN_MASK_MSB_REG);
}
void setPatternBitMask(uint64_t mask) {
set64BitReg(mask, PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
uint64_t getPatternBitMask() {
return get64BitReg(PATTERN_SET_LSB_REG, PATTERN_SET_MSB_REG);
}
int checkDetectorType() {
#ifdef VIRTUAL
return OK;
@ -2652,36 +2387,40 @@ int getNumberOfDACs() { return NDAC; }
int getNumberOfChannelsPerChip() { return NCHAN; }
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) {
LOG(logERROR,
("Could not set to trimming clock in order to change CSR\n"));
return FAIL;
}
pat = setChipStatusRegisterPattern(csr);
if (pat) {
error |= loadPattern(logDEBUG5, pat);
if (!error)
startPattern();
free(pat);
int iret = OK;
char cmess[MAX_STR_LENGTH];
patternParameters *pat = setChipStatusRegisterPattern(csr);
if (pat == NULL) {
iret = FAIL;
} else {
error = 1;
}
if (!error) {
LOG(logINFO, ("CSR is now: 0x%x\n", csr));
memset(cmess, 0, MAX_STR_LENGTH);
iret = loadPattern(cmess, logDEBUG5, pat);
if (iret == OK) {
startPattern();
LOG(logINFO, ("CSR is now: 0x%x\n", csr));
}
free(pat);
}
// set back to previous clock
if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
LOG(logERROR,
("Could not set to previous run clock after changing CSR\n"));
return FAIL;
}
return OK;
return iret;
}
int setGainCaps(int caps) {

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

@ -1,8 +1,11 @@
#pragma once
#include <stdint.h> // int64_t
#include <stdio.h>
#include <time.h>
enum numberMode { DEC, HEX };
/**
* Convert a value from a range to a different range (eg voltage to dac or vice
* versa)
@ -19,4 +22,9 @@ int ConvertToDifferentRange(int inputMin, int inputMax, int outputMin,
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 *ret, char *mess, int arg, int retval, char *modename,
enum numberMode nummode);
void validate64(int *ret, char *mess, int64_t arg, int64_t retval,
char *modename, enum numberMode nummode);

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

@ -3,5 +3,57 @@
#include "Pattern.h"
#include "clogger.h"
int loadPattern(enum TLogLevel printLevel, patternParameters *pat);
#if defined(CHIPTESTBOARDD) || defined(MOENCHD)
#ifdef VIRTUAL
void initializePatternWord();
#endif
uint64_t validate_readPatternIOControl();
int validate_writePatternIOControl(char *message, uint64_t arg);
void writePatternIOControl(uint64_t word);
#endif
int validate_readPatternWord(char *message, int addr, uint64_t *word);
uint64_t readPatternWord(int addr);
int validate_writePatternWord(char *message, int addr, uint64_t word);
void writePatternWord(int addr, uint64_t word);
int validate_getPatternWaitAddresses(char *message, int level, int *addr);
int getPatternWaitAddress(int level);
int validate_setPatternWaitAddresses(char *message, int level, int addr);
void setPatternWaitAddress(int level, int addr);
int validate_getPatternWaitTime(char *message, int level, uint64_t *waittime);
uint64_t getPatternWaitTime(int level);
int validate_setPatternWaitTime(char *message, int level, uint64_t waittime);
void setPatternWaitTime(int level, uint64_t t);
int validate_getPatternLoopCycles(char *message, int level, int *numLoops);
int getPatternLoopCycles(int level);
int validate_setPatternLoopCycles(char *message, int level, int numLoops);
void setPatternLoopCycles(int level, int nLoop);
void validate_getPatternLoopLimits(int *startAddr, int *stopAddr);
int validate_setPatternLoopLimits(char *message, int startAddr, int stopAddr);
void setPatternLoopLimits(int startAddr, int stopAddr);
int validate_getPatternLoopAddresses(char *message, int level, int *startAddr,
int *stopAddr);
void getPatternLoopAddresses(int level, int *startAddr, int *stopAddr);
int validate_setPatternLoopAddresses(char *message, int level, int startAddr,
int stopAddr);
void setPatternLoopAddresses(int level, int startAddr, int stopAddr);
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
#ifdef MYTHEN3D
void startPattern();
#endif
int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat);
int getPattern(char *mess, patternParameters *pat);
int loadPatternFile(char *patFname, char *errMessage);
#endif

24
slsDetectorServers/slsDetectorServer/include/readDefaultPattern.h
View File

@ -1,24 +0,0 @@
#pragma once
#include <inttypes.h>
#include <sys/types.h>
int loadDefaultPattern(char *patFname, char *errMessage);
int default_writePatternWord(char *line, uint32_t addr, uint64_t word);
#ifndef MYTHEN3D
int default_writePatternIOControl(char *line, uint64_t arg);
#endif
int default_setPatternLoopLimits(char *line, uint32_t startAddr,
uint32_t stopAddr);
int default_setPatternLoopAddresses(char *line, int level, uint32_t startAddr,
uint32_t stopAddr);
int default_setPatternLoopCycles(char *line, int level, int numLoops);
int default_setPatternWaitAddresses(char *line, int level, uint32_t addr);
int default_setPatternWaitTime(char *line, int level, uint64_t waittime);

27
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -8,9 +8,6 @@
defined(MOENCHD)
#include "AD9257.h" // commonServerFunctions.h, blackfin.h, ansi.h
#endif
#if defined(MOENCHD) || defined(MYTHEN3D)
#include "readDefaultPattern.h"
#endif
#if defined(MYTHEN3D) || defined(GOTTHARD2D)
#include "programFpgaNios.h"
@ -428,22 +425,12 @@ int getFrequency(enum CLKINDEX ind);
void configureSyncFrequency(enum CLKINDEX ind);
void setPipeline(enum CLKINDEX ind, int val);
int getPipeline(enum CLKINDEX ind);
// patterns
uint64_t writePatternIOControl(uint64_t word);
uint64_t readPatternWord(int addr);
uint64_t writePatternWord(int addr, uint64_t word);
int setPatternWaitAddress(int level, int addr);
uint64_t setPatternWaitTime(int level, uint64_t t);
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);
#endif
#ifdef CHIPTESTBOARDD
int setLEDEnable(int enable);
void setDigitalIODelay(uint64_t pinMask, int delay);
#endif
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
#endif
// jungfrau specific - powerchip, autocompdisable, clockdiv, asictimer, clock,
// pll, flashing firmware
@ -491,16 +478,6 @@ int getActivate(int *retval);
int setPhase(enum CLKINDEX ind, int val, int degrees);
#elif MYTHEN3D
void startPattern();
uint64_t readPatternWord(int addr);
uint64_t writePatternWord(int addr, uint64_t word);
int setPatternWaitAddress(int level, int addr);
uint64_t setPatternWaitTime(int level, uint64_t t);
void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);
void setPatternMask(uint64_t mask);
uint64_t getPatternMask();
void setPatternBitMask(uint64_t mask);
uint64_t getPatternBitMask();
int checkDetectorType();
int powerChip(int on);
int setPhase(enum CLKINDEX ind, int val, int degrees);

5
slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h
View File

@ -1,8 +1,8 @@
#pragma once
#include "clogger.h"
#include "common.h"
#include "sls/sls_detector_defs.h"
enum numberMode { DEC, HEX };
#define GOODBYE (-200)
#define REBOOT (-400)
@ -14,9 +14,6 @@ const char *getRetName();
void function_table();
void functionNotImplemented();
void modeNotImplemented(char *modename, int mode);
void validate(int arg, int retval, char *modename, enum numberMode nummode);
void validate64(int64_t arg, int64_t retval, char *modename,
enum numberMode nummode);
int executeCommand(char *command, char *result, enum TLogLevel level);
int M_nofunc(int);
#if defined(MYTHEN3D) || defined(GOTTHARD2D)

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

@ -7,6 +7,9 @@
#include <string.h>
#include <unistd.h> // readlink
extern int ret;
extern char mess[MAX_STR_LENGTH];
int ConvertToDifferentRange(int inputMin, int inputMax, int outputMin,
int outputMax, int inputValue, int *outputValue) {
LOG(logDEBUG1, (" Input Value: %d (Input:(%d - %d), Output:(%d - %d))\n",
@ -69,4 +72,34 @@ int GetTimeFromString(char *buf, time_t *result) {
}
*result = mktime(&t);
return OK;
}
void validate(int *ret, char *mess, int arg, int retval, char *modename,
enum numberMode nummode) {
if (*ret == OK && arg != GET_FLAG && 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);
LOG(logERROR, (mess));
}
}
void validate64(int *ret, char *mess, int64_t arg, int64_t retval,
char *modename, enum numberMode nummode) {
if (*ret == OK && arg != GET_FLAG && 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);
LOG(logERROR, (mess));
}
}

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

File diff suppressed because it is too large Load Diff

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

@ -1,478 +0,0 @@
#include "readDefaultPattern.h"
#include "loadPattern.h"
#include "clogger.h"
#include "common.h"
#include "sls/ansi.h"
#include "sls/sls_detector_defs.h"
#include "slsDetectorServer_defs.h"
#include <string.h>
extern char initErrorMessage[MAX_STR_LENGTH];
#ifndef MYTHEN3D
extern uint64_t writePatternIOControl(uint64_t word);
#endif
extern uint64_t writePatternWord(int addr, uint64_t word);
extern int setPatternWaitAddress(int level, int addr);
extern uint64_t setPatternWaitTime(int level, uint64_t t);
extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
int *nLoop);
int loadDefaultPattern(char *patFname, char *errMessage) {
char fname[128];
if (getAbsPath(fname, 128, patFname) == FAIL) {
return FAIL;
}
// open config file
FILE *fd = fopen(fname, "r");
if (fd == NULL) {
sprintf(errMessage, "Could not open pattern file [%s].\n", patFname);
LOG(logERROR, ("%s\n\n", errMessage));
return FAIL;
}
LOG(logINFOBLUE, ("Reading default pattern file %s\n", patFname));
// Initialization
const size_t LZ = 256;
char line[LZ];
memset(line, 0, LZ);
char command[LZ];
// keep reading a line
while (fgets(line, LZ, fd)) {
// ignore comments
if (line[0] == '#') {
LOG(logDEBUG1, ("Ignoring Comment\n"));
continue;
}
// ignore empty lines
if (strlen(line) <= 1) {
LOG(logDEBUG1, ("Ignoring Empty line\n"));
continue;
}
// removing leading spaces
if (line[0] == ' ' || line[0] == '\t') {
int len = strlen(line);
// find first valid character
int i = 0;
for (i = 0; i < len; ++i) {
if (line[i] != ' ' && line[i] != '\t') {
break;
}
}
// ignore the line full of spaces (last char \n)
if (i >= len - 1) {
LOG(logDEBUG1, ("Ignoring line full of spaces\n"));
continue;
}
// copying only valid char
char temp[LZ];
memset(temp, 0, LZ);
memcpy(temp, line + i, strlen(line) - i);
memset(line, 0, LZ);
memcpy(line, temp, strlen(temp));
LOG(logDEBUG1, ("Removing leading spaces.\n"));
}
LOG(logDEBUG1, ("Command to process: (size:%d) %.*s\n", strlen(line),
strlen(line) - 1, line));
memset(command, 0, LZ);
// patword
if (!strncmp(line, "patword", strlen("patword"))) {
uint32_t addr = 0;
uint64_t word = 0;
// cannot scan values
#ifdef VIRTUAL
if (sscanf(line, "%s 0x%x 0x%lx", command, &addr, &word) != 3) {
#else
if (sscanf(line, "%s 0x%x 0x%llx", command, &addr, &word) != 3) {
#endif
sprintf(errMessage,
"Could not scan patword arguments from default "
"pattern file. Line:[%s].\n",
line);
break;
}
if (default_writePatternWord(line, addr, word) == FAIL) {
break;
}
}
// patioctrl
#ifndef MYTHEN3D
if (!strncmp(line, "patioctrl", strlen("patioctrl"))) {
uint64_t arg = 0;
// cannot scan values
#ifdef VIRTUAL
if (sscanf(line, "%s 0x%lx", command, &arg) != 2) {
#else
if (sscanf(line, "%s 0x%llx", command, &arg) != 2) {
#endif
sprintf(errMessage,
"Could not scan patioctrl arguments from default "
"pattern file. Line:[%s].\n",
line);
break;
}
if (default_writePatternIOControl(line, arg) == FAIL) {
break;
}
}
#endif
// patlimits
if (!strncmp(line, "patlimits", strlen("patlimits"))) {
uint32_t startAddr = 0;
uint32_t stopAddr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
3) {
sprintf(errMessage,
"Could not scan patlimits arguments from default "
"pattern file. Line:[%s].\n",
line);
break;
}
if (default_setPatternLoopLimits(line, startAddr, stopAddr) ==
FAIL) {
break;
}
}
// patloop
if ((!strncmp(line, "patloop0", strlen("patloop0"))) ||
(!strncmp(line, "patloop1", strlen("patloop1"))) ||
(!strncmp(line, "patloop2", strlen("patloop2")))) {
// level
int level = -1;
if (!strncmp(line, "patloop0", strlen("patloop0"))) {
level = 0;
} else if (!strncmp(line, "patloop1", strlen("patloop1"))) {
level = 1;
} else {
level = 2;
}
uint32_t startAddr = 0;
uint32_t stopAddr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) !=
3) {
sprintf(errMessage,
"Could not scan patloop%d arguments from default "
"pattern file. Line:[%s].\n",
level, line);
break;
}
if (default_setPatternLoopAddresses(line, level, startAddr,
stopAddr) == FAIL) {
break;
}
}
// patnloop
if ((!strncmp(line, "patnloop0", strlen("patnloop0"))) ||
(!strncmp(line, "patnloop1", strlen("patnloop1"))) ||
(!strncmp(line, "patnloop2", strlen("patnloop2")))) {
// level
int level = -1;
if (!strncmp(line, "patnloop0", strlen("patnloop0"))) {
level = 0;
} else if (!strncmp(line, "patnloop1", strlen("patnloop1"))) {
level = 1;
} else {
level = 2;
}
int numLoops = -1;
// cannot scan values
if (sscanf(line, "%s %d", command, &numLoops) != 2) {
sprintf(errMessage,
"Could not scan patnloop%d arguments from default "
"pattern file. Line:[%s].\n",
level, line);
break;
}
if (default_setPatternLoopCycles(line, level, numLoops) == FAIL) {
break;
}
}
// patwait
if ((!strncmp(line, "patwait0", strlen("patwait0"))) ||
(!strncmp(line, "patwait1", strlen("patwait1"))) ||
(!strncmp(line, "patwait2", strlen("patwait2")))) {
// level
int level = -1;
if (!strncmp(line, "patwait0", strlen("patwait0"))) {
level = 0;
} else if (!strncmp(line, "patwait1", strlen("patwait1"))) {
level = 1;
} else {
level = 2;
}
uint32_t addr = 0;
// cannot scan values
if (sscanf(line, "%s 0x%x", command, &addr) != 2) {
sprintf(errMessage,
"Could not scan patwait%d arguments from default "
"pattern file. Line:[%s].\n",
level, line);
break;
}
if (default_setPatternWaitAddresses(line, level, addr) == FAIL) {
break;
}
}
// patwaittime
if ((!strncmp(line, "patwaittime0", strlen("patwaittime0"))) ||
(!strncmp(line, "patwaittime1", strlen("patwaittime1"))) ||
(!strncmp(line, "patwaittime2", strlen("patwaittime2")))) {
// level
int level = -1;
if (!strncmp(line, "patwaittime0", strlen("patwaittime0"))) {
level = 0;
} else if (!strncmp(line, "patwaittime1", strlen("patwaittime1"))) {
level = 1;
} else {
level = 2;
}
uint64_t waittime = 0;
// cannot scan values
#ifdef VIRTUAL
if (sscanf(line, "%s %ld", command, &waittime) != 2) {
#else
if (sscanf(line, "%s %lld", command, &waittime) != 2) {
#endif
sprintf(errMessage,
"Could not scan patwaittime%d arguments from default "
"pattern file. Line:[%s].\n",
level, line);
break;
}
if (default_setPatternWaitTime(line, level, waittime) == FAIL) {
break;
}
}
memset(line, 0, LZ);
}
fclose(fd);
if (strlen(errMessage)) {
LOG(logERROR, ("%s\n\n", errMessage));
return FAIL;
}
LOG(logINFOBLUE, ("Successfully read default pattern file\n"));
return OK;
}
int default_writePatternWord(char *line, uint32_t addr, uint64_t word) {
// validations
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(initErrorMessage,
"Cannot set pattern word from default "
"pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
MAX_PATTERN_LENGTH, line);
return FAIL;
}
writePatternWord(addr, word);
// cannot validate for moench, ctb ( same as executing pattern word)
return OK;
}
#ifndef MYTHEN3D
int default_writePatternIOControl(char *line, uint64_t arg) {
uint64_t retval = writePatternIOControl(arg);
if (retval != arg) {
#ifdef VIRTUAL
sprintf(initErrorMessage,
"Could not set patioctrl from default pattern "
"file. Set 0x%lx, read 0x%lx. Line:[%s]\n",
arg, retval, line);
#else
sprintf(initErrorMessage,
"Could not set patioctrl from default pattern "
"file. Set 0x%llx, read 0x%llx. Line:[%s]\n",
arg, retval, line);
#endif
return FAIL;
}
return OK;
}
#endif
int default_setPatternLoopLimits(char *line, uint32_t startAddr,
uint32_t stopAddr) {
// validations
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(initErrorMessage,
"Cannot set patlimits from default "
"pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
MAX_PATTERN_LENGTH, line);
return FAIL;
}
int numLoops = -1;
int r_startAddr = startAddr, r_stopAddr = stopAddr;
setPatternLoop(-1, &r_startAddr, &r_stopAddr, &numLoops);
// validate
if (r_startAddr != (int)startAddr || r_stopAddr != (int)stopAddr) {
sprintf(initErrorMessage,
"Could not set patlimits from default pattern "
"file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n",
r_startAddr, r_stopAddr, line);
return FAIL;
}
return OK;
}
int default_setPatternLoopAddresses(char *line, int level, uint32_t startAddr,
uint32_t stopAddr) {
// validations
if (level < 0 || level > 2) {
sprintf(initErrorMessage,
"Cannot set patloop from default "
"pattern file. Level must be between 0 and 2. Line:[%s]\n",
line);
return FAIL;
}
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
sprintf(initErrorMessage,
"Cannot set patloop (level: %d) from default "
"pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
level, MAX_PATTERN_LENGTH, line);
return FAIL;
}
int numLoops = -1;
int r_startAddr = startAddr, r_stopAddr = stopAddr;
setPatternLoop(level, &r_startAddr, &r_stopAddr, &numLoops);
// validate
if (r_startAddr != (int)startAddr || r_stopAddr != (int)stopAddr) {
sprintf(
initErrorMessage,
"Could not set patloop (level: %d) from default "
"pattern file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n",
level, r_startAddr, r_stopAddr, line);
return FAIL;
}
return OK;
}
int default_setPatternLoopCycles(char *line, int level, int numLoops) {
// validations
if (level < 0 || level > 2) {
sprintf(initErrorMessage,
"Cannot set patnloop from default "
"pattern file. Level must be between 0 and 2. Line:[%s]\n",
line);
return FAIL;
}
if (numLoops < 0) {
sprintf(initErrorMessage,
"Cannot set patnloop from default "
"pattern file. Iterations must be between > 0. Line:[%s]\n",
line);
return FAIL;
}
int startAddr = -1;
int stopAddr = -1;
int r_numLoops = numLoops;
setPatternLoop(level, &startAddr, &stopAddr, &r_numLoops);
// validate
if (r_numLoops != numLoops) {
sprintf(initErrorMessage,
"Could not set patnloop (level: %d) from default "
"pattern file. Read %d loops. Line:[%s]\n",
level, r_numLoops, line);
return FAIL;
}
return OK;
}
int default_setPatternWaitAddresses(char *line, int level, uint32_t addr) {
// validations
if (level < 0 || level > 2) {
sprintf(initErrorMessage,
"Cannot set patwait address from default "
"pattern file. Level must be between 0 and 2. Line:[%s]\n",
line);
return FAIL;
}
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
sprintf(initErrorMessage,
"Cannot set patwait address (level: %d) from default "
"pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
level, MAX_PATTERN_LENGTH, line);
return FAIL;
}
uint32_t retval = setPatternWaitAddress(level, addr);
// validate
if (retval != addr) {
sprintf(initErrorMessage,
"Could not set patwait address (level: %d) from default "
"pattern file. Read addr: 0x%x. Line:[%s]\n",
level, retval, line);
return FAIL;
}
return OK;
}
int default_setPatternWaitTime(char *line, int level, uint64_t waittime) {
// 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;
}

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

@ -7,6 +7,7 @@
#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D)
#include "Pattern.h"
#include "loadPattern.h"
#endif
#include <arpa/inet.h>
@ -400,35 +401,6 @@ void modeNotImplemented(char *modename, int mode) {
LOG(logERROR, (mess));
}
void validate(int arg, int retval, char *modename, enum numberMode nummode) {
if (ret == OK && arg != GET_FLAG && 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);
LOG(logERROR, (mess));
}
}
void validate64(int64_t arg, int64_t retval, char *modename,
enum numberMode nummode) {
if (ret == OK && arg != GET_FLAG && 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);
LOG(logERROR, (mess));
}
}
int executeCommand(char *command, char *result, enum TLogLevel level) {
const size_t tempsize = 256;
char temp[tempsize];
@ -603,7 +575,8 @@ int set_external_signal_flag(int file_des) {
if (ret == OK) {
setExtSignal(signalIndex, flag);
retval = getExtSignal(signalIndex);
validate((int)flag, (int)retval, "set external signal flag", DEC);
validate(&ret, mess, (int)flag, (int)retval,
"set external signal flag", DEC);
LOG(logDEBUG1, ("External Signal Flag: %d\n", retval));
}
}
@ -643,7 +616,7 @@ int set_timing_mode(int file_des) {
// get
retval = getTiming();
#ifndef MYTHEN3D
validate((int)arg, (int)retval, "set timing mode", DEC);
validate(&ret, mess, (int)arg, (int)retval, "set timing mode", DEC);
#endif
LOG(logDEBUG1, ("Timing Mode: %d\n", retval));
@ -1054,7 +1027,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
case IO_DELAY:
retval = setIODelay(val);
LOG(logDEBUG1, ("IODelay: %d\n", retval));
validate(val, retval, "set iodelay", DEC);
validate(&ret, mess, val, retval, "set iodelay", DEC);
break;
#endif
@ -1064,7 +1037,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
LOG(logDEBUG1, ("High Voltage: %d\n", retval));
#if defined(JUNGFRAUD) || defined(CHIPTESTBOARDD) || defined(MOENCHD) || \
defined(GOTTHARD2D) || defined(MYTHEN3D)
validate(val, retval, "set high voltage", DEC);
validate(&ret, mess, val, retval, "set high voltage", DEC);
#endif
#ifdef GOTTHARDD
if (retval == -1) {
@ -1073,7 +1046,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
"110, 120, 150, 180, 200\n");
LOG(logERROR, (mess));
} else
validate(val, retval, "set high voltage", DEC);
validate(&ret, mess, val, retval, "set high voltage", DEC);
#elif EIGERD
if ((retval != SLAVE_HIGH_VOLTAGE_READ_VAL) && (retval < 0)) {
ret = FAIL;
@ -1131,7 +1104,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
}
retval = getPower(serverDacIndex);
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;
case V_POWER_CHIP:
@ -1177,7 +1150,7 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
}
retval = getVLimit();
LOG(logDEBUG1, ("VLimit: %d\n", retval));
validate(val, retval, "set vlimit", DEC);
validate(&ret, mess, val, retval, "set vlimit", DEC);
break;
#endif
// dacs
@ -1238,8 +1211,8 @@ int validateAndSetDac(enum dacIndex ind, int val, int mV) {
ret = OK;
} else {
ret = FAIL;
sprintf(mess, "Setting dac %d : wrote %d but read %d\n",
serverDacIndex, val, retval);
sprintf(mess, "Setting dac %d : wrote %d but read %d\n",
serverDacIndex, val, retval);
LOG(logERROR, (mess));
}
}
@ -1577,7 +1550,8 @@ int set_module(int file_des) {
ret = setModule(module, mess);
enum detectorSettings retval = getSettings();
#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
LOG(logDEBUG1, ("Settings: %d\n", retval));
}
@ -1659,7 +1633,7 @@ int set_settings(int file_des) {
LOG(logDEBUG1, ("Settings: %d\n", retval));
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
if (ret == OK) {
ret = setDefaultDacs();
@ -1995,7 +1969,8 @@ int set_num_frames(int file_des) {
int64_t retval = getNumFrames();
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);
}
}
}
@ -2027,7 +2002,7 @@ int set_num_triggers(int file_des) {
setNumTriggers(arg);
int64_t retval = getNumTriggers();
LOG(logDEBUG1, ("retval num triggers %lld\n", (long long int)retval));
validate64(arg, retval, "set number of triggers", DEC);
validate64(&ret, mess, arg, retval, "set number of triggers", DEC);
}
return Server_SendResult(file_des, INT64, NULL, 0);
}
@ -2070,8 +2045,8 @@ int set_num_additional_storage_cells(int file_des) {
setNumAdditionalStorageCells(arg);
int retval = getNumAdditionalStorageCells();
LOG(logDEBUG1, ("retval num addl. storage cells %d\n", retval));
validate(arg, retval, "set number of additional storage cells",
DEC);
validate(&ret, mess, arg, retval,
"set number of additional storage cells", DEC);
}
}
#endif
@ -2128,7 +2103,8 @@ int set_num_analog_samples(int file_des) {
} else {
int retval = getNumAnalogSamples();
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);
}
}
}
@ -2175,7 +2151,8 @@ int set_num_digital_samples(int file_des) {
} else {
int retval = getNumDigitalSamples();
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
@ -2749,7 +2726,7 @@ int set_dynamic_range(int file_des) {
sprintf(mess, "Could not get dynamic range.\n");
LOG(logERROR, (mess));
}
validate(dr, retval, "set dynamic range", DEC);
validate(&ret, mess, dr, retval, "set dynamic range", DEC);
break;
default:
modeNotImplemented("Dynamic range", dr);
@ -2921,7 +2898,7 @@ int enable_ten_giga(int file_des) {
}
retval = enableTenGigabitEthernet(GET_FLAG);
LOG(logDEBUG1, ("10GbE: %d\n", retval));
validate(arg, retval, "enable/disable 10GbE", DEC);
validate(&ret, mess, arg, retval, "enable/disable 10GbE", DEC);
}
#endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -2956,7 +2933,7 @@ int validateAndSetAllTrimbits(int arg) {
// get
retval = getAllTrimbits();
LOG(logDEBUG1, ("All trimbits: %d\n", retval));
validate(arg, retval, "set all trimbits", DEC);
validate(&ret, mess, arg, retval, "set all trimbits", DEC);
#endif
return retval;
}
@ -2992,10 +2969,10 @@ int set_pattern_io_control(int file_des) {
LOG(logDEBUG1,
("Setting Pattern IO Control to 0x%llx\n", (long long int)arg));
if (((int64_t)arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = writePatternIOControl(arg);
LOG(logDEBUG1,
("Pattern IO Control retval: 0x%llx\n", (long long int)retval));
validate64(arg, retval, "set Pattern IO Control", HEX);
if ((int64_t)arg != GET_FLAG) {
ret = validate_writePatternIOControl(mess, arg);
}
retval = validate_readPatternIOControl();
}
#endif
return Server_SendResult(file_des, INT64, &retval, sizeof(retval));
@ -3019,19 +2996,10 @@ int set_pattern_word(int file_des) {
(long long int)word));
}
if (Server_VerifyLock() == OK) {
// valid address
if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern (Word, addr:0x%x). Addr must be "
"between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
if (word != (uint64_t)-1) {
ret = validate_writePatternWord(mess, addr, word);
} else {
retval = writePatternWord(addr, word);
LOG(logDEBUG1,
("Pattern Word retval: 0x%llx\n", (long long int)retval));
// no validation (cannot read as it will execute the pattern)
ret = validate_readPatternWord(mess, addr, &retval);
}
}
#endif
@ -3057,37 +3025,27 @@ int set_pattern_loop_addresses(int file_des) {
loopLevel, startAddr, stopAddr));
if ((startAddr == GET_FLAG) || (stopAddr == GET_FLAG) ||
(Server_VerifyLock() == OK)) {
// valid loop level
if (loopLevel < -1 ||
loopLevel > 2) { // loop level of -1 : complete pattern
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop addresses. Level %d should be "
"between -1 and 2\n",
loopLevel);
LOG(logERROR, (mess));
// loop limits
if (loopLevel == -1) {
// set
if (startAddr >= 0 && stopAddr >= 0) {
ret = validate_setPatternLoopLimits(mess, startAddr, stopAddr);
}
// get
validate_getPatternLoopLimits(&retvals[0], &retvals[1]);
}
// valid addr for loop level 0-2
else if (startAddr >= MAX_PATTERN_LENGTH ||
stopAddr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop addresses. Address (start "
"addr:0x%x and stop addr:0x%x) "
"should be less than 0x%x\n",
startAddr, stopAddr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
} else {
int numLoops = -1;
setPatternLoop(loopLevel, &startAddr, &stopAddr, &numLoops);
LOG(logDEBUG1,
("Pattern loop addresses retval: (start:0x%x, stop:0x%x)\n",
startAddr, stopAddr));
retvals[0] = startAddr;
retvals[1] = stopAddr;
validate(args[1], startAddr, "set Pattern loops' start address",
HEX);
validate(args[2], stopAddr, "set Pattern loops' stop address", HEX);
// loop addresses
else {
// set
if (startAddr >= 0 && stopAddr >= 0) {
ret = validate_setPatternLoopAddresses(mess, loopLevel, startAddr,
stopAddr);
}
// get
if (ret == OK) {
ret = validate_getPatternLoopAddresses(mess, loopLevel, &retvals[0],
&retvals[1]);
}
}
}
#endif
@ -3110,23 +3068,13 @@ int set_pattern_loop_cycles(int file_des) {
LOG(logDEBUG1, ("Setting Pattern loop cycles (loopLevel:%d numLoops:%d)\n",
loopLevel, numLoops));
if ((numLoops == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern loop cycles. Level %d should be "
"between 0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
} else {
int startAddr = GET_FLAG;
int stopAddr = GET_FLAG;
setPatternLoop(loopLevel, &startAddr, &stopAddr, &numLoops);
retval = numLoops;
LOG(logDEBUG1,
("Pattern loop cycles retval: (ncycles:%d)\n", retval));
validate(args[1], retval, "set Pattern loops' number of cycles",
DEC);
// set
if (numLoops != GET_FLAG) {
ret = validate_setPatternLoopCycles(mess, loopLevel, numLoops);
}
// get
if (ret == OK) {
ret = validate_getPatternLoopCycles(mess, loopLevel, &retval);
}
}
#endif
@ -3149,27 +3097,13 @@ int set_pattern_wait_addr(int file_des) {
LOG(logDEBUG1, ("Setting Pattern wait address (loopLevel:%d addr:0x%x)\n",
loopLevel, addr));
if ((addr == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level 0-2
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait address. Level %d should be "
"between 0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
// set
if (addr != GET_FLAG) {
ret = validate_setPatternWaitAddresses(mess, loopLevel, addr);
}
// valid addr
else if (addr >= MAX_PATTERN_LENGTH) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait address. Address (0x%x) should be "
"between 0 and 0x%x\n",
addr, MAX_PATTERN_LENGTH);
LOG(logERROR, (mess));
} else {
retval = setPatternWaitAddress(loopLevel, addr);
LOG(logDEBUG1, ("Pattern wait address retval: 0x%x\n", retval));
validate(addr, retval, "set Pattern wait address", HEX);
// get
if (ret == OK) {
ret = validate_getPatternWaitAddresses(mess, loopLevel, &retval);
}
}
#endif
@ -3192,19 +3126,13 @@ int set_pattern_wait_time(int file_des) {
LOG(logDEBUG1, ("Setting Pattern wait time (loopLevel:%d timeval:0x%llx)\n",
loopLevel, (long long int)timeval));
if (((int64_t)timeval == GET_FLAG) || (Server_VerifyLock() == OK)) {
// valid loop level 0-2
if (loopLevel < 0 || loopLevel > 2) {
ret = FAIL;
sprintf(mess,
"Cannot set Pattern wait time. Level %d should be between "
"0 and 2\n",
loopLevel);
LOG(logERROR, (mess));
} else {
retval = setPatternWaitTime(loopLevel, timeval);
LOG(logDEBUG1,
("Pattern wait time retval: 0x%llx\n", (long long int)retval));
validate64(timeval, retval, "set Pattern wait time", HEX);
// set
if ((int64_t)timeval != GET_FLAG) {
ret = validate_setPatternWaitTime(mess, loopLevel, timeval);
}
// get
if (ret == OK) {
ret = validate_getPatternWaitTime(mess, loopLevel, &retval);
}
}
#endif
@ -3229,7 +3157,7 @@ int set_pattern_mask(int file_des) {
uint64_t retval64 = getPatternMask();
LOG(logDEBUG1,
("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
return Server_SendResult(file_des, INT32, NULL, 0);
@ -3272,7 +3200,7 @@ int set_pattern_bit_mask(int file_des) {
uint64_t retval64 = getPatternBitMask();
LOG(logDEBUG1,
("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
return Server_SendResult(file_des, INT32, NULL, 0);
@ -3350,7 +3278,7 @@ int set_counter_bit(int file_des) {
// get
retval = setCounterBit(GET_FLAG);
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
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
}
@ -3450,7 +3378,7 @@ int set_rate_correct(int file_des) {
strcpy(mess, "Rate correction failed\n");
LOG(logERROR, (mess));
} else {
validate64(tau_ns, retval, "set rate correction", DEC);
validate64(&ret, mess, tau_ns, retval, "set rate correction", DEC);
}
}
#endif
@ -3493,7 +3421,7 @@ int set_ten_giga_flow_control(int file_des) {
} else {
int retval = getTenGigaFlowControl();
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
@ -3552,7 +3480,8 @@ int set_transmission_delay_frame(int file_des) {
int retval = getTransmissionDelayFrame();
LOG(logDEBUG1,
("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);
}
}
}
@ -3602,7 +3531,8 @@ int set_transmission_delay_left(int file_des) {
} else {
int retval = getTransmissionDelayLeft();
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
@ -3651,7 +3581,8 @@ int set_transmission_delay_right(int file_des) {
} else {
int retval = getTransmissionDelayRight();
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
@ -3902,7 +3833,7 @@ int power_chip(int file_des) {
retval = powerChip(arg);
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
// narrow down error when powering on
if (ret == FAIL && arg > 0) {
@ -3949,7 +3880,7 @@ int set_activate(int file_des) {
LOG(logERROR, (mess));
} else {
LOG(logDEBUG1, ("Activate: %d\n", retval));
validate(arg, retval, "set/get activate", DEC);
validate(&ret, mess, arg, retval, "set/get activate", DEC);
}
}
}
@ -3983,7 +3914,7 @@ int threshold_temp(int file_des) {
else {
retval = setThresholdTemperature(arg);
LOG(logDEBUG1, ("Threshold temperature: %d\n", retval));
validate(arg, retval, "set threshold temperature", DEC);
validate(&ret, mess, arg, retval, "set threshold temperature", DEC);
}
}
#endif
@ -4008,7 +3939,7 @@ int temp_control(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setTemperatureControl(arg);
LOG(logDEBUG1, ("Temperature control: %d\n", retval));
validate(arg, retval, "set temperature control", DEC);
validate(&ret, mess, arg, retval, "set temperature control", DEC);
}
#endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4032,7 +3963,7 @@ int temp_event(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setTemperatureEvent(arg);
LOG(logDEBUG1, ("Temperature event: %d\n", retval));
validate(arg, retval, "set temperature event", DEC);
validate(&ret, mess, arg, retval, "set temperature event", DEC);
}
#endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4055,7 +3986,7 @@ int auto_comp_disable(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = autoCompDisable(arg);
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
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4083,7 +4014,7 @@ int storage_cell_start(int file_des) {
} else {
retval = selectStoragecellStart(arg);
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
@ -4198,7 +4129,7 @@ int led(int file_des) {
if ((arg == GET_FLAG) || (Server_VerifyLock() == OK)) {
retval = setLEDEnable(arg);
LOG(logDEBUG1, ("LED Enable: %d\n", retval));
validate(arg, retval, "enable/disable LED", DEC);
validate(&ret, mess, arg, retval, "enable/disable LED", DEC);
}
#endif
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -4502,7 +4433,8 @@ int set_external_sampling_source(int file_des) {
} else {
retval = setExternalSamplingSource(arg);
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
@ -4527,7 +4459,7 @@ int set_external_sampling(int file_des) {
arg = (arg > 0) ? 1 : arg;
retval = setExternalSampling(arg);
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
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
@ -5616,7 +5548,7 @@ int set_readout_mode(int file_des) {
} else {
LOG(logDEBUG1, ("readout mode retval: %u\n", retval));
}
validate(arg, retval, "set readout mode", DEC);
validate(&ret, mess, arg, retval, "set readout mode", DEC);
}
}
}
@ -5701,7 +5633,7 @@ int set_clock_frequency(int file_des) {
int retval = getFrequency(c);
LOG(logDEBUG1, ("retval %s: %d %s\n", modeName, retval,
myDetectorType == GOTTHARD2 ? "Hz" : "MHz"));
validate(val, retval, modeName, DEC);
validate(&ret, mess, val, retval, modeName, DEC);
}
}
}
@ -5853,7 +5785,7 @@ int set_clock_phase(int file_des) {
int retval = getPhase(c, inDegrees);
LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval));
if (!inDegrees) {
validate(val, retval, modeName, DEC);
validate(&ret, mess, val, retval, modeName, DEC);
} else {
ret = validatePhaseinDegrees(c, val, retval);
if (ret == FAIL) {
@ -6056,7 +5988,7 @@ int set_clock_divider(int file_des) {
} else {
int retval = getClockDivider(c);
LOG(logDEBUG1, ("retval %s : %d\n", modeName, retval));
validate(val, retval, modeName, DEC);
validate(&ret, mess, val, retval, modeName, DEC);
}
}
}
@ -6147,7 +6079,7 @@ int set_pipeline(int file_des) {
setPipeline(c, val);
int retval = getPipeline(c);
LOG(logDEBUG1, ("retval %s: %d\n", modeName, retval));
validate(val, retval, modeName, DEC);
validate(&ret, mess, val, retval, modeName, DEC);
}
}
#endif
@ -6263,7 +6195,7 @@ int set_on_chip_dac(int file_des) {
} else {
int retval = getOnChipDAC(dacIndex, chipIndex);
LOG(logDEBUG1, ("retval %s: 0x%x\n", modeName, retval));
validate(val, retval, modeName, DEC);
validate(&ret, mess, val, retval, modeName, DEC);
}
}
}
@ -6732,7 +6664,7 @@ int set_num_bursts(int file_des) {
setNumBursts(arg);
int64_t retval = getNumBursts();
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
return Server_SendResult(file_des, INT64, NULL, 0);
@ -6799,7 +6731,7 @@ int set_current_source(int file_des) {
setCurrentSource(arg);
int retval = getCurrentSource();
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
return Server_SendResult(file_des, INT32, NULL, 0);
@ -7361,7 +7293,7 @@ int set_num_gates(int file_des) {
setNumGates(arg);
int retval = getNumGates();
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
return Server_SendResult(file_des, INT32, NULL, 0);
@ -7559,7 +7491,7 @@ int set_veto(int file_des) {
if (ret == OK) {
int retval = getVeto();
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
@ -7585,88 +7517,7 @@ int set_pattern(int file_des) {
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Setting Pattern from structure\n"));
LOG(logINFO,
("Setting Pattern Word (printing every 10 words that are not 0\n"));
/****************************************************************************************************************/
/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A
* SEPARATE FUNCTION WHICH COULD BE REUSED*/
/* added loadPattern.c/h - the same func could be reused also in
* readDefaultPattern */
/***************************************************************************************************************/
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
i, (long long int)pat->word[i]));
}
writePatternWord(i, pat->word[i]);
}
#ifndef MYTHEN3D
if (ret == OK) {
uint64_t retval64 = writePatternIOControl(pat->ioctrl);
validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX);
}
#endif
if (ret == OK) {
int numLoops = -1;
int retval0 = pat->limits[0];
int retval1 = pat->limits[1];
setPatternLoop(-1, &retval0, &retval1, &numLoops);
validate(pat->limits[0], retval0,
"set pattern Limits start address", HEX);
validate(pat->limits[1], retval1,
"set pattern Limits start address", HEX);
}
if (ret == OK) {
for (int i = 0; i <= 2; ++i) {
char msg[128];
int retval0 = -1, retval1 = -1, numLoops = -1;
uint64_t retval64 = -1;
// patloop
retval0 = pat->loop[i * 2 + 0];
retval1 = pat->loop[i * 2 + 1];
numLoops = pat->nloop[i];
setPatternLoop(i, &retval0, &retval1, &numLoops);
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d start address", i);
validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d stop address", i);
validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
if (ret == FAIL) {
break;
}
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d num loops", i);
validate(pat->nloop[i], numLoops, msg, HEX);
if (ret == FAIL) {
break;
}
// patwait
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait address", i);
retval0 = setPatternWaitAddress(i, pat->wait[i]);
validate(pat->wait[i], retval0, msg, HEX);
if (ret == FAIL) {
break;
}
// patwaittime
memset(msg, 0, sizeof(msg));
sprintf(msg, "set pattern Loop %d wait time", i);
retval64 = setPatternWaitTime(i, pat->waittime[i]);
validate64(pat->waittime[i], retval64, msg, HEX);
if (ret == FAIL) {
break;
}
}
}
/******* DOWN TO HERE ***********/
ret = loadPattern(mess, logINFO, pat);
}
if (pat != NULL)
free(pat);
@ -7688,97 +7539,7 @@ int get_pattern(int file_des) {
memset(pat, 0, sizeof(patternParameters));
if (Server_VerifyLock() == OK) {
LOG(logINFO, ("Getting Pattern from structure\n"));
// patword
LOG(logDEBUG,
("retval pattern word (printing every 10 words that are not 0\n"));
for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
pat->word[i] = readPatternWord(i);
if ((int64_t)pat->word[i] == -1) {
ret = FAIL;
sprintf(mess, "could not read pattern word for address 0x%x\n",
i);
LOG(logERROR, (mess));
break;
}
// debug print
if ((i % 10 == 0) && pat->word[i] != 0) {
LOG(logDEBUG,
("retval Patpattern word (addr:0x%x, word:0x%llx)\n", i,
(long long int)pat->word[i]));
}
}
// patioctrl
#ifndef MYTHEN3D
if (ret == OK) {
pat->ioctrl = writePatternIOControl(-1);
LOG(logDEBUG, ("retval pattern io control:0x%llx\n",
(long long int)pat->ioctrl));
}
#endif
if (ret == OK) {
// patlimits
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(-1, &retval0, &retval1, &numLoops);
pat->limits[0] = retval0;
pat->limits[1] = retval1;
LOG(logDEBUG, ("retval pattern limits start:0x%x stop:0x%x\n",
pat->limits[0], pat->limits[1]));
for (int i = 0; i <= 2; ++i) {
// patloop
{
int numLoops = -1;
int retval0 = -1;
int retval1 = -1;
setPatternLoop(i, &retval0, &retval1, &numLoops);
pat->nloop[i] = numLoops;
pat->loop[i * 2 + 0] = retval0;
pat->loop[i * 2 + 1] = retval1;
LOG(logDEBUG, ("retval pattern loop level %d start:0x%x "
"stop:0x%x numLoops:%d\n",
i, pat->loop[i * 2 + 0],
pat->loop[i * 2 + 0], pat->nloop[i]));
}
// patwait
{
pat->wait[i] = setPatternWaitAddress(i, -1);
if ((int)pat->wait[i] == -1) {
ret = FAIL;
sprintf(mess,
"could not read pattern wait address for level "
"%d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait address for level %d: 0x%x\n", i,
pat->wait[i]));
}
// patwaittime
{
pat->waittime[i] = setPatternWaitTime(i, -1);
if ((int64_t)pat->waittime[i] == -1) {
ret = FAIL;
sprintf(
mess,
"could not read pattern wait time for level %d\n",
i);
LOG(logERROR, (mess));
break;
}
LOG(logDEBUG,
("retval pattern wait time for level %d: %lld\n", i,
(long long int)pat->waittime[i]));
}
}
}
ret = getPattern(mess, pat);
}
// ignoring endianness for eiger
@ -7849,7 +7610,7 @@ int set_scan(int file_des) {
setNumFrames(arg);
retval = getNumFrames();
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
else {
@ -7899,7 +7660,8 @@ int set_scan(int file_des) {
retval = getNumFrames();
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);
retval = numScanSteps;
}
}
@ -7964,7 +7726,7 @@ int set_cds_gain(int file_des) {
setCDSGain(arg);
int retval = getCDSGain();
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
@ -8013,7 +7775,7 @@ int set_filter(int file_des) {
setFilter(arg);
int retval = getFilter();
LOG(logDEBUG1, ("filter retval: %u\n", retval));
validate(arg, retval, "set filter", DEC);
validate(&ret, mess, arg, retval, "set filter", DEC);
}
}
#endif
@ -8116,7 +7878,7 @@ int set_adc_config(int file_des) {
} else {
int retval = getADCConfiguration(chipIndex, adcIndex);
LOG(logDEBUG1, ("adc config retval: %u\n", retval));
validate(value, retval, "configure adc", HEX);
validate(&ret, mess, value, retval, "configure adc", HEX);
}
}
}
@ -8347,7 +8109,7 @@ int load_default_pattern(int file_des) {
functionNotImplemented();
#else
if (Server_VerifyLock() == OK) {
ret = loadDefaultPattern(DEFAULT_PATTERN_FILE, mess);
ret = loadPatternFile(DEFAULT_PATTERN_FILE, mess);
if (ret == FAIL) {
LOG(logERROR, (mess));
}

14
slsSupportLib/include/sls/versionAPI.h
View File

@ -1,12 +1,12 @@
/** API versions */
#define GITBRANCH "developer"
#define APICTB 0x210225
#define APIGOTTHARD 0x210225
#define APIGOTTHARD2 0x210225
#define APIJUNGFRAU 0x210225
#define APIMOENCH 0x210225
#define APIEIGER 0x210225
#define APILIB 0x210225
#define APIRECEIVER 0x210225
#define APIGUI 0x210225
#define APIMYTHEN3 0x210608
#define APICTB 0x210621
#define APIGOTTHARD 0x210621
#define APIGOTTHARD2 0x210621
#define APIJUNGFRAU 0x210621
#define APIMYTHEN3 0x210621
#define APIMOENCH 0x210621
#define APIEIGER 0x210621

6
slsSupportLib/tests/test-file_utils.cpp
View File

@ -1,13 +1,12 @@
#include "catch.hpp"
#include "sls/file_utils.h"
#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <iostream>
#include <vector>
TEST_CASE("Get size of empty file") {
char fname[] = "temfile_XXXXXX";
int fh = mkstemp(fname);
std::ifstream ifs(fname);
auto size = sls::getFileSize(ifs);
REQUIRE(size == 0);
@ -23,6 +22,5 @@ TEST_CASE("Get size of file with data") {
std::ifstream ifs(fname);
auto size = sls::getFileSize(ifs);
REQUIRE(size == n_bytes);
REQUIRE(ifs.tellg() == 0); //getting size resets pos!
REQUIRE(ifs.tellg() == 0); // getting size resets pos!
}