Pva is a synchronous API for accessing PVData via PVAccess. It also provides a number of convenience methods. It allows the client to request access without checking for failure, but throws an exception if a request fails. A client can also check for failues and thus prevent exceptions.
The Pva API has the following features:
Simple examples of using pva:
// pvaGet
PvaPtr pva = Pva::create();
double value = pva->channel("exampleDouble")->get()->getData()->getDouble();
// pvaPut
PvaChannelPtr channel = pva->channel("exampleDouble");
PvaPutPtr put = channel->put();
PvaPutDataPtr putData = put->getData();
putData->putDouble(3.0); put->put();
// pvaMonitor
PvaMonitorPtr monitor = pva->channel("examplePowerSupply")->monitor("");
PvaMonitorDataPtr pvaData = monitor->getData();
while(true) {
monitor->waitEvent();
cout << "changed\n";
pvaData->showChanged(cout);
cout << "overrun\n";
pvaData->showOverrun(cout);
monitor->releaseEvent();
}
// pvaProcess
PvaChannelPtr channel = pva->channel("exampleDouble");
PvaProcessPtr process = channel->createProcess();
process->process();
pvaExample includes a number of examples.
pva does not provide support for:
An instance of Pva is obtained via the call:
PvaPtr pva = Pva::create();
Pva has methods to create instances of PvaChannel. The client can specify the provider name or use the default provider. The client can manage it's own channels or can let pva cache channels. An example of using the cached method is:
PvaChannelPtr pvaChannel = pva->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, pva caches the pvaChannel 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:
PvaChannelPtr pvaChannel = pva->createChannel("exampleDouble");
This will create an PvaChannel 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 PvaField, PvaProcess, ..., PvaPutGet.
Connection must be made before any create method is called or an exception is raised. The following is a synchronous connection request:
pvaChannel->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.
pvaChannel->issueConnect(); // DOES NOT BLOCK
.....
Status status =pvaChannel->waitConnect(5.0); // BLOCKS DOES NOT THROW
if(!status.isOK()) {
// failure do something
}
Once the channel is connected other Pva objects can be created. For example:
PvaGetPtr pvaGet = pvaChannel->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 pvaGet is created than it is connected before it is returned to the client.
The client can also managed it's own objects:
PvaGetPtr pvaGet = pvaChannel->createGet(); // DOES NOT BLOCK
The client must connect the pvaGet.
This provides the data returned by pvaGet and pvaPutGet. It is obtained via:
PvaGetDataPtr pvaData = pvaGet->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 = pvaData->getDouble();
It also keeps a bitSet showing which fields have changed since the last channelGet or channelPutGet.
To the client this looks identical to PvaGetData except that it provides two BitSets: changedBitSet and overrrunBitSet. It is used by pvaMonitor.
This is used to provided data for pvaPut and pvaPutGet. It has many of the same methods as pvaGetData. It does not have a bitSet. It also has put methods like:
void pvaData->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:
pvaGet->issueConnect(); // DOES NOT BLOCK ... Status status = pvaGet->waitConnect(); // BLOCKS AND DOES NOT HROW
Once connected gets are issued via either:
void pvaGet->get(); // BLOCKS AND CAN THROWor
pvaGet->issueGet(); // DOES NOT BLOCK ... Status status = pvaGet->waitGet(); // BLOCKS AND DOES NOT THROW
This is similar to pvaGet except that it wraps channelPut instead of channelGet.
Once connected puts are issued via either:
void pvaPut->put(); // BLOCKS AND CAN THROWor
pvaPut->issuePut(); // DOES NOT BLOCK ... Status status = pvaPut->waitPut(); // BLOCKS AND DOES NOT THROW
Connecting is similar to pvaGet and pvaPut. The other methods are:
Connecting is similar to pvaGet. It has methods:
Connecting is similar to pvaGet. It has methods:
Look at javaDoc for details.
This provides methods for connecting to multiple channels. A client can either use PvaMultiChannel directly or use PvaMultiDouble or PvaNTMultiChannel. 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.