/** Subscribe for value updates. */
private void subscribe() {
synchronized (this) {
// Prevent multiple subscriptions.
if (subscription != null) {
return;
}
// Late callback, channel already closed?
final RefCountedChannel ch_ref = channel_ref;
if (ch_ref == null) {
return;
}
final Channel channel = ch_ref.getChannel();
// final Logger logger = Activator.getLogger();
try {
if (channel.getConnectionState() != Channel.CONNECTED) {
return;
}
//
// the RefCountedChannel should maintain a single
// subscription to the underlying CAJ/JCA channel.
// So even with N PVs for the same channel, it's
// only one subscription on the network instead of
// N subscriptions.
final DBRType type = DBR_Helper.getTimeType(plain, channel.getFieldType());
state = PVConnectionState.Subscribing;
totalMetaInfo.setStartTime(System.currentTimeMillis());
// isnotTimestampDBR
if (this.name.endsWith(".RTYP")) {
subscription = channel.addMonitor(MonitorMask.ARCHIVE.getMask(), this);
} else {
subscription =
channel.addMonitor(
type, channel.getElementCount(), MonitorMask.ARCHIVE.getMask(), this);
}
} catch (final Exception ex) {
logger.error("exception when subscribing pv " + name, ex);
}
}
}
/** @param channelName */
public void execute(String channelName) {
try {
// initialize context
initialize();
// Create the Channel to connect to the PV.
Channel channel = context.createChannel(channelName);
// Send the request and wait 5.0 seconds for the channel to connect to the PV.
context.pendIO(5.0);
// If we're here, then everything went fine.
// Display basic information about the channel.
channel.printInfo();
/** ***************************************************************** */
/** *************************** sync get **************************** */
/** ***************************************************************** */
System.out.println("\n------------------------------------------------\n");
System.out.println("Sync get:");
// get request w/o callbacks will wait until flush/pendIO is called
// (channel default 'type' and 'count' is used)
DBR dbr = channel.get();
context.pendIO(3.0);
dbr.printInfo();
System.out.println();
dbr = channel.get(DBRType.STRING, 1);
context.pendIO(3.0);
String[] value = ((STRING) dbr).getStringValue();
System.out.println("Read string value: " + value[0]);
/** ***************************************************************** */
/** ************************** async get **************************** */
/** ***************************************************************** */
System.out.println("\n------------------------------------------------\n");
System.out.println("Async get:");
// get request w/ callbacks are always issued immediately
// not related to pendIO at all, but require pend_event (to be flushed also)
GetListenerImpl listener = new GetListenerImpl();
channel.get(listener);
synchronized (listener) {
// flush & get event back
context.flushIO();
// wait for response...
listener.wait(3000);
}
if (listener.getStatus() == CAStatus.NORMAL) listener.getValue().printInfo();
else System.err.println("Get error: " + listener.getStatus());
/** ***************************************************************** */
/** *************************** Monitors **************************** */
/** ***************************************************************** */
System.out.println("\n------------------------------------------------\n");
System.out.println("Monitors:");
System.out.println();
// Create a monitor
Monitor monitor = channel.addMonitor(Monitor.VALUE, new MonitorListenerImpl());
context.flushIO();
// Sleep for 10 seconds (monitors will be printed out).
Thread.sleep(10000);
// Clear the monitor
monitor.clear();
System.out.println("\n------------------------------------------------");
/** ***************************************************************** */
/** ***************************************************************** */
/** ***************************************************************** */
// Disconnect the channel.
channel.destroy();
// Flush all pending requests...
context.flushIO();
System.out.println("Done.");
} catch (Throwable th) {
th.printStackTrace();
} finally {
// always finalize
destroy();
}
}