springboot-opc_ua实现客户端通讯

已于 2023-03-09 14:37:37 修改
阅读量1.9k 收藏 6
点赞数 1
分类专栏： springboot 文章标签： spring boot java
于 2022-04-15 17:51:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47848696/article/details/124200493
版权

1、客户端依赖包

 <dependency>
            <groupId>org.eclipse.milo</groupId>
            <artifactId>sdk-client</artifactId>
            <version>0.2.4</version>
        </dependency>

具体实现

package com.water.chlorine.utils;


import com.water.chlorine.WaterChlorineApplication;
import com.water.chlorine.entity.DictCode;
import com.water.chlorine.mapper.DictCodeMapper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
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.nodes.Node;
import org.eclipse.milo.opcua.sdk.client.nodes.UaNode;
import org.eclipse.milo.opcua.stack.client.UaTcpStackClient;
import org.eclipse.milo.opcua.stack.core.Identifiers;
import org.eclipse.milo.opcua.stack.core.UaException;
import org.eclipse.milo.opcua.stack.core.security.SecurityPolicy;
import org.eclipse.milo.opcua.stack.core.types.builtin.*;
import org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.UInteger;
import org.eclipse.milo.opcua.stack.core.types.enumerated.BrowseDirection;
import org.eclipse.milo.opcua.stack.core.types.enumerated.BrowseResultMask;
import org.eclipse.milo.opcua.stack.core.types.enumerated.NodeClass;
import org.eclipse.milo.opcua.stack.core.types.enumerated.TimestampsToReturn;
import org.eclipse.milo.opcua.stack.core.types.structured.BrowseDescription;
import org.eclipse.milo.opcua.stack.core.types.structured.BrowseResult;
import org.eclipse.milo.opcua.stack.core.types.structured.EndpointDescription;
import org.eclipse.milo.opcua.stack.core.types.structured.ReferenceDescription;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.eclipse.milo.opcua.sdk.client.OpcUaClient;
import org.eclipse.milo.opcua.stack.core.Identifiers;
import org.eclipse.milo.opcua.stack.core.types.builtin.NodeId;
import org.eclipse.milo.opcua.stack.core.types.enumerated.BrowseDirection;
import org.eclipse.milo.opcua.stack.core.types.enumerated.BrowseResultMask;
import org.eclipse.milo.opcua.stack.core.types.enumerated.NodeClass;
import org.eclipse.milo.opcua.stack.core.types.structured.BrowseDescription;
import org.eclipse.milo.opcua.stack.core.types.structured.BrowseResult;
import org.eclipse.milo.opcua.stack.core.types.structured.ReferenceDescription;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.uint;
import static org.eclipse.milo.opcua.stack.core.types.builtin.unsigned.Unsigned.ushort;
import static org.eclipse.milo.opcua.stack.core.util.ConversionUtil.toList;
import static org.python.icu.math.MathContext.ROUND_HALF_UP;

@Slf4j
@Data
@Component
public class OpcUtil {

    public static OpcUaClient opcClient = null;



    /**
     * 开启 opc请求对象
     *
     * @return opc请求对象
     */
    public static OpcUaClient createOpcClient() throws Exception {
//
        DictCodeMapper dictCodeMapper = WaterChlorineApplication.ac.getBean(DictCodeMapper.class);
        DictCode dictCode = dictCodeMapper.selectOneByCode("OPC_URL");
//        // 连接地址端口号
        String endPointUrl = dictCode.getCodeValue();
//        String endPointUrl = "opc.tcp://172.16.0.69:49320";
        //安全策略选择
        EndpointDescription[] endpointDescription = UaTcpStackClient.getEndpoints(endPointUrl).get();
        //过滤掉不需要的安全策略，选择一个自己需要的安全策略
        EndpointDescription endpoint = Arrays.stream(endpointDescription)
                .filter(e -> e.getSecurityPolicyUri().equals(SecurityPolicy.None.getSecurityPolicyUri()))
                .findFirst().orElseThrow(() -> new Exception("no desired endpoints returned"));
        // 设置配置信息
        OpcUaClientConfig config = OpcUaClientConfig.builder()
                .setApplicationName(LocalizedText.english("pump")) // opc ua 自定义的名称
                .setApplicationUri(endPointUrl)// 地址
                .setEndpoint(endpoint)// 安全策略等配置
                .setRequestTimeout(UInteger.valueOf(50000)) //等待时间
                .build();
        if (opcClient == null) {
            opcClient = new OpcUaClient(config);// 准备连接
        }
        //开启连接
        opcClient.connect().get();
        Thread.sleep(2000);
        return opcClient;
    }



    /**
     * 获取节点信息
     *
     * @param client
     * @throws Exception
     */
    public static void browseNode(OpcUaClient client, NodeId nodeId) throws Exception {
        //开启连接
        client.connect().get();
        if(nodeId == null){
            nodeId = Identifiers.RootFolder;
        }
        List<Node> nodes = client.getAddressSpace().browse(nodeId).get();
        for (Node node : nodes) {
            System.out.println("Node= " + node.getBrowseName().get().getName());
            browseNode(client, node.getNodeId().get());
        }
    }

    /**
     * 读取值
     *
     * @param client
     * @throws Exception
     */
    public static void readValues(OpcUaClient client, NodeId nodeId) throws Exception {
        //创建连接
        client.connect().get();

//        NodeId nodeId = new NodeId(3, "\"test_value\"");

        DataValue value = client.readValue(0.0, TimestampsToReturn.Both, nodeId).get();

        System.out.println((Integer) value.getValue().getValue());
    }

    public static ArrayList<Object> readValues(OpcUaClient client, List<NodeId> nodeIds) throws Exception {
        //创建连接

        client.connect().get();

//        NodeId nodeId = new NodeId(3, "\"test_value\"");
        ArrayList<Object> results = new ArrayList<>();
        List<DataValue> values = client.readValues(1, TimestampsToReturn.Both, nodeIds).get();
        for (int i = 0; i < values.size(); i++) {
            DataValue dataValue = values.get(i);


            if(dataValue.getValue().getValue() == null){
                System.out.println(
                        "---- opc key: " + nodeIds.get(i).getIdentifier().toString() + "  " +
                                "--- read value: null" );
                results.add("null");
            }else{
                System.out.println(
                        "---- opc key: " + nodeIds.get(i).getIdentifier().toString() + "  " +
                                "--- read value: " + dataValue.getValue().getValue().toString());
                results.add(dataValue.getValue().getValue()
                        .toString().trim().replaceAll(",", ""));
            }

        }
        return results;
    }

    public   static ArrayList<Object> readWaterChlorineInfoValues(OpcUaClient client) throws Exception {

        String opcKeys = "ns=2;s=OPC.JL.PRIVATE.ID\n" +
                "ns=2;s=OPC.JL.PRIVATE.Now\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI021601.A_CV\n" +
                "ns=2;s=OPC.JL.PRIVATE.Null\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040201.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040202.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040207.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040301.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040302.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040307.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI040405.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.AI050304.A_CV\n" +
                "ns=2;s=IFIX.OPC.FIX.AI.PLC2_VD228.A_CV\n" +
                "ns=2;s=XS.PLC3.VD124\n" +
                "ns=2;s=XS.PLC3.VD132\n" +
                "ns=2;s=XS.PLC3.VD140\n" +
                "ns=2;s=IFIX.OPC2.FIX.AI.AI020202.A_CV\n" +
                "ns=2;s=IFIX.OPC2.FIX.AI.AI020203.A_CV\n" +
                "ns=2;s=IFIX.OPC2.FIX.AI.AI020301.A_CV\n" +
                "ns=2;s=IFIX.OPC2.FIX.AI.AI020401.A_CV\n" +
                "ns=2;s=IFIX.OPC2.FIX.AI.AI020404.A_CV\n" +
                "ns=2;s=XS.PLC3.VD136\n" +
                "ns=2;s=XS.PLC3.VD128\n" +
                "ns=2;s=XS.PLC3.VD156\n" +
                "ns=2;s=XS.PLC3.VD144\n" +
                "ns=2;s=XS.PLC3.I03\n" +
                "ns=2;s=XS.PLC3.I05\n" +
                "ns=2;s=XS.PLC3.I07\n" +
                "ns=2;s=XS.PLC3.I11\n" +
                "ns=2;s=XS.PLC3.I13\n" +
                "ns=2;s=XS.PLC3.VD200\n" +
                "ns=2;s=XS.PLC3.VD204\n" +
                "ns=2;s=XS.PLC3.VD208\n" +
                "ns=2;s=XS.PLC3.VD212\n" +
                "ns=2;s=XS.PLC3.VD216"

                ;

        String[] keys = opcKeys.split("\n");
        List<NodeId> nodeIds = new ArrayList<>();
        for(String k: keys){
            nodeIds.add(NodeId.parse(k));
        }


        return OpcUtil.readValues(client, nodeIds);
    }

    public   static ArrayList<Object> readPumpFreeComputeInfo(OpcUaClient client) throws Exception {

        String opcKeys =
                "ns=2;s=XS.PLC3.VD124\n" +
                "ns=2;s=XS.PLC3.VD132\n" +
                "ns=2;s=XS.PLC3.VD140\n" +

                "ns=2;s=XS.PLC3.VD136\n" +
                "ns=2;s=XS.PLC3.VD128\n" +
                "ns=2;s=XS.PLC3.VD156\n" +
                "ns=2;s=XS.PLC3.VD144";

        String[] keys = opcKeys.split("\n");
        List<NodeId> nodeIds = new ArrayList<>();
        for(String k: keys){
            nodeIds.add(NodeId.parse(k));
        }

        return OpcUtil.readValues(client, nodeIds);
    }
    public static  int setPumpFre(OpcUaClient client, int pumpId, BigDecimal value) throws Exception {

        int VD124 = 0;
        int VD128 = 4;
        int VD156 = 5;
        int VD136 = 3;
        int VD132 = 1;
        int VD140 = 2;
        int VD144 = 6;
        int result = 0;
        ArrayList<Object> info = OpcUtil.readPumpFreeComputeInfo(client);
        BigDecimal multiply = value.divide(BigDecimal.valueOf(50),
                        5, RoundingMode.HALF_UP)
                .multiply(BigDecimal.valueOf(1415)).multiply(new BigDecimal(info.get(VD156).toString()));

        if(pumpId == 1 ){
            BigDecimal target = new BigDecimal(info.get(VD128).toString());
            if(target.compareTo(new BigDecimal(0)) == 0){
                target = new BigDecimal("0.001");
            }
            BigDecimal vd124 = multiply.divide(target,
                            5, RoundingMode.HALF_UP);
            NodeId nodeId = NodeId.parse("ns=2;s=XS.PLC3.VD124");
            OpcUtil.writeValue(client, vd124, nodeId);
            result += 1;
        }
        if(pumpId == 2 || pumpId == 3){

            BigDecimal target = new BigDecimal(info.get(VD136).toString());
            if(target.compareTo(new BigDecimal(0)) == 0){
                target = new BigDecimal("0.001");
            }
//            Long vd132 = value / 50 * 1415 * VD156 / VD136;
            BigDecimal vd132 = multiply.divide(target,
                            5, RoundingMode.HALF_UP);
            NodeId nodeId = NodeId.parse("ns=2;s=XS.PLC3.VD132");
            OpcUtil.writeValue(client, vd132, nodeId);
            result += 1;
        }
        if(pumpId == 4 || pumpId == 5){

            BigDecimal target = new BigDecimal(info.get(VD144).toString());
            if(target.compareTo(new BigDecimal(0)) == 0){
                target = new BigDecimal("0.001");
            }
//            Long vd140 = value / 50 * 1415 * VD156 / VD144;
            BigDecimal vd140 = multiply.divide(target,
                    5, RoundingMode.HALF_UP);
            NodeId nodeId = NodeId.parse("ns=2;s=XS.PLC3.VD140");
            OpcUtil.writeValue(client, vd140, nodeId);
            result += 1;
        }
        return result;
    }
    /**
     * 写入值
     *
     * @param client
     * @param value
     * @throws Exception
     */
    public static  void writeValue(OpcUaClient client, BigDecimal value, NodeId nodeId) throws Exception {
        //创建连接
        client.connect().get();

        //创建变量节点
//        NodeId nodeId = new NodeId(3, "\"test_value\"");
        //创建Variant对象和DataValue对象
        Variant v = new Variant(value.floatValue());
        DataValue dataValue = new DataValue(v, null, null);
        StatusCode statusCode = client.writeValue(nodeId, dataValue).get();
        System.out.println(statusCode.getValue() + "+"  + nodeId.toString() + "+" +  value.floatValue());
        System.out.println(statusCode.isGood()); // 写入成功返回值
    }

    public static void main(String[] args) throws Exception {
        OpcUaClient opcUaClient = OpcUtil.createOpcClient();
//        OpcUtil.writeValue(opcUaClient, BigDecimal.valueOf(12.555), NodeId.parse("ns=2;s=XS.PLC3.VD124"));
        OpcUtil.setPumpFre(opcUaClient, 1, new BigDecimal("2.255"));
    }
}

在需要用的地方使用，info就是 opc数据

        OpcUtil.createOpcClient();
        ArrayList<Object> info = OpcUtil.readWaterChlorineInfoValues(OpcUtil.opcClient);
ジ你是我永远のbugグ
关注
专栏目录
Springboot 实现操作OPC ua Server 的数据读写 | 代码教程
洛阳泰山的博客
05-18 3085
本次采用KEPServerEX5模拟服务端，使用milo开发的程序作为客户端 搭建服务端，KEPServerEX6的安装省略掉，下面是配置过程 设置通道、设备、标签 代码教程 pom文件引入milo客户端jar包依赖 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifac.
Java实现 OPC Ua Server服务器创建
洛阳泰山的博客
01-23 1633
我们除了使用KEPServerEX6 创建OPC Ua Server 服务器以外，还可以使用 开源项目org.eclipse.milo 创建一个java项目OPC Ua Server的服务。相对于KEPServerEX6 属于收费的商用版本来说，后者更为简单轻便。下面附加代码和文字说明，教你如何创建一个OPC Ua Server的java服务。
基于springboot实现的opc 客户端
04-28
基于springboot实现的opc 客户端，该样例经过本人亲自测试，已用于实际项目中，有疑问欢迎留言交流。
java(springboot)集成Milo实现OPCUA客户端，读取OPCUA服务端节点数据
PcZxq的博客
07-03 1220
SpringBoot 后端项目中引入 Milo 库依赖（客户端 SDK ）
OPC-UA GUI客户端安装配置指南
最新发布
gitblog_07231的博客
09-13 439
OPC-UA GUI客户端安装配置指南 opcua-client-gui OPC-UA GUI Client 项目地址: https://gitcode.com/gh_mirrors/op/opcua-client-gui ...
SpringBoot集成Milo库实现OPC UA客户端：连接、遍历节点、读取、写入、订阅与批量订阅
热门推荐
Heartsuit的博客
04-15 1万+
在这篇文章中，我们将通过 SpringBoot 集成 Milo 库实现一个 OPC UA 客户端，包括连接、遍历节点、读取、写入、订阅与批量订阅等功能。
springboot 整合milo连接opcua
PcZxq的博客
11-02 975
此依赖在很多帖子中没有导入 了解到此依赖是谷歌的一个工具类 疑惑的是跟opcua 的连接又有什么联系 可能是本身导入的依赖出现了版本问题或者是冲突 不管咋说希望大家养成一个文件管理的好习惯。我在上面尝试了很多方式建立连接 始终没有获取到节点的值 网上很多帖子没有这个依赖。
基于 springboot 实现的opc客户端
04-13
总之，"基于SpringBoot实现的opc客户端"项目是一个实用示例，展示了如何将流行的Java微服务框架与工业自动化领域的标准结合，为开发者提供了一个高效、灵活的解决方案。通过学习这个项目，开发者可以更好地理解如何...
opc ua java服务器搭建_OPC UA Java 开发笔记（三）：open62541建立基础服务器
weixin_35995951的博客
03-01 1553
前两天一直在搞open62541，因为milo库的server sdk没有办法根据xml生成结点文件，于是准备用open62541来搭建服务器，milo结合Spring Boot来构件客户端。网络上大多是建立一个open62541.h的头文件，还有就是open62541.c的执行文件，但是新版好像并不是这样的。然后很多教程都是讲的linux，但是初学者用linux的还是比较少，所我写了这一篇帮助大...
SpringBoot集成milo读写OPC UA
yinjl123456的博客
08-03 2015
SpringBoot集成milo读写OPC UA。
SpringBoot集成OPC协议，批量读取数据
qq_48885166的博客
11-27 1558
DCOM配置：https://www.cnblogs.com/ioufev/p/9365919.html。安装和使用：https://www.cnblogs.com/ioufev/p/9366877.html。
opc ua server
12-27
opc ua服务器调试 opc ua服务器调试 opc ua服务器调试
OPC UA Java写的服务器和客户端 Windows下的源代码SDK
05-29
OPC UA 用Java写的服务器和客户端，包含源代码，这个只有Windows下的程序
基于SpringBoot实现用户身份验证工具
08-27
主要介绍了基于SpringBoot实现的用户身份验证工具，非常不错，具有参考借鉴价值 ,需要的朋友可以参考下
Java使用Milo实现OPC UA客户端，封装spring boot starter
kangaroo的博客
05-05 7004
本文介绍基于eclipse milo 封装的spring boot starter，yml配置OPC UA地址，是否匿名等信息，即可连接OPC UA服务器。
Springboot集成Milo实现OPCUA客户端，读取OPCUA服务端节点数据
chen_lay的博客
07-18 1973
使用KEPServerEX6.4模拟OPCUA服务端数据一、安装KEPServerEX6.4安装包地址：链接：https://pan.baidu.com/s/1Ku_NcK1xk8bP-n1Ch3nM3A 提取码：rqs6二、配置KEPServerEX6.4，模拟OPCUA服务端数据1、设置-用户管理器 新建用户（1）右键点击图标，选择设置（2）添加OPC_UA服务器用户，我的是my_opc_ua，设置密码后，点击确定和应用2、OPCUA配置。
Ops——Spring Boot Actuator
十年梦归尘的专栏
12-09 411
Spring Boot Actuator
java(springboot) 读写 opc ua
逗比爱好者
04-23 5468
1. pom 加入包 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifactId> <version>0.2.4</version> </dependency> <dependency&gt..
OPC-UA入门教程：客户端与服务器配置
4. OPC-UA Sample Client：这是一个标准的OPC-UA客户端，用于测试和验证OPC-UA Server的配置和功能。 教程中提到了三种典型的应用场景： 第一种场景：OPC-UA Client连接一个在同一系统中运行的OPC-UA Server和Twin...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值