设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › C语言读取模块实例程序VS2010
返回列表 发新帖
查看: 3787|回复: 0
收起左侧

C语言读取模块实例程序VS2010

[复制链接]
ID:114240 发表于 2016-4-15 18:24 | 显示全部楼层 |阅读模式
========================================================================
    控制台应用程序：UARTTest 项目概述
========================================================================

应用程序向导已为您创建了此 UARTTest 应用程序。

本文件概要介绍组成 UARTTest 应用程序的每个文件的内容。


UARTTest.vcxproj
    这是使用应用程序向导生成的 VC++ 项目的主项目文件，
    其中包含生成该文件的 Visual C++
    的版本信息，以及有关使用应用程序向导选择的平台、配置和项目功能的信息。

UARTTest.vcxproj.filters
    这是使用“应用程序向导”生成的 VC++ 项目筛选器文件。
    它包含有关项目文件与筛选器之间的关联信息。 在 IDE
    中，通过这种关联，在特定节点下以分组形式显示具有相似扩展名的文件。
    例如，“.cpp”文件与“源文件”筛选器关联。

UARTTest.cpp
    这是主应用程序源文件。

/////////////////////////////////////////////////////////////////////////////
其他标准文件：

StdAfx.h，StdAfx.cpp
    这些文件用于生成名为 UARTTest.pch 的预编译头 (PCH) 文件和
    名为 StdAfx.obj 的预编译类型文件。

/////////////////////////////////////////////////////////////////////////////
其他注释：

应用程序向导使用“TODO:”注释来指示应添加或自定义的源代码部分。

/////////////////////////////////////////////////////////////////////////////


  1. #include <stdafx.h>
  2. #include <stdio.h>
  3. #include <tchar.h>
  4. #include <windows.h>
  5. #include "Com.h"

  7. #define                TOTAL_PORT_NUM                65
  8. #define                START_PORT_NUM                0

  10. #define                iBufferSize 250
  11. #define     UARTBufferLength 98304
  12. #undef  SYNCHRONOUS_MODE

  14. static HANDLE                 hComDev[TOTAL_PORT_NUM]         ={NULL};
  15. static unsigned long long ulComMask = 0;
  16. static HANDLE                 hCOMThread[TOTAL_PORT_NUM]      ={NULL};
  17. static OVERLAPPED         stcWriteStatus[TOTAL_PORT_NUM]  = {0};
  18. static OVERLAPPED         stcReadStatus[TOTAL_PORT_NUM]   = {0};

  20. #ifdef SYNCHRONOUS_MODE
  21. static HANDLE                 hReceiveEvent[TOTAL_PORT_NUM]   ={NULL};
  22. #endif

  24. static volatile char chrUARTBuffers[TOTAL_PORT_NUM][UARTBufferLength]={0};
  25. static volatile unsigned long ulUARTBufferStart[TOTAL_PORT_NUM]={0}, ulUARTBufferEnd[UARTBufferLength]={0};

  27. unsigned short CollectUARTData(const unsigned long ulCOMNo,char chrUARTBufferOutput[])
  28. {
  29.         unsigned long ulLength=0;
  30.         unsigned long ulEnd ;
  31.         unsigned long ulStart ;

  33. #ifdef SYNCHRONOUS_MODE
  34.         WaitForSingleObject(hReceiveEvent[ulIndexCorrect],INFINITE);
  35.         ResetEvent(hReceiveEvent[ulIndexCorrect]);
  36. #endif
  37.         ulEnd = ulUARTBufferEnd[ulCOMNo];
  38.         ulStart = ulUARTBufferStart[ulCOMNo];
  39.         if (ulEnd == ulStart)
  40.                 return(0);
  41.         if (ulEnd > ulStart)
  42.         {
  43.                 memcpy((void*)chrUARTBufferOutput,(void*)(chrUARTBuffers[ulCOMNo]+ulStart),ulEnd-ulStart);
  44.                 ulLength = ulEnd-ulStart;
  45.         }
  46.         else
  47.         {
  48.                 memcpy((void*)chrUARTBufferOutput,(void*)(chrUARTBuffers[ulCOMNo]+ulStart),UARTBufferLength-ulStart);
  49.                 if ( ulEnd != 0 )
  50.                 {
  51.                         memcpy((void*)(chrUARTBufferOutput+(UARTBufferLength-ulStart)),(void*)chrUARTBuffers[ulCOMNo],ulEnd);
  52.                 }
  53.                 ulLength = UARTBufferLength+ulEnd-ulStart;
  54.         }
  55.         ulUARTBufferStart[ulCOMNo] = ulEnd;
  56.         return (unsigned short) ulLength;
  57. }

  59. signed char SendUARTMessageLength(const unsigned long ulChannelNo, const char chrSendBuffer[],const unsigned short usLen)
  60. {
  61.         DWORD iR;
  62.         DWORD dwRes;
  63.         DCB dcb;
  64.         char chrDataToSend[1000] = {0};
  65.         memcpy(chrDataToSend,chrSendBuffer,usLen);
  66.         memcpy(&chrDataToSend[usLen],chrSendBuffer,usLen);

  68.         GetCommState(hComDev[ulChannelNo] ,&dcb);
  69.         dcb.fDtrControl = 0;//DTR = 1;发送
  70.         SetCommState(hComDev[ulChannelNo] ,&dcb);

  72.         if ( WriteFile(hComDev[ulChannelNo],chrSendBuffer,usLen,&iR,&(stcWriteStatus[ulChannelNo])) || GetLastError() != ERROR_IO_PENDING  )
  73.                 return -1;
  74.         dwRes = WaitForSingleObject(stcWriteStatus[ulChannelNo].hEvent,1000);
  75.         Sleep(10);
  76.         dcb.fDtrControl = 1;//DTR = 0;接收
  77.         SetCommState(hComDev[ulChannelNo] ,&dcb);
  78.         Sleep(10);

  80.         if(dwRes != WAIT_OBJECT_0 || ! GetOverlappedResult(hComDev[ulChannelNo], &stcWriteStatus[ulChannelNo], &iR, FALSE))
  81.                 return 0;
  82.         return 0;
  83. }

  85. DWORD WINAPI ReceiveCOMData(PVOID pParam)
  86. {
  87.         unsigned long uLen;
  88.         unsigned long ulLen1;
  89.         unsigned long ulLen2;
  90.         DWORD        dwRes;
  91.         COMSTAT Comstat;
  92.         DWORD dwErrorFlags;
  93.         char chrBuffer[iBufferSize]={0};
  94.         unsigned long ulUARTBufferEndTemp=ulUARTBufferEnd[0];

  96.         unsigned long ulComNumber = 0;
  97.         memcpy(&ulComNumber,pParam,4);


  100.         while (1)
  101.         {
  102.                 if ( ! ReadFile(hComDev[ulComNumber],chrBuffer,iBufferSize-1,&uLen,&(stcReadStatus[ulComNumber])) )
  103.                 {
  104.                         dwRes = GetLastError() ;
  105.                         if ( dwRes != ERROR_IO_PENDING)
  106.                         {
  107.                                 ClearCommError(hComDev[ulComNumber],&dwErrorFlags,&Comstat);
  108.                                 continue;
  109.                         }

  111.                         WaitForSingleObject(stcReadStatus[ulComNumber].hEvent,INFINITE);
  112.                         if ( !GetOverlappedResult(hComDev[ulComNumber], &(stcReadStatus[ulComNumber]), &uLen, FALSE))
  113.                                 continue;
  114.                         if(uLen <= 0)
  115.                                 continue;
  116.                         if ( (ulUARTBufferEndTemp + uLen) > UARTBufferLength )
  117.                         {
  118.                                 ulLen1 = UARTBufferLength - ulUARTBufferEndTemp;
  119.                                 ulLen2 = uLen - ulLen1;
  120.                                 if (ulLen1 > 0)
  121.                                 {
  122.                                         memcpy((void *)&chrUARTBuffers[ulComNumber][ulUARTBufferEnd[ulComNumber]],(void *)chrBuffer,ulLen1);
  123.                                 }
  124.                                 if (ulLen2 > 0)
  125.                                 {
  126.                                         memcpy((void *)&chrUARTBuffers[ulComNumber][0],(void *)(chrBuffer+ulLen1),ulLen2);
  127.                                 }
  128.                                 ulUARTBufferEndTemp = ulLen2;
  129.                         }
  130.                         else
  131.                         {
  132.                                 memcpy((void *)&chrUARTBuffers[ulComNumber][ulUARTBufferEnd[ulComNumber]],(void *)chrBuffer,uLen);
  133.                                 ulUARTBufferEndTemp+=uLen;       
  134.                         }

  136.                         if (  ulUARTBufferEndTemp == ulUARTBufferStart[ulComNumber])
  137.                         {
  138.                                 printf("Error!");
  139.                         }
  140.                         else
  141.                         {
  142.                                 ulUARTBufferEnd[ulComNumber] = ulUARTBufferEndTemp;
  143.                         }

  145. #ifdef SYNCHRONOUS_MODE
  146.                         SetEvent(hReceiveEvent[ucComNumber]);
  147. #endif
  148.                         continue;
  149.                 }

  151.                 if(uLen <= 0)
  152.                         continue;
  153.                 if ( (ulUARTBufferEndTemp + uLen) > (UARTBufferLength) )
  154.                 {
  155.                         ulLen1 = UARTBufferLength - ulUARTBufferEndTemp;
  156.                         ulLen2 = uLen - ulLen1;
  157.                         if (ulLen1 > 0)
  158.                         {
  159.                                 memcpy((void *)&chrUARTBuffers[ulComNumber][ulUARTBufferEnd[ulComNumber]],(void *)chrBuffer,ulLen1);
  160.                         }
  161.                         if (ulLen2 > 0)
  162.                         {
  163.                                 memcpy((void *)&chrUARTBuffers[ulComNumber][0],(void *)(chrBuffer+ulLen1),ulLen2);
  164.                         }
  165.                         ulUARTBufferEndTemp = ulLen2;
  166.                 }
  167.                 else
  168.                 {
  169.                         memcpy((void *)&chrUARTBuffers[ulComNumber][ulUARTBufferEnd[ulComNumber]],(void *)chrBuffer,uLen);
  170.                         ulUARTBufferEndTemp+=uLen;       
  171.                 }

  173.                 if (  ulUARTBufferEndTemp== ulUARTBufferStart[ulComNumber])
  174.                 {
  175.                         printf("Error!");
  176.                 }
  177.                 else
  178.                 {
  179.                         ulUARTBufferEnd[ulComNumber] = ulUARTBufferEndTemp;
  180.                 }       

  182. #ifdef SYNCHRONOUS_MODE
  183.                 SetEvent(hReceiveEvent[ucComNumber]);
  184. #endif

  186.         }
  187.         return 0;
  188. }

  190. signed char OpenCOMDevice(const unsigned long ulPortNo,const unsigned long ulBaundrate)
  191. {
  192.         DWORD dwThreadID,dwThreadParam;
  193.         COMSTAT Comstat;
  194.         DWORD dwErrorFlags;
  195.         DWORD dwRes;
  196.         DCB dcb;
  197.         COMMTIMEOUTS comTimeOut;
  198.         TCHAR PortName[10] = {'\\','\\','.','\\','C','O','M',0,0,0};//"\\\\.\\COM";
  199.         TCHAR chrTemple[5]={0};

  201.         if(ulPortNo >= TOTAL_PORT_NUM)
  202.         {
  203.                 printf("\nerror: exceed the max com port num\n");
  204.                 return -1;
  205.         }


  208.         _itot(ulPortNo+START_PORT_NUM,chrTemple,10);
  209.         _tcscat(PortName,chrTemple);

  211.         if((hComDev[ulPortNo] = CreateFile(PortName,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED ,NULL))==INVALID_HANDLE_VALUE)
  212.         {
  213.                 dwRes=GetLastError();
  214.                 return -1;
  215.         }
  216.         ulComMask |= 1<<ulPortNo;

  218.         SetupComm(hComDev[ulPortNo] ,iBufferSize,iBufferSize);
  219.         GetCommState(hComDev[ulPortNo] ,&dcb);
  220.                 dcb.BaudRate = ulBaundrate;
  221.         dcb.fParity = NOPARITY;
  222.         dcb.ByteSize=8;
  223.         dcb.fDtrControl = 1;//DTR = 0;接收
  224.         dcb.fRtsControl = 0;//RTS = 0;接收
  225.         dcb.StopBits=ONESTOPBIT;

  227.         SetCommState(hComDev[ulPortNo] ,&dcb);
  228.         ClearCommError(hComDev[ulPortNo] ,&dwErrorFlags,&Comstat);
  229.         dwRes = GetLastError();

  231.         comTimeOut.ReadIntervalTimeout = 5;                               
  232.         comTimeOut.ReadTotalTimeoutMultiplier = 10;               
  233.         comTimeOut.ReadTotalTimeoutConstant = 100;               
  234.         comTimeOut.WriteTotalTimeoutMultiplier = 5;               
  235.         comTimeOut.WriteTotalTimeoutConstant = 5;               
  236.         SetCommTimeouts(hComDev[ulPortNo] ,&comTimeOut);       

  238.         stcWriteStatus[ulPortNo] .hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  239.         stcReadStatus[ulPortNo] .hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
  240.         stcReadStatus[ulPortNo].Internal = 0;
  241.         stcReadStatus[ulPortNo].InternalHigh = 0;
  242.         stcReadStatus[ulPortNo].Offset = 0;
  243.         stcReadStatus[ulPortNo].OffsetHigh = 0;
  244.         dwThreadParam = ulPortNo;
  245.         hCOMThread[dwThreadParam] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ReceiveCOMData,&dwThreadParam,0,&dwThreadID);
  246.         SetThreadPriority(hCOMThread[ulPortNo],THREAD_PRIORITY_NORMAL);
  247.         Sleep(200);

  249.         return 0;

  251. }

  253. signed char SetBaundrate(const unsigned long ulPortNo,const unsigned long ulBaundrate)
  254. {

  256.         DCB dcb;       
  257.         GetCommState(hComDev[ulPortNo] ,&dcb);
  258.         dcb.BaudRate = ulBaundrate;
  259.         SetCommState(hComDev[ulPortNo] ,&dcb);
  260.         return 0;

  262. }
  263. void CloseCOMDevice()
  264. {
  265.         unsigned char i;
  266.         for(i=0 ; i<sizeof(ulComMask)*8 ; i++)
  267.         {
  268.                 if((ulComMask & (1<<i))==0)
  269.                         continue;
  270.                 ulUARTBufferEnd[i] = 0;ulUARTBufferStart[i]=0;
  271.                 TerminateThread(hCOMThread[i],0);
  272.                 WaitForSingleObject(hCOMThread[i],10000);
  273.                 PurgeComm(hComDev[i],PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);
  274.                 CloseHandle(stcReadStatus[i].hEvent);
  275.                 CloseHandle(stcWriteStatus[i].hEvent);
  276.                 CloseHandle(hComDev[i]);
  277.         }
  278.         ulComMask = 0;
  279. }
复制代码


单片机

单片机多模块.rar

22.29 KB, 下载次数: 11, 下载积分: 黑币 -5

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表