EasyPVA is a synchronous API for accessing PVData via PVAccess. It also provides a number of convience methods. It allows the client to request access without checking for failure, but throws an exception when a reuest fails. A client can also check for failues and thus prevent failures.
The EasyPVA API has the following features:
Simple examples of using easyPVA:
// easyGet
EasyPVAPtr easyPVA = EasyPVA::create();
double value = easyPVA->channel("exampleDouble")->get()->getData()->getDouble();
// easyPut
EasyChannelPtr channel = easyPVA->channel("exampleDouble");
EasyPutPtr put = channel->put();
EasyPutDataPtr putData = put->getData();
putData->putDouble(3.0); put->put();
// easyMonitor
EasyMonitorPtr monitor = easyPVA->channel("examplePowerSupply")->monitor("");
EasyMonitorDataPtr easyData = monitor->getData();
while(true) {
monitor->waitEvent();
cout << "changed\n";
easyData->showChanged(cout);
cout << "overrun\n";
easyData->showOverrun(cout);
monitor->releaseEvent();
}
// easyProcess
EasyChannelPtr channel = easyPVA->channel("exampleDouble");
EasyProcessPtr process = channel->createProcess();
process->process();
easyPVACPP includes a number of examples.
easyPVA does not provide support for:
An instance of EasyPVA is obtained via the call:
EasyPVAPtr easyPVA = EasyPVA::create();
EasyPVA has methods to create instances of EasyChannel. The client can specify the provider name or use the default provider. The client can manage it's own channels or can let easyPVA cache channels. An example of using the cached method is:
EasyChannelPtr easyChannel = easyPVA->channel("exampleDouble");
This will attempt to connect to channel exampleDouble. Since the client did not specify a timeout an exception wll be thrown if the connection request fails. The client will block until the connection is made or an exception is thrown. If the request succeeds, easyPVA caches the easyChannel so that if the client makes another request for the same channel the cached object is returned to the client.
An example of using a non cached method is:
EasyChannelPtr easyChannel = easyPVA->createChannel("exampleDouble");
This will create an EasyChannel and return it to the client. The client must itself connect. This is useful if the client wants to connect to multiple channels in parallel.
This provides methods for connecting to a channel and for creating instances of EasyField, EasyProcess, ..., EasyPutGet.
Connection must be made before any create method is called or an exception is raised. The following is a synchronous connection request:
easyChannel->connect(5.0); // BLOCKS AND THROWS IF NO CONNECT
This blocks until then connection is made or until timout occurs. An exception is raised if the connection request fails.
The same request can be made without blocking and without exceptions.
easyChannel->issueConnect(); // DOES NOT BLOCK
.....
Status status =easyChannel->waitConnect(5.0); // BLOCKS DOES NOT THROW
if(!status.isOK()) {
// failure do something
}
Once the channel is connected other Easy objects can be created. For example:
EasyGetPtr easyGet = easyChannel->get(); // DOES BLOCK
This is a caching request. If the client already has made an identical request the client will receive the cached object. If a new easyGet is created than it is connected before it is returned to the client.
The client can also managed it's own objects:
EasyGetPtr easyGet = easyChannel->createGet(); // DOES NOT BLOCK
The client must connect the easyGet.
This provides the data returned by easyGet and easyPutGet. It is obtained via:
EasyGetDataPtr easyData = easyGet->getData();
It provides methods to get everything returned by channelGet. In addition there are methods that make it easier to handle a value field that is a scalar or a scalarArray. Also for a scalar that is a double or a scalarArray with element type double.
An example is:
double value = easyData->getDouble();
It also keeps a bitSet showing which fields have changed since the last channelGet or channelPutGet.
To the client this looks identical to EasyGetData except that it provides two BitSets: changedBitSet and overrrunBitSet. It is used by easyMonitor.
This is used to provided data for easyPut and easyPutGet. It has many of the same methods as easyGetData. It does not have a bitSet. It also has put methods like:
void easyData->putDouble(5.0);
This provides methods to connect to channelGet and to issue get request. To connect via a single synchronous call:
eastGet->connect(); // BLOCKS AND CAN THROW
This can also be done in two steps:
easyGet->issueConnect(); // DOES NOT BLOCK ... Status status = easyGet->waitConnect(); // BLOCKS AND DOES NOT HROW
Once connected gets are issued via either:
void easyGet->get(); // BLOCKS AND CAN THROWor
easyGet->issueGet(); // DOES NOT BLOCK ... Status status = easyGet->waitGet(); // BLOCKS AND DOES NOT THROW
This is similar to easyGet except that it wraps channelPut instead of channelGet.
Once connected puts are issued via either:
void easyPut->put(); // BLOCKS AND CAN THROWor
easyPut->issuePut(); // DOES NOT BLOCK ... Status status = easyPut->waitPut(); // BLOCKS AND DOES NOT THROW
Connecting is similar to easyGet and easyPut. The other methods are:
Connecting is similar to easyGet. It has methods:
Connecting is similar to easyGet. It has methods:
Look at javaDoc for details.
This provides methods for connecting to multiple channels. A client can either use EasyMultiChannel directly or use EasyMultiDouble or EasyNTMultiChannel. But both impose restrictions on what can be accessed.
This provides support for gets and puts to the value field of multiple channels. Each channel must have a value field that is a numeric scalar. The client always sees the data as a PVDoubleArray. All channels must connect. If any problems occur an exception is thrown.
This provides support for gets and puts to the value field of multiple channels. Each channel must have a value field. The client always sees the data as a NTMultiChannel, which is one of the types provided by normativeTypesCPP. All channels must connect. If any problems occur an exception is thrown.