精华内容
下载资源
问答
  • modbus rtu 通讯协议

    2012-08-13 15:37:12
    modbus rtu 通讯协议 详解
  • modbusrtu通讯协议

    2019-04-23 17:26:25
    modbus-rtu通讯协议详解,能让初学者尽快掌握协议对接。
  • modbusRTU通讯协议简介

    2018-01-28 01:15:46
    modbusRTU 通讯协议简介,介绍了该I通讯协议格式,有利于了解此协议。
  • ModBus RTU通讯协议ModBus通讯协议
  • Modbus RTU通讯协议

    千次阅读 2018-06-23 08:36:39
    1.Modbus RTU报文基本格式 起始应有 不小于3.5个字符的报文间隔 目标站号 功能码 数据 CRC校验码 1字节 1字节 N字节 ...

     1.Modbus RTU报文基本格式

    起始应有 不小于3.5个字符的报文间隔

    目标站号

    功能码

    数据

    CRC校验码

    1字节

    1字节

    N字节

    2字节


    2. Modbus命令

    若响应错误,则返回的应答帧中“功能码”最高位置1, 比如功能码为01,若响应错误,则返回的功能码为0x81。

    2.1 功能码01:读线圈(开关量输出)

    请求格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址

    低字节

    读取个数

    高字节

    读取个数

    低字节

    CRC

    1字节

    01

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    站号

    功能码

    返回数据字节数

    返回数据字节1

    返回数据字节2

    CRC

    1字节

    01

    1字节

    1字节

    1字节

    2字节


    2.2 功能码02:读输入状态(开关量输入)

    请求格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址

    低字节

    读取个数

    高字节

    读取个数

    低字节

    CRC

    1字节

    02

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    站号

    功能码

    返回数据字节数

    返回数据字节1

    返回数据字节2

    CRC

    1字节

    02

    1字节

    1字节

    1字节

    2字节


    2.3 功能码03:读保持寄存器(模拟量输出)

    请求格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址

    低字节

    读取个数

    高字节

    读取个数

    低字节

    CRC

    1字节

    03

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    站号

    功能码

    返回数据字节数

    寄存器1高字节

    寄存器1低字节

    CRC

    1字节

    03

    1字节

    1字节

    1字节

    2字节


    2.4 功能码04:读输入寄存器(模拟量输入)

    请求格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址

    低字节

    读取个数

    高字节

    读取个数

    低字节

    CRC

    1字节

    04

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    站号

    功能码

    返回数据字节数

    寄存器1高字节

    寄存器1低字节

    CRC

    1字节

    04

    1字节

    1字节

    1字节

    2字节


    2.5 功能码05:写单线圈(开关量输出)

    请求格式:

    目标站号

    功能码

    线圈地址

    高字节

    线圈地址

    低字节

    强制值

    高字节

    强制值

    低字节

    CRC校验码

    1字节

    05

    1字节

    1字节

    1字节

    1字节

    2字节

    注:强制值= 0xFF00,则置线圈为ON;强制值=0x0000,则置线圈为OFF。

    应答格式:

    若设置成功,原文返回

    2.6 功能码06:写单保持寄存器(模拟量输出)

    请求格式:

    目标站号

    功能码

    寄存器地址

    高字节

    寄存器地址

    低字节

    强制值

    高字节

    强制值

    低字节

    CRC校验码

    1字节

    06

    1字节

    1字节

    1字节

    1字节

    2字节


    应答格式:

    若设置成功,原文返回

    2.7 功能码15:写多线圈(开关量输出)

    请求格式:

    目标

    站号

    功能码

    起始地址

    高字节

    起始地址低字节

    数量

    高字节

    数量

    低字节

    强制值字节数

    强制值

    第1字节

    CRC

    1字节

    15

    1字节

    1字节

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址低字节

    数量

    高字节

    数量

    低字节

    CRC校验码

    1字节

    15

    1字节

    1字节

    1字节

    1字节

    2字节


    2.8 功能码16:写多保持寄存器(模拟量输出)

    请求格式:

    目标

    站号

    功能码

    起始地址

    高字节

    起始地址低字节

    数量

    高字节

    数量

    低字节

    强制值字节数

    强制值1

    高字节

    强制值1

    低字节

    CRC

    1字节

    16

    1字节

    1字节

    1字节

    1字节

    1字节

    1字节

    1字节

    2字节


    正确应答格式:

    目标站号

    功能码

    起始地址

    高字节

    起始地址低字节

    数量

    高字节

    数量

    低字节

    CRC

    校验码

    1字节

    16

    1字节

    1字节

    1字节

    1字节

    2字节

    展开全文
  • 485 ModbusRTU通讯协议(完整版),PDF 网上找到的的最全的资料,可直接使用----
  • MODBUS RTU通讯协议在S7_200中的应用pdf,MODBUS RTU通讯协议在S7_200中的应用
  • MODBUS RTU通讯协议在S7-200中的应用doc,MODBUS RTU通讯协议在S7-200中的应用
  • MODBUSrtu通讯协议简介

    2014-09-07 07:51:56
    讲解MODBUSrtu通讯协议,理解请求数组,id,功能码,波特率等
  • 本案例是西门子1200PLC通过MODBUS RTU通讯协议控制海利普变频器。采用点对点发送指令Send_P2P来实现通讯,软件是博图14版本
  • 485 ModbusRTU通讯协议(完整版),这是我在网上找到的的最全的资料,和大家一块学习!
  • MODBUSRTU通讯协议在STM32F103上的实现
  • 松下plc modbus rtu协议,可断网重连,批量读写寄存器,单个写寄存器,已在项目中稳定运行
  • MODBUS RTU 通讯协议 一、 通讯协议 本系采用单主多从网络数据通信方式,与 MODBUS RTU 通讯规约相兼容: 波特率: 2400,4800,9600 消息发送至少要以 3.5 个字符时间的停顿间隔作为开始。整个消息帧必须作为连续...

    MODBUS RTU  通讯协议


    一、 通讯协议

    本系采用单主多从网络数据通信方式,与 MODBUS RTU 通讯规约相兼容:

    波特率: 2400,4800,9600

    消息发送至少要以 3.5 个字符时间的停顿间隔作为开始。整个消息帧必须作为连续的数

    据流来传送,如果整个数据流在传送完成之前发生超过 3.5 个字符时间的传送停顿,接收设

    备将刷新不完整的消息并假定下一字节是一个新消息的地址域;同样地,如果一个新消息在

    小于 3.5 个字符时间内接着前个消息开始,接收设备将认为它是前一消息的延续。

    一帧信息的标准结构如下所示:

    1、地址码:地址码为通讯传送的第一个字节。这个字节表明由用户设定地址码

    的从机将接收由主机发送来的信息。并且每个从机都具有唯一的地址码,

    并且响应回送均以各自的地址码开始。主机发送的地址码表明将发送到

    的从机地址,而从机发送的地址码表明回送的从机地址。 “从机” 的地址

    范围为1~128 (十进制) 。

    2、功能码:通讯传送的第二个字节。 有效的编码范围是1…255(十进制)。 作为主机

    请求发送,通过功能码告诉从机执行什么动作。 例如:

    02:读取多位寄存器;

    03:读取多字寄存器;

    15:写位位寄存器;

    16:写多字寄存器;

    从机可以响应也可以不响应,作为从机响应,从机发送的功能码与从主机发

    送来的功能码一样,并表明从机已响应主机进行操作。可以约定对于广播数据不

    作响应。

    3、数据区:数据区是根据不同的功能码而不同。数据区可以是实际数值、设置

    点、主机发送给从机或从机发送给主机的寄存器地址,连续数据长度等。

    4、CRC 码: 低字节在前,高字节在后。

    注:本仪表通讯时的读取间隔,在通讯速率等于 9600bps 时, 一般命令的读取间隔建议大于

    50mS,0X69(连读)命令大于 250mS。


    更多介绍请见附件pdf。


    源码如下:

    using System;

    using System.Collections;

    using System.Collections.Generic;

    using System.ComponentModel;

    using System.IO.Ports;

    using System.Text;

    using System.Threading;

    using Bandweaver.Bus.Data;


    namespace Bandweaver.Applet.HaiNanDataAgent

    {

        /// <summary>

        /// 版权(C), 2008-2017, Krones

        /// 文件名称:ModbusHelper.cs

        /// 编写人员:成杭

        /// 编写日期:2016/10/8 13:31:01

        /// 功能描述:完成对Modbus操作帮助类

        /// 更改历史:

        /// </summary> 

        public class ModbusController

        {

            #region 事件

            /// <summary>

            /// 接收数据

            /// </summary>

            public event RecivedDataEventHandler RecivedDataEvent = null;

            /// <summary>

            /// 接收到消息

            /// </summary>

            public event RecivedMessageEventHandler RecivedMessageEvent = null;

            /// <summary>

            /// COMM口状态改变事件

            /// </summary>

            public event ComPortStatusChangedEventHandler ComPortStatusChangedEvent = null;

            #endregion

            #region 属性

            /// <summary>

            /// 状态

            /// </summary>

            public AppStatus Status = AppStatus.停止;

            /// <summary>

            /// COM操作对象

            /// </summary>

            private SerialPort sp = new SerialPort();

            /// <summary>

            /// 锁

            /// </summary>

            private static Object o = new Object();

            /// <summary>

            /// CRC验证表

            /// </summary>

            public byte[] crc_table = new byte[512];

            /// <summary>

            /// 数据集合

            /// </summary>

            private Dictionary<Int16, Int16> DicData = null;

            /// <summary>

            /// 从机地址

            /// </summary>

            private byte SlaveID = 0;

            /// <summary>

            /// 数据发送对象配置信息

            /// </summary>

            private ArrayList DataList = null;

            /// <summary>

            /// COM口配置信息

            /// </summary>

            private ComSetting Setting = null;

            #endregion

            #region 构造函数

            /// <summary>

            /// 构造函数

            /// </summary> 

            public ModbusController(RecivedConfigurationTable configuration)

            {

                #region 初始化CRC

                crc_table[0] = 0x0;

                crc_table[1] = 0xC1;

                crc_table[2] = 0x81;

                crc_table[3] = 0x40;

                crc_table[4] = 0x1;

                crc_table[5] = 0xC0;

                crc_table[6] = 0x80;

                crc_table[7] = 0x41;

                crc_table[8] = 0x1;

                crc_table[9] = 0xC0;

                crc_table[10] = 0x80;

                crc_table[11] = 0x41;

                crc_table[12] = 0x0;

                crc_table[13] = 0xC1;

                crc_table[14] = 0x81;

                crc_table[15] = 0x40;

                crc_table[16] = 0x1;

                crc_table[17] = 0xC0;

                crc_table[18] = 0x80;

                crc_table[19] = 0x41;

                crc_table[20] = 0x0;

                crc_table[21] = 0xC1;

                crc_table[22] = 0x81;

                crc_table[23] = 0x40;

                crc_table[24] = 0x0;

                crc_table[25] = 0xC1;

                crc_table[26] = 0x81;

                crc_table[27] = 0x40;

                crc_table[28] = 0x1;

                crc_table[29] = 0xC0;

                crc_table[30] = 0x80;

                crc_table[31] = 0x41;

                crc_table[32] = 0x1;

                crc_table[33] = 0xC0;

                crc_table[34] = 0x80;

                crc_table[35] = 0x41;

                crc_table[36] = 0x0;

                crc_table[37] = 0xC1;

                crc_table[38] = 0x81;

                crc_table[39] = 0x40;

                crc_table[40] = 0x0;

                crc_table[41] = 0xC1;

                crc_table[42] = 0x81;

                crc_table[43] = 0x40;

                crc_table[44] = 0x1;

                crc_table[45] = 0xC0;

                crc_table[46] = 0x80;

                crc_table[47] = 0x41;

                crc_table[48] = 0x0;

                crc_table[49] = 0xC1;

                crc_table[50] = 0x81;

                crc_table[51] = 0x40;

                crc_table[52] = 0x1;

                crc_table[53] = 0xC0;

                crc_table[54] = 0x80;

                crc_table[55] = 0x41;

                crc_table[56] = 0x1;

                crc_table[57] = 0xC0;

                crc_table[58] = 0x80;

                crc_table[59] = 0x41;

                crc_table[60] = 0x0;

                crc_table[61] = 0xC1;

                crc_table[62] = 0x81;

                crc_table[63] = 0x40;

                crc_table[64] = 0x1;

                crc_table[65] = 0xC0;

                crc_table[66] = 0x80;

                crc_table[67] = 0x41;

                crc_table[68] = 0x0;

                crc_table[69] = 0xC1;

                crc_table[70] = 0x81;

                crc_table[71] = 0x40;

                crc_table[72] = 0x0;

                crc_table[73] = 0xC1;

                crc_table[74] = 0x81;

                crc_table[75] = 0x40;

                crc_table[76] = 0x1;

                crc_table[77] = 0xC0;

                crc_table[78] = 0x80;

                crc_table[79] = 0x41;

                crc_table[80] = 0x0;

                crc_table[81] = 0xC1;

                crc_table[82] = 0x81;

                crc_table[83] = 0x40;

                crc_table[84] = 0x1;

                crc_table[85] = 0xC0;

                crc_table[86] = 0x80;

                crc_table[87] = 0x41;

                crc_table[88] = 0x1;

                crc_table[89] = 0xC0;

                crc_table[90] = 0x80;

                crc_table[91] = 0x41;

                crc_table[92] = 0x0;

                crc_table[93] = 0xC1;

                crc_table[94] = 0x81;

                crc_table[95] = 0x40;

                crc_table[96] = 0x0;

                crc_table[97] = 0xC1;

                crc_table[98] = 0x81;

                crc_table[99] = 0x40;

                crc_table[100] = 0x1;

                crc_table[101] = 0xC0;

                crc_table[102] = 0x80;

                crc_table[103] = 0x41;

                crc_table[104] = 0x1;

                crc_table[105] = 0xC0;

                crc_table[106] = 0x80;

                crc_table[107] = 0x41;

                crc_table[108] = 0x0;

                crc_table[109] = 0xC1;

                crc_table[110] = 0x81;

                crc_table[111] = 0x40;

                crc_table[112] = 0x1;

                crc_table[113] = 0xC0;

                crc_table[114] = 0x80;

                crc_table[115] = 0x41;

                crc_table[116] = 0x0;

                crc_table[117] = 0xC1;

                crc_table[118] = 0x81;

                crc_table[119] = 0x40;

                crc_table[120] = 0x0;

                crc_table[121] = 0xC1;

                crc_table[122] = 0x81;

                crc_table[123] = 0x40;

                crc_table[124] = 0x1;

                crc_table[125] = 0xC0;

                crc_table[126] = 0x80;

                crc_table[127] = 0x41;

                crc_table[128] = 0x1;

                crc_table[129] = 0xC0;

                crc_table[130] = 0x80;

                crc_table[131] = 0x41;

                crc_table[132] = 0x0;

                crc_table[133] = 0xC1;

                crc_table[134] = 0x81;

                crc_table[135] = 0x40;

                crc_table[136] = 0x0;

                crc_table[137] = 0xC1;

                crc_table[138] = 0x81;

                crc_table[139] = 0x40;

                crc_table[140] = 0x1;

                crc_table[141] = 0xC0;

                crc_table[142] = 0x80;

                crc_table[143] = 0x41;

                crc_table[144] = 0x0;

                crc_table[145] = 0xC1;

                crc_table[146] = 0x81;

                crc_table[147] = 0x40;

                crc_table[148] = 0x1;

                crc_table[149] = 0xC0;

                crc_table[150] = 0x80;

                crc_table[151] = 0x41;

                crc_table[152] = 0x1;

                crc_table[153] = 0xC0;

                crc_table[154] = 0x80;

                crc_table[155] = 0x41;

                crc_table[156] = 0x0;

                crc_table[157] = 0xC1;

                crc_table[158] = 0x81;

                crc_table[159] = 0x40;

                crc_table[160] = 0x0;

                crc_table[161] = 0xC1;

                crc_table[162] = 0x81;

                crc_table[163] = 0x40;

                crc_table[164] = 0x1;

                crc_table[165] = 0xC0;

                crc_table[166] = 0x80;

                crc_table[167] = 0x41;

                crc_table[168] = 0x1;

                crc_table[169] = 0xC0;

                crc_table[170] = 0x80;

                crc_table[171] = 0x41;

                crc_table[172] = 0x0;

                crc_table[173] = 0xC1;

                crc_table[174] = 0x81;

                crc_table[175] = 0x40;

                crc_table[176] = 0x1;

                crc_table[177] = 0xC0;

                crc_table[178] = 0x80;

                crc_table[179] = 0x41;

                crc_table[180] = 0x0;

                crc_table[181] = 0xC1;

                crc_table[182] = 0x81;

                crc_table[183] = 0x40;

                crc_table[184] = 0x0;

                crc_table[185] = 0xC1;

                crc_table[186] = 0x81;

                crc_table[187] = 0x40;

                crc_table[188] = 0x1;

                crc_table[189] = 0xC0;

                crc_table[190] = 0x80;

                crc_table[191] = 0x41;

                crc_table[192] = 0x0;

                crc_table[193] = 0xC1;

                crc_table[194] = 0x81;

                crc_table[195] = 0x40;

                crc_table[196] = 0x1;

                crc_table[197] = 0xC0;

                crc_table[198] = 0x80;

                crc_table[199] = 0x41;

                crc_table[200] = 0x1;

                crc_table[201] = 0xC0;

                crc_table[202] = 0x80;

                crc_table[203] = 0x41;

                crc_table[204] = 0x0;

                crc_table[205] = 0xC1;

                crc_table[206] = 0x81;

                crc_table[207] = 0x40;

                crc_table[208] = 0x1;

                crc_table[209] = 0xC0;

                crc_table[210] = 0x80;

                crc_table[211] = 0x41;

                crc_table[212] = 0x0;

                crc_table[213] = 0xC1;

                crc_table[214] = 0x81;

                crc_table[215] = 0x40;

                crc_table[216] = 0x0;

                crc_table[217] = 0xC1;

                crc_table[218] = 0x81;

                crc_table[219] = 0x40;

                crc_table[220] = 0x1;

                crc_table[221] = 0xC0;

                crc_table[222] = 0x80;

                crc_table[223] = 0x41;

                crc_table[224] = 0x1;

                crc_table[225] = 0xC0;

                crc_table[226] = 0x80;

                crc_table[227] = 0x41;

                crc_table[228] = 0x0;

                crc_table[229] = 0xC1;

                crc_table[230] = 0x81;

                crc_table[231] = 0x40;

                crc_table[232] = 0x0;

                crc_table[233] = 0xC1;

                crc_table[234] = 0x81;

                crc_table[235] = 0x40;

                crc_table[236] = 0x1;

                crc_table[237] = 0xC0;

                crc_table[238] = 0x80;

                crc_table[239] = 0x41;

                crc_table[240] = 0x0;

                crc_table[241] = 0xC1;

                crc_table[242] = 0x81;

                crc_table[243] = 0x40;

                crc_table[244] = 0x1;

                crc_table[245] = 0xC0;

                crc_table[246] = 0x80;

                crc_table[247] = 0x41;

                crc_table[248] = 0x1;

                crc_table[249] = 0xC0;

                crc_table[250] = 0x80;

                crc_table[251] = 0x41;

                crc_table[252] = 0x0;

                crc_table[253] = 0xC1;

                crc_table[254] = 0x81;

                crc_table[255] = 0x40;

                crc_table[256] = 0x0;

                crc_table[257] = 0xC0;

                crc_table[258] = 0xC1;

                crc_table[259] = 0x1;

                crc_table[260] = 0xC3;

                crc_table[261] = 0x3;

                crc_table[262] = 0x2;

                crc_table[263] = 0xC2;

                crc_table[264] = 0xC6;

                crc_table[265] = 0x6;

                crc_table[266] = 0x7;

                crc_table[267] = 0xC7;

                crc_table[268] = 0x5;

                crc_table[269] = 0xC5;

                crc_table[270] = 0xC4;

                crc_table[271] = 0x4;

                crc_table[272] = 0xCC;

                crc_table[273] = 0xC;

                crc_table[274] = 0xD;

                crc_table[275] = 0xCD;

                crc_table[276] = 0xF;

                crc_table[277] = 0xCF;

                crc_table[278] = 0xCE;

                crc_table[279] = 0xE;

                crc_table[280] = 0xA;

                crc_table[281] = 0xCA;

                crc_table[282] = 0xCB;

                crc_table[283] = 0xB;

                crc_table[284] = 0xC9;

                crc_table[285] = 0x9;

                crc_table[286] = 0x8;

                crc_table[287] = 0xC8;

                crc_table[288] = 0xD8;

                crc_table[289] = 0x18;

                crc_table[290] = 0x19;

                crc_table[291] = 0xD9;

                crc_table[292] = 0x1B;

                crc_table[293] = 0xDB;

                crc_table[294] = 0xDA;

                crc_table[295] = 0x1A;

                crc_table[296] = 0x1E;

                crc_table[297] = 0xDE;

                crc_table[298] = 0xDF;

                crc_table[299] = 0x1F;

                crc_table[300] = 0xDD;

                crc_table[301] = 0x1D;

                crc_table[302] = 0x1C;

                crc_table[303] = 0xDC;

                crc_table[304] = 0x14;

                crc_table[305] = 0xD4;

                crc_table[306] = 0xD5;

                crc_table[307] = 0x15;

                crc_table[308] = 0xD7;

                crc_table[309] = 0x17;

                crc_table[310] = 0x16;

                crc_table[311] = 0xD6;

                crc_table[312] = 0xD2;

                crc_table[313] = 0x12;

                crc_table[314] = 0x13;

                crc_table[315] = 0xD3;

                crc_table[316] = 0x11;

                crc_table[317] = 0xD1;

                crc_table[318] = 0xD0;

                crc_table[319] = 0x10;

                crc_table[320] = 0xF0;

                crc_table[321] = 0x30;

                crc_table[322] = 0x31;

                crc_table[323] = 0xF1;

                crc_table[324] = 0x33;

                crc_table[325] = 0xF3;

                crc_table[326] = 0xF2;

                crc_table[327] = 0x32;

                crc_table[328] = 0x36;

                crc_table[329] = 0xF6;

                crc_table[330] = 0xF7;

                crc_table[331] = 0x37;

                crc_table[332] = 0xF5;

                crc_table[333] = 0x35;

                crc_table[334] = 0x34;

                crc_table[335] = 0xF4;

                crc_table[336] = 0x3C;

                crc_table[337] = 0xFC;

                crc_table[338] = 0xFD;

                crc_table[339] = 0x3D;

                crc_table[340] = 0xFF;

                crc_table[341] = 0x3F;

                crc_table[342] = 0x3E;

                crc_table[343] = 0xFE;

                crc_table[344] = 0xFA;

                crc_table[345] = 0x3A;

                crc_table[346] = 0x3B;

                crc_table[347] = 0xFB;

                crc_table[348] = 0x39;

                crc_table[349] = 0xF9;

                crc_table[350] = 0xF8;

                crc_table[351] = 0x38;

                crc_table[352] = 0x28;

                crc_table[353] = 0xE8;

                crc_table[354] = 0xE9;

                crc_table[355] = 0x29;

                crc_table[356] = 0xEB;

                crc_table[357] = 0x2B;

                crc_table[358] = 0x2A;

                crc_table[359] = 0xEA;

                crc_table[360] = 0xEE;

                crc_table[361] = 0x2E;

                crc_table[362] = 0x2F;

                crc_table[363] = 0xEF;

                crc_table[364] = 0x2D;

                crc_table[365] = 0xED;

                crc_table[366] = 0xEC;

                crc_table[367] = 0x2C;

                crc_table[368] = 0xE4;

                crc_table[369] = 0x24;

                crc_table[370] = 0x25;

                crc_table[371] = 0xE5;

                crc_table[372] = 0x27;

                crc_table[373] = 0xE7;

                crc_table[374] = 0xE6;

                crc_table[375] = 0x26;

                crc_table[376] = 0x22;

                crc_table[377] = 0xE2;

                crc_table[378] = 0xE3;

                crc_table[379] = 0x23;

                crc_table[380] = 0xE1;

                crc_table[381] = 0x21;

                crc_table[382] = 0x20;

                crc_table[383] = 0xE0;

                crc_table[384] = 0xA0;

                crc_table[385] = 0x60;

                crc_table[386] = 0x61;

                crc_table[387] = 0xA1;

                crc_table[388] = 0x63;

                crc_table[389] = 0xA3;

                crc_table[390] = 0xA2;

                crc_table[391] = 0x62;

                crc_table[392] = 0x66;

                crc_table[393] = 0xA6;

                crc_table[394] = 0xA7;

                crc_table[395] = 0x67;

                crc_table[396] = 0xA5;

                crc_table[397] = 0x65;

                crc_table[398] = 0x64;

                crc_table[399] = 0xA4;

                crc_table[400] = 0x6C;

                crc_table[401] = 0xAC;

                crc_table[402] = 0xAD;

                crc_table[403] = 0x6D;

                crc_table[404] = 0xAF;

                crc_table[405] = 0x6F;

                crc_table[406] = 0x6E;

                crc_table[407] = 0xAE;

                crc_table[408] = 0xAA;

                crc_table[409] = 0x6A;

                crc_table[410] = 0x6B;

                crc_table[411] = 0xAB;

                crc_table[412] = 0x69;

                crc_table[413] = 0xA9;

                crc_table[414] = 0xA8;

                crc_table[415] = 0x68;

                crc_table[416] = 0x78;

                crc_table[417] = 0xB8;

                crc_table[418] = 0xB9;

                crc_table[419] = 0x79;

                crc_table[420] = 0xBB;

                crc_table[421] = 0x7B;

                crc_table[422] = 0x7A;

                crc_table[423] = 0xBA;

                crc_table[424] = 0xBE;

                crc_table[425] = 0x7E;

                crc_table[426] = 0x7F;

                crc_table[427] = 0xBF;

                crc_table[428] = 0x7D;

                crc_table[429] = 0xBD;

                crc_table[430] = 0xBC;

                crc_table[431] = 0x7C;

                crc_table[432] = 0xB4;

                crc_table[433] = 0x74;

                crc_table[434] = 0x75;

                crc_table[435] = 0xB5;

                crc_table[436] = 0x77;

                crc_table[437] = 0xB7;

                crc_table[438] = 0xB6;

                crc_table[439] = 0x76;

                crc_table[440] = 0x72;

                crc_table[441] = 0xB2;

                crc_table[442] = 0xB3;

                crc_table[443] = 0x73;

                crc_table[444] = 0xB1;

                crc_table[445] = 0x71;

                crc_table[446] = 0x70;

                crc_table[447] = 0xB0;

                crc_table[448] = 0x50;

                crc_table[449] = 0x90;

                crc_table[450] = 0x91;

                crc_table[451] = 0x51;

                crc_table[452] = 0x93;

                crc_table[453] = 0x53;

                crc_table[454] = 0x52;

                crc_table[455] = 0x92;

                crc_table[456] = 0x96;

                crc_table[457] = 0x56;

                crc_table[458] = 0x57;

                crc_table[459] = 0x97;

                crc_table[460] = 0x55;

                crc_table[461] = 0x95;

                crc_table[462] = 0x94;

                crc_table[463] = 0x54;

                crc_table[464] = 0x9C;

                crc_table[465] = 0x5C;

                crc_table[466] = 0x5D;

                crc_table[467] = 0x9D;

                crc_table[468] = 0x5F;

                crc_table[469] = 0x9F;

                crc_table[470] = 0x9E;

                crc_table[471] = 0x5E;

                crc_table[472] = 0x5A;

                crc_table[473] = 0x9A;

                crc_table[474] = 0x9B;

                crc_table[475] = 0x5B;

                crc_table[476] = 0x99;

                crc_table[477] = 0x59;

                crc_table[478] = 0x58;

                crc_table[479] = 0x98;

                crc_table[480] = 0x88;

                crc_table[481] = 0x48;

                crc_table[482] = 0x49;

                crc_table[483] = 0x89;

                crc_table[484] = 0x4B;

                crc_table[485] = 0x8B;

                crc_table[486] = 0x8A;

                crc_table[487] = 0x4A;

                crc_table[488] = 0x4E;

                crc_table[489] = 0x8E;

                crc_table[490] = 0x8F;

                crc_table[491] = 0x4F;

                crc_table[492] = 0x8D;

                crc_table[493] = 0x4D;

                crc_table[494] = 0x4C;

                crc_table[495] = 0x8C;

                crc_table[496] = 0x44;

                crc_table[497] = 0x84;

                crc_table[498] = 0x85;

                crc_table[499] = 0x45;

                crc_table[500] = 0x87;

                crc_table[501] = 0x47;

                crc_table[502] = 0x46;

                crc_table[503] = 0x86;

                crc_table[504] = 0x82;

                crc_table[505] = 0x42;

                crc_table[506] = 0x43;

                crc_table[507] = 0x83;

                crc_table[508] = 0x41;

                crc_table[509] = 0x81;

                crc_table[510] = 0x80;

                crc_table[511] = 0x40;

                #endregion

                if (configuration == null || configuration.DataList == null)

                    return;

                DataList = configuration.DataList;

                Setting = configuration.ComSetting;

                SlaveID = configuration.SlaveID;

                #region 填充数据集合

                DicData = new Dictionary<short, short>();

                foreach (RecivedData data in DataList)

                {

                    DicData.Add(data.Address, 0);

                }

                #endregion


            }

            #endregion

            #region 打开、关闭COM口

            /// <summary>

            /// 打开COM口

            /// </summary>

            /// <param name="portName">COM口名称</param>

            /// <param name="baudRate">波特率</param>

            /// <param name="dataBits">数据位</param>

            /// <param name="parity">奇偶校验位</param>

            /// <param name="stopBits">停止位</param>

            /// <returns></returns>

            public void Start()

            {

                if (!sp.IsOpen)

                {

                    try

                    {

                        sp.PortName = Setting.PortName;

                        sp.BaudRate = Setting.BaudRate;

                        sp.DataBits = Setting.DataBits;

                        sp.Parity = Setting.Parity;

                        sp.StopBits = Setting.StopBits;

                        sp.DtrEnable = true;//启用控制终端就续信号

                        sp.RtsEnable = true; //启用请求发送信号

                        sp.ReadTimeout = 1000;

                        sp.WriteTimeout = 1000;

                        sp.Open();

                        Status = AppStatus.监听;

                        sp.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);

                    }

                    catch

                    {

                        Status = AppStatus.停止;

                    }

                }

                if (ComPortStatusChangedEvent != null)

                {

                    ComPortStatusChangedEvent(Status);

                }

            }


            /// <summary>

            /// 关闭COM口

            /// </summary>

            /// <returns></returns>

            public void Close()

            {

                if (sp != null)

                {

                    if (sp.IsOpen)

                    {

                        try

                        {

                            sp.Close();

                        }

                        catch

                        {

                        }

                    }

                }

                Status = AppStatus.停止;

                if (ComPortStatusChangedEvent != null)

                {

                    ComPortStatusChangedEvent(Status);

                }

            }

            /// <summary>

            /// 刷新指定数据

            /// </summary>

            public void RefreshData(short address, float value)

            {

                foreach (RecivedData data in DataList)

                {

                    if (data.Address == address)

                    {

                        DicData[address] = (short)(value * (data.ExactNum == 0 ? 1 : data.ExactNum));

                        break;

                    }

                }

            }

            #endregion

            #region 生成CRC码

            /// <summary>

            /// 生成CRC码

            /// </summary>

            /// <param name="message">发送或返回的命令,CRC码除外</param>

            /// <param name="CRC">生成的CRC码</param>

            public void GetCRC(byte[] message, ref byte[] CRC)

            {

                ushort CRCFull = 0xFFFF;

                byte CRCHigh = 0xFF, CRCLow = 0xFF;

                char CRCLSB;

                for (int i = 0; i < message.Length - 2; i++)

                {

                    CRCFull = (ushort)(CRCFull ^ message[i]);

                    for (int j = 0; j < 8; j++)

                    {

                        CRCLSB = (char)(CRCFull & 0x0001);

                        //下面两句所得结果一样

                        //CRCFull = (ushort)(CRCFull >> 1);

                        CRCFull = (ushort)((CRCFull >> 1) & 0x7FFF);

                        if (CRCLSB == 1)

                            CRCFull = (ushort)(CRCFull ^ 0xA001);

                    }

                }

                CRC[1] = CRCHigh = (byte)((CRCFull >> 8) & 0xFF);

                CRC[0] = CRCLow = (byte)(CRCFull & 0xFF);

            }

            #endregion

            #region CRC验证

            /// <summary>

            /// 国标算法

            /// </summary>

            /// <param name="modbusframe">数据</param>

            /// <param name="Length">数据字节长度</param>

            /// <returns></returns>

            private int crc16(byte[] modbusframe, int Length)

            {

                int i;

                int index;

                int crc_Low = 0xFF;

                int crc_High = 0xFF;


                for (i = 0; i < Length; i++)

                {

                    index = crc_High ^ (char)modbusframe[i];

                    crc_High = crc_Low ^ crc_table[index];

                    crc_Low = (byte)crc_table[index + 256];

                }


                return crc_High * 256 + crc_Low;

            }

            /// <summary>

            /// CRC校验

            /// </summary>

            /// <param name="src">ST开头,&&结尾</param>

            /// <returns>十六进制数</returns>

            public string CRCEfficacy(string src)

            {

                byte[] byteArr = Encoding.UTF8.GetBytes(src);

                int len = byteArr.Length;

                int temp = crc16(byteArr, len);

                string result = temp.ToString("X");

                return result;

            }

            #endregion

            #region 数据读取

            void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)

            {

                lock (o)

                {

                    try

                    {

                        Thread.Sleep(120);

                        int len = sp.BytesToRead;

                        if (len != 0)

                        {

                            byte[] buff = new byte[len];

                            sp.Read(buff, 0, len);

                            Thread thread = new Thread(new ParameterizedThreadStart(HandData));

                            thread.Start(buff);

                        }

                    }

                    catch (Exception ex)

                    {

                        if (RecivedMessageEvent != null)

                        {

                            RecivedMessageEvent(ex.Message);

                        }

                    }

                }

            }

            /// <summary>

            /// 数据接收线程

            /// </summary> 

            private void HandData(object o)

            {

                byte[] buff = o as byte[];

                if (buff == null)

                    return;

                int crc = crc16(buff, buff.Length);

                if (crc != 0)

                {

                    //Crc数据校验失败 

                    string str = string.Empty;

                    foreach (byte b in buff)

                    {

                        str += b + " ";

                    }

                    RecivedMessage("Crc校验错误,数据:" + str);

                }

                if (buff.Length < 8)

                    return;

                ModbusData data = new ModbusData();

                data.SlaveID = buff[0];

                if (data.SlaveID != SlaveID)//判断是否符合从机地址

                {

                    RecivedMessage("从机地址错误,地址:" + data.SlaveID);

                    return;

                }

                data.Code = buff[1];

                if (data.Code == 3)

                {

                    RecivedMessage("接收数据请求信息");

                    #region 响应数据请求

                    try

                    {

                        byte[] temp = new byte[2];//起始地址

                        temp[0] = buff[3];

                        temp[1] = buff[2];

                        Int16 startAddress = BitConverter.ToInt16(temp, 0);//值

                        temp = new byte[2];//数量

                        temp[0] = buff[5];

                        temp[1] = buff[4];

                        Int16 count = BitConverter.ToInt16(temp, 0);//值

                        if (count > 0)

                        {

                            byte[] response = new byte[2 + 1 + count * 2];

                            response[0] = data.SlaveID;

                            response[1] = data.Code;

                            response[2] = Convert.ToByte(count * 2);


                            for (Int16 index = 0; index < count; index++)

                            {

                                Int16 dataValue = 0;

                                short key = Convert.ToInt16(startAddress + index);

                                if (DicData.ContainsKey(key))

                                {

                                    dataValue = DicData[key];

                                }


                                byte[] valueByte = BitConverter.GetBytes(dataValue);

                                response[3 + index * 2 + 1] = valueByte[0];

                                response[3 + index * 2] = valueByte[1];

                            }

                            byte[] crcBytes = new byte[2];

                            byte[] sendResponse = new byte[response.Length + crcBytes.Length];

                            response.CopyTo(sendResponse, 0);

                            GetCRC(sendResponse, ref crcBytes);

                            sendResponse[sendResponse.Length - 1] = crcBytes[1];//高8位   

                            sendResponse[sendResponse.Length - 2] = crcBytes[0];//低8位

                            try

                            {

                                sp.Write(sendResponse, 0, sendResponse.Length);

                                RecivedMessageEvent("数据响应成功,发送数据长度:" + sendResponse.Length + " 数据开始编号:" + startAddress);

                            }

                            catch (Exception ex)

                            {

                                RecivedMessageEvent("数据响应错误,错误:" + ex.Message + " 数据开始编号:" + startAddress);

                            }

                        }

                    }

                    catch

                    {

                        string str = string.Empty;

                        foreach (byte b in buff)

                        {

                            str += b + " ";

                        }

                        RecivedMessage("数据解析错误,数据:" + str);

                    }

                    #endregion

                }

                else

                {

                    //其他命令数据 

                    string str = string.Empty;

                    foreach (byte b in buff)

                    {

                        str += b + " ";

                    }

                    RecivedMessage("其他命令数据,数据:" + str);

                }

            }

            /// <summary>

            /// 通知消息至前端

            /// </summary>  

            private void RecivedMessage(string message)

            {

                if (RecivedMessageEvent != null)

                {

                    RecivedMessageEvent(message);

                }

            }

            #endregion

        }

        #region 委托

        /// <summary>

        /// 接收到数据信息

        /// </summary> 

        public delegate void RecivedDataEventHandler(ModbusData data);

        /// <summary>

        /// 接收到告警信息

        /// </summary> 

        public delegate void RecivedMessageEventHandler(string message);

        /// <summary>

        /// 端口状态改变事件

        /// </summary>

        public delegate void ComPortStatusChangedEventHandler(AppStatus status);

        #endregion

        /// <summary>

        /// 接收到的数据信息

        /// </summary>

        public class ModbusData

        {

            /// <summary>

            /// 从机地址

            /// </summary>

            public byte SlaveID { get; set; }

            /// <summary>

            /// 功能码

            /// </summary>

            public byte Code { get; set; }

            /// <summary>

            /// 数据开始地址

            /// </summary>

            public Int16 StartAddress { get; set; }

            /// <summary>

            /// 寄存器个数

            /// </summary>

            public Int16 MCount { get; set; }

            /// <summary>

            /// 数值值列表

            /// </summary>

            public Int16[] Data { get; set; }

        }

    }




    本文转自成杭 51CTO博客,原文链接:http://blog.51cto.com/hangtc/1955689,如需转载请自行联系原作者


    展开全文
  • usb转rs-485,基于ModBus RTU获取气象站信息,包括简单数据库操作,使用vs2013,包括CRC校验,增加掉线检测,掉线重连
  • 动物电子耳标阅读器|识读器|读卡器L8600系列Modbus RTU通讯协议与二次开发说明适用于L8600-S-02、L8600-R-02,更多MODBUS TCP协议资料欢迎交流! 出厂默认配置: 从机地址 02 复位配置 ...

    动物电子耳标阅读器|识读器|读卡器L8600系列Modbus RTU通讯协议与二次开发说明适用于L8600-S-02、L8600-R-02,更多MODBUS TCP协议资料欢迎交流!

    出厂默认配置:

    从机地址

    02

    复位配置

    标准主从模式、天线为开启状态

    想要读卡器读到卡就发送数据(从机主动发送模式):开机后要发指令:02 06 00 00 00 03 C9 F8

    串口配置(8位数据位):

    波特率

    19200 

    校验

    1位偶校验

    停止位

    1位

    系统可配置内容:(16进制通信)

    1. 天线开关和应答模式,(从机主动发送)模式时读卡器读到卡后会主动往总线发读卡数据;(主从模式)时是读卡器不会主动返回数据,等到主机访问才回复数据。此配置数据断电不保存,需要每次上电进行一次配制。(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 06 00 00 00 03 C9 F8

    天线开,从机主动发送

    02 06 00 00 00 03 C9 F8

    通常应用在一主一从的通信中

    02 06 00 00 00 02 08 38

    天线开,主从模式

    02 06 00 00 00 02 08 38

     

    02 06 00 00 00 01 48 39

    天线关,从机主动发送

    02 06 00 00 00 01 48 39

     

    02 06 00 00 00 00 89 F9

    天线关,主从模式

    02 06 00 00 00 00 89 F9

     

    1. 卡片的后带数据长度和读卡器地址。后带数据指的是有些卡片发送数据除了卡号和国家代号外,后面还带有其他数据,当前产品支持最多访问20个字节的数据(160位)。此配置数据保存,断电不丢失。(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 06 00 01 A0 02 21 F8

    A0(160)个位。地址0x02 (范围:1-247)

    02 06 00 01 A0 02 21 F8

    读取后带数据160位,地址配置为0x02

    02 06 00 01 00 02 59 F8

    无后加数据(范围:0-160),地址0x02 (范围:1-247)

    02 06 00 01 00 02 59 F8

    配置值不在范围时,返回值正常,但系统不理会。

    读取数据:(16进制通信)

    1. 读取天线开关和应答模式信息。(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 03 00 00 00 01 84 39

    回读0x00地址信息

    02 03 02 00 03 BC 45

    天线开,从机主动发送

    2、读取后带数据长度、地址、版本号信息。(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 03 00 01 00 04 15 FA

    回读0x01-0x04地址信息

    02 03 08 A0 02 17 05 B1 FA 00 01 BA C1

    后带数据长0xA0,地址:0x02,版本信息:

    17 05 B1 FA 00 01

    3、读取系统调谐状态信息(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 03 00 05 00 09 95 FE

    回读0x05-0x0D地址信息

    02 03 12 B5 3F 50 62 81 9C B9 B6 98 8A 70 60 52 4A 41 3C 37 05 26 AA

    系统调谐状态信息,用于查看模块工作状态,平常不用读取

    4、读卡数据读取:(16进制通信)

    主机发送命令

    配置内容

    读卡器返回

    备注

    02 03 00 0E 00 07 65 F8

    回读0x0E-0x15地址信息,长度为0x07

    02 03 0E 02 62 07 B6 60 CB 53 00 80 00 00 00 00 3E DC F6

    读取到卡号等卡片信息

    02 03 00 0E 00 11 E4 36

    回读0x0E-0x1F地址信息,长度为0x11

    02 03 22 02 62 07 B6 60 CB 53 80 80 00 00 00 11 11 11 11 22 22 22 22 33 33 24 55 25 25 45 53 55 84 53 43 FF 20 D5 CF

    读取到卡号信息和后带数据信息

    读卡数据读取的长度可以从0x07-0x11(就是说回读信息地址可以从(0x0E-0x15)到(0x0E-0x1F))。

    发送命令分析(02 03 00 0E 00 07 65 F8)

    02:  从机地址;

    03:   读取功能(MODBUS-RTU);

    000E:读取寄存器地址;

    0007:读取数据长度(7个字14 Bytes);

    65F8:前面所有数据(02 03 00 0E 00 07)的CRC检验值,低字节先发。

    接收命令分析:(02 03 0E 02 62 07 B6 60 CB 53 00 80 00 00 00 00 3E DC F6)

    02:从机地址;

    03: 读取功能(MODBUS-RTU);

    0E:回读数据长度(14 Bytes);

    0262:国家代号(10进制610)

    07B660CB53:卡号数据(10进制33124567891)

    00:0000 0000最低位代表后加数据是否有效(0无效、1有效),其他7位是未定义数据。

    80:1000 0000最高位代表动物标志,其他7位是未定义数据。

    000000:卡内其他数据,未定义数据。

    00:数据传输补充够偶数字节(14 Bytes),无意义

    3E: 当前数据的读卡时间(0x3E*0.02s) 证明是1.24s 前读到的,最多计算到5.1s前。

    DCF6:前面整个数据包(02 03 0E 02 62 07 B6 60 CB 53 00 80 00 00 00 00 3E)的CRC检验。DC为低字节,F6为高字节。

    接收命令分析:(02 03 22 02 62 07 B6 60 CB 53 80 80 00 00 00 11 11 11 11 22 22 22 22 33 33 24 55 25 25 45 53 55 84 53 43 FF 20 D5 CF)

    02 03 22 02 62 07 B6 60 CB 53 80 80 00 00 00:和以上分析一致。

    11 11 11 11 22 22 22 22 33 33 24 55 25 25 45 53 55 84 53 43:20字节的后加数据。

    FF:数据传输补充够偶数字节(34 Bytes),无意义。

    20:当前数据的读卡时间(0x20*0.02s) 证明是0.64s 前读到的,最多计算到5.1s前。

    D5CF: 前面整个数据包的CRC检验,D5为低字节,CF为高字节。

    从机主动发信息的方式:机器读到卡会马上发一帧数据,如果卡片一直不离开数据不会重复发送,如果卡离开0.2s以上再进入机器会再发一帧数据(每次卡片进入都会实时往总线发送一帧数据)

    当将读卡器配置为从机主动发送模式后,读卡器读到卡就马上往总线上发卡号信息,信息的长度可以配置,比如我们将后加数据长度配置为30位(16位以下不发送后带数据,后带数据从16-160有效),35位为4个字节3位需要5个字节来发送,所以字符串数据长度为12(卡号信息长度)+5=17字节,但是由于数据长度数要偶数(字),所以后面要补个随机数,即18个。所以字符串的构成就是0xxx(从机地址)+0x03(功能)+0x12(18个字节)+18个字节数据+2字节CRC。总共23个字节。(后加数据如果没有需要时最好配0,有利于数据传输

    例如后加数据配置A0(160位、20字节)。卡片有后加数据时收到的数据为:

    03 03 20 02 62 07 B6 60 CB 53 01 80 00 00 00 11 11 11 11 22 22 22 22 33 33 24 55 25 25 45 53 55 84 53 43 C1 26 

    03:从机地址;

    03: 读取功能(MODBUS-RTU);

    20:回读数据长度(32 Bytes);

    0262:国家代号(10进制610)

    07B660CB53:卡号数据(10进制33124567891)

    01:0000 0001最低位代表后加数据是否有效(0无效、1有效),其他7位是未定义数据。

    80:1000 0000最高位代表动物标志,其他7位是未定义数据。

    000000:卡内其他数据,未定义数据。

    11 11 11 11 22 22 22 22 33 33 24 55 25 25 45 53 55 84 53 43:是后加数据20个字节。

    C126:CRC校验。

    将后加数据配置为0后读到数据:02 03 0C 02 62 07 B6 60 CB 53 01 80 00 00 00 17 35

    02:从机地址;

    03: 读取功能(MODBUS-RTU);

    0C:回读数据长度(12 Bytes);

    0262:国家代号(10进制610)

    07B660CB53:卡号数据(10进制33124567891)

    01:0000 0001最低位代表后加数据是否有效(0无效、1有效),其他7位是未定义数据。

    80:1000 0000最高位代表动物标志,其他7位是未定义数据。

    000000:卡内其他数据,未定义数据。

    1735: CRC校验

    本协议符合MODBUS- RTU标准,支持0地址广播监听功能(可以用于配置从机地址等信息)。但是广播命令从机不做回复。

    CRC校验函数:

    unsigned int CRC16_MB(unsigned char *cBuffer, unsigned int iBufLen)

    {

        unsigned int i, j; 

            unsigned int wPolynom = 0xa001;

            unsigned int wCrc     =  0xffff;

        for (i = 0; i < iBufLen; i++)

        {

            wCrc ^= cBuffer[i];

            for (j = 0; j < 8; j++)

            {

                if (wCrc &0x0001)

                {

                    wCrc = (wCrc >> 1) ^ wPolynom;

                }

                else

                {

                    wCrc = wCrc >> 1;

                }

            }

        }

        return wCrc;

    }

    附录:

    设备地址

    命令

    寄存器地址

    内容

    实现的功能

    02

     

    06

     

    00 00

    (配置后断电不保存)

     

    b15-

    b3:无定义,(上电默认:00 02)

    b0==1:从机主动发送通常应用在一主一从的通信中

    b0==0:主从模式

    b1==1:天线开

    b1==0:天线关

    b2==1:从机主动发送模式下,读到卡连续发送数据

    b2==0:从机主动发送模式下,卡进入一次场区发送一次数据

    00 01

    (配置后断电保存)

    A0 02

    读取后带数据160(0xA0)位,设备地址配置为0x02

    00 02

    无后加数据,设备地址0x02

    03

     

    00 00

    00 01

    返回0x00地址信息,即天线状态和发送模式

    00 01

    00 04

    后带数据长度和地址以及版本信息

    00 05

    00 09

    系统调谐状态信息,用于查看模块工作状态,平常不用读取

    以上命令仅支持以上格式读写

    02

    03

    00 0E

    00 01

    ~

    00 11

    读取到卡号信息和后带数据信息

     

     

    展开全文
  • MODBUS与西门子PLC200的运用。
  • 1、Modbus协议属于应用层(OSI模型第7层)协议,TCP/UDP协议属于传输层(OSI模型第4层)协议,两者层级不是并列关系。打个比喻,Modbus协议就像公司里的总经理,TCP/UDP协议就像公司里的轿车、商务车。某天总经理要到...

    1、Modbus协议属于应用层(OSI模型第7层)协议,TCP/UDP协议属于传输层(OSI模型第4层)协议,两者层级不是并列关系。

    打个比喻,Modbus协议就像公司里的总经理,TCP/UDP协议就像公司里的轿车、商务车。某天总经理要到机场去乘飞机,他可以选择:1)自己开轿车去,2)让司机开商务车送去,3)搭的士/公交车过去。若选择1),那就是总经理-轿车的关系,Modbus TCP协议就形同这种关系。若选择3),就形同另外的Modbus RTU/ASCII协议的关系。

    478513c0f6775447bf3af962fea28e99.png

    2、Modbus协议是一种已广泛应用于当今工业控制领域的通用通讯协议。通过此协议,控制器相互之间、或控制器经由网络(如以太网)可以和其它设备之间进行通信。Modbus协议使用的是主从通讯技术,即由主设备主动查询和操作从设备。一般将主控设备方所使用的协议称为Modbus Master,从设备方使用的协议称为Modbus Slave。典型的主设备包括工控机和工业控制器等;典型的从设备如PLC可编程控制器等。Modbus通讯物理接口可以选用串口(包括RS232和RS485),也可以选择以太网口。

    3、而Modbus TCP协议则是在RTU协议上加一个MBAP报文头,由于TCP是基于可靠连接的服务,RTU协议中的CRC校验码就不再需要,所以在Modbus TCP协议中是没有CRC校验码,用一句比较通俗的话说就是:Modbus TCP协议就是Modbus RTU协议在前面加上五个0以及一个6,然后去掉两个CRC校验码字节就OK.虽然这句话说得不是特别准确,但是也基本上把RTU与TCP之间的区别说得比较清楚了。

    展开全文
  • 每个串口最多可接255只 IBF25系列模块,通讯方式采用ASCII码通讯协议或MODBUS RTU通讯协议,地址和波特率可由代码设置,能与其他厂家的控制模块挂在同一RS-485总线上,便于计算机编程。 IBF25系列产品是基于单片机的...
  • 公司目前所做产品都是基于ModBus-RTU通讯协议,最近一直在写触摸屏应用程序,多多少少也了解了触摸屏ModBus-RTU模块是如何工作的; 【上位机】 采用CSerialPort类实现基本的串口通信,每当接收到一个字符时,向主...
  • MODBUS-RTU通讯协议

    2014-08-03 09:39:33
    MODBUS-RTU通讯协议
  • Modbus 一个工业上常用的通讯协议、一种通讯约定。MODBUS-RTU,再单片机上很容易实现。所以我们见到的很多仪表都采用的MODBUS-RTU协议 ,其物理层可以说是485,通常我们只需要A接A,B接B即可。最近呢,我是使用了一款...
  • modbus_rtu通讯协议

    2013-12-01 22:02:35
    讲述modbus_rtu通讯协议的架构,以及代码的分析
  • MODBUS_RTU通讯协议

    2013-06-05 14:30:49
    福光百特(FB)工控标准的modbus_RTU协议通讯协议
  • MODBUS——RTU通讯协议简介

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 761
精华内容 304
关键字:

modbusrtu通讯协议