/*
* 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
SessionSummaryThr::run()
{
if ( mysqlpp::get_library_version() != MYSQLPP_HEADER_VERSION )
{
cerr<< "Library/header version number mismatch" << endl;
return;
};
MyNode mynode(mpSession);
//mynode.prevshotnum = startshot;
SEVCHK(ca_context_create(ca_disable_preemptive_callback),"ca_context_create");
SEVCHK(ca_add_exception_event(exceptionCallback,NULL), "ca_add_exception_event");
//string pvnames[]={"CCS_SHOT_NUMBER","CCS_PERFORM_SHOT_SUMMARY"};
//Test..
//SEVCHK(ca_create_channel("DDS2_getState",connectionCallback,
// &mynode,10,(oldChannelNotify**)&mynode.summary_chid), "ca_create_channel");
SEVCHK(ca_create_channel("CCS_PERFORM_SHOT_SUMMARY",connectionCallback,
&mynode,10,(oldChannelNotify**)&mynode.summary_chid), "ca_create_channel");
SEVCHK(ca_replace_access_rights_event(mynode.summary_chid,
accessRightsCallback), "ca_replace_access_rights_event");
ca_create_subscription (DBR_TIME_LONG, 0, mynode.summary_chid, DBE_VALUE|DBE_ALARM, eventCallback, (void*)&mynode, NULL);
/*Should never return from following call*/
SEVCHK(ca_pend_event(0.0),"ca_pend_event");
}
void ChannelAccessThr::run()
{
//printchannel(); //for Debug
CHNODE mynode[register_chacc.size()];
unsigned int i = 0;
//const char SHM_KEY[] = "0x50000000";
//const key_t SHM_KEY = 0x50000000;
//char *shmPtr = m_pattach->mCachedData.open (SHM_KEY, register_chacc.size()*sizeof(CachedData), CachedChannelAccess::RT_SHM_CREAT | CachedChannelAccess::RT_SHM_RDWR);
mutex.lock();
for ( reg_chacciter = register_chacc.begin(); reg_chacciter != register_chacc.end(); ++reg_chacciter, i++)
{
mynode[i].objname = QString(reg_chacciter->objname.c_str());
mynode[i].acacc = m_pattach;
mynode[i].pvname = QString(reg_chacciter->pvname.c_str());
mynode[i].dbrequest = reg_chacciter->dbrequest;
mynode[i].chindex = reg_chacciter->chindex;
ca_create_channel(reg_chacciter->pvname.c_str(), connectionCallback, &mynode[i], 10, (oldChannelNotify**)&mynode[i].ch_id);
};
ca_pend_event(1.0);
for ( reg_chacciter = register_chacc.begin(), i=0; reg_chacciter != register_chacc.end(); ++reg_chacciter, i++)
{
if (mynode[i].onceConnected)
{
//qDebug("Conn PV:%s", mynode[i].pvname.toStdString().c_str() );
}
else if (mynode[i].onceConnected == 0)
{
//qDebug("NotConn PV:%s", mynode[i].pvname.toStdString().c_str() );
m_pattach->ConnectionStatusObj(mynode[i].objname, -1);
};
}
mutex.unlock();
#if 1
//in vm image, ca_pend_event(0.0001) stop processing on running;
while(true)
{
if(getStop() == true) break;
ca_pend_event(0.0001);
};
ca_context_destroy();
exit();
#else
//in vm image, this code no problem why?? U know?
ca_pend_event(0.0);
#endif
}
// extern "C"
int epicsShareAPI ca_pend ( ca_real timeout, int early )
{
if ( early ) {
return ca_pend_io ( timeout );
}
else {
return ca_pend_event ( timeout );
}
}
static void medmProcessCA(XtPointer cd, int *source , XtInputId *id)
{
UNREFERENCED(cd);
UNREFERENCED(source);
UNREFERENCED(id);
#ifdef __MONITOR_CA_PEND_EVENT__
{
double t;
t = medmTime();
ca_pend_event(CA_PEND_EVENT_TIME);
t = medmTime() - t;
if(t > 0.5) {
print("medmProcessCA: time used by ca_pend_event = %8.1f\n",t);
}
}
#else
ca_pend_event(CA_PEND_EVENT_TIME);
#endif
}
void ChannelAccessThr::run()
{
unsigned int i = 0;
vecnode.reserve(register_chacc.size());
mutex.lock();
for ( reg_chacciter = register_chacc.begin(); reg_chacciter != register_chacc.end(); ++reg_chacciter, i++)
{
CHNODE node;
node.objname = QString(reg_chacciter->objname.c_str());
node.acacc = m_pattach;
node.pvname = QString(reg_chacciter->pvname.c_str());
node.dbrequest = reg_chacciter->dbrequest;
node.chindex = reg_chacciter->chindex;
node.pItem = reg_chacciter->pItem;
vecnode.push_back(node);
ca_create_channel(reg_chacciter->pvname.c_str(), connectionCallback, (void*)&(vecnode.at(i)), 10, (oldChannelNotify**)&((vecnode.at(i)).ch_id));
};
ca_pend_event(1.0);
for ( reg_chacciter = register_chacc.begin(), i=0; reg_chacciter != register_chacc.end(); ++reg_chacciter, i++)
{
CHNODE *pNode = &vecnode.at(i);
if (pNode->onceConnected)
{
}
else if (pNode->onceConnected == 0)
{
m_pattach->ConnectionStatusObj(pNode->objname, -1);
};
}
mutex.unlock();
while(true)
{
if(getStop() == true) break;
ca_pend_event(0.0001);
};
ca_context_destroy();
exit();
}
void medmCATerminate()
{
int status;
/* Cancel registration of the CA file descriptors */
/* KE: Doesn't cancel it. The first argument should be NULL for cancel */
/* And why do we want to cancel it ? */
status = ca_task_initialize();
if(status != ECA_NORMAL) {
medmPostMsg(1,"medmCATerminate: ca_add_fd_registration failed: %s\n",
ca_message(status));
}
/* Do a pend_event */
/* KE: Why? */
#ifdef __MONITOR_CA_PEND_EVENT__
{
double t;
t = medmTime();
/* Don't allow early returns */
ca_pend_event(20.0*CA_PEND_EVENT_TIME);
t = medmTime() - t;
if(t > 0.5) {
print("medmCATerminate: time used by ca_pend_event = %8.1f\n",t);
}
}
#else
ca_pend_event(20.0*CA_PEND_EVENT_TIME); /* don't allow early returns */
#endif
/* Close down channel access */
status = ca_task_exit();
if(status != ECA_NORMAL) {
medmPostMsg(1,"medmCATerminate: ca_task_exit failed: %s\n",
ca_message(status));
}
/* Clean up the memory allocated for Channel's */
/* KE: Used to be done first */
caTaskDelete();
}
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);
}
/*
* end channel access: note - should just clean up the CURRENT CONTEXT!
*/
int
end_CA()
{
int stat;
stat = ca_pend_event(0.01);
if( stat != ECA_TIMEOUT && stat != ECA_NORMAL)
printf("ca_pend_event failed\n");
#if 0
stat = ca_task_exit();
if( stat != ECA_NORMAL) {
printf("ca_task_exit failed\n");
return -1;
}
#endif
return 0;
}
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);
}
void ChannelAccessThr::ClearEventsOnPage(const int page)
{
if(getClearEvents()==true) return;
//qDebug("ClearEvents-Page[%d]",page);
for(size_t i = 0; i < vecnode.size(); i++)
{
CHNODE *pNode = &vecnode.at(i);
if(pNode == NULL) continue;
int state = ca_state(pNode->ch_id);
ca_pend_event(0.001);
if(state == 0)
{
qDebug("Not Conntected - pv(%s)", pNode->pvname.toStdString().c_str());
continue;
};
SEVCHK(ca_clear_event(pNode->ev_id), NULL);
};
setClearEvents(true);
}
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);
}
int main (int argc, char *argv[])
{
int returncode = 0;
int n = 0;
int result; /* CA result */
int opt; /* getopt() current option */
int digits = 0; /* getopt() no. of float digits */
int nPvs; /* Number of PVs */
pv* pvs = 0; /* Array of PV structures */
setvbuf(stdout,NULL,_IOLBF,BUFSIZ); /* Set stdout to line buffering */
while ((opt = getopt(argc, argv, ":nhm:se:f:g:#:d:0:w:t:")) != -1) {
switch (opt) {
case 'h': /* Print usage */
usage();
return 0;
case 'n': /* Print ENUM as index numbers */
enumAsNr=1;
break;
case 't': /* Select timestamp source(s) and type */
tsSrcServer = 0;
tsSrcClient = 0;
{
int i = 0;
char c;
while ((c = optarg[i++]))
switch (c) {
case 's': tsSrcServer = 1; break;
case 'c': tsSrcClient = 1; break;
case 'n': break;
case 'r': tsType = relative; break;
case 'i': tsType = incremental; break;
case 'I': tsType = incrementalByChan; break;
default :
fprintf(stderr, "Invalid argument '%c' "
"for option '-t' - ignored.\n", c);
}
}
break;
case 'w': /* Set CA timeout value */
if(epicsScanDouble(optarg, &caTimeout) != 1)
{
fprintf(stderr, "'%s' is not a valid timeout value "
"- ignored. ('caget -h' for help.)\n", optarg);
caTimeout = DEFAULT_TIMEOUT;
}
break;
case '#': /* Array count */
if (sscanf(optarg,"%ld", &reqElems) != 1)
{
fprintf(stderr, "'%s' is not a valid array element count "
"- ignored. ('caget -h' for help.)\n", optarg);
reqElems = 0;
}
break;
case 'm': /* Select CA event mask */
eventMask = 0;
{
int i = 0;
char c, err = 0;
while ((c = optarg[i++]) && !err)
switch (c) {
case 'v': eventMask |= DBE_VALUE; break;
case 'a': eventMask |= DBE_ALARM; break;
case 'l': eventMask |= DBE_LOG; break;
default :
fprintf(stderr, "Invalid argument '%s' "
"for option '-m' - ignored.\n", optarg);
eventMask = DBE_VALUE | DBE_ALARM;
err = 1;
}
}
break;
case 's': /* Select string dbr for floating type data */
floatAsString = 1;
break;
case 'e': /* Select %e/%f/%g format, using <arg> digits */
case 'f':
case 'g':
if (sscanf(optarg, "%d", &digits) != 1)
fprintf(stderr,
"Invalid precision argument '%s' "
"for option '-%c' - ignored.\n", optarg, opt);
else
{
if (digits>=0 && digits<=VALID_DOUBLE_DIGITS)
sprintf(dblFormatStr, "%%-.%d%c", digits, opt);
else
fprintf(stderr, "Precision %d for option '-%c' "
"out of range - ignored.\n", digits, opt);
}
break;
case '0': /* Select integer format */
switch ((char) *optarg) {
case 'x': outType = hex; break; /* 0x print Hex */
case 'b': outType = bin; break; /* 0b print Binary */
case 'o': outType = oct; break; /* 0o print Octal */
default :
fprintf(stderr, "Invalid argument '%s' "
"for option '-0' - ignored.\n", optarg);
}
break;
case '?':
fprintf(stderr,
"Unrecognized option: '-%c'. ('caget -h' for help.)\n",
optopt);
return 1;
case ':':
fprintf(stderr,
"Option '-%c' requires an argument. ('caget -h' for help.)\n",
optopt);
return 1;
default :
usage();
return 1;
}
}
nPvs = argc - optind; /* Remaining arg list are PV names */
if (nPvs < 1)
{
fprintf(stderr, "No pv name specified. ('camonitor -h' for help.)\n");
return 1;
}
/* Start up Channel Access */
result = ca_context_create(ca_disable_preemptive_callback);
if (result != ECA_NORMAL) {
fprintf(stderr, "CA error %s occurred while trying "
"to start channel access '%s'.\n", ca_message(result), pvs[n].name);
return 1;
}
/* Allocate PV structure array */
pvs = calloc (nPvs, sizeof(pv));
if (!pvs)
{
fprintf(stderr, "Memory allocation for channel structures failed.\n");
return 1;
}
/* Connect channels */
/* Copy PV names from command line */
for (n = 0; optind < argc; n++, optind++)
{
pvs[n].name = argv[optind];
}
/* Create CA connections */
returncode = create_pvs(pvs, nPvs, connection_handler);
if ( returncode ) {
return returncode;
}
/* Check for channels that didn't connect */
ca_pend_event(caTimeout);
for (n = 0; n < nPvs; n++)
{
if (!pvs[n].onceConnected)
print_time_val_sts(&pvs[n], pvs[n].reqElems);
}
/* Read and print data forever */
ca_pend_event(0);
/* Shut down Channel Access */
ca_context_destroy();
return result;
}
void SinglePlotThread::run()
{
#if 0
// event gathering
//printchannel(); //for Debug
mutex.lock();
mynode.plot = m_plot;
chid unit_chid;
dbr_string_t units;
QString unitch = m_pvname + ".EGU";
ca_create_channel(unitch.toStdString().c_str(), 0, 0, 0, &unit_chid);
ca_pend_io(0.1);
ca_get(DBR_STRING, unit_chid, (void *)&units);
ca_pend_io(0.1);
m_plot->SetUnit(units);
ca_create_channel(m_pvname.toStdString().c_str(), connectionCallback, &mynode, 0, (oldChannelNotify**)&mynode.mychid);
ca_replace_access_rights_event(mynode.mychid, accessRightsCallback);
ca_create_subscription (DBR_TIME_DOUBLE, 0, mynode.mychid, DBE_VALUE|DBE_ALARM, eventCallback, &mynode, &mynode.myevid);
//ca_add_event(DBR_GR_DOUBLE, mynode.mychid, eventCallback, &mynode, &mynode.myevid);
mutex.unlock();
ca_pend_event(0.0);
#else
//periodic gathering
mutex.lock();
chid unit_chid, val_chid;
dbr_string_t units;
QString unitch = m_pvname + ".EGU";
ca_create_channel(unitch.toStdString().c_str(), 0, 0, 0, &unit_chid); ca_pend_io(0.2);
ca_get(DBR_STRING, unit_chid, (void *)&units); ca_pend_io(0.2);
m_plot->SetUnit(units);
struct dbr_time_double data;
ca_create_channel(m_pvname.toStdString().c_str(), 0, 0, 0, &val_chid);
ca_pend_io(0.2);
epicsTime stamp;
struct local_tm_nano_sec tm;
int totsec = 0;
//for periodic single plot local time
int year, month, day, hour, min, sec;
int factor = 1;
switch(mperiodic)
{
case PointOne:
factor *= 0.1;
break;
case PointFive:
factor *= 0.5;
break;
case FiveSec:
factor *= 5;
break;
case TenSec:
factor *= 10;
break;
case OneSec:
default:
break;
};
while(getStop()==false)
{
ca_get(DBR_TIME_DOUBLE, val_chid, (void *)&data);
ca_pend_io(0.2);
//qDebug("%s : %f\n",ca_name(val_chid), data.value);
Epoch2Datetime(year, month, day, hour, min, sec);
#if 0
stamp = data.stamp;
tm = (local_tm_nano_sec) stamp;
totsec = tm.ansi_tm.tm_hour*3600+tm.ansi_tm.tm_min*60+tm.ansi_tm.tm_sec;
m_plot->GetValue(data.value, totsec,tm.ansi_tm.tm_year,tm.ansi_tm.tm_mon, tm.ansi_tm.tm_mday );
#else
totsec = hour*3600+min*60+sec;
m_plot->GetValue(data.value, totsec, year, month, day);
#endif
usleep(1000000*factor);
};
//ca_clear_channel(unit_chid);
//ca_clear_channel(val_chid);
ca_context_destroy();
mutex.unlock();
exit();
qDebug("SinglePlot Exit");
#endif
}
int
heartBeat()
{
ca_pend_event( 0.001);
return 1;
}
/*
* 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;
}
int main(int argc, char** argv)
{
fd_set rfds;
int tot;
struct timeval tv;
if(argc!=3)
{
fprintf(stderr,"Usage: %s PV_to_monitor script_to_run\n\n",argv[0]);
fprintf(stderr,"This program monitored PV PV_to_monitor and\n");
fprintf(stderr,"runs and executes script_to_run, which can be\n");
fprintf(stderr,"any program or executable script.\n");
fprintf(stderr,"The script or program gets invoked with the first\n");
fprintf(stderr,"argument as the PV name and the second argument\n");
fprintf(stderr,"as the value of the PV\n");
fprintf(stderr,"The program or shell script script_to_run is\n");
fprintf(stderr,"run as a separate child process of this program\n");
fprintf(stderr,"This means that your script or program will not\n");
fprintf(stderr,"stop this process from running, if fact your\n");
fprintf(stderr,"script or program can be invoked many times if\n");
fprintf(stderr,"the value of the PV is changing rapidly and\n");
fprintf(stderr,"several instances of your program could be running\n");
fprintf(stderr,"simultaneously.\n");
return -1;
}
strcpy(pv_name,argv[1]);
script_name=argv[2];
pv_value[0]='\0';
if(access(script_name,X_OK)<0)
{
fprintf(stderr,"Script %s not found or not executable\n",script_name);
return -1;
}
signal(SIGINT,sig_func);
signal(SIGQUIT,sig_func);
signal(SIGTERM,sig_func);
signal(SIGHUP,sig_func);
signal(SIGCHLD,sig_chld);
FD_ZERO(&all_fds);
SEVCHK(ca_task_initialize(),"task initialize");
SEVCHK(ca_add_fd_registration(fdCB,&all_fds),"add fd registration");
SEVCHK(ca_add_exception_event(exCB,NULL),"add exception event");
SEVCHK(ca_search_and_connect(pv_name,&id,conCB,NULL),
"search and connect");
SEVCHK(ca_replace_access_rights_event(id,accCB),
"replace access rights event");
/* SEVCHK(ca_add_event(DBR_TIME_STRING,data.id,evCB,&data,&data.event),
"add event"); */
ca_pend_event(REALLY_SMALL);
/* fprintf(stderr,"Monitoring <%s>\n",pv_name); */
while(do_not_exit)
{
rfds=all_fds;
tv.tv_sec=1;
tv.tv_usec=0; /*200000*/;
switch(tot=select(FD_SETSIZE,&rfds,NULL,NULL,&tv))
{
/*
case -1:
perror("select error - bad");
break;
*/
case 0:
ca_pend_event(REALLY_SMALL);
break;
default:
/* fprintf(stderr,"select data ready\n"); */
ca_pend_event(REALLY_SMALL);
break;
}
}
fprintf(stderr,"PV monitor program is exiting!\n");
ca_task_exit();
return 0;
}
int cagetFuZE(char *pvName, char *pvValue) {
RequestT request = get;
OutputT format = plain;
chtype dbrType = -1;
unsigned long reqElems = 0;
int n, result;
pv* pvs;
int i;
unsigned long nElems;
result = ca_context_create(ca_disable_preemptive_callback);
pvs = calloc(1, sizeof(pv));
pvs[0].name = pvName;
connect_pvs(pvs, 1);
for (n = 0; n < 1; n++) {
/* Set up pvs structure */
/* -------------------- */
/* Get natural type and array count */
nElems = ca_element_count(pvs[n].chid);
pvs[n].dbfType = ca_field_type(pvs[n].chid);
pvs[n].dbrType = dbrType;
/* Set up value structures */
if (format != specifiedDbr)
{
pvs[n].dbrType = dbf_type_to_DBR_TIME(pvs[n].dbfType); /* Use native type */
if (dbr_type_is_ENUM(pvs[n].dbrType)) /* Enums honour -n option */
{
if (enumAsNr) pvs[n].dbrType = DBR_TIME_INT;
else pvs[n].dbrType = DBR_TIME_STRING;
}
else if (floatAsString &&
(dbr_type_is_FLOAT(pvs[n].dbrType) || dbr_type_is_DOUBLE(pvs[n].dbrType)))
{
pvs[n].dbrType = DBR_TIME_STRING;
}
}
/* Issue CA request */
/* ---------------- */
if (ca_state(pvs[n].chid) == cs_conn)
{
nConn++;
pvs[n].onceConnected = 1;
if (request == callback)
{
/* Event handler will allocate value and set nElems */
pvs[n].reqElems = reqElems > nElems ? nElems : reqElems;
result = ca_array_get_callback(pvs[n].dbrType,
pvs[n].reqElems,
pvs[n].chid,
event_handler,
(void*)&pvs[n]);
} else {
/* We allocate value structure and set nElems */
pvs[n].nElems = reqElems && reqElems < nElems ? reqElems : nElems;
pvs[n].value = calloc(1, dbr_size_n(pvs[n].dbrType, pvs[n].nElems));
if (!pvs[n].value) {
fprintf(stderr,"Memory allocation failed\n");
return -1;
}
result = ca_array_get(pvs[n].dbrType,
pvs[n].nElems,
pvs[n].chid,
pvs[n].value);
}
pvs[n].status = result;
} else {
pvs[n].status = ECA_DISCONN;
}
}
if (!nConn) return -1; /* No connection? We're done. */
/* Wait for completion */
/* ------------------- */
result = ca_pend_io(caTimeout);
if (result == ECA_TIMEOUT) {
fprintf(stderr, "Read operation timed out: some PV data was not read.\n");
return -1;
}
if (request == callback) /* Also wait for callbacks */
{
if (caTimeout != 0)
{
double slice = caTimeout / PEND_EVENT_SLICES;
for (n = 0; n < PEND_EVENT_SLICES; n++)
{
ca_pend_event(slice);
if (nRead >= nConn) break;
}
if (nRead < nConn) {
fprintf(stderr, "Read operation timed out: some PV data was not read.\n");
return -1;
}
} else {
/* For 0 timeout keep waiting until all are done */
while (nRead < nConn) {
ca_pend_event(1.0);
}
}
}
// Does this kill the connection??
ca_context_destroy();
sprintf(pvValue, "%s\n", val2str(pvs[0].value, pvs[0].dbrType, 0));
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;
}
}
