串口基础类库（WIN32）稳定版本 Version 1.0 (2004/12)

最新推荐文章于 2019-06-13 17:25:34 发布
最新推荐文章于 2019-06-13 17:25:34 发布
阅读量6.1k 收藏 3
点赞数
分类专栏： 原创类库 文章标签： null buffer asynchronous winapi user thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujian53/article/details/180939
版权

/*
这个版本是12月份的稳定版本， 有不少网友试用过， 也给我不少宝贵的意见，
因为较稳定， 也适合大多数应用场合， 不会有太多的改动，故我决定版本定位1.0;欢迎来信反馈;
修正内容:
Read()函数不在读取内容后加'/0';
新增ReadString()函数在读取内容后加'/0';
这个修改可能会引起原来的代码出错;
其他为零星的修改, 且不会影响原来的代码;
 if(Stat.cbInQue >= _dwNotifyNum) 这里原来为> 改为 >=
*/
/*
Comm Base Library(WIN98/NT/2000) ver 1.0

Compile by： BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET;  GCC;

copyright(c) 2004.5 - 2004.12  llbird wushaojian@21cn.com

注: 作为基础代码, 为保证源码的正确性, 请勿修改以下代码, 有问题可直接联系, 可以继承扩展你所需要的功能
*/

#ifndef _CN_COMM_H_
#define _CN_COMM_H_

#pragma warning(disable: 4530)
#pragma warning(disable: 4786)
#pragma warning(disable: 4800)

#include <assert.h>
#include <stdio.h>
#include <windows.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(); 
  UnInit();
 }

//----------------------------------Attributes----------------------------------
 //判断串口是或打开
 inline bool IsOpen()
 {
  return _hCommHandle != INVALID_HANDLE_VALUE;
 }
 //判断串口是或打开
 operator bool ()
 {
  return _hCommHandle != INVALID_HANDLE_VALUE;
 }
 //获得串口句炳
 inline HANDLE GetHandle()
 {
  return _hCommHandle;
 }
 //获得串口句炳
 operator HANDLE()
 {
  return _hCommHandle;
 }
 //获得串口参数 DCB
 DCB *GetState()
 {
  return IsOpen() && ::GetCommState(_hCommHandle, &_DCB) ? &_DCB : NULL;
 }
 //设置串口参数 DCB
 bool SetState(DCB *pdcb = NULL)
 {
  return IsOpen() ? ::SetCommState(_hCommHandle, pdcb == NULL ? &_DCB : pdcb) == TRUE : false;
 }
 //设置串口参数：波特率，停止位，等 支持设置字符串 "9600, 8, n, 1"
 bool SetState(char *szSetStr) 
 {
  if(IsOpen())
  {
   if(!::GetCommState(_hCommHandle, &_DCB))
    return false;
   if(!::BuildCommDCB(szSetStr, &_DCB))
    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))
    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) ? &_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; 
 }
 //关联消息的窗口句柄
 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) ? Stat.cbInQue : (DWORD)-1L;
 }

//----------------------------------Operations----------------------------------
 //打开串口 缺省 9600, 8, n, 1
 bool Open(DWORD dwPort)
 {
  return Open(dwPort, 9600);
 }
 //打开串口 缺省 baud_rate, 8, n, 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, 8, n, 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, DWORD dwWaitTime = 20)
 {
  if(!IsOpen())
   return 0;

  COMSTAT  Stat;
  DWORD dwError;

  if(::ClearCommError(_hCommHandle, &dwError, &Stat) && dwError > 0)
  {
   ::PurgeComm(_hCommHandle, PURGE_RXABORT | PURGE_RXCLEAR);
   return 0;
  }

  if(!Stat.cbInQue) // 缓冲区无数据
   return 0;

  unsigned long uReadLength = 0;

  dwBufferLength = dwBufferLength > Stat.cbInQue ? Stat.cbInQue : dwBufferLength;

  if(!::ReadFile(_hCommHandle, Buffer, dwBufferLength, &uReadLength, &_ReadOverlapped))
  {
   if(::GetLastError() == ERROR_IO_PENDING)
   {
    WaitForSingleObject(_ReadOverlapped.hEvent, dwWaitTime); // 结束异步I/O
    if(!::GetOverlappedResult(_hCommHandle, &_ReadOverlapped, &uReadLength, false))
    {
     if(::GetLastError() != ERROR_IO_INCOMPLETE)
       uReadLength = 0;
    }
   }
   else
    uReadLength = 0;
  }
   
  return uReadLength;
 }
 //读取串口 dwBufferLength - 1 个字符到 szBuffer 返回ANSI C 模式字符串指针 适合一般字符通讯
 char * ReadString(char *szBuffer, DWORD dwBufferLength, DWORD dwWaitTime = 20)
 {
  unsigned long uReadLength = Read(szBuffer, dwBufferLength - 1, dwWaitTime);
  szBuffer[uReadLength] = '/0';
  return szBuffer;
 }
 //写串口 可写任意数据 "abcd" or "/x0/x1/x2"
 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 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;
  }
 }
 //DTR 电平控制
 bool SetDTR(bool OnOrOff)
 {
  return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETDTR : CLRDTR) : false;
 }
 //RTS 电平控制
 bool SetRTS(bool OnOrOff)
 {
  return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETRTS : CLRRTS) : false;
 }
 //
 bool SetBreak(bool OnOrOff)
 {
  return IsOpen() ? EscapeCommFunction(_hCommHandle, OnOrOff ? SETBREAK : CLRBREAK) : false;
 }
 //辅助线程控制 建监视线程
 bool BeginThread()
 {
  if(!IsThreadRunning())
  {
   _fRunFlag = true;
   _hThreadHandle = NULL;

   DWORD id;

   _hThreadHandle = ::CreateThread(NULL, 0, CommThreadProc, this, 0, &id);

   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[20];  //保存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

 //初始化
 void Init() 
 {
  memset(_szCommStr, 0, 20);
  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 != INVALID_HANDLE_VALUE);
  
  _WriteOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
  assert(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE);

  _hNotifyWnd = NULL;
  _dwNotifyNum = 0;
  _dwMaskEvent = DEFAULT_COM_MASK_EVENT;
  _hThreadHandle = NULL;

  memset(&_WaitOverlapped, 0, sizeof(_WaitOverlapped));
  _WaitOverlapped.hEvent = ::CreateEvent(NULL, true, false, NULL);
  assert(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE); 
 } 
 //析构
 void UnInit()
 {
  if(_ReadOverlapped.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_ReadOverlapped.hEvent);

  if(_WriteOverlapped.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_WriteOverlapped.hEvent);

  if(_WaitOverlapped.hEvent != INVALID_HANDLE_VALUE)
   CloseHandle(_WaitOverlapped.hEvent);
 }
 //绑定串口
 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 = 0xFFFFFFFF;
  _CO.ReadTotalTimeoutMultiplier = 0;
  _CO.ReadTotalTimeoutConstant = 0;
  _CO.WriteTotalTimeoutMultiplier = 0;
  _CO.WriteTotalTimeoutConstant = 2000;
  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&);
 const cnComm &operator = (const cnComm&);

 //base function for thread
 static DWORD WINAPI CommThreadProc(LPVOID lpPara)
 {
  return ( (cnComm *)lpPara )->ThreadFunc();
 }
};

#endif //_CN_COMM_H_

 

wujian53
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 26
    评论
专栏目录
一个WIN32串口通讯库
FASM_FASM的专栏
09-09 1085
Win32串行通信库（LibSp）是一个软件开发包，是一个基于Windows串行通讯API的静态链接库。 LibSp使用标准的Windows API与任何串口设备通讯。 LibSp支持如下功能： 可控制任何连接到串行RS232端口的设备。可用于GUI模式或控制台模式的程序。可同时控制多个端口（创建多个端口句柄）。包括硬件和软件流控制。兼容RS232，RS485串行端口。完全线程安全。支持在Wind
串口操作类库(SerialPort)
07-22
串口 类 SerialPort c# api串口操作类库(SerialPort)
一个很好的串口类库
01-04
一个很好的串口类库,附有BCB和VC的Demo
串口基础类库（WIN32）异步通信 _COM_H 源代码
weixin_30702413的博客
06-14 125
/* 串口基础类库（WIN32） ver 0.1 编译器 ： BC++ 5; C++ BUILDER 4, 5, 6, X; VC++ 5, 6; VC.NET; GCC; class _base_com : 虚基类 基本串口接口; class _sync_com : 同步I/O 串口类; class _asyn_com : 异步I/O 串口类; clas...
STM32USB虚拟串口驱动 支持win10
03-07
在本文中，我们将讨论如何在Windows操作系统，特别是Win10，中使用STM32的USB功能作为虚拟串口驱动。 首先，STM32的USB功能可以通过固件配置为不同的USB类设备，如设备类、主机类或OTG（On-The-Go）。在这个案例中...
使用Win32API实现Windows下异步串口通讯.doc
07-07
使用Win32API实现Windows下异步串口通讯 目录：1．异步非阻塞串口通讯的优点2．异步非阻塞串口通讯的基本原理3．异步非阻塞串口通讯的基础知识4．异步非阻塞串口通讯的实现步骤一，异步非阻塞串口通讯的优点读写...
MFC类库 WIN32API大全
04-18
1. **基础类与对象**: MFC的核心类包括CObject，它是所有MFC类的基类，提供了一些基本的特性如串行化、调试支持等。其他如CWinApp代表应用程序对象，CWnd代表窗口对象，CFrameWnd和CMDIFrameWnd则用于创建主框架窗口...
STM32开发指南V1.0 库函数版本
10-22
STM32开发指南V1.0库函数版本是针对ALIENTEK战舰STM32开发板的一份详尽教程，旨在帮助开发者深入了解和熟练运用STM32微控制器。该指南覆盖了从硬件介绍到软件开发的各个层面，适用于初学者和有经验的工程师。 在...
C# 实现 串口通用类库
06-06
2019-06-06 这是基于.Net Framework 4.0，封装了串口一些操作，如打开串口、关闭串口、串口发送、串口接收等，方便下次需要使用串口功能时，直接在解决方案中添加该类库。可以直接调取使用。 目前完成功能： 1、打开串口 2、关闭串口 3、广播串口收到的消息 4、发送串口数据 注意事项： 需要订阅 串口接收数据事件，才可以接收到串口数据。 该类库的编译器是Visual Studio 2010，框架是.Net Framework 4.0
WIN32串口通讯库
09-11
Win32串行通信库（LibSp）是一个软件开发包，是一个基于Windows串行通讯API的静态链接库。 LibSp使用标准的Windows API与任何串口设备通讯。 LibSp支持如下功能： 可控制任何连接到串行RS232端口的设备。可用于GUI模式或控制台模式的程序。可同时控制多个端口（创建多个端口句柄）。包括硬件和软件流控制。兼容RS232，RS485串行端口。完全线程安全。
基于Win32的 串口通信操作类
07-26
最近写一个上位机软件，经过多方学习写了一个串口的类，可能不够完善，希望大家帮忙看看有什么不足的地方！ 如果发现不足，望给我留言，我的QQ122478722 也可以在csdn留言，多谢！
Win下串口类Win32 API
11-19
整理的Windows下串口类，封装了Win32 API，挺实用的，供下载参考
最新 串口类 CSerialPort v1.29 (A C++ class for Win32 serial ports)
03-05
CSerialPort类的最新版本 修正以往BUG 内含CSerialPort类的整个工程 可编译运行 方便学习和移植 在程序中如果要用到多个串口，而且还要做很多复杂的处理，那么最好不用MSComm通讯控件，如果这时你还不愿意自己编写底层，就用这个类：CserialPort类。 作者是 Remon Spekreijse
Win32串口编程
10-25
Win32下串口通信与16位串口通信有很大的区别。在Win32下，可以使用两种编程方式实现串口通信，其一是调用的Windows的API函数，其二是使用ActiveX控件。
C# 串口驱动封装成类库
代码收割机的博客
06-13 4086
由于最近写了许多软件都需要调用到串口驱动，本来 C#自带的已经封装的挺好了，不过为了以后图省事，所以在C#串口驱动的基础上封装了一个类库，未来只要引用一个类库，用两行代码直接完成了串口的操作。 下面讲一下串口类库里面的内容以及调用方法。 串口类库调用方法： 首先，在解决方案中，添加“现有项目”，现有项目选择类库。 然后，在需要使用串口的项目中右键点击“引用”，选择“添加引用”，在项目中选择刚才添...
win32 API 开发串口 参考资料
abc
06-01 3239
参考网址： Win32 API串口编程 (很好) 同步 代码 异步 代码 都有 https://blog.csdn.net/zhuyonghao123/article/details/8162250 WIN32控制台下的串口通信程序（异步操作） https://blog.csdn.net/u013232740/article/details/49871113 windows串口通信操作和...
windows串口通讯（读和写，很方便！！）
热门推荐
朱铭德的博客
11-15 2万+
串口通讯

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值