lin-epics-modules/sinqDAQ
0
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Continued work

Browse Source
This commit is contained in:
soederqvist_a
2026-01-16 08:30:41 +01:00
committed by soederqvist_a
parent 1d47b02833
commit 2aa6bd4405
2 changed files with 160 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
db/daq_soft_proton.db
View File

@@ -33,7 +33,7 @@ record(mbbi, "$(INSTR)$(NAME):STATUS")
record(longin, "$(INSTR)$(NAME):CHANNELS") record(longin, "$(INSTR)$(NAME):CHANNELS")
{ {
field(DESC, "Total Supported Channels") field(DESC, "Total Supported Channels")
field(VAL, $(CHANNELS=1)) field(VAL, 1)
field(DISP, 1) field(DISP, 1)
} }
@@ -41,6 +41,13 @@ record(stringin, "$(INSTR)$(NAME):MsgTxt")
{ {
field(DESC, "Miscellanous messages") field(DESC, "Miscellanous messages")
} }
record(bi, "$(INSTR)$(NAME):IS_LOWRATE")
{
field(ZNAM, "LOW RATE")
field(ONAM, "GOOD RATE")
}
################################################################################ ################################################################################
# Commands # Commands
################################################################################ ################################################################################
@@ -150,8 +157,7 @@ record(longout,"$(INSTR)$(NAME):THRESHOLD-MONITOR")
field(DESC, "Channel monitored for minimum rate") field(DESC, "Channel monitored for minimum rate")
field(VAL, "1") # Monitor field(VAL, "1") # Monitor
field(DRVL, "0") # Smallest Threshold Channel (0 is off) field(DRVL, "0") # Smallest Threshold Channel (0 is off)
field(DRVH, "$(CHANNELS=1)") # Largest Threshold Channel field(DRVH, "1") # Largest Threshold Channel
field(DTYP, "stream")
} }
record(ao,"$(INSTR)$(NAME):THRESHOLD") record(ao,"$(INSTR)$(NAME):THRESHOLD")
@@ -160,19 +166,15 @@ record(ao,"$(INSTR)$(NAME):THRESHOLD")
alias("$(INSTR)$(NAME):THRESHOLD_RBV") alias("$(INSTR)$(NAME):THRESHOLD_RBV")
field(DESC, "Minimum rate for counting to proceed") field(DESC, "Minimum rate for counting to proceed")
field(VAL, "1") # Default Rate field(VAL, "1") # Default Rate
# Could perhaps still be improved.
# It seems to only accept whole counts?
field(DRVL, "1") # Minimum Rate field(DRVL, "1") # Minimum Rate
field(DRVH, "100000") # Maximum Rate field(DRVH, "100000") # Maximum Rate
field(OMSL, "supervisory") field(OMSL, "supervisory")
field(OROC, "0")
} }
record(ai,"$(INSTR)$(NAME):ELAPSED-TIME") record(ai,"$(INSTR)$(NAME):ELAPSED-TIME")
{ {
field(DESC, "DAQ Measured Time") field(DESC, "DAQ Measured Time")
field(EGU, "sec") field(EGU, "sec")
field(FLNK, "$(INSTR)$(NAME):ETO")
} }
# Array Subroutine record which emulates the counterbox functionality # Array Subroutine record which emulates the counterbox functionality
@@ -182,7 +184,6 @@ record(aSub, "$(INSTR)$(NAME):EMULATION")
# Scan rate determines how often we sample the rate # Scan rate determines how often we sample the rate
# and how often the counter value updates. # and how often the counter value updates.
field(SCAN, "0.1 seconds" field(SCAN, "0.1 seconds"
field(INAM, "initEmulatedCounter")
field(SNAM, "processEmulatedCounter" field(SNAM, "processEmulatedCounter"
# The first 4 inputs are also mapped as the first 4 outputs # The first 4 inputs are also mapped as the first 4 outputs
@@ -219,8 +220,12 @@ record(aSub, "$(INSTR)$(NAME):EMULATION")
field(FTVC, "DOUBLE") field(FTVC, "DOUBLE")
field(OUTD, "$(INSTR)$(NAME):COMMAND-TRIG PP") field(OUTD, "$(INSTR)$(NAME):COMMAND-TRIG PP")
field(FTVD, "ULONG") field(FTVD, "ULONG")
field(INPE, "$(INSTR)$(NAME):R0-PREV PP") field(OUTE, "$(INSTR)$(NAME):R0-PREV PP")
field(FTE, "DOUBLE") field(FTVE, "DOUBLE")
field(OUTF, "$(INSTR)$(NAME):IS_LOWRATE PP")
field(FTVF, "ULONG")
field(OUTF, "$(INSTR)$(NAME):MSG_TXT PP")
field(FTVF, "CHAR")
} }
####################### #######################
@@ -237,9 +242,10 @@ record(int64in, "$(INSTR)$(NAME):M0")
record(calc, "$(INSTR)$(NAME):R0") record(calc, "$(INSTR)$(NAME):R0")
{ {
field(DESC, "Rate of DAQ CH0 proton current") field(DESC, "Rate of DAQ CH0 proton current")
field(INPA, "$(REMOTE_RATE_PV) CA" #field(INPA, "$(REMOTE_RATE_PV) CA")
field(INPA, "$(INSTR)$(NAME):PROTON_CURR)"
field(INPB, "$(SHUTTER1_PV=0)") field(INPB, "$(SHUTTER1_PV=0)")
field(INPC, "$(SHUTTER1_CLOSED_VAL=1)" field(INPC, "$(SHUTTER1_CLOSED_VAL=1)")
field(INPD, "$(SHUTTER2_PV=0)") field(INPD, "$(SHUTTER2_PV=0)")
field(INPE, "$(SHUTTER2_CLOSED_VAL=1)") field(INPE, "$(SHUTTER2_CLOSED_VAL=1)")
# If either shutter is closed we have no rate # If either shutter is closed we have no rate
@@ -273,3 +279,12 @@ record(bi, "$(INSTR)$(NAME):S0")
field(ONAM, "CLEARING") field(ONAM, "CLEARING")
} }
record(calc, "$(INSTR)$(NAME):PROTON_CURR") {
field(SCAN, "0.05 seconds")
field(CALC, "1500 * 101 * SIN(A)")
field(INPA, "$(INSTR)$(NAME):PROTON_CURR_VAR PP")
}
record(calc, "$(INSTR)$(NAME):PROTON_CURR_VAR") {
field(CALC, "VAL + 0.001")
}

230
src/daq_soft_proton.c
View File

@@ -1,3 +1,10 @@
/* This is a software emulated counterbox with 1 channel.
* It's stateless implementation with only a process function.
* All states that are need between the periods,
* are saved in the EPICS databases.
* Typically it is sampling the proton rate from HIPA via
* channel access.
*/
#include <stdio.h> #include <stdio.h>
#include <dbDefs.h> #include <dbDefs.h>
#include <errlog.h> #include <errlog.h>
@@ -8,7 +15,7 @@
#include <epicsExport.h> #include <epicsExport.h>
/* Sample rate */ /* Sample rate */
static const epicsFloat64 soft_proton_sample_rate = 0.1; #define SOFT_PROTON_SAMPLE_RATE 0.1
/* To allow setting debug pring from iocsh */ /* To allow setting debug pring from iocsh */
static int softProtonDebug=0; static int softProtonDebug=0;
@@ -27,7 +34,8 @@ struct spc_internal {
epicsFloat64 preset_time; epicsFloat64 preset_time;
}; };
/* Enum with values for all commands */ /* Enum with values for all commands
* this has to match the what's in the mbbi in the database*/
enum commands { enum commands {
NONE = 0, NONE = 0,
COUNT_PRESET = 1, COUNT_PRESET = 1,
@@ -38,7 +46,8 @@ enum commands {
FULL_RESET = 6 FULL_RESET = 6
}; };
/* Enum with the possible statuses/states */ /* Enum with the possible statuses/states
* this has to match the what's in the mbbi in the database*/
enum status { enum status {
IDLE = 0, IDLE = 0,
COUNTING = 1, COUNTING = 1,
@@ -48,36 +57,29 @@ enum status {
}; };
int handleNoop(struct spc_internal* spc_int, int* exit_status) { int handleNoop(struct spc_internal* spc_int, epicsChar** msg_text) {
const char[] funcstr = "handleNoop"; const char[] funcstr = "handleNoop";
/* This shouldn't happen, but let's handle it just in case */ /* This shouldn't happen, but let's handle it just in case */
if (spc_int->status >= INVALID || spc->command_trig > FULL_RESET) { if (spc_int->status >= INVALID || spc->command_trig > FULL_RESET) {
*msg_text = "INVALID STATE!";
errlogPrintf("%s: Status and/or command triggers are invalid \n" errlogPrintf("%s: Status and/or command triggers are invalid \n"
"Status has value %d, \n Command trigger has value %d\n", "Status has value %d, \n Command trigger has value %d\n",
funcstr, spc_int->status, spc_int->command_trig); funcstr, spc_int->status, spc_int->command_trig);
*exit_status = -1;
return 1; return 1;
} }
/* Determine if we are idle or paused and have not received a command */
if ((spc_int->status == IDLE || spc_int->status == PAUSED) &&
spc_int->command_trig == NONE) {
/* Just return as quickly as possible if there is nothing going on */
*exit_status = 0;
return 1;
}
/* Determine if we are idle and have received a noop command */ /* Determine if we are idle and have received a noop command */
if (spc_int->status == IDLE) { if (spc_int->status == IDLE) {
switch (spc_int->command_trig) { switch (spc_int->command_trig) {
case PAUSE: case PAUSE:
case CONTINUE: case CONTINUE:
case STOP: case STOP:
errlogPrintf("%s: Can not PAUSE/CONTINUE/STOP during IDLE\n" *msg_text = "Can not PAUSE/CONTINUE/STOP during IDLE.";
"Status has value %d, \n" printf("%s: %s\n"
"Command trigger has value %d\n", "Status has value %d, \n"
funcstr, spc_int->status, spc_int->command_trig); "Command trigger has value %d\n",
*exit_status = -1; funcstr, spc_int->status, spc_int->command_trig);
*exit_status = 1; /* Positive value: No alarm and no output processing */
return 1; return 1;
} }
} }
@@ -89,22 +91,24 @@ int handleNoop(struct spc_internal* spc_int, int* exit_status) {
switch (spc_int->command_trig) { switch (spc_int->command_trig) {
case COUNT_PRESET: case COUNT_PRESET:
case TIME_PRESET: case TIME_PRESET:
errlogPrintf("%s: Already counting can not start a new count\n" printf("%s: Already counting can not start a new count\n"
"Status has value %d, \n" "Status has value %d, \n"
"Command trigger has value %d\n", "Command trigger has value %d\n",
funcstr, spc_int->status, spc_int->command_trig); funcstr, spc_int->status, spc_int->command_trig);
*exit_status = -1; *exit_status = 0;
return 1; /* This case could be seen as OK.
* Nothing is keeping us from continuing, so let's do that. */
return 0;
} }
} }
/* Determine if we are paused and received a command */ /* Determine if we are paused and a pause command */
if (spc_int->status == PAUSED && spc_int->command_trig == PAUSE) { if (spc_int->status == PAUSED && spc_int->command_trig == PAUSE) {
errlogPrintf("%s: Already paused\n" errlogPrintf("%s: Already paused\n"
"Status has value %d, \n" "Status has value %d, \n"
"Command trigger has value %d\n", "Command trigger has value %d\n",
funcstr, spc_int->status, spc_int->command_trig); funcstr, spc_int->status, spc_int->command_trig);
*exit_status = -1; *exit_status = 1; /* Positive value: No alarm and no output processing */
return 1; return 1;
} }
/* None of the noop cases detected */ /* None of the noop cases detected */
@@ -112,16 +116,7 @@ int handleNoop(struct spc_internal* spc_int, int* exit_status) {
} }
/* /*
* This function is called a IOC init * This function is called everytime the record processes.
*/
static long initEmulatedCounter(struct subRecord *psub)
{
if (softProtonDebug) printf("initEmulatedCounter was called\n");
return 0;
}
/*
* This functioni is called everytime the record processes.
* Even though this record can process arrays, we only use it with scalars, * Even though this record can process arrays, we only use it with scalars,
* hence all the [0]'s. * hence all the [0]'s.
*/ */
@@ -132,90 +127,139 @@ static long processEmulatedCounter(struct aSubRecord *psub)
/* Declare internal variable */ /* Declare internal variable */
struct spc_internal spc_int; struct spc_internal spc_int;
struct spc_internal spc = &spc_int;
int exit_status = 0; int exit_status = 0;
/* Copy input values to a struct on the stack /* Copy input values to a struct on the stack
* to simplify creation of functions */ * to simplify creation of functions */
spc_int.status = psub->a[0]; spc->status = psub->a[0];
monitor_count = psub->b[0]; spc->monitor_count = psub->b[0];
elapsed_time = psub->c[0]; spc->elapsed_time = psub->c[0];
command_trig = psub->d[0]; spc->command_trig = psub->d[0];
threshold = psub->e[0]; spc->threshold = psub->e[0];
count_type = psub->f[0]; spc->count_type = psub->f[0];
preset_count = psub->g[0]; spc->preset_count = psub->g[0];
preset_time = psub->h[0]; spc->preset_time = psub->h[0];
prev_proton_rate = psub->j[0]; spc->prev_proton_rate = psub->j[0];
proton_rate = psub->l[0]; spc->proton_rate = psub->l[0];
/* Get the pointer to output values. /* Get the pointer to output values only to increase readability. */
This to increase readability. */
epicsUInt32* status_out = psub->vala; epicsUInt32* status_out = psub->vala;
epicsInt64* monitor_count_out = psub->valb; epicsInt64* monitor_count_out = psub->valb;
epicsFloat64* elaped_time_out = psub->valc; epicsFloat64* elaped_time_out = psub->valc;
epicsUInt32* command_trig_out = psub->vald; epicsUInt32* command_trig_out = psub->vald;
epicsFloat64* prev_proton_rate_out = psub->vale; epicsFloat64* prev_proton_rate_out = psub->vale;
epicsUInt32* is_low_rate_out = psub->valf;
epicsChar* msg_txt_out = &psub->valg;
/* Always no matter what, handle the rate */
/* - Calculate average rate */
average_rate = (spc->proton_rate + spc->prev_proton_rate) / 2;
/* - Store current rate as previous rate */
*prev_proton_rate_out = spc_int->proton_rate;
if (average_rate < spc->threshold) {
*is_low_rate_out = 0; /* Illogical but 0 is low_rate, 1 high rate */
} else {
*is_low_rate_out = 1; /* Illogical but 0 is low_rate, 1 high rate */
}
/* Handle noop situations both valid and invalid */ /* Handle noop situations both valid and invalid */
if (handle_noop(&spc_int, &exit_status)) if (handle_noop(spc, &msg_txt_out))
return exit_status; /* We have state that prohibits further processing */
return 0;
if (spc_int->command_trig == FULL_RESET) {
/* Commands with priority always yielding IDLE status first */
if (spc->command_trig == FULL_RESET) {
msg_txt_out = "Full reset!";
/* Reset everything, done! */
*status_out = IDLE; *status_out = IDLE;
*monitor_count_out = 0; *monitor_count_out = 0;
*elapsed_time_out = 0.0; *elapsed_time_out = 0.0;
*command_trig_out = NONE; *command_trig_out = NONE;
if (softProtonDebug) printf("%s: Full reset done!\n", funcstr); if (softProtonDebug) printf("%s: Full reset done!\n", funcstr);
return 0; return 0;
} } else if (spc->command_trig == STOP ||
(spc->status == IDLE && spc->command_trig == NONE)) {
if ((spc_int->status == COUNTING || spc_int->status == LOW_RATE) && /* Stop is always valid, retains everything except status goes to idle.
spc_int->command_trig == PAUSE)) { * This happens to be the same case as when IDLE and no command received */
/* We are counting or at low rate and will pause */ *status_out = IDLE;
*command_trig_out = NONE;
*monitor_count_out = spc->monitor_count;
*elapsed_time_out = spc->elapsed_time;
return 0;
} else if (((spc->status == COUNTING || spc->status == LOW_RATE)
&& spc->command_trig == PAUSE) ||
(spc->status == PAUSED && spc->command_trig == NONE)) {
msg_txt_out = "Stopping!";
/* We are counting or at low rate and received pause.
* Also we are paused but have received no command, this
* is probably slightly inaccurate but simplifies things.*/
*status_out = PAUSED; *status_out = PAUSED;
*command_trig_out = NONE;
} *monitor_count_out = spc->monitor_count;
*elapsed_time_out = spc->elapsed_time;
/* Determine if we are idle but received a count command */ return 0;
if (status == IDLE && } else if (spc->status == IDLE &&
(command_trig == COUNT_PRESET || command_trig == TIME_PRESET)) { (spc->command_trig == COUNT_PRESET || spc->command_trig == TIME_PRESET)) {
/* Determine if we are idle but received a count command */
if (softProtonDebug) printf("%s: Starting Count!\n", funcstr); if (softProtonDebug) printf("%s: Starting Count!\n", funcstr);
/* Sanity check that count type is properly stored */ /* Sanity check that count type is properly stored */
if ( command_trig != count_type ) { if (command_trig != count_type) {
if (softProtonDebug) printf("%s: Count type not stored!\n", funcstr); if (softProtonDebug) printf("%s: Count type not stored!\n", funcstr);
return -1; return -1;
} }
/* Starting a new count /* Starting a new count
/* Reset counter and time */ * Reset counter and time */
*monitor_count_out = 0; *monitor_count_out = 0;
*elapsed_time_out = 0; *elapsed_time_out = 0;
*command_trig_out = NONE;
if (is_low_rate_out == 1) {
*status_out = LOW_RATE;
} else {
*status_out = COUNTING;
}
return 0;
} else if ((((spc_int->status == LOW_RATE && spc_int->command_trig == NONE) ||
(spc_int->status == LOW_RATE && spc_int->command_trig == CONTINUE)))
&& is_low_rate_out == 1) {
*status_out = LOW_RATE;
/* LOW_RATE or resuming from PAUSE */
*command_trig_out = NONE;
/* Maintain same counter and time*/
*monitor_count_out = spc_int->monitor_count;
*elapsed_time_out = spc_int->elapsed_time;
return 0
}
/* Ending up here means:
* 1. status == COUNTING && command_trig == NONE
* 2. status == COUNTING && command_trig == CONTINUE
* 3. status == PAUSED && command_trig == CONTINUE
* 4. status == LOW_RATE && command_trig in [ NONE, CONTINUE ] && high_rate
*/
/* We may have had a command */
*command_trig_out = NONE;
/* Normal incremental count */
*status_out = COUNTING;
/* Increament counter and time */
*monitor_count_out = spc_int->monitor_count +
average_rate * SOFT_PROTON_SAMPLE_RATE;
*elapsed_time_out = spc_int->elapsed_time + SOFT_PROTON_SAMPLE_RATE;
/* Check if we are below threshold */
if (is_low_rate_out == 1) {
*status_out = LOW_RATE;
} else {
*status_out = COUNTING; *status_out = COUNTING;
*command_trig_out = NONE;
*prev_proton_rate_out = spc_int->proton_rate;
goto FINISH_ONGOING_COUNT;
} }
/* Resume from paused */ /* Check if count is finished normally.
if (spc_int->status == PAUSED && spc_int->command_trig == CONTINUE) { * Higher priority than low rate */
*prev_proton_rate_out = spc_int->proton_rate;
*status_out = COUNTING;
*command_trig_out = NONE;
/* continue cycle doesn't increment the counter */
goto FINISH_ONGOING_COUNT;
}
/* Counting */
if (spc_int->status == COUNTING && spc_int->command_trig == NONE) {
/* Take the average proton rate of the sampling period */
*monitor_count_out =
(spc_int->proton_rate + spc_int->prev_proton_rate) / 2;
*elapsed_time_out += soft_proton_sample_rate;
*command_trig_out = NONE;
*prev_proton_rate_out = spc_int->proton_rate;
}
/* Special cases */
/* Count finished normally */
if (/* Time based count finished */ if (/* Time based count finished */
(*elapsed_time_out >= spc_int->preset_time && (*elapsed_time_out >= spc_int->preset_time &&
spc_int->count_type = TIME_PRESET) || spc_int->count_type = TIME_PRESET) ||
@@ -223,17 +267,9 @@ static long processEmulatedCounter(struct aSubRecord *psub)
(*monitor_count_out >= spc_int->preset_time && (*monitor_count_out >= spc_int->preset_time &&
spc_int->count_type = COUNT_PRESET)) { spc_int->count_type = COUNT_PRESET)) {
*status_out = IDLE; *status_out = IDLE;
return 0;
} }
FINISH_ONGOING_COUNT:
if (spc_int->proton_rate < spc_int->threshold)
*status_out = LOW_RATE;
else
*status_out = COUNTING;
return 0; return 0;
} }
epicsRegisterFunction(initEmulatedCounter);
epicsRegisterFunction(processEmulatedCounter); epicsRegisterFunction(processEmulatedCounter);