1700 lines
57 KiB
C++
1700 lines
57 KiB
C++
//
|
|
// A simple example
|
|
//
|
|
#include <cafe.h>
|
|
|
|
#include "callbacks.h"
|
|
|
|
#define PV_X1 "ARIDI-BPM-01LE:X-AVG"
|
|
#define PV_Y1 "ARIDI-BPM-01LE:Y-AVG"
|
|
#define PV_WF "ARIDI-BPM-01LE:WF-INT-1" //256 elements
|
|
//define PV_WF "SINSB04-ROPT-LOG:MON-MSG"
|
|
#define PV_MBBI "ARIDI-BPM-01LE:GET-ENABLE" //mmbi
|
|
#define PV_X1_DESC "ARIDI-BPM-01LE:X-AVG.DESC" //dbr_string_t
|
|
|
|
#define PV_JOKE "PV:JOKE"
|
|
|
|
|
|
|
|
#define NHANDLES 6 // should match number of pvs above that we are to open.
|
|
|
|
|
|
template<typename A, typename B>
|
|
std::pair<B,A> flip_pair(const std::pair<A,B> &p)
|
|
{
|
|
return std::pair<B,A>(p.second, p.first);
|
|
}
|
|
|
|
|
|
template <typename A, typename B>
|
|
std::multimap<B,A> flip_map(const std::map<A,B> & src) {
|
|
|
|
std::multimap<B,A> dst;
|
|
|
|
std::transform(src.begin(), src.end(), std::inserter(dst, dst.begin()),
|
|
flip_pair<A,B>);
|
|
|
|
return dst;
|
|
}
|
|
|
|
|
|
|
|
int main( int argc, char *argv[] )
|
|
{
|
|
using namespace std;
|
|
|
|
// Test with 6 PVS
|
|
// PV_X1,PV_Y1 are scalar numerics
|
|
// PV_WF is a vecror numeric
|
|
// PV_MBBI is anmbbi record witha number of enum vakues
|
|
// PV_X!_DESC is of data type dbr_string_t
|
|
// PV_JOKE is a non-existant channel (used to show CAFE response is such cases)
|
|
|
|
string pvArray[NHANDLES]={PV_X1,PV_Y1,PV_WF,PV_MBBI,PV_X1_DESC,PV_JOKE};
|
|
unsigned int hArray[NHANDLES];
|
|
|
|
//------------------------------------------------------------
|
|
//(1) Preliminaries
|
|
//------------------------------------------------------------
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (1) Preliminaries " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
//Instantaite CAFE
|
|
|
|
ChannelRequestPolicy channelRequestPolicyPutNew;
|
|
channelRequestPolicyPutNew.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::NO_WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //W
|
|
|
|
ChannelRequestPolicy channelRequestPolicyGetNew;
|
|
channelRequestPolicyGetNew.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::WAIT, CAFENUM::WITHOUT_CALLBACK);
|
|
|
|
ChannelGetActionWhenMonitorPolicy cgawmp;
|
|
cgawmp.setActionKind(CAFENUM::GET_FROM_CACHE);
|
|
|
|
|
|
CAFE * cafe = new CAFE(); //channelRequestPolicyPutNew);
|
|
|
|
|
|
// cafe->channelRequestPolicyMasterPut.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
// CAFENUM::NO_WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //WITHOUT_CALLBACK)
|
|
|
|
cout << "---1------------------------------------------------------ " << endl;
|
|
ChannelRequestPolicy * channelRequestPolicySet = new ChannelRequestPolicy();
|
|
cout << "---2------------------------------------------------------ " << endl;
|
|
ChannelRequestPolicy channelRequestPolicySet2;
|
|
cout << "---3------------------------------------------------------ " << endl;
|
|
unsigned int handle;
|
|
int status;
|
|
//Class with methods to report on the value and meaning of status codes
|
|
CAFEStatus cstat;
|
|
//Classes defining value/name pairs of alarm status and and severity
|
|
CAFEGlobalAlarmSeverity alarmSev;
|
|
CAFEGlobalAlarmCondition alarmStat;
|
|
|
|
HandleHelper handleHelper;
|
|
|
|
|
|
// This is optional
|
|
//Initialize ca (otherwise first cafe method call will initialize ca)
|
|
cout << "---4------------------------------------------------------ " << endl;
|
|
try {
|
|
status=cafe->init( ); // ca_disable_preemptive_callback
|
|
}
|
|
catch (CAFEException_init &e) {
|
|
cout << e.what() << endl;
|
|
exit(1);
|
|
}
|
|
|
|
|
|
// This too is optional
|
|
// The first Cafe method invoked on this channel will otherwise enable the virtual circuit
|
|
// An open operation will pend the ioc for a default amount of time fiven by:
|
|
// cafe->channelOpenPolicy.getDefaultTimeout()
|
|
// else otherwise specified.
|
|
cout << "---5------------------------------------------------------ " << endl;
|
|
cafe->channelOpenPolicy.setTimeout(0.1); //pend 0.1 seconds
|
|
cout << "---6------------------------------------------------------ " << endl;
|
|
// It is not an error if the channel is not connected!
|
|
cout << "open " << endl;
|
|
try {
|
|
cafe->open(pvArray[0].c_str(), handle);
|
|
}
|
|
catch(CAFEException_open & e) {
|
|
cout << e.what() << endl;
|
|
exit(1);
|
|
}
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (1) Preliminaries " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
sleep(1);
|
|
|
|
cout << "when /" << channelRequestPolicySet->getWhenToFlushSendBuffer() << endl;
|
|
cout << "wait /" << channelRequestPolicySet->getWaitKind() << endl;
|
|
cout << "method /" << channelRequestPolicySet->getMethodKind() << endl;
|
|
|
|
cout << cafe->getPolicyHelper().getChannelRequestPolicyPut(1, *channelRequestPolicySet ) << endl;
|
|
|
|
cout << "when /" << channelRequestPolicySet->getWhenToFlushSendBuffer() << endl;
|
|
cout << "wait /" << channelRequestPolicySet->getWaitKind() << endl;
|
|
cout << "method /" << channelRequestPolicySet->getMethodKind() << endl;
|
|
|
|
|
|
cout << cafe->getPolicyHelper().getChannelRequestPolicyGet(1, *channelRequestPolicySet ) << endl;
|
|
|
|
cout << "when /" << channelRequestPolicySet->getWhenToFlushSendBuffer() << endl;
|
|
cout << "wait /" << channelRequestPolicySet->getWaitKind() << endl;
|
|
cout << "method /" << channelRequestPolicySet->getMethodKind() << endl;
|
|
|
|
|
|
ChannelGetActionWhenMonitorPolicy cm;
|
|
cout << cafe->getPolicyHelper().getChannelGetActionWhenMonitorPolicy(1, cm ) << endl;
|
|
cout << cm.getActionKind() << endl;
|
|
|
|
|
|
|
|
cout << "when /" << channelRequestPolicySet2.getWhenToFlushSendBuffer() << endl;
|
|
cout << "wait /" << channelRequestPolicySet2.getWaitKind() << endl;
|
|
cout << "method /" << channelRequestPolicySet2.getMethodKind() << endl;
|
|
|
|
cout << cafe->getPolicyHelper().getChannelRequestPolicyPut(1, channelRequestPolicySet2 ) << endl;
|
|
|
|
cout << "when /" << channelRequestPolicySet2.getWhenToFlushSendBuffer() << endl;
|
|
cout << "wait /" << channelRequestPolicySet2.getWaitKind() << endl;
|
|
cout << "method /" << channelRequestPolicySet2.getMethodKind() << endl;
|
|
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (1b) Opening and Closing Channels " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
unsigned int hDesc;
|
|
|
|
vector<unsigned int> hV;
|
|
vector<string> pvV;
|
|
vector<unsigned short> stateV;
|
|
|
|
|
|
try{
|
|
|
|
//For multiple invocations of cafe->open it is more efficient and less of a
|
|
//time sink to first prepare the messages before flushing the message buffer
|
|
//once at the end.
|
|
//This can be done by configuring the channelopenPolicy class accordingly.
|
|
//See policies.h
|
|
//Set open policy so as to create virtual circuits in one step
|
|
//cafe->channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
|
|
//cafe->channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
|
|
//cafe->channelOpenPolicy.setTimeout(1.0);
|
|
|
|
//cafe->open(...)
|
|
|
|
//cafe->openNow() // Now send messages to IOC
|
|
|
|
|
|
//However, for convenience open policy has been conveniently packaged so that
|
|
//only the openPrepare method need be called a priori
|
|
|
|
cafe->openPrepare();
|
|
cafe->open(pvArray, hArray, NHANDLES);
|
|
cafe->open(PV_X1_DESC, hDesc);
|
|
|
|
cafe->openNow() ; // and wait for cafe->channelOpenPolicy.getTimeout()
|
|
//or
|
|
cafe->openNowAndWait(0.5); //wait for specified time, here 3.0 seconds
|
|
|
|
|
|
//Is the given channel connected? Returns true/false
|
|
bool ifYes= cafe->isChannelConnected(hDesc);
|
|
|
|
//Are all channels connected? Returns true/false
|
|
ifYes= cafe->allChannelsConnected();
|
|
|
|
|
|
if (!ifYes) {
|
|
cafe->printDisconnectedHandles();
|
|
}
|
|
|
|
|
|
status=handleHelper.getDisconnectedHandles(hV, pvV);
|
|
status=handleHelper.getHandles(hV, pvV);
|
|
status=handleHelper.getHandleStates(hV, pvV,stateV);
|
|
|
|
|
|
//cafe->channelOpenPolicy.flushSendBufferNow(); //Now send open message
|
|
//cafe->channelOpenPolicy.setTimeoutToDefault(); //Reset timeout to default value
|
|
|
|
}
|
|
catch(CAFEException_open & e) {
|
|
cout << e.what() << endl;
|
|
}
|
|
|
|
|
|
// To close channels within a given ca_client_context
|
|
|
|
// To close a single Channel
|
|
//cafe->close(hDesc);
|
|
|
|
// To close many channels
|
|
//cafe->closeChannels(hArray, NHANDLES);
|
|
|
|
// To close alls channesl
|
|
//cafe->closeChannels();
|
|
|
|
// If you wish to close channels that are in other threads
|
|
// (i.e., with other ca_client_context)
|
|
// use instead the following methods:
|
|
// To close a single Channel irrespective of ca_client_context
|
|
// I.e. these will also close handle s in other threads
|
|
//cafe->closeHandle(hDesc);
|
|
|
|
// To close many handles
|
|
//cafe->closeHandles(hArray, NHANDLES);
|
|
|
|
// To close all handles
|
|
//cafe->closeHandles();
|
|
|
|
/*
|
|
cafe->loadCollectionsFromXML("cNodes.xml");
|
|
cafe->loadGroupsFromXML("gDBPM.xml");
|
|
//cafe->loadCollectionsFromXML("cSF_Aramis_bunch1.xml");
|
|
//cafe->loadCollectionsFromXML("testVSUP.xml");
|
|
//cafe->loadGroupsFromXML("bpmDisplaySFEnergyBunch1.xml");
|
|
|
|
vector<string> _glist;
|
|
cafe->groupMemberList("gDBPM", _glist);
|
|
vector<unsigned int> _hVA;
|
|
|
|
cafe->openPrepare();
|
|
cafe->open(_glist, _hVA);
|
|
|
|
cafe->openNowAndWait(2.0); //wait for specified time, here 3.0 seconds
|
|
|
|
*/
|
|
|
|
vector<string> _glist;
|
|
|
|
vector<unsigned int> _hVA;
|
|
|
|
typedef std::map<float, std::string> floatStringMap2;
|
|
floatStringMap2 posDev2;
|
|
floatStringMap2::iterator pos2;
|
|
|
|
/*
|
|
cafe->devicePositionMap("cDBPM", posDev2);
|
|
|
|
for (pos2 =posDev2.begin(); pos2 != posDev2.end(); ++pos2) {
|
|
cout << "position= " << pos2->first << " Dev " << pos2->second << endl;
|
|
//++pos;
|
|
}
|
|
*/
|
|
//cafe->readyDBPM(_hVA);
|
|
|
|
|
|
// cafe->prepareDBPM(_glist, _hVA, posDev2);
|
|
|
|
|
|
//cafe->devicePositionMap("cDBPM", posDev2);
|
|
|
|
// for (pos2 =posDev2.begin(); pos2 != posDev2.end(); ++pos2) {
|
|
// cout << "position= " << pos2->first << " Dev " << pos2->second << endl;
|
|
|
|
// }
|
|
|
|
|
|
//DBPMKeeper dbpm(_glist,_hVA,posDev2);
|
|
|
|
|
|
vector<float> posV; vector<string> devS;
|
|
cout << " HERE prepareDBPM" << endl;
|
|
|
|
|
|
cafe->prepareDBPM(_glist, _hVA, devS, posV);
|
|
|
|
cout << " HERE " << endl;
|
|
|
|
DBPMKeeper dbpm(_glist,_hVA, devS, posV);
|
|
|
|
cafe->readDBPMOffsets(dbpm);
|
|
vector <double> ox = dbpm.getOffsetX();
|
|
vector <double> oy = dbpm.getOffsetY();
|
|
vector <string> devis = dbpm.getDevice();
|
|
|
|
cout << "size x " << ox.size() << endl;
|
|
cout << "size y " << oy.size() << endl;
|
|
cout << "devis " << devis.size() << endl;
|
|
|
|
for (int i=0; i<devis.size(); ++i) {
|
|
|
|
cout << i << " " << devis[i] << " xoffset= " << ox[i] << " " << oy[i] << endl;
|
|
}
|
|
|
|
//for (int i=0; i<devS.size(); ++i) {
|
|
// cout << _glist[i] << " " << _hVA[i] << " " << devS[i] << " " << posV[i] << endl;
|
|
//}
|
|
|
|
cafe->terminate();
|
|
exit(0);
|
|
|
|
////dbpm.setBS(true);
|
|
|
|
////vector<double> x,y,q,E;
|
|
////vector<bool> vx,vy,vq;
|
|
vector<DBPMData> ddx, ddy, ddq, dde;
|
|
ChannelRequestStatus cre;
|
|
vector<string> devices;
|
|
|
|
cout << "STATUS GETCTRL = " << cafe->getHandleHelper().getChannelRequestStatusGetCtrl(8, cre) << endl;
|
|
cout << "Value 1 is PENDING, while 2 is COMPLETE: " << cre.getCallbackProgressKind() << endl;
|
|
|
|
|
|
system("date");
|
|
for (int i=0; i<200; ++i ) {
|
|
if (i==0) dbpm.setBS(true);
|
|
status=cafe->getDBPM(dbpm);
|
|
|
|
if (status > ICAFE_LINUX_ERROR) continue;
|
|
|
|
//cout << i << " STATUS GETCTRL = " << cafe->getHandleHelper().getChannelRequestStatusGetCtrl(8, cre) << endl;
|
|
|
|
//cout << i << " Value 1 is PENIDING, while 2 is COMPLETE: " << cre.getCallbackProgressKind() << endl;
|
|
cout << "STATUS " << status << " " << dbpm.status << endl;
|
|
|
|
ddx=dbpm.getX();
|
|
ddy=dbpm.getY();
|
|
ddq=dbpm.getQ();
|
|
dde=dbpm.getEnergy();
|
|
|
|
devices = dbpm.getDevice();
|
|
|
|
cout << " ddx.size " << ddx.size() << endl;
|
|
cout << " ddy.size " << ddy.size() << endl;
|
|
cout << " ddq.size " << ddq.size() << endl;
|
|
cout << " dde.size " << dde.size() << endl;
|
|
for (int j=0; j<ddx.size(); ++j) {
|
|
cout << i << " " << devices[j] << " " << devS[j] << " value=" << ddx[j].getValue() << " status=" << ddx[j].getStatus() << endl;
|
|
|
|
}
|
|
|
|
//cout << i << " " << ddx[0].getValue() << " " << ddy[0].getValue() << " "
|
|
//<< ddq[0].getValue() << " " << dde[0].getValue() << endl;
|
|
|
|
//cout << i << " " << ddx[0].getEpicsTimeStamp().secPastEpoch << " " << ddx[0].getEpicsTimeStamp().nsec << " "
|
|
//<< ddx[0].getStatus() << " " << endl;
|
|
|
|
|
|
//cout << dbpm.getY()[0] << " " << dbpm.getY()[6] << " " << dbpm.getY()[7] << endl;
|
|
//cout << dbpm.getQ()[0] << " " << dbpm.getQ()[6] << " " << dbpm.getQ()[7] << endl;
|
|
|
|
//for (int i=0; i<_glist.size(); ++ i) {
|
|
// cout << _glist[i] << " " << " [" << "] " ;
|
|
//}
|
|
//usleep(1000);
|
|
//cout << endl;
|
|
|
|
//sleep(1);
|
|
|
|
}
|
|
system("date");
|
|
cafe->terminate();
|
|
exit(0);
|
|
|
|
|
|
|
|
|
|
PVDataHolder * pdh = new PVDataHolder[_glist.size()];
|
|
system("date");
|
|
for (int i=0; i<1; ++i) {
|
|
status=cafe->get(_hVA, pdh);
|
|
}
|
|
system("date");
|
|
cafe->closeHandles(_hVA);
|
|
|
|
unsigned int _gh;
|
|
|
|
cafe->groupOpen("gDBPM", _gh);
|
|
PVGroup _pvg;
|
|
system("date");
|
|
status=cafe->groupGet(_gh, _pvg);
|
|
system("date");
|
|
cout <<"status + " << status << endl;
|
|
|
|
cafe->terminate();
|
|
exit(0);
|
|
|
|
|
|
typedef std::map<float, std::string> floatStringMap;
|
|
floatStringMap posDev;
|
|
floatStringMap::iterator pos;
|
|
|
|
cafe->devicePositionMap("cDBPM", posDev);
|
|
|
|
|
|
for (pos =posDev.begin(); pos != posDev.end(); ++pos) {
|
|
cout << "device= " << pos->first << " Pos " << pos->second << endl;
|
|
//++pos;
|
|
}
|
|
|
|
|
|
cafe->devicePositionMap("cDBPM", posDev);
|
|
|
|
for (pos =posDev.begin(); pos != posDev.end(); ++pos) {
|
|
cout << "device= " << pos->first << " Pos " << pos->second << endl;
|
|
//++pos;
|
|
}
|
|
|
|
posDev.clear();
|
|
cafe->devicePositionMap("cVSUP", posDev);
|
|
|
|
for (pos =posDev.begin(); pos != posDev.end(); ++pos) {
|
|
cout << "device= " << pos->first << " Pos " << pos->second << endl;
|
|
//++pos;
|
|
}
|
|
|
|
vector<const char *> deviceListV;
|
|
deviceListV.push_back("AB-CD");
|
|
deviceListV.push_back("AB-EF");
|
|
cafe->collectionDefine("cTest", deviceListV);
|
|
|
|
posDev.clear();
|
|
cafe->devicePositionMap("cTest", posDev);
|
|
|
|
for (pos =posDev.begin(); pos != posDev.end(); ++pos) {
|
|
cout << "device= " << pos->first << " Pos " << pos->second << endl;
|
|
//++pos;
|
|
}
|
|
|
|
double dValArray[12];
|
|
int sAy[12];
|
|
cafe->getCache(hArray, NHANDLES, dValArray, sAy);
|
|
|
|
|
|
for (int i=0; i<NHANDLES; ++i) {
|
|
cout << "val from Cache " << dValArray[i] << " status " << sAy[i]<< endl;
|
|
}
|
|
|
|
|
|
|
|
|
|
//cafe->terminate();
|
|
//exit(1);
|
|
|
|
vector<string> gl;
|
|
cafe->collectionList(gl);
|
|
for (int i=0; i < gl.size(); ++i) {
|
|
cout << gl[i] << endl;
|
|
}
|
|
PVGroup pvgrp;
|
|
unsigned int ghan;
|
|
cafe->groupOpen("gDBPM", ghan);
|
|
cafe->groupGet(ghan, pvgrp);
|
|
//pvgrp.show();
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (1b) Opening and Closing Channels " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
sleep(3);
|
|
|
|
//------------------------------------------------------------
|
|
//(2) Basic Single Channel Operations
|
|
//------------------------------------------------------------
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (2) Basic Single Channel Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
//------------------------------------------------------------
|
|
//Data retrieval methods returning a scalar value
|
|
//------------------------------------------------------------
|
|
|
|
double d;
|
|
//get by handle
|
|
status=cafe->get(handle, d);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
//or
|
|
cafe->printStatus(handle,status);
|
|
}
|
|
else {
|
|
cout << "Value d=" << d << endl;
|
|
}
|
|
|
|
float f; short alarmStatus, alarmSeverity; epicsTimeStamp ets;
|
|
status=cafe->get(handle, f, alarmStatus, alarmSeverity, ets);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cafe->printStatus(handle,status);
|
|
}
|
|
else {
|
|
cout << "Value f=" << f << endl;
|
|
cout << "AlarmStatus= " << alarmStat.asString(alarmStatus) << " AlarmSeverity=" << alarmSev.asString(alarmSeverity)
|
|
<< " TimeStamp= " << ets.secPastEpoch << " sec. " << ets.nsec << " nsec " << endl;
|
|
}
|
|
|
|
|
|
//get by pvname
|
|
status=cafe->get(pvArray[0].c_str(), d);
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
//or
|
|
cafe->printStatus(handle,status);
|
|
}
|
|
|
|
|
|
//To explicitly check on timeout error
|
|
if (cstat.csc.isTimeout(status)) {
|
|
cout << "Above is a timeout error" << endl;
|
|
}
|
|
|
|
//To interchange between handle and array
|
|
handle = cafe->getHandleFromPV(pvArray[0].c_str());
|
|
const char * pvName= cafe->getPVFromHandle(handle);
|
|
|
|
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//Data retrieval methods returning structured data
|
|
//------------------------------------------------------------
|
|
unsigned int hWF;
|
|
status=cafe->open(PV_WF,hWF);
|
|
//status=cafe->open("XHIPA-STA:STA-ND1",hWF);
|
|
|
|
|
|
|
|
double dwff;
|
|
cafe->get(hWF, dwff);
|
|
|
|
cout << "wfd " << dwff << endl;
|
|
string ms;
|
|
cafe->getWFAsString(hWF, ms);
|
|
cout << "wf asstring 1st " << ms << endl;
|
|
|
|
cafe->getWFAsString(hWF, ms);
|
|
cout << "wf asstring 2nd" << ms << endl;
|
|
|
|
cafe->getWFAsStringCache(hWF, ms);
|
|
cout << "wf asstring 3rd" << ms << endl;
|
|
|
|
|
|
PVDataHolder pvd;
|
|
//pvd.setNelem(cafe->getNelemNative(hWF));
|
|
pvd.setNelem(cafe->getNelemNative(hWF));
|
|
status=cafe->get(hWF, pvd);
|
|
|
|
if (status==ICAFE_NORMAL) {
|
|
|
|
pvd.print(10); //Show only 10 elements of the waveform
|
|
|
|
//The PVDataHolder
|
|
cout << "pvd.getAsString()" << endl;
|
|
for (int i=0; i<min(5,(int) cafe->getNelemRequest(hWF)); ++i) {
|
|
cout << pvd.getAsString(i) << " [" << i << "] ";
|
|
}
|
|
cout << endl;
|
|
//First Element Only
|
|
cout << "pvd.getAsDbr_string_t() = " << pvd.getAsDbr_string_t() << endl;
|
|
cout << "pvd.getAsDouble() = " << pvd.getAsDouble() << endl;
|
|
cout << "pvd.getAsFloat() = " << pvd.getAsFloat() << endl;
|
|
cout << "pvd.getAsChar() = " << (unsigned short) pvd.getAsChar() << endl;
|
|
cout << "pvd.getAsShort() = " << pvd.getAsShort() << endl;
|
|
cout << "pvd.getAsUShort() = " << pvd.getAsUShort() << endl;
|
|
cout << "pvd.getAsLong() = " << pvd.getAsLong() << endl;
|
|
cout << "pvd.getAsULong() = " << pvd.getAsULong() << endl;
|
|
cout << "pvd.getAsLongLong() = " << pvd.getAsLongLong() << endl;
|
|
cout << "pvd.getAsULongLong() = " << pvd.getAsULongLong() << endl;
|
|
|
|
boost::shared_ptr<vector<double> > spVd = pvd.getAsVDouble();
|
|
cout << "pvd.getAsVDouble() = " << spVd.get()[0][0] << " [0] " << spVd.get()[0][1] << " [1] " << endl;
|
|
vector<double> * vd= spVd.get();
|
|
cout << "pvd.getAsVDouble() = " << vd[0][0] << " [0] " << vd[0][1] << " [1] " << endl;
|
|
|
|
boost::shared_ptr<vector<float> > spVf = pvd.getAsVFloat();
|
|
cout << "pvd.getAsVFloat() = " << spVf.get()[0][0] << " [0] " << spVf.get()[0][1] << " [1] " << endl;
|
|
vector<float> * vf= spVf.get();
|
|
cout << "pvd.getAsVFloat() = " << vf[0][0] << " [0] " << vf[0][1] << " [1] " << endl;
|
|
|
|
|
|
cout << "pvd.getPVName() = " << pvd.getPV() << endl;
|
|
cout << "pvd.getPVAlias() = " << pvd.getPVAlias() << endl;
|
|
cout << "pvd.getDevice() = " << pvd.getDevice() << endl;
|
|
cout << "pvd.getAttribute() = " << pvd.getAttribute() << endl;
|
|
cout << "pvd.getNelem() = " << pvd.getNelem() << endl;
|
|
cout << "pvd.getSize() = " << pvd.getSize() << endl; //Size of PVDataHolder container
|
|
cout << "pvd.getVal() = " << pvd.getVal() << endl; //CAFE_DATATYPE_UNION_SEQ type
|
|
cout << "pvd.getVal()[0].f = " << pvd.getVal()[0].f << endl; // extract assuming a float
|
|
cout << "pvd.getDataType() = " << pvd.getDataType() << endl; // CAFE_DATATYPE
|
|
|
|
cout << "pvd.getStatus() = " << pvd.getStatus() << endl;
|
|
|
|
cout << "pvd.getHasAlarm = " << pvd.getHasAlarm() << endl; // true if Alarm/Severity data returned
|
|
cout << "pvd.getAlarmStatus() = " << pvd.getAlarmStatus() << endl;
|
|
cout << "pvd.getAlarmSeverity() = " << pvd.getAlarmSeverity() << endl;
|
|
cout << "pvd.getHasTS = " << pvd.getHasTS() << endl; // true if Epics Timestamps data returned
|
|
ets= pvd.getEpicsTimeStamp();
|
|
cout << "epicsTimeStamp = " << ets.secPastEpoch << " " << ets.nsec << endl;
|
|
|
|
|
|
//cout << "pvd.getEnumIntegerValueAsString() = " << pvd.getEnumIntegerValueAsString() << endl; //for mbbi/o records
|
|
cout << "pvd.concatToString() = " << pvd.concatToString() << endl; //for waveforesm with data type dbr_chart_t
|
|
cout << "pvd.getWFAsString() = " << pvd.concatToString() << endl;
|
|
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//Alarm, status/severity values
|
|
//------------------------------------------------------------
|
|
|
|
//Alarm status and severities have value/name (int/string) pairs.
|
|
//The string equivalent of a given value may be gotten as shown
|
|
|
|
cout << "Alarm Status =" << alarmStat.asString(pvd.getAlarmStatus()) << endl;
|
|
cout << "Alarm Severity =" << alarmSev.asString(pvd.getAlarmSeverity()) << endl;
|
|
|
|
//Information concerning the meaning of the status of the cafe operation
|
|
cout << cstat.severity(pvd.getStatus()) << endl;
|
|
cout << cstat.asString(pvd.getStatus()) << endl;
|
|
cout << cstat.code(pvd.getStatus()) << endl;
|
|
cout << cstat.info(pvd.getStatus()) << endl;
|
|
cout << cstat.message(pvd.getStatus()) << endl;
|
|
//print summary
|
|
cstat.report(pvd.getStatus());
|
|
|
|
|
|
|
|
|
|
} // if status=ICAFE_NORMAL
|
|
//------------------------------------------------------------
|
|
//Set data
|
|
//The set method is able to intrepret all data types, and can
|
|
//cater for scalar values and arrays
|
|
//------------------------------------------------------------
|
|
|
|
status=cafe->set(PV_X1, 0.02453);
|
|
|
|
if (status!=ICAFE_NORMAL) {
|
|
cstat.report(status);
|
|
}
|
|
//or another way to print an error with pv name
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_X1),status);
|
|
|
|
|
|
|
|
//Now perform a get/set operation with a user supplied callback function
|
|
|
|
|
|
//Get original policy in case we want to use it again.
|
|
//ChannelRequestPolicy channelRequestPolicyGetOriginal;
|
|
//status=cafe->getPolicyHelper().getChannelRequestPolicyGet(hArray[0], channelRequestPolicyGetOriginal);
|
|
|
|
|
|
ChannelRequestPolicy channelRequestPolicyLocal;
|
|
//Supply user defined handle
|
|
channelRequestPolicyLocal.setHandler(handlerGet);
|
|
//Set policy to use
|
|
//ChannelWhenToFlushSendBufferPolicyKind CAFENUM::FLUSH_AFTER_EACH_MESSAGE
|
|
//ChannelWaitForResponsePolicyKind CAFENUM::WAIT
|
|
//ChannelRequestPolicyKind CAFENUM::WITH_CALLBACK_USER_SUPPLIED
|
|
channelRequestPolicyLocal.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::WAIT, CAFENUM::WITH_CALLBACK_USER_SUPPLIED);
|
|
|
|
//Now set this policy for GET operation for handle[0]
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyGet(hArray[0], channelRequestPolicyLocal);
|
|
//Modify policy to accept PutHandler
|
|
channelRequestPolicyLocal.setHandler(handlerPut);
|
|
//Now set this policy for PUT operation for hanlde[0]
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyPut(hArray[0], channelRequestPolicyLocal);
|
|
|
|
status=cafe->set(PV_X1, 0.62453);
|
|
|
|
|
|
cafe->get(PV_X1, f);
|
|
|
|
cout <<PV_X1 << " has value " << f << endl;
|
|
|
|
cafe->getCache(PV_X1, f);
|
|
|
|
cout <<PV_X1 << " has value " << f << endl;
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (2) Basic Single Channel Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
//cafe->terminate();
|
|
//exit(0);
|
|
|
|
//------------------------------------------------------------
|
|
//(3) Waveforms and Arrays
|
|
//------------------------------------------------------------
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (3) Waveforms and Arrays " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//Data retrieval methods returning a waveform array
|
|
//------------------------------------------------------------
|
|
|
|
PVDataHolder pvd_h;
|
|
pvd_h.setNelem(cafe->getNelemNative(hWF));
|
|
status=cafe->get(hWF, pvd_h);
|
|
cout << "n elements " << pvd_h.getNelem() << endl;
|
|
status=cafe->getCache(hWF, pvd_h);
|
|
cout << "n elements " << pvd_h.getNelem() << endl;
|
|
|
|
|
|
double * dwf = new double[cafe->getNelemNative(hWF)];
|
|
|
|
double inwf [20] = {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10, 11, 12, 13,14,15,16,17,18,19,20};
|
|
|
|
|
|
|
|
//by pvName
|
|
status=cafe->set(PV_WF, inwf);
|
|
status=cafe->get(PV_WF, dwf);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
}
|
|
else {
|
|
cout << PV_WF << " successfully read out " << endl;
|
|
cout << "First five elements have values: " << endl;
|
|
for (int i=0; i<std::min(5,(int) cafe->getNelemNative(hWF)); ++i) {
|
|
cout << dwf[i] << " [" << i << "] ";
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
|
|
//One may also set the number of elements to retrieve
|
|
//int nelem =cafe->getHandleHelper().setNelemToNative(hWF);
|
|
int nelem = cafe->getHandleHelper().setNelem(hWF, 10); //returns max(10, cafe->getNelemNative(handle))
|
|
//and offset
|
|
int offset = cafe->getHandleHelper().setOffset(hWF, 2);
|
|
//by Handle
|
|
status=cafe->get(hWF, dwf);
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
}
|
|
else {
|
|
cout << PV_WF << " sucessfully read out " << endl;
|
|
cout << "Elements 2 to 12 of WF (recall offset=2, nelem=10) have values:" << endl;
|
|
for (int i=0; i<nelem; ++i) {
|
|
cout << dwf[i] << " [" << i << "] ";
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
//reset offset for read and the nelemtonative
|
|
cout << "Resetting nelem for wf to native value: " << cafe->getHandleHelper().setNelemToNative(hWF)
|
|
<< " and resetting offset to: " << cafe->getHandleHelper().setOffset(hWF, 0) << endl;
|
|
|
|
cafe->get(hWF);
|
|
delete dwf;
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//Data retrieval methods returning a std::vector
|
|
//------------------------------------------------------------
|
|
vector<float> dV;
|
|
dbr_short_t alarmSta; dbr_short_t alarmSe; epicsTimeStamp tsta;
|
|
|
|
cout << "nELEM n: " << cafe->getHandleHelper().getNelemNative (hWF) << endl;
|
|
cout << "nELEM r: " << cafe->getHandleHelper().getNelemRequest(hWF) << endl;
|
|
cout << "nELEM c: " << cafe->getHandleHelper().getNelemClient (hWF) << endl;
|
|
|
|
cout << "set nelem to 16, get: " << cafe->getHandleHelper().setNelem(hWF,16) << endl;;
|
|
|
|
cout << "nELEM n: " << cafe->getHandleHelper().getNelemNative (hWF) << endl;
|
|
cout << "nELEM r: " << cafe->getHandleHelper().getNelemRequest(hWF) << endl;
|
|
cout << "nELEM c: " << cafe->getHandleHelper().getNelemClient (hWF) << endl;
|
|
|
|
|
|
cout << "get nelem cache get: " << cafe->getHandleHelper().getNelemToRetrieveFromCache(hWF) << endl;
|
|
cout << "set nelem cache to 18, get: " << cafe->getHandleHelper().setNelemToRetrieveFromCache(hWF,18) << endl;
|
|
cout << "get nelem cache get: " << cafe->getHandleHelper().getNelemToRetrieveFromCache(hWF) << endl;
|
|
|
|
//status=cafe->get(hWF, dV);
|
|
//cout << "dV.size " << dV.size() << endl;
|
|
status=cafe->getCache(hWF, dV, alarmSta, alarmSe, tsta);
|
|
cout << "status " << status << endl;
|
|
cout << "dV.size " << dV.size() << endl;
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
}
|
|
else {
|
|
cout << PV_WF << " successfully read out " << endl;
|
|
cout << "Elements 1-5 of WF have values:" << endl;
|
|
for (int i=0; i<min(25, (int) dV.size()); ++i) {
|
|
cout << dV[i] << " [" << i << "] ";
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
//status=cafe->get(hWF, dV);
|
|
//cout << "dV.size " << dV.size() << endl;
|
|
|
|
PVCtrlHolder pvc_h(cafe->getNelemNative(hWF));
|
|
|
|
pvc_h.setNelem(12);
|
|
|
|
status=cafe->getCtrl(hWF, pvc_h);
|
|
cout << "n elements " << pvc_h.getNelem() << endl;
|
|
|
|
|
|
cout << "get nelem ctrl cache get: " << cafe->getHandleHelper().getNelemToRetrieveFromCtrlCache(hWF) << endl;
|
|
cout << "set nelem ctrl cache to 18, get: " << cafe->getHandleHelper().setNelemToRetrieveFromCtrlCache(hWF,18) << endl;
|
|
cout << "get nelem ctrl cache get: " << cafe->getHandleHelper().getNelemToRetrieveFromCtrlCache(hWF) << endl;
|
|
|
|
status=cafe->getCtrlCache(hWF, pvc_h);
|
|
cout << "n elements " << pvc_h.setNelem(cafe->getHandleHelper().getNelemToRetrieveFromCtrlCache(hWF) ) << endl;
|
|
if (status != ICAFE_NORMAL) {
|
|
cout << "Status indicates an error at line no." << __LINE__ << endl;
|
|
cstat.report(status);
|
|
}
|
|
else {
|
|
cout << PV_WF << " successfully read out " << endl;
|
|
cout << "Elements of WF have values:" << endl;
|
|
for (int i=0; i<min(25, (int) pvc_h.getNelem() ); ++i) {
|
|
cout << pvc_h.getAsFloat(i) << " [" << i << "] ";
|
|
}
|
|
cout << endl;
|
|
}
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (3) Waveforms and Arrays " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
sleep(10);
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (4) Multiple Scalar Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
vector<int> statusV;
|
|
cafe->getScalars(hV, dV, statusV);
|
|
|
|
for (unsigned int i=0; i<hV.size(); ++i) {
|
|
cout << pvV[i] << " has value " << dV[i] << " and status " << statusV[i] << endl;
|
|
}
|
|
|
|
status=cafe->set(hV[0], 3.214);
|
|
|
|
//or Asynchronous gets
|
|
cafe->get(hV, statusV);
|
|
cafe->getCache(hV, dV, statusV);
|
|
|
|
|
|
for (unsigned int i=0; i<hV.size(); ++i) {
|
|
cout << pvV[i] << " has value " << dV[i] << " and status " << statusV[i] << endl;
|
|
}
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (4) Multiple Scalar Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (5) Multiple Compound Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
PVDataHolder pvdArray[NHANDLES];
|
|
for (int i=0; i<NHANDLES; ++i) {
|
|
pvdArray[i].setNelem(cafe->getNelemNative(hArray[i]));
|
|
}
|
|
|
|
|
|
|
|
//input Array of handles
|
|
//cout << "---------------------------------------" << endl;
|
|
//cout << "status=cafe->get(hArray, NHANDLES, pvdArray)" << endl;
|
|
//cout << "---------------------------------------" << endl;
|
|
|
|
status=cafe->get(hArray, NHANDLES, pvdArray);
|
|
|
|
|
|
//input vector of handles
|
|
//cout << "---------------------------------------" << endl;
|
|
//cout << "status=cafe->getPVArray(hV, pvdArray);" << endl;
|
|
//cout << "---------------------------------------" << endl;
|
|
|
|
status=cafe->getPVArray(hV, pvdArray);
|
|
|
|
|
|
//synchornous get
|
|
cout << "---------------------------------------" << endl;
|
|
cout << "status=cafe->get(hArray, NHANDLES, statusArray);" << endl;
|
|
cout << "---------------------------------------" << endl;
|
|
|
|
|
|
//Asynchronous get
|
|
int statusArray[NHANDLES];
|
|
status=cafe->get(hArray, NHANDLES, statusArray);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
//cstat.report(status);
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
cafe->printStatusIfError(hArray[i],statusArray[i]);
|
|
}
|
|
}
|
|
|
|
//now send message and get values
|
|
status=cafe->getCache(hArray, NHANDLES, pvdArray);
|
|
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
//if (pvdArray[i].getStatus() != ICAFE_NORMAL) {
|
|
pvdArray[i].print();
|
|
//}
|
|
}
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (5) Mulitple Compound Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (6) Synchronous Group Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
//CA SYNCHRONOUS GROUPS
|
|
//Define a Group, and perform synchronous group
|
|
|
|
|
|
vector<string> pvSeries;
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
pvSeries.push_back((const char *) pvArray[i].c_str());
|
|
}
|
|
|
|
cafe->groupDefine((const char *) "gTest", pvSeries);
|
|
|
|
unsigned int gHandle;
|
|
try {
|
|
cafe->groupOpen("gTest", gHandle);
|
|
}
|
|
catch(CAFEException_groupOpen &e) {
|
|
|
|
cout << e.what() << endl;
|
|
cstat.report(e.groupEx.statusCode);
|
|
exit(1);
|
|
}
|
|
|
|
PVGroup pvgroup;
|
|
|
|
//fill gvgroup with pv parameters from ghandle
|
|
//Tis is optional; will be done by groupGet
|
|
cafe->groupAttach(gHandle, pvgroup); //do not use groupFetch which will set nelem to 1 for wfs!
|
|
|
|
|
|
PVDataHolder * pvdA = pvgroup.getPVData();
|
|
pvdA[0].setNelem(1);
|
|
|
|
cafe->groupGet(gHandle, pvgroup);
|
|
|
|
//pvgroup.print();
|
|
pvgroup.print(pvgroup.getNPV(),25); // print all members; if wf, max 25 elements
|
|
|
|
|
|
pvdA[0].set(1.111);
|
|
double d4[4]= {1,2,3,4};
|
|
pvdA[2].set(d4);
|
|
|
|
|
|
status=cafe->groupSet(gHandle, pvgroup);
|
|
|
|
cafe->groupGet(gHandle, pvgroup);
|
|
|
|
|
|
//Alternatively...
|
|
for (size_t i=0; i<pvgroup.getNPV(); ++i) {
|
|
|
|
cout << "Name = " << pvdA[i].getPV() << endl;
|
|
cout << "Value = " << pvdA[i].getAsString() << "[0]" << endl;
|
|
cout << "Status= " << pvdA[i].getStatus() << endl;
|
|
cout << "Nelem = " << pvdA[i].getNelem() << endl;
|
|
cout << "Alarm Status = " << pvdA[i].getAlarmStatus() << endl;
|
|
cout << "Alarm Severity= " << pvdA[i].getAlarmSeverity() << endl;
|
|
cout << "Timestamp = " << pvdA[i].getEpicsTimeStamp().secPastEpoch
|
|
<< " sec. " << pvdA[i].getEpicsTimeStamp().nsec << " nsec " << endl;
|
|
cout << endl;
|
|
}
|
|
|
|
|
|
cafe->snapshot2XML(pvgroup);
|
|
|
|
//cafe->loadSFGroups("VA");
|
|
|
|
|
|
cout << "---------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (6) Synchronous Group Operations " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (7) Control System Parameters and Channel Information" << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
// An example of a single get that retrieves control display parameters
|
|
// Get ctrl limits
|
|
PVCtrlHolder pvc;
|
|
|
|
status=cafe->getCtrl(hArray[0], pvc);
|
|
|
|
if (status==ICAFE_NORMAL) {
|
|
pvc.print(); //just print
|
|
// Access a members explicitly
|
|
cout << "---------------------------------------" << endl;
|
|
cout << "Control Parameters " << endl;
|
|
cout << "---------------------------------------" << endl;
|
|
cout << "pv = " << pvc.getPV() << endl;
|
|
cout << "val (asString) = " << pvc.getAsString() << endl;
|
|
cout << "units = " << pvc.getUnits() << endl; // as char *
|
|
//cout << "units = " << pvc.getUnitsAsString() << endl; // as string
|
|
cout << "precision = " << pvc.getPrecision() << endl;
|
|
vector<std::string> strV = pvc.getEnumStrings();
|
|
for (unsigned int i=0; i< strV.size(); ++i) {
|
|
cout << strV[0] << " " ;
|
|
}
|
|
if (strV.size() >0) {cout << endl;}
|
|
cout << "AsDouble: " << endl;
|
|
cout << "upperDispLimit = " << pvc.getUpperDispLimit_AsDouble() << endl;
|
|
cout << "lowerDispLimit = " << pvc.getLowerDispLimit_AsDouble() << endl;
|
|
cout << "upperAlarmLimit = " << pvc.getUpperAlarmLimit_AsDouble() << endl;
|
|
cout << "upperWarningLimit= " << pvc.getUpperWarningLimit_AsDouble() << endl;
|
|
cout << "lowerWarningLimit= " << pvc.getLowerWarningLimit_AsDouble() << endl;
|
|
cout << "lowerAlarmLimit = " << pvc.getLowerAlarmLimit_AsDouble() << endl;
|
|
cout << "upperCtrlLimit = " << pvc.getUpperCtrlLimit_AsDouble() << endl;
|
|
cout << "lowerCtrlLimit = " << pvc.getLowerCtrlLimit_AsDouble() << endl;
|
|
cout << "AsString: " << endl;
|
|
cout << "upperDispLimit = " << pvc.getUpperDispLimit_AsString() << endl;
|
|
cout << "lowerDispLimit = " << pvc.getLowerDispLimit_AsString() << endl;
|
|
cout << "upperAlarmLimit = " << pvc.getUpperAlarmLimit_AsString() << endl;
|
|
cout << "upperWarningLimit= " << pvc.getUpperWarningLimit_AsString() << endl;
|
|
cout << "lowerWarningLimit= " << pvc.getLowerWarningLimit_AsString() << endl;
|
|
cout << "lowerAlarmLimit = " << pvc.getLowerAlarmLimit_AsString() << endl;
|
|
cout << "upperCtrlLimit = " << pvc.getUpperCtrlLimit_AsString() << endl;
|
|
cout << "lowerCtrlLimit = " << pvc.getLowerCtrlLimit_AsString() << endl;
|
|
cout << "---------------------------------------\n" << endl;
|
|
|
|
}
|
|
else {
|
|
cafe->printStatusIfError(hArray[0],status);
|
|
}
|
|
|
|
ChannelRegalia chInfo;
|
|
CAFEDataTypeCode cdt;
|
|
status=cafe->getChannelInfo(hArray[0], chInfo);
|
|
|
|
cout << "---------------------------------------" << endl;
|
|
cout << "Channel Information " << endl;
|
|
cout << "---------------------------------------" << endl;
|
|
cout << "channelID = " << chInfo.getChannelID() << endl;
|
|
cout << "channelID = " << cafe->getChannelIDAsString(chInfo.getChannelID()) << endl;
|
|
cout << "connectFlag = " << chInfo.getConnectFlag() << endl; //bool
|
|
cout << "hostName = " << chInfo.getHostName() << endl; //char *
|
|
cout << "hostName = " << chInfo.getHostNameAsString() << endl; //string
|
|
cout << "dataType = " << chInfo.getDataType() << endl;
|
|
cout << "dataType = " << cdt.asString( chInfo.getDataType() ) << endl;
|
|
cout << "className = " << chInfo.getClassName() << endl; //char *
|
|
cout << "className = " << chInfo.getClassNameAsString() << endl; //string
|
|
cout << "readAccess = " << chInfo.getReadAccess() << endl;
|
|
cout << "writeAccess = " << chInfo.getWriteAccess() << endl;
|
|
cout << "nElem = " << chInfo.getNelem() << endl;
|
|
cout << "connectionState = " << chInfo.getConnectionState() << endl;
|
|
cout << "connectionState = " << chInfo.getConnectionStateAsString() << endl;
|
|
cout << "cafeConnectionState = " << chInfo.getCafeConnectionState() << endl;
|
|
cout << "cafeConnectionState = " << chInfo.getCafeConnectionStateAsString() << endl;
|
|
cout << "---------------------------------------\n" << endl;
|
|
|
|
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (7) Control System Parameters and Channel Information" << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (8) Monitors, either with or without user supplied callbacks " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
//Simple Monitor
|
|
//cafe->monitorStart(hArray[0]);
|
|
//or
|
|
//cafe->monitorStart(cafe->getInfo().getHandleFromPV(PV_X1));
|
|
|
|
|
|
//Change Policy so that set is synchronous
|
|
ChannelRequestPolicy channelRequestPolicyPut;
|
|
channelRequestPolicyPut.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //Wait!!
|
|
|
|
ChannelRequestPolicy channelRequestPolicyGet;
|
|
channelRequestPolicyGet.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::WAIT, CAFENUM::WITHOUT_CALLBACK); //Wait!!
|
|
|
|
ChannelRequestPolicy channelRequestPolicyGetDefault;
|
|
channelRequestPolicyGetDefault.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
|
|
CAFENUM::WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //Wait!!
|
|
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyPut(channelRequestPolicyPut); //for all handles
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyPut(hArray[0], channelRequestPolicyPut); //for single handle
|
|
|
|
int NLOOPV =1;
|
|
// NLOOPV =100000; //double default) 60 secs 2) withoutcallback 54s
|
|
// NLOOPV =100000; float default) 43 secs 2) withoutcallback 43s
|
|
// NLOOPV =100000; short default) 51 secs 2) withoutcallback 46s
|
|
// NLOOPV =100000; short default) 52 secs 2) withoutcallback 56s //change policy to do conversion at ioc
|
|
// NLOOPV =100000; dbr_char_t default) 52 secs 2) withoutcallback 52s //change policy to do conversion at ioc
|
|
|
|
//However for Waveforms 4084 elements
|
|
// NLOOPV =10000; dbr_char_t default) 80 secs 2) withoutcallback 73s //change policy to CAFENUM::NATIVE_DATATYPE
|
|
// NLOOPV =10000; dbr_char_t default) 64 secs 2) withoutcallback 63s //change policy to CAFENUM::LOWEST_DATATYPE
|
|
|
|
ChannelRequestDataTypePolicy channelRequestDataTypePolicy;
|
|
channelRequestDataTypePolicy.setRequestKind(CAFENUM::LOWEST_DATATYPE);
|
|
status=cafe->getPolicyHelper().setChannelRequestDataTypePolicy(hArray[1],channelRequestDataTypePolicy);
|
|
|
|
dbr_float_t sl[5000];
|
|
system("date");
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyGet(hArray[1], channelRequestPolicyGetDefault);
|
|
for (int i=0; i<NLOOPV; ++i) {status=cafe->get(hArray[1], sl);}
|
|
system("date");
|
|
status=cafe->getPolicyHelper().setChannelRequestPolicyGet(hArray[1], channelRequestPolicyGet);
|
|
for (int i=0; i<NLOOPV; ++i) {status=cafe->get(hArray[1], sl);}
|
|
system("date");
|
|
|
|
|
|
MonitorPolicy mp, mp2;
|
|
mp.setUserArgs((void *) pvArray[0].c_str());
|
|
mp.setHandler(callbackHandlerMonitor);
|
|
mp.setCafeDbrType(CAFENUM::DBR_TIME);
|
|
mp.setDataType(DBR_STS_FLOAT); //THis will overwrite DBR_TIME above
|
|
mp.setMask(DBE_VALUE | DBE_LOG | DBE_ALARM);
|
|
|
|
mp2.setUserArgs((void *) hArray[0]);
|
|
mp2.setHandler(callbackHandlerMonitor);
|
|
mp2.setCafeDbrType(CAFENUM::DBR_TIME);
|
|
mp2.setDataType(DBR_STS_FLOAT); //THis will overwrite DBR_TIME above
|
|
mp2.setMask(DBE_VALUE | DBE_LOG | DBE_ALARM);
|
|
|
|
|
|
cafe->monitorStart(hArray[0], mp);
|
|
|
|
cafe->monitorStart(hArray[0], mp2);
|
|
|
|
|
|
cafe->set(hArray[0], 1.1023456);
|
|
usleep(100000); // 0.1s just about long enough to trigger an extra monitor
|
|
|
|
|
|
cafe->monitorStop(hArray[0], mp);
|
|
cafe->monitorStop(hArray[0], mp2.getMonitorID()); //Actually, only the monitorID is required
|
|
|
|
|
|
|
|
//start many Monitors
|
|
cafe->monitorStart(hArray, NHANDLES);
|
|
|
|
//sleep(1);
|
|
//get latest value from cache
|
|
status=cafe->getCache(hArray[0],d);
|
|
|
|
//get latest value from cache
|
|
status=cafe->getCache(hArray, NHANDLES, pvdArray);
|
|
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
//if (pvdArray[i].getStatus() != ICAFE_NORMAL) {
|
|
pvdArray[i].print();
|
|
//}
|
|
}
|
|
|
|
|
|
|
|
//stop many Monitors
|
|
cafe->monitorStop(hArray, NHANDLES);
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (8) Monitors, either with or without user supplied callbacks " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
cafe->terminate();
|
|
exit(1);
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (9) Asynchronous interactions and retrieving data from cache " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
status=cafe->get(hArray[0]);
|
|
//by array
|
|
status=cafe->get(hArray, NHANDLES, statusV);
|
|
//by vector
|
|
status=cafe->get(hV, statusV);
|
|
|
|
//cafe->_ca_flush_io();
|
|
cafe->flushNow();
|
|
|
|
status=cafe->getCache(hArray, NHANDLES, pvdArray);
|
|
|
|
int NL=10;
|
|
system("date");
|
|
for (int i=0; i<NL; ++i) {
|
|
status=cafe->getCachePVArray(hV, pvdArray);
|
|
}
|
|
system("date");
|
|
|
|
sleep(1);
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
pvdArray[i].print();
|
|
}
|
|
|
|
cafe->set(hArray[1], 3.333455666);
|
|
cafe->get(hArray[1]);
|
|
cafe->flushNow();
|
|
system("date");
|
|
for (int i=0; i<NL; ++i) {
|
|
status=cafe->getCache(hV, pvdArray);
|
|
}
|
|
system("date");
|
|
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
pvdArray[i].print();
|
|
}
|
|
|
|
|
|
status=cafe->getCache(hV, dV, statusV);
|
|
|
|
//for (size_t i=0; i<NHANDLES; ++i) {
|
|
// cout << "pv " << pvV[i] << " has value " << dV[i] << " and status " << statusV[i] << endl;
|
|
//}
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (9) Asynchronous interactions and retrieving data from cache " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (10) Synchronous group operations with externally defined groups " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (10) Synchronous group operations with externally defined groups " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (11) Special methods, match, setAndMatch " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
status=cafe->setAndGet(hWF, 2.2, d);
|
|
cafe->printStatusIfError(hWF, status);
|
|
|
|
cout << "val should be 2.2 " << d << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (11) Special methods, match, setAndMatch " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << "START: (12) Gracefully terminate CAFE " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
|
|
cout << "------------------------------------------------------------" << endl;
|
|
cout << " END: (12) Gracefully terminate CAFE " << endl;
|
|
cout << "------------------------------------------------------------" << endl;
|
|
|
|
cafe->printHandles();
|
|
|
|
sleep(1);
|
|
cafe->closeHandles(hV);
|
|
cafe->printHandles();
|
|
cafe->closeHandles();
|
|
cafe->groupClose();
|
|
//cafe->groupHandleErase();
|
|
cafe->printHandles();
|
|
|
|
cafe->terminate();
|
|
exit(0);
|
|
|
|
|
|
|
|
//------------------------------------------------------------
|
|
//(1) Quick Start
|
|
//------------------------------------------------------------
|
|
|
|
//status=cafe->get(PV_X1, d);
|
|
|
|
|
|
//cafe->terminate();
|
|
//exit(0);
|
|
|
|
//2 write/read wf
|
|
float fArray[256] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
|
|
status=cafe->set(PV_WF, fArray);
|
|
if (status!=ICAFE_NORMAL) {
|
|
cstat.report(status);
|
|
}
|
|
//or another way to print an error with pv name
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_WF),status);
|
|
|
|
//zero array
|
|
std::fill(fArray, fArray+256, 0);
|
|
|
|
//ask for 25 elements of the wf
|
|
cafe->getHandleHelper().setNelem(cafe->getInfo().getHandleFromPV(PV_WF),25);
|
|
|
|
status=cafe->get(PV_WF, fArray);
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_WF << " is a wf; the first 25 elements have values: " << endl;
|
|
for (size_t i=0; i<25; ++i) {
|
|
cout << fArray[i] << " [" << i << "] " ;
|
|
}
|
|
cout << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_WF),status);
|
|
}
|
|
|
|
|
|
status=cafe->set(PV_WF, 3.2);
|
|
|
|
double valD;
|
|
status=cafe->get(PV_WF, valD);
|
|
cout << "First Element of WF " << valD << endl;
|
|
|
|
cout << "Request=" << cafe->getHandleHelper().getNelemRequest(cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
cout << "Native =" << cafe->getHandleHelper().getNelemNative (cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
cout << "Client =" << cafe->getHandleHelper().getNelemClient (cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
|
|
|
|
status=cafe->get(PV_WF, fArray);
|
|
|
|
cout << "Request=" << cafe->getHandleHelper().getNelemRequest(cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
cout << "Native =" << cafe->getHandleHelper().getNelemNative (cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
cout << "Client =" << cafe->getHandleHelper().getNelemClient (cafe->getInfo().getHandleFromPV(PV_WF)) << endl;
|
|
|
|
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_WF << " is a wf; the first 25 elements have values: " << endl;
|
|
for (size_t i=0; i<cafe->getHandleHelper().getNelemRequest(cafe->getInfo().getHandleFromPV(PV_WF)); ++i) {
|
|
cout << fArray[i] << " [" << i << "] " ;
|
|
}
|
|
cout << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_WF),status);
|
|
}
|
|
|
|
//cafe->terminate();
|
|
//exit(0);
|
|
|
|
//3 write/read mbbi
|
|
|
|
status=cafe->set(PV_MBBI, "on");
|
|
if (status!=ICAFE_NORMAL) {
|
|
cstat.report(status);
|
|
}
|
|
//or another way to print an error with pv name
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_MBBI),status);
|
|
|
|
dbr_string_t sData; // i.e. char[40] sData;
|
|
status=cafe->get(PV_MBBI, sData);
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_MBBI << " has value= " << sData << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_MBBI),status);
|
|
}
|
|
|
|
unsigned short enumValue; //
|
|
status=cafe->get(PV_MBBI, enumValue);
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_MBBI << " has enumValue= " << enumValue << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_MBBI),status);
|
|
}
|
|
|
|
|
|
//Get Enum String from Index
|
|
cout << "String State = " << cafe->getInfo().getStringFromEnum(cafe->getInfo().getHandleFromPV(PV_MBBI), enumValue) << endl;
|
|
|
|
cout << "String State = " << cafe->getInfo().getStringFromEnum(cafe->getInfo().getHandleFromPV(PV_MBBI), 88) << endl;
|
|
|
|
cout << "String State = " << cafe->getInfo().getEnumFromString(cafe->getInfo().getHandleFromPV(PV_MBBI), " on 1") << endl;
|
|
//cafe->terminate();
|
|
//exit(0);
|
|
|
|
//4 Quick Start, reading alarmStatus, alarmSeverity, ts
|
|
|
|
d=0.0; // zero d
|
|
status=cafe->get(cafe->getInfo().getHandleFromPV(PV_X1), d, alarmStatus, alarmSeverity, ets);
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_X1 << " has value= " << d << endl;
|
|
cout << "alarmStatus= " << alarmStatus << " alarmSeverity=" << alarmSeverity
|
|
<< " timeStamp= " << ets.secPastEpoch << " sec. " << ets.nsec << " nsec " << endl;
|
|
}
|
|
else {
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_X1),status);
|
|
}
|
|
|
|
//5 Quick start, same as above but reading strutured data
|
|
//PVDataHolder pvd;
|
|
//Allocate memory
|
|
pvd.setNelem(cafe->getInfo().getNelemNative(cafe->getInfo().getHandleFromPV(PV_WF))); //Important, else memory will not be allocated to receive data
|
|
status=cafe->get(PV_WF, pvd);
|
|
//status=cafe->get(cafe->getInfo().getHandleFromPV(PV_WF), pvd);
|
|
if (status==ICAFE_NORMAL) {
|
|
pvd.print(25); //just print first 25 elements of the waveform
|
|
// Access data explicitly
|
|
cout << "Value (string format): " << endl;
|
|
for (size_t i=0; i<25; ++i) {
|
|
cout << pvd.getAsString(i) << " [" << i << "] " ;
|
|
}
|
|
cout << endl;
|
|
cout << "Value ( float format) " << pvd.getAsFloat() << endl;
|
|
for (size_t i=0; i<25; ++i) {
|
|
cout << pvd.getAsFloat(i) << " [" << i << "] " ;
|
|
}
|
|
cout << endl;
|
|
cout << "Alarm Status = " << pvd.getAlarmStatus() << endl;
|
|
cout << "Alarm Severity= " << pvd.getAlarmSeverity() << endl;
|
|
cout << "Timestamp = " << pvd.getEpicsTimeStamp().secPastEpoch
|
|
<< " sec. " << pvd.getEpicsTimeStamp().nsec << " nsec " << endl;
|
|
}
|
|
else {
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_WF),status);
|
|
}
|
|
|
|
|
|
// An example of a single get
|
|
// get string by handle
|
|
status=cafe->get(hArray[0], sData); //sData declared earlier
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_MBBI << " has value= " << sData << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(cafe->getInfo().getHandleFromPV(PV_MBBI),status);
|
|
}
|
|
|
|
// Another example of a single get
|
|
// get string by handle
|
|
dbr_string_t sDesc; //char[40];
|
|
status=cafe->get(hDesc, sDesc);
|
|
if (status==ICAFE_NORMAL) {
|
|
cout << PV_X1_DESC << " has value= " << sDesc << endl;
|
|
}
|
|
else {
|
|
//cstat.report(status);
|
|
cafe->printStatusIfError(hDesc,status);
|
|
}
|
|
|
|
|
|
|
|
// An example of a single get with data, alarms and timestamp
|
|
// Get structured data by handle
|
|
PVDataHolder pvd2;
|
|
pvd2.setNelem(1); //Important if nelements>1,
|
|
//else memory will not be allocated to receive data
|
|
|
|
status=cafe->get(hArray[0], pvd2);
|
|
if (status==ICAFE_NORMAL) {
|
|
pvd2.print(); //just print
|
|
// Access data explicitly
|
|
cout << "Value (string format): " << pvd2.getAsString() << endl;
|
|
cout << "Value ( float format) " << pvd2.getAsFloat() << endl;
|
|
cout << "Alarm Status = " << pvd2.getAlarmStatus() << endl;
|
|
cout << "Alarm Severity= " << pvd2.getAlarmSeverity() << endl;
|
|
cout << "Timestamp = " << pvd2.getEpicsTimeStamp().secPastEpoch
|
|
<< " sec. " << pvd2.getEpicsTimeStamp().nsec << " nsec " << endl;
|
|
}
|
|
else {
|
|
cafe->printStatusIfError(hArray[0],status);
|
|
}
|
|
|
|
|
|
|
|
//CA SYNCHRONOUS GROUPS
|
|
//Define a Group, and perform synchronous group
|
|
|
|
|
|
|
|
for (size_t kl=0; kl<1; ++kl) {
|
|
|
|
|
|
//2. ANOTHER WAY TO DO A GET ON A COLLECTIONM OF CHANNELS
|
|
//2. Gathers gets and send in one call
|
|
status=cafe->get(hArray, NHANDLES, pvdArray);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
cstat.report(status);
|
|
}
|
|
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
//if (pvdArray[i].getStatus() != ICAFE_NORMAL) {
|
|
pvdArray[i].print(); //Check how it should print enum!
|
|
//}
|
|
}
|
|
|
|
status=cafe->set(hArray[6],3.3) ; // change one value
|
|
if (status!=ICAFE_NORMAL) {
|
|
cafe->printStatusIfError(hArray[6],status);
|
|
}
|
|
|
|
cout << "---------------------------" << endl;
|
|
|
|
//3. Another way: gets and send in one call
|
|
//3. IN ESSENCE THIS IS THE SAME AS 2. but broken down into 2 parts
|
|
int statusArray[NHANDLES];
|
|
status=cafe->get(hArray, NHANDLES, statusArray);
|
|
|
|
if (status != ICAFE_NORMAL) {
|
|
//cstat.report(status);
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
cafe->printStatusIfError(hArray[i],statusArray[i]);
|
|
}
|
|
}
|
|
|
|
cout << "---------------------------" << endl;
|
|
status=cafe->getCache(hArray, NHANDLES, pvdArray);
|
|
|
|
for (size_t i=0; i<NHANDLES; ++i) {
|
|
//if (pvdArray[i].getStatus() != ICAFE_NORMAL) {
|
|
pvdArray[i].print();
|
|
//}
|
|
}
|
|
|
|
cout << "---------------------------" << endl;
|
|
|
|
//sleep(1);
|
|
} //for lpop
|
|
//cafe->printHandles();
|
|
|
|
|
|
|
|
|
|
//Start Monitors on Group
|
|
vector<int> statusMonV;
|
|
status=cafe->groupMonitorStart(gHandle, statusMonV); // monitorIDV);
|
|
|
|
|
|
cout << "MONITOR STARTED " << endl;
|
|
|
|
//sleep(1);
|
|
|
|
PVDataHolder * pvda=pvgroup.getPVData();
|
|
|
|
for (int ij=0; ij< pvgroup.getNPV(); ++ij) {
|
|
//pvda[ij].set(1.1234);//pvda->val[0].d+ij;
|
|
pvda[ij].set((string)"1.012");
|
|
}
|
|
|
|
|
|
pvgroup.setPVData(pvda);
|
|
|
|
status=cafe->groupSet(gHandle, pvgroup);
|
|
|
|
cout << "GROUP SET WITH status = " << status << endl;
|
|
|
|
//sleep(1);
|
|
|
|
status=cafe->groupGetCache(gHandle, pvgroup);
|
|
if ( status != ICAFE_NORMAL) {
|
|
cout << "STATUS from groupGetCache for group "
|
|
<< pvgroup.getName() << " is " << pvgroup.getStatusGroup() << "//" << status << endl;
|
|
for (int i=0; i<pvgroup.getNPV(); ++i) {
|
|
if ( pvgroup.getPVData()[i].getStatus() != ICAFE_NORMAL) {
|
|
cout << "Channel: " << pvgroup.getPVData()[i].getPVName() << endl;
|
|
cout << "Status: " << pvgroup.getPVData()[i].getStatus() << " [" << i << "] of "
|
|
<< pvgroup.getNPV() << endl;
|
|
cstat.report( pvgroup.getPVData()[i].getStatus() );
|
|
}
|
|
}
|
|
}
|
|
pvgroup.print();
|
|
|
|
|
|
cout << "STOPPING MONITORS" << endl;
|
|
status=cafe->monitorStop(hArray, NHANDLES);
|
|
|
|
|
|
cout << "STOPPING GROUP MONITORS" << endl;
|
|
|
|
status=cafe->groupMonitorStop(gHandle, statusV);
|
|
|
|
cout << "status " << status << endl;
|
|
|
|
vector<string> glist;
|
|
glist.clear();
|
|
glist.reserve(50);
|
|
cafe->groupList (glist);
|
|
for (int i=0; i< glist.size(); ++i) {
|
|
cout << glist[i] << " " << i << endl;
|
|
}
|
|
|
|
sleep(5);
|
|
|
|
cafe->groupClose();
|
|
glist.clear();
|
|
|
|
cafe->groupList (glist);
|
|
cout << " size " << glist.size() << endl;
|
|
for (int i=0; i< glist.size(); ++i) {
|
|
cout << glist[i] << " " << i << endl;
|
|
}
|
|
|
|
|
|
#if HAVE_PYTHON
|
|
|
|
cout << "HAVE PYTHON " << endl;
|
|
//dlopen("/opt/gfa/python-3.5/latest/lib/libpython3.5m.so", RTLD_GLOBAL|RTLD_LAZY);
|
|
Py_Finalize();
|
|
|
|
#endif
|
|
|
|
|
|
sleep(2);
|
|
//terminate cafe
|
|
|
|
cafe->terminate();
|
|
sleep(2);
|
|
return 0;
|
|
}
|