507 lines
15 KiB
C
507 lines
15 KiB
C
/**
|
|
* This is a general purpose adapter between SICS and EPICS. It provides callbacks
|
|
* which allows Hipadaba nodes to be connected to EPICS PV's for both reading and
|
|
* writing.
|
|
*
|
|
* copyright: see file COPYRIGHT
|
|
*
|
|
* Mark Koennecke, October - November 2014
|
|
*/
|
|
#include <assert.h>
|
|
#include <sics.h>
|
|
#include <sicshipadaba.h>
|
|
#undef INLINE /* already defined bz tcl.h, breaks EPICS includes */
|
|
#include <cadef.h>
|
|
#include <epicsMessageQueue.h>
|
|
#include <epicsThread.h>
|
|
#include <messagepipe.h>
|
|
|
|
/*
|
|
One of those: alarmString.h cannot be doubly included into the
|
|
same application
|
|
*/
|
|
#include <alarmString.h>
|
|
/* extern char *epicsAlarmConditionStrings[]; */
|
|
|
|
/*
|
|
* we have a SICS tasks which polls EPICS regularly.
|
|
*/
|
|
static long epicsTaskID = -1L;
|
|
static pMP readPipe = NULL;
|
|
static epicsMessageQueueId writeQueue;
|
|
|
|
|
|
typedef struct {
|
|
char pvname[64];
|
|
int connected;
|
|
pHdb node;
|
|
chid pvchid;
|
|
chtype pvtype;
|
|
}EpicsPriv, *pEpicsPriv;
|
|
|
|
typedef struct {
|
|
SConnection *pCon;
|
|
char message[512];
|
|
} WriteMessage, *pWriteMessage;
|
|
|
|
/*======================================================================================
|
|
Code for reading PV's
|
|
======================================================================================*/
|
|
static int EpicsTask(void *userData)
|
|
{
|
|
pWriteMessage mes;
|
|
|
|
/*
|
|
drive the main EPICS loop for subscriptions
|
|
*/
|
|
ca_poll();
|
|
|
|
/*
|
|
process possible messages from the writing threads
|
|
*/
|
|
if(epicsMessageQueueTryReceive(writeQueue,&mes,sizeof(mes)) > 0){
|
|
if(mes->pCon == NULL){
|
|
traceIO("epics",mes->message);
|
|
} else {
|
|
SCWrite(mes->pCon,mes->message,eError);
|
|
SCDeleteConnection(mes->pCon);
|
|
}
|
|
free(mes);
|
|
}
|
|
return 1;
|
|
}
|
|
/*---------------------------------------------------------------------------------------*/
|
|
static int makeEPICSContext(void *message, void *userData)
|
|
{
|
|
int status;
|
|
pEpicsPriv priv = NULL;
|
|
|
|
if(epicsTaskID < 0){
|
|
status = ca_context_create(ca_disable_preemptive_callback);
|
|
if(status != ECA_NORMAL){
|
|
priv = (pEpicsPriv)message;
|
|
SetHdbProperty(priv->node,"geterror", "Failed to create EPICS context");
|
|
return MPSTOP;
|
|
}
|
|
epicsTaskID = TaskRegisterN(pServ->pTasker,
|
|
"epics",
|
|
EpicsTask,
|
|
NULL,NULL,NULL,TASK_PRIO_MED
|
|
);
|
|
}
|
|
return MPCONTINUE;
|
|
}
|
|
/*--------------------------------------------------------------------------------------*/
|
|
static int epicsConnectPV(void *message, void *userData)
|
|
{
|
|
pEpicsPriv priv = NULL;
|
|
int status;
|
|
|
|
priv = (pEpicsPriv)message;
|
|
|
|
status = ca_create_channel(priv->pvname,NULL,NULL,10,&priv->pvchid);
|
|
if(status != ECA_NORMAL){
|
|
SetHdbProperty(priv->node,"geterror", "Failed to connect to PV");
|
|
return MPSTOP;
|
|
}
|
|
status = ca_pend_io(0.2);
|
|
if(status != ECA_NORMAL){
|
|
SetHdbProperty(priv->node,"geterror", "Timeout connecting to PV");
|
|
return MPSTOP;
|
|
}
|
|
return MPCONTINUE;
|
|
}
|
|
/*--------------------------------------------------------------------------------------*/
|
|
static void epicsDataCallback(struct event_handler_args args)
|
|
{
|
|
pEpicsPriv priv = NULL;
|
|
hdbValue v;
|
|
char error[256];
|
|
|
|
priv = (pEpicsPriv)args.usr;
|
|
|
|
if(args.status == ECA_NORMAL){
|
|
switch(priv->node->value.dataType){
|
|
case HIPTEXT:
|
|
free(priv->node->value.v.text);
|
|
if(args.type == DBR_STRING){
|
|
priv->node->value.v.text = strdup((char *)args.dbr);
|
|
} else if(args.type == DBR_CHAR) {
|
|
priv->node->value.v.text = strndup((char *)args.dbr,args.count);
|
|
}
|
|
break;
|
|
case HIPINT:
|
|
priv->node->value.v.intValue = *(int *)args.dbr;
|
|
break;
|
|
case HIPFLOAT:
|
|
priv->node->value.v.doubleValue = *(double *)args.dbr;
|
|
break;
|
|
case HIPINTAR:
|
|
case HIPINTVARAR:
|
|
v = MakeHdbIntArray(args.count,(int *)args.dbr);
|
|
copyHdbValue(&v,&priv->node->value);
|
|
break;
|
|
case HIPFLOATAR:
|
|
case HIPFLOATVARAR:
|
|
v = MakeHdbFloatArray(args.count,(double *)args.dbr);
|
|
copyHdbValue(&v,&priv->node->value);
|
|
break;
|
|
}
|
|
SetHdbProperty(priv->node,"geterror",NULL);
|
|
traceIO("epics","Received data for %s", priv->node->name);
|
|
NotifyHipadabaPar(priv->node,NULL);
|
|
} else {
|
|
snprintf(error,sizeof(error),"ERROR: %s for node %s", ca_message(args.status), priv->node->name);
|
|
traceIO("epics",error);
|
|
SetHdbProperty(priv->node,"geterror",error);
|
|
}
|
|
}
|
|
/*--------------------------------------------------------------------------------------*/
|
|
static int epicsSubscribePV(void *message, void *userData)
|
|
{
|
|
pEpicsPriv priv = NULL;
|
|
int status;
|
|
chtype subType = DBR_STRING;
|
|
evid eid;
|
|
|
|
priv = (pEpicsPriv)message;
|
|
switch(priv->node->value.dataType){
|
|
case HIPTEXT:
|
|
if(ca_field_type(priv->pvchid) == DBR_CHAR){
|
|
subType = DBR_CHAR;
|
|
} else {
|
|
subType = DBR_STRING;
|
|
}
|
|
break;
|
|
case HIPINT:
|
|
case HIPINTAR:
|
|
case HIPINTVARAR:
|
|
subType = DBR_LONG;
|
|
break;
|
|
case HIPFLOAT:
|
|
case HIPFLOATAR:
|
|
case HIPFLOATVARAR:
|
|
subType = DBR_DOUBLE;
|
|
break;
|
|
}
|
|
|
|
status = ca_create_subscription(subType,0,priv->pvchid,
|
|
DBE_VALUE|DBE_ALARM,epicsDataCallback,priv,&eid);
|
|
if(status != ECA_NORMAL){
|
|
SetHdbProperty(priv->node,"geterror", "Failed to subscribe to PV");
|
|
return MPSTOP;
|
|
}
|
|
|
|
|
|
return MPCONTINUE;
|
|
}
|
|
/*--------------------------------------------------------------------------------------*/
|
|
static void createEPICSReadPipe()
|
|
{
|
|
readPipe = MakeMP();
|
|
AppendMPFilter(readPipe,makeEPICSContext,NULL,NULL);
|
|
AppendMPFilter(readPipe,epicsConnectPV,NULL,NULL);
|
|
AppendMPFilter(readPipe,epicsSubscribePV,NULL,NULL);
|
|
}
|
|
/*--------------------------------------------------------------------------------------*/
|
|
static void connectPV(pHdb node, pEpicsPriv priv)
|
|
{
|
|
int status;
|
|
|
|
SetHdbProperty(node,"geterror", NULL);
|
|
priv->node = node;
|
|
status = MPprocess(readPipe, priv);
|
|
if(status == MPCONTINUE){
|
|
priv->connected = 1;
|
|
}
|
|
}
|
|
/*--------------------------------------------------------------------------------------
|
|
This is the Hipadaba callback function
|
|
--------------------------------------------------------------------------------------*/
|
|
static hdbCallbackReturn EPICSReadCallback(pHdb currentNode,
|
|
void *userData,
|
|
pHdbMessage message)
|
|
{
|
|
pEpicsPriv priv = (pEpicsPriv)userData;
|
|
hdbDataMessage *mm = NULL;
|
|
SConnection *con = NULL;
|
|
char *geterror;
|
|
char error[256];
|
|
enum channel_state cs;
|
|
|
|
assert(priv != NULL);
|
|
|
|
mm = GetHdbGetMessage(message);
|
|
if (mm != NULL) {
|
|
con = mm->callData;
|
|
|
|
if(priv->connected != 1){
|
|
connectPV(currentNode, priv);
|
|
}
|
|
cs = ca_state(priv->pvchid);
|
|
if(cs != cs_conn){
|
|
SCWrite(con,"ERROR: epics disconnected", eError);
|
|
return hdbAbort;
|
|
}
|
|
geterror = GetHdbProp(currentNode, "geterror");
|
|
if (geterror != NULL) {
|
|
snprintf(error,sizeof(error),"ERROR: %s", geterror);
|
|
SCWrite(con, error, eError);
|
|
if (mm->v->dataType == HIPTEXT) {
|
|
if (mm->v->v.text != NULL) {
|
|
free(mm->v->v.text);
|
|
}
|
|
mm->v->v.text = strdup(error);
|
|
}
|
|
return hdbAbort;
|
|
}
|
|
return hdbContinue;
|
|
}
|
|
|
|
return hdbContinue;
|
|
}
|
|
/*------------------------------------------------------------------------------------*/
|
|
static int EpicsConnectRead(pSICSOBJ ccmd, SConnection * con,
|
|
Hdb * cmdNode, Hdb * par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
pEpicsPriv priv = NULL;
|
|
|
|
if(nPar < 2){
|
|
SCWrite(con,"ERROR: need node and PV-name arguments to connectread", eError);
|
|
return 0;
|
|
}
|
|
|
|
node = FindHdbNode(NULL,par[0]->value.v.text,con);
|
|
if(node == NULL){
|
|
SCPrintf(con,eError,"ERROR: failed to locate node %s", par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
|
|
priv = calloc(1,sizeof(EpicsPriv));
|
|
priv->node = node;
|
|
strncpy(priv->pvname,par[1]->value.v.text,sizeof(priv->pvname));
|
|
SetHdbProperty(node,"readpv", par[1]->value.v.text);
|
|
AppendHipadabaCallback(node,MakeHipadabaCallback(EPICSReadCallback, priv,free));
|
|
connectPV(node,priv);
|
|
|
|
SCSendOK(con);
|
|
|
|
return 1;
|
|
}
|
|
/*==============================================================================================
|
|
Writing Things. Writing can block, thus it has to run in its own thread. This raises the
|
|
question how to propagate error messages. The solution is a EPICS message queue to which
|
|
writing threads post. The epics task will read this queue and do the actual printing in the
|
|
SICS main thread. A convention: NULL means to print to trace.
|
|
|
|
================================================================================================*/
|
|
typedef struct {
|
|
SConnection *pCon;
|
|
hdbValue v;
|
|
char pvName[64];
|
|
} WritePar, *pWritePar;
|
|
/*----------------------------------------------------------------------------------------------*/
|
|
static void writeEpicsMessage(void *target, char *txt)
|
|
{
|
|
pWriteMessage wm = NULL;
|
|
|
|
wm = calloc(1,sizeof(WriteMessage));
|
|
if(wm != NULL){
|
|
if(target != NULL){
|
|
wm->pCon = SCCopyConnection(target);
|
|
}
|
|
strncpy(wm->message,txt,sizeof(wm->message));
|
|
epicsMessageQueueSend(writeQueue,&wm,sizeof(pWriteMessage));
|
|
}
|
|
}
|
|
/*----------------------------------------------------------------------------------------------
|
|
To my surprise this is never called. May be, when the thread terminates anyway,
|
|
epics does not know anymore that the callback existed or how to call it.
|
|
------------------------------------------------------------------------------------------------*/
|
|
static void epicsEndCallback(struct event_handler_args args)
|
|
{
|
|
char message[512];
|
|
snprintf(message,sizeof(message),"%s finished with %s", (char *)args.usr,
|
|
ca_message(args.status));
|
|
writeEpicsMessage(NULL,message);
|
|
free(args.usr);
|
|
}
|
|
/*----------------------------------------------------------------------------------------------*/
|
|
static void EpicsWriteFunc(void *param)
|
|
{
|
|
pWritePar wp = (pWritePar)param;
|
|
pWriteMessage wm = NULL;
|
|
int status;
|
|
chid cid;
|
|
char error[512];
|
|
char *pv;
|
|
|
|
status = ca_context_create(ca_disable_preemptive_callback);
|
|
if(status != ECA_NORMAL){
|
|
writeEpicsMessage(wp->pCon,"ERROR: failed to create EPICS context for write");
|
|
goto cleanup;
|
|
}
|
|
status = ca_create_channel(wp->pvName,NULL,NULL,10,&cid);
|
|
if(status != ECA_NORMAL){
|
|
snprintf(error,sizeof(error),"ERROR: failed to create EPICS channel for %s", wp->pvName);
|
|
writeEpicsMessage(wp->pCon,error);
|
|
goto cleanup;
|
|
}
|
|
status = ca_pend_io(0.5);
|
|
if(status != ECA_NORMAL){
|
|
snprintf(error,sizeof(error),"ERROR: failed to connect EPICS channel for %s", wp->pvName);
|
|
writeEpicsMessage(wp->pCon,error);
|
|
goto cleanup;
|
|
}
|
|
|
|
pv = strdup(wp->pvName);
|
|
switch(wp->v.dataType){
|
|
case HIPINT:
|
|
status = ca_put_callback(DBR_LONG,cid,&wp->v.v.intValue,epicsEndCallback,pv);
|
|
break;
|
|
case HIPFLOAT:
|
|
status = ca_put_callback(DBR_DOUBLE,cid,&wp->v.v.doubleValue,epicsEndCallback,pv);
|
|
break;
|
|
case HIPTEXT:
|
|
status = ca_put_callback(DBR_STRING,cid,wp->v.v.text,epicsEndCallback, pv);
|
|
break;
|
|
case HIPINTVARAR:
|
|
case HIPINTAR:
|
|
status = ca_array_put_callback(DBR_LONG,wp->v.arrayLength,
|
|
cid, wp->v.v.intArray,epicsEndCallback,pv);
|
|
break;
|
|
case HIPFLOATVARAR:
|
|
case HIPFLOATAR:
|
|
status = ca_array_put_callback(DBR_DOUBLE,wp->v.arrayLength,
|
|
cid, wp->v.v.floatArray,epicsEndCallback,pv);
|
|
break;
|
|
}
|
|
if(status != ECA_NORMAL){
|
|
snprintf(error,sizeof(error),"ERROR: failed to write to EPICS channel for %s with %d", wp->pvName, status);
|
|
writeEpicsMessage(wp->pCon,error);
|
|
goto cleanup;
|
|
}
|
|
writeEpicsMessage(wp->pCon,"OK");
|
|
snprintf(error,sizeof(error),"Writing data for PV %s", wp->pvName);
|
|
writeEpicsMessage(NULL,error);
|
|
|
|
ca_pend_io(0);
|
|
|
|
goto cleanup;
|
|
cleanup:
|
|
if(wp->pCon != NULL){
|
|
SCDeleteConnection(wp->pCon);
|
|
}
|
|
ReleaseHdbValue(&wp->v);
|
|
free(wp);
|
|
free(pv);
|
|
ca_clear_channel(cid);
|
|
/* ca_context_destroy(); */
|
|
}
|
|
/*----------------------------------------------------------------------------------------------*/
|
|
static hdbCallbackReturn EPICSWriteCallback(pHdb currentNode,
|
|
void *userData,
|
|
pHdbMessage message)
|
|
{
|
|
hdbDataMessage *mm = NULL;
|
|
pWritePar par = NULL;
|
|
|
|
mm = GetHdbSetMessage(message);
|
|
if(mm != NULL){
|
|
par = calloc(1,sizeof(WritePar));
|
|
if(par == NULL){
|
|
SCWrite(mm->callData,"ERROR: out of memory in EPICSWriteCallback", eError);
|
|
return hdbAbort;
|
|
}
|
|
if(mm->callData != NULL){
|
|
par->pCon = SCCopyConnection(mm->callData);
|
|
}
|
|
cloneHdbValue(mm->v,&par->v);
|
|
strncpy(par->pvName,(char *)userData,sizeof(par->pvName));
|
|
epicsThreadCreate("Write",
|
|
epicsThreadPriorityHigh,
|
|
epicsThreadStackMedium,
|
|
EpicsWriteFunc,
|
|
par);
|
|
}
|
|
|
|
return hdbContinue;
|
|
}
|
|
/*------------------------------------------------------------------------------------*/
|
|
static int EpicsConnectWrite(pSICSOBJ ccmd, SConnection * con,
|
|
Hdb * cmdNode, Hdb * par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
pEpicsPriv priv = NULL;
|
|
|
|
if(nPar < 2){
|
|
SCWrite(con,"ERROR: need node and PV-name arguments to connectread", eError);
|
|
return 0;
|
|
}
|
|
|
|
node = FindHdbNode(NULL,par[0]->value.v.text,con);
|
|
if(node == NULL){
|
|
SCPrintf(con,eError,"ERROR: failed to locate node %s", par[0]->value.v.text);
|
|
return 0;
|
|
}
|
|
|
|
SetHdbProperty(node,"writepv", par[1]->value.v.text);
|
|
RemoveSetUpdateCallback(node);
|
|
AppendHipadabaCallback(node,MakeHipadabaCallback(EPICSWriteCallback,
|
|
strdup(par[1]->value.v.text),free));
|
|
|
|
SCSendOK(con);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*==============================================================================================
|
|
SICS Hydraulics
|
|
================================================================================================*/
|
|
static int EpicsConvertAlarm(pSICSOBJ ccmd, SConnection * con,
|
|
Hdb * cmdNode, Hdb * par[], int nPar)
|
|
{
|
|
pHdb node = NULL;
|
|
char value[256];
|
|
|
|
if(nPar < 1){
|
|
SCWrite(con,"ERROR: need alarm code to convert", eError);
|
|
return 0;
|
|
}
|
|
|
|
snprintf(value,sizeof(value),"%s", epicsAlarmConditionStrings[par[0]->value.v.intValue]);
|
|
SCWrite(con,value,eValue);
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------------------------*/
|
|
int MakeEpicsAdapter(SConnection * con, SicsInterp * sics,
|
|
void *object, int argc, char *argv[])
|
|
{
|
|
pSICSOBJ self = NULL;
|
|
pHdb child, par;
|
|
|
|
self = MakeSICSOBJv("epicsadapter", "EpicsAdapter", HIPNONE, usMugger);
|
|
createEPICSReadPipe();
|
|
writeQueue = epicsMessageQueueCreate(64,sizeof(pWriteMessage));
|
|
|
|
child = AddSICSHdbPar(self->objectNode,
|
|
"connectread", usMugger, MakeSICSFunc(EpicsConnectRead));
|
|
AddSICSHdbPar(child, "node", usMugger, MakeHdbText(""));
|
|
AddSICSHdbPar(child, "pvname", usMugger, MakeHdbText(""));
|
|
|
|
child = AddSICSHdbPar(self->objectNode,
|
|
"connectwrite", usMugger, MakeSICSFunc(EpicsConnectWrite));
|
|
AddSICSHdbPar(child, "node", usMugger, MakeHdbText(""));
|
|
AddSICSHdbPar(child, "pvname", usMugger, MakeHdbText(""));
|
|
|
|
child = AddSICSHdbPar(self->objectNode,
|
|
"convertalarm", usSpy, MakeSICSFunc(EpicsConvertAlarm));
|
|
AddSICSHdbPar(child, "stat", usSpy, MakeHdbInt(1.));
|
|
|
|
AddCommand(pServ->pSics, "epicsadapter", InterInvokeSICSOBJ, KillSICSOBJ, self);
|
|
return 1;
|
|
}
|