1. Toy模板网首页
  2. > Toy博客

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

10月前 作者：罗迪尼亚的熔岩 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了C# 中，使用OpcUaHelper读写OPC服务器。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

c#opc ua服务端,服务器,c#

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));

        }
    }
}

结果：

c#opc ua服务端,服务器,c#

c#opc ua服务端,服务器,c#文章来源地址https://www.toymoban.com/news/detail-689678.html

到了这里，关于C# 中，使用OpcUaHelper读写OPC服务器的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【Python】OPC UA模拟服务器实现

    【Python】OPC UA模拟服务器实现

     在工业自动化和物联网（IoT）领域，OPC UA（开放平台通信统一架构）已经成为一种广泛采用的数据交换标准。它提供了一种安全、可靠且独立于平台的方式来访问实时数据。在本文中，我们将探讨如何使用Python和OPC UA库来创建一个高效的数据服务器，该服务器能够从CSV文件

    2024年04月29日
    浏览(69)

  • Java实现 OPC Ua Server服务器创建

    我们除了使用KEPServerEX6 创建OPC Ua Server 服务器以外，还可以使用 开源项目org.eclipse.milo 创建一个java项目OPC Ua Server的服务。相对于KEPServerEX6 属于收费的商用版本来说，后者更为简单轻便。下面附加代码和文字说明，教你如何创建一个OPC Ua Server的java服务。 可以不是web项目的，

    2024年01月24日
    浏览(44)
  • 通过Milo实现的OPC UA客户端连接并订阅Prosys OPC UA Simulation Server模拟服务器

    通过Milo实现的OPC UA客户端连接并订阅Prosys OPC UA Simulation Server模拟服务器

    前面我们搭建了一个本地的 PLC 仿真环境，并通过 KEPServerEX6 读取 PLC 上的数据，最后还使用 UAExpert 作为 OPC 客户端完成从 KEPServerEX6 这个OPC服务器的数据读取与订阅功能：SpringBoot集成Milo库实现OPC UA客户端：连接、遍历节点、读取、写入、订阅与批量订阅。 注意，如果实际工

    2024年02月16日
    浏览(51)

  • Java模拟OPC Server服务器并创建节点代码实现

    模拟OPC Server服务器的方法除了使用KEPServerEX6软件以外，还可以使用java代码模拟启动一个opc server。下文详细讲解，如何使用java代码，实现模拟一个或者多个opc server服务器。 OPC（OLE for Process Control）Server是一种用于实时数据通信的标准化软件接口，它允许不同厂商的设备和软

    2024年02月09日
    浏览(46)
  • Node-Red如何与OPC UA服务器通讯

    Node-Red如何与OPC UA服务器通讯

    本篇内容主要介绍Node-Red如何通过插件node-red-contrib-opcua来从OPC UA服务器读写数据，仍然用KEPServer来模拟OPC UA服务器，UaExpert用来测试连接和获取变量NodeId。 KEPServer的安装参考文章Node-Red如何与OPC DA服务器通讯。 安装UaExpert没有太多要注意的地方，依次下一步就行了 接下来安装

    2024年03月17日
    浏览(58)
  • 【SCADA】测试用KingIOServer采集杰控OPC DA服务器数据

    【SCADA】测试用KingIOServer采集杰控OPC DA服务器数据

    Hello，大家好，我是雷工！ 现场做数据采集时经常会遇到需要通过OPC采集数据的情况，本篇测试KingIOServer采集北京杰控组态软件的OPCDA服务器数据。 以下为测试记录过程。 KingIOServer可以作为OPC DA客户端采集OPC Server的数据，支持OPC DA 3.0接口，可以连接并枚举其他OPC DA服务器的

    2024年02月09日
    浏览(145)

  • 【OPC UA】使用C#读取OPC UA电液控数据

    OPC UA与OPC DA协议常见于工业生产中使用，例如煤矿的综采支架电液控系统。OPC UA 是OPC 的后继标准，只是后面增加了UA ,意指”统一架构”(Unified Architecture).它的主要目的是摆脱windows! 实现与平台无关的OPC.从OPC 演进到OPC UA,它的目的并没有改变,依然是为了实现分布式控制系统中

    2024年02月15日
    浏览(42)
  • OPC UA服务端(Prosys OPC UA Simulation Server)和客户端(OPC UA Explorer)工具使用

    OPC UA服务端(Prosys OPC UA Simulation Server)和客户端(OPC UA Explorer)工具使用

    1.Prosys OPC UA Simulation Server下载地址 https://downloads.prosysopc.com/opc-ua-simulation-server-downloads.php 2.简单使用 2.1 特殊项设置 【1】端口设置 【2】OPC UA Simulation Server运行状态 2.2 新加需要模拟上数的点 2.3 模拟动态变化值，修改ValueType 效果图如下： 2.4 模拟固定值(手动修改值) 1.Matriko

    2024年02月14日
    浏览(45)
  • OPC通信从入门到精通_1_OPC基础知识及简单C#程序编写（OPCDA，OPCUA简介；OPC通信数据流框架图；C#程序编写）

    OPC通信从入门到精通_1_OPC基础知识及简单C#程序编写（OPCDA，OPCUA简介；OPC通信数据流框架图；C#程序编写）

    OPC的诞生及历史 ：软件进行开发时需要与各种不同的协议进行对接，例如Modbus协议等，当设备很多，协议很多的情况下，上位机与硬件的沟通就会变得很麻烦，所以就有了将这些协议抽象出一个标准接口，对于软件人员就无需和协议对接，只需要对接接口即可，因此OPC就诞生

    2024年02月15日
    浏览(50)

  • 【C#项目实战】OPC_DA客户端开发

    大家好，我是雷工。 之前练习过一个OPC客户端的样例，并总结了博文，记录了C#开发OPC客户端的一些知识： C#学习记录——【实例】C#实现OPC Client 最近看到一个不同的思路开发的OPC DA客户端，开发并测试了下，下面将开发过程记录如下。 开发OPC客户端程序，其访问接口方式

    2024年02月03日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包