springboot-opc_ua实现客户端通讯

已于 2023-03-09 14:37:37 修改
阅读量1.7k 收藏 5
点赞数 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グ
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Springboot 实现操作OPC ua Server 的数据读写 | 代码教程
洛阳泰山的博客
05-18 1872
本次采用KEPServerEX5模拟服务端，使用milo开发的程序作为客户端 搭建服务端，KEPServerEX6的安装省略掉，下面是配置过程 设置通道、设备、标签 代码教程 pom文件引入milo客户端jar包依赖 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifac.
基于springboot实现的opc 客户端
04-28
基于springboot实现的opc 客户端，该样例经过本人亲自测试，已用于实际项目中，有疑问欢迎留言交流。
基于QT C++的OPC_UA客户端源程序.zip
03-22
基于QT C++的OPC_UA客户端源程序，亲身测试可用，有注释
JAVA对接OPC协议-Utgard
热门推荐
略简略烦的博客
06-17 1万+
一、准备工作 下载OPC服务器，推荐KEPServer，推荐此篇博客 OPC和DCOM配置，不细说了，推荐此篇博客 建立些模拟设备 二、OPC系统连接和读写操作-Utgard方式 同步读写很简单，网上找找就能有，我就不细说了 异步写， 暂时没研究，我遇到的场景是写入并发少，读取并发多，毕竟是用于工控领域 所以本篇博客主要是针对于异步读取（侧重点）与同步写入（比较简单） 异步读取 网上大都是用的Async20Access这个类去实现的，这个写法的优点：能随时获取到当前的item属性，缺..
Java使用Milo实现OPC UA客户端，封装spring boot starter
kangaroo的博客
05-05 4378
本文介绍基于eclipse milo 封装的spring boot starter，yml配置OPC UA地址，是否匿名等信息，即可连接OPC UA服务器。
SpringBoot集成Milo库实现OPC UA客户端：连接、遍历节点、读取、写入、订阅与批量订阅
Heartsuit的博客
04-15 7797
在这篇文章中，我们将通过 SpringBoot 集成 Milo 库实现一个 OPC UA 客户端，包括连接、遍历节点、读取、写入、订阅与批量订阅等功能。
Springboot集成Milo实现OPCUA客户端，读取OPCUA服务端节点数据
chen_lay的博客
07-18 1337
使用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配置。
springboot 连接西门子plc，读取对应的值，并修改到数据库
最新发布
weixin_44021888的博客
11-05 899
springboot连接西门子plc2100，读取数据并修改数据库
通过Milo实现的OPC UA客户端连接并订阅Prosys OPC UA Simulation Server模拟服务器
Heartsuit的博客
04-16 4334
如果实际工作中，仅仅需要测试下 OPC UA 客户端的功能，那么就Duck不必搭建本地的 PLC 仿真环境，而是借助一些 OPC UA 服务端的模拟工具。在这篇文章中，我们将使用 Prosys OPC UA Simulation Server 作为 OPC UA 的服务端，并通过我们前面自己实现的 OPC UA 客户端来连接这个模拟的 OPC UA 的服务器。
基于 springboot 实现的opc客户端
04-13
基于springboot实现的opc 客户端，具有参考价值
OPC_UA_Client_S7-1500西门子OPC UA客户端案例
12-05
用于OPC UA的C#通信开发学习，实现设备的数据控制和采集，采用OPC UA基金会的标准库及Client的标准实现，有助于初学者理解掌握工业控制编程的技巧。
KEPServerEX6-OPC_UA服务器软件.rar
08-05
KEPServerEX6-OPC_UA服务器软件
标准OPC_UA客户端软件UaExpert.rar
03-23
标准OPC_UA客户端软件UaExpert
prosys-opc-ua-client-3.0.0-256.exeOPC UA客户端
06-17
OPC基金会 (OPC Foundation) 发布了最新的数据通讯统一方法 — OPC统一架构 (OPC UA)， 涵盖了OPC 实时数据访问规范 (OPC DA)、OPC历史数据访问规范 (OPC HDA)、 OPC 报警事件访问规范 (OPC A&E) 和OPC安全协议 (OPC...
node-opcua-sample:一个简单的OPCUA示例客户端，以演示如何使用节点opcua SDK
05-15
一个简单的OPCUA示例客户端，以演示如何使用 SDK。 该样品带有3种口味 带有异步/等待支持的打字稿 $ npm install ts-node -g $ ts-node simple_client_ts.ts 支持async / await的最新nodejs版本（es2017） $ node...
java(springboot) 读写 opc ua
逗比爱好者
04-23 5030
1. pom 加入包 <dependency> <groupId>org.eclipse.milo</groupId> <artifactId>sdk-client</artifactId> <version>0.2.4</version> </dependency> <dependency&gt..
Java实现OPCUA通信
qq_27615455的博客
11-07 5840
在 linux 上看教程到还可以。🍄 设备的出现的各种状况（比如上线，某个组件出故障，某个参数超标），就是：物模型的事件，Java 中的事件，OPCUA中订阅。，服务发现时，服务端返回的断点描述的主机名或者本地IP，远程是访问不到的，按照解答参考，修改端点的主机名为远程IP地址即可。🍄 设备的参数，就是：物模型的属性值，Java 中类的属性（也可以叫变量，字段），OPCUA 中的节点的变量。🍄 设备的操作方法，就是：物模型的功能，Java 中类的方法（也可以叫函数），OPCUA 中的方法。
Springboot使用s7connector 实现对西门子PLC数据读写
helldoger的博客
11-17 4290
【代码】Springboot使用s7connector 实现对西门子PLC数据读写。
tf6100-opc-ua.4.3.44.0
08-01
TF6100-OPC-UA.4.3.44.0是一个OPC-UA服务器软件版本。OPC-UA（OLE for Process Control-Unifed Architecture，过程控制统一体系结构）是一种通信协议，用于在工业自动化系统中实现设备间的数据传输和通信。TF6100-OPC-UA.4.3.44.0是该软件的特定版本。 TF6100-OPC-UA.4.3.44.0具有以下特点： 1. 支持OPC-UA标准：该软件遵循OPC-UA通信标准，确保与其他OPC-UA兼容设备和系统的互操作性。 2. 强大的数据传输功能：TF6100-OPC-UA.4.3.44.0可以高效地传输各种类型的数据，包括实时数据、历史数据和报警信息等。 3. 高可用性和稳定性：该软件版本经过稳定性测试，具有高可靠性和稳定性，确保数据传输的连续性和可用性。 4. 安全性保障：TF6100-OPC-UA.4.3.44.0采用了先进的安全措施，包括数据加密和身份验证，以确保通信的安全性和数据的保密性。 5. 易于集成和使用：该软件提供友好的用户界面和简化的配置选项，使用户能够轻松地集成和使用该OPC-UA服务器。 总之，TF6100-OPC-UA.4.3.44.0是一个功能强大的OPC-UA服务器软件版本，可以实现工业自动化系统中设备之间的高效通信和数据传输。它的稳定性、可靠性和安全性让用户能够方便地集成和使用该软件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值