现在的位置: 首页 > 综合 > 正文

基于WIN32 API的串口通讯软件的设计

2013年05月16日 ⁄ 综合 ⁄ 共 9695字 ⁄ 字号 小 中 大 ⁄ 评论关闭

串口调试助手源代码：http://download.csdn.net/user/kissyfish

1、串口的应用

随着计算机技术的发展及工业自动化水平的提高,在许多场合采用单机控制已不能满足现场要求,因而必须采用多机控制的形式。串行通信作为计算机之间常用的通信方法之一,由于其通信编程灵活、硬件简洁并遵循统一的标准,而在工业控制领域得到了广泛的应用。

2、串口的属性

2.1波特率

波特率即数据传送速率，表示每秒钟传送二进制代码的位数，他的单位是bit/s。波特率对于CPU与外界的通信是很重要的。通讯过程中，必须保证上位机和下位机的波特率一致。如果不一致的话，就有可能出现乱码甚至出现丢包。这个就好如一个蓄水池的进水管道和出水管道，如果进水管道流入水的速度太快而出水管道的出水太慢，这样时间长了水就会溢出，反映在串口通讯上就是丢包。

2.2数据帧

在异步通信中，数据是一帧一帧（包括一个字符或一个字节数据）传送的，每一帧数据的格式如下表所示。

起始位 数据位 奇偶校验位 停止位
0 5-8位 可省 1

在帧格式中，一个字符由四个部分组成：起始位、数据位、奇偶校验位和停止位。首先是一个起始位（0），然后是5-8位数据（规定低位在前，高位在后），接下来是奇偶校验位（可省略），最后是停止位（1）。

起始位（0）信号只占用一位，用来通知设备一个待接收的数据准备到达。线路上在不传送字符时应保持为1。接收端不断检测线路的状态，若连续为以后又测得一个0，就知道后来一个新字符，应该马上接收。字符的起始位还被用作同步接收端的时钟，以保证以后的接收能正确进行。奇偶校验位只占一位，但在字符中也可以规定不用奇偶校验位，这一位可以省去。也可以用这一位来确定这一帧中的字符所代表信息的性质（地址数据等）。停止位用来表示数据的结束，它一定四高电位（1）。停止位可以是1位、1.5位或2位。接收端收到停止位后，知道上一字符已传送完毕，同时为准备接收下字符作好准备。只要接收到0，就是新的字符的起始位。若停止位以后不是紧接着传送下一个字符，则使电路电平保持高电平（1）。存在空闲位，正是异步通信的特征之一。

2.3通讯协议

要想保证通讯成功，通讯双方必须有一系列的约定。作为发送方，必须知道应该什么时候发送，发什么，对方是否接收到，收到的内容有没有错，要不要重发，怎样通知对方结束等等；作为接收方，必须知道对方是否发送了信息，发的是什么，收到的信息有没有错，如果有错，怎样通知对方重发。

这种约定就叫做通信规程或协议，它必须在编程之前确定下来。然后双方必须严格按照预先规定的协议，进行通讯。

比如通讯的起始头、地址位、数据长度、数据段、数据校验位、结束尾等。数据校验算法有CRC算法、异或算法。代码如下：

  1. /*
  2. 将16进制的字符转化为对应的十进制整数
  3. */
  4. HRESULT CCrc:: strHexToInt(BYTE byRecv, int& nData)
  5. {
  6.     nData = 0;
  8.     if(byRecv>=48 && byRecv<=57)
  9.     {
  10.         nData = byRecv - 48; 
  11.     }
  12.     else if(byRecv>=65 && byRecv<=70)
  13.     {
  14.         nData = byRecv - 55; 
  15.     }
  16.     else
  17.     {
  18.             return -1;
  19.     }
  20.     return S_OK;
  21. }
  22. /*
  23. 对字符串所对应的ASCII码进行CRC校验
  24. */
  25. HRESULT CCrc::CRCCheck(BYTE ucChar[], int commandLength, int nCRCData)
  26. {
  27.     WORD chCRC=0XFFFF;//初始化CRC校验    
  28.     for(int i=3;i<commandLength-3;i++)
  29.     {
  30.         chCRC=chCRC^ucChar[i];
  31.         for(int bits=0;bits<8;bits++)
  32.         {
  33.             if(chCRC&0X0001)
  34.             {   
  35.                 chCRC=chCRC>>1;
  36.                 chCRC=chCRC^nCRCData;
  37.             }
  38.             else
  39.                 chCRC=chCRC>>1;
  40.         }
  41.     }
  42.     WORD CRC,CRC2;//原校验码
  43.     CRC2=chCRC>>8;
  44.     CRC2+=chCRC<<8;
  45.     CRC=ucChar[commandLength-3];
  46.     CRC=CRC<<8;
  47.     CRC=CRC+ucChar[commandLength-2];
  48.     if(CRC==CRC2)
  49.         return S_OK;
  50.     else
  51.     return -1;
  52. }

3串口通讯例程序

有了上面的基础知识，我们来开发一个类似串口调试助手的小工具，以便对于WIN32 API的有一个直观认识，现在让我们开始我们的旅程吧！

打开串口，串口在WINDOWS 32位操作系统下也被认识是一种文件资源，但是这个文件资源不允许共享。代码如下：

  1. BOOL CSerialPort::OpenComm(CString strComm)
  2. {
  3.     if(m_hComm == NULL)
  4.     {
  5.         m_hComm = CreateFile((char*)(LPCSTR)strComm, GENERIC_READ | GENERIC_WRITE, 0, NULL,  OPEN_EXISTING, 
  6.             FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, 0); 
  7.         if(m_hComm == INVALID_HANDLE_VALUE)
  8.         {
  9.             int nError = GetLastError();
  10.             m_hComm = NULL;
  11.             AfxMessageBox("打开串口失败！");
  12.             return FALSE;
  13.         }
  14.     }
  15.     return TRUE;
  16. }

设置串口的属性，包括波特率、帧格式、超时属性等，代码如下：

  1. BOOL CSerialPort::SetCommState(DWORD dwBaudrate, BYTE byParity, BYTE byByteSize, BYTE byStopBits)
  2. {
  3.     DCB dcbOld;
  4.     int ret = ::GetCommState(m_hComm, &dcbOld);
  5.     if(ret == 0)
  6.     {
  7.         CloseHandle(m_hComm);
  8.         m_hComm = NULL;
  9.         return FALSE;   
  10.     }
  11.     dcbOld.BaudRate = dwBaudrate;
  12.     dcbOld.ByteSize = byByteSize;
  13.     dcbOld.Parity = byParity;
  14.     dcbOld.StopBits = byStopBits;
  15.     ret = ::SetCommState(m_hComm, &dcbOld);
  16.     if(ret == 0)
  17.     {
  18.         CloseHandle(m_hComm);
  19.         m_hComm = NULL;
  20.         return FALSE;   
  21.     }
  22.     return TRUE;
  23. }

设置缓冲大小，代码如下：

  1. BOOL CSerialPort::SetupComm(DWORD dwInQueue, DWORD dwOutQueue)
  2. {
  3.     return ::SetupComm(m_hComm, dwInQueue, dwOutQueue);
  4. }

清楚错误状态后，设置监视事件，代码如下：

  1. BOOL CSerialPort::PurgeComm(DWORD dwFlags)
  2. {
  3.     return ::PurgeComm(m_hComm, dwFlags);
  4. }
  6. BOOL CSerialPort::SetCommMask(DWORD dwEvtMask)
  7. {
  8.     return ::SetCommMask(m_hComm, dwEvtMask);
  9. }

串口设置完后，可以进行读写操作了，代码如下：

  1. BOOL CSerialPort::WriteFile( LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
  2. {
  3.     return ::WriteFile(m_hComm, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
  4. }
  6. BOOL CSerialPort::ReadFile(LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
  7. {
  8.     return ::ReadFile(m_hComm, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
  9. }

总体的调用代码如下：

  1. // 打开串口，并设置属性
  2. void CCommDemoDlg::OnBnClickedBtnCommcontrol()
  3. {       
  4.     CButton* pBtnCommControl = (CButton*)GetDlgItem(IDC_BTN_COMMCONTROL);
  5.     if(!m_bIsOpen)
  6.     {
  7.         CComboBox* pComboComm = (CComboBox*)GetDlgItem(IDC_COMBO_COMM);
  8.         int nSel = pComboComm->GetCurSel();
  9.         CString strComm;
  10.         pComboComm->GetLBText(nSel, strComm);
  11.         m_bIsOpen = m_serialPort.OpenComm(strComm); 
  12.         if(m_bIsOpen)
  13.         {
  14.             pBtnCommControl->SetWindowText("关闭串口");
  15.             CComboBox* pComboBaudrate = (CComboBox*)GetDlgItem(IDC_COMBO_BAUDRATE);
  16.             int nSel = pComboBaudrate->GetCurSel();
  17.             DWORD dwBaudrate = pComboBaudrate->GetItemData(nSel);
  19.             CComboBox* pComboCheckbit = (CComboBox*)GetDlgItem(IDC_COMBO_CHECKBIT);
  20.             nSel = pComboCheckbit->GetCurSel();
  21.             BYTE byParity = (BYTE)pComboCheckbit->GetItemData(nSel);
  23.             CComboBox* pComboDatabit = (CComboBox*)GetDlgItem(IDC_COMBO_DATABIT);
  24.             nSel = pComboDatabit->GetCurSel();
  25.             BYTE byDataSize = (BYTE)pComboDatabit->GetItemData(nSel);
  27.             CComboBox* pComboStopbit = (CComboBox*)GetDlgItem(IDC_COMBO_STOPBIT);
  28.             nSel = pComboStopbit->GetCurSel();
  29.             BYTE byStopBits = (BYTE)pComboStopbit->GetItemData(nSel);
  31.             BOOL bRet = m_serialPort.SetCommState(dwBaudrate, byParity, byDataSize, byStopBits);
  32.             if(!bRet)
  33.             {
  34.                 m_serialPort.CloseComm();
  35.                 AfxMessageBox("设置COMM属性出错！");
  36.                 return;
  37.             }
  39.             bRet = m_serialPort.SetupComm(1024, 1024);
  40.             if(!bRet)
  41.             {
  42.                 m_serialPort.CloseComm();
  43.                 AfxMessageBox("设置COMM输入输出缓冲区出错！");
  44.                 return;
  45.             }
  47.             bRet = m_serialPort.PurgeComm(PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
  48.             if(!bRet)
  49.             {
  50.                 m_serialPort.CloseComm();
  51.                 AfxMessageBox("无法清除COMM的错误状态！");
  52.                 return;
  53.             }
  55.             bRet = m_serialPort.SetCommMask(EV_RXCHAR);
  56.             if(!bRet)
  57.             {
  58.                 m_serialPort.CloseComm();
  59.                 AfxMessageBox("设置COMM的事件出错！");
  60.                 return;
  61.             }
  62.         }
  63.         else
  64.         {
  65.             pBtnCommControl->SetWindowText("打开串口");
  67.         }
  68.     }
  69.     else
  70.     {
  71.         m_bIsOpen = FALSE;
  72.         AfxMessageBox("已经有一个串口正在运行中，请关闭该串口！");
  73.         m_serialPort.CloseComm();
  74.         pBtnCommControl->SetWindowText("打开串口");
  75.     }
  76. }
  78. // 发送数据
  79. void CCommDemoDlg::OnBnClickedBtnSend()
  80. {
  81.     if(m_serialPort.m_hComm==NULL)
  82.     {
  83.         AfxMessageBox("请打开串口后发送数据！");
  84.         return;
  85.     }
  86.     CEdit* pEditSend = (CEdit*)GetDlgItem(IDC_EDIT_SEND);   
  87.     CEdit* pEditRecv = (CEdit*)GetDlgItem(IDC_EDIT_RECV);
  88.     DWORD dwWrite =0;
  89.     CString strSend, strRecv;
  90.     pEditSend->GetWindowText(strSend);
  91.     if(strSend.IsEmpty())
  92.     {
  93.         return;
  94.     }
  95.     OVERLAPPED m_OverlappedWrite;
  96.     ZeroMemory(&m_OverlappedWrite, sizeof(OVERLAPPED));
  97.     m_OverlappedWrite.hEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
  98.     m_serialPort.WriteFile((LPVOID)strSend.GetBuffer(strSend.GetLength()+1), strSend.GetLength()+1, &dwWrite, &m_OverlappedWrite);
  99.     pEditSend->SetWindowText("");
  100.     pEditRecv->GetWindowText(strRecv);
  101.     strRecv += strSend;
  102.     pEditRecv->SetWindowText(strRecv);
  103.     Sleep(10);
  104. }
  106. // 读线程
  107. UINT  CThreadSvr::ReadProc(LPVOID lpParameter)
  108. {
  109.     Sleep(100);
  110.     CThreadSvr* pThreadSvr = (CThreadSvr*)lpParameter;
  111.     int nLength = 0;
  112.     while(!pThreadSvr->bMainThreadExit)
  113.     {
  114.         Sleep(100);
  115.         EnterCriticalSection(&pThreadSvr->cs);
  116.         CCommDemoDlg* pCommDemoDlg = (CCommDemoDlg*)AfxGetApp()->m_pMainWnd;
  117.         if(pCommDemoDlg==NULL)
  118.         {
  119.             continue; // 对话框还没有创建成功，须等待其创建成功。
  120.         }
  121.         if(pCommDemoDlg->m_serialPort.m_hComm==NULL)
  122.         {
  123.             continue;
  124.         }
  126.         COMSTAT comStat ;
  127.         DWORD dwError = 0;
  128.         BOOL ret = TRUE;
  129.         DWORD dwRead = 0;
  130.         char recvTemp[512];
  131.         ZeroMemory(recvTemp, 512);
  132.         char recvBuf[4096];
  133.         ZeroMemory(recvBuf, 4096);
  135.         pCommDemoDlg->m_serialPort.ClearCommError(&dwError, &comStat);
  136.         if(comStat.cbInQue>0)
  137.         {
  138.             if(comStat.cbInQue<512)
  139.             {
  140.                 ret = pCommDemoDlg->m_serialPort.ReadFile(recvTemp, comStat.cbInQue, &dwRead, &pThreadSvr->m_OverlappedRead);
  141.             }
  142.             else
  143.             {
  144.                 ret = pCommDemoDlg->m_serialPort.ReadFile(recvTemp, 500, &dwRead, &pThreadSvr->m_OverlappedRead);
  145.             }
  146.             if(comStat.cbInQue>=dwRead)
  147.             {
  148.                 memcpy(recvBuf+nLength, recvTemp, dwRead);
  149.                 nLength += dwRead;
  150.             }
  151.             if(comStat.cbInQue>=dwRead)
  152.             {
  153.                 nLength = 0;
  154.                 CEdit* pEditRecv = (CEdit*)pCommDemoDlg->GetDlgItem(IDC_EDIT_RECV);
  155.                 CString strRecv;
  156.                 pEditRecv->GetWindowText(strRecv);
  157.                 strRecv += recvBuf;
  158.                 pEditRecv->SetWindowText(strRecv);
  159.             }
  160.             if(!ret)
  161.             {
  162.                 if(ERROR_IO_PENDING == GetLastError())
  163.                 {
  164.                     while ( !ret )
  165.                     {
  166.                         ret = pCommDemoDlg->m_serialPort.GetOverlappedResult(&pThreadSvr->m_OverlappedRead, &dwRead, TRUE);
  167.                         if ( GetLastError() != ERROR_IO_INCOMPLETE )
  168.                         {
  169.                             pCommDemoDlg->m_serialPort.ClearCommError(&dwError, &comStat);
  170.                             break;
  171.                         }
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.         LeaveCriticalSection(&pThreadSvr->cs);
  177.     }
  178.     return TRUE;
  179. }

最后调试助手的效果如下：

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞