CnComm 1.3

最新推荐文章于 2021-05-16 15:06:46 发布
最新推荐文章于 2021-05-16 15:06:46 发布
阅读量7k 收藏 9
点赞数
文章标签： null buffer asynchronous winapi user thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujian53/article/details/1794187
版权

/*
cnComm Serial Port Library(WIN32) free version 1.3
Compiled by： BC++ 5(free tool); C++ BUILDER 4, 5, 6, X; VC++ 5, 6, 7, 8;  GCC;
Writer: llbird
Mail  : wushaojian@21cn.com 
Blog  : http:///blog.csdn.net/wujian53
Copyright(c) 2004.5 - 2006.1

Update:
2007.9 :
    将 DWORD Read(LPVOID Buffer, DWORD dwBufferLength, DWORD dwWaitTime = 10)
    改成 DWORD Read(LPVOID Buffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    由于为了提高异步读的速度及成功率，通常只把读缓冲区的数据读出；
     对于处理字符串被分割的问题，可以参考我博克的案例。
*/

#ifndef _CN_COMM_H_
#define _CN_COMM_H_

#include <assert.h>
#include <stdio.h>
#include <windows.h>
#include <process.h>

///送到窗口的消息  WPARAM 端口号
#define ON_COM_RECEIVE WM_USER + 618   
#define ON_COM_CTS     WM_USER + 619 //>LPARAM 1 valid
#define ON_COM_DSR     WM_USER + 621 //>LPARAM 1 valid
#define ON_COM_RING    WM_USER + 623
#define ON_COM_RLSD    WM_USER + 624
#define ON_COM_BREAK   WM_USER + 625
#define ON_COM_TXEMPTY WM_USER + 626
#define ON_COM_ERROR   WM_USER + 627 //>LPARAM save Error ID
#define DEFAULT_COM_MASK_EVENT  EV_RXCHAR | EV_ERR | EV_CTS | EV_DSR | EV_BREAK | EV_TXEMPTY | EV_RING | EV_RLSD

class cnComm   
{
public:
   
    //------------------------------Construction-----------------------------------
    ///第1个参数为是否在打开串口时启动监视线程， 第2个参数为IO方式 阻塞方式（0）/ 异步重叠方式（默认）
    cnComm(bool fAutoBeginThread = true, DWORD dwIOMode = FILE_FLAG_OVERLAPPED)
        : _dwIOMode(dwIOMode), _fAutoBeginThread(fAutoBeginThread)
    {
        Init();
    }
   
    virtual ~cnComm()
    {
        Close();
        Destroy();
    }
   
    //----------------------------------Attributes----------------------------------
    ///判断串口是或打开
    inline bool IsOpen()
    {
        return _hCommHandle != INVALID_HANDLE_VALUE;
    }
    ///判断串口是或打开
    operator bool ()
    {
        return _hCommHandle != INVALID_HANDLE_VALUE;
    }
    ///获得串口句炳
    HANDLE GetHandle()
    {
        return _hCommHandle;
    }
    ///获得串口句炳
    operator HANDLE()
    {
        return _hCommHandle;
    }
    ///获得串口序号
    const int GetPortID()
    {
        return _dwPort;
    }
    ///获得串口全名
    const char *GetPortName()
    {
        return _szCommStr;
    }
    ///获得串口参数 DCB
    DCB *GetState()
    {
        return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) == TRUE ? &_DCB : NULL;
    }
    ///设置串口参数 DCB
    bool SetState(DCB *pdcb = NULL)
    {
        return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB : pdcb) == TRUE : false;
    }
    ///设置串口参数：波特率，停止位，等 支持设置字符串 "9600, n, 8, 1"
    bool SetState(char *szSetStr)
    {
        if(IsOpen())
        {
            if(::GetCommState(_hCommHandle, &_DCB) != TRUE)
                return false;
            if(::BuildCommDCB(szSetStr, &_DCB) != TRUE)
                return false;
            return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
        }
        return false;
    }
    ///设置串口参数：波特率，停止位，等
    bool SetState(DWORD dwBaudRate, DWORD dwByteSize = 8, DWORD dwParity = NOPARITY, DWORD dwStopBits = ONESTOPBIT)
    {
        if(IsOpen())
        {
            if(::GetCommState(_hCommHandle, &_DCB) != TRUE)
                return false;
            _DCB.BaudRate = dwBaudRate;
            _DCB.ByteSize = (unsigned char)dwByteSize;
            _DCB.Parity   = (unsigned char)dwParity;
            _DCB.StopBits = (unsigned char)dwStopBits;
            return ::SetCommState(_hCommHandle, &_DCB) == TRUE;
        }
        return false;
    }
    ///获得超时结构
    LPCOMMTIMEOUTS GetTimeouts(void)
    {
        return IsOpen() && ::GetCommTimeouts(_hCommHandle, &_CO) == TRUE  ? &_CO : NULL;
    }
    ///设置超时
    bool SetTimeouts(LPCOMMTIMEOUTS lpCO)
    {
        return IsOpen() ? ::SetCommTimeouts(_hCommHandle, lpCO) == TRUE : false;
    }
    ///设置串口的I/O缓冲区大小
    bool SetBufferSize(DWORD dwInputSize, DWORD dwOutputSize)
    {
        return IsOpen() ? ::SetupComm(_hCommHandle, dwInputSize, dwOutputSize) == TRUE : false;
    }
    ///清除接受缓冲区
    void ClearInputBuffer()
    {
        if(IsOpen())
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR );
    }
    ///清除发送缓冲区
    void ClearOutputBuffer()
    {
        if(IsOpen())
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR );
    }
    ///关联消息的窗口句柄
    inline void SetWnd(HWND hWnd)
    {
        assert(::IsWindow(hWnd));
        _hNotifyWnd = hWnd;
    }
    ///设定发送通知, 接受字符最小值
    inline void SetNotifyNum(DWORD dwNum)
    {
        _dwNotifyNum = dwNum;
    }
    ///线程是否运行
    inline bool IsThreadRunning()
    {
        return _hThreadHandle != NULL;
    }
    ///获得线程句柄
    inline HANDLE GetThread()
    {
        return _hThreadHandle;
    }
    ///设置要监视的事件， 打开前设置有效
    void SetMaskEvent(DWORD dwEvent = DEFAULT_COM_MASK_EVENT)
    {
        _dwMaskEvent = dwEvent;
    }
    ///获得读缓冲区的字符数
    int GetInputSize()
    {
        COMSTAT Stat;
        DWORD dwError;
       
        return ::ClearCommError(_hCommHandle, &dwError, &Stat) == TRUE  ? Stat.cbInQue : (DWORD)-1L;
    }
   
    //----------------------------------Operations----------------------------------
    ///打开串口 缺省 9600, n, 8, 1
    bool Open(DWORD dwPort)
    {
        return Open(dwPort, 9600);
    }
    ///打开串口 缺省 baud_rate, n, 8, 1
    bool Open(DWORD dwPort, DWORD dwBaudRate)
    {
        if(dwPort < 1 || dwPort > 1024)
            return false;
       
        BindCommPort(dwPort);
       
        if(!OpenCommPort())
            return false;
       
        if(!SetupPort())
            return false;
       
        return SetState(dwBaudRate);
    }
    ///打开串口, 使用类似"9600, n, 8, 1"的设置字符串设置串口
    bool Open(DWORD dwPort, char *szSetStr)
    {
        if(dwPort < 1 || dwPort > 1024)
            return false;
       
        BindCommPort(dwPort);
       
        if(!OpenCommPort())
            return false;
       
        if(!SetupPort())
            return false;
       
        return SetState(szSetStr);
    }
    ///读取串口 dwBufferLength个字符到 Buffer 返回实际读到的字符数  可读任意数据
    DWORD Read(LPVOID Buffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    {
        if(!IsOpen())
            return 0;
       
        COMSTAT  Stat;
        DWORD dwError;
       
        if(::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0)
        {
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);
            return 0;
        }
       
        if(bOnlyGetBuffer)
            dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue : dwBufferLength;

        unsigned long uReadLength = 0;
        if(!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, &_ReadOverlapped))
        {
            if(::GetLastError() == ERROR_IO_PENDING)
            {
                while(!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped, &uReadLength, TRUE))    
                {
                    if(::GetLastError() != ERROR_IO_INCOMPLETE)
                    {
                        ::ClearCommError(_hCommHandle, &dwError, &Stat);
                        break;
                    }
                }
            }
            else
                ::ClearCommError(_hCommHandle, &dwError, &Stat);
        }
       
        return uReadLength;
    }
   
    ///读取串口 dwBufferLength - 1 个字符到 szBuffer 返回ANSI C 模式字符串指针 适合一般字符通讯
    char * ReadString(char *szBuffer, DWORD dwBufferLength, bool bOnlyGetBuffer = true)
    {
        unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1, bOnlyGetBuffer);
        szBuffer[uReadLength] = '/0';
        return szBuffer;
    }
    ///写串口 可写任意数据 "abcd" or "x0x1x2"
    DWORD Write(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
       
        DWORD dwError;
       
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
       
        unsigned long uWriteLength = 0;
       
        if(!::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, &_WriteOverlapped))
            if(::GetLastError() != ERROR_IO_PENDING)
                uWriteLength = 0;
           
            return uWriteLength;
    }
    ///写串口 写ANSI C 模式字符串指针
    DWORD Write(const char *szBuffer)
    {
        assert(szBuffer);
       
        return Write((void *)szBuffer, strlen(szBuffer));
    }
    ///读串口    同步应用
    DWORD ReadSync(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
       
        DWORD dwError;
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
        {
            ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);
            return 0;
        }

        DWORD uReadLength = 0;
        ::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, NULL);
        return uReadLength;
    }
    ///写串口 同步应用
    DWORD WriteSync(LPVOID Buffer, DWORD dwBufferLength)
    {
        if(!IsOpen())
            return 0;
       
        DWORD dwError;
        if(::ClearCommError(_hCommHandle, &dwError, NULL) && dwError > 0)
            ::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
       
        unsigned long uWriteLength = 0;
        ::WriteFile(_hCommHandle, Buffer, dwBufferLength, &uWriteLength, NULL);
        return uWriteLength;
    }
    ///写串口 szBuffer 可以输出格式字符串 包含缓冲区长度
    DWORD Write(char *szBuffer, DWORD dwBufferLength, char * szFormat, ...)
    {
        if(!IsOpen())
            return 0;
       
        va_list va;
        va_start(va, szFormat);
        _vsnprintf(szBuffer, dwBufferLength, szFormat, va);
        va_end(va);
       
        return Write(szBuffer);
    }
    ///写串口 szBuffer 可以输出格式字符串 不检查缓冲区长度 小心溢出
    DWORD Write(char *szBuffer, char * szFormat, ...)
    {
        if(!IsOpen())
            return 0;
       
        va_list va;
        va_start(va, szFormat);
        vsprintf(szBuffer, szFormat, va);
        va_end(va);
       
        return Write(szBuffer);
    }
    ///关闭串口 同时也关闭关联线程
    virtual void Close()
    {
        if(IsOpen()) 
        {
            PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_TXCLEAR);
           
            EndThread();
            ::CloseHandle(_hCommHandle);
           
            _hCommHandle = INVALID_HANDLE_VALUE;
        }
    }

    struct InnerLock
    {
        cnComm* ptr;

        InnerLock(cnComm* p) : ptr(p)
        {
            ptr->Lock();
        }
        ~InnerLock()
        {
            ptr->Unlock();
        }
    };

    ///锁定资源
    void Lock()
    {
        ::EnterCriticalSection(&_Mutex);
    }
    void Unlock()
    {
        ::LeaveCriticalSection(&_Mutex);
    }
    ///DTR 电平控制
    bool SetDTR(bool OnOrOff)
    {
        return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETDTR : CLRDTR) != 0 : false;
    }
    ///RTS 电平控制
    bool SetRTS(bool OnOrOff)
    {
        return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETRTS : CLRRTS) != 0 : false;
    }
    //
    bool SetBreak(bool OnOrOff)
    {
        return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETBREAK : CLRBREAK) != 0 : false;
    }
    ///辅助线程控制 建监视线程
    bool BeginThread()
    {
        if(!IsThreadRunning())
        {
            _fRunFlag = true;
            _hThreadHandle = NULL;
           
            #ifdef _MT
            unsigned int id;
            _hThreadHandle = (HANDLE)_beginthreadex(NULL, 0, CommThreadProc, this, 0, &id);
            #else
            DWORD id;
            _hThreadHandle = ::CreateThread(NULL, 0, CommThreadProc, this, 0, &id);
            #endif
           
            return (_hThreadHandle != NULL);
        }
        return false;
    }
    ///暂停监视线程
    inline bool SuspendThread()
    {
        return IsThreadRunning() ? ::SuspendThread(_hThreadHandle) != 0xFFFFFFFF : false;
    }
    ///恢复监视线程
    inline bool ResumeThread()
    {
        return IsThreadRunning() ? ::ResumeThread(_hThreadHandle) != 0xFFFFFFFF : false;
    }
    ///终止线程
    bool EndThread(DWORD dwWaitTime = 100)
    {
        if(IsThreadRunning())
        {
            _fRunFlag = false;
            ::SetCommMask(_hCommHandle, 0);
            ::SetEvent(_WaitOverlapped.hEvent);
            if(::WaitForSingleObject(_hThreadHandle, dwWaitTime) != WAIT_OBJECT_0)
                if(!::TerminateThread(_hThreadHandle, 0))
                    return false;
               
                ::CloseHandle(_hThreadHandle);
                ::ResetEvent(_WaitOverlapped.hEvent);
               
                _hThreadHandle = NULL;
               
                return true;
        }
        return false;
    }
   
protected:

    volatile DWORD _dwPort;   ///串口号
    volatile HANDLE _hCommHandle;  ///串口句柄
    char _szCommStr[64];  ///保存COM1类似的字符串
   
    DCB _DCB;  ///波特率，停止位，等  
    COMMTIMEOUTS _CO;  ///超时结构  
   
    DWORD _dwIOMode;  // 0 同步  默认 FILE_FLAG_OVERLAPPED 重叠I/O 异步
    OVERLAPPED _ReadOverlapped, _WriteOverlapped; // 重叠I/O
   
    volatile HANDLE _hThreadHandle; ///辅助线程
    volatile HWND _hNotifyWnd;  // 通知窗口
    volatile DWORD _dwNotifyNum; ///接受多少字节(>=_dwNotifyNum)发送通知消息
    volatile DWORD _dwMaskEvent; ///监视的事件
    volatile bool _fRunFlag;  ///线程运行循环标志
    bool _fAutoBeginThread;  ///Open() 自动 BeginThread();
    OVERLAPPED _WaitOverlapped;  ///WaitCommEvent use
   
    ///初始化
    virtual void Init()
    {
        memset(_szCommStr, 0, 64);
        memset(&_DCB, 0, sizeof(_DCB));
        _DCB.DCBlength = sizeof(_DCB);
        _hCommHandle = INVALID_HANDLE_VALUE;
       
        memset(&_ReadOverlapped, 0, sizeof(_ReadOverlapped));
        memset(&_WriteOverlapped, 0, sizeof(_WriteOverlapped));
       
        _ReadOverlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
        assert(_ReadOverlapped.hEvent != NULL);
       
        _WriteOverlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
        assert(_WriteOverlapped.hEvent != NULL);
       
        _hNotifyWnd = NULL;
        _dwNotifyNum = 0;
        _dwMaskEvent = DEFAULT_COM_MASK_EVENT;
        _hThreadHandle = NULL;
        _dwPort = 0;
       
        memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped));
        _WaitOverlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
        assert(_WaitOverlapped.hEvent != NULL);

        ::InitializeCriticalSection(&_Mutex);
    }
    ///析构
    virtual void Destroy()
    {
        if(_ReadOverlapped.hEvent != NULL)
            CloseHandle(_ReadOverlapped.hEvent);
       
        if(_WriteOverlapped.hEvent != NULL)
            CloseHandle(_WriteOverlapped.hEvent);
       
        if(_WaitOverlapped.hEvent != NULL)
            CloseHandle(_WaitOverlapped.hEvent);

        ::DeleteCriticalSection(&_Mutex);
    }
    ///绑定串口
    void BindCommPort(DWORD dwPort)
    {
        assert(dwPort >= 1 && dwPort <= 1024);
       
        char p[5];
       
        _dwPort = dwPort;
        strcpy(_szCommStr, ".//COM");
        ltoa(_dwPort, p, 10);
        strcat(_szCommStr, p);
    }
    ///打开串口
    virtual bool OpenCommPort()
    {
        if(IsOpen())
            Close();
       
        _hCommHandle = ::CreateFile(
            _szCommStr,
            GENERIC_READ | GENERIC_WRITE,
            0,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL | _dwIOMode,
            NULL
            );
       
        if(_fAutoBeginThread)
        {
            if(IsOpen() && BeginThread())
                return true;
            else
            {
                Close();  ///创建线程失败
                return false;
            }
        }
        return IsOpen();
    }
    ///设置串口
    virtual bool SetupPort()
    {
        if(!IsOpen())
            return false;
       
       
        if(!::SetupComm(_hCommHandle, 4096, 4096))
            return false;
       
       
        if(!::GetCommTimeouts(_hCommHandle, &_CO))
            return false;
        _CO.ReadIntervalTimeout = 0;
        _CO.ReadTotalTimeoutMultiplier = 1;
        _CO.ReadTotalTimeoutConstant = 1000;
        _CO.WriteTotalTimeoutMultiplier = 1;
        _CO.WriteTotalTimeoutConstant = 1000;
        if(!::SetCommTimeouts(_hCommHandle, &_CO))
            return false;
       
       
        if(!::PurgeComm(_hCommHandle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR ))
            return false;
       
        return true;
    }
   
    //---------------------------------------threads callback-----------------------------------------------------
    ///线程收到消息自动调用, 如窗口句柄有效, 送出消息, 包含串口编号， 均为虚函数可以在基层类中扩展      
    virtual void OnReceive()///EV_RXCHAR
    {
        if(::IsWindow(_hNotifyWnd))
            ::PostMessage(_hNotifyWnd, ON_COM_RECEIVE, WPARAM(_dwPort), LPARAM(0));
    }
   
    virtual void OnDSR()
    {
        if(::IsWindow(_hNotifyWnd))
        {
            DWORD Status;
            if(GetCommModemStatus(_hCommHandle, &Status))
                ::PostMessage(_hNotifyWnd, ON_COM_DSR, WPARAM(_dwPort), LPARAM( (Status & MS_DSR_ON) ? 1 : 0));
        }
    }
   
    virtual void OnCTS()
    {
        if(::IsWindow(_hNotifyWnd))
        {
            DWORD Status;
            if(GetCommModemStatus(_hCommHandle, &Status))
                ::PostMessage(_hNotifyWnd, ON_COM_CTS, WPARAM(_dwPort), LPARAM( (Status & MS_CTS_ON) ? 1 : 0));
        }
    }
   
    virtual void OnBreak()
    {
        if(::IsWindow(_hNotifyWnd))
        {
            ::PostMessage(_hNotifyWnd, ON_COM_BREAK , WPARAM(_dwPort), LPARAM(0));
        }
    }
   
    virtual void OnTXEmpty()
    {
        if(::IsWindow(_hNotifyWnd))
            ::PostMessage(_hNotifyWnd, ON_COM_TXEMPTY, WPARAM(_dwPort), LPARAM(0));
    }
   
    virtual void OnError()
    {
        DWORD dwError;
        ::ClearCommError(_hCommHandle, &dwError, NULL);
        if(::IsWindow(_hNotifyWnd))
            ::PostMessage(_hNotifyWnd, ON_COM_ERROR, WPARAM(_dwPort), LPARAM(dwError));
    }
   
    virtual void OnRing()
    {
        if(::IsWindow(_hNotifyWnd))
            ::PostMessage(_hNotifyWnd, ON_COM_RING, WPARAM(_dwPort), LPARAM(0));
    }
   
    virtual void OnRLSD()
    {
        if(::IsWindow(_hNotifyWnd))
            ::PostMessage(_hNotifyWnd, ON_COM_RLSD, WPARAM(_dwPort), LPARAM(0));
    }
   
    virtual DWORD ThreadFunc()
    {
        if(!::SetCommMask(_hCommHandle, _dwMaskEvent))
        {
            char szBuffer[256];
            _snprintf(szBuffer, 255, "%s(%d) : COM%d Call WINAPI SetCommMask(%x, %x) Fail, thread work invalid! GetLastError() = %d;",
                __FILE__, __LINE__, _dwPort, _hCommHandle, _dwMaskEvent, GetLastError());
            MessageBox(NULL, szBuffer, "Class cnComm", MB_OK);
            return 1;
        }
       
        COMSTAT Stat;
        DWORD dwError;
       
        for(DWORD dwLength, dwMask = 0; _fRunFlag && IsOpen(); dwMask = 0)
        {
            if(!::WaitCommEvent(_hCommHandle, &dwMask, &_WaitOverlapped))
            {
                if(::GetLastError() == ERROR_IO_PENDING)// asynchronous
                    ::GetOverlappedResult(_hCommHandle, &_WaitOverlapped, &dwLength, TRUE);
                else
                    continue;
            }
           
            if(dwMask == 0)
                continue;
           
            switch(dwMask)
            {
            case EV_RXCHAR :
                ::ClearCommError(_hCommHandle, &dwError, &Stat);
                if(Stat.cbInQue >= _dwNotifyNum)
                    OnReceive();
                break;
               
            case EV_TXEMPTY :
                OnTXEmpty();
                break;
               
            case EV_CTS :
                OnCTS();
                break;
               
            case EV_DSR :
                OnDSR();
                break;
               
            case EV_RING :
                OnRing();
                break;
               
            case EV_RLSD :
                OnRLSD();
                break;
               
            case EV_BREAK:
                OnBreak();
                break;
               
            case EV_ERR :
                OnError();
                break;
               
            }///case
        }///for
        return 0;
    }
   
private:  ///the function protected
   
    cnComm(const cnComm&);
    cnComm &operator = (const cnComm&);
    CRITICAL_SECTION _Mutex;
   
    ///base function for thread
    #ifdef _MT
    static UINT APIENTRY CommThreadProc(LPVOID lpPara)
    #else
    static DWORD WINAPI CommThreadProc(LPVOID lpPara)
    #endif
    {
        return ( (cnComm *)lpPara )->ThreadFunc();
    }
};

#endif ///_CN_COMM_H_

wujian53
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
关于CnComm的一点总结
不定期更新的博客
11-30 4161
CnComm是国人llbird所编写的一个串口通信开源库，详细介绍请查看：https://blog.csdn.net/wujian53/article/category/336981，最新的讨论博客请查看：http://www.cppblog.com/llbird/archive/2009/05/15/CnComm.html，最新的版本为1.51（事实上已多年没更新的说。。）。 （PS：月更博客...
CnComm多线程串口通讯类的封装实现
渔樵阿飞
02-17 7080
之前对于CnComm类库做过简单的分析，详见CnComm多线程串口通讯类解读CnComm是llbird开发的WINDOWS/WINCE 多线程串口通讯开源库，提供同步IO并发访问的支持，内存管理采用内存池技术，提供对于C++异常的支持。在实际的项目中，需要使用多个串口来收发消息，于是对于CnComm类做了简单的封装操作。 实现对于CnComm串口类的封装，提供基本的接口通过串口管理类
《渝快办》智能小程序应用平台上线.pdf
07-01
《渝快办》智能小程序应用平台上线.pdf
CnComm 1.3 的用法
llbird的C/C++世界
09-21 7623
案例：假如发送间隔发送一个字符串，间隔时间、长度不确定，没有起始、结束的标志；可以确定是发送端一口气发送完后字符串，并且能够假定有最大长度,如何处理；cnComm 1.3可以一定程度的解决这个问题；假设字符串的最大长度为20，设定每次读为3倍的最大长度即60；不能确定的就尽可能大一点;class MyCom : public CxComm{    virtual void OnReceiv
llbird的MFC串口操作库CnComm断言问题探讨及vs2015修正
zhouhaiyangqq的专栏
11-25 3081
最近在读llbird的MFC串口操作库CnComm，在vs2015中使用了一下，感觉非常简洁精妙，好的地方就不说了，来谈谈问题。 首先是断言的使用问题，感觉作者的断言使用有点小小的问题，当然我说的也不一定对，欢迎大家来提意见！！
CnComm 1.3正确版
11-28
上一个版本有问题，会导致CPU耗尽，有些网友下了，但是没有看到我的勘误，所以很抱歉,CSDN没有提供删除功能,这个是正确的版本。
CnComm1.3
09-22
支持多种编译器的串口支持C++实现类库
CnComm 1.3 正确版
11-28
上一个版本有问题，会导致CPU耗尽，有些网友下了，但是没有看到我的勘误，所以很抱歉,CSDN没有提供删除功能,这个是正确的版本。
VS2015cncomm改进版
12-19
这是非常实用的CnComm的改良版，在VS2015中可以直接运行，请大家多多指教
CnComm串口通信 经典串口通信程序
07-21
CnComm串口通信 经典串口通信程序 非常详解
CnComm 1.51(串口类 串口库 完全源码 带例程 带使用说明)
09-12
最值得推荐的，使用简单、功能丰富、运行高效的串口类，国产奇葩。
SerialAssistant_CnComm
12-22
开源共享，原创串口助手，带置顶功能，用CnComm类编写，采用vs2010环境，内有简单的文档说明，有意见请联系本人
CnComm1.51 修正版
08-30
相对于CnComm1.5的修正版，及将放在CppBlog的勘误放入头文件，版本定位CnComm1.51
opencomm在c语言中的作用,cnComm类（串口类）的使用方法
weixin_30915399的博客
05-16 975
类库文件：cncomm.h 加入VC++工程StdAfx.h中加入#include "CnComm.h"界面头文件加入COM口定义CnComm m_Com;界面头文件加入消息响应函数afx_msg LRESULT OnReceive(WPARAM, LPARAM);初始化打开串口m_Com.Open(5);设置波特率等参数(可选)m_Com.SetState(DWORD dwBaudRate, ...
MySQL多种安装方式（重点）
weixin_45697293的博客
02-02 388
文章目录① .用yum安装centos6用的是mysql-servercentos7用的是mariabd-server② . 基于RPM包的安装(yum网络源- --包)③ .二进制安装通用二进制格式安装过程④ . 源码包安装源码编译安装mariadb五. 实现数据库的多实例（重点） ① .用yum安装 端口号3306 centos6用的是mysql-server 服务为mysqld mysql自带一个root账号（得设置密码） centos7用的是mariabd-server 服务为mariadb-
cncomm1.51 修正版
最新发布
02-06
cncomm1.51修正版是一款通信软件，主要用于实现网络通信和数据传输。这款软件经过修正之后，在之前版本的基础上做了一些优化和改进。首先，修正了一些之前版本存在的bug和问题，提升了软件的稳定性和可靠性。其次，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值