一、MODBUS规约

  Modbus规约是一种广泛使用的串行通信协议（应用层报文传输协议），用于工业环境中控制器和电子设备之间的数据交换。

Modbus协议的特点：

• Modbus是一种应用广泛的问答式通信规约

  信息交换是以主站采取主动实现的，即由主站启动交换。所有的一个完整交换由下行和上行两个报文组成：

  • 下行报文：主站发出的一个请求到从站
  • 上行报文：从站发回的一个回答到主站

• MODBUS 是一种主／从架构

  Modbus协议中，主设备发起通信请求，而从设备响应这些请求。

• Modbus设备中的数据存储在寄存器中，包括位寄存器和16位寄存器，每个寄存器都有一个唯一的地址

• Modbus支持多种通信方式，包括Modbus RTU和Modbus TCP。Modbus RTU主要用于串口通信，而Modbus TCP适用于以太网通信

• Modbus协议的帧格式简单紧凑，易于理解和实现。Modbus RTU帧以CRC校验（错误检测机制）结束，确保数据的完整性。而Modbus TCP帧则不包含CRC校验，因为TCP/IP协议本身提供了错误检测和重传机制。

• 设备地址唯一性：在Modbus网络中，每个从设备都有一个唯一的地址，确保了通信的准确性

• 支持多种电气接口：Modbus可以支持多种电气接口，如RS-232、RS-485等，并且可以在多种介质上传输，包括双绞线、光纤、无线等

1.MODBUS-RTU规约

报文格式：

  所有交换的 RTU 类型报文（帧），无论上／下行，具有相同的结构：

从站号	功能码	数据区	CRC16校验和
1字节	1字节	n字节	2字节

每帧报文包含 4 种类型的信息：

• 从站号

  从站号为 1 字节，取值范围为 0～FFH．例外的，如果此值为 0，则作为主站的广播信文标识．因此，物理上使用的从站号只能在 01H～FFH 之间（即1～255 之间）

• 功能码

  功能码为 1 字节，它被用来选择一个命令（读、写或回答校验是否正确等）,有效功能码范围为 1～255 之间。Modbus标准协议中可使用如下功能码：

  功能码（十进制）	含义
  01	读线圈状态
  02	读离散输入量寄存器
  03	读多个保持寄存器
  04	读输入型寄存器
  05	强制单个线圈
  06	写单个寄存器
  15	强制多个线圈
  16	写多个保持寄存器
  20	读变量
  21	写变量

  上述是Modbus协议支持的所有功能码（标准），并不代表所有支持Modbus-RTU通信协议的设备支持所有功能码。比如：

  • 安科瑞ADL400导轨式多功能电能表的RS485 通信接口支持 MODBUS-RTU 通信协议，但只支持MODBUS-RTU 协议中的 03H 命令与 10H 命令，03H 为读多个寄存器，10H为写多个寄存器
  • 高特ESBCM的物理接口同时支持485接口与TCP接口，支持的功能码有02、03、04、06、41
  • 汇川PCS支持采用 MODBUS RTU 或 MODBUS TCP/IP 通讯规约实现PCS与EMS之间的通信。支持的功能码有03、06
  • TX-CSL60-230除湿机具有RS-485通信口，支持功能码03、06

  功能码解读：

  读线圈状态–功能码01：

  • 线圈通常指的是设备的输出线圈，如继电器或接触器的线圈
  • 这个功能用于读取这些输出线圈的状态，即它们是被激活（闭合）还是未激活（断开）

  读离散输入量寄存器–功能码02：

  • 这些寄存器一般是只读位寻址寄存器，一般可用于存储设备的告警信息，如：高特ESBCM

    

  读多个保持寄存器–功能码03：

  • 这些寄存器是读写寻址寄存器，可接受多种数据类型，只要每一帧报文要采集的点位对应的数据类型相同即可，如安科瑞ADL400电能表

    

  读输入型寄存器–功能码04：

  • 这些寄存器为只读字寻址寄存器，输入型寄存器通常包含模拟输入信号的数字化值，如从传感器或变位器获取的信息，如高特ESBCM

    

  强制单个线圈–功能码05

    字面意思感觉是遥控的功能码，不确定

  Modbus的数据传输被定义为对以下4个存储块的读写：(方便理解功能码的具体含义)

  • 线圈–操作单位为1位字的开关量，PLC的输出位，在Modbus中可读可写

    一般指的是触点的“开”与“关”的状态

  • 离散量–操作单位为1位字的开关量，PLC的输入位，在Modbus中只读

  • 输入寄存器-- 操作单位为16位字(两个字节)数据，PLC中只能从模拟量输入端改变的寄存器，在Modbus中只读

  • 保持寄存器-- 操作单位为16位字(两个字节)数据，PLC中用于输出模拟量信号的寄存器，在Modbus中可读可写

• 数据区

  数据区为 n 字节，它包含与功能码相关的一串十六进制数据，

  如果是读，则包含寄存器起始地址与寄存器数量，数据格式基本一致。

  • 寄存器起始地址指的是要通讯设备的寄存器地址，查设备的使用说明书就可以得到，如：

  

  • 寄存器数指的是一帧报文连续读多少个寄存器
    

  如果是写，则需要分写单个与写多个

  • 示例
    

• CRC16校验码和

  CRC16校验码通常被添加到数据帧的末尾，用于接收端校验数据的完整性。

  CRC在线计算网址为http://www.ip33.com/crc.html，该报文帧为01 03 00 01 00 01 D5 CA。
  

2.MODBUS-TCP规约

  Modbus由MODICON公司于1979年开发，是一种工业现场总线协议标准。1996年施耐德公司推出基于以太网TCP/IP的Modbus协议：Modbus-TCP。与传统的串口方式，MODBUS TCP插入一个标准的MODBUS报文到TCP报文中，不再带有数据校验和地址。

  Modbus-TCP结合了Modbus应用协议和TCP/IP网络协议，主要用于工业自动化领域，允许设备通过以太网进行数据交换。

以下是Modbus-TCP通信规约的关键点：

• 基于TCP/IP：Modbus-TCP运行在TCP/IP网络上，使用TCP作为传输层协议，确保数据的可靠传输

• MBAP报文头：Modbus-TCP的数据帧包含一个Modbus应用协议(MBAP)报文头，长度为7字节，包含了事务处理标识、协议标识、长度和单元标识符等信息

• 端口号：Modbus-TCP通信通常使用TCP端口号502，这是由互联网编号分配管理机构(IANA)为Modbus协议指定的端口号

• 主从架构：Modbus-TCP遵循主从架构，有一个主站(客户端)和多个从站(服务器)。主站发起请求，从站响应请求

• 数据表示：Modbus-TCP在以太网TCP/IP数据包中传输Modbus RTU或ASCII格式的数据帧，但不包含数据校验和地址

• 功能码：Modbus-TCP保留了Modbus RTU和ASCII的功能码，用于执行不同的操作，如读取和写入寄存器

• 异常响应：当从站设备无法正确处理主站的请求时，会返回异常功能码和错误代码，以指示错误类型

• 通信过程：Modbus-TCP的通信过程包括建立TCP连接、发送Modbus报文、接收响应报文和关闭TCP连接

• 数据帧格式：Modbus-TCP的数据帧格式包括MBAP报文头和PDU（协议数据单元），其中PDU包含Modbus功能码和数据

Modbus-TCP报文帧格式：

  Modbus-TCP的数据帧可分为两部分：MBAP+PDU。

• MBAP报文头，长度为7个字节，组成如下：

  序号	名称	字节长度	说明
  1	事务处理标识	2	可以理解为报文的序列号，一般每次通信之后就要加1以区别不同的通信数据报文
  2	协议标识	2	协议标识符，00 00表示ModbusTCP协议
  3	长度	2	表示后续字节数，单位为字节
  4	单元标识符	1	设备标识符，即从站地址

• 帧结构PDU，由功能码与数据区组成，

  • 功能码为1个字节，同上

  • 数据区长度不定，同上

二、报文解析

1.MODBUS-RTU报文帧解析

  以ADL400导轨式多功能电能表为例，解析报文的请求（查询报文帧）与响应（返回数据帧）。

读A相电流数据：

请求/返回	报文数据
RTU报文_请求	01 03 00 64 00 01 C5 D5

• 01：从机地址
• 03：读功能码
• 00 64：寄存器起始地址
• 00 01：读取寄存器个数
• C5 D5：CRC16校验码和

请求/返回	报文数据
RTU报文_回复	01 03 02 03 B2 38 C1

• 01：从机地址

• 03：读功能码

• 02：表示后面有两个字节长度的数据，如果一个寄存器占两个字节，则数据长度等于寄存器量*2

• 03 B2：对应点位的数据，以十六进制表示，这里是A相电流数据

  处理如下：03 B2（十六进制） = 946（十进制）

  计算：946 * 0.01 = 9.46，单位：A

• 38 C1：循环冗余校验码

读总有功电能数据：

请求/返回	报文数据
RTU报文_请求	01 03 00 00 00 02 C4 0B

• 01：从机地址
• 03：读功能码
• 00 00：寄存器起始地址
• 00 02：读取寄存器个数
• C4 0B：CRC16校验码和

请求/返回	报文数据
RTU报文_返回	01 03 04 00 00 30 26 6F 9E

• 01：从机地址

• 03：读功能码

• 04：表示后面有4个字节长度的数据，如果一个寄存器占两个字节，则数据长度等于寄存器量*2

• 00 00 30 26 ：对应点位的数据，需要用4个字节，以十六进制表示

  高位：00 00(16 进制) = 0 (10 进制)

  低位：30 26(16 进制) = 12326 (10 进制)

  因此该仪表二次测有功电能为：(0×65536 + 12326)*0.01 = 123.26;单位：kWh

2.MODBUS-TCP报文帧解析

  以汇川IES1000-M-04-100 系列储能变流器PCS为例，解析报文的请求（查询报文帧）与响应（返回数据帧）。

读取电网相电压与输出相电压：

请求/返回	报文数据
TCP报文_请求	00 00 00 00 00 06 01 03 ED 64 00 06

• 00 00：事务处理标识
• 00 00：表示ModbusTCP协议
• 00 06：表示后续字节数为6个字节
• 01：从机地址
• 03：读功能码
• ED 64：寄存器起始地址
• 00 06：寄存器的数量为6个

请求/返回	报文数据
TCP报文_返回	00 00 00 00 00 0F 01 03 0C 09 7C 09 7D 09 8A 00 06 00 0A 00 0C

• 00 00：事务处理标识

• 00 00：表示ModbusTCP协议

• 00 0F：表示后续字节数为15个

• 01：从机地址

• 03：读功能码

• 0C：表示后面有12个字节长度的数据，如果一个寄存器占两个字节，则数据长度等于寄存器量*2 （6*2=12=0CH）

• 09 7C 09 7D 09 8A 00 06 00 0A 00 0C：

  • A相电网相电压

    处理如下：09 7c（十六进制） = 2428（十进制）

    计算：2428 * 0.1 = 242.8，单位：V

  • B相电网相电压

    处理如下：09 7D（十六进制） = 2429（十进制）

    计算：2429 * 0.1 = 242.9，单位：V

  • C相电网相电压

    处理如下：09 8A（十六进制） = 2442（十进制）

    计算：2442 * 0.1 = 244.2，单位：V

  • A相输出相电压

    处理如下：00 06（十六进制） = 6（十进制）

    计算：6 * 0.1 = 0.6，单位：V

  • B相输出相电压

    处理如下：00 0A六进制） = 10（十进制）

    计算：10 * 0.1 = 1，单位：V

  • C相输出相电压

    处理如下：00 0C（十六进制） = 12（十进制）

    计算：12 * 0.1 = 1.2，单位：V

写寄存器报文帧解析：

• 写单寄存器

  

• 写多寄存器
  

三、C++代码实现组织报文与解析报文

  执行逻辑

• 首先，从数据库表中获取规约的编号，如：ptl_modbus_cj

• 然后，加载规约动态库，得到该规约对应的组织数据与解析数据的函数

  QLibrary            m_LibPtl;  //加载规约的lib
  
  char chParseFuncName[SIZE_SN] = "parseData"; // 解析报文函数
  char chBuildFuncName[SIZE_SN] = "buildData"; //组织报文函数
  
  m_LibPtl.setFileName(m_qsPtlLibName);       //设置外部动态链接库文件名
  //调用QLibrary对象的load()方法来加载指定的库。如果库文件存在并且可以成功加载，此方法返回true；否则返回false。
  if(m_LibPtl.load())     //加载动态链接库
  {
      //resolve()方法被用来查找库中指定名称的函数,返回一个指向该函数的指针
      m_pFuncParseData = (PFunc_ParseData)(m_LibPtl.resolve(chParseFuncName));  //得到规约对应的解析数据与组织数据的函数
      m_pFuncbuildData = (PFunc_BuildData)(m_LibPtl.resolve(chBuildFuncName));
  
  }
  

• 通道通信发送数据处理

  • 调用规约报文组织函数组织报文

    m_pFuncbuildData(m_SPTLRecvSenddata, dynamic_cast<CUnitBase*>(m_pCurrentUnit));  //调用规约报文组织函数组织报文
    

    PTL_API void buildData(S_RecvSendData &sRecvSendData, CUnitBase* pUnit)  //组织报文
    {
        S_PtlVariant sVariant;
        memset(&sVariant, 0, sizeof(S_PtlVariant));
        if(pUnit != NULL)
        {
            sVariant.pUnit = pUnit;
            sVariant.pBySendBuffer = sRecvSendData.pSendBuf;
            sVariant.uwSendDataLen = sRecvSendData.uiSendLen;
            sVariant.bMainChannel = sRecvSendData.bMainChannel;
            sVariant.byChannelMode = sRecvSendData.byChannelMode;
            sVariant.byChannelIndex = sRecvSendData.byChannelIndex;
            sVariant.pPtlFlag = (S_PtlFlag*)(pUnit->getTUFlagBuffer());  // 获取规约标志位使用的缓冲区
    
            sendFrame(sVariant); //组织数据
            sRecvSendData.uiSendLen = sVariant.uwSendDataLen;
        }
    }
    

    根据组织发送什么类型的报文，调用不同的组织函数

    • 遥测查询帧
    • 遥信查询帧
    • 遥脉查询帧
    • 遥调帧
    • 遥控帧
    • 校时命令

    以组织发送遥测查询帧为例，

    void buildCmdQueryYC(S_PtlVariant &sVariant)
    {
        if(sVariant.uwSendDataLen + 14 > sVariant.uwMaxSendLen)
        {
            return;
        }
    
        quint16 uwTUAddr = sVariant.pUnit->getTUAddress();
        if(uwTUAddr > 255)
        {
            return;
        }
    
        quint8 byDataLen = 0;
        quint8* pBySendBuffer = sVariant.pBySendBuffer + sVariant.uwSendDataLen;
        //校验和开始地址
        quint8* pSumPos = pBySendBuffer;
        pBySendBuffer[0] = uwTUAddr; //从站地址
    
        //功能码
        if(sVariant.pPtlFlag->byQueryYCNum >= sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec.size())
        {
            sVariant.pPtlFlag->byQueryYCNum = 0;
        }
        const S_ModbusQuery* pModbusQuery = sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec[sVariant.pPtlFlag->byQueryYCNum];
        pBySendBuffer[1] = pModbusQuery->byFUNCCODE;
    
        //寄存器起始地址HL
        quint16 uwRegStartAddr = pModbusQuery->uwStartAddr;
        if(MODBUS_BYTEORDER_TYPE_H_L == sVariant.pPtlFlag->pPtlModbus->pModbus->byRegisterByteOrder)
        {
            uwRegStartAddr =  qByteOrderConvert(uwRegStartAddr);
    
        }
        memcpy(pBySendBuffer + 2, &uwRegStartAddr, 2);
    
        //寄存器数量HL
        quint16 uwRegisterNum = pModbusQuery->byRegisterNum;
        uwRegisterNum = qByteOrderConvert(uwRegisterNum);
        memcpy(pBySendBuffer + 4, &uwRegisterNum, 2);
    
        byDataLen = 6;
    
        quint16 uwCheckSum = 0;
        if(buildCheckSum(sVariant, pSumPos, byDataLen, uwCheckSum)) //有校验和
        {
            memcpy(pBySendBuffer + byDataLen, &uwCheckSum, 2);
            byDataLen += 2;
        }
    
        buildTCPHead(sVariant, byDataLen);    //TCP头
    
        sVariant.uwSendDataLen += byDataLen;
        sVariant.pPtlFlag->tLastSendYCTime = qGetCurrentTime();
        sVariant.pPtlFlag->byQueryYCNum++ ;
        sVariant.pPtlFlag->byQueryType = QUERYDATA_TYPE_YCDATA;
        sVariant.pPtlFlag->sendCmdQueryYC = 0;
        sVariant.pPtlFlag->bWaitDataReturn = 1;
        sVariant.pPtlFlag->byResentCount = sVariant.uwSendDataLen;
    }
    

    其中，组织校验和与组织MBAP头的函数分别为

    void buildTCPHead(S_PtlVariant &sVariant, quint8& byDataLen)    //组织TCP头 调用该函数之前 其余报文已经组织完毕
    {
        if(MODBUS_TYPE_TCP == sVariant.pPtlFlag->pPtlModbus->pModbus->byType)
        {
            memmove(sVariant.pBySendBuffer + 6, sVariant.pBySendBuffer, byDataLen);
            sVariant.pBySendBuffer[0] = sVariant.pPtlFlag->pPtlModbus->pModbus->uwTCPHeadHigh;
            sVariant.pBySendBuffer[1] = sVariant.pPtlFlag->pPtlModbus->pModbus->uwTCPHeadLow;
            sVariant.pBySendBuffer[2] = 0;
            sVariant.pBySendBuffer[3] = 0;
            quint16 uwDataLen = byDataLen;
            uwDataLen = qByteOrderConvert(uwDataLen);
            memcpy(sVariant.pBySendBuffer + 4, &uwDataLen, sizeof(quint16));
    
            byDataLen += 6;
        }
    }
    
    bool buildCheckSum(S_PtlVariant &sVariant, quint8 *pStartCheckPost, quint8 byDataLen, quint16 &uwCheckSum)    //组织校验和报文 返回字节转换后的校验后
    {
        //校验
        if(MODBUS_TYPE_RTU == sVariant.pPtlFlag->pPtlModbus->pModbus->byType)
        {
            quint8 byCheckSumType=sVariant.pPtlFlag->pPtlModbus->pModbus->byCheckCodeMode;
            if(CHECK_CODE_CRC == byCheckSumType)    //CRC校验
            {
                uwCheckSum = getCheckCRC16SUM(pStartCheckPost, byDataLen);
            }
            else    //累加和校验
            {
                uwCheckSum = getCheckCumlationSum(pStartCheckPost, byDataLen);
            }
            if(MODBUS_BYTEORDER_TYPE_H_L == sVariant.pPtlFlag->pPtlModbus->pModbus->byCCBYTEORDER)
            {
                uwCheckSum = qByteOrderConvert(uwCheckSum);
            }
            return true;
        }
        return false;
    }
    

  • 组织好报文后，基于通道通讯类型，分别调用串口或网络的发送数据接口

    switch(m_pChannel->byChannelCOMType)
    {
        case CHANNEL_TYPE_TCP_CLIENT:
        case CHANNEL_TYPE_TCP_SERVER:
        case CHANNEL_TYPE_UDP_CLIENT:
        case CHANNEL_TYPE_UDP_SERVER:
            m_SocketMutex.lock();
            m_SPTLRecvSenddata.iSendedLen = m_pNetComm->sendData(m_pSocketHandle, m_SPTLRecvSenddata.pSendBuf, m_SPTLRecvSenddata.uiSendLen);
            m_SocketMutex.unlock();
            if(m_SPTLRecvSenddata.iSendedLen > 0)
            {
                if(m_qsPtlLibName.contains("_zf"))
                {
                    //ljx debug
                    qMSleep(50);
                }
                else
                {
                    //                qMSleep(30);
                }
            }
            break;
        case CHANNEL_TYPE_COM_485:
        case CHANNEL_TYPE_COM_232:
            {
                m_SPTLRecvSenddata.iSendedLen = m_pSerial->sendData(m_SPTLRecvSenddata.pSendBuf,static_cast<int>(m_SPTLRecvSenddata.uiSendLen));
            }
            break;
        case CHANNEL_TYPE_CAN:
    
            break;
    
        default:
            break;
    }
    

• 通道通信接收数据处理

  • 基于通道类型，采用不同的处理方法将接收到的数据存放到接收缓存区中

    switch(m_pChannel->byChannelCOMType)   //通道类型
    {
        case CHANNEL_TYPE_TCP_CLIENT:
        case CHANNEL_TYPE_TCP_SERVER:
        case CHANNEL_TYPE_UDP_CLIENT:
        case CHANNEL_TYPE_UDP_SERVER:
            m_NewRecvedDataMutex.lock();
            while(m_sNewRecvedDataList.size() > 0)
            {
                S_NewRecvedData& sNewRecvedData = m_sNewRecvedDataList.first();
                quint32 uiFreeRecvBufLen = MAX_BUF_SIZE - m_SPTLRecvSenddata.uiRecvedLen;   //剩余的接收缓冲区长度
                if(uiFreeRecvBufLen >= sNewRecvedData.uiRecvedLen)  //若剩余的缓冲区长度大于新接收的缓冲区长度，则新接收到的数据全部复制 
                {
                    memcpy(m_SPTLRecvSenddata.pRecvBuf + m_SPTLRecvSenddata.uiRecvedLen, sNewRecvedData.pRecvBuf, sNewRecvedData.uiRecvedLen);
                    m_SPTLRecvSenddata.uiRecvedLen += sNewRecvedData.uiRecvedLen;
                    m_sNewRecvedDataList.removeFirst();
                }
                else if(uiFreeRecvBufLen > 0)  //若剩余的接收缓冲区长度大于0，则只复制剩余的接收缓冲区长度
                {
                    memcpy(m_SPTLRecvSenddata.pRecvBuf + m_SPTLRecvSenddata.uiRecvedLen, sNewRecvedData.pRecvBuf, uiFreeRecvBufLen);
                    m_SPTLRecvSenddata.uiRecvedLen += uiFreeRecvBufLen;
                    sNewRecvedData.uiRecvedLen -= uiFreeRecvBufLen;
                    memmove(sNewRecvedData.pRecvBuf, sNewRecvedData.pRecvBuf + uiFreeRecvBufLen, sNewRecvedData.uiRecvedLen);
                    break;
                }
                else
                {
                    break;
                }
            }
            m_NewRecvedDataMutex.unlock();
            break;
        case CHANNEL_TYPE_COM_485:
        case CHANNEL_TYPE_COM_232:
            m_uiMaxRecvLen = MAX_BUF_SIZE - m_SPTLRecvSenddata.uiRecvedLen;
            if(m_uiMaxRecvLen > 0)
            {
                m_SPTLRecvSenddata.iRecvedLen = m_pSerial->recvData(m_SPTLRecvSenddata.pRecvBuf + m_SPTLRecvSenddata.uiRecvedLen,
                                                                    static_cast<int>(m_uiMaxRecvLen));  //从串口中接收数据
                if(m_SPTLRecvSenddata.iRecvedLen > 0)
                {
                    m_tRecvedTime = time(NULL);
                    addCommMsg(true, static_cast<quint16>(m_SPTLRecvSenddata.iRecvedLen), m_SPTLRecvSenddata.pRecvBuf + m_SPTLRecvSenddata.uiRecvedLen);  //添加通信报文
                    setUpCommFault(false);
                    setDownCommFault(false);
                    m_SPTLRecvSenddata.uiRecvedLen += static_cast<quint32>(m_SPTLRecvSenddata.iRecvedLen);
                }
                else if(m_SPTLRecvSenddata.iRecvedLen < 0)
                {
                    setCommState(COMM_ERROR);
                }
            }
            break;
        case CHANNEL_TYPE_CAN:
    
            break;
    
        default:
            break;
    }
    

  • 调用规约报文解析函数来解析报文

    m_pFuncParseData(m_SPTLRecvSenddata, dynamic_cast<CUnitBase*>(m_pCurrentUnit)
    

    PTL_API bool parseData(S_RecvSendData &sRecvSendData, CUnitBase* pUnit) //解析报文
    {
        S_PtlVariant sVariant;
        memset(&sVariant, 0, sizeof(S_PtlVariant));
        if(pUnit != NULL)
        {
            sVariant.pUnit = pUnit;
            sVariant.pByReadBuffer = sRecvSendData.pRecvBuf;
            sVariant.uwRecvDataLen = sRecvSendData.uiRecvedLen;
            sVariant.bMainChannel = sRecvSendData.bMainChannel;
            sVariant.byChannelMode = sRecvSendData.byChannelMode;
            sVariant.byChannelIndex = sRecvSendData.byChannelIndex;
            memset(sVariant.pParsedCommMsg, 0, MAX_BUF_SIZE);
            sVariant.uwParsedCommMsgLen = 0;
            sVariant.pPtlFlag = (S_PtlFlag*)(pUnit->getTUFlagBuffer());
    
            if(readFrame(sVariant)) //解析数据
            {
                sRecvSendData.uiRecvedLen = sVariant.uwRecvDataLen;
                return true;
            }
        }
        sRecvSendData.uiRecvedLen = sVariant.uwRecvDataLen;
        return false;
    }
    

    根据要解析什么类型的报文，调用不同的解析函数

    • 解析查询到的数据，可细分为遥测、遥信、遥脉
    • 解析遥控命令的响应
    • 解析遥调命令的响应

    以解析查询到的数据为例，

    bool readFrame(S_PtlVariant &sVariant)   //解析数据
    {
        if(!sVariant.pPtlFlag->bPtlInitOK)
        {
            if(initPtl(sVariant))
            {
                sVariant.pPtlFlag->bPtlInitOK = true;
            }
            else
            {
                return false;
            }
        }
    
        //判断接收长度  数据包长度
        if(sVariant.uwRecvDataLen < 6)
        {
            return false;
        }
    
        if(FRAME_STATE_NO == sVariant.byCurrentRecvedFrameState)
        {	//移除到接受数据中的MBAP头
            parseFrameStateNoToSyncing(sVariant);
            if(sVariant.byCurrentRecvedFrameState != FRAME_STATE_SYNING)
            {
                return false;
            }
        }
        if(FRAME_STATE_SYNING == sVariant.byCurrentRecvedFrameState)
        {
            parseFrameStateSyncingToSync(sVariant);
            if(sVariant.byCurrentRecvedFrameState != FRAME_STATE_SYN)
            {
                return false;
            }
        }
    
        memcpy(sVariant.pParsedCommMsg + sVariant.uwParsedCommMsgLen, sVariant.pByReadBuffer, sVariant.uwCurrentRecvedFrameLen);
        sVariant.uwParsedCommMsgLen += sVariant.uwCurrentRecvedFrameLen;
        sVariant.pUnit->addCommMsg(true, sVariant.uwParsedCommMsgLen, sVariant.pParsedCommMsg, sVariant.byChannelMode, sVariant.byChannelIndex, sVariant.bMainChannel);
    
        //数据接收完毕，开始解析帧
        switch(sVariant.byCurrentRecvedFrameType)
        {
        case FRAME_TYPE_DATA:
            praseQueryedData(sVariant);
            break;
        case FRAME_TYPE_CMD:
            if (sVariant.pUnit->getHaveCmd() && sVariant.pUnit->isCmdProcing())
            {
                switch(sVariant.pUnit->getCmdType())
                {
                case CMD_TYPE_YK:
                    praseAllYK(sVariant);
                    break;
                case CMD_TYPE_YT:
                    parseAllYT(sVariant);
                    break;
    
                default:
                    break;
                }
            }
            break;
    
        default:
            break;
        }
    
        sVariant.byCurrentRecvedFrameState = FRAME_STATE_NO;
        sVariant.byCurrentRecvedFrameType = FRAME_TYPE_MAX;
        offsetRecvBuffer(sVariant, sVariant.uwCurrentRecvedFrameLen);
        sVariant.uwCurrentRecvedFrameLen = 0;
        sVariant.pPtlFlag->bWaitDataReturn = 0;
    
        return true;
    
    }
    
    void praseQueryedData(S_PtlVariant &sVariant)
    {
        //目前没考虑校验和
        switch(sVariant.pPtlFlag->byQueryType)
        {
        case QUERYDATA_TYPE_YCDATA:
            if(0 == sVariant.pPtlFlag->byQueryYCNum ||
                    sVariant.pPtlFlag->byQueryYCNum > static_cast<quint8>(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec.size()))
            {
                return;
            }
            if(sVariant.pByReadBuffer[1] != sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec[sVariant.pPtlFlag->byQueryYCNum - 1]->byFUNCCODE)
            {
                return;
            }
            praseYC(sVariant);
            break;
        case QUERYDATA_TYPE_YXDATA:
            if(0 == sVariant.pPtlFlag->byQueryYXNum ||
                    sVariant.pPtlFlag->byQueryYXNum > static_cast<quint8>(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec.size()))
            {
                return;
            }
            if (sVariant.pByReadBuffer[1] != sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec[sVariant.pPtlFlag->byQueryYXNum - 1]->byFUNCCODE)
            {
                return;
            }
            praseYX(sVariant);
           break;
        case QUERYDATA_TYPE_YMDATA:
            if(0 == sVariant.pPtlFlag->byQueryYMNum ||
                    sVariant.pPtlFlag->byQueryYMNum > static_cast<quint8>(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYMVec.size()))
            {
                return;
            }
            if(sVariant.pByReadBuffer[1] != sVariant.pPtlFlag->pPtlModbus->pModbusQueryYMVec[sVariant.pPtlFlag->byQueryYMNum - 1]->byFUNCCODE)
            {
                return;
            }
            praseYM(sVariant);
            break;
    
        default:
            break;
        }
    }
    

    解析查询帧响应时，需要对于不同的数据类型进行不同的处理，并在解析完成后设置数据库表中对应点位的值

    void praseYC(S_PtlVariant &sVariant)
    {
        const S_ModbusQuery* pModbusQuery = sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec[sVariant.pPtlFlag->byQueryYCNum -1];
        switch(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYCVec[sVariant.pPtlFlag->byQueryYCNum  - 1]->byDataType)
        {
        case DATA_TYPE_UINT8:
        {
            double dYCValue = 0;
            quint8 bytempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint8);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                bytempYCValue = sVariant.pByReadBuffer[3 + i];
                dYCValue = double(bytempYCValue);
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
    
        }
            break;
        case DATA_TYPE_INT8:
        {
            double dYCValue = 0;
            qint8 bytempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(qint8);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                bytempYCValue = sVariant.pByReadBuffer[3 + i];
                dYCValue = double(bytempYCValue);
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
    
        }
            break;
        case DATA_TYPE_UINT16:
        {
            quint32 uiTUModelID = 0;
            char  chTUModelName[SIZE_NAME] = "";
            sVariant.pUnit->getValue(S_DataID(TABLE_TU, sVariant.pUnit->getTUID(), COL_TU_TUMODELID), &uiTUModelID);
            sVariant.pUnit->getValue(S_DataID(TABLE_TUMODEL, uiTUModelID, COL_TUMODEL_TUMODELNAME), chTUModelName);
            QString qsTUModelName = QString(chTUModelName);
    
            double dYCValue = 0;
            quint16 uwTempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint16);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uwTempYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(quint16), sizeof(quint16));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uwTempYCValue = qByteOrderConvert(uwTempYCValue);
                }
                uwTempYCValue = qBigLittleEndianConvert(uwTempYCValue);
                dYCValue = uwTempYCValue;
                if(qsTUModelName.contains("DLJTCW") && uwTempYCValue == 0xffff)
                {
                    qDebug()<<"值为：0XFFFF不上送";
                    continue;
                }
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
            break;
        case DATA_TYPE_INT16:
        {
            double dYCValue = 0;
            qint16 wTempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(qint16);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&wTempYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(qint16), sizeof(qint16));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    wTempYCValue = qByteOrderConvert(wTempYCValue);
                }
                wTempYCValue = qBigLittleEndianConvert(wTempYCValue);
                dYCValue = wTempYCValue;
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
            break;
        case DATA_TYPE_UINT32:
        {
            double dYCValue = 0;
            quint32 uiTempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint32);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uiTempYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(quint32), sizeof(quint32));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uiTempYCValue = qByteOrderConvert(uiTempYCValue);
                }
                uiTempYCValue = qBigLittleEndianConvert(uiTempYCValue);
                dYCValue = uiTempYCValue;
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
            break;
        case DATA_TYPE_INT32:
        {
            double dYCValue = 0;
            qint32 iTempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(qint32);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&iTempYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(qint32), sizeof(qint32));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    iTempYCValue = qByteOrderConvert(iTempYCValue);
                }
                iTempYCValue = qBigLittleEndianConvert(iTempYCValue);
                dYCValue = iTempYCValue;
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
    
            break;
        case DATA_TYPE_FLOAT:
        {
            double dYCValue = 0;
            float fTempYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(float);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&fTempYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(float), sizeof(float));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    fTempYCValue = qByteOrderConvert(fTempYCValue);
                }
                fTempYCValue = qBigLittleEndianConvert(fTempYCValue);
                dYCValue = fTempYCValue;
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
            break;
        case DATA_TYPE_DOUBLE:
        {
            double dYCValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(double);
    
            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&dYCValue, sVariant.pByReadBuffer + 3 + i * sizeof(double), sizeof(double));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    dYCValue = qByteOrderConvert(dYCValue);
                }
                dYCValue = qBigLittleEndianConvert(dYCValue);
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYC, pModbusQuery->uwStartINFO + i, COL_PREYC_YCVALUE), &dYCValue);
            }
        }
            break;
    
        default:
            break;
    
        }
    }
    

补充：

• 数据类型如何影响报文帧
  在解析数据时，对不同的数据类型进行不同的解析处理
• 字节序如何影响报文
  大端字节序通常被认为是“网络字节序”，若系统的硬件架构是按照小端存储的，则网络字节序需先转换成小端字节序再直接解析
• 设备的点位由字节的一个位来决定（遥信点位）
  此时，Modbus查询帧表中数据类型为单字节（也可以是其他，由设备说明书决定），是否位偏移设置为是，

void praseYX(S_PtlVariant &sVariant)
{
    const S_ModbusQuery* pModbusQuery = sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec[sVariant.pPtlFlag->byQueryYXNum -1];
    bool bIfOffset = sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec[sVariant.pPtlFlag->byQueryYXNum -1]->bISOffset;
    quint32 uiIndex = 0;
    if(bIfOffset)
    {
        switch(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec[sVariant.pPtlFlag->byQueryYXNum -1]->byDataType)
        {
        case DATA_TYPE_UINT8:
        case DATA_TYPE_INT8:
        {
            quint8 bytempYXValue = 0;
            quint16 uwYXValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount;

            for(quint32 i = 0; i < uiCount; ++i)
            {
                bytempYXValue = sVariant.pByReadBuffer[3 + i];

                for(quint32 j = 0; j < 8; ++j)
                {
                    uwYXValue = (bytempYXValue >> j) & 0x01;
                    uiIndex = i * 8 + pModbusQuery->uwStartINFO + j;
                    if(!sVariant.pUnit->isCommStateYX(uiIndex)) //不设置通信状态相关的遥信
                    {
                        sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, uiIndex, COL_PREYX_YXVALUE), &uwYXValue);
                    }
                }
            }
        }
            break;
        case DATA_TYPE_UINT16:
        case DATA_TYPE_INT16:
        {
            quint16 uwTempYXValue = 0;
            quint16 uwYXValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint16);

            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uwTempYXValue, sVariant.pByReadBuffer + 3 + i * sizeof(quint16), sizeof(quint16));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uwTempYXValue = qByteOrderConvert(uwTempYXValue);

                }
                uwTempYXValue = qBigLittleEndianConvert(uwTempYXValue);
                for(quint32 j = 0; j < 16; ++j)
                {
                    uwYXValue = (uwTempYXValue >> j) & 0x01;
                    uiIndex = i * 16 + pModbusQuery->uwStartINFO +  j;
                    if(!sVariant.pUnit->isCommStateYX(uiIndex)) //不设置通信状态相关的遥信
                    {
                        sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, uiIndex, COL_PREYX_YXVALUE), &uwYXValue);
                    }
                }
            }
        }
            break;
        case DATA_TYPE_UINT32:
        case DATA_TYPE_INT32:
        {
            quint32 uiTempYXValue = 0;
            quint16 uwYXValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint32);

            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uiTempYXValue, sVariant.pByReadBuffer + 3 + i * sizeof(quint32), sizeof(quint32));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uiTempYXValue = qByteOrderConvert(uiTempYXValue);

                }
                uiTempYXValue = qBigLittleEndianConvert(uiTempYXValue);
                for(quint32 j = 0; j < 32; ++j)
                {
                    uwYXValue = (uiTempYXValue >> j) & 0x01;
                    uiIndex = i * 32 + pModbusQuery->uwStartINFO +  j;
                    if(!sVariant.pUnit->isCommStateYX(uiIndex)) //不设置通信状态相关的遥信
                    {
                        sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, uiIndex, COL_PREYX_YXVALUE), &uwYXValue);
                    }
                }
            }
        }
            break;

        default:
            break;
        }
    }
    else
    {
        switch(sVariant.pPtlFlag->pPtlModbus->pModbusQueryYXVec[sVariant.pPtlFlag->byQueryYXNum -1]->byDataType)
        {
        case DATA_TYPE_UINT8:
        case DATA_TYPE_INT8:
        {
            quint16 uwYXValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount;

            for(quint32 i = 0; i < uiCount; ++i)
            {
                uwYXValue = sVariant.pByReadBuffer[3 + i];
                uiIndex = pModbusQuery->uwStartINFO + i;
                if(!sVariant.pUnit->isCommStateYX(uiIndex)) //不设置通信状态相关的遥信
                {
                    sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, uiIndex, COL_PREYX_YXVALUE), &uwYXValue);
                }
            }
        }
            break;
        case DATA_TYPE_UINT16:
        case DATA_TYPE_INT16:
        {
            quint16 uwYXValue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint16);

            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uwYXValue, sVariant.pByReadBuffer + 3 + i * sizeof(quint16), sizeof(quint16));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uwYXValue = qByteOrderConvert(uwYXValue);
                }
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, pModbusQuery->uwStartINFO + i, COL_PREYX_YXVALUE), &uwYXValue);
            }
        }
            break;
        case DATA_TYPE_UINT32:
        case DATA_TYPE_INT32:
        {
            quint32 uiYXvalue = 0;
            quint32 uiByteCount = sVariant.pByReadBuffer[2];
            quint32 uiCount = uiByteCount / sizeof(quint32);

            for(quint32 i = 0; i < uiCount; ++i)
            {
                memcpy(&uiYXvalue, sVariant.pByReadBuffer + 3 + i * sizeof(quint32), sizeof(quint32));
                if(MODBUS_BYTEORDER_TYPE_H_L == pModbusQuery->byByteOrder)
                {
                    uiYXvalue = qByteOrderConvert(uiYXvalue);
                }
                sVariant.pUnit->setValue(S_DataIndex(TABLE_PREYX, pModbusQuery->uwStartINFO + i, COL_PREYX_YXVALUE), &uiYXvalue);
            }
        }
            break;

        default:
            break;
        }
    }
}

---

参考文献：

• Modbus-3: Modbus TCP通信协议解析

• modbus tcp 协议详解