background
Earlier we set up a local PLCsimulation environment, KEPServerEX6read PLCthe data on the , and finally used it UAExpertas an OPC client to complete KEPServerEX6the data reading and subscription functions from this OPC server. In this article, we will implement a client through SpringBootthe integration library, including functions such as connection, node traversal, reading, writing, subscription, and batch subscription.MiloOPC UA
Milo library
MiloThe address of the library GitHub: https://github.com/eclipse/milo
MiloThe library provides OPC UAthe server and client SDK. Obviously, we only use the OPC UA Client SDK here .
Introduce dependencies
SpringBootIntroduce Milolibrary dependencies (clients SDK) into the backend project.
Implement OPCUA client
connect
/**
* 创建OPC UA客户端
*
* @param ip
* @param port
* @param suffix
* @return
* @throws Exception
*/
public OpcUaClient connectOpcUaServer(String ip, String port, String suffix) throws Exception {
String endPointUrl = "opc.tcp://" + ip + ":" + port + suffix;
Path securityTempDir = Paths.get(System.getProperty("java.io.tmpdir"), "security");
Files.createDirectories(securityTempDir);
if (!Files.exists(securityTempDir)) {
throw new Exception("unable to create security dir: " + securityTempDir);
}
OpcUaClient opcUaClient = OpcUaClient.create(endPointUrl,
endpoints ->
endpoints.stream()
.filter(e -> e.getSecurityPolicyUri().equals(SecurityPolicy.None.getUri()))
.findFirst(),
configBuilder ->
configBuilder
.setApplicationName(LocalizedText.english("eclipse milo opc-ua client"))
.setApplicationUri("urn:eclipse:milo:examples:client")
//访问方式
.setIdentityProvider(new AnonymousProvider())
.setRequestTimeout(UInteger.valueOf(5000))
.build()
);
opcUaClient.connect().get();
Thread.sleep(2000); // 线程休眠一下再返回对象，给创建过程一个时间。
return opcUaClient;
}
traverse nodes
/**
* 遍历树形节点
*
* @param client OPC UA客户端
* @param uaNode 节点
* @throws Exception
*/
public void listNode(OpcUaClient client, UaNode uaNode) throws Exception {
List<? extends UaNode> nodes;
if (uaNode == null) {
nodes = client.getAddressSpace().browseNodes(Identifiers.ObjectsFolder);
} else {
nodes = client.getAddressSpace().browseNodes(uaNode);
}
for (UaNode nd : nodes) {
//排除系统性节点，这些系统性节点名称一般都是以"_"开头
if (Objects.requireNonNull(nd.getBrowseName().getName()).contains("_")) {
continue;
}
System.out.println("Node= " + nd.getBrowseName().getName());
listNode(client, nd);
}
}
read specified node
/**
* 读取节点数据
*
* namespaceIndex可以通过UaExpert客户端去查询，一般来说这个值是2。
* identifier也可以通过UaExpert客户端去查询，这个值=通道名称.设备名称.标记名称
*
* @param client
* @param namespaceIndex
* @param identifier
* @throws Exception
*/
public void readNodeValue(OpcUaClient client, int namespaceIndex, String identifier) throws Exception {
//节点
NodeId nodeId = new NodeId(namespaceIndex, identifier);
//读取节点数据
DataValue value = client.readValue(0.0, TimestampsToReturn.Neither, nodeId).get();
// 状态
System.out.println("Status: " + value.getStatusCode());
//标识符
String id = String.valueOf(nodeId.getIdentifier());
System.out.println(id + ": " + value.getValue().getValue());
}
write to specified node
/**
* 写入节点数据
*
* @param client
* @param namespaceIndex
* @param identifier
* @param value
* @throws Exception
*/
public void writeNodeValue(OpcUaClient client, int namespaceIndex, String identifier, Float value) throws Exception {
//节点
NodeId nodeId = new NodeId(namespaceIndex, identifier);
//创建数据对象,此处的数据对象一定要定义类型，不然会出现类型错误，导致无法写入
DataValue newValue = new DataValue(new Variant(value), null, null);
//写入节点数据
StatusCode statusCode = client.writeValue(nodeId, newValue).join();
System.out.println("结果：" + statusCode.isGood());
}
Subscribe to the specified node
/**
* 订阅(单个)
*
* @param client
* @param namespaceIndex
* @param identifier
* @throws Exception
*/
private static final AtomicInteger atomic = new AtomicInteger();
public void subscribe(OpcUaClient client, int namespaceIndex, String identifier) throws Exception {
//创建发布间隔1000ms的订阅对象
client
.getSubscriptionManager()
.createSubscription(1000.0)
.thenAccept(t -> {
//节点
NodeId nodeId = new NodeId(namespaceIndex, identifier);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(), null, null);
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(UInteger.valueOf(atomic.getAndIncrement()), 1000.0, null, UInteger.valueOf(10), true);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
List<MonitoredItemCreateRequest> requests = new ArrayList<>();
requests.add(request);
//创建监控项，并且注册变量值改变时候的回调函数。
t.createMonitoredItems(
TimestampsToReturn.Both,
requests,
(item, id) -> item.setValueConsumer((it, val) -> {
System.out.println("nodeid :" + it.getReadValueId().getNodeId());
System.out.println("value :" + val.getValue().getValue());
})
);
}).get();
//持续订阅
Thread.sleep(Long.MAX_VALUE);
}
Subscribe to specified nodes in batches
/**
* 批量订阅
*
* @param client
* @throws Exception
*/
public void subscribeBatch(OpcUaClient client) throws Exception {
final CountDownLatch eventLatch = new CountDownLatch(1);
//处理订阅业务
handlerMultipleNode(client);
//持续监听
eventLatch.await();
}
/**
* 处理订阅业务
*
* @param client OPC UA客户端
*/
private void handlerMultipleNode(OpcUaClient client) {
try {
//创建订阅
ManagedSubscription subscription = ManagedSubscription.create(client);
List<NodeId> nodeIdList = new ArrayList<>();
for (String id : batchIdentifiers) {
nodeIdList.add(new NodeId(batchNamespaceIndex, id));
}
//监听
List<ManagedDataItem> dataItemList = subscription.createDataItems(nodeIdList);
for (ManagedDataItem managedDataItem : dataItemList) {
managedDataItem.addDataValueListener((t) -> {
System.out.println(managedDataItem.getNodeId().getIdentifier().toString() + ":" + t.getValue().getValue().toString());
});
}
} catch (Exception e) {
e.printStackTrace();
}
}
Regarding the batch subscription for disconnection and reconnection , you can refer to the source code at the end of the article. I have not conducted actual tests.
test
Connect to OPC UA server of KEPServerEX6
Use the one in the previous article KEPServerEX6as OPC UAa server to test the client functions we implemented. Here namespaceIndexand identifierrefer to KEPServerEX6the configuration of or the display UAExpertin the upper right corner of Attribute.
public class OpcUaStart {
public void start() throws Exception {
OpcUaClientService opcUaClientService = new OpcUaClientService();
// 与OPC UA服务端建立连接，并返回客户端实例
OpcUaClient client = opcUaClientService.connectOpcUaServer("127.0.0.1", "49320", "");
// 遍历所有节点
opcUaClientService.listNode(client, null);
// 读取指定节点的值
// opcUaClientService.readNodeValue(client, 2, "Demo.1500PLC.D1");
// opcUaClientService.readNodeValue(client, 2, "Demo.1500PLC.D2");
// 向指定节点写入数据
opcUaClientService.writeNodeValue(client, 2, "Demo.1500PLC.D1", 6f);
// 订阅指定节点
// opcUaClientService.subscribe(client, 2, "Demo.1500PLC.D1");
// 批量订阅多个节点
List<String> identifiers = new ArrayList<>();
identifiers.add("Demo.1500PLC.D1");
identifiers.add("Demo.1500PLC.D2");
opcUaClientService.setBatchNamespaceIndex(2);
opcUaClientService.setBatchIdentifiers(identifiers);
// opcUaClientService.subscribeBatch(client);
opcUaClientService.subscribeBatchWithReconnect(client);
}
}
OPC UARemember to enable the client in the startup class .
@SpringBootApplication
public class SpringbootOpcuaApplication {
public static void main(String[] args) throws Exception {
SpringApplication.run(SpringbootOpcuaApplication.class, args);
OpcUaStart opcUa = new OpcUaStart();
opcUa.start();
}
}
Connect to a test OPC UA server provided by Milo
MiloThe official provides an open OPC UAserver: opc.tcp://milo.digitalpetri.com:62541/milo, you can first use UAExpertto test the connection (I use an anonymous connection) to check the node and address information in it.
public class OpcUaStart {
public void start() throws Exception {
OpcUaClientService opcUaClientService = new OpcUaClientService();
// 与OPC UA服务端建立连接，并返回客户端实例
OpcUaClient client = opcUaClientService.connectOpcUaServer("milo.digitalpetri.com", "62541", "/milo");
// 遍历所有节点
// opcUaClientService.listNode(client, null);
// 读取指定节点的值
opcUaClientService.readNodeValue(client, 2, "Dynamic/RandomInt32");
opcUaClientService.readNodeValue(client, 2, "Dynamic/RandomInt64");
// 向指定节点写入数据
// opcUaClientService.writeNodeValue(client, 2, "Demo.1500PLC.D1", 6f);
// 订阅指定节点
// opcUaClientService.subscribe(client, 2, "Dynamic/RandomDouble");
// 批量订阅多个节点
List<String> identifiers = new ArrayList<>();
identifiers.add("Dynamic/RandomDouble");
identifiers.add("Dynamic/RandomFloat");
opcUaClientService.setBatchNamespaceIndex(2);
opcUaClientService.setBatchIdentifiers(identifiers);
// opcUaClientService.subscribeBatch(client);
opcUaClientService.subscribeBatchWithReconnect(client);
}
}
The test results are as follows:
possible problems
UaException: status=Bad_SessionClosed, message=The session was closed by the client.
Reason analysis: opcUaClient.connect().get();It is an asynchronous process, and the connection may not be established when reading and writing.
Solution: Thread.sleep(2000);// The thread sleeps for a while and then returns to the object, giving the creation process a time.
Reference
https://blog.csdn.net/u013457145/article/details/121283612
Source Code
https://github.com/heartsuit/demo-spring-boot/tree/master/springboot-opcua
If you have any questions or any bugs are found, please feel free to contact me.
Your comments and suggestions are welcome!