int
channel_put_callback( Channel *chan, int count, CHANNEL_USERFUNC func, void *arg)
{
int status;
DEBUGP printf("channel_put_callback %s %d %s\n", chan->chan_name, count, chan->valid?"valid":"invalid");
if( !chan->valid)
return -1;
if( count > chan->maxelement)
count = chan->maxelement;
chan->outstanding = 1;
status = ca_array_put_callback( chan->chan_type, count, chan->chan_id, chan->dataval, func, arg);
SEVCHK(status, "channel_put_callback : ca_array_put_callback failed");
ca_flush_io();
return 0;
}
static int PutCmd(Tcl_Interp *interp, pvInfo *info, int objc, Tcl_Obj * const objv[]) {
if (objc != 5 && objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "<value> ?-command <cmdprefix>?");
return TCL_ERROR;
}
int callback = (objc == 5);
Tcl_Obj *value = objv[2];
Tcl_Obj *cmdopt = NULL;
Tcl_Obj *cmdprefix = NULL;
if (callback) {
cmdopt = objv[3];
cmdprefix = objv[4];
/* check that the option is -command */
if (strcmp(Tcl_GetString(cmdopt), "-command") != 0) {
Tcl_SetObjResult(interp, Tcl_NewStringObj("Unknown option, must be -command", -1));
return TCL_ERROR;
}
}
/* Convert value into the EPICS record format */
void *dbr;
chtype puttype;
if (GetEpicsValueFromObj(interp, value, info->type, info->nElem, &puttype, &dbr) != TCL_OK) {
return TCL_ERROR;
}
//printf("Data type %d, native %d\n", (int)puttype, (int)(info->type));
/* Issue put operation */
if (callback) {
putEvent *ev = ckalloc(sizeof(putEvent));
ev->info = info;
ev->putCmdPrefix = cmdprefix;
if (cmdprefix) Tcl_IncrRefCount(ev->putCmdPrefix);
ev->code = TCL_OK;
int code = ca_array_put_callback (puttype, info->nElem, info->id, dbr, putHandler, ev);
CACHECKTCL(ckfree(dbr); Tcl_DecrRefCount(ev->putCmdPrefix); ckfree(ev));
} else {
int main(int argc,char **argv)
{
int status;
double value=1.0;
char *pvname;
double pendEventTime;
int maxTrys = 3;
if(argc!=3) {
printf("usage: testputnotify <pvname> <pendEventTime>\n");
exit(1);
}
pvname = argv[1];
sscanf(argv[2],"%le",&pendEventTime);
SEVCHK(ca_task_initialize(),"ca_task_initialize");
SEVCHK(ca_search(pvname,&mychid),"ca_search_and_connect");
SEVCHK(ca_pend_io(1.0),"ca_pend_io");
while(TRUE) {
SEVCHK(ca_array_put_callback(DBR_DOUBLE,1,mychid,
(void *)&value,putCallback,NULL),
"ca_put_callback");
ntrys=0;
gotCallback=FALSE;
while(!gotCallback && ntrys <=maxTrys) {
status = ca_pend_event(pendEventTime);
if(status!=ECA_NORMAL && status!=ECA_TIMEOUT)
printf("ca_pend_event status=%s\n",ca_message(status));
ntrys++;
if(ntrys==maxTrys) {
printf(" Never got callback\n");
break;
}
}
printf(" number ca_pend_event = %d\n",ntrys);
}
return(0);
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int i,j, k, status,buflen,Cnt, Hndl, L,M,N, NumHandles, commandswitch;
int *HndlArray;
mxArray *mymxArray;
double *myDblPr;
chtype RequestType;
char PVName[PV_NAME_LENGTH_MAX+1];
// char MCAMessageString[MCA_MESSAGE_STRING_LENGTH_MAX+1];
dbr_string_t StrBuffer;
const char *MCAInfoFields[]={"PVName","ElementCount","NativeType","State","MCAMessage","Host"};
char *NativeTypeStrings[] = {"STRING","INT","FLOAT","ENUM","CHAR","LONG","DOUBLE"};
if(!CA_INITIALIZED) // Initialize CA if not initialized (first call)
{ mexPrintf("Initializing MATLAB Channel Access ... \n");
status = ca_task_initialize();
if(status!=ECA_NORMAL)
mexErrMsgTxt("Unable to initialise Challel Access\n");
CA_INITIALIZED = true;
// Register a function to be called when a this mex-file is cleared from memory
// with 'clear' or when exitting MATLAB
mexAtExit(mca_cleanup);
// Lock the mex-file so that it can not be cleared without explicitly
// mexUnclock
mexLock();
//start periodic polling:
/* PollTimerHandle = SetTimer(NULL,NULL,MCA_POLL_PERIOD,background_poll);
if(PollTimerHandle)
mexPrintf("Periodic CA polling started! System Timer ID: %u\n",PollTimerHandle);
else
mexWarnMsgTxt("Failed to start periodic CA polling\n");
*/
}
commandswitch = (int)mxGetScalar(prhs[0]);
switch(commandswitch)
{ case 0:
mexUnlock();
break;
case 1: // MCAOPEN - add channel(s) by PV names, all arguments following prhs[0]
// must be strings - names of PV's
for(i=1;i<nrhs;i++)
{ mxGetString(prhs[i],PVName,PV_NAME_LENGTH_MAX+1);
status = ca_search(PVName,&(CHNLS[HandlesUsed].CHID));
if(status == ECA_NORMAL) // if not - go on to the next PV name
{ status = ca_pend_io(MCA_SEARCH_TIMEOUT);
if (status == ECA_NORMAL)
{ // Allocate persistent memory for the DataBuffer on this channel
// to hold all elements of the DBR_XXX type
// nearest to the native type
// RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[HandlesUsed].CHID));
// Cnt=ca_element_count(CHNLS[HandlesUsed].CHID);
CHNLS[HandlesUsed].NumElements = ca_element_count(CHNLS[HandlesUsed].CHID);
CHNLS[HandlesUsed].NativeType2DBR = dbf_type_to_DBR(ca_field_type(CHNLS[HandlesUsed].CHID));
CHNLS[HandlesUsed].MonitorEventCount = 0;
switch(CHNLS[HandlesUsed].NativeType2DBR)
{ case DBR_STRING:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_string_t));
break;
case DBR_INT: // As defined in db_access.h DBR_INT = DBR_SHORT = 1
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_short_t));
break;
case DBR_FLOAT:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_float_t));
break;
case DBR_ENUM:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_enum_t));
break;
case DBR_CHAR:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_char_t));
break;
case DBR_LONG:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_short_t));
break;
case DBR_DOUBLE:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_double_t));
break;
}
mexMakeMemoryPersistent(CHNLS[HandlesUsed].DataBuffer);
if(CHNLS[HandlesUsed].NativeType2DBR==DBR_STRING) // CACHE
{ if(CHNLS[HandlesUsed].NumElements==1) // Create MATLAB string - originally empty
CHNLS[HandlesUsed].CACHE = mxCreateString("");
else // Create MATLAB cell array of strings
{ CHNLS[HandlesUsed].CACHE = mxCreateCellMatrix(1,CHNLS[HandlesUsed].NumElements);
for(k=0;k<CHNLS[HandlesUsed].NumElements;k++)
{ mymxArray = mxCreateString("");
mexMakeArrayPersistent(mymxArray);
mxSetCell(CHNLS[HandlesUsed].CACHE, k, mymxArray);
}
}
}
else // Make CACHE a numeric mxArray
{ CHNLS[HandlesUsed].CACHE = mxCreateDoubleMatrix(1,CHNLS[HandlesUsed].NumElements,mxREAL);
}
mexMakeArrayPersistent(CHNLS[HandlesUsed].CACHE);
plhs[i-1]=mxCreateScalarDouble(++HandlesUsed);
}
else
plhs[i-1]=mxCreateScalarDouble(0);
}
else
plhs[i-1]=mxCreateScalarDouble(0);
} break;
case 2:// MCAOPEN - add channel(s) by PV names. The arguments following prhs[0]
// argument must be a cell array of strings - PV names
L = mxGetM(prhs[1])*mxGetN(prhs[1]);
plhs[0] = mxCreateDoubleMatrix(1,L,mxREAL);
myDblPr = mxGetPr(plhs[0]);
for(i=0;i<L;i++)
{ mymxArray = mxGetCell(prhs[1],i);
mxGetString(mymxArray,PVName,PV_NAME_LENGTH_MAX+1);
status = ca_search(PVName,&(CHNLS[HandlesUsed].CHID));
if(status == ECA_NORMAL) // if not - go on to the next PV name
{ status = ca_pend_io(MCA_IO_TIMEOUT);
if (status == ECA_NORMAL)
{ // Allcate persistent memory for the DataBuffer on this channel
//RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[HandlesUsed].CHID));
CHNLS[HandlesUsed].NativeType2DBR = dbf_type_to_DBR(ca_field_type(CHNLS[HandlesUsed].CHID));
CHNLS[HandlesUsed].NumElements = ca_element_count(CHNLS[HandlesUsed].CHID);
CHNLS[HandlesUsed].MonitorEventCount = 0;
//Cnt=ca_element_count(CHNLS[HandlesUsed].CHID);
switch(CHNLS[HandlesUsed].NativeType2DBR)
{ case DBR_STRING:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_string_t));
break;
case DBR_INT: // As defined in db_access.h DBR_INT = DBR_SHORT = 1
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_short_t));
break;
case DBR_FLOAT:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_float_t));
break;
case DBR_ENUM:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_enum_t));
break;
case DBR_CHAR:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_char_t));
break;
case DBR_LONG:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_short_t));
break;
case DBR_DOUBLE:
CHNLS[HandlesUsed].DataBuffer = mxCalloc(CHNLS[HandlesUsed].NumElements,sizeof(dbr_double_t));
break;
}
mexMakeMemoryPersistent(CHNLS[HandlesUsed].DataBuffer);
if(CHNLS[HandlesUsed].NativeType2DBR == DBR_STRING) // CACHE
{ CHNLS[HandlesUsed].CACHE = mxCreateCellMatrix(1,CHNLS[HandlesUsed].NumElements);
for(k=0;k<CHNLS[HandlesUsed].NumElements;k++)
{ mymxArray = mxCreateString(StrBuffer);
mexMakeArrayPersistent(mymxArray);
mxSetCell(CHNLS[HandlesUsed].CACHE, k, mymxArray);
}
}
else
{ CHNLS[HandlesUsed].CACHE = mxCreateDoubleMatrix(1,CHNLS[HandlesUsed].NumElements,mxREAL);
}
mexMakeArrayPersistent(CHNLS[HandlesUsed].CACHE);
myDblPr[i] = ++HandlesUsed;
}
else
myDblPr[i] = 0;
}
else
myDblPr[i] = 0;
} break;
case 3: // MCAOPEN Return names of connected channels as cell array of strings
plhs[0] = mxCreateCellArray(1, &HandlesUsed);
for(i=0;i<HandlesUsed;i++)
{ if(CHNLS[i].CHID!=NULL)
{ mymxArray = mxCreateString(ca_name(CHNLS[i].CHID));
mxSetCell(plhs[0], i, mymxArray);
}
else
{ mymxArray = mxCreateString("");
//mexPrintf("Handle: %d PV: %s\n",i+1, "Cleared Channel");
mxSetCell(plhs[0], i, mymxArray);
}
} break;
case 5: // MCACLOSE permanently clear channel
Hndl = (int)mxGetScalar(prhs[1]);
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Handle out of range");
// If a monitor is installed, set the EVID pointer to NULL
// ca_clear_event dos not do it by itself
if(CHNLS[Hndl-1].EVID)
CHNLS[Hndl-1].EVID = NULL;
// If there is Callback String - destroy it
if(CHNLS[Hndl-1].MonitorCBString)
{ mxFree(CHNLS[Hndl-1].MonitorCBString);
CHNLS[Hndl-1].MonitorCBString =NULL;
}
if(ca_state(CHNLS[Hndl-1].CHID)==3)
mexWarnMsgTxt("Channel previously cleared");
else
if(ca_clear_channel(CHNLS[Hndl-1].CHID)!=ECA_NORMAL)
mexErrMsgTxt("ca_clear_channel failed");
break;
case 10: // MCAINFO return channels info as MATLAB structure array
if(HandlesUsed>0)
{ plhs[0] = mxCreateStructMatrix(1,HandlesUsed,6,MCAInfoFields);
for(i=0;i<HandlesUsed;i++)
{ mxSetFieldByNumber(plhs[0],i,0,mxCreateString(ca_name(CHNLS[i].CHID)));
mxSetFieldByNumber(plhs[0],i,1,mxCreateScalarDouble(ca_element_count(CHNLS[i].CHID)));
mxSetFieldByNumber(plhs[0],i,5,mxCreateString(ca_host_name(CHNLS[i].CHID)));
switch(ca_state(CHNLS[i].CHID))
{ case 1: // Disconnected due to Server or Network - may reconnect
mxSetFieldByNumber(plhs[0],i,2,mxCreateString("unknown"));
mxSetFieldByNumber(plhs[0],i,3,mxCreateString("disconnected"));
mxSetFieldByNumber(plhs[0],i,4,mxCreateString("Disconnected due to server or network problem"));
break;
case 2: // Normal connection
mxSetFieldByNumber(plhs[0],i,2,mxCreateString(NativeTypeStrings[ca_field_type(CHNLS[i].CHID)]));
mxSetFieldByNumber(plhs[0],i,3,mxCreateString("connected"));
mxSetFieldByNumber(plhs[0],i,4,mxCreateString("Normal connection"));
break;
case 3: // Disconnected by user
mxSetFieldByNumber(plhs[0],i,2,mxCreateString("unknown"));
mxSetFieldByNumber(plhs[0],i,3,mxCreateString("disconnected"));
mxSetFieldByNumber(plhs[0],i,4,mxCreateString("Permanently disconnected (cleared) by the user"));
break;
}
}
}
else
{ mexWarnMsgTxt("No connected PV's found");
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
break;
case 11: // MCAINFO return info for 1 channel by handle number
Hndl = (int)mxGetScalar(prhs[1]);
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Handle out of range");
plhs[0] = mxCreateStructMatrix(1,1,6,MCAInfoFields);
mxSetFieldByNumber(plhs[0],0,0,mxCreateString(ca_name(CHNLS[Hndl-1].CHID)));
mxSetFieldByNumber(plhs[0],0,1,mxCreateScalarDouble(ca_element_count(CHNLS[Hndl-1].CHID)));
mxSetFieldByNumber(plhs[0],0,5,mxCreateString(ca_host_name(CHNLS[Hndl-1].CHID)));
switch(ca_state(CHNLS[Hndl-1].CHID))
{ case 1: // Disconnected due to Server or Network - may reconnect
mxSetFieldByNumber(plhs[0],0,2,mxCreateString("unknown"));
mxSetFieldByNumber(plhs[0],0,3,mxCreateString("disconnected"));
mxSetFieldByNumber(plhs[0],0,4,mxCreateString("Disconnected due to server or network problem"));
break;
case 2: // Normal connection
mxSetFieldByNumber(plhs[0],0,2,mxCreateString(NativeTypeStrings[ca_field_type(CHNLS[Hndl-1].CHID)]));
mxSetFieldByNumber(plhs[0],0,3,mxCreateString("connected"));
mxSetFieldByNumber(plhs[0],0,4,mxCreateString("Normal connection"));
break;
case 3: // Disconnected by user
mxSetFieldByNumber(plhs[0],0,2,mxCreateString("unknown"));
mxSetFieldByNumber(plhs[0],0,3,mxCreateString("disconnected"));
mxSetFieldByNumber(plhs[0],0,4,mxCreateString("Permanently disconnected (cleared) by the user"));
break;
};
break;
case 12: // MCASTATE return an array of status (1 - OK, 0 - disconnected or cleared)
if(HandlesUsed>0)
{ plhs[0] = mxCreateDoubleMatrix(1,HandlesUsed,mxREAL);
myDblPr = mxGetPr(plhs[0]);
for(i=0;i<HandlesUsed;i++)
myDblPr[i] = (double)(ca_state(CHNLS[i].CHID)==2);
}
else
{ mexWarnMsgTxt("No connected PV's found");
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
break;
case 30: // poll
ca_poll();
break;
case 50: // MCAGET Get PV values by their MCA handles
for(i=0;i<nrhs-1;i++) // First loop: place all ca_get requests in the buffer
{ Hndl = (int)mxGetScalar(prhs[1+i]); //start from[1]: [0] argument is the commnads switch
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Invalid Handle");
RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID));
Cnt = ca_element_count(CHNLS[Hndl-1].CHID);
status = ca_array_get(RequestType,Cnt,CHNLS[Hndl-1].CHID,CHNLS[Hndl-1].DataBuffer);
if(status!=ECA_NORMAL)
mexPrintf("Error in call to ca_array_get\n");
}
status = ca_pend_io(MCA_GET_TIMEOUT);
if(status!=ECA_NORMAL)
mexErrMsgTxt("... ca_pend_io call timed out \n");
for(i=0;i<nrhs-1;i++) // Another loop to copy data from temp structures to MATLAB
{ Hndl = (int)mxGetScalar(prhs[1+i]);
RequestType = RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID));
Cnt = ca_element_count(CHNLS[Hndl-1].CHID);
if(RequestType==DBR_STRING)
{ if(Cnt==1)
plhs[i] = mxCreateString((char*)(*((dbr_string_t*)(CHNLS[Hndl-1].DataBuffer))));
else
{ plhs[i] = mxCreateCellMatrix(1,Cnt);
for(j=0;j<Cnt;j++)
mxSetCell(plhs[i], j, mxCreateString((char*)(*((dbr_string_t*)(CHNLS[Hndl-1].DataBuffer)+j))));
}
}
else
{ plhs[i] = mxCreateDoubleMatrix(1,Cnt,mxREAL);
myDblPr = mxGetPr(plhs[i]);
switch(dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID)))
{ case DBR_INT: // As defined in db_access.h DBR_INT = DBR_SHORT = 1
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_short_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
case DBR_FLOAT:
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_float_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
case DBR_ENUM:
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_enum_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
case DBR_CHAR:
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_char_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
case DBR_LONG:
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_long_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
case DBR_DOUBLE:
for(j=0;j<Cnt;j++)
myDblPr[j]= (double)(*((dbr_double_t*)(CHNLS[Hndl-1].DataBuffer)+j));
break;
}
}
} break;
case 51: // MCAGET Get scalar PV of the same type
// second argument is an array of handles
// returns an array of values
myDblPr = mxGetPr(prhs[1]);
M = mxGetM(prhs[1]);
N = mxGetN(prhs[1]);
NumHandles = M*N;
plhs[0] = mxCreateDoubleMatrix(M,N,mxREAL);
for(i=0;i<NumHandles;i++) // First loop: place all ca_get requests in the buffer
{ Hndl = (int)myDblPr[i];
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Invalid Handle");
RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID));
status = ca_array_get(DBR_DOUBLE,1,CHNLS[Hndl-1].CHID,mxGetPr(plhs[0])+i);
if(status!=ECA_NORMAL)
mexPrintf("Error in call to ca_array_get\n");
}
status = ca_pend_io(MCA_GET_TIMEOUT);
if(status!=ECA_NORMAL)
mexErrMsgTxt("... ca_pend_io call timed out \n");
break;
case 70: // MCAPUT
NumHandles = (nrhs-1)/2;
for(i=0;i<NumHandles;i++)
{ j = 2+i*2;
Hndl = (int)mxGetScalar(prhs[1+i*2]);
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Handle out of range - no values written");
// Set the status to 0 - mcaput_callback will write 1, if successful
CHNLS[Hndl-1].LastPutStatus = 0;
RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID));
Cnt = ca_element_count(CHNLS[Hndl-1].CHID);
// If a value to write is passed as a string - the number of elements to write
// is 1 , NOT the length of the string returned by mxGetNumberOfElements
if(mxIsChar(prhs[j]))
L=1;
else
L = min(mxGetNumberOfElements(prhs[j]),Cnt);
// Copy double or string data from MATLAB prhs[] to DataBuffer
// on each channel
if(RequestType==DBR_STRING)
{ // STRING type is is passed as a cell array of strings
// A a 1-row MATLAB character array (1 string) may also be passed as a value
if(mxIsChar(prhs[j]))
{ mxGetString(prhs[j], StrBuffer, sizeof(dbr_string_t));
strcpy((char*)(*((dbr_string_t*)(CHNLS[Hndl-1].DataBuffer))),StrBuffer);
}
else if(mxIsCell(prhs[j]))
{ for(k=0;k<L;k++)
{ mxGetString(mxGetCell(prhs[j],k), StrBuffer, sizeof(dbr_string_t));
strcpy((char*)(*((dbr_string_t*)(CHNLS[Hndl-1].DataBuffer)+k)),StrBuffer);
}
}
}
else
{ myDblPr = mxGetPr(prhs[j]);
switch(RequestType)
{
case DBR_INT: // As defined in db_access.h DBR_INT = DBR_SHORT = 1
for(k=0;k<L;k++)
*((dbr_short_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_short_t)(myDblPr[k]);
break;
case DBR_FLOAT:
for(k=0;k<L;k++)
*((dbr_float_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_float_t)(myDblPr[k]);
break;
case DBR_ENUM:
for(k=0;k<L;k++)
*((dbr_enum_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_enum_t)(myDblPr[k]);
break;
case DBR_CHAR:
for(k=0;k<L;k++)
*((dbr_char_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_char_t)(myDblPr[k]);
break;
case DBR_LONG:
for(k=0;k<L;k++)
*((dbr_long_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_long_t)(myDblPr[k]);
break;
case DBR_DOUBLE:
for(k=0;k<L;k++)
*((dbr_double_t*)(CHNLS[Hndl-1].DataBuffer)+k) = (dbr_double_t)(myDblPr[k]);
break;
}
}
// place request in the que
status = ca_array_put_callback(RequestType,L,CHNLS[Hndl-1].CHID,CHNLS[Hndl-1].DataBuffer,
mcaput_callback,&(CHNLS[Hndl-1].LastPutStatus));
if(status!=ECA_NORMAL)
mexPrintf("ca_array_put_callback failed\n");
}
status = ca_pend_event(MCA_PUT_TIMEOUT);
plhs[0]=mxCreateDoubleMatrix(1,NumHandles,mxREAL);
myDblPr = mxGetPr(plhs[0]);
for(i=0;i<NumHandles;i++)
{ Hndl = (int)mxGetScalar(prhs[1+i*2]);
myDblPr[i] = (double)CHNLS[Hndl-1].LastPutStatus;
}
break;
case 80: // MCAPUT - fast unconfirmed put for scalar numeric PV's
myDblPr = mxGetPr(prhs[1]);
M = mxGetM(prhs[1]);
N = mxGetN(prhs[1]);
NumHandles = M*N;
plhs[0] = mxCreateDoubleMatrix(M,N,mxREAL);
myDblPr = mxGetPr(plhs[0]);
for(i=0;i<NumHandles;i++)
{ myDblPr = mxGetPr(plhs[0]);
Hndl = (int)(*(mxGetPr(prhs[1])+i));
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Handle out of range - no values written");
status = ca_array_put(DBR_DOUBLE,1,CHNLS[Hndl-1].CHID,mxGetPr(prhs[2])+i);
if(status!=ECA_NORMAL)
{ myDblPr[i] = 0;
//mexPrintf("ca_array_put_callback failed\n");
}
else
{ myDblPr[i] = 1;
}
}
status = ca_pend_io(MCA_PUT_TIMEOUT);
break;
case 100: // MCAMON install Monitor or replace MonitorCBString
Hndl = (int)mxGetScalar(prhs[1]);
// Check if the handle is within range
if(Hndl<1 || Hndl>HandlesUsed)
{ plhs[0]=mxCreateScalarDouble(0);
mexErrMsgTxt("Invalid Handle");
}
if(CHNLS[Hndl-1].EVID) // if VID is not NULL - another monitor is already installed - replace MonitorCBString
{ if(CHNLS[Hndl-1].MonitorCBString) // Free memory for occupied by the old MonitorCBString
{ mxFree(CHNLS[Hndl-1].MonitorCBString);
CHNLS[Hndl-1].MonitorCBString = NULL;
}
if(nrhs>2) // Check if the new string is specified
{ if(mxIsChar(prhs[2]))
{ buflen = mxGetM(prhs[2])*mxGetN(prhs[2])+1;
CHNLS[Hndl-1].MonitorCBString = (char *)mxMalloc(buflen);
mexMakeMemoryPersistent(CHNLS[Hndl-1].MonitorCBString);
mxGetString(prhs[2],CHNLS[Hndl-1].MonitorCBString,buflen);
}
else
mexErrMsgTxt("Third argument must be a string\n");
}
plhs[0]=mxCreateScalarDouble(1);
}
else // No monitor is presently installed;
{ RequestType = dbf_type_to_DBR(ca_field_type(CHNLS[Hndl-1].CHID)); // Closest to the native
if(nrhs>2)
{ if(mxIsChar(prhs[2]))
{ buflen = mxGetM(prhs[2])*mxGetN(prhs[2])+1;
CHNLS[Hndl-1].MonitorCBString = (char *)mxMalloc(buflen);
mexMakeMemoryPersistent(CHNLS[Hndl-1].MonitorCBString);
mxGetString(prhs[2],CHNLS[Hndl-1].MonitorCBString,buflen);
}
else
mexErrMsgTxt("Third argument must be a string\n");
}
else
CHNLS[Hndl-1].MonitorCBString = NULL; // Set MonitorCBString to NULL so that mcaMonitorEventHandler only copies data to CACHE
// Count argument set to 0 - native count
status = ca_add_array_event(RequestType,0,CHNLS[Hndl-1].CHID, mcaMonitorEventHandler, &CHNLS[Hndl-1], 0.0, 0.0, 0.0, &(CHNLS[Hndl-1].EVID));
if(status!=ECA_NORMAL)
{ mexPrintf("ca_add_array_event failed\n");
plhs[0]=mxCreateScalarDouble(0);
}
else
{ ca_poll();
plhs[0]=mxCreateScalarDouble(1);
}
}
break;
case 200: // Clear Monitor MCACLEARMON
Hndl = (int)mxGetScalar(prhs[1]);
if(Hndl<1 || Hndl>HandlesUsed)
mexErrMsgTxt("Invalid Handle");
if(!CHNLS[Hndl-1].EVID)
mexErrMsgTxt("No monitor installed - can not clear");
status = ca_clear_event(CHNLS[Hndl-1].EVID);
if(status!=ECA_NORMAL)
mexPrintf("ca_clear_event failed\n");
// Set the EVID pointer to NULL (ca_clear_event dos not do it by itself)
// to use as a FLAG that no monitors are installed
CHNLS[Hndl-1].EVID = NULL;
// Reset
CHNLS[Hndl-1].MonitorEventCount = 0;
// If there is Callback String - destroy it
if(CHNLS[Hndl-1].MonitorCBString)
{ mxFree(CHNLS[Hndl-1].MonitorCBString);
CHNLS[Hndl-1].MonitorCBString =NULL;
}
break;
case 300: // MCACACHE Get Cached values of a monitored PV
for(i=0;i<nrhs-1;i++)
{ Hndl = (int)mxGetScalar(prhs[1+i]);
// if(Hndl<1 || Hndl>HandlesUsed || !CHNLS[Hndl-1].CACHE)
if(Hndl<1 || Hndl>HandlesUsed)
plhs[i] = mxCreateDoubleMatrix(0,0,mxREAL);
else
{ plhs[i] = mxDuplicateArray(CHNLS[Hndl-1].CACHE);
CHNLS[Hndl-1].MonitorEventCount = 0;
}
}
break;
case 500: // MCAMON Info on installed monitors
L = 0;
HndlArray = (int*)mxCalloc(HandlesUsed,sizeof(int));
for(i=0;i<HandlesUsed;i++) // Count installed monitors
{ if(CHNLS[i].EVID)
HndlArray[L++]=i+1;
}
if(L>0)
{ plhs[0] = mxCreateDoubleMatrix(1,L,mxREAL);
myDblPr = mxGetPr(plhs[0]);
plhs[1] = mxCreateCellMatrix(1,L);
for(i=0;i<L;i++)
{ myDblPr[i] = (double)HndlArray[i];
mxSetCell(plhs[1],i,mxCreateString(CHNLS[HndlArray[i]-1].MonitorCBString));
}
}
else
{ plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
plhs[1] = mxCreateCellMatrix(0,0);
}
break;
case 510: // MCAMONEVENTS Event count fot monitors
plhs[0] = mxCreateDoubleMatrix(1,HandlesUsed,mxREAL);
myDblPr = mxGetPr(plhs[0]);
for(i=0;i<HandlesUsed;i++)
myDblPr[i]=(double)(CHNLS[i].MonitorEventCount);
break;
case 1000: // print timeout settings
plhs[0] = mxCreateDoubleMatrix(3,1,mxREAL);
mexPrintf("MCA timeout settings\n:");
mexPrintf("mcaopen\t%f [s]\n", MCA_SEARCH_TIMEOUT );
mexPrintf("mcaget\t%f [s]\n", MCA_GET_TIMEOUT );
mexPrintf("mcaput\t%f [s]\n", MCA_PUT_TIMEOUT );
myDblPr = mxGetPr(plhs[0]);
myDblPr[0] = MCA_SEARCH_TIMEOUT;
myDblPr[1] = MCA_GET_TIMEOUT;
myDblPr[2] = MCA_PUT_TIMEOUT;
break;
case 1001: // set MCA_SEARCH_TIMEOUT
// return delay value
MCA_SEARCH_TIMEOUT = mxGetScalar(prhs[1]);
plhs[0] = mxCreateScalarDouble(MCA_SEARCH_TIMEOUT);
break;
case 1002: // set MCA_GET_TIMEOUT
// return delay value
MCA_GET_TIMEOUT = mxGetScalar(prhs[1]);
plhs[0] = mxCreateScalarDouble(MCA_GET_TIMEOUT);
break;
case 1003: // set MCA_PUT_TIMEOUT
// return delay value
MCA_PUT_TIMEOUT = mxGetScalar(prhs[1]);
plhs[0] = mxCreateScalarDouble(MCA_PUT_TIMEOUT);
break;
}
}
int main (int argc, char *argv[])
{
int i;
int result; /* CA result */
OutputT format = plain; /* User specified format */
RequestT request = get; /* User specified request type */
int isArray = 0; /* Flag for array operation */
int enumAsString = 0; /* Force ENUM values to be strings */
int count = 1;
int opt; /* getopt() current option */
chtype dbrType = DBR_STRING;
char *pend;
EpicsStr *sbuf;
double *dbuf;
char *cbuf = 0;
char *ebuf = 0;
void *pbuf;
int len = 0;
int waitStatus;
struct dbr_gr_enum bufGrEnum;
int nPvs; /* Number of PVs */
pv* pvs; /* Array of PV structures */
LINE_BUFFER(stdout); /* Configure stdout buffering */
putenv("POSIXLY_CORRECT="); /* Behave correct on GNU getopt systems */
while ((opt = getopt(argc, argv, ":cnlhatsS#:w:p:F:")) != -1) {
switch (opt) {
case 'h': /* Print usage */
usage();
return 0;
case 'n': /* Force interpret ENUM as index number */
enumAsNr = 1;
enumAsString = 0;
break;
case 's': /* Force interpret ENUM as menu string */
enumAsString = 1;
enumAsNr = 0;
break;
case 'S': /* Treat char array as (long) string */
charArrAsStr = 1;
isArray = 0;
break;
case 't': /* Select terse output format */
format = terse;
break;
case 'l': /* Select long output format */
format = all;
break;
case 'a': /* Select array mode */
isArray = 1;
charArrAsStr = 0;
break;
case 'c': /* Select put_callback mode */
request = callback;
break;
case 'w': /* Set CA timeout value */
if(epicsScanDouble(optarg, &caTimeout) != 1)
{
fprintf(stderr, "'%s' is not a valid timeout value "
"- ignored. ('caput -h' for help.)\n", optarg);
caTimeout = DEFAULT_TIMEOUT;
}
break;
case '#': /* Array count */
if (sscanf(optarg,"%d", &count) != 1)
{
fprintf(stderr, "'%s' is not a valid array element count "
"- ignored. ('caput -h' for help.)\n", optarg);
count = 0;
}
break;
case 'p': /* CA priority */
if (sscanf(optarg,"%u", &caPriority) != 1)
{
fprintf(stderr, "'%s' is not a valid CA priority "
"- ignored. ('caget -h' for help.)\n", optarg);
caPriority = DEFAULT_CA_PRIORITY;
}
if (caPriority > CA_PRIORITY_MAX) caPriority = CA_PRIORITY_MAX;
break;
case 'F': /* Store this for output and tool_lib formatting */
fieldSeparator = (char) *optarg;
break;
case '?':
fprintf(stderr,
"Unrecognized option: '-%c'. ('caput -h' for help.)\n",
optopt);
return 1;
case ':':
fprintf(stderr,
"Option '-%c' requires an argument. ('caput -h' for help.)\n",
optopt);
return 1;
default :
usage();
return 1;
}
}
nPvs = argc - optind; /* Remaining arg list are PV names and values */
if (nPvs < 1) {
fprintf(stderr, "No pv name specified. ('caput -h' for help.)\n");
return 1;
}
if (nPvs == 1) {
fprintf(stderr, "No value specified. ('caput -h' for help.)\n");
return 1;
}
nPvs = 1; /* One PV - the rest is value(s) */
epId = epicsEventCreate(epicsEventEmpty); /* Create empty EPICS event (semaphore) */
/* Start up Channel Access */
result = ca_context_create(ca_enable_preemptive_callback);
if (result != ECA_NORMAL) {
fprintf(stderr, "CA error %s occurred while trying "
"to start channel access.\n", ca_message(result));
return 1;
}
/* Allocate PV structure array */
pvs = calloc (nPvs, sizeof(pv));
if (!pvs) {
fprintf(stderr, "Memory allocation for channel structure failed.\n");
return 1;
}
/* Connect channels */
pvs[0].name = argv[optind] ; /* Copy PV name from command line */
result = connect_pvs(pvs, nPvs); /* If the connection fails, we're done */
if (result) {
ca_context_destroy();
return result;
}
/* Get values from command line */
optind++;
if (isArray) {
optind++; /* In case of array skip first value (nr
* of elements) - actual number of values is used */
count = argc - optind;
} else { /* Concatenate the remaining line to one string
* (sucks but is compatible to the former version) */
for (i = optind; i < argc; i++) {
len += strlen(argv[i]);
len++;
}
cbuf = calloc(len, sizeof(char));
if (!cbuf) {
fprintf(stderr, "Memory allocation failed.\n");
return 1;
}
strcpy(cbuf, argv[optind]);
if (argc > optind+1) {
for (i = optind + 1; i < argc; i++) {
strcat(cbuf, " ");
strcat(cbuf, argv[i]);
}
}
if ((argc - optind) >= 1)
count = 1;
argv[optind] = cbuf;
}
sbuf = calloc (count, sizeof(EpicsStr));
dbuf = calloc (count, sizeof(double));
if(!sbuf || !dbuf) {
fprintf(stderr, "Memory allocation failed\n");
return 1;
}
/* ENUM? Special treatment */
if (ca_field_type(pvs[0].chid) == DBR_ENUM) {
/* Get the ENUM strings */
result = ca_array_get (DBR_GR_ENUM, 1, pvs[0].chid, &bufGrEnum);
result = ca_pend_io(caTimeout);
if (result == ECA_TIMEOUT) {
fprintf(stderr, "Read operation timed out: ENUM data was not read.\n");
return 1;
}
if (enumAsNr) { /* Interpret values as numbers */
for (i = 0; i < count; ++i) {
dbuf[i] = epicsStrtod(*(argv+optind+i), &pend);
if (*(argv+optind+i) == pend) { /* Conversion didn't work */
fprintf(stderr, "Enum index value '%s' is not a number.\n",
*(argv+optind+i));
return 1;
}
if (dbuf[i] >= bufGrEnum.no_str) {
fprintf(stderr, "Warning: enum index value '%s' may be too large.\n",
*(argv+optind+i));
}
}
dbrType = DBR_DOUBLE;
} else { /* Interpret values as strings */
for (i = 0; i < count; ++i) {
epicsStrnRawFromEscaped(sbuf[i], sizeof(EpicsStr), *(argv+optind+i), sizeof(EpicsStr));
*( sbuf[i]+sizeof(EpicsStr)-1 ) = '\0';
dbrType = DBR_STRING;
/* Compare to ENUM strings */
for (len = 0; len < bufGrEnum.no_str; len++)
if (!strcmp(sbuf[i], bufGrEnum.strs[len]))
break;
if (len >= bufGrEnum.no_str) {
/* Not a string? Try as number */
dbuf[i] = epicsStrtod(sbuf[i], &pend);
if (sbuf[i] == pend || enumAsString) {
fprintf(stderr, "Enum string value '%s' invalid.\n", sbuf[i]);
return 1;
}
if (dbuf[i] >= bufGrEnum.no_str) {
fprintf(stderr, "Warning: enum index value '%s' may be too large.\n", sbuf[i]);
}
dbrType = DBR_DOUBLE;
}
}
}
} else { /* Not an ENUM */
if (charArrAsStr) {
dbrType = DBR_CHAR;
ebuf = calloc(len, sizeof(char));
if(!ebuf) {
fprintf(stderr, "Memory allocation failed\n");
return 1;
}
count = epicsStrnRawFromEscaped(ebuf, len, cbuf, len-1) + 1;
} else {
for (i = 0; i < count; ++i) {
epicsStrnRawFromEscaped(sbuf[i], sizeof(EpicsStr), *(argv+optind+i), sizeof(EpicsStr));
*( sbuf[i]+sizeof(EpicsStr)-1 ) = '\0';
}
dbrType = DBR_STRING;
}
}
/* Read and print old data */
if (format != terse) {
printf("Old : ");
result = caget(pvs, nPvs, format, 0, 0);
}
/* Write new data */
if (dbrType == DBR_STRING) pbuf = sbuf;
else if (dbrType == DBR_CHAR) pbuf = ebuf;
else pbuf = dbuf;
if (request == callback) {
/* Use callback version of put */
pvs[0].status = ECA_NORMAL; /* All ok at the moment */
result = ca_array_put_callback (
dbrType, count, pvs[0].chid, pbuf, put_event_handler, (void *) pvs);
} else {
/* Use standard put with defined timeout */
result = ca_array_put (dbrType, count, pvs[0].chid, pbuf);
}
result = ca_pend_io(caTimeout);
if (result == ECA_TIMEOUT) {
fprintf(stderr, "Write operation timed out: Data was not written.\n");
return 1;
}
if (request == callback) { /* Also wait for callbacks */
waitStatus = epicsEventWaitWithTimeout( epId, caTimeout );
if (waitStatus)
fprintf(stderr, "Write callback operation timed out\n");
/* retrieve status from callback */
result = pvs[0].status;
}
if (result != ECA_NORMAL) {
fprintf(stderr, "Error occured writing data.\n");
return 1;
}
/* Read and print new data */
if (format != terse)
printf("New : ");
result = caget(pvs, nPvs, format, 0, 0);
/* Shut down Channel Access */
ca_context_destroy();
return result;
}
int main(int argc,char **argv)
{
char *pval;
double sleepSecs = 0.0;
int clearEvery = 0;
int indValue = 1;
int indNumberCallback = 1;
while((argc>1) && (argv[1][0] == '-')) {
int i;
char option;
int narg;
option = toupper((argv[1])[1]);
pval = argv[2];
argc -= 1; narg = 1;
if(option=='S') {
sscanf(pval,"%lf",&sleepSecs);
argc -= 1; ++narg;
} else if(option=='C') {
sscanf(pval,"%d",&clearEvery);
argc -= 1; ++narg;
} else if(option=='V') {
verbose = 1;
} else {
usageExit();
}
for(i=1; i<argc; i++) argv[i] = argv[i + narg];
}
if(argc != 4) usageExit();
pvname = argv[1];
pvalue1 = argv[2];
pvalue2 = argv[3];
pevent = epicsEventCreate(epicsEventEmpty);
SEVCHK(ca_context_create(ca_enable_preemptive_callback),
"ca_task_initialize");
while(1) {
SEVCHK(ca_search(pvname,&mychid),"ca_search_and_connect");
if(ca_pend_io(3.0)!=ECA_NORMAL) {
epicsThreadSleep(5.0);
continue;
}
while(1) {
epicsEventWaitStatus status;
if(indValue==0) {
indValue = 1; pvalue = pvalue2;
} else {
indValue = 0; pvalue=pvalue1;
}
if(++indNumberCallback >= MAXnumberCallback) indNumberCallback=0;
numberCallback[indNumberCallback] = ++expectedCallback;
status = ca_array_put_callback(DBR_STRING,1,mychid,
pvalue,putCallback,&numberCallback[indNumberCallback]);
if(status!=ECA_NORMAL) {
printf("ca_array_put_callback %s\n",ca_message(status));
epicsThreadSleep(2.0);
continue;
}
if((clearEvery>0)
&& ((expectedCallback % clearEvery)==0)) {
ca_flush_io();
epicsThreadSleep(sleepSecs);
SEVCHK(ca_clear_channel(mychid),"ca_clear_channel");
ca_flush_io();
expectedCallback = 0;
epicsThreadSleep(sleepSecs);
if(verbose) {
printTime();
printf("Issued ca_clear_channel expectedCallback %d\n",
expectedCallback);
}
break;
}
ca_flush_io();
if(verbose) {
printTime();
printf("Issued ca_put_callback expectedCallback %d\n",
expectedCallback);
}
while(1) {
status = epicsEventWaitWithTimeout(pevent,10.0);
if(status==epicsEventWaitTimeout) {
if(verbose) {
printTime();
printf("timeout after 10 seconds\n");
}
continue;
}
break;
}
if(status!=epicsEventWaitOK) {
int i;
printTime();
printf("eventWait status %d\n",status);
for(i=0; i<MAXnumberCallback; i++) numberCallback[i]=0;
}
epicsThreadSleep(sleepSecs);
}
}
ca_task_exit();
return(0);
}
static void dbCaTask(void *arg)
{
taskwdInsert(0, NULL, NULL);
SEVCHK(ca_context_create(ca_enable_preemptive_callback),
"dbCaTask calling ca_context_create");
dbCaClientContext = ca_current_context ();
SEVCHK(ca_add_exception_event(exceptionCallback,NULL),
"ca_add_exception_event");
epicsEventSignal(startStopEvent);
/* channel access event loop */
while (TRUE){
do {
epicsEventMustWait(workListEvent);
} while (dbCaCtl == ctlPause);
while (TRUE) { /* process all requests in workList*/
caLink *pca;
short link_action;
int status;
epicsMutexMustLock(workListLock);
if (!(pca = (caLink *)ellGet(&workList))){ /* Take off list head */
epicsMutexUnlock(workListLock);
if (dbCaCtl == ctlExit) goto shutdown;
break; /* workList is empty */
}
link_action = pca->link_action;
pca->link_action = 0;
if (link_action & CA_CLEAR_CHANNEL) --removesOutstanding;
epicsMutexUnlock(workListLock); /* Give back immediately */
if (link_action & CA_CLEAR_CHANNEL) { /* This must be first */
dbCaLinkFree(pca);
/* No alarm is raised. Since link is changing so what? */
continue; /* No other link_action makes sense */
}
if (link_action & CA_CONNECT) {
status = ca_create_channel(
pca->pvname,connectionCallback,(void *)pca,
CA_PRIORITY_DB_LINKS, &(pca->chid));
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_create_channel %s\n",
ca_message(status));
printLinks(pca);
continue;
}
dbca_chan_count++;
status = ca_replace_access_rights_event(pca->chid,
accessRightsCallback);
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask replace_access_rights_event %s\n",
ca_message(status));
printLinks(pca);
}
continue; /*Other options must wait until connect*/
}
if (ca_state(pca->chid) != cs_conn) continue;
if (link_action & CA_WRITE_NATIVE) {
assert(pca->pputNative);
if (pca->putType == CA_PUT) {
status = ca_array_put(
pca->dbrType, pca->nelements,
pca->chid, pca->pputNative);
} else if (pca->putType==CA_PUT_CALLBACK) {
status = ca_array_put_callback(
pca->dbrType, pca->nelements,
pca->chid, pca->pputNative,
putCallback, pca);
} else {
status = ECA_PUTFAIL;
}
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_array_put %s\n",
ca_message(status));
printLinks(pca);
}
epicsMutexMustLock(pca->lock);
if (status == ECA_NORMAL) pca->newOutNative = FALSE;
epicsMutexUnlock(pca->lock);
}
if (link_action & CA_WRITE_STRING) {
assert(pca->pputString);
if (pca->putType == CA_PUT) {
status = ca_array_put(
DBR_STRING, 1,
pca->chid, pca->pputString);
} else if (pca->putType==CA_PUT_CALLBACK) {
status = ca_array_put_callback(
DBR_STRING, 1,
pca->chid, pca->pputString,
putCallback, pca);
} else {
status = ECA_PUTFAIL;
}
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_array_put %s\n",
ca_message(status));
printLinks(pca);
}
epicsMutexMustLock(pca->lock);
if (status == ECA_NORMAL) pca->newOutString = FALSE;
epicsMutexUnlock(pca->lock);
}
/*CA_GET_ATTRIBUTES before CA_MONITOR so that attributes available
* before the first monitor callback */
if (link_action & CA_GET_ATTRIBUTES) {
status = ca_get_callback(DBR_CTRL_DOUBLE,
pca->chid, getAttribEventCallback, pca);
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_get_callback %s\n",
ca_message(status));
printLinks(pca);
}
}
if (link_action & CA_MONITOR_NATIVE) {
size_t element_size;
element_size = dbr_value_size[ca_field_type(pca->chid)];
epicsMutexMustLock(pca->lock);
pca->pgetNative = dbCalloc(pca->nelements, element_size);
epicsMutexUnlock(pca->lock);
status = ca_add_array_event(
ca_field_type(pca->chid)+DBR_TIME_STRING,
ca_element_count(pca->chid),
pca->chid, eventCallback, pca, 0.0, 0.0, 0.0, 0);
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_add_array_event %s\n",
ca_message(status));
printLinks(pca);
}
}
if (link_action & CA_MONITOR_STRING) {
epicsMutexMustLock(pca->lock);
pca->pgetString = dbCalloc(1, MAX_STRING_SIZE);
epicsMutexUnlock(pca->lock);
status = ca_add_array_event(DBR_TIME_STRING, 1,
pca->chid, eventCallback, pca, 0.0, 0.0, 0.0, 0);
if (status != ECA_NORMAL) {
errlogPrintf("dbCaTask ca_add_array_event %s\n",
ca_message(status));
printLinks(pca);
}
}
}
SEVCHK(ca_flush_io(), "dbCaTask");
}
shutdown:
taskwdRemove(0);
if (dbca_chan_count == 0)
ca_context_destroy();
else
fprintf(stderr, "dbCa: chan_count = %d at shutdown\n", dbca_chan_count);
epicsEventSignal(startStopEvent);
}
