C#上位机序列9: 批量读写+事件广播+数据类型处理

已于 2023-10-19 09:11:16 修改
阅读量545 收藏 2
点赞数
文章标签： c# 上位机 实战
于 2023-10-18 17:27:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/arno1988/article/details/133910957
版权

一、源码结构：

 二、运行效果：

三、源码解析

1. 读取配置文件及创建变量信息（点位名称，地址，数据类型（bool/short/int/float/long/double））

2. 异步任务处理：读任务&写任务,将读到的数据存到字典中，判断数据是否有发生变化，如果数据有变化则事件广播通知

复制代码

using HslCommunication;
using HslCommunication.Core;
using HslCommunication.ModBus;
using PLCEvent.Util;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;
using UtilHelper;

namespace PLCEvent.Service
{
    public class PLCService
    { 
        public static Action<string> OnDataChange;
        public static ConcurrentDictionary<string, bool> DicBoolData = new ConcurrentDictionary<string, bool>();
        public static ConcurrentDictionary<string, Word> DicAllData = new ConcurrentDictionary<string, Word>();
        public static ConcurrentDictionary<string, Word> DicChangeData = new ConcurrentDictionary<string, Word>();
        static ModbusTcpNet client = null;
        static IByteTransform byteTransform;
        static ConcurrentQueue<PLCModel> queueWrite = new ConcurrentQueue<PLCModel>();
         
        public static void DataChange(string address)
        {
            OnDataChange?.Invoke(address);
        }

        /// <summary>
        /// 自定义控件内接收到数据变化事件，根据传入address，以及DataType查询监听地址所需要的监听范围（40120_int 监听两个word：40120 40121；40130_long 监听四个word：40130 40131 40132 40133），判断是否属于本控件监听
        /// </summary>
        public static List<string> RangeAddress(string address, int length)
        {
            List<string> lstaddress = new List<string>();

            if (0 == length)
            {
                lstaddress.Add(address);
            }
            else
            {
                for (int i = 0; i < length; i++)
                {
                    lstaddress.Add(FillAddress((DataHelper.Obj2Int(address) + i).ToString()));
                }
            }
            return lstaddress;
        }

        /// <summary>
        /// 读取时，按位补充0
        /// </summary>
        public static string FillAddress(string val, int length = 5)
        {
            return val.PadLeft(length, '0');
        }

        /// <summary>
        /// 写入时，格式化地址，如：40101 -> 101
        /// </summary> 
        public static string FormatAddress(string val)
        {
            if (val.Length < 5) return val;

            return val.Substring(1, val.Length - 1);
        }

        /// <summary>
        /// 初始化plc通信，开启读写任务
        /// </summary>
        public static void Init()
        {
            client = new ModbusTcpNet(CommonMethods.PLCConfig.HostAddress, CommonMethods.PLCConfig.PortNumber);
            client.AddressStartWithZero = false;
            client.DataFormat = DataFormat.CDAB;
            byteTransform = client.ByteTransform;

            TskPlcRead();
            TskPlcWrite();
        }

        /// <summary>
        /// 获取bool（bool类型）
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static bool GetBool(string address)
        { 
            try
            {
                bool exist = DicBoolData.TryGetValue(address, out var value);// 字典存储
                if (!exist)
                {
                    Logger.Info($"[Error] PLCService,GetBool,errmsg:查无点位数据({address})");
                }
                return value;
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetBool,errmsg:" + ex.Message);
            }
            return false;
        }

        /// <summary>
        /// 获取word（1个word，2个字节）
        /// </summary> 
        static Word GetAddressWord(string address, int add)
        {
            address = FillAddress((Convert.ToInt32(address) + add).ToString());
            bool exist = DicAllData.TryGetValue(address, out var value);
            if (!exist)
            {
                Logger.Info($"[Error] PLCService,GetAddressWord,errmsg:查无点位数据({address})");
            }
            return value;
        }

        /// <summary>
        /// 拼接字节（多个word）
        /// </summary> 
        static byte[] JoinAddressWord(string address, DataType datatype)
        {
            byte[] ret = null;
            switch (datatype)
            { 
                case DataType.Short:
                    { 
                        var buff = GetAddressWord(address, 0);
                        ret = new byte[2] { buff.Byte1, buff.Byte2 };
                    }
                    break;
                case DataType.Int:
                case DataType.Float:
                    {
                        var buff1 = GetAddressWord(address, 0);
                        var buff2 = GetAddressWord(address, 1);
                        ret = new byte[4] { buff1.Byte1, buff1.Byte2, buff2.Byte1, buff2.Byte2 };
                    } 
                    break;
                case DataType.Long: 
                case DataType.Double:
                    {
                        var buff1 = GetAddressWord(address, 0);
                        var buff2 = GetAddressWord(address, 1);
                        var buff3 = GetAddressWord(address, 2);
                        var buff4 = GetAddressWord(address, 3);
                        ret = new byte[8] { buff1.Byte1, buff1.Byte2, buff2.Byte1, buff2.Byte2, buff3.Byte1, buff3.Byte2, buff4.Byte1, buff4.Byte2 };
                    } 
                    break;
            }
            return ret;
        }

        public static ushort GetShort(string address)
        {
            try
            { 
                var buff = JoinAddressWord(address, DataType.Short);
                return byteTransform.TransUInt16(buff, 0); 
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetShort,errmsg:" + ex.Message);
            }
            return 0;
        }

        public static uint GetInt(string address)
        {
            try
            {
                var buff = JoinAddressWord(address, DataType.Int);
                return byteTransform.TransUInt32(buff, 0);
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetInt,errmsg:" + ex.Message);
            }
            return 0;
        }

        public static float GetFloat(string address)
        {
            try
            {
                var buff = JoinAddressWord(address, DataType.Float);
                return byteTransform.TransSingle(buff, 0);
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetFloat,errmsg:" + ex.Message);
            }
            return 0;
        }

        public static ulong GetLong(string address)
        {
            try
            {
                var buff = JoinAddressWord(address, DataType.Long);
                return byteTransform.TransUInt64(buff, 0);
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetLong,errmsg:" + ex.Message);
            }
            return 0;
        }

        public static double GetDouble(string address)
        {
            try
            {
                var buff = JoinAddressWord(address, DataType.Double);
                return byteTransform.TransDouble(buff, 0);
            }
            catch (Exception ex)
            {
                Logger.Info("[Error] PLCService,GetDouble,errmsg:" + ex.Message);
            }
            return 0;
        }

        /// <summary>
        /// 定时读取
        /// </summary>
        static void TskPlcRead()
        {
            Task.Factory.StartNew(async () =>
            {
                var start_c = CommonMethods.PLCConfig.ReadStart_Coil;
                var start_h = CommonMethods.PLCConfig.ReadStart_Holding;

                bool[] temp_c = null; byte[] temp_h = null;

                while (!CommonMethods.CTS.IsCancellationRequested)
                {
                    try
                    {
                        DicChangeData.Clear();

                        var array_c = (await client.ReadBoolAsync(start_c, (ushort)CommonMethods.PLCConfig.ReadCount_Coil)).Content;
                        var array_h = (await client.ReadAsync(start_h, (ushort)(CommonMethods.PLCConfig.ReadCount_Holding * 2))).Content;// ushort占两个字节
                         
                        if (null != array_c)
                        {
                            // bool类型只占1位，数据有变化直接通知
                            if (null == temp_c) temp_c = new bool[array_c.Length];
                            CheckBoolChange("0", start_c, temp_c, array_c);
                            Array.Copy(array_c, temp_c, array_c.Length);
                        }

                        if (null != array_h)
                        {
                            // word类型数据位(2,4,8)，所以要先读取全部的数据，再通知变化
                            if (null == temp_h) temp_h = new byte[array_h.Length];
                            CheckWordChange("4", start_h, temp_h, array_h);
                            Array.Copy(array_h, temp_h, array_h.Length);

                            if (DicChangeData.Count > 0)
                            {
                                foreach (var item in DicChangeData)
                                {
                                    DataChange(item.Key);
                                }
                            }
                        } 
                    }
                    catch (Exception ex)
                    { 
                        Logger.Info("[Error] PLCMgr,TskPlcRead,errmsg" + ex.Message);
                    } 

                    await Task.Delay(100);
                }
            }, TaskCreationOptions.LongRunning);
        }

        /// <summary>
        /// 检查数据是否有变化（bool类型）
        /// </summary> 
        public static void CheckBoolChange(string flg, string start, bool[] oldbuffer, bool[] newbuffer)
        {
            for (int i = 0; i < newbuffer.Length; i++)
            {
                string address = flg + FillAddress((i + Convert.ToInt32(start)).ToString(), 4);// 00101
                bool value = newbuffer[i];

                DicBoolData.AddOrUpdate1(address, value); 
               
                if (oldbuffer[i] != value)
                { 
                    OnDataChange(address);
                }
            }
        }

        /// <summary>
        /// 检查数据是否有变化（word类型）
        /// </summary> 
        public static void CheckWordChange(string flg, string start, byte[] oldbuffer, byte[] newbuffer)
        {
            int index = 0;
            for (int i = 0; i < newbuffer.Length; i = i + 2)
            {
                string address = flg + FillAddress((index + Convert.ToInt32(start)).ToString(), 4);// 40101

                index++;
                byte byte1 = newbuffer[i];
                byte byte2 = newbuffer[i + 1];

                Word buff = new Word() { Byte1 = byte1, Byte2 = byte2 };

                DicAllData.AddOrUpdate1(address, buff);

                if (oldbuffer[i] != byte1 || oldbuffer[i + 1] != byte2)
                {
                    DicChangeData.AddOrUpdate1(address, buff);
                }
            }
        }

        /// <summary>
        /// 添加写入值
        /// </summary> 
        public static void AddWriteVariable(string address, object value, DataType datatype)
        {
            queueWrite.Enqueue(new PLCModel() { Address = address, Value = value, PLCDataType = datatype });//加载值进队列
        } 

        /// <summary>
        /// 定时写入
        /// </summary>
        static void TskPlcWrite()
        { 
            Task.Factory.StartNew(async () =>
            {
                while (!CommonMethods.CTS.IsCancellationRequested)
                {
                    try
                    {
                        if (!queueWrite.IsEmpty)
                        {
                            PLCModel model = null; OperateResult result = null;
                            queueWrite.TryDequeue(out model);

                            var dataype = model.PLCDataType;
                            switch (dataype)
                            {
                                case DataType.Bool:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToBoolean(model.Value));
                                    break;
                                case DataType.Short:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToUInt16(model.Value)); 
                                    break;
                                case DataType.Int:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToUInt32(model.Value));
                                    break;
                                case DataType.Float:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToSingle(model.Value));
                                    break;
                                case DataType.Long:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToUInt64(model.Value));
                                    break;
                                case DataType.Double:
                                    result = await client.WriteAsync(FormatAddress(model.Address), Convert.ToDouble(model.Value));
                                    break;
                            }

                            if (!result.IsSuccess)
                            {
                                Logger.Info("[Error] PLCMgr,TskPlcWrite,errmsg:写入失败," + result.Message);
                            }
                        }
                    }
                    catch (Exception ex)
                    { 
                        Logger.Info("[Error] PLCMgr,TskPlcWrite,errmsg:" + ex.Message);
                    } 

                    await Task.Delay(100);
                }
            }, TaskCreationOptions.LongRunning);
        }
    }
}

复制代码

3. 自定义控件绑定参数,绑定事件，当收到数据变化事件，通过属性get方式，如果是bool类型，直接取Bool字典的点位数据；如果是Word类型，根据数据类型拼装Word字典中的word数据，得到对应数据类型的点位数据；通过set方式，加入到写队列。

注意点：
1. 字典类型：ConcurrentDictionary<string, bool> DicBoolData；ConcurrentDictionary<string, Word> DicAllData；Word：byte1，byte2
2. bool类型只占1位，数据有变化直接通知
3. word类型数据位(short:2,int/float:4,long/double:8)，所以要先读取全部的数据，再通知变化
4. 自定义控件内接收到数据变化事件，根据传入address，以及DataType查询监听地址所需要的监听范围（40120_int 监听两个word：40120 40121；40130_long 监听四个word：40130 40131 40132 40133），判断是否属于本控件监听
5. 自定义控件继承BaseParams类， PLCValue get:通过不同的数据类型，获取字典中的word数据，并拼接合成相应的数据类型;set:传入地址(写入时格式化地址，如:40101->101)及类型

CHHC1880
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#上位机与plc之间的通讯
01-03
C#上位机与plc之间的通讯，读写地址值。
C# 读取Modbus
zhaogaojian的专栏
12-07 118
using (TcpClient client = new TcpClient("127.0.0.1", 1502)) { var factory = new ModbusFactory(); IModbusMaster master = factory.CreateMaster(client); ...
PLC通用读写HslCommunication DEMO
10-19
PLC通用读写HslCommunication DEMO已更改为支持VS2015了，希望能够帮到大家
C#上位机序列10: 批量读写+点对点更新+数据类型处理
arno1988的专栏
10-27 882
C#上位机序列10: 批量读写+点对点更新+数据类型处理
【转】c#读取Modbus数据
爱喝奶茶的博客
03-01 1676
前面连续写了关于SOCKET编程的东西，似乎有点高大上，为了学习而学习。因此这里我们来整点实际应用的东西。C#如何读取Modbus数据，Modbus很多人可能一点都不知道，也正常，隔行如隔山嘛。Modbus在自动化行业就不一样，属于路人皆知的东西，很多设备、程序都与Modbus息息相关。 Modbus这个东西，本人也是个二把刀，只有半瓶水，所以在这里晃荡，写点Modbus东西，也...
C#MODBUSTCPIP批量读取基恩士PLCKV-7500.zip
07-11
C#MODBUSTCPIP批量读取基恩士PLCKV-7500
HslCommunication C#的 PLC 通信类库源代码 含Test项目和自动更新项目
07-24
方便学习数据采集，正式使用请移步官网注册。 HslCommunication C# 的 PLC 通信类库源代码 ，包含 Demo ； HslCommunication .net 3.5 项目源码； HslCommunication .net 4.5 项目源码； HslCommunication Java项目； Test项目 帮助文档 chm
Light-cube.zip_C#上位机
09-24
在这个上下文中，C#上位机软件可能设计用于控制光立方的灯光效果、颜色变化、动画序列等。C#提供了丰富的类库和工具，如.NET Framework或.NET Core，支持创建这样的应用程序，特别适合构建图形用户界面（GUI）和串行...
mavlink嵌入式代码移植，可读写航点显示飞机信息及简易版C#上位机
08-29
本资源提供了`mavlink`在`STM32`嵌入式平台上的应用实例，涵盖了航点读写和飞机状态信息的读取，同时附带了一个简易版的C#上位机地面站。 首先，`STM32`是一款基于ARM Cortex-M内核的微控制器，常用于嵌入式系统...
TEST_TCP.rar_C#上位机_pushhof_tcp c# .net_test_tcp_上位机
07-14
在“TEST_TCP.rar_C#上位机_pushhof_tcp c# .net_test_tcp_上位机”这个项目中，我们关注的核心是创建一个能够与下位机或其他设备进行数据交换的上位机应用。以下是一些关键知识点： 1. **TCP（传输控制协议）**：...
C#引用HslCommunication.dll读写西门子、AB罗克韦尔系列PLC地址
08-03
C#引用HslCommunication.dll通过S7协议读写西门子系列PLC，控制台程序。自定义函数类架构。
HslCommunicationDemo.zip
03-13
HslCommunication支持各类型号读取plc值，HslCommunication demo下载
一个PLC读写控制类，支持批量读取数据集合。本项目中使用了HslCommunication组件。.zip
01-03
使用c#开发的系统项目源码、数据集
C# 对文件操作的方法(读取,删除,批量拷贝,删除
09-25
c# 对文件操作的方法(读取,删除,批量拷贝,删除 c# 对文件操作的方法(读取,删除,批量拷贝,删除 c# 对文件操作的方法(读取,删除,批量拷贝,删除
C#上位机开发(波形显示).zip
09-03
【C#上位机开发(波形显示)】 在IT领域，上位机是指与下位机（如嵌入式设备、单片机等）进行通信的计算机程序，通常用于数据采集、控制、分析等任务。C#作为.NET框架的一部分，因其强大的面向对象特性和丰富的库支持...
【WinForm】C# Modbus RTU 通信学习过程-数据读取、写入
cenwenjing的博客
02-25 7384
【WinForm】C# Modbus RTU 通信学习过程-数据读取、写入了
HslCommunication组件库使用说明
weixin_30562507的博客
10-21 6731
一个由个人开发的组件库，携带了一些众多的功能，包含了数据网络通信，文件上传下载，日志组件，PLC访问类，还有一些其他的基础类库。 nuget地址：https://www.nuget.org/packages/HslCommunication/ github地址：https://github.com/dathlin/HslCommunication ...
C#利用HslCommunication读取和写入汇川H3U
hpck2007的博客
05-28 4421
this.richCurrent.Text = $"写入{this.richCurrent.Text}到{this.txtStartAddress.Text}成功";this.richCurrent.Text = $"写入{this.richCurrent.Text}到{this.txtStartAddress.Text}失败";this.richCurrent.Text = $"写入{this.richCurrent.Text}到{this.txtStartAddress.Text}成功";
c语言错误C1189
最新发布
06-18
抱歉，但您提到的"C1189"不是一个标准的C语言错误代码。通常，编译器错误代码是特定于特定编译器的，并且C1189并不属于常见的C语言错误列表。可能是您使用的某个非标准IDE、编译器插件或者自定义的错误标识。 在C语言中，标准的错误代码通常由编译器生成，例如GCC可能会使用类似“error: identifier ‘x’ is undefined”这样的信息。常见的C语言错误可能包括类型不匹配、未声明的变量、数组越界、空指针引用等。 如果您遇到具体的编译错误，请提供详细的错误信息，以便我能更准确地帮助您理解问题所在。如果C1189确实是您的问题，那可能需要查看相关的文档或项目设置，因为这可能是一个内部错误号或者是特定环境下的错误标识。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值