- 前言
- 一、Java实现OPC UA Client
- 二、代码展示
- 1.maven依赖
- 2.Client实现类
- 3.KeyStoreLoader实现类(实际没用到)
- 4.PLC数据操作类(浏览节点并未调通)
- 5.访问接口(浏览节点并未调通)
- 三、关于空间Index和节点Index
前言
在涉及PLC联网的项目中, 常常会使用OPC UA协议进行数据交互. JAVA如何实现OPC UA Client与OPC UA Server进行交互? 网上常用的交互方式是通过KepServer做中转的, 怎么不通过中转直接连接?
这篇文章只是大致介绍一下Java直接与西门子OPC UA Server的通讯方式, 默认读者已经对这些技术有了最简单的了解. 基础部分就不再过多介绍.
关键词: OPC UA, PLC, JAVA, Milo, Client, S7-1500
一、Java实现OPC UA Client
我的需求如下:
- Java实现OPC UA Client, 依赖资源易找, 有保障, 有先例.
- 通过符号地址访问数据, 而不是通过内存地址方式.
- 最好不要依赖第三方软硬件.
在网络上搜索Java实现OPC UA Client, 已经有很多实现方法. 主流的是引入Milo + KepServer实现, 还有少部分通过s7connector与PLC OPC UA Server连接. 但是这些实现方式都不太满足我的需求.
Milo + KepServer实现: 依赖KepServer, 需另外采购, 且不一定能通过甲方的软件审查. 参考JAVA使用OPC UA 方式与设备通信（milo）
s7connector实现: 通过内存地址访问数据, 不方便也不安全. 参考JAVA与PLC通讯读取数据(两种方式)
拜读一系列的文章之后, 我认为Milo + KepServer实现方式还可以进一步的优化, 可以将KepServer替换为任意一个PLC设备的OPC UA Server, 因为在原理上, Kepserver只是提供了一个标准的OPC UA Server, 和PLC设备的并没有本质区别.
所以, 在JAVA使用OPC UA 方式与设备通信（milo）的基础上, 对实现进行了修改, 以满足我的需求.
二、代码展示 1.maven依赖2.Client实现类org.eclipse.milo sdk-client 0.6.0 org.eclipse.milo dictionary-reader 0.6.0 org.eclipse.milo sdk-server 0.6.0 org.eclipse.milo dictionary-manager 0.6.0 org.bouncycastle bcpkix-jdk15on 1.70
package com.xckj.generalcontrol.controlsoft.client;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.config.OpcUaClientConfig;
import org.eclipse.milo.opcua.sdk.client.api.identity.AnonymousProvider;
import org.eclipse.milo.opcua.stack.client.DiscoveryClient;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.stack.core.types.builtin.LocalizedText;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.UInteger;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.security.Security;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
public class ClientGen {
static {
Security.addProvider(new BouncyCastleProvider());
}
private final Logger log = LoggerFactory.getLogger(getClass());
private final CompletableFuture future = new CompletableFuture<>();
public static OpcUaClient opcUaClient;
private String endpointUrl = "opc.tcp://192.168.1.11:4840";
@PostConstruct
public void createClient() {
try {
// Path securityTempDir = Paths.get(System.getProperty("java.io.tmpdir"), "security");
// Files.createDirectories(securityTempDir);
// if (!Files.exists(securityTempDir)) {
// throw new Exception("没有创建安全目录: " + securityTempDir);
// }
// log.info("安全目录: {}", securityTempDir.toAbsolutePath());
//
// //加载秘钥
// KeyStoreLoader loader = new KeyStoreLoader().load(securityTempDir);
//安全策略 None、Basic256、Basic128Rsa15、Basic256Sha256
SecurityPolicy securityPolicy = SecurityPolicy.None;
List endpoints;
try {
endpoints = DiscoveryClient.getEndpoints(endpointUrl).get();
} catch (Throwable ex) {
// 发现服务
String discoveryUrl = endpointUrl;
if (!discoveryUrl.endsWith("/")) {
discoveryUrl += "/";
}
discoveryUrl += "discovery";
log.info("开始连接 URL: {}", discoveryUrl);
endpoints = DiscoveryClient.getEndpoints(discoveryUrl).get();
}
EndpointDescription endpoint = endpoints.stream()
.filter(e -> e.getSecurityPolicyUri().equals(securityPolicy.getUri()))
.findFirst()
.orElseThrow(() -> new Exception("没有连接上端点"));
log.info("使用端点: {} [{}/{}]", endpoint.getEndpointUrl(), securityPolicy, endpoint.getSecurityMode());
OpcUaClientConfig config = OpcUaClientConfig.builder()
.setApplicationName(LocalizedText.english("eclipse milo opc-ua client"))
.setApplicationUri("urn:eclipse:milo:examples:client")
//.setCertificate(loader.getClientCertificate())
//.setKeyPair(loader.getClientKeyPair())
.setEndpoint(endpoint)
//根据匿名验证和第三个用户名验证方式设置传入对象 AnonymousProvider（匿名方式）UsernameProvider（账户密码）
//new UsernameProvider("admin","123456")
.setIdentityProvider(new AnonymousProvider())
.setRequestTimeout(UInteger.valueOf(5000))
.build();
opcUaClient = OpcUaClient.create(config);
} catch (Exception e) {
log.error("创建客户端失败", e);
}
}
}
3.KeyStoreLoader实现类(实际没用到)
package com.xckj.generalcontrol.controlsoft.util;
import org.eclipse.milo.opcua.sdk.server.util.HostnameUtil;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateBuilder;
import org.eclipse.milo.opcua.stack.core.util.SelfSignedCertificateGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.*;
import java.security.cert.X509Certificate;
import java.util.regex.Pattern;
public class KeyStoreLoader {
private static final Pattern IP_ADDR_PATTERN = Pattern.compile(
"^(([01]?\d\d?|2[0-4]\d|25[0-5])\.){3}([01]?\d\d?|2[0-4]\d|25[0-5])$");
private static final String CLIENT_ALIAS = "client-ai";
private static final char[] PASSWORD = "password".toCharArray();
private final Logger logger = LoggerFactory.getLogger(getClass());
private X509Certificate clientCertificate;
private KeyPair clientKeyPair;
public KeyStoreLoader load(Path baseDir) throws Exception {
KeyStore keyStore = KeyStore.getInstance("PKCS12");
Path serverKeyStore = baseDir.resolve("example-client.pfx");
logger.info("Loading KeyStore at {}", serverKeyStore);
if (!Files.exists(serverKeyStore)) {
keyStore.load(null, PASSWORD);
KeyPair keyPair = SelfSignedCertificateGenerator.generateRsaKeyPair(2048);
SelfSignedCertificateBuilder builder = new SelfSignedCertificateBuilder(keyPair)
.setCommonName("Eclipse Milo Example Client")
.setOrganization("digitalpetri")
.setOrganizationalUnit("dev")
.setLocalityName("Folsom")
.setStateName("CA")
.setCountryCode("US")
.setApplicationUri("urn:eclipse:milo:examples:client")
.addDnsName("localhost")
.addIpAddress("127.0.0.1");
// Get as many hostnames and IP addresses as we can listed in the certificate.
for (String hostname : HostnameUtil.getHostnames("0.0.0.0")) {
if (IP_ADDR_PATTERN.matcher(hostname).matches()) {
builder.addIpAddress(hostname);
} else {
builder.addDnsName(hostname);
}
}
X509Certificate certificate = builder.build();
keyStore.setKeyEntry(CLIENT_ALIAS, keyPair.getPrivate(), PASSWORD, new X509Certificate[]{certificate});
try (OutputStream out = Files.newOutputStream(serverKeyStore)) {
keyStore.store(out, PASSWORD);
}
} else {
try (InputStream in = Files.newInputStream(serverKeyStore)) {
keyStore.load(in, PASSWORD);
}
}
Key serverPrivateKey = keyStore.getKey(CLIENT_ALIAS, PASSWORD);
if (serverPrivateKey instanceof PrivateKey) {
clientCertificate = (X509Certificate) keyStore.getCertificate(CLIENT_ALIAS);
PublicKey serverPublicKey = clientCertificate.getPublicKey();
clientKeyPair = new KeyPair(serverPublicKey, (PrivateKey) serverPrivateKey);
}
return this;
}
public X509Certificate getClientCertificate() {
return clientCertificate;
}
public KeyPair getClientKeyPair() {
return clientKeyPair;
}
}
4.PLC数据操作类(浏览节点并未调通)
package com.xckj.generalcontrol.controlsoft.client;
import cn.minsin.core.tools.StringUtil;
import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaMonitoredItem;
import org.eclipse.milo.opcua.sdk.client.api.subscriptions.UaSubscription;
import org.eclipse.milo.opcua.stack.core.AttributeId;
import org.eclipse.milo.opcua.stack.core.Identifiers;
import org.eclipse.milo.opcua.stack.core.types.builtin.DataValue;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.builtin.StatusCode;
import org.eclipse.milo.opcua.stack.core.types.builtin.Variant;
import org.eclipse.milo.opcua.stack.core.types.enumerated.*;
import org.eclipse.milo.opcua.stack.core.types.structured.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;
@Component
public class OpcUaOperationSupport {
private final Logger logger = LoggerFactory.getLogger(getClass());
public String browseNode() {
OpcUaClient client = ClientGen.opcUaClient;
try {
client.connect().get();
return browseNode("", client, Identifiers.RootFolder);
} catch (InterruptedException | ExecutionException e) {
logger.error("", e);
return e.getMessage();
}
}
public String readPlc(int namespaceIndex, int nameIndex) {
OpcUaClient client = ClientGen.opcUaClient;
try {
client.connect().get();
NodeId nodeId = new NodeId(namespaceIndex, nameIndex);
CompletableFuture readValue = client.readValue(0.0, TimestampsToReturn.Both, nodeId);
DataValue value = readValue.get();
String plcValue = value.getValue().getValue().toString();
String statusCode = String.valueOf(value.getStatusCode());
if (value.getStatusCode() != null) {
if (value.getStatusCode().isGood()) {
logger.info("获取数据成功。plcValue={}", plcValue);
} else {
logger.info("获取数据失败。");
}
logger.info("======== > it means successfully read StatusCode = {}", statusCode);
} else {
logger.error("=====》 读数据异常，未获取到数据。。。");
}
return plcValue;
} catch (InterruptedException | ExecutionException e) {
logger.error("", e);
return e.getMessage();
}
}
public String writePlc(int namespaceIndex, int itemIndex, String valueType, String editValue) {
try {
// 创建连接
OpcUaClient client = ClientGen.opcUaClient;
client.connect().get();
// 创建节点
NodeId nodeId = new NodeId(namespaceIndex, itemIndex);
// 创建Variant对象和DataValue对象
Variant v;
String valueTypeStr = StringUtil.trim(StringUtil.lowerCase(valueType));
switch (valueTypeStr) {
case "boolean":
v = new Variant(Boolean.valueOf(editValue));
break;
case "int":
v = new Variant(Integer.valueOf(editValue));
break;
case "short":
v = new Variant(Short.valueOf(editValue));
break;
case "string":
default:
v = new Variant(editValue);
break;
}
DataValue dv = new DataValue(v, null, null);
StatusCode statusCode = client.writeValue(nodeId, dv).get();
if (statusCode.isGood()) {
logger.info("========== > it means successfully Wrote '{}' to nodeId={}, statusCodes = {}", v, nodeId, statusCode);
} else {
logger.error("statusCodes: {}", statusCode);
}
return statusCode.toString();
} catch (InterruptedException | ExecutionException e) {
logger.error("", e);
return e.getMessage();
}
}
public void createSubscription(int namespaceIndex, int itemIndex) {
try {
OpcUaClient client = ClientGen.opcUaClient;
client.connect().get();
//创建发布间隔1000ms的订阅对象
UaSubscription subscription = client.getSubscriptionManager().createSubscription(1000.0).get();
//创建监控的参数
MonitoringParameters parameters = new MonitoringParameters(
uint(1),
// 发布间隔
1000.0,
// filter, 空表示用默认值
null,
// 队列大小
uint(10),
//放弃旧配置
true
);
//创建订阅的变量
NodeId nodeId = new NodeId(namespaceIndex, itemIndex);
ReadValueId readValueId = new ReadValueId(nodeId, AttributeId.Value.uid(), null, null);
//创建监控项请求
//该请求最后用于创建订阅。
MonitoredItemCreateRequest request = new MonitoredItemCreateRequest(readValueId, MonitoringMode.Reporting, parameters);
List requests = new ArrayList<>();
requests.add(request);
//创建监控项，并且注册变量值改变时候的回调函数。
UaSubscription.ItemCreationCallback onItemCreated =
(subscriptionItem, id) -> subscriptionItem.setValueConsumer((UaMonitoredItem item1, DataValue value) -> {
logger.info("===== > here is callbacks ... 订阅的回调函数。 ");
logger.info("订阅成功, item1 : {}", item1.getReadValueId().getNodeId().toString());
logger.info("subscription value received: item={}, value={}", item1.getReadValueId().getNodeId(), value.getValue());
}
);
List monitoredItems = subscription.createMonitoredItems(
TimestampsToReturn.Both,
requests,
onItemCreated
).get();
for (UaMonitoredItem monitoredItem : monitoredItems) {
if (monitoredItem.getStatusCode().isGood()) {
logger.info("item created for nodeId={}", monitoredItem.getReadValueId().getNodeId());
} else {
logger.warn(
"failed to create item for nodeId={} (status={})",
monitoredItem.getReadValueId().getNodeId(), monitoredItem.getStatusCode());
}
}
} catch (Exception e) {
logger.error("订阅变量失败", e);
}
}
private String browseNode(String indent, OpcUaClient client, NodeId browseRoot) {
BrowseDescription browse = new BrowseDescription(
browseRoot,
BrowseDirection.Forward,
Identifiers.References,
true,
uint(NodeClass.Object.getValue() | NodeClass.Variable.getValue()),
uint(BrowseResultMask.All.getValue())
);
try {
BrowseResult browseResult = client.browse(browse).get();
ReferenceDescription[] references = browseResult.getReferences();
StringBuilder nodesInfo = new StringBuilder();
for (ReferenceDescription rd : references) {
logger.info("{} Node={}", indent, rd.getBrowseName().getName());
nodesInfo.append(indent).append(" Node=").append(rd.getBrowseName().getName()).append("n");
// recursively browse to children
rd.getNodeId().toNodeId(client.getNamespaceTable())
.ifPresent(nodeId -> browseNode(indent + " ", client, nodeId));
}
return nodesInfo.toString();
} catch (InterruptedException | ExecutionException e) {
logger.error("Browsing nodeId={} failed: {}", browseRoot, e.getMessage(), e);
return e.getMessage();
}
}
}
5.访问接口(浏览节点并未调通)
package com.xckj.generalcontrol.controlsoft.controller;
import com.alibaba.fastjson.JSONObject;
import com.xckj.generalcontrol.controlsoft.client.OpcUaOperationSupport;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@RequestMapping("/opcUa")
public class OpcUaController {
@Resource
private OpcUaOperationSupport opcUaOperationSupport;
@PostMapping(value = "/")
public String test() {
return "hello ";
}
@PostMapping(value = "/query")
public String readPlc(@RequestBody JSONObject paramJson) {
int namespaceIndex = paramJson.getIntValue("namespaceIndex");
int itemIndex = paramJson.getIntValue("itemIndex");
return opcUaOperationSupport.readPlc(namespaceIndex, itemIndex);
}
@PostMapping(value = "/subscription")
public void readSubscriptionPlc(@RequestBody JSONObject paramJson) {
int namespaceIndex = paramJson.getIntValue("namespaceIndex");
int itemIndex = paramJson.getIntValue("itemIndex");
opcUaOperationSupport.createSubscription(namespaceIndex, itemIndex);
}
@PostMapping(value = "/edit")
public String writePlc(@RequestBody JSONObject paramJson) {
int namespaceIndex = paramJson.getIntValue("namespaceIndex");
int itemIndex = paramJson.getIntValue("itemIndex");
String valueType = paramJson.getString("valueType");
String editValue = paramJson.getString("editValue");
return opcUaOperationSupport.writePlc(namespaceIndex, itemIndex, valueType, editValue);
}
@PostMapping("/browseNode")
public String browseNode() {
return opcUaOperationSupport.browseNode();
}
}
三、关于空间Index和节点Index
仔细观看我实现的代码与前人写的与KepServer连接的代码, 可以发现主要的区别在于需要传入namespaceIndex和itemIndex两个.
KepServer: NodeId nodeId = new NodeId(2, item);
S7-1500: NodeId nodeId = new NodeId(namespaceIndex, nameIndex);
用KepServer做Server端, namespaceIndex固定传2, identifier传入String类型的NodeId
用S7-1500做Server端, namespaceIndex和identifier需要根据expert显示的传入, identifier传入int类型
那么这两个值能够在哪里获取到呢?
通过PLC工程师常用的UaExpert这个软件, 我们可以找到plc数据对应的namespaceIndex, itemIndex
kepServer:
S7-1500:
比如想获取截图里的plcValue, namespaceIndex应传4, itemIndex应传9
