mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-06-19 08:17:13 +02:00
wip
This commit is contained in:
@ -1,7 +1,6 @@
|
||||
#include "loadPattern.h"
|
||||
#include "clogger.h"
|
||||
#include "common.h"
|
||||
#include "readDefaultPattern.h"
|
||||
#include "sls/ansi.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
#include "slsDetectorServer_defs.h"
|
||||
@ -25,7 +24,7 @@ extern uint64_t setPatternWaitTime(int level, uint64_t t);
|
||||
extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
|
||||
int *nLoop);
|
||||
|
||||
int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
|
||||
int loadPattern(char *message, enum TLogLevel printLevel, patternParameters *pat) {
|
||||
LOG(logINFOBLUE, ("Loading Pattern\n"));
|
||||
int ret = OK;
|
||||
trimmingPrint = printLevel;
|
||||
@ -35,72 +34,43 @@ int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
|
||||
LOG(logDEBUG5, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
|
||||
i, (long long int)pat->word[i]));
|
||||
}
|
||||
writePatternWord(i, pat->word[i]);
|
||||
ret = pattern_writeWord(message, i, pat->word[i]);
|
||||
if (ret == FAIL) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
#ifndef MYTHEN3D
|
||||
if (ret == OK) {
|
||||
uint64_t retval64 = writePatternIOControl(pat->ioctrl);
|
||||
validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX);
|
||||
ret = pattern_writeIOControl(message, pat->ioctrl);
|
||||
}
|
||||
#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);
|
||||
ret = pattern_setLoopLimits(message, pat->limits[0], pat->limits[1]);
|
||||
}
|
||||
uint64_t retval64;
|
||||
|
||||
if (ret == OK) {
|
||||
for (int i = 0; i <= 2; ++i) {
|
||||
char msg[128];
|
||||
int retval0 = -1, retval1 = -1, numLoops = -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);
|
||||
// loop addr
|
||||
ret = pattern_setLoopAddresses(message, i, pat->loop[i * 2 + 0], pat->loop[i * 2 + 1]);
|
||||
if (ret == FAIL) {
|
||||
break;
|
||||
}
|
||||
|
||||
// patwaittime
|
||||
if (pattern_setWaitTime(mess, i, pat->waittime[i]) == FAIL) {
|
||||
// num loops
|
||||
ret = pattern_setLoopCycles(message, i, pat->nloop[i]);
|
||||
if (ret == FAIL) {
|
||||
break;
|
||||
}
|
||||
|
||||
// wait addr
|
||||
ret = pattern_setWaitAddresses(message, i, pat->wait[i]);
|
||||
if (ret == FAIL) {
|
||||
break;
|
||||
}
|
||||
|
||||
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 (retval64 == FAIL) {
|
||||
// wait time
|
||||
ret = pattern_setWaitTime(message, i, pat->waittime[i]);
|
||||
if (ret == FAIL) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -110,34 +80,183 @@ int loadPattern(char *mess, enum TLogLevel printLevel, patternParameters *pat) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
int pattern_setWaitTime(char *mess, int level, uint64_t waittime) {
|
||||
memset(mess, 0, sizeof(mess));
|
||||
char msg[128];
|
||||
memset(msg, 0, sizeof(msg));
|
||||
// validations
|
||||
if (level < 0 || level > 2) {
|
||||
sprintf(initErrorMessage,
|
||||
"Cannot set patwaittime from default "
|
||||
"pattern file. Level must be between 0 and 2. Line:[%s]\n",
|
||||
line);
|
||||
int pattern_writeWord(char *message, uint32_t addr, uint64_t word) {
|
||||
// vaiidate input
|
||||
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
|
||||
sprintf(message,
|
||||
"Cannot set pattern word. Addr must be between 0 and 0x%x.\n",
|
||||
MAX_PATTERN_LENGTH);
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
writePatternWord(addr, word);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
// cannot validate for moench, ctb ( same as executing pattern word)
|
||||
#ifdef MYTHEN3D
|
||||
uint64_t retval = readPatternWord(addr);
|
||||
char mode[128];
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern word for addr 0x%x", addr);
|
||||
validate64(&ret, message, word, retval, "set pattern word", HEX);
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifndef MYTHEN3D
|
||||
int pattern_writeIOControl(char *message, uint64_t arg) {
|
||||
uint64_t retval = writePatternIOControl(arg);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
validate64(&ret, message, arg, retval, "set pattern IO Control", HEX);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
int pattern_setLoopLimits(char *message, uint32_t startAddr,
|
||||
uint32_t stopAddr) {
|
||||
// vaiidate input
|
||||
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
|
||||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
|
||||
sprintf(message,
|
||||
"Cannot set patlimits from default "
|
||||
"pattern file. Addr must be between 0 and 0x%x.\n",
|
||||
MAX_PATTERN_LENGTH);
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
int numLoops = -1;
|
||||
int r_startAddr = startAddr, r_stopAddr = stopAddr;
|
||||
setPatternLoop(-1, &r_startAddr, &r_stopAddr, &numLoops);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
// start addr
|
||||
validate(&ret, message, startAddr, r_startAddr, "set pattern Limits start addr", HEX);
|
||||
if (ret == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
// stop addr
|
||||
validate(&ret, message, stopAddr, r_stopAddr, "set pattern Limits stop addr", HEX);
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
int pattern_setLoopAddresses(char *message, int level, uint32_t startAddr, uint32_t stopAddr) {
|
||||
// vaiidate input
|
||||
if (level < 0 || level > 2) {
|
||||
sprintf(message,
|
||||
"Cannot set patloop. Level must be between 0 and 2.\n");
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
if ((int32_t)startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH ||
|
||||
(int32_t)stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
|
||||
sprintf(message,
|
||||
"Cannot set patloop (level: %d). Addr must be between 0 and 0x%x.\n",
|
||||
level, MAX_PATTERN_LENGTH);
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
int numLoops = -1;
|
||||
int r_startAddr = startAddr, r_stopAddr = stopAddr;
|
||||
setPatternLoop(level, &r_startAddr, &r_stopAddr, &numLoops);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
char mode[128];
|
||||
// start addr
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern Loop %d start addr", level);
|
||||
validate(&ret, message, startAddr, r_startAddr, mode, HEX);
|
||||
if (ret == FAIL) {
|
||||
return FAIL;
|
||||
}
|
||||
// stop addr
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern Loop %d stop addr", level);
|
||||
validate(&ret, message, stopAddr, r_stopAddr, mode, HEX);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int pattern_setLoopCycles(char *message, int level, int numLoops) {
|
||||
// vaiidate input
|
||||
if (level < 0 || level > 2) {
|
||||
sprintf(message,
|
||||
"Cannot set patnloop. Level must be between 0 and 2.\n");
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
if (numLoops < 0) {
|
||||
sprintf(message,
|
||||
"Cannot set patnloop. Iterations must be between > 0.\n");
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
int startAddr = -1;
|
||||
int stopAddr = -1;
|
||||
int r_numLoops = numLoops;
|
||||
setPatternLoop(level, &startAddr, &stopAddr, &r_numLoops);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
char mode[128];
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern Loop %d num loops", level);
|
||||
validate(&ret, message, numLoops, r_numLoops, mode, DEC);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int pattern_setWaitAddresses(char *message, int level, uint32_t addr) {
|
||||
// validate input
|
||||
if (level < 0 || level > 2) {
|
||||
sprintf(message,
|
||||
"Cannot set patwait address. Level must be between 0 and 2.\n");
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
if ((int32_t)addr < 0 || addr >= MAX_PATTERN_LENGTH) {
|
||||
sprintf(message,
|
||||
"Cannot set patwait address (level: %d). Addr must be between 0 and 0x%x.\n", level, MAX_PATTERN_LENGTH);
|
||||
LOG(logERROR, (message));
|
||||
return FAIL;
|
||||
}
|
||||
|
||||
uint32_t retval = setPatternWaitAddress(level, addr);
|
||||
|
||||
// validate result
|
||||
int ret = OK;
|
||||
char mode[128];
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern Loop %d wait address", level);
|
||||
validate(&ret, message, addr, retval, mode, HEX);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int pattern_setWaitTime(char *message, int level, uint64_t waittime) {
|
||||
memset(message, 0, sizeof(message));
|
||||
|
||||
// validate input
|
||||
if (level < 0 || level > 2) {
|
||||
sprintf(message,
|
||||
"Cannot set patwaittime. Level must be between 0 and 2.\n");
|
||||
LOG(logERROR, (message));
|
||||
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;
|
||||
}
|
||||
// validate result
|
||||
int ret = OK;
|
||||
char mode[128];
|
||||
memset(mode, 0, sizeof(mode));
|
||||
sprintf(mode, "set pattern Loop %d wait time", level);
|
||||
validate64(&ret, message, waittime, retval, mode, DEC);
|
||||
return ret;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user