win 串口编程

1220阅读　0评论2015-08-29　zhanggf8220
分类：C/C++

在windows程序设计与开发过程中，特别是涉及到开发嵌入式软硬件系统时，往往会涉及到串口编程。

点击(此处)折叠或打开

  1. //////////////////////////////////////////////////////////////////////////
  2. /// COPYRIGHT NOTICE
  3. ///
  4. /// @file SerialPort.h
  5. /// @brief 串口通信类头文件
  6. ///
  7. /// 本文件完成串口通信类的声明
  8. ///
  9. /// 修订说明：
  10. //////////////////////////////////////////////////////////////////////////

  12. #ifndef SERIALPORT_H_
  13. #define SERIALPORT_H_

  15. #include <Windows.h>

  17. /** 串口通信类
  18.  *
  19.  * 本类实现了对串口的基本操作
  20.  * 例如监听发到指定串口的数据、发送指定数据到串口
  21.  */
  22. class CSerialPort
  23. {
  24. public:
  25.     CSerialPort(void);
  26.     ~CSerialPort(void);

  28. public:
  29.     
  30.     /** 初始化串口函数
  31.      *
  32.      * @param: UINT portNo 串口编号,默认值为1,即COM1,注意,尽量不要大于9
  33.      * @param: UINT baud 波特率,默认为9600
  34.      * @param: char parity 是否进行奇偶校验,'Y'表示需要奇偶校验,'N'表示不需要奇偶校验
  35.      * @param: UINT databits 数据位的个数,默认值为8个数据位
  36.      * @param: UINT stopsbits 停止位使用格式,默认值为1
  37.      * @param: DWORD dwCommEvents 默认为EV_RXCHAR,即只要收发任意一个字符,则产生一个事件
  38.      * @return: bool 初始化是否成功
  39.      * @note: 在使用其他本类提供的函数前,请先调用本函数进行串口的初始化
  40.      *　　　　　 /n本函数提供了一些常用的串口参数设置,若需要自行设置详细的DCB参数,可使用重载函数
  41.      * /n本串口类析构时会自动关闭串口,无需额外执行关闭串口
  42.      * @see:
  43.      */
  44.     bool InitPort( UINT portNo = 1,UINT baud = CBR_9600,char parity = 'N',UINT databits = 8,
  45.          UINT stopsbits = 1,DWORD dwCommEvents = EV_RXCHAR);

  47.     /** 串口初始化函数
  48.      *
  49.      * 本函数提供直接根据DCB参数设置串口参数
  50.      * @param: UINT portNo
  51.      * @param: const LPDCB & plDCB
  52.      * @return: bool 初始化是否成功
  53.      * @note: 本函数提供用户自定义地串口初始化参数
  54.      * @see:
  55.      */
  56.     bool InitPort( UINT portNo ,const LPDCB& plDCB );

  58.     /** 开启监听线程
  59.      *
  60.      * 本监听线程完成对串口数据的监听,并将接收到的数据打印到屏幕输出
  61.      * @return: bool 操作是否成功
  62.      * @note: 当线程已经处于开启状态时,返回flase
  63.      * @see:
  64.      */
  65.     bool OpenListenThread();

  67.     /** 关闭监听线程
  68.      *
  69.      *
  70.      * @return: bool 操作是否成功
  71.      * @note: 调用本函数后,监听串口的线程将会被关闭
  72.      * @see:
  73.      */
  74.     bool CloseListenTread();

  76.     /** 向串口写数据
  77.      *
  78.      * 将缓冲区中的数据写入到串口
  79.      * @param: unsigned char * pData 指向需要写入串口的数据缓冲区
  80.      * @param: unsigned int length 需要写入的数据长度
  81.      * @return: bool 操作是否成功
  82.      * @note: length不要大于pData所指向缓冲区的大小
  83.      * @see:
  84.      */
  85.     bool WriteData(unsigned char* pData, unsigned int length);

  87.     /** 获取串口缓冲区中的字节数
  88.      *
  89.      *
  90.      * @return: UINT 操作是否成功
  91.      * @note: 当串口缓冲区中无数据时,返回0
  92.      * @see:
  93.      */
  94.     UINT GetBytesInCOM();

  96.     /** 读取串口接收缓冲区中一个字节的数据
  97.      *
  98.      *
  99.      * @param: char & cRecved 存放读取数据的字符变量
  100.      * @return: bool 读取是否成功
  101.      * @note:
  102.      * @see:
  103.      */
  104.     bool ReadChar(char &cRecved);

  106. private:

  108.     /** 打开串口
  109.      *
  110.      *
  111.      * @param: UINT portNo 串口设备号
  112.      * @return: bool 打开是否成功
  113.      * @note:
  114.      * @see:
  115.      */
  116.     bool openPort( UINT portNo );

  118.     /** 关闭串口
  119.      *
  120.      *
  121.      * @return: void 操作是否成功
  122.      * @note:
  123.      * @see:
  124.      */
  125.     void ClosePort();
  126.     
  127.     /** 串口监听线程
  128.      *
  129.      * 监听来自串口的数据和信息
  130.      * @param: void * pParam 线程参数
  131.      * @return: UINT WINAPI 线程返回值
  132.      * @note:
  133.      * @see:
  134.      */
  135.     static UINT WINAPI ListenThread(void* pParam);

  137. private:

  139.     /** 串口句柄 */
  140.     HANDLE m_hComm;

  142.     /** 线程退出标志变量 */
  143.     static bool s_bExit;

  145.     /** 线程句柄 */
  146.     volatile HANDLE m_hListenThread;

  148.     /** 同步互斥,临界区保护 */
  149.     CRITICAL_SECTION m_csCommunicationSync; //!< 互斥操作串口

  151. };

  153. #endif //SERIALPORT_H_

  155. //////////////////////////////////////////////////////////////////////////
  156. /// COPYRIGHT NOTICE
  157. ///
  158. /// @file SerialPort.cpp
  159. /// @brief 串口通信类的实现文件
  160. ///
  161. /// 本文件为串口通信类的实现代码
  162. ///
  163. ///
  164. /// 修订说明：
  165. //////////////////////////////////////////////////////////////////////////

  167. #include "StdAfx.h"
  168. #include "SerialPort.h"
  169. #include <process.h>
  170. #include <iostream>

  172. /** 线程退出标志 */
  173. bool CSerialPort::s_bExit = false;
  174. /** 当串口无数据时,sleep至下次查询间隔的时间,单位:秒 */
  175. const UINT SLEEP_TIME_INTERVAL = 5;

  177. CSerialPort::CSerialPort(void)
  178. : m_hListenThread(INVALID_HANDLE_VALUE)
  179. {
  180.     m_hComm = INVALID_HANDLE_VALUE;
  181.     m_hListenThread = INVALID_HANDLE_VALUE;

  183.     InitializeCriticalSection(&m_csCommunicationSync);

  185. }

  187. CSerialPort::~CSerialPort(void)
  188. {
  189.     CloseListenTread();
  190.     ClosePort();
  191.     DeleteCriticalSection(&m_csCommunicationSync);
  192. }

  194. bool CSerialPort::InitPort( UINT portNo /*= 1*/,UINT baud /*= CBR_9600*/,char parity /*= 'N'*/,
  195.                          UINT databits /*= 8*/, UINT stopsbits /*= 1*/,DWORD dwCommEvents /*= EV_RXCHAR*/ )
  196. {

  198.     /** 临时变量,将制定参数转化为字符串形式,以构造DCB结构 */
  199.     char szDCBparam[50];
  200.     sprintf_s(szDCBparam, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits, stopsbits);

  202.     /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
  203.     if (!openPort(portNo))
  204.     {
  205.         return false;
  206.     }

  208.     /** 进入临界段 */
  209.     EnterCriticalSection(&m_csCommunicationSync);

  211.     /** 是否有错误发生 */
  212.     BOOL bIsSuccess = TRUE;

  214.     /** 在此可以设置输入输出的缓冲区大小,如果不设置,则系统会设置默认值.
  215.      * 自己设置缓冲区大小时,要注意设置稍大一些,避免缓冲区溢出
  216.      */
  217.     /*if (bIsSuccess )
  218.     {
  219.         bIsSuccess = SetupComm(m_hComm,10,10);
  220.     }*/

  222.     /** 设置串口的超时时间,均设为0,表示不使用超时限制 */
  223.     COMMTIMEOUTS CommTimeouts;
  224.     CommTimeouts.ReadIntervalTimeout = 0;
  225.     CommTimeouts.ReadTotalTimeoutMultiplier = 0;
  226.     CommTimeouts.ReadTotalTimeoutConstant = 0;
  227.     CommTimeouts.WriteTotalTimeoutMultiplier = 0;
  228.     CommTimeouts.WriteTotalTimeoutConstant = 0;
  229.     if ( bIsSuccess)
  230.     {
  231.         bIsSuccess = SetCommTimeouts(m_hComm, &CommTimeouts);
  232.     }

  234.     DCB dcb;
  235.     if ( bIsSuccess )
  236.     {
  237.         // 将ANSI字符串转换为UNICODE字符串
  238.         DWORD dwNum = MultiByteToWideChar (CP_ACP, 0, szDCBparam, -1, NULL, 0);
  239.         wchar_t *pwText = new wchar_t[dwNum] ;
  240.         if (!MultiByteToWideChar (CP_ACP, 0, szDCBparam, -1, pwText, dwNum))
  241.         {
  242.             bIsSuccess = TRUE;
  243.         }

  245.         /** 获取当前串口配置参数,并且构造串口DCB参数 */
  246.         bIsSuccess = GetCommState(m_hComm, &dcb) && BuildCommDCB(pwText, &dcb) ;
  247.         /** 开启RTS flow控制 */
  248.         dcb.fRtsControl = RTS_CONTROL_ENABLE;

  250.         /** 释放内存空间 */
  251.         delete [] pwText;
  252.     }

  254.     if ( bIsSuccess )
  255.     {
  256.         /** 使用DCB参数配置串口状态 */
  257.         bIsSuccess = SetCommState(m_hComm, &dcb);
  258.     }
  259.         
  260.     /** 清空串口缓冲区 */
  261.     PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

  263.     /** 离开临界段 */
  264.     LeaveCriticalSection(&m_csCommunicationSync);

  266.     return bIsSuccess==TRUE;
  267. }

  269. bool CSerialPort::InitPort( UINT portNo ,const LPDCB& plDCB )
  270. {
  271.     /** 打开指定串口,该函数内部已经有临界区保护,上面请不要加保护 */
  272.     if (!openPort(portNo))
  273.     {
  274.         return false;
  275.     }
  276.     
  277.     /** 进入临界段 */
  278.     EnterCriticalSection(&m_csCommunicationSync);

  280.     /** 配置串口参数 */
  281.     if (!SetCommState(m_hComm, plDCB))
  282.     {
  283.         return false;
  284.     }

  286.     /** 清空串口缓冲区 */
  287.     PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

  289.     /** 离开临界段 */
  290.     LeaveCriticalSection(&m_csCommunicationSync);

  292.     return true;
  293. }

  295. void CSerialPort::ClosePort()
  296. {
  297.     /** 如果有串口被打开，关闭它 */
  298.     if( m_hComm != INVALID_HANDLE_VALUE )
  299.     {
  300.         CloseHandle( m_hComm );
  301.         m_hComm = INVALID_HANDLE_VALUE;
  302.     }
  303. }

  305. bool CSerialPort::openPort( UINT portNo )
  306. {
  307.     /** 进入临界段 */
  308.     EnterCriticalSection(&m_csCommunicationSync);

  310.     /** 把串口的编号转换为设备名 */
  311.     char szPort[50];
  312.     sprintf_s(szPort, "COM%d", portNo);

  314.     /** 打开指定的串口 */
  315.     m_hComm = CreateFileA(szPort,         /** 设备名,COM1,COM2等 */
  316.                          GENERIC_READ | GENERIC_WRITE, /** 访问模式,可同时读写 */
  317.                          0, /** 共享模式,0表示不共享 */
  318.                      NULL,                            /** 安全性设置,一般使用NULL */
  319.                      OPEN_EXISTING,                    /** 该参数表示设备必须存在,否则创建失败 */
  320.                          0,
  321.                          0);

  323.     /** 如果打开失败，释放资源并返回 */
  324.     if (m_hComm == INVALID_HANDLE_VALUE)
  325.     {
  326.         LeaveCriticalSection(&m_csCommunicationSync);
  327.         return false;
  328.     }

  330.     /** 退出临界区 */
  331.     LeaveCriticalSection(&m_csCommunicationSync);

  333.     return true;
  334. }

  336. bool CSerialPort::OpenListenThread()
  337. {
  338.     /** 检测线程是否已经开启了 */
  339.     if (m_hListenThread != INVALID_HANDLE_VALUE)
  340.     {
  341.         /** 线程已经开启 */
  342.         return false;
  343.     }

  345.     s_bExit = false;
  346.     /** 线程ID */
  347.     UINT threadId;
  348.     /** 开启串口数据监听线程 */
  349.     m_hListenThread = (HANDLE)_beginthreadex(NULL, 0, ListenThread, this, 0, &threadId);
  350.     if (!m_hListenThread)
  351.     {
  352.         return false;
  353.     }
  354.     /** 设置线程的优先级,高于普通线程 */
  355.     if (!SetThreadPriority(m_hListenThread, THREAD_PRIORITY_ABOVE_NORMAL))
  356.     {
  357.         return false;
  358.     }

  360.     return true;
  361. }

  363. bool CSerialPort::CloseListenTread()
  364. {    
  365.     if (m_hListenThread != INVALID_HANDLE_VALUE)
  366.     {
  367.         /** 通知线程退出 */
  368.         s_bExit = true;

  370.         /** 等待线程退出 */
  371.         Sleep(10);

  373.         /** 置线程句柄无效 */
  374.         CloseHandle( m_hListenThread );
  375.         m_hListenThread = INVALID_HANDLE_VALUE;
  376.     }
  377.     return true;
  378. }

  380. UINT CSerialPort::GetBytesInCOM()
  381. {
  382.     DWORD dwError = 0;    /** 错误码 */
  383.     COMSTAT comstat; /** COMSTAT结构体,记录通信设备的状态信息 */
  384.     memset(&comstat, 0, sizeof(COMSTAT));

  386.     UINT BytesInQue = 0;
  387.     /** 在调用ReadFile和WriteFile之前,通过本函数清除以前遗留的错误标志 */
  388.     if ( ClearCommError(m_hComm, &dwError, &comstat) )
  389.     {
  390.         BytesInQue = comstat.cbInQue; /** 获取在输入缓冲区中的字节数 */
  391.     }

  393.     return BytesInQue;
  394. }

  396. UINT WINAPI CSerialPort::ListenThread( void* pParam )
  397. {
  398.     /** 得到本类的指针 */
  399.     CSerialPort *pSerialPort = reinterpret_cast<CSerialPort*>(pParam);

  401.     // 线程循环,轮询方式读取串口数据
  402.     while (!pSerialPort->s_bExit)
  403.     {
  404.         UINT BytesInQue = pSerialPort->GetBytesInCOM();
  405.         /** 如果串口输入缓冲区中无数据,则休息一会再查询 */
  406.         if ( BytesInQue == 0 )
  407.         {
  408.             Sleep(SLEEP_TIME_INTERVAL);
  409.             continue;
  410.         }

  412.         /** 读取输入缓冲区中的数据并输出显示 */
  413.         char cRecved = 0x00;
  414.         do
  415.         {
  416.             cRecved = 0x00;
  417.             if(pSerialPort->ReadChar(cRecved) == true)
  418.             {
  419.                 std::cout << cRecved ;
  420.                 continue;
  421.             }
  422.         }while(--BytesInQue);
  423.     }

  425.     return 0;
  426. }

  428. bool CSerialPort::ReadChar( char &cRecved )
  429. {
  430.     BOOL bResult = TRUE;
  431.     DWORD BytesRead = 0;
  432.     if(m_hComm == INVALID_HANDLE_VALUE)
  433.     {
  434.         return false;
  435.     }

  437.     /** 临界区保护 */
  438.     EnterCriticalSection(&m_csCommunicationSync);

  440.     /** 从缓冲区读取一个字节的数据 */
  441.     bResult = ReadFile(m_hComm, &cRecved, 1, &BytesRead, NULL);
  442.     if ((!bResult))
  443.     {
  444.         /** 获取错误码,可以根据该错误码查出错误原因 */
  445.         DWORD dwError = GetLastError();

  447.         /** 清空串口缓冲区 */
  448.         PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
  449.         LeaveCriticalSection(&m_csCommunicationSync);

  451.         return false;
  452.     }

  454.     /** 离开临界区 */
  455.     LeaveCriticalSection(&m_csCommunicationSync);

  457.     return (BytesRead == 1);

  459. }

  461. bool CSerialPort::WriteData( unsigned char* pData, unsigned int length )
  462. {
  463.     BOOL bResult = TRUE;
  464.     DWORD BytesToSend = 0;
  465.     if(m_hComm == INVALID_HANDLE_VALUE)
  466.     {
  467.         return false;
  468.     }

  470.     /** 临界区保护 */
  471.     EnterCriticalSection(&m_csCommunicationSync);

  473.     /** 向缓冲区写入指定量的数据 */
  474.     bResult = WriteFile(m_hComm, pData, length, &BytesToSend, NULL);
  475.     if (!bResult)
  476.     {
  477.         DWORD dwError = GetLastError();
  478.         /** 清空串口缓冲区 */
  479.         PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_RXABORT);
  480.         LeaveCriticalSection(&m_csCommunicationSync);

  482.         return false;
  483.     }

  485.     /** 离开临界区 */
  486.     LeaveCriticalSection(&m_csCommunicationSync);

  488.     return true;
  489. }


  492. // mySerialport.cpp : Defines the entry point for the console application.
  493. //

  495. #include "stdafx.h"
  496. #include "SerialPort.h"
  497. #include <iostream>

  499. int _tmain(int argc, _TCHAR* argv[])
  500. {

  502.     CSerialPort mySerialPort;

  504.     if (!mySerialPort.InitPort(2))
  505.     {
  506.         std::cout << "initPort fail !" << std::endl;
  507.     }
  508.     else
  509.     {
  510.         std::cout << "initPort success !" << std::endl;
  511.     }

  513.     if (!mySerialPort.OpenListenThread())
  514.     {
  515.         std::cout << "OpenListenThread fail !" << std::endl;
  516.     }
  517.     else
  518.     {
  519.         std::cout << "OpenListenThread success !" << std::endl;
  520.     }

  522.     int temp;
  523.     std::cin >> temp;

  525.     return 0;
  526. }

上一篇：getsockopt的TCP层实现剖析
下一篇：linux c 定时器