Java实现OPC UA Client直接与PLC通讯

---

前言

在涉及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

我的需求如下:

1. Java实现OPC UA Client, 依赖资源易找, 有保障, 有先例.
2. 通过符号地址访问数据, 而不是通过内存地址方式.
3. 最好不要依赖第三方软硬件.

在网络上搜索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依赖

<!--与控制软件的plc OPC通信-->
<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>sdk-client</artifactId>
    <version>0.6.0</version>
</dependency>
<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>dictionary-reader</artifactId>
    <version>0.6.0</version>
</dependency>
<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>sdk-server</artifactId>
    <version>0.6.0</version>
</dependency>
<dependency>
    <groupId>org.eclipse.milo</groupId>
    <artifactId>dictionary-manager</artifactId>
    <version>0.6.0</version>
</dependency>
<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcpkix-jdk15on</artifactId>
    <version>1.70</version>
</dependency>

2.Client实现类

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;

/**
 * @author lgy
 * @date 
 */
@Component
public class ClientGen {

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    private final Logger log = LoggerFactory.getLogger(getClass());

    private final CompletableFuture<OpcUaClient> 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<EndpointDescription> 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;

/**
 * @author lgy
 */
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;

/**
 * @author lgy
 * @date 
 */
@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();
        }
    }

    /**
     * 单个读取 PLC
     */
    public String readPlc(int namespaceIndex, int nameIndex) {
        OpcUaClient client = ClientGen.opcUaClient;
        try {
            client.connect().get();
            NodeId nodeId = new NodeId(namespaceIndex, nameIndex);
            CompletableFuture<DataValue> 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();
        }
    }

    /**
     * 写入 PLC
     */
    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<MonitoredItemCreateRequest> 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<UaMonitoredItem> 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;


/**
 * @author lgy
 */
@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

---