/*
* cagft()
*
* ca get field test
*
* test ca get over the range of CA data types
*/
static int cagft(char *pname)
{
const unsigned maxTries = 1000ul;
unsigned ntries = 0u;
chid chan_id;
int status;
int i;
/*
* convert name to chan id
*/
status = ca_search(pname, &chan_id);
SEVCHK(status,NULL);
status = ca_pend_io(5.0);
if(status != ECA_NORMAL){
SEVCHK(ca_clear_channel(chan_id),NULL);
printf("Not Found %s\n", pname);
return -1;
}
printf("name:\t%s\n",
ca_name(chan_id));
printf("native type:\t%s\n",
dbr_type_to_text(ca_field_type(chan_id)));
printf("native count:\t%lu\n",
ca_element_count(chan_id));
/*
* fetch as each type
*/
for(i=0; i<=LAST_BUFFER_TYPE; i++){
if(ca_field_type(chan_id)==DBR_STRING) {
if( (i!=DBR_STRING)
&& (i!=DBR_STS_STRING)
&& (i!=DBR_TIME_STRING)
&& (i!=DBR_GR_STRING)
&& (i!=DBR_CTRL_STRING)) {
continue;
}
}
/* ignore write only types */
if (
i == DBR_PUT_ACKT ||
i == DBR_PUT_ACKS ) {
continue;
}
status = ca_array_get_callback(
i,
ca_element_count(chan_id),
chan_id,
printit,
NULL);
SEVCHK(status, NULL);
outstanding++;
}
/*
* wait for the operation to complete
* before returning
*/
while ( ntries < maxTries ) {
unsigned long oldOut;
oldOut = outstanding;
ca_pend_event ( 0.05 );
if ( ! outstanding ) {
SEVCHK ( ca_clear_channel ( chan_id ), NULL );
printf ( "\n\n" );
return 0;
}
if ( outstanding == oldOut ) {
ntries++;
}
}
SEVCHK ( ca_clear_channel ( chan_id ), NULL );
return -1;
}
void SearchTag()
{
int i = 0;
//MAXI2_GAUGE(Dual Gauge)
for(i=0;i<2;i++)
{
ca_search(VacTagData2[i], &VacTagDatachid2[i]);
istatus = ca_pend_io(0.1);
printf("Maxi2 %d : %d\n", i, istatus);
}
//TMP3~4
for(i=0;i<2;i++)
{
ca_search(TmpStsTagData[i], &TmpStsTagDatachid[i]);
istatus = ca_pend_io(0.1);
printf("TmpSts %d : %d\n", i, istatus);
ca_search(TmpAmpTagData[i], &TmpAmpTagDatachid[i]);
istatus = ca_pend_io(0.1);
printf("TmpAmp %d : %d\n", i, istatus);
ca_search(TmpRpmTagData[i], &TmpRpmTagDatachid[i]);
istatus = ca_pend_io(0.1);
printf("TmpRpm %d : %d\n", i, istatus);
ca_search(TmpTempTagData[i], &TmpTempTagDatachid[i]);
istatus = ca_pend_io(0.1);
printf("TmpTemp %d : %d\n", i, istatus);
}
}
int main(int argc,char **argv)
{
int status;
double value=1.0;
double newvalue=0.0;
char *pvname;
double blockTime;
if(argc!=3) {
printf("usage: testsyncgroup <pvname> <blockTime>\n");
exit(1);
}
pvname = argv[1];
sscanf(argv[2],"%le",&blockTime);
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");
SEVCHK(ca_sg_create(&gid),"ca_sg_create");
SEVCHK(ca_sg_array_put(gid,DBR_DOUBLE,1,mychid,(void *)&value),
"ca_sg_array_put");
SEVCHK(ca_sg_array_get(gid,DBR_DOUBLE,1,mychid,(void *)&newvalue),
"ca_sg_array_put");
status = ca_sg_block(gid,blockTime);
printf("ca_sg_block status=%s\n",ca_message(status));
status = ca_sg_test(gid);
printf("ca_sg_test status=%s\n",ca_message(status));
printf("newvalue=%f\n",newvalue);
return(0);
}
void ECCD_Calorimetric::slot_SET_DATA(void)
{
chid searchID;
int istatus;
int iDATA = 1;
ca_search ("EC1_WCS_SET_DATA", &searchID);
istatus = ca_pend_io(0.1);
ca_put(DBR_INT, searchID, &iDATA);
istatus = ca_pend_io(0.1);
}
int main(int argc,char **argv)
{
chid mychid;
unsigned short value;
if(argc!=3) {
printf("usage: caputackt pvname value\n");
exit(1);
}
sscanf(argv[2],"%hu",&value);
SEVCHK(ca_task_initialize(),"ca_task_initialize");
SEVCHK(ca_search(argv[1],&mychid), "ca_search");
ca_pend_io(5.0);
SEVCHK(ca_put(DBR_PUT_ACKT,mychid,&value),"ca_put");
ca_pend_event(1.0);
/*
ca_task_exit();
*/
return(0);
}
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);
}
/*
* capft
*
* test ca_put() over a range of data types
*
*/
static int capft(
char *pname,
char *pvalue
)
{
dbr_short_t shortvalue;
dbr_long_t longvalue;
dbr_float_t floatvalue;
dbr_char_t charvalue;
dbr_double_t doublevalue;
unsigned long ntries = 10ul;
int status;
chid chan_id;
if (((*pname < ' ') || (*pname > 'z'))
|| ((*pvalue < ' ') || (*pvalue > 'z'))){
printf("\nusage \"pv name\",\"value\"\n");
return -1;
}
/*
* convert name to chan id
*/
status = ca_search(pname, &chan_id);
SEVCHK(status,NULL);
status = ca_pend_io(5.0);
if(status != ECA_NORMAL){
SEVCHK(ca_clear_channel(chan_id),NULL);
printf("Not Found %s\n", pname);
return -1;
}
printf("name:\t%s\n", ca_name(chan_id));
printf("native type:\t%d\n", ca_field_type(chan_id));
printf("native count:\t%lu\n", ca_element_count(chan_id));
/*
* string value ca_put
*/
status = ca_put(
DBR_STRING,
chan_id,
pvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_STRING);
if(ca_field_type(chan_id)==0)goto skip_rest;
if(sscanf(pvalue,"%hd",&shortvalue)==1) {
/*
* short integer ca_put
*/
status = ca_put(
DBR_SHORT,
chan_id,
&shortvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_SHORT);
status = ca_put(
DBR_ENUM,
chan_id,
&shortvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_ENUM);
charvalue=(dbr_char_t)shortvalue;
status = ca_put(
DBR_CHAR,
chan_id,
&charvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_CHAR);
}
if(sscanf(pvalue,"%d",&longvalue)==1) {
/*
* long integer ca_put
*/
status = ca_put(
DBR_LONG,
chan_id,
&longvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_LONG);
}
if(epicsScanFloat(pvalue, &floatvalue)==1) {
/*
* single precision float ca_put
*/
status = ca_put(
DBR_FLOAT,
chan_id,
&floatvalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_FLOAT);
}
if(epicsScanDouble(pvalue, &doublevalue)==1) {
/*
* double precision float ca_put
*/
status = ca_put(
DBR_DOUBLE,
chan_id,
&doublevalue);
SEVCHK(status, NULL);
verify_value(chan_id, DBR_DOUBLE);
}
skip_rest:
/*
* wait for the operation to complete
* (outstabnding decrements to zero)
*/
while(ntries){
ca_pend_event(1.0);
if(!outstanding){
SEVCHK(ca_clear_channel(chan_id),NULL);
printf("\n\n");
return 0;
}
ntries--;
}
SEVCHK(ca_clear_channel(chan_id),NULL);
return -1;
}
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)
{
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);
}
int main(int argc,char **argv)
{
int indval,field;
SEVCHK(ca_task_initialize(),"ca_task_initialize");
SEVCHK(ca_search("enumCputDTYP",&putCchid[0]),"ca_search failure");
SEVCHK(ca_search("enumCputPRIO",&putCchid[1]),"ca_search failure");
SEVCHK(ca_search("enumCputVAL" ,&putCchid[2]),"ca_search failure");
SEVCHK(ca_search("enumMDbputDTYP",&putMDbchid[0]),"ca_search failure");
SEVCHK(ca_search("enumMDbputPRIO",&putMDbchid[1]),"ca_search failure");
SEVCHK(ca_search("enumMDbputVAL" ,&putMDbchid[2]),"ca_search failure");
SEVCHK(ca_search("enumMCaputDTYP",&putMCachid[0]),"ca_search failure");
SEVCHK(ca_search("enumMCaputPRIO",&putMCachid[1]),"ca_search failure");
SEVCHK(ca_search("enumMCaputVAL" ,&putMCachid[2]),"ca_search failure");
SEVCHK(ca_search("enumCmbbi.DTYP" ,&getCchid[0]),"ca_search failure");
SEVCHK(ca_search("enumCmbbi.PRIO" ,&getCchid[1]),"ca_search failure");
SEVCHK(ca_search("enumCmbbi.VAL" ,&getCchid[2]),"ca_search failure");
SEVCHK(ca_search("enumMDbmbbi.DTYP" ,&getMDbchid[0]),"ca_search failure");
SEVCHK(ca_search("enumMDbmbbi.PRIO" ,&getMDbchid[1]),"ca_search failure");
SEVCHK(ca_search("enumMDbmbbi.VAL" ,&getMDbchid[2]),"ca_search failure");
SEVCHK(ca_search("enumMCambbi.DTYP" ,&getMCachid[0]),"ca_search failure");
SEVCHK(ca_search("enumMCambbi.PRIO" ,&getMCachid[1]),"ca_search failure");
SEVCHK(ca_search("enumMCambbi.VAL" ,&getMCachid[2]),"ca_search failure");
SEVCHK(ca_pend_io(5.0),"ca_pend_io failure");
for(indval=0; indval<2; indval++) {
SEVCHK(ca_put(DBR_STRING,putCchid[0],dtypValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putCchid[1],prioValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putCchid[2],valValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMDbchid[0],dtypValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMDbchid[1],prioValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMDbchid[2],valValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMCachid[0],dtypValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMCachid[1],prioValue[indval]),"ca_put");
SEVCHK(ca_put(DBR_STRING,putMCachid[2],valValue[indval]),"ca_put");
/*Wait until evertthing updated*/
ca_pend_event(2.0);
for(field=0; field<3; field++) {
SEVCHK(ca_get(DBR_STRING,getCchid[field],&getCvalue[field]),
"ca_get");
SEVCHK(ca_get(DBR_STRING,getMDbchid[field],&getMDbvalue[field]),
"ca_get");
SEVCHK(ca_get(DBR_STRING,getMCachid[field],&getMCavalue[field]),
"ca_get");
}
SEVCHK(ca_pend_io(5.0),"ca_pend_io failure");
printReport(indval);
}
return(0);
}
void popupPvInfo(DisplayInfo *displayInfo)
{
DlElement *pE;
Record **records;
chid chId;
int i, status;
Record *pR;
Channel *pCh;
char descName[MAX_TOKEN_LENGTH];
char *pDot;
double connTimeout;
#if DEBUG_PVINFO
XUngrabPointer(display,CurrentTime);
#endif
/* Check if another call is in progress */
if(pvInfo) {
medmPostMsg(1,"popupPvInfo: "
"Another PV Info request is already in progress\n"
" It is probably having problems\n"
" Wait for it to finish\n");
return;
}
/* Create the dialog box if it has not been created */
if(!pvInfoS) createPvInfoDlg();
/* Get the records */
records = getPvInfoFromDisplay(displayInfo, &nPvInfoPvs, &pE);
if(!records) return;
pvInfoElement = pE;
/* Allocate space */
pvInfo = (PvInfo *)calloc(nPvInfoPvs, sizeof(PvInfo));
if(!pvInfo) {
medmPostMsg(1,"popupPvInfo: Memory allocation error\n");
if(records) free(records);
if(pvInfoS && XtIsManaged(pvInfoS)) return;
}
/* Loop over the records, initialize, and initiate search for DESC */
for(i=0; i < nPvInfoPvs; i++) {
/* Initialize */
pvInfo[i].pvChid = NULL;
pvInfo[i].pvOk = False;
pvInfo[i].timeOk = False;
pvInfo[i].descChid = NULL;
pvInfo[i].descOk = False;
strcpy(pvInfo[i].descVal, NOT_AVAILABLE);
#if defined(DBR_CLASS_NAME) && DO_RTYP
pvInfo[i].rtypOk = False;
strcpy(pvInfo[i].rtypVal, NOT_AVAILABLE);
#endif
/* Check for a valid record */
if(records[i]) {
pR = pvInfo[i].record = records[i];
pCh = getChannelFromRecord(pR);
if(!pCh) continue;
if(!pCh->chid) continue;
chId = pvInfo[i].pvChid = pCh->chid;
} else continue;
pvInfo[i].pvOk = True;
/* Don't try the others unless the PV is connected */
if(ca_state(chId) != cs_conn || !ca_read_access(chId))
continue;
/* Construct the DESC name */
strcpy(descName,ca_name(chId));
pDot = strchr(descName,'.');
if(pDot) {
/* Assume it is a name with a field and replace the field
* with DESC */
strcpy(pDot,".DESC");
} else {
/* Append .DESC */
strcat(descName,".DESC");
}
/* Search for the DESC */
status = ca_search(descName, &pvInfo[i].descChid);
if(status == ECA_NORMAL) {
pvInfo[i].descOk = True;
} else {
medmPostMsg(1,"popupPvInfo: DESC: ca_search for %s: %s\n",
descName, ca_message(status));
}
}
/* Free the records, they are now stored in pvInfo */
if(records) free(records);
/* Wait for the searches (Timeouts should be uncommon) */
status=ca_pend_io(CA_PEND_IO_TIME);
if(status != ECA_NORMAL) {
medmPostMsg(1,"popupPvInfo: Waited %g seconds. "
"Did not find the DESC information (%s).\n",
CA_PEND_IO_TIME, descName);
}
/* Loop over the records and do the gets */
nPvInfoCbs = 0;
for(i=0; i < nPvInfoPvs; i++) {
if(!pvInfo[i].pvOk) continue;
/* Don't try the others unless the PV is connected */
chId = pvInfo[i].pvChid;
if(ca_state(chId) != cs_conn || !ca_read_access(chId))
continue;
/* Get the DESC */
if(ca_state(pvInfo[i].descChid) == cs_conn &&
ca_read_access(pvInfo[i].descChid)) {
/* Do the get */
status = ca_get_callback(DBR_STRING, pvInfo[i].descChid,
pvInfoDescGetCb, &pvInfo[i]);
if(status == ECA_NORMAL) {
nPvInfoCbs++;
} else {
pvInfo[i].descOk = False;
medmPostMsg(1,"pvInfoConnectCb: DESC: ca_array_get_callback"
" for %s: %s\n",
ca_name(pvInfo[i].descChid), ca_message(status));
}
} else {
pvInfo[i].descOk = False;
}
/* Get the time value as a string */
status = ca_get_callback(DBR_TIME_STRING, chId, pvInfoTimeGetCb,
&pvInfo[i]);
if(status == ECA_NORMAL) {
nPvInfoCbs++;
} else {
medmPostMsg(1,"popupPvInfo: STAMP: ca_get_callback for %s: %s\n",
ca_name(chId), ca_message(status));
}
#if defined(DBR_CLASS_NAME) && DO_RTYP
/* Get the RTYP */
status = ca_get_callback(DBR_CLASS_NAME, chId, pvInfoRtypGetCb,
&pvInfo[i]);
if(status == ECA_NORMAL) {
nPvInfoCbs++;
} else {
medmPostMsg(1,"popupPvInfo: RTYP: ca_get_callback for %s: %s\n",
ca_name(chId), ca_message(status));
}
#endif
}
/* Add a timeout and poll if there are callbacks
* The timeout is a safety net and should never be called
* All callbacks should come back inside the EPICS_CA_CONN_TMO
* Wait for 2 times this */
if(nPvInfoCbs) {
ca_poll(); /* May not be really necessary here */
status = envGetDoubleConfigParam(&EPICS_CA_CONN_TMO, &connTimeout);
if (status == 0) pvInfoTime = (unsigned long)(2000.*connTimeout+.5);
else pvInfoTime = PVINFO_TIMEOUT;
pvInfoTimeoutId = XtAppAddTimeOut(appContext, pvInfoTime,
pvInfoTimeout, NULL);
pvInfoTimerOn = True;
} else {
pvInfoWriteInfo();
}
#if DEBUG_PVINFO
print("popupPvInfo: nPvInfoCbs=%d timeout=%ld\n",
nPvInfoCbs, nPvInfoCbs?pvInfoTime:0L);
#endif
}