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

ran formatter

Browse Source
This commit is contained in:
wall_e
2024-09-30 17:12:30 +02:00
parent 39098fd0d1
commit 501c5badea
3 changed files with 600 additions and 591 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.RHEL8
View File

@ -13,7 +13,7 @@ REQUIRED+=scaler
REQUIRED+=asynMotor
# Release version
LIBVERSION=2024-v2
LIBVERSION=2024-ed-dev2
# DB files to include in the release
TEMPLATES += sinqEPICSApp/Db/dimetix.db

247
sinqEPICSApp/src/devScalerEL737.c
View File

@ -14,59 +14,59 @@
* 2 = threshold monitor
* 3 = threshold monitor count
*
* This is less then ideal. But it is a workaround for the fact that the scalar record
* does not do all the tricks the EL737 knows:
* This is less then ideal. But it is a workaround for the fact that the scalar
* record does not do all the tricks the EL737 knows:
* - Thresholding
* - two count modes
* A better solution would be to extend the scalar record to have a proper status and count
* mode field. And threshold control fields too. But this is much more work, breaks
* compatability with the scalar record completely and thus was not done for now.
* A better solution would be to extend the scalar record to have a proper
* status and count mode field. And threshold control fields too. But this is
* much more work, breaks compatability with the scalar record completely and
* thus was not done for now.
*
* The driver will run a separate thread which does all the
* communication.
*
* Mark Koennecke, February 2013
*
* Enhanced by adding an addtional external pause and status flag in the database and code in here
* to handle this. Moreover an external MsgTxt field in the DB can be filled with an error message.
* Enhanced by adding an addtional external pause and status flag in the
* database and code in here to handle this. Moreover an external MsgTxt field
* in the DB can be filled with an error message.
*
* Mark Koennecke, July 2017
*
* Enhanced with a separate thresholdCounter and threshold field in order to replace the
* hack for threshold handling. If these fields are present, the hack with presets 2 and
* 3 as described above is ignored.
* Enhanced with a separate thresholdCounter and threshold field in order to
* replace the hack for threshold handling. If these fields are present, the
* hack with presets 2 and 3 as described above is ignored.
*
* Mark Koennecke, August 2017
*/
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <asynEpicsUtils.h>
#include <asynOctetSyncIO.h>
#include <epicsEvent.h>
#include <epicsThread.h>
#include <epicsTime.h>
#include <epicsExport.h>
#include <errlog.h>
#include <callback.h>
#include <recSup.h>
#include <devSup.h>
#include <cantProceed.h>
#include <dbAccess.h>
#include <dbDefs.h>
#include <dbFldTypes.h>
#include <dbAccess.h>
#include <errlog.h>
#include <scalerRecord.h>
#include <devScaler.h>
#include <asynEpicsUtils.h>
#include <devSup.h>
#include <epicsEvent.h>
#include <epicsExport.h>
#include <epicsThread.h>
#include <epicsTime.h>
#include <errlog.h>
#include <errno.h>
#include <recSup.h>
#include <scalerRecord.h>
#include <string.h>
#include <unistd.h>
/* dset functions */
static long el737_init_record(struct scalerRecord *psr, CALLBACK *pcallback);
static long el737_reset(scalerRecord *psr);
static long el737_read(scalerRecord *psr, epicsUInt32 *val);
static long el737_write_preset(scalerRecord *psr, int signal, unsigned long val);
static long el737_write_preset(scalerRecord *psr, int signal,
unsigned long val);
static long el737_arm(scalerRecord *psr, int val);
static long el737_done(scalerRecord *psr);
@ -82,17 +82,9 @@ static void el737Thread(void *param);
#define COMLEN 132
SCALERDSET devScalerEL737 = {
7,
NULL,
NULL,
el737_init_record,
NULL,
el737_reset,
el737_read,
el737_write_preset,
el737_arm,
el737_done
};
7, NULL, NULL, el737_init_record,
NULL, el737_reset, el737_read, el737_write_preset,
el737_arm, el737_done};
epicsExportAddress(dset, devScalerEL737);
typedef struct {
@ -114,12 +106,9 @@ typedef struct {
unsigned int dbInit;
} EL737priv;
static void dummyAsynCallback([[maybe_unused]] asynUser *pasynUser)
{
}
static void dummyAsynCallback([[maybe_unused]] asynUser *pasynUser) {}
static void connectSlaveRecords(EL737priv *priv)
{
static void connectSlaveRecords(EL737priv *priv) {
char slaveName[PVNAME_SZ + 18], errName[256];
long status;
@ -129,10 +118,12 @@ static void connectSlaveRecords(EL737priv *priv)
status = dbNameToAddr(slaveName, &priv->pause);
if (status != 0) {
errSymLookup(status, errName, sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName,
errName);
priv->dbInit = 0;
} else {
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",slaveName, priv->pause.precord->name);
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",
slaveName, priv->pause.precord->name);
}
snprintf(slaveName, sizeof(slaveName), "%s:MsgTxt", priv->psr->name);
@ -140,10 +131,12 @@ static void connectSlaveRecords(EL737priv *priv)
status = dbNameToAddr(slaveName, &priv->msgTxt);
if (status != 0) {
errSymLookup(status, errName, sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName,
errName);
priv->dbInit = 0;
} else {
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",slaveName, priv->msgTxt.precord->name);
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",
slaveName, priv->msgTxt.precord->name);
}
snprintf(slaveName, sizeof(slaveName), "%s:Status", priv->psr->name);
@ -151,21 +144,26 @@ static void connectSlaveRecords(EL737priv *priv)
status = dbNameToAddr(slaveName, &priv->status);
if (status != 0) {
errSymLookup(status, errName, sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName,
errName);
priv->dbInit = 0;
} else {
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",slaveName, priv->status.precord->name);
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",
slaveName, priv->status.precord->name);
}
snprintf(slaveName,sizeof(slaveName),"%s:ThresholdCounter", priv->psr->name);
snprintf(slaveName, sizeof(slaveName), "%s:ThresholdCounter",
priv->psr->name);
errlogPrintf("Name of thresholdCounter variable: %s\n", slaveName);
status = dbNameToAddr(slaveName, &priv->threshCounter);
if (status != 0) {
errSymLookup(status, errName, sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName,
errName);
priv->dbInit = 0;
} else {
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",slaveName, priv->threshCounter.precord->name);
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",
slaveName, priv->threshCounter.precord->name);
}
snprintf(slaveName, sizeof(slaveName), "%s:Threshold", priv->psr->name);
@ -173,16 +171,17 @@ static void connectSlaveRecords(EL737priv *priv)
status = dbNameToAddr(slaveName, &priv->threshold);
if (status != 0) {
errSymLookup(status, errName, sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName,
errName);
priv->dbInit = 0;
} else {
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",slaveName, priv->threshold.precord->name);
errlogPrintf("dbNameToAddr succeded for %s, record access %s\n",
slaveName, priv->threshold.precord->name);
}
priv->thresholdValue = -999;
}
static long el737_init_record(scalerRecord *psr, CALLBACK *pcallback)
{
static long el737_init_record(scalerRecord *psr, CALLBACK *pcallback) {
EL737priv *priv = NULL;
char *port, *userParam;
int signal, status, reason;
@ -204,23 +203,23 @@ static long el737_init_record(scalerRecord *psr, CALLBACK *pcallback)
/*
* private data structure
*/
priv = callocMustSucceed(1,sizeof(EL737priv), "devScalerEL737 init_record()");
priv =
callocMustSucceed(1, sizeof(EL737priv), "devScalerEL737 init_record()");
priv->psr = psr;
priv->wakeUp = epicsEventCreate(epicsEventEmpty);
priv->pcallback = pcallback;
priv->dbInit = 0;
psr->dpvt = priv;
/*
* Hook up with device
*/
dummyUser = pasynManager->createAsynUser(dummyAsynCallback, 0);
status = pasynEpicsUtils->parseLink(dummyUser, &psr->out,
&port, &signal, &userParam);
status = pasynEpicsUtils->parseLink(dummyUser, &psr->out, &port, &signal,
&userParam);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::init_record %s bad link %s\n",
psr->name, dummyUser->errorMessage);
errlogPrintf("devScalerEL737::init_record %s bad link %s\n", psr->name,
dummyUser->errorMessage);
psr->pact = 1;
return 0;
}
@ -251,18 +250,14 @@ static long el737_init_record(scalerRecord *psr, CALLBACK *pcallback)
/*
start the thread which actually runs the device
*/
epicsThreadCreate("EL737",
epicsThreadPriorityMedium,
epicsThreadStackMedium,
el737Thread,
priv);
epicsThreadCreate("EL737", epicsThreadPriorityMedium,
epicsThreadStackMedium, el737Thread, priv);
// errlogPrintf("EL7373 thread started \n");
return 0;
}
static long el737_reset(scalerRecord *psr)
{
static long el737_reset(scalerRecord *psr) {
unsigned int i;
EL737priv *priv;
@ -273,8 +268,7 @@ static long el737_reset(scalerRecord *psr)
return 0;
}
static long el737_read(scalerRecord *psr, epicsUInt32 *val)
{
static long el737_read(scalerRecord *psr, epicsUInt32 *val) {
unsigned int i;
EL737priv *priv;
@ -286,8 +280,8 @@ static long el737_read(scalerRecord *psr, epicsUInt32 *val)
return 0;
}
static long el737_write_preset(scalerRecord *psr, int signal, unsigned long val)
{
static long el737_write_preset(scalerRecord *psr, int signal,
unsigned long val) {
EL737priv *priv;
// errlogPrintf("EL737: Setting preset %d to %ld\n", signal, val);
@ -300,13 +294,11 @@ static long el737_write_preset(scalerRecord *psr, int signal, unsigned long val)
priv->sendThreshold = 1;
epicsEventSignal(priv->wakeUp);
// errlogPrintf("EL737: Setting threshold \n");
}
return 0;
}
static long el737_arm(scalerRecord *psr, int val)
{
static long el737_arm(scalerRecord *psr, int val) {
EL737priv *priv;
priv = (EL737priv *)psr->dpvt;
@ -319,8 +311,7 @@ static long el737_arm(scalerRecord *psr, int val)
return 0;
}
static long el737_done(scalerRecord *psr)
{
static long el737_done(scalerRecord *psr) {
EL737priv *priv;
priv = (EL737priv *)psr->dpvt;
@ -337,8 +328,8 @@ static long el737_done(scalerRecord *psr)
}
}
static asynStatus el737_transactCommand(EL737priv *priv,char command[COMLEN],char reply[COMLEN])
{
static asynStatus el737_transactCommand(EL737priv *priv, char command[COMLEN],
char reply[COMLEN]) {
asynStatus status;
size_t in, out;
int reason, dbStatus;
@ -349,18 +340,22 @@ static asynStatus el737_transactCommand(EL737priv *priv,char command[COMLEN],cha
// errlogPrintf("EL737: sending command %s\n", command);
strcpy(message, "");
status = pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
status =
pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
reply, COMLEN, 1., &out, &in, &reason);
if (status == asynSuccess) {
if (strstr(reply, "?OF") != NULL) {
strcpy(myCommand, "RMT 1");
status = pasynOctetSyncIO->writeRead(priv->asynContext, myCommand, strlen(myCommand),
reply,COMLEN, 1.,&out,&in,&reason);
status = pasynOctetSyncIO->writeRead(
priv->asynContext, myCommand, strlen(myCommand), reply, COMLEN,
1., &out, &in, &reason);
strcpy(myCommand, "ECHO 2");
status = pasynOctetSyncIO->writeRead(priv->asynContext, myCommand, strlen(myCommand),
reply,COMLEN, 1.,&out,&in,&reason);
return pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
reply,COMLEN, 1.,&out,&in,&reason);
status = pasynOctetSyncIO->writeRead(
priv->asynContext, myCommand, strlen(myCommand), reply, COMLEN,
1., &out, &in, &reason);
return pasynOctetSyncIO->writeRead(priv->asynContext, command,
strlen(command), reply, COMLEN,
1., &out, &in, &reason);
} else {
if (strstr(reply, "?OV") != NULL) {
strncpy(message, "Overflow", sizeof(message));
@ -392,7 +387,8 @@ static asynStatus el737_transactCommand(EL737priv *priv,char command[COMLEN],cha
if (errno == EAGAIN) {
errlogPrintf("Lost response to %s with EAGAIN\n", command);
} else {
snprintf(message,sizeof(message), "Lost communication with errno %d", errno);
snprintf(message, sizeof(message),
"Lost communication with errno %d", errno);
/* force a reconnect */
pasynOctetSyncIO->disconnect(priv->asynContext);
}
@ -401,33 +397,33 @@ static asynStatus el737_transactCommand(EL737priv *priv,char command[COMLEN],cha
dbStatus = dbPutField(&priv->msgTxt, DBR_STRING, message, 1);
if (dbStatus != 0) {
errSymLookup(dbStatus, message, sizeof(message));
errlogPrintf("Setting external count message failed with %s\n", message);
errlogPrintf("Setting external count message failed with %s\n",
message);
}
}
return status;
}
static asynStatus sendStop(EL737priv *priv)
{
static asynStatus sendStop(EL737priv *priv) {
char command[COMLEN], reply[COMLEN];
// errlogPrintf("EL737: Sending stop\n");
strcpy(command, "S");
return el737_transactCommand(priv, command, reply);
}
static void runEvents(EL737priv *priv)
{
static void runEvents(EL737priv *priv) {
char command[COMLEN], reply[COMLEN], errName[256];
int status;
long dbStatus, nElements = 1, options = 0, threshCounter;
long unsigned int myThreshold;
/*
This is the better way to set the threshold rather then the old way below which uses
presets for that function. This one uses separate fields.
This is the better way to set the threshold rather then the old way below
which uses presets for that function. This one uses separate fields.
*/
if (priv->dbInit == 1 && priv->sendThreshold) {
dbStatus = dbGetField(&priv->threshold,DBR_LONG,&myThreshold,&options, &nElements,NULL);
dbStatus = dbGetField(&priv->threshold, DBR_LONG, &myThreshold,
&options, &nElements, NULL);
if (dbStatus != 0) {
errSymLookup(dbStatus, errName, sizeof(errName));
errlogPrintf("Reading threshold failed with %s\n", errName);
@ -436,10 +432,13 @@ static void runEvents(EL737priv *priv)
/*
we have to set the threshold
*/
dbStatus = dbGetField(&priv->threshCounter,DBR_LONG,&threshCounter, &options, &nElements,NULL);
dbStatus =
dbGetField(&priv->threshCounter, DBR_LONG, &threshCounter,
&options, &nElements, NULL);
if (dbStatus != 0) {
errSymLookup(dbStatus, errName, sizeof(errName));
errlogPrintf("Reading thresholdCounter failed with %s\n", errName);
errlogPrintf("Reading thresholdCounter failed with %s\n",
errName);
} else {
if (threshCounter == 0) {
threshCounter = 1;
@ -460,11 +459,13 @@ static void runEvents(EL737priv *priv)
}
if (priv->sendThreshold == 1) {
// fallback when we do not have the DB fields or threshCounter is invalid
// fallback when we do not have the DB fields or threshCounter is
// invalid
if (priv->presets[THRESHMON] > 0) {
sprintf(command, "DL %d %d", (int)priv->presets[THRESHMON],
(int)priv->presets[THRESHVAL]);
// errlogPrintf("Sending threshold from presets, command %s\n", command);
// errlogPrintf("Sending threshold from presets, command %s\n",
// command);
status = el737_transactCommand(priv, command, reply);
sprintf(command, "DR %d", (int)priv->presets[THRESHMON]);
status = el737_transactCommand(priv, command, reply);
@ -496,15 +497,14 @@ static void runEvents(EL737priv *priv)
}
}
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n, errno =%d",
errlogPrintf(
"devScalerEL737::el737Thread communication problem %s\n, errno =%d",
priv->asynContext->errorMessage, errno);
}
}
static void updateValues(EL737priv *priv)
{
static void updateValues(EL737priv *priv) {
char command[COMLEN], reply[COMLEN];
int status;
float fTime;
@ -514,20 +514,24 @@ static void updateValues(EL737priv *priv)
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
if (errno == EAGAIN) {
errlogPrintf("devScalerEL737::el737Thread lost response to %s with EAGAIN\n", command);
errlogPrintf(
"devScalerEL737::el737Thread lost response to %s with EAGAIN\n",
command);
} else {
errlogPrintf("devScalerEL737::el737Thread communication problem %s, errno = %d\n",
errlogPrintf("devScalerEL737::el737Thread communication problem "
"%s, errno = %d\n",
priv->asynContext->errorMessage, errno);
}
return;
}
status = sscanf(reply, "%f %ld %ld %ld %ld %ld %ld %ld %ld",
&fTime, &m1, &m2, &m3, &m4, &m5, &m6, &m7, &m8);
status = sscanf(reply, "%f %ld %ld %ld %ld %ld %ld %ld %ld", &fTime, &m1,
&m2, &m3, &m4, &m5, &m6, &m7, &m8);
if (status != 9) {
/*
old form with 4 monitors
*/
status = sscanf(reply, "%ld %ld %ld %ld %f", &m1, &m2, &m3, &m4, &fTime);
status =
sscanf(reply, "%ld %ld %ld %ld %f", &m1, &m2, &m3, &m4, &fTime);
if (status != 5) {
errlogPrintf("devScalerEL737::el737Thread bad RA reply %s\n",
reply);
@ -543,11 +547,9 @@ static void updateValues(EL737priv *priv)
priv->values[6] = m6;
priv->values[7] = m7;
priv->values[8] = m8;
}
static void el737Thread(void *param)
{
static void el737Thread(void *param) {
EL737priv *priv = (EL737priv *)param;
epicsEventWaitStatus evStatus;
double timeout = 60.;
@ -581,12 +583,12 @@ static void el737Thread(void *param)
status = sendStop(priv);
}
if (priv->counting) {
strcpy(command, "RS");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n",
errlogPrintf("devScalerEL737::el737Thread communication "
"problem %s\n",
priv->asynContext->errorMessage);
continue;
}
@ -619,23 +621,28 @@ static void el737Thread(void *param)
dbStatus = dbPutField(&priv->status, DBR_LONG, &ctStatus, 1);
if (dbStatus != 0) {
errSymLookup(dbStatus, errName, sizeof(errName));
errlogPrintf("Setting external count status failed with %s\n", errName);
errlogPrintf(
"Setting external count status failed with %s\n",
errName);
}
/*
check and handle pause flag
*/
dbStatus = dbGetField(&priv->pause, DBR_LONG,&pauseFlag,&options, &nElements, NULL);
dbStatus = dbGetField(&priv->pause, DBR_LONG, &pauseFlag,
&options, &nElements, NULL);
if (dbStatus != 0) {
errSymLookup(dbStatus, errName, sizeof(errName));
errlogPrintf("Reading pauseFlag failed with %s\n", errName);
}
/* errlogPrintf("Successfully read %ld pause flags as %d\n",nElements, pauseFlag); */
/* errlogPrintf("Successfully read %ld pause flags as
* %d\n",nElements, pauseFlag); */
if (pauseFlag == 1 && ctStatus == 1) {
strcpy(command, "PS");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n",
errlogPrintf("devScalerEL737::el737Thread "
"communication problem %s\n",
priv->asynContext->errorMessage);
continue;
}
@ -643,7 +650,8 @@ static void el737Thread(void *param)
strcpy(command, "CO");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n",
errlogPrintf("devScalerEL737::el737Thread "
"communication problem %s\n",
priv->asynContext->errorMessage);
continue;
}
@ -658,4 +666,3 @@ static void el737Thread(void *param)
}
}
}

4
sinqEPICSApp/src/el737Record.db
View File

@ -1,16 +1,18 @@
record(bo,"$(P):Pause")
{
field(DTYP,"Soft Channel")
}
record(longin,"$(P):Status")
{
field(DTYP,"Soft Channel")
}
record(stringin,"$(P):MsgTxt")
{
field(DTYP,"Soft Channel")
}
record(scaler,"$(P)")
{
field(DESC,"$(DESC)")