使用modbusTCP给西门子PLC传输字符串

最新推荐文章于 2024-08-15 13:37:49 发布
最新推荐文章于 2024-08-15 13:37:49 发布
阅读量6.4k 收藏 11
点赞数 1
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/128211461
版权

modbus的报文是16进制数，PLC使用word(16位)或者int(16位)类型能接收到modbus的16进制数报文。

在PLC中，可以用以下方法把word/int解析为String类型。

在这里插入图片描述
在这里插入图片描述
代码：

    #pos := 0;
    "GunData".dints[0] := Serialize(SRC_VARIABLE := "GunData".ushorts1,
                                    DEST_ARRAY => "GunData".bytes,
                                    POS := #pos);
    
    Chars_TO_Strg(Chars := "GunData".bytes,
                  pChars := "GunData".dints[2],
                  Cnt := "GunData".uints[1],
                  Strg => "GunData".strings[0]);

先用序列化命令Serialize将 “GunData”.ushorts 解析为"GunData".bytes，即word数组解析为byte字节数组。

最后使用命令Chars_TO_Strg 将字节数组解析为字符串。Chars_TO_Strg 参数定义如下：

在这里插入图片描述

附带上我的C# modbus通信库，基于Nmodbus封装。

using Modbus.Device;
using Newtonsoft.Json;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using ZgCsharp.Entities;
using ZgCsharp.SqlSugar.Impl;
using ZgCsharp.SqlSugar.Repository.Impl;

namespace ZgCsharp.Modbus
{
    public class ModbusHelper : IModbusHelper
    {
        bool last = false;
        bool trigIn = false;
        bool trigQ = false;

        private string ip;
        private string port;


        private List<ActualData> actualDatas = new List<ActualData>();

        public List<ActualData> ActualDatas
        {
            get { return actualDatas; }
            set { actualDatas = value; }
        }

        /**
         * modubs从站ID
         */
        private string slaveNo;

        private bool isConnected = false;

        private bool isFirstConn = true;

        private int errorTimes = 0;

        CancellationTokenSource cts = new CancellationTokenSource();

        /**
         * 起始地址
         */

        private string address;

        //变量个数
        private string varNum;

        private TcpClient tcpClient = null;

        private ModbusIpMaster master;

        //配置文件地址
        private string jsonfile = Application.StartupPath + "\\Config\\modbuscfg1.json";

        private List<string> trendList = new List<string>();

        public List<string> TrendList
        {
            get { return trendList; }
            set { trendList = value; }
        }

        private Dictionary<string, string> currentPLCNote = new Dictionary<string, string>();

        public Dictionary<string, string> CurrentPLCNote
        {
            get { return currentPLCNote; }
            set { currentPLCNote = value; }
        }

        private Dictionary<string, string> currentPLCValue = new Dictionary<string, string>();

        public Dictionary<string, string> CurrentPLCValue
        {
            get { return currentPLCValue; }
            set { currentPLCValue = value; }
        }




        public string Jsonfile
        {
            get { return jsonfile; }
        }

        //读取变量
        private string str;
        private CfgJson cfgJson;
        private ModelRepository modelRepository;
        private List<ReportData> reportDatas = new List<ReportData>();

        public ModbusHelper(ModelRepository modelRepository)
        {
            this.modelRepository = modelRepository;
            str = File.ReadAllText(jsonfile);
            cfgJson = JsonConvert.DeserializeObject<CfgJson>(str);

            this.ip = cfgJson.Ip;
            this.port = cfgJson.Port;
            this.slaveNo = cfgJson.SlaveNo;
            this.address = cfgJson.Address;
            this.varNum = cfgJson.VarNum;
            this.actualDatas = cfgJson.ActualDatas;

            foreach (var item in actualDatas)
            {
                trendList.Add(item.Name);
                if (!currentPLCNote.ContainsKey(item.Name))
                {
                    currentPLCNote.Add(item.Name, item.Description);
                }
                else
                {
                    currentPLCNote[item.Name] = item.Description;
                }
            }



            //this.Conn();
            //this.readHoldingRegisters();
        }

        public string Conn()
        {
            try
            {
                tcpClient = new TcpClient();
                tcpClient.Connect(IPAddress.Parse(ip), int.Parse(port));
                master = ModbusIpMaster.CreateIp(tcpClient);
                isConnected = true;
                master.Transport.ReadTimeout = 1000;//读取数据超时时间为设定值

                master.Transport.WriteTimeout = 1000;//写入数据超时时间为设定值

                master.Transport.Retries = 5;

                master.Transport.WaitToRetryMilliseconds = 2500;
                Console.WriteLine("OK");
                return "OK";

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return ex.Message;
            }
        }

        public string DisConn()
        {
            if (master != null)
            {
                master.Dispose();
                tcpClient.Dispose();
                tcpClient.Close();
                return "OK";
            }
            else
            {
                return "Failed";
            }
        }

        public void readHoldingRegisters()
        {
            Task.Run(async () =>
            {
                while (!cts.IsCancellationRequested)
                {
                    if (isConnected == true)
                    {
                        ushort[] des = null;
                        await Task.Delay(500);
                        try
                        {
                            des = master.ReadHoldingRegisters(byte.Parse(slaveNo), ushort.Parse(address), ushort.Parse(varNum));
                        }
                        catch (Exception ex)
                        {

                        }

                        //读出的数据不为空，则解析数据，存储
                        if (des != null)
                        {
                            errorTimes = 0;
                            for (int i = 0; i < actualDatas.Count; i++)
                            {
                                actualDatas[i].Value = ((float)des[i] * float.Parse(actualDatas[i].Scale)).ToString();
                                actualDatas[i].CreateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                            }
                            //foreach (var item in actualDatas)
                            //{
                            //    Console.WriteLine(item.Value);
                            //}

                            foreach (var item in actualDatas)
                            {
                                if (!currentPLCValue.ContainsKey(item.Name))
                                {
                                    currentPLCValue.Add(item.Name, item.Value);
                                }
                                else
                                {
                                    currentPLCValue[item.Name] = item.Value;
                                }
                            }


                            ReportDataGenerate();
                            //按事件插入数据库
                            Insert();
                        }

                        else
                        {
                            errorTimes++;
                            await Task.Delay(500);
                            if (errorTimes >= 3)
                            {
                                isConnected = false;
                            }
                        }
                    }
                    else
                    {
                        if (!isFirstConn)
                        {
                            await Task.Delay(1000);

                            tcpClient?.Close();
                            //已经测试，不行
                            //tcpClient.Dispose();
                            //master?.Transport.Dispose();
                            //master?.Dispose();
                        }

                        try
                        {
                            //首次连接，或多次连接
                            tcpClient = new TcpClient();
                            tcpClient.Connect(IPAddress.Parse(ip), int.Parse(port));
                            //先将master置为空，再断线重连
                            master = null;
                            master = ModbusIpMaster.CreateIp(tcpClient);
                            master.Transport.ReadTimeout = 1000;//读取数据超时时间为设定值

                            master.Transport.WriteTimeout = 1000;//写入数据超时时间为设定值

                            master.Transport.Retries = 5;

                            master.Transport.WaitToRetryMilliseconds = 2500;
                            isConnected = true;
                            isFirstConn = false;

                        }
                        catch (Exception ex)
                        {

                        }


                    }

                }
            }, cts.Token);
        }

        public string writeHoldingRegisters(string varAddress, string value)
        {
            master.WriteSingleRegister(byte.Parse(this.slaveNo), ushort.Parse(varAddress), ushort.Parse(value));
            return "OK";
        }

        public string WriteMultipleRegisters(ushort starAddress, ushort[] data)
        {
            master.WriteMultipleRegisters(byte.Parse(this.slaveNo), starAddress, data);
            return "OK";
        }

        public void Insert()
        {
            trigIn = this.actualDatas[9].Value.Equals("10");
            trigQ = (trigIn & !last);
            last = trigIn;
            if (trigQ)
            {
                try
                {
                    InsertDataBase();
                }
                catch (Exception ex)
                {
                    
                }
            }
        }

        //插入数据工具类
        public int InsertDataBase()
        {
            string now = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            foreach (var item in this.actualDatas)
            {
                item.InsertTime = now;
            }
            int myCount = modelRepository.InsertReportData(reportDatas);
            int count = modelRepository.InsertActualData(this.actualDatas);

            return count+ myCount;
        }

        //生成数据
        public void ReportDataGenerate()
        {
            if (reportDatas.Count < 500)
            {
                reportDatas.Add(new ReportData()
                {
                    InsertTime = DateTime.Now,
                    Var1 = actualDatas[0].Value,
                    Var2 = actualDatas[1].Value,
                    Var3 = actualDatas[2].Value,
                    Var4 = actualDatas[3].Value,
                    Var5 = actualDatas[4].Value,
                    Var6 = actualDatas[5].Value,
                    Var7 = actualDatas[6].Value,
                    Var8 = actualDatas[7].Value,
                    Var9 = actualDatas[8].Value,
                    Var10 = actualDatas[9].Value
                });
            }
            else
            {
                reportDatas.RemoveAt(0);
            }
        }


    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZgCsharp.Modbus
{
    public interface IModbusHelper
    {
        string Conn();
        string DisConn();
        void readHoldingRegisters();
        string writeHoldingRegisters(string varAddress, string value);
        string WriteMultipleRegisters(ushort starAddress,ushort[] data);
    }
}
潘诺西亚的火山
关注
Modbus—TCP协议
11-26
modbus—TCP报文协议，解决工业控制信息传输，解决工业控制信息传输，解决工业控制信息传输，解决工业控制信息传输，
modbus协议通信时字符串如何发送和接收处理的解决办法
乄小小胖的博客
10-18 1万+
注意：这里所说的从机发送是指在收到主机要读取保持寄存器的数据的命令时，从机的反馈帧。从机是不能主动发送数据给主机的。。。 一、字符串保存到保持寄存器中，以供主机来读取时就可以读取到 /* 注意:从机这里这样处理字符串后，需要主机在读取从机保持寄存器来显示字符的时候， 需要先取保持寄存器的低8位，再取高8位 * @file String_To_HoldRegister * @brief 将stm32从机保持寄存器的值取出转换成字符串 * @param usHoldRegAddr 从机地址 Rstr 接收
解析西门子PLC的String和WString
ylq1045的专栏
07-24 1679
西门子PLC有两种字符串类型，String与WString String 用于存放英文数字标点符号等ASCII字符，每个字符占用一个字节 WString宽字符串用于存放中文、英文、数字等Unicode字符，每个字符占用两个字节 WString[50]为例： 西门子PLC字符串类型 WString[50]，占用104个字节（偏移量），第一第二个字节是最大长度，就是50，第三第四个字节是实际长度10，第五个字节之后就是Unicode码， PLC解析逻辑为找到第三第四个字节的长度actualLength，然后查找
实战: EasyModbus的使用及如何传输中文字符串
最新发布
usabcd2的博客
08-15 928
EasyModbus的使用及常见问题，modbus中传输中文字符串。C# Modbus EasyModbus
java使用modbus4j读取和存储String字符
wanwgei的博客
01-20 2723
因为工作中需要用到modbus读取和存储字符串，但是modbus本身并不直接支持字符串类型数据。这里只能将字符串进行转换后进行存储，读的时候也是一样，通过读入一段连续的寄存器地址数据，再转成字符串。
C++ Modbus tcp 如何给寄存器写字符串
u013083044的博客
05-21 1823
函数向多个寄存器地址写入数据。对于字符串类型的数据，可以将其转换为 16 位数字，并按顺序在多个寄存器地址上进行写入。函数连接到 Modbus TCP 服务器。然后，我们将字符串数据转换为 16 位数字数组，使用。函数，我们可以指定起始地址和要写入的寄存器数量。然后，我们将转换后的 16 位数字数组传递给。希望这可以帮助你将字符串数据转换为 16 位数字，并将其写入到多个寄存器地址。在 Modbus TCP 中，可以使用。函数将其写入多个连续的寄存器地址中。函数，以按顺序写入多个寄存器地址。
MODBUS通信协议学习（二）：通信方式
weixin_45024950的博客
01-21 2899
目录前言MODBUS通信模式串口层面Modbus ASCII通信格式数据格式Modbus RTU互联网层面Modbus TCP 前言 初步了解了MODBUS协议（https://blog.csdn.net/weixin_45024950/article/details/112836614），现在具体学习通信模式。 这篇文章在学习过程中作为总结，如有错误，请多指教。 MODBUS通信模式 MODBUS目前有串口形式的Modbus RTU、Modbus ASCII，以及互联网层面的Modbus TCP。 串口层
Qt使用ModbusTcp与汇川PLC通讯
12-13
在本文中，我们将深入探讨如何使用Qt框架与汇川（Inovance）PLC设备通过ModbusTCP协议进行通信。Qt是一个跨平台的应用程序开发框架，广泛用于创建图形用户界面和其他软件。而ModbusTCP是一种基于TCP/IP网络协议的...
c#与西门子PLC进行TCP通讯源码
12-24
可以使用`StreamWriter`和`StreamReader`进行字符串的发送和接收，或直接操作`NetworkStream`进行二进制数据的传输。 5. **西门子PLC通信协议**：与PLC通信时，需要遵循其特定的通信协议。例如，对于西门子S7 PLC，...
基于LabVIEW和ModBus TCP的一种PLC通讯方法.pdf
08-07
ModBusTCP协议是一种基于TCP/IP协议之上的应用层协议，它允许PLC与计算机系统间的数据交互，是工业自动化领域常用的通信协议之一。 文章《基于LabVIEW和ModBus TCP的一种PLC通讯方法》由杨晨宇撰写，发表于上海交通...
C#与PLC进行ModbusRTU通信源码
12-23
3. **ModbusRTU通信**：RTU模式是Modbus通信的一种，它使用连续的8位数据位传输，没有开始和结束标志，而是依赖于字符间的定时间隔来区分数据。这种模式比ASCII模式更节省带宽，适用于低速串行连接。 4. **PLC（可...
s7-200 smart PLC modbus通讯实例
04-24
RTU 模式使用二进制数据，而 ASCII 模式使用文本字符串。Modbus 协议支持多种数据类型，包括 coils、discrete inputs、input registers 和 holding registers。 在本实例中，我们使用 Modbus RTU 模式，波特率为 ...
Modbus通讯
依宸2016
03-19 709
Modbus通讯1、串行传输模式Modbus 串行链路协议是一个主-从协议。 在同一时刻，只有一个主节点连接于总线，一个或多个子节点 (最大编号为 247) 连接于同一个串行总线。 Modbus 通信总是由主节点发起。子节点在没有收到来自主节点的请求时，从不会发送数据。子节点之间从不会互相通信。主节点在同一时刻只会发起一个Modbus 事务处理。节点以两种模式对子节点发出 Modbus 请求:1、...
MODBUS协议最简单又是最直白的解释
热门推荐
僧哥叨叨叨
01-11 7万+
Modbus是一种单主站的主/从通信模式。Modbus网络上只能有一个主站存在，主站在 Modbus网络上没有地址，从站的地址范围为 0 - 247，其中 0 为广播地址，从站的实际地址范围为 1 - 247。 Modbus通信标准协议可以通过各种传输方式传播，如 RS232C、RS485、光纤、无线电等。 Modbus具有两种串行传输模式，ASCII 和 RTU。它们定义了数据如何打包、解码的...
Modbus 通信协议详解
weixin_30855761的博客
05-24 4371
一、Modbus 协议简介 　 Modbus 协议是应用于电子控制器上的一种通用语言。通过此协议，控制器相互之间、控制器经由网络（例如以太网）和其它设备之间可以通信。它已经成为一通用工业标准。有了它，不同厂商生产的控制设备可以连成工业网络，进行集中监控。 此协议定义了一个控制器能认识使用的消息结构,而不管它们是经过何种网络进行通信的。它描述了一控制器请求访问其它...
西门子S71200PLC编程TCP/IP通讯FB功能块 以字符串的格式直观显示发送接受数据
m0_73168220的博客
08-06 3191
西门子S71200PLC编程TCP/IP通讯FB功能块 以字符串的格式直观显示发送接受数据。 自动计算发送数据长度，简化发送不定长数据过程。 接受不定长数据，转化为对应长度的字符串， 在控制过程中，只需要通过比较字符串来获取反馈状态。 ID:759659203054322沉默物语...
三菱q系列plc 和电脑socket_三菱Q系列Socket通讯（套接字通讯）讲解
weixin_39620037的博客
11-23 2315
首先我们来看下socket的定义Socket是一个通讯协议，简单说就是带有网口的2个设备，而且这两个设备都支持socket的情况下，可以实现数据的交互。三菱的5U和Q系列的，只要带网口的，就可以实现socket通讯。以两个Q系列的PLC作为样例，讲解socket的使用两个设备通讯，有一个作为主动的一方，我们叫做主站，在socket里面叫Active，被动的一方，我们叫做从站，在socket里面叫U...
西门子读PLC的字符串数据
06-25
西门子（Siemens）PLC（Programmable Logic Controller）使用的是SIMATIC编程语言和通信协议，如LAD（梯形图）、FBD（功能块图）或STL（结构文本）。如果你想读取PLC中的字符串数据，通常需要通过以下步骤： 1. **连接硬件**：首先，确保你有适当的通信接口，如MPI、PROFINET、Ethernet/IP或现场总线（如Profinet IO、Modbus TCP等），连接到PLC。 2. **编程软件**：使用西门子TIA Portal或Step7等软件，配置数据访问权限和通信参数。 3. **选择指令**：在LAD或STL程序中，使用像`S7STRING`或`S7_WGET`这样的指令读取存储的字符串数据。例如，`S7STRING var, data`从内存变量`data`中读取字符串。 4. **地址定位**：确定你要读取的字符串变量的地址。在西门子PLC中，通常字符串会被存储在符号表或数据块中，地址会根据编程语言和数据类型进行计算。 5. **执行程序**：运行程序后，该指令会从指定位置读取字符串数据并将其存储到编程环境中的变量或缓冲区中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

潘诺西亚的火山

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

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

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

打赏作者

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

抵扣说明：

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

余额充值