通信缓冲数据ModBusRTU

已于 2022-12-04 08:59:51 修改
阅读量754 收藏 1
点赞数
分类专栏： 立体仓库 PLC 文章标签： ModBusRTU
于 2022-12-04 01:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdpcxq/article/details/128166907
版权

#include "ModBusRTU.h"


//通信缓冲数据
ModBusRTU_CommInfoType    g_datModBusRTUSendInfo,g_datModBusRTUReciveInfo;


uint8_t        g_arrayModBusRTUBuffer[MODBUSRTU_BUFLEN*2];                               /* 数据缓冲区 ,此数据缓冲区长度可根据单片机资源适当调大,以提高通讯速度*/
uint8_t        *g_pModBusRTUBuffer = g_arrayModBusRTUBuffer;
uint8_t        *g_pModBusRTUBufferHead = g_arrayModBusRTUBuffer;
uint8_t        *g_pModBusRTUBufferTail = &g_arrayModBusRTUBuffer[MODBUSRTU_BUFLEN];        //指向数组的末尾
uint8_t        g_ModBusRTURecv_Flag = 0;
uint16_t    g_ModBusRTURecv_Length = 0;


//网络接受缓冲器
uint8_t        g_arrayModBusRTURecBuf[MODBUSRTU_BUFLEN] = {0};

//应答数据缓存
uint8_t g_arrayModBusRTUTxBuf[MODBUSRTU_BUFLEN];
uint16_t g_ModBusRTUTxLen;
void (*g_pFunModBusRTUSendDat)(uint8_t *pDat,uint16_t len);

static void IOA_ModBusRTUDataBackup(uint8_t *pDat,uint16_t len);

uint16_t crc16(uint8_t *ptr, uint8_t len)
{
    uint16_t crc=0xFFFF;
    uint8_t i;
    while(len--)
    {
        crc ^=*ptr++;
        for(i=0;i<8;i++)
        {
            if(crc & 0x01)
            {
                crc>>=1; crc^=0xA001;
            }
            else
            {
                crc>>=1;
            }
        }
    }
    return crc;
}


static void IOA_ModBusRTUDataBackup(uint8_t *pDat,uint16_t len)
{
    uint16_t surLen;
    if(len > 0 && len <= MODBUSRTU_BUFLEN)
    {
        if((g_ModBusRTURecv_Length + len) <= MODBUSRTU_BUFLEN)  // 如果如果接收完该数据还未到缓冲区的末尾，即缓冲区剩余空间能够存储下该帧数据
        {
            surLen = (uint16_t)(g_pModBusRTUBufferTail - g_pModBusRTUBufferHead);   // 计算缓冲区中剩余的数据空间，地址数相减
            if(len > surLen)  // 如果剩余的数据空间不够存储长度为LEN的数据
            {
                if(surLen > 0)
                {
                    memcpy(g_pModBusRTUBufferHead,pDat,surLen);
                    g_ModBusRTURecv_Length += surLen;
                }
                g_pModBusRTUBufferHead = g_arrayModBusRTUBuffer;                 // 帧头移到缓冲区开头
                len = len - surLen;                                        // 计算剩余未读数据的长度
                memcpy(g_pModBusRTUBufferHead,&(pDat[surLen]),len);
                g_ModBusRTURecv_Length += len;  // 接收缓冲区的数据长度 = 刚接收的数据长度
            }
            else  // 如果剩余的数据空间够存储长度为LEN的数据，则将数据存储head处
            {
                memcpy(g_pModBusRTUBufferHead,pDat,len);
                g_ModBusRTURecv_Length += len;
            }    
        }
        else        //如果接收数据的长度大于缓冲区的长度，则丢弃缓冲区
        {
            g_pModBusRTUBufferHead = g_arrayModBusRTUBuffer;   // g_pSocketBufferHead指针指向缓冲区的开头
            g_pModBusRTUBuffer = g_pModBusRTUBufferHead;       // g_pSocketBuffer指针也指向缓冲区的开头
            
            memcpy(g_pModBusRTUBufferHead,pDat,len);
            g_ModBusRTURecv_Length = len;
        }
        g_pModBusRTUBufferHead += len;    
        if(g_pModBusRTUBufferHead > g_pModBusRTUBufferTail)                    //仅仅用于调试使用这个代码在工程中无效
        {
            int i = 1;
            i++;
        }
        g_ModBusRTURecv_Flag = 1;  // 接收完成后标志位置1
    }
}

void ModBusRTU_ask( void )
{
    uint8_t    serial_i = 0;
    uint8_t    remainderNumTemp = 0, remainderAddrTemp = 0;
    uint16_t divisorAddrTemp = 0;
    uint16_t ctcCheckTemp;
    g_arrayModBusRTUTxBuf[0] = g_ucModBus_ID;
    g_arrayModBusRTUTxBuf[1] = g_datModBusRTUReciveInfo.mode;
    switch(g_datModBusRTUReciveInfo.mode)
    {
        case MODBUSRTU_FUNC01:
        {
            g_arrayModBusRTUTxBuf[2] = g_datModBusRTUReciveInfo.regNum/8;
            remainderNumTemp = g_datModBusRTUReciveInfo.regNum%8;
            if(remainderNumTemp)
            {
                g_arrayModBusRTUTxBuf[2] += 1;
            }
            //先把数据清零
            for(serial_i = 0; serial_i < g_arrayModBusRTUTxBuf[2]; serial_i++)
            {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = 0;
            }
            //进行赋值操作
            for(serial_i = 0; serial_i < g_datModBusRTUReciveInfo.regNum; serial_i++)
            {
                divisorAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)/8;
                remainderAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)%8;
                if(g_bit0xDat[divisorAddrTemp] & (0x01<<remainderAddrTemp))
                {
                    g_arrayModBusRTUTxBuf[2 + g_arrayModBusRTUTxBuf[2] - serial_i/8] |= (0x01<<(serial_i%8));
                }
            }
            ctcCheckTemp = crc16(g_arrayModBusRTUTxBuf,3 + g_arrayModBusRTUTxBuf[2]);
            //注意，ModBusRTU CRC校验位低位在前。
            g_arrayModBusRTUTxBuf[3 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)ctcCheckTemp;
            g_arrayModBusRTUTxBuf[4 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)(ctcCheckTemp >> 8);
            g_ModBusRTUTxLen = 5 + g_arrayModBusRTUTxBuf[2];
            break;
        }
        case MODBUSRTU_FUNC02:
        {
            g_arrayModBusRTUTxBuf[2] = g_datModBusRTUReciveInfo.regNum/8;
            remainderNumTemp = g_datModBusRTUReciveInfo.regNum%8;
            if(remainderNumTemp)
            {
                g_arrayModBusRTUTxBuf[2] += 1;
            }
            //先把数据清零
            for(serial_i = 0; serial_i < g_arrayModBusRTUTxBuf[2]; serial_i++)
            {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = 0;
            }
            //进行赋值操作
            for(serial_i = 0; serial_i < g_datModBusRTUReciveInfo.regNum; serial_i++)
            {
                divisorAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)/8;
                remainderAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)%8;
                if(g_bit1xDat[divisorAddrTemp] & (0x01<<remainderAddrTemp))
                {
                    g_arrayModBusRTUTxBuf[2 + g_arrayModBusRTUTxBuf[2] - serial_i/8] |= (0x01<<(serial_i%8));
                }
            }
            
            ctcCheckTemp = crc16(g_arrayModBusRTUTxBuf,3 + g_arrayModBusRTUTxBuf[2]);
            //注意，ModBusRTU CRC校验位低位在前。
            g_arrayModBusRTUTxBuf[3 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)ctcCheckTemp;
            g_arrayModBusRTUTxBuf[4 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)(ctcCheckTemp >> 8);
            g_ModBusRTUTxLen = 5 + g_arrayModBusRTUTxBuf[2];
            break;
        }
        case MODBUSRTU_FUNC03:
        {
            g_arrayModBusRTUTxBuf[2] = g_datModBusRTUReciveInfo.regNum * 2;
            for(serial_i = 0; serial_i < g_arrayModBusRTUTxBuf[2]; serial_i++)
            {
                if(serial_i%2)
                {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = (uint8_t)g_word4xDat[g_datModBusRTUReciveInfo.regAddr + serial_i/2];
                }
                else
                {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = (uint8_t)(g_word4xDat[g_datModBusRTUReciveInfo.regAddr + serial_i/2] >> 8);
                }
            }
            ctcCheckTemp = crc16(g_arrayModBusRTUTxBuf,3 + g_arrayModBusRTUTxBuf[2]);
            g_arrayModBusRTUTxBuf[3 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)ctcCheckTemp;
            g_arrayModBusRTUTxBuf[4 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)(ctcCheckTemp >> 8);
            g_ModBusRTUTxLen = 5 + g_arrayModBusRTUTxBuf[2];
            break;
        }
        case MODBUSRTU_FUNC04:
        {
            g_arrayModBusRTUTxBuf[2] = g_datModBusRTUReciveInfo.regNum * 2;
            for(serial_i = 0; serial_i < g_arrayModBusRTUTxBuf[2]; serial_i++)
            {
                if(serial_i%2)
                {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = (uint8_t)g_word3xDat[g_datModBusRTUReciveInfo.regAddr + serial_i/2];
                }
                else
                {
                    g_arrayModBusRTUTxBuf[3 + serial_i] = (uint8_t)(g_word3xDat[g_datModBusRTUReciveInfo.regAddr + serial_i/2] >> 8);
                }
            }
            ctcCheckTemp = crc16(g_arrayModBusRTUTxBuf,3 + g_arrayModBusRTUTxBuf[2]);
            g_arrayModBusRTUTxBuf[3 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)ctcCheckTemp;
            g_arrayModBusRTUTxBuf[4 + g_arrayModBusRTUTxBuf[2]] = (uint8_t)(ctcCheckTemp >> 8);
            g_ModBusRTUTxLen = 5 + g_arrayModBusRTUTxBuf[2];
            break;
        }
        case MODBUSRTU_FUNC05:
        case MODBUSRTU_FUNC15:
        case MODBUSRTU_FUNC06:
        case MODBUSRTU_FUNC16:
        {
            g_arrayModBusRTUTxBuf[2] = (uint8_t)(g_datModBusRTUReciveInfo.regAddr >> 8);
            g_arrayModBusRTUTxBuf[3] = (uint8_t)(g_datModBusRTUReciveInfo.regAddr);
            g_arrayModBusRTUTxBuf[4] = (uint8_t)(g_datModBusRTUReciveInfo.regNum >> 8);
            g_arrayModBusRTUTxBuf[5] = (uint8_t)(g_datModBusRTUReciveInfo.regNum);
            ctcCheckTemp = crc16(g_arrayModBusRTUTxBuf,6);
            g_arrayModBusRTUTxBuf[6] = (uint8_t)ctcCheckTemp;
            g_arrayModBusRTUTxBuf[7] = (uint8_t)(ctcCheckTemp >> 8);
            g_ModBusRTUTxLen = 8;
            
            break;
        }
        default:
        {
            break;
        }
    }
    
    MODBUSRTU_SENDDATA(g_arrayModBusRTUTxBuf,g_ModBusRTUTxLen);
}


void ModBusRTU_UartHandle(uint8_t *pDat,uint16_t len)
{
    uint8_t    serial_i = 0;
    uint8_t    remainderNumTemp = 0;
    uint8_t    remainderAddrTemp = 0;
    uint16_t divisorAddrTemp = 0;
    uint16_t ctcCheckTemp = 0;
    uint16_t surLen = 0;
    uint8_t        datlessFlag = 0;
    uint8_t *pPosTemp = g_arrayModBusRTURecBuf;
    IOA_ModBusRTUDataBackup(pDat, len);
    if(g_ModBusRTURecv_Flag == 1)        //有网络数据没有处理
    {
        while(g_ModBusRTURecv_Length >= MODBUSRTU_LESSLEN)        //至少有12个数据包
        {
            surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
            if(surLen >= MODBUSRTU_LEN_HEAD)
            {
                memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, MODBUSRTU_LEN_HEAD);
            }
            else
            {
                memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LEN_HEAD - surLen);
            }
            pPosTemp = g_arrayModBusRTURecBuf;
            g_datModBusRTUReciveInfo.id = *((uint16_t *)pPosTemp);
            g_datModBusRTUReciveInfo.mode = *(pPosTemp + 1);
            g_datModBusRTUReciveInfo.regAddr = (((uint16_t)pPosTemp[2])<<8) + pPosTemp[3];
            g_datModBusRTUReciveInfo.regNum = (((uint16_t)pPosTemp[4])<<8) + pPosTemp[5];
            if(g_datModBusRTUReciveInfo.id == g_ucModBus_ID)
            {
                switch(g_datModBusRTUReciveInfo.mode)
                {
                    case MODBUSRTU_FUNC01:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_0XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            ((g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_0XLEN))
                        {
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;    
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC02:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_1XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            ((g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_1XLEN))
                        {
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;    
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC03:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_3XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum >= 1) && (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            ((g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_3XLEN))
                        {
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;    
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC04:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_4XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            (g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_4XLEN)
                        {
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;    
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC05:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_0XLEN))
                        {
                            divisorAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)/8;
                            remainderAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)%8;
                            if(g_datModBusRTUReciveInfo.regNum == 0x0000)
                            {
                                g_bit0xDat[divisorAddrTemp] &= (~(0x01<<remainderAddrTemp));
                            }
                            else if(g_datModBusRTUReciveInfo.regNum == 0xFF00)
                            {
                                g_bit0xDat[divisorAddrTemp] |= (0x01<<remainderAddrTemp);
                            }
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;    
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC15:
                    {
                        g_datModBusRTUReciveInfo.datLen = pPosTemp[6];
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - surLen);
                        }
                        //处理数据
                        remainderNumTemp = g_datModBusRTUReciveInfo.regNum%8;
                        if((g_ModBusRTURecv_Length >=  (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1)) &&
                            (((remainderNumTemp == 0) && (g_datModBusRTUReciveInfo.datLen == g_datModBusRTUReciveInfo.regNum/8)) ||
                            ((remainderNumTemp > 0) && (g_datModBusRTUReciveInfo.datLen == (g_datModBusRTUReciveInfo.regNum/8 + 1)))))
                        {
                            ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,(7 + g_datModBusRTUReciveInfo.datLen));
                            g_datModBusRTUReciveInfo.crcCheck = pPosTemp[7 + g_datModBusRTUReciveInfo.datLen] + (((uint16_t)pPosTemp[8 + g_datModBusRTUReciveInfo.datLen])<<8);
                            //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                            if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_0XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            ((g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_0XLEN))
                            {
                                g_datModBusRTUReciveInfo.pDat = &(pPosTemp[7]);
                                //进行赋值操作
                                for(serial_i = 0; serial_i < g_datModBusRTUReciveInfo.regNum; serial_i++)
                                {
                                    divisorAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)/8;
                                    remainderAddrTemp = (g_datModBusRTUReciveInfo.regAddr + serial_i)%8;
                                    if(g_datModBusRTUReciveInfo.pDat[g_datModBusRTUReciveInfo.datLen - serial_i/8] & (0x01<<(serial_i%8)))
                                    {
                                        g_bit0xDat[divisorAddrTemp] |= (0x01<<remainderAddrTemp);
                                    }
                                    else
                                    {
                                        g_bit0xDat[divisorAddrTemp] &= (~(0x01<<remainderAddrTemp));
                                    }
                                }
                                pPosTemp += (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                ModBusRTU_ask();
                                
                                //长度减小
                                if(surLen >= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                                {
                                    g_pModBusRTUBuffer += (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                }
                                else
                                {
                                    g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[(MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - surLen];
                                }
                                g_ModBusRTURecv_Length -= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                datlessFlag = 2;    
                            }
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC06:
                    {
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= MODBUSRTU_LESSLEN)
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], MODBUSRTU_LESSLEN - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, MODBUSRTU_LESSLEN - surLen);
                        }
                        //处理数据
                        ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,6);
                        g_datModBusRTUReciveInfo.crcCheck = pPosTemp[6] + (((uint16_t)pPosTemp[7])<<8);
                        //判断调节：crc16校验正确，地址没有越界，最长只能读取125个寄存器数据，数据内容没有越界
                        if((ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck) &&        
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_4XLEN))
                        {
                            g_word4xDat[g_datModBusRTUReciveInfo.regAddr] = g_datModBusRTUReciveInfo.regNum;
                            pPosTemp += MODBUSRTU_LESSLEN;
                            ModBusRTU_ask();
                            //长度减小
                            if(surLen >= MODBUSRTU_LESSLEN)
                            {
                                g_pModBusRTUBuffer += MODBUSRTU_LESSLEN;
                            }
                            else
                            {
                                g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[MODBUSRTU_LESSLEN - surLen];
                            }
                            g_ModBusRTURecv_Length -= MODBUSRTU_LESSLEN;
                            datlessFlag = 2;
                        }
                        break;
                    }
                    case MODBUSRTU_FUNC16:
                    {
                        g_datModBusRTUReciveInfo.datLen = pPosTemp[6];
                        //复制尾部数据
                        if(g_ModBusRTURecv_Length < (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                        {
                            datlessFlag = 1;
                            break;
                        }
                        surLen = g_pModBusRTUBufferTail - g_pModBusRTUBuffer;
                        if(surLen >= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                        {
                            memcpy(&g_arrayModBusRTURecBuf[MODBUSRTU_LEN_HEAD], &g_pModBusRTUBuffer[MODBUSRTU_LEN_HEAD], (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - MODBUSRTU_LEN_HEAD);        
                        }
                        else
                        {
                            memcpy(g_arrayModBusRTURecBuf, g_pModBusRTUBuffer, surLen);
                            memcpy(&g_arrayModBusRTURecBuf[surLen], g_arrayModBusRTUBuffer, (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - surLen);
                        }
                        //处理数据
                        if((g_ModBusRTURecv_Length >=  (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1)) &&
                            (g_datModBusRTUReciveInfo.datLen == (g_datModBusRTUReciveInfo.regNum * 2)) &&
                            (g_datModBusRTUReciveInfo.regAddr < MODBUS_4XLEN) &&
                            (g_datModBusRTUReciveInfo.regNum >= 1) && (g_datModBusRTUReciveInfo.regNum <= 125) &&
                            ((g_datModBusRTUReciveInfo.regAddr + g_datModBusRTUReciveInfo.regNum) <= MODBUS_4XLEN))
                        {
                            ctcCheckTemp = crc16(g_arrayModBusRTURecBuf,7 + g_datModBusRTUReciveInfo.datLen);
                            g_datModBusRTUReciveInfo.crcCheck = pPosTemp[7 + g_datModBusRTUReciveInfo.datLen] + (((uint16_t)pPosTemp[8 + g_datModBusRTUReciveInfo.datLen])<<8);
                            if(ctcCheckTemp == g_datModBusRTUReciveInfo.crcCheck)
                            {
                                for(serial_i = 0; serial_i < g_datModBusRTUReciveInfo.regNum; serial_i++)
                                {
                                    g_word4xDat[g_datModBusRTUReciveInfo.regAddr] = (((uint16_t)pPosTemp[7 + serial_i])<<8) + pPosTemp[8 + serial_i];
                                }
                                pPosTemp += (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                ModBusRTU_ask();
                                //长度减小
                                if(surLen >= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1))
                                {
                                    g_pModBusRTUBuffer += (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                }
                                else
                                {
                                    g_pModBusRTUBuffer = &g_arrayModBusRTUBuffer[(MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1) - surLen];
                                }
                                g_ModBusRTURecv_Length -= (MODBUSRTU_LESSLEN + g_datModBusRTUReciveInfo.datLen + 1);
                                datlessFlag = 2;
                            }
                        }
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
                //1：数据长度不够；2：处理完数据
                if(datlessFlag)
                {
                    datlessFlag = 0;
                    continue;
                }
            }
            //坐标后移
            g_pModBusRTUBuffer++;
            if(g_pModBusRTUBuffer > g_pModBusRTUBufferTail)
            {
                g_pModBusRTUBuffer = g_arrayModBusRTUBuffer;
            }
            g_ModBusRTURecv_Length--;
            if(g_ModBusRTURecv_Length < MODBUSRTU_LESSLEN)
            {
                g_ModBusRTURecv_Flag = 0;
                break;
            }
        }
    }
}

!chen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C# ModBus协议（RTU ）详细指南
qq_46104786的博客
10-27 1万+
Modbus协议广泛应用于工业自动化领域，可以用于控制器之间的通信、传感器的数据采集和PLC与HMI之间的通信等。由于其简单、可靠和易于实现等特点，Modbus协议仍然是工业界中最常用的通信协议之一。
Modbus-RTU状态机接收数据帧的方式(串口 or DMA)
armwind的专栏
05-21 3759
传统单片机一般具有串口外设，有一些还具有DMA。 针对没有DMA外设的单片机，只能使用方式1了，每个字节的串口数据都会产生串口中断。 而对于具有DMA的单片机，我们可以使用方式2，当接收到一帧后才会产生中断，这样就不会频繁打断主程序运行。 Modbus的一帧串口接收缓存最大为256个字节，所以接收到一帧数据，会产生256个串口中断。但串口中最好只做数据接收操作。不要有过多的耗时动作，不然会丢数据的，也影响主循环的实时性。 1. Modbus 数据帧接收方式1-串口中断 这种方式，在每次收到一个字节的数据
485 Modbus协议程序实例（DMA+缓存数据处理）
thornbird_echo的博客
03-15 1669
#define TX_MODE (GPIOB->ODR |= GPIO_Pin_8)| (GPIOC->ODR |= GPIO_Pin_14) #define RX_MODE (GPIOB->ODR &= ~GPIO_Pin_8)| (GPIOC->ODR |= GPIO_Pin_14) word_def UartStateAdr; #define FunctionReceiveFlag UartStateAdr.bit.b5//功能码.
关于通信数据的接收缓存
Vincent_winner的博客
04-10 1804
一般通信不管是用什么物理方式，如RS232、485、CAN、网口等，都是将数据首先定义成意义明确的帧，每帧数据大体上都包含帧头、命令字、长度域、有效数据域、校验域、结束符等这几个部分，收发双方都遵循一个固定的帧格式。发送比较简单，将数据打包组成完整帧之后，往外发送就行了，但接收方则相对麻烦一点，因为有些时候是一次读一个字节，有时候一次可以读很多字节，以何种方式来接收并组包比较好呢，相信有经验的工程...
关于Modbus协议使用的一点总结
江东风又起
08-10 3173
先介绍一下常用的0x03和0x10功能码，其他功能码同理： 协议原文如下： 0x03 0x10 汇总 协议实现细节见 https://blog.csdn.net/ysgjiangsu/article/details/81512310 这里调试， memcpy是按位拷贝的，当拷贝数据到内存时，注意大小端问题。比如 uint16 a = 0x3130; uint16 b ...
Modbus 协议基本原理
weixin_43866583的博客
07-13 5904
Modbus 是由 Modicon（现为施耐德电气公司的一个品牌）在 1979 年发明的，是全球第一个真正用于工业现场的总线协议。
STM32作从机实现简单的Modbus RTU协议
04-04
RTU（Remote Terminal Unit）是Modbus的一种传输模式，采用串行通信方式，数据格式简洁高效。在RTU模式下，数据以二进制形式连续发送，每个字符之间没有间隔，且每个消息都有校验和以确保数据传输的准确性。 **STM...
西门子S7-1200PLC与V20变频器进行MODBUS RTU通信步骤详解.docx
07-23
西门子S7-1200 PLC与V20变频器之间的MODBUS RTU通信是一种常见的工业自动化系统中的通信方式，它允许PLC控制变频器的运行状态，如速度、方向等。以下是对该通信过程的详细步骤解析： 1. **创建TIA项目并配置PLC**：...
S7-1200 MODBUS RTU
09-27
S7-1200 MODBUS RTU 通信主站设置和编程步骤 S7-1200 PLC 作为 Modbus RTU 主站可以实现与从站的通信，以下将详细介绍 S7-1200 作为 Modbus RTU 主站的设置和编程步骤。 硬件和软件需求 * 硬件：CPU1215C DC/DC/...
Modbus RTU
02-26
Modbus RTU是一种广泛应用于工业自动化领域的通信协议，它允许不同厂商的设备之间进行数据交换，尤其适用于远程终端单元（RTU）环境下的数据通信。本文将深入探讨如何使用Modbus RTU协议实现触摸屏与单片机之间的...
基于MemobusRTU通信协议的PLC数据优化组合传送方法
12-17
基于MemobusRTU通信协议的PLC数据优化组合传送方法基于MemobusRTU通信协议的PLC数据优化组合传送方法
手把手教VB 实现MODBUS RTU通讯
12-02
MODBUS RTU是一种基于ASCII或RTU（远程终端单元）数据帧格式的通信协议，适用于串行通信。RTU模式下，数据以二进制形式传输，没有ASCII的字符间隔，因此传输效率更高。协议规定了主站和从站之间的请求/响应机制，...
Modbus超时时间设置
热门推荐
sunxboy的专栏
11-16 1万+
很多同学在做Modbus通讯时，需要连续读取多个现场设备的数据，虽然也编写了Modbus轮询的程序，但是有时还是无法正常通讯。有时虽然能够保证通讯，但是所有现场设备的轮询周期很长。本文将从MBUS_CTRL的超时时间参数设置来说明超时时间设置的重要性。 Modbus通讯协议是单主多从的通讯协议，如果需要读取多个现场Modbus从站设备的数据时，很多PLC不支持对Modbus通讯功能块的自动排序...
台达PLC与C#上位机通过Modbus RTU实现实时数据读写通信
最新发布
jOZnOARku的博客
04-08 644
最后，我们可以根据具体的需求，对读取到的数据进行解析和分析，并将结果展示在上位机的用户界面上。其次，我们需要合理安排通信的时序和周期，避免过于频繁的读写操作对PLC和上位机的性能产生负面影响。通过使用C#编写的上位机程序，我们可以实现与PLC的通信、数据的读取和写入、以及数据的分析和展示等功能。在本文中，我们将使用C#编写一个简单的上位机程序，实现与台达PLC的Modbus RTU通信。综上所述，通过台达PLC与C#上位机之间的Modbus RTU通信，我们可以实现实时数据的读取和写入。
ardunio modbus rtu读写 esp8266 微信小程序数据传送
weixin_50618858的博客
12-12 217
【代码】ardunio modbus rtu读写 esp8266 微信小程序数据传送。
ESP32 modbus RTU程序。用arduino IDE开发的ESP32 modbus RTU slave程序_esp32 modbus 主站
2401_83817418的博客
04-04 819
你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！” />你的支持，我的动力；祝各位前程似锦，offer不断，步步高升！！！更多资料点击此处获qu！！
Modbus协议理解
ayout_five的博客
07-06 7213
Modbus 协议 报文理解 常用
MODBUS寄存器从40000开始而不从0开始，有什么特别的说法吗，还是仅仅是大家都习惯
学而不思则罔
05-25 1万+
（1）、 MODBUS 分为 0X ,1X,3X,4X 四种寄存器。 0X--->离散输出 （可读可写） 对应PLC为：DO 1X--->离散输入（只读） 对应PLC为：DI 3X--->输入寄存器16位（只读） 对应PLC为：AI 4X--->保持寄存器16位（可读可写） 对应PLC为：AO 同时根据上述规约，还可以扩展0X和4X,其中OX不仅可以对应DO，同时还可以对应上位机发送的“按钮” ...
modbusrtu中的大小端数据存储问题
09-13
在Modbus RTU中，数据存储的方式与大小端（Endian）无关。 Modbus RTU是一种串行通信协议，数据以字节为单位进行传输，不考虑字节顺序。 因此，无论是小端存储还是大端存储，数据在传输过程中都会被分解为字节，并且以相同的方式传输。 引用和引用中的代码片段提供了关于Modbus RTU通信缓冲区的定义。这些变量和缓冲区用于存储发送和接收到的数据。其中，g_arrayModBusRTUBuffer是一个字节数组，用于存储Modbus RTU通信的数据缓冲区。这个缓冲区在通信过程中会被动态地填充和读取。 引用中的代码片段则提供了另一个用于存储应答数据的缓冲区g_arrayModBusRTUTxBuf。这个缓冲区用于存储待发送的Modbus RTU数据。 综上所述，在Modbus RTU中，数据存储的问题主要是在设备的实际实现中考虑，而不是协议本身的规范。因此，大小端存储问题在Modbus RTU中并不是一个重要的考虑因素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

!chen

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

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

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

打赏作者

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

抵扣说明：

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

余额充值