C# 中，使用OpcUaHelper读写OPC服务器

置顶 已于 2023-05-04 10:47:57 修改
阅读量2.6k 收藏 30
点赞数 6
文章标签： 服务器 c#
于 2023-05-02 10:09:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/130461630
版权

在这里插入图片描述

nuget包

帮助类：

using Opc.Ua.Client;
using Opc.Ua;
using OpcUaHelper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;

namespace MyOPCUATest
{

    public class OPCUAHelper
    {
        #region   基础参数
        //OPCUA客户端
        private OpcUaClient opcUaClient;


        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public OPCUAHelper()
        {
            opcUaClient = new OpcUaClient();
        }

        /// <summary>
        /// 连接状态
        /// </summary>
        public bool ConnectStatus
        {
            get { return opcUaClient.Connected; }
        }



        #region   公有方法


        /// <summary>
        /// 打开连接【匿名方式】
        /// </summary>
        /// <param name="serverUrl">服务器URL【格式：opc.tcp://服务器IP地址/服务名称】</param>
        public async void OpenConnectOfAnonymous(string serverUrl)
        {

            if (!string.IsNullOrEmpty(serverUrl))
            {
                try
                {
                    opcUaClient.UserIdentity = new UserIdentity(new AnonymousIdentityToken());

                    await opcUaClient.ConnectServer(serverUrl);

                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("连接失败！！！", ex);
                }

            }
        }

        /// <summary>
        /// 打开连接【账号方式】
        /// </summary>
        /// <param name="serverUrl">服务器URL【格式：opc.tcp://服务器IP地址/服务名称】</param>
        /// <param name="userName">用户名称</param>
        /// <param name="userPwd">用户密码</param>
        public async void OpenConnectOfAccount(string serverUrl, string userName, string userPwd)
        {
            if (!string.IsNullOrEmpty(serverUrl) &&
                !string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(userPwd))
            {
                try
                {
                    opcUaClient.UserIdentity = new UserIdentity(userName, userPwd);

                    await opcUaClient.ConnectServer(serverUrl);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("连接失败！！！", ex);
                }
            }

        }

        /// <summary>
        /// 打开连接【证书方式】
        /// </summary>
        /// <param name="serverUrl">服务器URL【格式：opc.tcp://服务器IP地址/服务名称】</param>
        /// <param name="certificatePath">证书路径</param>
        /// <param name="secreKey">密钥</param>
        public async void OpenConnectOfCertificate(string serverUrl, string certificatePath, string secreKey)
        {
            if (!string.IsNullOrEmpty(serverUrl) &&
                !string.IsNullOrEmpty(certificatePath) && !string.IsNullOrEmpty(secreKey))
            {
                try
                {
                    X509Certificate2 certificate = new X509Certificate2(certificatePath, secreKey, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
                    opcUaClient.UserIdentity = new UserIdentity(certificate);

                    await opcUaClient.ConnectServer(serverUrl);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("连接失败！！！", ex);
                }
            }
        }


        /// <summary>
        /// 关闭连接
        /// </summary>
        public void CloseConnect()
        {
            if (opcUaClient != null)
            {
                try
                {
                    opcUaClient.Disconnect();
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("关闭连接失败！！！", ex);
                }

            }
        }


        /// <summary>
        /// 获取到当前节点的值【同步读取】
        /// </summary>
        /// <typeparam name="T">节点对应的数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <returns>返回当前节点的值</returns>
        public T GetCurrentNodeValue<T>(string nodeId)
        {
            T value = default(T);
            if (!string.IsNullOrEmpty(nodeId) && ConnectStatus)
            {
                try
                {
                    value = opcUaClient.ReadNode<T>(nodeId);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败！！！", ex);
                }
            }

            return value;
        }

        /// <summary>
        /// 获取到当前节点数据【同步读取】
        /// </summary>
        /// <typeparam name="T">节点对应的数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <returns>返回当前节点的值</returns>
        public DataValue GetCurrentNodeValue(string nodeId)
        {
            DataValue dataValue = null;
            if (!string.IsNullOrEmpty(nodeId) && ConnectStatus)
            {
                try
                {
                    dataValue = opcUaClient.ReadNode(nodeId);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败！！！", ex);
                }
            }

            return dataValue;
        }

        /// <summary>
        /// 获取到批量节点数据【同步读取】
        /// </summary>
        /// <param name="nodeIds">节点列表</param>
        /// <returns>返回节点数据字典</returns>
        public Dictionary<string, DataValue> GetBatchNodeDatasOfSync(List<NodeId> nodeIdList)
        {
            Dictionary<string, DataValue> dicNodeInfo = new Dictionary<string, DataValue>();
            if (nodeIdList != null && nodeIdList.Count > 0 && ConnectStatus)
            {
                try
                {
                    List<DataValue> dataValues = opcUaClient.ReadNodes(nodeIdList.ToArray());

                    int count = nodeIdList.Count;
                    for (int i = 0; i < count; i++)
                    {
                        AddInfoToDic(dicNodeInfo, nodeIdList[i].ToString(), dataValues[i]);
                    }
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败！！！", ex);
                }
            }

            return dicNodeInfo;
        }


        /// <summary>
        /// 获取到当前节点的值【异步读取】
        /// </summary>
        /// <typeparam name="T">节点对应的数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <returns>返回当前节点的值</returns>
        public async Task<T> GetCurrentNodeValueOfAsync<T>(string nodeId)
        {
            T value = default(T);
            if (!string.IsNullOrEmpty(nodeId) && ConnectStatus)
            {
                try
                {
                    value = await opcUaClient.ReadNodeAsync<T>(nodeId);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败！！！", ex);
                }
            }

            return value;
        }

        /// <summary>
        /// 获取到批量节点数据【异步读取】
        /// </summary>
        /// <param name="nodeIds">节点列表</param>
        /// <returns>返回节点数据字典</returns>
        public async Task<Dictionary<string, DataValue>> GetBatchNodeDatasOfAsync(List<NodeId> nodeIdList)
        {
            Dictionary<string, DataValue> dicNodeInfo = new Dictionary<string, DataValue>();
            if (nodeIdList != null && nodeIdList.Count > 0 && ConnectStatus)
            {
                try
                {
                    List<DataValue> dataValues = await opcUaClient.ReadNodesAsync(nodeIdList.ToArray());

                    int count = nodeIdList.Count;
                    for (int i = 0; i < count; i++)
                    {
                        AddInfoToDic(dicNodeInfo, nodeIdList[i].ToString(), dataValues[i]);
                    }
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败！！！", ex);
                }
            }

            return dicNodeInfo;
        }




        /// <summary>
        /// 获取到当前节点的关联节点
        /// </summary>
        /// <param name="nodeId">当前节点</param>
        /// <returns>返回当前节点的关联节点</returns>
        public ReferenceDescription[] GetAllRelationNodeOfNodeId(string nodeId)
        {
            ReferenceDescription[] referenceDescriptions = null;

            if (!string.IsNullOrEmpty(nodeId) && ConnectStatus)
            {
                try
                {
                    referenceDescriptions = opcUaClient.BrowseNodeReference(nodeId);
                }
                catch (Exception ex)
                {
                    string str = "获取当前： " + nodeId + "  节点的相关节点失败！！！";
                    ClientUtils.HandleException(str, ex);
                }
            }

            return referenceDescriptions;
        }


        /// <summary>
        /// 获取到当前节点的所有属性
        /// </summary>
        /// <param name="nodeId">当前节点</param>
        /// <returns>返回当前节点对应的所有属性</returns>
        public OpcNodeAttribute[] GetCurrentNodeAttributes(string nodeId)
        {
            OpcNodeAttribute[] opcNodeAttributes = null;
            if (!string.IsNullOrEmpty(nodeId) && ConnectStatus)
            {
                try
                {
                    opcNodeAttributes = opcUaClient.ReadNoteAttributes(nodeId);
                }
                catch (Exception ex)
                {
                    string str = "读取节点；" + nodeId + "  的所有属性失败！！！";
                    ClientUtils.HandleException(str, ex);
                }
            }

            return opcNodeAttributes;
        }

        /// <summary>
        /// 写入单个节点【同步方式】
        /// </summary>
        /// <typeparam name="T">写入节点值得数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <param name="value">节点对应的数据值(比如:(short)123）)</param>
        /// <returns>返回写入结果（true:表示写入成功）</returns>
        public bool WriteSingleNodeId<T>(string nodeId, T value)
        {
            bool success = false;

            if (opcUaClient != null && ConnectStatus)
            {
                if (!string.IsNullOrEmpty(nodeId))
                {
                    try
                    {
                        success = opcUaClient.WriteNode(nodeId, value);
                    }
                    catch (Exception ex)
                    {
                        string str = "当前节点：" + nodeId + "  写入失败";
                        ClientUtils.HandleException(str, ex);
                    }
                }

            }

            return success;
        }

        /// <summary>
        /// 批量写入节点
        /// </summary>
        /// <param name="nodeIdArray">节点数组</param>
        /// <param name="nodeIdValueArray">节点对应数据数组</param>
        /// <returns>返回写入结果（true:表示写入成功）</returns>
        public bool BatchWriteNodeIds(string[] nodeIdArray, object[] nodeIdValueArray)
        {
            bool success = false;
            if (nodeIdArray != null && nodeIdArray.Length > 0 &&
                nodeIdValueArray != null && nodeIdValueArray.Length > 0)

            {
                try
                {
                    success = opcUaClient.WriteNodes(nodeIdArray, nodeIdValueArray);
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("批量写入节点失败！！！", ex);
                }
            }
            return success;
        }

        /// <summary>
        /// 写入单个节点【异步方式】
        /// </summary>
        /// <typeparam name="T">写入节点值得数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <param name="value">节点对应的数据值</param>
        /// <returns>返回写入结果（true:表示写入成功）</returns>
        public async Task<bool> WriteSingleNodeIdOfAsync<T>(string nodeId, T value)
        {
            bool success = false;

            if (opcUaClient != null && ConnectStatus)
            {
                if (!string.IsNullOrEmpty(nodeId))
                {
                    try
                    {
                        success = await opcUaClient.WriteNodeAsync(nodeId, value);
                    }
                    catch (Exception ex)
                    {
                        string str = "当前节点：" + nodeId + "  写入失败";
                        ClientUtils.HandleException(str, ex);
                    }
                }

            }

            return success;
        }


        /// <summary>
        /// 读取单个节点的历史数据记录
        /// </summary>
        /// <typeparam name="T">节点的数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>返回该节点对应的历史数据记录</returns>
        public List<T> ReadSingleNodeIdHistoryDatas<T>(string nodeId, DateTime startTime, DateTime endTime)
        {
            List<T> nodeIdDatas = null;
            if (!string.IsNullOrEmpty(nodeId) && startTime != null && endTime != null && endTime > startTime)
            {
                try
                {
                    nodeIdDatas = opcUaClient.ReadHistoryRawDataValues<T>(nodeId, startTime, endTime).ToList();
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("读取失败", ex);
                }
            }

            return nodeIdDatas;
        }

        /// <summary>
        /// 读取单个节点的历史数据记录
        /// </summary>
        /// <typeparam name="T">节点的数据类型</typeparam>
        /// <param name="nodeId">节点</param>
        /// <param name="startTime">开始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>返回该节点对应的历史数据记录</returns>
        public List<DataValue> ReadSingleNodeIdHistoryDatas(string nodeId, DateTime startTime, DateTime endTime)
        {
            List<DataValue> nodeIdDatas = null;
            if (!string.IsNullOrEmpty(nodeId) && startTime != null && endTime != null && endTime > startTime)
            {
                if (ConnectStatus)
                {
                    try
                    {
                        nodeIdDatas = opcUaClient.ReadHistoryRawDataValues(nodeId, startTime, endTime).ToList();
                    }
                    catch (Exception ex)
                    {
                        ClientUtils.HandleException("读取失败", ex);
                    }
                }

            }

            return nodeIdDatas;
        }


        /// <summary>
        /// 单节点数据订阅
        /// </summary>
        /// <param name="key">订阅的关键字（必须唯一）</param>
        /// <param name="nodeId">节点</param>
        /// <param name="callback">数据订阅的回调方法</param>
        public void SingleNodeIdDatasSubscription(string key, string nodeId, Action<string, MonitoredItem, MonitoredItemNotificationEventArgs> callback)
        {
            if (ConnectStatus)
            {
                try
                {
                    opcUaClient.AddSubscription(key, nodeId, callback);
                }
                catch (Exception ex)
                {
                    string str = "订阅节点：" + nodeId + " 数据失败！！！";
                    ClientUtils.HandleException(str, ex);
                }
            }
        }

        /// <summary>
        /// 取消单节点数据订阅
        /// </summary>
        /// <param name="key">订阅的关键字</param>
        public bool CancelSingleNodeIdDatasSubscription(string key)
        {
            bool success = false;
            if (!string.IsNullOrEmpty(key))
            {
                if (ConnectStatus)
                {
                    try
                    {
                        opcUaClient.RemoveSubscription(key);
                        success = true;
                    }
                    catch (Exception ex)
                    {
                        string str = "取消 " + key + " 的订阅失败";
                        ClientUtils.HandleException(str, ex);
                    }

                }
            }

            return success;
        }


        /// <summary>
        /// 批量节点数据订阅
        /// </summary>
        /// <param name="key">订阅的关键字（必须唯一）</param>
        /// <param name="nodeIds">节点数组</param>
        /// <param name="callback">数据订阅的回调方法</param>
        public void BatchNodeIdDatasSubscription(string key, string[] nodeIds, Action<string, MonitoredItem, MonitoredItemNotificationEventArgs> callback)
        {
            if (!string.IsNullOrEmpty(key) && nodeIds != null && nodeIds.Length > 0)
            {
                if (ConnectStatus)
                {
                    try
                    {
                        opcUaClient.AddSubscription(key, nodeIds, callback);
                    }
                    catch (Exception ex)
                    {
                        string str = "批量订阅节点数据失败！！！";
                        ClientUtils.HandleException(str, ex);
                    }
                }
            }

        }

        /// <summary>
        /// 取消所有节点的数据订阅
        /// </summary>
        /// <returns></returns>
        public bool CancelAllNodeIdDatasSubscription()
        {
            bool success = false;

            if (ConnectStatus)
            {
                try
                {
                    opcUaClient.RemoveAllSubscription();
                    success = true;
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("取消所有的节点数据订阅失败！！！", ex);
                }

            }

            return success;
        }


        /// <summary>
        /// 取消单节点的数据订阅
        /// </summary>
        /// <returns></returns>
        public bool CancelNodeIdDatasSubscription(string key)
        {
            bool success = false;

            if (ConnectStatus)
            {
                try
                {
                    opcUaClient.RemoveSubscription(key);
                    success = true;
                }
                catch (Exception ex)
                {
                    ClientUtils.HandleException("取消节点数据订阅失败！！！", ex);
                }

            }

            return success;
        }

        #endregion



        #region   私有方法

        /// <summary>
        /// 添加数据到字典中（相同键的则采用最后一个键对应的值）
        /// </summary>
        /// <param name="dic">字典</param>
        /// <param name="key">键</param>
        /// <param name="dataValue">值</param>
        private void AddInfoToDic(Dictionary<string, DataValue> dic, string key, DataValue dataValue)
        {
            if (dic != null)
            {
                if (!dic.ContainsKey(key))
                {

                    dic.Add(key, dataValue);
                }
                else
                {
                    dic[key] = dataValue;
                }
            }

        }




        #endregion

    }//Class_end

}

Winform：

using Opc.Ua;
using Opc.Ua.Client;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MyOPCUATest
{
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();
        }
        private OPCUAHelper opcClient;

        private string[] MonitorNodeTags = null;
        Dictionary<string, object> myDic = new Dictionary<string, object>();

        private void BtnConn_Click(object sender, EventArgs e)
        {
            string url = "opc.tcp://192.168.2.11:4840";
            string userName = "Administrator";
            string password = "123456";
            opcClient = new OPCUAHelper();
            //opcClient.OpenConnectOfAccount(url, userName, password);
            opcClient.OpenConnectOfAnonymous(url);
            MessageBox.Show(opcClient.ConnectStatus.ToString());
        }

        private void BtnCurrentNode_Click(object sender, EventArgs e)
        {
            //string nodeId = "\"S7MesData\".\"S7Real\"[0]";
            string nodeId = "ns=3;s=\"S7MesData\".\"S7Real\"[0]";
            DataValue myValue= opcClient.GetCurrentNodeValue(nodeId);
            this.Txtbox.Text = myValue.ToString();
        }

        private void BtnCertificate_Click(object sender, EventArgs e)
        {
            string url = "opc.tcp://192.168.2.11:4840";
            string path = "D:\\zhengshu\\security\\zg-client.pfx";
            string key = "123456";
            opcClient = new OPCUAHelper();
            opcClient.OpenConnectOfCertificate(url, path, key);
            MessageBox.Show(opcClient.ConnectStatus.ToString());

        }

        private void BtnSigleScribe_Click(object sender, EventArgs e)
        {
            List<string> list = new List<string>();
            list.Add("ns=3;s=\"S7MesData\".\"S7Real\"[0]");
            list.Add("ns=3;s=\"S7MesData\".\"S7Real\"[1]");
            MonitorNodeTags = list.ToArray();

            opcClient.BatchNodeIdDatasSubscription("B", MonitorNodeTags, SubCallback);
        }

        private void SubCallback(string key, MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs args)
        {
            if (key == "B")
            {
                MonitoredItemNotification notification = args.NotificationValue as MonitoredItemNotification;

                
                if (monitoredItem.StartNodeId.ToString() == MonitorNodeTags[0])
                {
                    textBox2.Invoke(new Action(() =>
                    {
                        textBox2.Text = notification.Value.WrappedValue.Value.ToString();
                    }));

                }
                else if (monitoredItem.StartNodeId.ToString() == MonitorNodeTags[1])
                {
                    textBox3.Invoke(new Action(() =>
                    {
                        textBox3.Text = notification.Value.WrappedValue.Value.ToString();
                    }));

                }

                if (myDic.ContainsKey(monitoredItem.StartNodeId.ToString()))
                {
                    myDic[monitoredItem.StartNodeId.ToString()] = notification.Value.WrappedValue.Value;
                }
                else
                {
                    myDic.Add(monitoredItem.StartNodeId.ToString(), notification.Value.WrappedValue.Value);
                }
                string str = "";
                //foreach (var item in myDic)
                //{
                //    Console.WriteLine(item.Key);
                //    Console.WriteLine(item.Value);
                //}
            }
        }

        private void btnWrite_Click(object sender, EventArgs e)
        {
            string myTxt = textBox4.Text.Trim();
            string nodeId = "ns=3;s=\"S7MesData\".\"S7Real\"[0]";
            opcClient.WriteSingleNodeId(nodeId, (float)Convert.ToDouble(myTxt));
           
        }
    }
}

KepServer 设置：

using Opc.Ua;
using Opc.Ua.Client;
using System;
using System.Collections.Generic;
using System.Windows.Forms;

namespace MyOPCUATest
{
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();
        }
        private OPCUAHelper opcClient;

        private string[] MonitorNodeTags = null;
        Dictionary<string, object> myDic = new Dictionary<string, object>();

        private void BtnConn_Click(object sender, EventArgs e)
        {
            //string url = "opc.tcp://192.168.2.11:4840";  //PLC
            string url = "opc.tcp://192.168.2.125:49320"; //KepServer
            string userName = "Administrator";
            string password = "123456";
            opcClient = new OPCUAHelper();
            opcClient.OpenConnectOfAccount(url, userName, password);
            //opcClient.OpenConnectOfAnonymous(url);
            MessageBox.Show(opcClient.ConnectStatus.ToString());
        }

        private void BtnCurrentNode_Click(object sender, EventArgs e)
        {
            //string nodeId = "\"S7MesData\".\"S7Real\"[0]";
            //string nodeId = "ns=3;s=\"S7MesData\".\"S7Real\"[0]"; //PLC

            string nodeId = "ns=2;s=KxOPC.KX1500.电压1"; //Kep

            DataValue myValue = opcClient.GetCurrentNodeValue(nodeId);
            this.Txtbox.Text = myValue.ToString();
        }

        private void BtnCertificate_Click(object sender, EventArgs e)
        {
            //string url = "opc.tcp://192.168.2.11:4840";
            string url = "opc.tcp://192.168.2.125:49320"; //KepServer
            string path = @"D:\zhengshu\security\zg-client.pfx";
            string key = "123456";
            opcClient = new OPCUAHelper();
            opcClient.OpenConnectOfCertificate(url, path, key);
            MessageBox.Show(opcClient.ConnectStatus.ToString());

        }

        private void BtnSigleScribe_Click(object sender, EventArgs e)
        {
            List<string> list = new List<string>();
            list.Add("ns=3;s=\"S7MesData\".\"S7Real\"[0]");
            list.Add("ns=3;s=\"S7MesData\".\"S7Real\"[1]");
            MonitorNodeTags = list.ToArray();

            opcClient.BatchNodeIdDatasSubscription("B", MonitorNodeTags, SubCallback);
        }

        private void SubCallback(string key, MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs args)
        {
            if (key == "B")
            {
                MonitoredItemNotification notification = args.NotificationValue as MonitoredItemNotification;


                if (monitoredItem.StartNodeId.ToString() == MonitorNodeTags[0])
                {
                    textBox2.Invoke(new Action(() =>
                    {
                        textBox2.Text = notification.Value.WrappedValue.Value.ToString();
                    }));

                }
                else if (monitoredItem.StartNodeId.ToString() == MonitorNodeTags[1])
                {
                    textBox3.Invoke(new Action(() =>
                    {
                        textBox3.Text = notification.Value.WrappedValue.Value.ToString();
                    }));

                }

                if (myDic.ContainsKey(monitoredItem.StartNodeId.ToString()))
                {
                    myDic[monitoredItem.StartNodeId.ToString()] = notification.Value.WrappedValue.Value;
                }
                else
                {
                    myDic.Add(monitoredItem.StartNodeId.ToString(), notification.Value.WrappedValue.Value);
                }
                string str = "";
                //foreach (var item in myDic)
                //{
                //    Console.WriteLine(item.Key);
                //    Console.WriteLine(item.Value);
                //}
            }
        }

        private void btnWrite_Click(object sender, EventArgs e)
        {
            string myTxt = textBox4.Text.Trim();
            string nodeId = "ns=3;s=\"S7MesData\".\"S7Real\"[0]";
            opcClient.WriteSingleNodeId(nodeId, (float)Convert.ToDouble(myTxt));

        }
    }
}

结果：

在这里插入图片描述

在这里插入图片描述

潘诺西亚的火山
关注
  • 6
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
OpcUA C#实现
03-18
本资源来自网络，这是用C#实现的OpcUA Client， 希望帮助新人学习。
OpcUaHelper:一个通用的opc ua客户端类库，基于.net 4.6.1创建，基于官方opc ua基金会跨平台库创建，封装了节点读写，批量节点读写，引用读取，特性读取，历史数据读取，方法调用，节点订阅，批量订阅等操作。还提供了一个节点浏览器工具
05-14
OpcUaHelper 一个通用的二次封装的opc ua客户端类库，基于.net 4.6.1创建，基于官方opc ua基金会跨平台库创建，方便的实现和OPC Server进行数据交互。本类库每个几个月就同步官方的类库。 免责声明 OpcUa相关的组件版权归OPC UA基金会所有，使用本库时请遵循OPC UA基金会的授权规则。 非商用情况，如果你的项目仅仅是自己公司使用的，那么需要注册为OPC基金会的成员，否则，必须开源。 商用都是需要额外授权的，请联系OPC基金会。 FormBrowseServer 在开发客户端之前，需要使用本窗口来进行查看服务器的节点状态，因为在请求服务器的节点数据之前，必须知道节点的名称，而节点的名称可以通过这个窗口获取。以下演示实例化操作 OpcUaHelper.Forms.FormBrowseServer formBrowseServer = new Forms.
C#使用OpcUaHelper开源库开发客户端实现读取、订阅OPC UA服务器节点信息
热门推荐
CoffeMilk的博客
05-25 2万+
目录 一、内容准备 1.1、搭建OPC UA服务器环境 1.2、项目安装OPCUaHelper开源库 1.3、OpcUaHelper开源库 二、实现操作 2.1、连接OPC UA服务器，浏览所有节点信息 2.2、OpcUaHelper帮助类的常用方法 2.2.1、连接OPC UA服务器方法 2.2.2、读取OPC UA服务器的节点数据 2.2.3、读取OPC UA服务器中节点信息 三、运行测试 3.1、自己写的核心类 3.2、运行项目测试 一、内容准备 1.1、搭建OPC UA
C# opc ua客户端实例源码，带ef6+sqlite
最新发布
EsEOYLT的博客
02-28 409
本文将介绍一个基于C#的OPC UA客户端实例源码，该源码提供了EF6+SQLite的支持，方便开发者学习和理解OPC UA的使用。通过阅读和理解这份源码，开发者可以学习和掌握OPC UA的使用，并了解到如何通过OPC UA客户端程序连接到服务器并获取数据。通过阅读源码，开发者可以学习和理解OPC UA的使用，掌握如何编写一个高效、可靠的OPC UA客户端程序。通过阅读源码和注解，开发者可以深入了解OPC UA的底层实现，掌握如何编写一个高效、可靠的OPC UA客户端程序。
C# 读写opc ua服务器
luan0125的博客
11-05 1万+
最近了解了一下OPC，上网查了很多资料，整理一下读写操作的代码，以防以后忘了找起来麻烦。 首先先添加opcuahelper组件 其次，再编写OPCUAHelper类 using Opc.Ua; using Opc.Ua.Client; using OpcUaHelper; using System; using System.Collections.Generic; using System.Linq; using System.Security.Cryptography.X509Certi.
C# OPC UA 客户端开发
elie_yang的博客
08-06 2万+
OPC UA（OPC Unified Architecture）是为了在工业自动化等行业安全可靠地进行数据交换而制定的开放式国际标准规格。由OPC Foundation于2008年发布，之后制定了国际标准IEC62541.跨越设备的种类、操作系统（OS）、制造商的壁垒，可以安全地进行高可靠性的数据交换，作为标准通信协议得到了工业4.0的推荐。https://opcfoundation.org/ OPC UA开发首先需要一个服务器端：这里使用KEPServer来模拟。首先下载并安装KepServer，基本.
OpcUaHelper实现西门子OPC Server数据交互
xdpcxq的专栏
12-31 930
Opc ua客户端类库，基于.net 4.6.1创建，基于官方opc ua基金会跨平台库创建，方便的实现和OPC Server进行数据交互。
OPC UA Helper
12-07
NUGET上的OPC UA HELPER 用于开发学习用，VS的版本为2017 C#语言
【OPC UA】C# 通过OpcUaHelper建立OPC客户端访问KEPServerEx6 OPC服务器数据
cxyhjl的博客
10-19 6229
OpcUaHelper一个通用的opc ua客户端类库，基于.net 4.6.1创建，基于官方opc ua基金会跨平台库创建，封装了节点读写，批量节点读写，引用读取，特性读取，历史数据读取，方法调用，节点订阅，批量订阅等操作。还提供了一个节点浏览器工具。KEPServerEX第三方的OPC服务器，各不同厂家多种设备下位PLC与上位机之间通讯。KEPServerEX是行业领先的通信平台，用于向您的所...
OpcUaHelper-master.zip
12-10
一个通用的opc ua客户端类库，基于.net 4.6.1创建，基于官方opc ua基金会跨平台库创建，封装了节点读写，批量节点读写，引用读取，特性读取，历史数据读取，方法调用，节点订阅，批量订阅等操作。还提供了一个节点浏览器工具。
C#基于OPC服务器读写欧姆龙PLC数据实例源码
01-08
【工控老马出品，必属精品，质量保证，亲测能用】 资源名：C#基于OPC服务器读写欧姆龙PLC数据实例源码 资源类型：程序源代码 源码说明： 本资源详细介绍了用C#编写客户端程序连接OPC服务器，从而实现上位机与PLC的数据通讯。 适合人群：新手及有一定经验的开发人员
KepServer可以将任何工业设备的通信协议转换为opc协议，然后用OPCAutomation进行上位机数据读写。
07-17
KepServer可以将任何工业设备的通信协议转换为opc协议，然后用OPCAutomation进行上位机数据读写。
OpcUaHelperDemo_OpcUaHelper_OPC.DU_
09-29
OPC.DU专门对接PLCOPC.DU通讯
OpcUaHelper-1-master.zip
02-12
OPC-UA代码测试，可远程或本地连接IP加端口号进行连接，读写设备信息。大牛学者可扩展到PLC应用。改文档需要一定功底人员参考，初学者请慎重！！！
C#编程实现OPC UA .NET 客户端访问SIMATIC NET OPC UA代码
06-09
C#编程实现OPC UA .NET 客户端访问SIMATIC NET OPC UA代码 里面有两个客户端连接
C#基于OPC服务器读写欧姆龙PLC数据
04-15
本资源详细介绍了用C#编写客户端程序连接OPC服务器，从而实现上位机与PLC的数据通讯。 本资源详细介绍了用C#编写客户端程序连接OPC服务器，从而实现上位机与PLC的数据通讯。
C# 使用OPCUA 读写PLC数据
05-02
C# 使用OPCUA 读写PLC数据
C# 代码 使用OPCUA 与KEPserver通讯--小白代码
11-18
通过调用OpcUaHelper程序集，实例化此程序集可以预览KEPserver标签内容， 小白学习使用，大神级别手下留情，客户端程序，学习使用
使用C#写一个OPCUA服务器
07-15
当使用C#编写一个OPCUA服务器时，你可以使用OPCUA库来简化开发过程。以下是一个简单的示例： 首先，你需要在项目中引用OPCUA库。你可以通过NuGet包管理器搜索并安装OPCUA库。 接下来，在你的代码中添加必要的命名空间引用： ```csharp using Opc.Ua; using Opc.Ua.Server; ``` 然后，创建一个类来实现OPCUA服务器： ```csharp public class OpcuaServer : StandardServer { public OpcuaServer() { // 设置服务器的名称 this.ServerName = "MyOPCUAServer"; // 添加你的自定义节点管理器 this.AddNodeManager(new YourNodeManager()); } protected override void Dispose(bool disposing) { // 在释放服务器之前执行清理操作 base.Dispose(disposing); } } public class YourNodeManager : CustomNodeManager2 { public YourNodeManager() : base(new YourNamespaceTable()) { // 添加你的自定义节点 // AddNode方法用于添加节点到OPCUA服务器 // 在这里添加你的节点 // 示例代码： // 添加一个Object节点 var objectNode = new MyObjectNode(); this.AddNode(objectNode); // 添加一个Variable节点 var variableNode = new MyVariableNode(); variableNode.Value = new Variant(0); this.AddNode(variableNode); } } public class MyObjectNode : BaseObjectState { public MyObjectNode() { // 设置节点的属性 this.DisplayName = "MyObject"; } } public class MyVariableNode : BaseDataVariableState { public MyVariableNode() { // 设置节点的属性 this.DisplayName = "MyVariable"; this.TypeDefinitionId = VariableTypeIds.Int32; } } ``` 最后，在你的应用程序的入口点创建并启动OPCUA服务器： ```csharp class Program { static void Main(string[] args) { // 创建OPCUA服务器实例 var server = new OpcuaServer(); // 启动服务器 server.Start(); Console.WriteLine("OPCUA server started. Press Enter to exit."); Console.ReadLine(); // 停止服务器 server.Stop(); } } ``` 这是一个基本的OPCUA服务器示例，你可以根据你的需求进行扩展和修改。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值