【C++】Modbus通讯

最新推荐文章于 2024-01-03 18:46:13 发布
最新推荐文章于 2024-01-03 18:46:13 发布
阅读量1.7w 收藏 68
点赞数 7
分类专栏： 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Taily_Duan/article/details/51736825
版权


MODBUS_SERVER.h

MODBUS_SERVER.cpp

MODBUS_SHARE.h

MODBUS_SHARE.cpp

PORT.h

PORT.cpp

两个VC++ Modbus通信例子源代码.rar


modbus 协议编程 C++

MODBUS_SERVER.h

//Download by http://www.NewXing.com
#if !defined(MSERVERH)
#define MSERVERH
 
#ifdef __cplusplus
extern "C"
{
#endif
    /*1.对单个PLC操作*/
    /*读一个或多个模拟量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
    char MODBUS_S_ReadMultiRegD(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, short int *list);    
    /*读一个或多个开关量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
    char MODBUS_S_ReadMultiRegM(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list);
    /*读一个或多个开关量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
    char MODBUS_S_ReadMultiRegM_1x(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list);
    /*写一个模拟量 参数：站号，写地址， 返回数据变量指针  返回：小于零失败，大于零表示成功*/
    char MODBUS_S_WriteSingRegD(unsigned char rtu, unsigned short int RegAdd, short int var);
    /*写一个模拟量 参数：站号，写地址， 返回数据变量指针  返回：小于零失败，大于零表示成功*/
    char MODBUS_S_WriteSingRegM(unsigned char rtu, unsigned short int RegAdd, bool var);
 
    /*2.对全部PLC操作*/
    char MODBUS_S_A_WriteSingRegD(unsigned short int RegAdd, bool var);
    char MODBUS_S_A_WriteSingRegM(unsigned short int RegAdd, short int var);
     
    /*3.端口操作*/
    char MODBUS_S_Init(unsigned long xPort, unsigned long xBabd, unsigned char xDataSize, 
                unsigned char xParity, unsigned char xStopBit);
    char MODBUS_S_UnInit();
     
#ifdef __cplusplus
}
#endif
 
 
#endif

MODBUS_SERVER.cpp 

#include "stdafx.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include "MODBUS_SHARE.h"
#include "MODBUS_SERVER.h"
#include "PORT.h"
//Download by http://www.NewXing.com
unsigned char buff[256];
 

/*1.对单个PLC操作*/
/*读一个或多个模拟量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
/*40000*/
char MODBUS_S_ReadMultiRegD(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, short int *list)
{
    unsigned short int crc16;
    unsigned short int crctmp;
    short int vartmp;
     
    memset(buff, 0x00, 255);
    buff[0]= rtu;
    buff[1]= 0x03;
    buff[2]= (unsigned char)((RegAdd-40001) >> 8);
    buff[3]= (unsigned char)(RegAdd-40001);
    buff[4]= (unsigned char)(RegCount >> 8);
    buff[5]= (unsigned char)RegCount;
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
     
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen==8)
        {
            //读数据
            memset(buff, 0x00, 255);
            Sleep(50);
            strlen= ReadChar(255, (char *)buff, 1000);
            if(strlen==0)
            {
                //无返回
                return(-2);             
            }
            else
            {
                //返回长度有效,解析接收缓冲区
                if(strlen== (3+(RegCount *2)+ 2) && buff[0]== rtu && buff[1]== 0x03)
                {
                    crc16= CalcCrcFast(buff, 3+(RegCount*2));
                    crctmp= buff[strlen-2];
                    crctmp= crctmp << 8 | buff[strlen-1];
                    if(crc16== crctmp )
                    {
                        for(int i=0; i< RegCount; i++)
                        {
                            vartmp= buff[3+(2*i)];
                            vartmp= vartmp << 8;
                            vartmp= vartmp | buff[3+((2*i)+1)];
                             
                            list[i]= vartmp;
                        }                               
                    }
                    else
                    {
                        return(-1);
                    }
                }
                else
                {
                    return(-1);
                }
            }
        }
        else
        {           
            return(-2);
        }       
    }
    else
    {
        return(-2);
    }
     
    return(1);
}
 
/*读一个或多个开关量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
/*00000*/
char MODBUS_S_ReadMultiRegM(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list)
{
    unsigned short int crc16;
    unsigned short int crctmp;
     
    memset(buff, 0x00, 255);
    buff[0]= rtu;
    buff[1]= 0x01;
    buff[2]= (unsigned char)(RegAdd >> 8);
    buff[3]= (unsigned char)RegAdd;
    buff[4]= (unsigned char)(RegCount >> 8);
    buff[5]= (unsigned char)RegCount;
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
     
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen==8)
        {
            //读数据
            memset(buff, 0x00, 255);
            Sleep(50);
            strlen= ReadChar(255, (char *)buff, 1000);
            if(strlen==0)
            {
                //无返回
                return(-2);             
            }
            else
            {
                //返回长度有效,解析接收缓冲区
                if(strlen== (3+((RegCount+7)/8)+ 2) && buff[0]== rtu && buff[1]== 0x01)
                {
                    crc16= CalcCrcFast(buff, 3+((RegCount +7)/8));
                    crctmp= buff[strlen-2];
                    crctmp= crctmp << 8 | buff[strlen-1];
                    if(crc16== crctmp )
                    {
                        unsigned char row=0, col=0;                     
                        for(int i=0; i<RegCount; i++)
                        {                       
                            row= i / 8;                         
                            col= i % 8;                         
                            list[i]= buff[3 + row] >> col & 0x01;
                        }                               
                    }
                    else
                    {
                        return(-1);
                    }
                }
                else
                {
                    return(-1);
                }
            }
        }
        else
        {           
            return(-2);
        }       
    }
    else
    {
        return(-2);
    }
     
    return(1);
}
 
/*读一个或多个开关量  参数：站号，开始地址， 读的数量， 返回数据变量指针  返回：－1表示CRC校验失败，－2表示无应答， 大于零表示接收数据成功*/
/*10000*/
char MODBUS_S_ReadMultiRegM_1x(unsigned char rtu, unsigned short int RegAdd, unsigned short int RegCount, bool *list)
{
    unsigned short int crc16;
    unsigned short int crctmp;
     
    memset(buff, 0x00, 255);
    buff[0]= rtu;
    buff[1]= 0x02;
    buff[2]= (unsigned char)((RegAdd-10001)>> 8);
    buff[3]= (unsigned char)(RegAdd-10001);
    buff[4]= (unsigned char)(RegCount >> 8);
    buff[5]= (unsigned char)RegCount;
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
     
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen==8)
        {
            //读数据
            memset(buff, 0x00, 255);
            Sleep(50);
            strlen= ReadChar(255, (char *)buff, 1000);
            if(strlen==0)
            {
                //无返回
                return(-2);             
            }
            else
            {
                //返回长度有效,解析接收缓冲区
                if(strlen== (3+((RegCount+7)/8)+ 2) && buff[0]== rtu && buff[1]== 0x02)
                {
                    crc16= CalcCrcFast(buff, 3+((RegCount +7)/8));
                    crctmp= buff[strlen-2];
                    crctmp= crctmp << 8 | buff[strlen-1];
                    if(crc16== crctmp )
                    {
                        unsigned char row=0, col=0;                     
                        for(int i=0; i<RegCount; i++)
                        {                       
                            row= i / 8;                         
                            col= i % 8;                         
                            list[i]= buff[3 + row] >> col & 0x01;
                        }                               
                    }
                    else
                    {
                        return(-1);
                    }
                }
                else
                {
                    return(-1);
                }
            }
        }
        else
        {           
            return(-2);
        }       
    }
    else
    {
        return(-2);
    }
     
    return(1);
}
 
/*写一个模拟量 参数：站号，写地址， 返回数据变量指针  返回：小于零失败，大于零表示成功*/
/*40000*/
char MODBUS_S_WriteSingRegD(unsigned char rtu, unsigned short int RegAdd, short int var)
{
    unsigned short int crc16;
     
    memset(buff, 0x00, 255);
    buff[0]= rtu;
    buff[1]= 0x06;
    buff[2]= (unsigned char)((RegAdd-40001) >> 8);
    buff[3]= (unsigned char)(RegAdd-40001);
    buff[4]= (unsigned char)(var >> 8);
    buff[5]= (unsigned char)var;
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
 
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen==8)
        {
            Sleep(50);
            strlen= ReadChar(255, (char *)buff, 1000);
            //返回长度有效,解析接收缓冲区
            if(!(strlen== 8 && buff[0]== rtu && buff[1]== 0x06))
            {
                return(-1);
            }
        }
        else
        {           
            return(-1);
        }       
    }
    else
    {
        return(-1);
    }
     
    return(1);      
}
 
/*写一个模拟量 参数：站号，写地址， 返回数据变量指针  返回：小于零失败，大于零表示成功*/
char MODBUS_S_WriteSingRegM(unsigned char rtu, unsigned short int RegAdd, bool var)
{
    unsigned short int crc16;
     
    memset(buff, 0x00, 255);
    buff[0]= rtu;
    buff[1]= 0x05;
    buff[2]= (unsigned char)(RegAdd >> 8);
    buff[3]= (unsigned char)RegAdd;
    if(var)
    {
        buff[4]= 0xff;
        buff[5]= 0x00;
    }
    else
    {
        buff[4]= 0x00;
        buff[5]= 0x00;
    }
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
     
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        Sleep(50);
        strlen= WriteChar(8, (char *)buff);
        if(strlen==8)
        {
            Sleep(50);
            strlen= ReadChar(255, (char *)buff, 1000);
            //返回长度有效,解析接收缓冲区
            if(!(strlen== 8 && buff[0]== rtu && buff[1]== 0x05))
            {
                return(-1);
            }
        }
        else
        {           
            return(-1);
        }       
    }
    else
    {
        return(-1);
    }
     
    return(1);  
}
 
//
/*2.对全部PLC操作*/
char MODBUS_S_A_WriteSingRegD(unsigned short int RegAdd, short int var)
{
    unsigned short int crc16;
     
    memset(buff, 0x00, 255);
    buff[0]= 0xff;
    buff[1]= 0x06;
    buff[2]= (unsigned char)((RegAdd -40001) >> 8);
    buff[3]= (unsigned char)(RegAdd -40001);
    buff[4]= (unsigned char)(var >> 8);
    buff[5]= (unsigned char)var;
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
 
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen!=8)
        {           
            return(-1);
        }       
    }
    else
    {
        return(-1);
    }
     
    return(1);  
}
 
char MODBUS_S_A_WriteSingRegM(unsigned short int RegAdd, bool var)
{
    unsigned short int crc16;
     
    memset(buff, 0x00, 255);
    buff[0]= 0xff;
    buff[1]= 0x05;
    buff[2]= (unsigned char)(RegAdd >> 8);
    buff[3]= (unsigned char)RegAdd;
    if(var)
    {
        buff[4]= 0xff;
        buff[5]= 0x00;
    }
    else
    {
        buff[4]= 0x00;
        buff[5]= 0x00;
    }
    crc16= CalcCrcFast(buff, 6);
    buff[6]= (unsigned char)(crc16 >> 8);
    buff[7]= (unsigned char)crc16;
     
    //发送数据
    unsigned long strlen;
    if(IsOpen())
    {
        //发送数据
        strlen= WriteChar(8, (char *)buff);
        if(strlen!=8)
        {           
            return(-1);
        }       
    }
    else
    {
        return(-1);
    }
     
    return(1);  
}
 

char MODBUS_S_Init(unsigned long xPort, unsigned long xBabd, unsigned char xDataSize, 
                unsigned char xParity, unsigned char xStopBit)
{
    /*
    Parity :
    EVENPARITY Even 
    MARKPARITY Mark 
    NOPARITY No parity 
    ODDPARITY Odd 
    SPACEPARITY Space 
    */ 
    /*BaudRate:
    CBR_110
    CBR_19200
    CBR_300
    CBR_38400
    CBR_600
    CBR_56000
    CBR_1200
    CBR_57600
    CBR_2400
    CBR_115200
    CBR_4800
    CBR_128000
    CBR_9600
    CBR_256000
    CBR_14400   
    */
    /*
    ONESTOPBIT 1 stop bit 
    ONE5STOPBITS 1.5 stop bits 
    TWOSTOPBITS 
    */
 
    if(OpenPort(xPort,xBabd,xDataSize,xParity, xStopBit,4096,4096,1000))
    {
        return(1);
    }
    else
    {
        return(0);
    }
}
 
char MODBUS_S_UnInit()
{
    ClosePort();
    return(1);
}

MODBUS_SHARE.h 

//Download by http://www.NewXing.com
#if !defined(MSHAREH)
#define MSHAREH
 
#ifdef __cplusplus
extern "C"
{
    #endif
     
    unsigned short CalcCrcFast(unsigned char*puchMsg,unsigned short usDataLen);
     
    #ifdef __cplusplus
}
#endif
 
#endif

MODBUS_SHARE.cpp 

#include "stdafx.h"
#include "MODBUS_SHARE.h"
//Download by http://www.NewXing.com
const unsigned char m_auchCRCHi[]=
{
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
    0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,
    0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,
    0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,
    0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,
    0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,
    0x81,0x40,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,
    0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,
    0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
    0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
    0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,
    0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,
    0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
    0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,
    0x80,0x41,0x00,0xC1,0x81,0x40 
}
;
 
const unsigned char m_auchCRCLo[]=
{
    0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,
    0x07,0xC7,0x05,0xC5,0xC4,0x04,0xCC,0x0C,0x0D,0xCD,
    0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,
    0x08,0xC8,0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,
    0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,0x14,0xD4,
    0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,
    0x11,0xD1,0xD0,0x10,0xF0,0x30,0x31,0xF1,0x33,0xF3,
    0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
    0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,
    0x3B,0xFB,0x39,0xF9,0xF8,0x38,0x28,0xE8,0xE9,0x29,
    0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,
    0xEC,0x2C,0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,
    0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,0xA0,0x60,
    0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,
    0xA5,0x65,0x64,0xA4,0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,
    0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
    0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,
    0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,0xB4,0x74,0x75,0xB5,
    0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,
    0x70,0xB0,0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,
    0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,0x9C,0x5C,
    0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,
    0x99,0x59,0x58,0x98,0x88,0x48,0x49,0x89,0x4B,0x8B,
    0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
    0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,
    0x43,0x83,0x41,0x81,0x80,0x40 
}
;
 
unsigned short CalcCrcFast(unsigned char*puchMsg,unsigned short usDataLen)
{
    unsigned char uchCRCHi=0xFF ;
    unsigned char uchCRCLo=0xFF ;
    unsigned short uIndex ;
     
    while(usDataLen--)
    {
        uIndex=uchCRCHi^*puchMsg++;
        uchCRCHi=uchCRCLo^m_auchCRCHi[uIndex];
        uchCRCLo=m_auchCRCLo[uIndex];
    }
    return(uchCRCHi<<8|uchCRCLo);
}

PORT.h 

//Download by http://www.NewXing.com
#if !defined(MPORT)
#define MPORT
 
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    inline bool IsOpen();
    bool OpenPort(unsigned long xPort, unsigned long xBabd, unsigned char xDataSize, 
                unsigned char xParity, unsigned char xStopBit, unsigned long InputBuffSize, 
                unsigned long OutputBuffSize, unsigned long dwTimerOut);
    void ClosePort();
    void ClearBuffer();
    unsigned long ReadChar(unsigned long dwBufferLength, char *buff, unsigned long dwWaitTime);
    unsigned long WriteChar(unsigned long dwBufferLength, char *buff);
     
#ifdef __cplusplus
}
#endif
 
#endif

PORT.cpp 

//Download by http://www.NewXing.com
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "PORT.h"
 
//
DCB dcb;
COMMTIMEOUTS CommTimerOuts;
HANDLE hCom= INVALID_HANDLE_VALUE;
 
OVERLAPPED m_overlappedRead;
OVERLAPPED m_overlappedWrite;
 
//
//通讯端口是否打开
inline bool IsOpen()
{
    return hCom != INVALID_HANDLE_VALUE;
} 
 
//设置超时
void SetTimerOut(unsigned long dwTimerOut= 5000)
{
    if(!IsOpen())  
    {
        return;   
    }
     
    CommTimerOuts.ReadIntervalTimeout= MAXDWORD;
    CommTimerOuts.ReadTotalTimeoutConstant= 0;
    CommTimerOuts.ReadTotalTimeoutMultiplier= 0;
    CommTimerOuts.WriteTotalTimeoutConstant= dwTimerOut;
    CommTimerOuts.WriteTotalTimeoutMultiplier= 0;
 
    SetCommTimeouts(hCom, &CommTimerOuts);
}
 
//设置DCB参数
bool SetDCBParm(unsigned long xBabd, unsigned char xDataSize, 
                unsigned char xParity, unsigned char xStopBit)
{
    if(!IsOpen())  
    {
        return false;   
    }
     
    if (!GetCommState(hCom, &dcb)) 
    {
        #ifdef _DEBUG
            printf ("错误: %d << 等到通讯口参数失败.\n", GetLastError());
        #endif
         
        ClosePort();
        return (false);
    }   
    //设置通讯参数    
    dcb.DCBlength= sizeof(DCB); 
    dcb.BaudRate = xBabd;     // set the baud rate
    dcb.ByteSize = xDataSize; // data size, xmit, and rcv
    dcb.Parity =   xParity;   // no parity bit
    dcb.StopBits = xStopBit;  // one stop bit   
    if (!SetCommState(hCom, &dcb)) 
    {
        #ifdef _DEBUG
            printf ("错误: %d << 设置通讯端口参数失败.\n", GetLastError());
        #endif
        ClosePort();
        return (false);
    }   
 
    return true;
}
 
//设置端口缓冲区大小
bool SetPortBuffSize(unsigned long InputBuffSize, unsigned long OutputBuffSize)
{
    if(!IsOpen())  
    {
        return false;   
    } 
     
    if(!SetupComm(hCom, InputBuffSize, OutputBuffSize))
    {
        #ifdef _DEBUG
            printf ("错误: %d << 设置通讯端口缓冲失败.\n", GetLastError());
        #endif
        ClosePort();
        return (false);
    }   
 
    return true;
}
 
//清理所有缓冲区
void ClearBuffer()
{
    if(!IsOpen())  
    {
        return;   
    }
 
    PurgeComm(hCom, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
}
 
//当前接收缓冲区字节数目; 
unsigned long GetInBuffCount()
{
    if(!IsOpen())  
    {
    return(0);   
    }
 
    DWORD     dwErrorFalgs;
    COMSTAT   Comstat;
 
    ClearCommError(hCom, &dwErrorFalgs, &Comstat);
    return Comstat.cbInQue;
}
 
//当前发送缓冲区字节数目; 
unsigned long GetOutBuffCount()
{
    if(!IsOpen())  
    {
        return false;   
    }
 
    DWORD     dwErrorFalgs;
    COMSTAT   Comstat;
 
    ClearCommError(hCom, &dwErrorFalgs, &Comstat);
    return Comstat.cbOutQue;
}
 
///打开串口 
bool OpenPort(unsigned long xPort, unsigned long xBabd, unsigned char xDataSize, 
                unsigned char xParity, unsigned char xStopBit, unsigned long InputBuffSize,
                unsigned long OutputBuffSize, unsigned long dwTimerOut)
{   
    if(IsOpen())
    {
        ClosePort();
    }   
    //设置事件 
    memset(&m_overlappedRead,0,sizeof(OVERLAPPED));
    m_overlappedRead.hEvent= CreateEvent(NULL,FALSE,TRUE,"portread");
    ASSERT(m_overlappedRead.hEvent != INVALID_HANDLE_VALUE);
 
    memset(&m_overlappedWrite,0,sizeof(OVERLAPPED));   
    m_overlappedWrite.hEvent= CreateEvent(NULL,FALSE,TRUE,"portwrite");  
    ASSERT(m_overlappedWrite.hEvent != INVALID_HANDLE_VALUE);
    //取得串口字符
    char com_str[255];
    strcpy(com_str, "COM");
    ltoa(xPort, com_str + 3, 10);
    //打开通讯端口 
    hCom = CreateFile(com_str,
                    GENERIC_READ | GENERIC_WRITE,
                    0,    
                    NULL, 
                    OPEN_EXISTING, 
                    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,    
                    NULL  
                    );
    if (hCom == INVALID_HANDLE_VALUE) 
    {
        #ifdef _DEBUG
            printf ("错误: %d << 打开通讯口失败,请检查是否已经安装串口设备.\n", GetLastError());
        #endif
        return (false);
    }     
    SetPortBuffSize(InputBuffSize,OutputBuffSize);
    SetDCBParm(xBabd,xDataSize,xParity,xStopBit);   
    SetTimerOut(dwTimerOut);    
    //清理缓冲器
    PurgeComm(hCom, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
    //启动成功
    #ifdef _DEBUG
        printf ("成功开启端口 %d.\n", com_str);
    #endif
    return(true);
}
 
//关闭串口;
void ClosePort()
{
    if(IsOpen())
    {
        CloseHandle(hCom);      
        hCom= INVALID_HANDLE_VALUE;
    }    
     
    //ResetEvent(m_overlappedRead.hEvent);
    //ResetEvent(m_overlappedWrite.hEvent); 
 
    if(m_overlappedRead.hEvent!=NULL) 
    {
        CloseHandle(m_overlappedRead.hEvent);        
    }
    if(m_overlappedWrite.hEvent!=NULL) 
    {
        CloseHandle(m_overlappedWrite.hEvent);        
    }   
}
 
//异步读数据
unsigned long ReadChar(unsigned long dwBufferLength, char *buff, unsigned long dwWaitTime=20)
{   
    if(!IsOpen())  
    {
        return(0);   
    }
     
    DWORD       dwError;
    COMSTAT     Stat;  
    if(::ClearCommError(hCom, &dwError, &Stat) && dwError > 0)   //清除错误
    {
        ::PurgeComm(hCom, PURGE_RXABORT | PURGE_RXCLEAR); /*清除输入缓冲区*/
        return 0;
    }
    if(!Stat.cbInQue)// 缓冲区无数据
    {
        return 0;
    }
 
    unsigned long uReadLength = 0;
    dwBufferLength = dwBufferLength - 1 > Stat.cbInQue ? Stat.cbInQue : dwBufferLength - 1;
    if(!::ReadFile(hCom, buff, dwBufferLength, &uReadLength, &m_overlappedRead)) //2000 下 ReadFile 始终返回 True
    {
        if(::GetLastError() == ERROR_IO_PENDING) // 结束异步I/O
        {
            WaitForSingleObject(m_overlappedRead.hEvent, dwWaitTime);   //等待20ms
            if(!::GetOverlappedResult(hCom, &m_overlappedRead, &uReadLength, false))
            {
                if(::GetLastError() != ERROR_IO_INCOMPLETE)//其他错误
                {
                    uReadLength = 0;
                }
            }
        }
        else
        {
            uReadLength = 0;
        }
    }
         
    return uReadLength;
}
 
//异步写数据 
unsigned long WriteChar(unsigned long dwBufferLength, char *buff)
{
    if(!IsOpen())
    {
        return 0;
    }
 
    DWORD dwError;
    if(ClearCommError(hCom, &dwError, NULL) && dwError > 0)  //清除错误
    {
        PurgeComm(hCom, PURGE_TXABORT | PURGE_TXCLEAR); 
    }
 
    unsigned long uWriteLength = 0;
    if(!WriteFile(hCom, buff, dwBufferLength, &uWriteLength, &m_overlappedWrite))
    {
        if(GetLastError() == ERROR_IO_PENDING)
        {
            DWORD m_tmp=0;
            m_tmp= WaitForSingleObject(m_overlappedWrite.hEvent, 1000);
            if(m_tmp== WAIT_TIMEOUT || m_tmp== WAIT_ABANDONED)
            {
                return(0);
            }
            else if(m_tmp== WAIT_OBJECT_0)
            {           
                if(!GetOverlappedResult(hCom,&m_overlappedWrite,&uWriteLength,false))
                {
                    return(0);      
                }
                else
                {
                    return uWriteLength;        
                }
            }
             
            uWriteLength = 0;
        }
    }
 
    return uWriteLength;  
}




Taily老段
关注
  • 7
    点赞
  • 踩
  • 68
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于C++实现Modbus TCP通信的详细指南
m0_57781768的博客
06-16 1376
Modbus协议是一种主从通信协议，最早由Modicon公司（现在是施耐德电气的一部分）在1979年开发。它被设计用于在控制器和设备之间传输数据。Modbus协议分为多种变体，其中Modbus TCP是使用最广泛的一种，它通过TCP/IP网络进行数据传输。本文详细介绍了如何在C++中实现Modbus TCP通信。从基础概念到具体实现，包括创建TCP客户端和服务器，构建和解析Modbus帧，处理并发请求和常见问题的解决方案。
c/c++,modbus通讯库
07-08
C/C++是两种常见的编程语言，它们可以用来开发Modbus通信库，以实现对Modbus协议的支持。本文将详细讲解Modbus协议、C/C++编程语言在Modbus通信中的应用，以及libmodbus这个特定的库。 首先，了解Modbus协议。...
modbus 协议编程 C++
热门推荐
wu_jing_sheng0的专栏
05-13 1万+
<br />MODBUS通讯协议及编程<br />　　ModBus通讯协议分为RTU协议和ASCII协议，我公司的多种仪表都采用ModBus RTU通讯协议，如：CH2000智能电力监测仪、CH2000M电力参数采集模块、巡检表、数显表、光柱数显表等。下面就ModBus RTU协议简要介绍如下：<br />一、通讯协议<br />（一）、通讯传送方式 ：<br /> 　　 通讯传送分为独立的信息头，和发送的编码数据。以下的通讯传送方式定义也与MODBUS
C++vs2013 + Modbus通讯协议 实现与PLC通讯
Adoranya的博客
12-02 1776
C++vs2013 + Modbus通讯协议 实现与PLC通讯
Modbus
tering的专栏
05-20 422
在主函数中，我们可以根据需要设置流量计的地址、要写入的寄存器地址和要设置的新值，然后调用sendModbusRTUCommand函数来写入数据。cout << "流量计读数：瞬时流量=" << flow_rate << " m3/h，总流量=" << total_flow << " m3" << endl;
Qt 上位机串口编程 Modbus编程
10-07
      Qt是由Qt Company开发的主流跨平台C++图形用户界面应用程序开发框架。  Qt是面向对象的框架,容易扩展，并且允许真正地组件编程，既可以开发GUI程序，也可用于控制台工具和服务器。     串口（Serial Port），也称串行通讯接口（通常指COM口）， 串口通信是指将数据一个比特一个比特地逐位进行传输的通信模式。其特点是通信线路简单，传送速度较慢。Qt串口通信是借助一个QSerialPort的对象来方便的对串口进行读写。   Modbus是一种串行通信协议，是施耐德电气发表工业标准协议。Qt Modbus通讯 采用QModbusRtuSerialMaster 、QModbusRtuSerialSlave等类来实现Modbus通讯相关的功能    本课程主要帮助学员熟练掌握 Qt 5框架串口编程，Modbus协议编程，并且通过两个实战工具项目，为学习Qt 上位机编程 串口、Modbus编程打下坚固的基础！ 
C++上位软件通过LibModbus开源库和西门子S7-1200/S7-1500/S7-200 PLC进行ModbusTcp 和ModbusRTU 通信
lzc881012的博客
01-03 4120
C++上位软件通过LibModbus开源库和西门子S7-1200/S7-1500/S7-200 PLC进行ModbusTcp 和ModbusRTU 通信。
C++ ModBUS TCP客户端工具 qModMaster 介绍及使用
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
08-08 7543
QModMaster是一个基于Qt的Modbus主站（Master）模拟器，用于模拟和测试Modbus TCP和RTU通信。它提供了一个直观的图形界面，使用户能够轻松设置和发送Modbus请求，并查看和分析响应数据。
ModBus协议原理、Modbus Slave以及基于C++和Qt的代码实现
认真努力，做一只会飞的毛毛虫。
07-23 1894
包含有：0x01 读继电器/线圈、0x05 写继电器/线圈、0x0F 写多个继电器/线圈、0x02 读离散量输入、0x04 读输入寄存器、0x03 读保持寄存器数据、0x06 写单个保持寄存器、0x10 写多个保持寄存器。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的起始地址+两个字节的读取个数。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的地址+两个字节的读取个数。事务处理标识+协议标识符+长度+设备地址+功能码+两个字节的地址+两个字节的读取个数。读取保持寄存器的帧结构，
【Linux/C++:modebus通信示例】（带初习配置概括）
CROWPSYCHO的博客
04-15 2571
Linux unbunt环境，C++，写modebus通信示例（主RTU，简提TCP），包含modbus slave，虚拟串口，串口调试工具，等等的初始配置。
C++ Modbus Tcp 通讯程序
11-17
**C++ Modbus TCP通信程序详解** 在工业自动化领域，Modbus协议因其简单性和广泛支持而被广泛应用。本文将深入探讨一个基于C++实现的Modbus TCP通信程序，该程序设计用于多线程后台批量读取寄存器状态，以解决接口...
vs2022 x86 C++ Modbus RTU通信
最新发布
01-06
实现了Modbus RTU通信，发送格式例子：01 03 00 00 00 01后，自动生成CRC校验，并传输，并能接收消息
QT/C++ modbuse 通讯库，批量读写，不阻塞
05-17
1、QT/C++ modbuse 通讯库； 2、批量读写，不阻塞 3、后台线程批量读写
Modbus RTU
05-03
对于自动化系统集成的工程师，该代码实用性较强，用于实现工控机与PLC等的通信。
ModbusTCP连接C++源码
04-26
《ModbusTCP连接C++源码详解》 在工业自动化领域，Modbus协议因其简单、易用的特点，被广泛应用于设备间的通信。本篇将详细解析一个基于C++的MFC（Microsoft Foundation Classes）实现的ModbusTCP连接代码，帮助...
C++基于开源Modbus Tcp 通讯应用客户端（稳定高效，多线程后台状态读取，不卡顿）
u013083044的博客
11-17 4913
使用多线程后台批量刷寄存器的状态，在某种程度上保证了上层接口读取的时候，不会卡顿，整体应用效果比较友好。程序应用简单稳定高效，是一个比较不错的尝试。
Modbus Master 控制传感器与从机: 用C++实现与详细解读
m0_57781768的博客
09-24 1659
在我们的场景中，主设备将用C++编写，用于控制和获取传感器或从机的数据。在这里，我们将使用libmodbus，它是一个开源的Modbus库，支持多种操作系统。通过C++和libmodbus库，我们可以轻松地创建一个Modbus主设备来控制和监视从设备，从而为现代工业应用提供强大的通信能力。与单个Modbus从设备的通信相比，与多个从设备的交互会有一些复杂性。每个从设备都有一个唯一的地址，这使得主设备可以区分不同的设备。当我们与多个从设备交互或需要快速响应时，有几个方法可以优化我们的Modbus主设备。
c++ modbusTCP
weixin_39926429的博客
06-09 4130
/Modbus TCP是一种基于TCP/IP协议的Modbus协议，它允许Modbus协议通过以太网进行通信。//在C++中，可以使用第三方库来实现Modbus TCP通信，例如libmodbus和QModbus。// 断开Modbus连接并释放上下文。// 创建Modbus TCP上下文。// 创建Modbus TCP客户端。// 连接到Modbus从设备。// 连接到Modbus从设备。// 读取Modbus寄存器。// 读取Modbus寄存器。// 打印读取到的寄存器值。
c++编写modbusTCP/ip协议远程读写服务器
matewang的博客
12-28 823
自己根据网络编程知识模拟客户端多线程远程读写modbus slave
c++采用modbus通讯
05-14
Modbus是一种常见的通讯协议，适用于工业现场、自动化控制、能源管理等领域。采用Modbus通讯的最主要特点是简单易用、可靠性高、应用领域广泛。 Modbus通讯涉及主站和从站两个角色。主站是控制设备的中心节点，可以查询或写入从站的数据。从站是被控制设备，回应主站的控制信号，或提供数据给主站。 由于Modbus通讯具有简单易用的特点，因此其在智能家居、智能楼群、新能源设备等领域中的应用日益广泛，成为许多控制系统中的重要组成部分。 如果您正在寻找一种成本低廉、实现简单的通讯方案，那么Modbus通讯可能是一个不错的选择。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值