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

509
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 {
@ -112,77 +104,84 @@ typedef struct {
DBADDR threshCounter;
DBADDR threshold;
unsigned int dbInit;
}EL737priv;
} 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;
priv->dbInit = 1;
snprintf(slaveName,sizeof(slaveName),"%s:Pause", priv->psr->name);
snprintf(slaveName, sizeof(slaveName), "%s:Pause", priv->psr->name);
errlogPrintf("Name of pause variable: %s\n", slaveName);
status = dbNameToAddr(slaveName,&priv->pause);
if(status!= 0){
errSymLookup(status,errName,sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
status = dbNameToAddr(slaveName, &priv->pause);
if (status != 0) {
errSymLookup(status, errName, sizeof(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);
snprintf(slaveName, sizeof(slaveName), "%s:MsgTxt", priv->psr->name);
errlogPrintf("Name of MsgTxt variable: %s\n", slaveName);
status = dbNameToAddr(slaveName,&priv->msgTxt);
if(status!= 0){
errSymLookup(status,errName,sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
status = dbNameToAddr(slaveName, &priv->msgTxt);
if (status != 0) {
errSymLookup(status, errName, sizeof(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);
snprintf(slaveName, sizeof(slaveName), "%s:Status", priv->psr->name);
errlogPrintf("Name of status variable: %s\n", slaveName);
status = dbNameToAddr(slaveName,&priv->status);
if(status!= 0){
errSymLookup(status,errName,sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
status = dbNameToAddr(slaveName, &priv->status);
if (status != 0) {
errSymLookup(status, errName, sizeof(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);
status = dbNameToAddr(slaveName, &priv->threshCounter);
if (status != 0) {
errSymLookup(status, errName, sizeof(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);
errlogPrintf("Name of thresholdCounter variable: %s\n", slaveName);
status = dbNameToAddr(slaveName,&priv->threshold);
if(status!= 0){
errSymLookup(status,errName,sizeof(errName));
errlogPrintf("dbNameToAddr failed for %s with %s\n", slaveName, errName);
status = dbNameToAddr(slaveName, &priv->threshold);
if (status != 0) {
errSymLookup(status, errName, sizeof(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);
dummyUser = pasynManager->createAsynUser(dummyAsynCallback, 0);
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;
}
@ -233,17 +232,17 @@ static long el737_init_record(scalerRecord *psr, CALLBACK *pcallback)
psr->pact = 1;
return 0;
}
pasynOctetSyncIO->setOutputEos(priv->asynContext,"\r",strlen("\r"));
pasynOctetSyncIO->setInputEos(priv->asynContext,"\r",strlen("\r"));
pasynOctetSyncIO->setOutputEos(priv->asynContext, "\r", strlen("\r"));
pasynOctetSyncIO->setInputEos(priv->asynContext, "\r", strlen("\r"));
priv->asynContext->timeout = 2.0;
strcpy(command,"RMT 1");
strcpy(command, "RMT 1");
pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
reply,sizeof(reply), 1.,&out,&in,&reason);
reply, sizeof(reply), 1., &out, &in, &reason);
pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
reply,sizeof(reply), 1.,&out,&in,&reason);
strcpy(command,"ECHO 2");
reply, sizeof(reply), 1., &out, &in, &reason);
strcpy(command, "ECHO 2");
pasynOctetSyncIO->writeRead(priv->asynContext, command, strlen(command),
reply,sizeof(reply), 1.,&out,&in,&reason);
reply, sizeof(reply), 1., &out, &in, &reason);
pasynManager->freeAsynUser(dummyUser);
connectSlaveRecords(priv);
@ -251,62 +250,55 @@ 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");
// errlogPrintf("EL7373 thread started \n");
return 0;
}
static long el737_reset(scalerRecord *psr)
{
static long el737_reset(scalerRecord *psr) {
unsigned int i;
EL737priv *priv;
priv = (EL737priv *)psr->dpvt;
for(i = 0; i < NCOUNT; i++){
for (i = 0; i < NCOUNT; i++) {
priv->values[i] = 0;
}
return 0;
}
static long el737_read(scalerRecord *psr, epicsUInt32 *val)
{
static long el737_read(scalerRecord *psr, epicsUInt32 *val) {
unsigned int i;
EL737priv *priv;
priv = (EL737priv *)psr->dpvt;
for(i = 0; i < NCOUNT; i++){
for (i = 0; i < NCOUNT; i++) {
val[i] = (epicsUInt32)priv->values[i];
}
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);
priv = (EL737priv *)psr->dpvt;
if(signal >= 0 && signal < 13){
if (signal >= 0 && signal < 13) {
priv->presets[signal] = val;
}
if(signal == THRESHVAL){
if (signal == THRESHVAL) {
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,26 +311,25 @@ 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;
// errlogPrintf("EL737: Calling done with %d\n", psr->cnt);
if(priv->counting && psr->cnt == 0){
if (priv->counting && psr->cnt == 0) {
priv->countCommand = 0;
epicsEventSignal(priv->wakeUp);
}
if(priv->counting || priv->countCommand == 1){
if (priv->counting || priv->countCommand == 1) {
return 1;
} else {
return 0;
}
}
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;
@ -348,109 +339,117 @@ 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),
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);
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);
strcpy(message, "");
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);
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);
} else {
if(strstr(reply,"?OV") != NULL){
strncpy(message,"Overflow",sizeof(message));
} else if(strstr(reply,"?1") != NULL) {
strncpy(message,"Par out of range",sizeof(message));
} else if(strstr(reply,"?2") != NULL){
strncpy(message,"Bad command",sizeof(message));
} else if(strstr(reply,"?3") != NULL){
strncpy(message,"Bad parameter",sizeof(message));
} else if(strstr(reply,"?4") != NULL){
strncpy(message,"Bad counter",sizeof(message));
} else if(strstr(reply,"?5") != NULL){
strncpy(message,"Parameter missing",sizeof(message));
} else if(strstr(reply,"?6") != NULL){
strncpy(message,"to many counts",sizeof(message));
} else if(strstr(reply,"?91") != NULL){
strncpy(message,"Start Failure",sizeof(message));
} else if(strstr(reply,"?92") != NULL){
strncpy(message,"Failure while counting",sizeof(message));
} else if(strstr(reply,"?93") != NULL){
strncpy(message,"Read Failure",sizeof(message));
if (strstr(reply, "?OV") != NULL) {
strncpy(message, "Overflow", sizeof(message));
} else if (strstr(reply, "?1") != NULL) {
strncpy(message, "Par out of range", sizeof(message));
} else if (strstr(reply, "?2") != NULL) {
strncpy(message, "Bad command", sizeof(message));
} else if (strstr(reply, "?3") != NULL) {
strncpy(message, "Bad parameter", sizeof(message));
} else if (strstr(reply, "?4") != NULL) {
strncpy(message, "Bad counter", sizeof(message));
} else if (strstr(reply, "?5") != NULL) {
strncpy(message, "Parameter missing", sizeof(message));
} else if (strstr(reply, "?6") != NULL) {
strncpy(message, "to many counts", sizeof(message));
} else if (strstr(reply, "?91") != NULL) {
strncpy(message, "Start Failure", sizeof(message));
} else if (strstr(reply, "?92") != NULL) {
strncpy(message, "Failure while counting", sizeof(message));
} else if (strstr(reply, "?93") != NULL) {
strncpy(message, "Read Failure", sizeof(message));
} else {
if(strstr(reply,"?") != NULL) {
snprintf(message,sizeof(message),"HW error: %s", reply);
if (strstr(reply, "?") != NULL) {
snprintf(message, sizeof(message), "HW error: %s", reply);
}
}
}
} else {
if(errno == EAGAIN){
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);
}
}
if(priv->dbInit){
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);
if (priv->dbInit) {
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);
}
}
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);
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);
if(dbStatus != 0){
errSymLookup(dbStatus,errName,sizeof(errName));
if (priv->dbInit == 1 && priv->sendThreshold) {
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);
} else {
if(myThreshold != priv->thresholdValue){
if (myThreshold != priv->thresholdValue) {
/*
we have to set the threshold
*/
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);
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);
} else {
if(threshCounter == 0){
if (threshCounter == 0) {
threshCounter = 1;
}
sprintf(command,"DL %d %d", (int)threshCounter,
sprintf(command, "DL %d %d", (int)threshCounter,
(int)myThreshold);
// errlogPrintf("Sending threshold command %s\n", command);
status = el737_transactCommand(priv,command,reply);
sprintf(command,"DR %d", (int)threshCounter);
status = el737_transactCommand(priv, command,reply);
if(status == asynSuccess){
status = el737_transactCommand(priv, command, reply);
sprintf(command, "DR %d", (int)threshCounter);
status = el737_transactCommand(priv, command, reply);
if (status == asynSuccess) {
priv->sendThreshold = 0;
priv->thresholdValue = myThreshold;
}
@ -459,36 +458,38 @@ static void runEvents(EL737priv *priv)
}
}
if(priv->sendThreshold == 1) {
// 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],
if (priv->sendThreshold == 1) {
// 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);
status = el737_transactCommand(priv,command,reply);
sprintf(command,"DR %d", (int)priv->presets[THRESHMON]);
status = el737_transactCommand(priv, command,reply);
if(status == asynSuccess) {
// 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);
if (status == asynSuccess) {
priv->sendThreshold = 0;
}
}
}
errlogPrintf("EL737: Doing a count command: %d\n", priv->countCommand);
if(priv->countCommand == 1){
if(priv->presets[MODE] > 0) {
if (priv->countCommand == 1) {
if (priv->presets[MODE] > 0) {
/* preset monitor */
sprintf(command,"MP %d", (int)priv->presets[MONITOR]);
sprintf(command, "MP %d", (int)priv->presets[MONITOR]);
// errlogPrintf("EL737: Starting preset monitor\n");
} else {
/* preset time */
sprintf(command,"TP %f", priv->presets[TIMER]/1000.);
sprintf(command, "TP %f", priv->presets[TIMER] / 1000.);
// errlogPrintf("EL737: Starting preset timer\n");
}
status = el737_transactCommand(priv,command,reply);
status = el737_transactCommand(priv, command, reply);
priv->counting = 1;
} else {
if(priv->counting) {
if (priv->counting) {
/* Stop */
status = sendStop(priv);
} else {
@ -496,45 +497,48 @@ static void runEvents(EL737priv *priv)
}
}
if(status != asynSuccess){
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n, errno =%d",
if (status != asynSuccess) {
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;
long m1, m2 ,m3, m4, m5, m6 ,m7, m8;
long m1, m2, m3, m4, m5, m6, m7, m8;
strcpy(command,"RA");
status = el737_transactCommand(priv,command,reply);
if(status != asynSuccess){
if(errno == EAGAIN){
errlogPrintf("devScalerEL737::el737Thread lost response to %s with EAGAIN\n", command);
strcpy(command, "RA");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
if (errno == EAGAIN) {
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);
return;
}
}
priv->values[0] = (long)(fTime*1000);
priv->values[0] = (long)(fTime * 1000);
priv->values[1] = m1;
priv->values[2] = m2;
priv->values[3] = m3;
@ -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.;
@ -558,16 +560,16 @@ static void el737Thread(void *param)
// errlogPrintf("EL737: Within EL737 thread \n");
while(1){
evStatus = epicsEventWaitWithTimeout(priv->wakeUp,timeout);
while (1) {
evStatus = epicsEventWaitWithTimeout(priv->wakeUp, timeout);
// errlogPrintf("EL737 thread woke up with %d\n", evStatus);
if(evStatus == epicsEventWaitOK) {
if (evStatus == epicsEventWaitOK) {
/*
FEAR: we received a command!!!!
*/
runEvents(priv);
if(priv->counting == 1){
if (priv->counting == 1) {
timeout = .2;
usleep(500);
}
@ -576,74 +578,80 @@ static void el737Thread(void *param)
Just do a poll.....
*/
if(priv->counting && priv->countCommand == 0) {
if (priv->counting && priv->countCommand == 0) {
/* Stop */
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",
if (priv->counting) {
strcpy(command, "RS");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread communication "
"problem %s\n",
priv->asynContext->errorMessage);
continue;
}
sscanf(reply,"%d",&rs);
//errlogPrintf("RS = %d\n", rs);
if(rs == 0) {
sscanf(reply, "%d", &rs);
// errlogPrintf("RS = %d\n", rs);
if (rs == 0) {
priv->counting = 0;
timeout = 60.;
priv->values[9] = 0;
ctStatus = 0;
} else if(rs == 1 || rs == 2){
} else if (rs == 1 || rs == 2) {
/* counting */
priv->values[9] = 1;
ctStatus = 1;
} else if(rs == 5 || rs == 6){
} else if (rs == 5 || rs == 6) {
/* low rate */
priv->values[9] = 2;
ctStatus = 2;
} else if(rs == 9 || rs == 13 || rs == 10 || rs == 14){
} else if (rs == 9 || rs == 13 || rs == 10 || rs == 14) {
/* paused states */
priv->values[9] = 3;
ctStatus = 3;
}
}
if(priv->dbInit){
if (priv->dbInit) {
/*
update the external status field
*/
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);
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);
}
/*
check and handle pause flag
*/
dbStatus = dbGetField(&priv->pause, DBR_LONG,&pauseFlag,&options, &nElements, NULL);
if(dbStatus!= 0){
errSymLookup(dbStatus,errName,sizeof(errName));
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); */
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("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",
priv->asynContext->errorMessage);
continue;
}
} else if(pauseFlag == 0 && ctStatus == 3){
strcpy(command,"CO");
status = el737_transactCommand(priv,command,reply);
if(status != asynSuccess){
errlogPrintf("devScalerEL737::el737Thread communication problem %s\n",
} else if (pauseFlag == 0 && ctStatus == 3) {
strcpy(command, "CO");
status = el737_transactCommand(priv, command, reply);
if (status != asynSuccess) {
errlogPrintf("devScalerEL737::el737Thread "
"communication problem %s\n",
priv->asynContext->errorMessage);
continue;
}
@ -652,10 +660,9 @@ static void el737Thread(void *param)
updateValues(priv);
if(rs == 0){
if (rs == 0) {
callbackRequest(priv->pcallback);
}
}
}
}

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)")