#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <windows.h>
    #include <winnt.h>

    #define BAUD_RATE  9600
    #define COM1_BASE  ???                        /* com1基地址 */
    #define p  printf
   
    int main()
    {
    /*  打开串口  */
    Handle hCom;
   //    int pos;
    unsigned char  buff[128];                     //要传输串口数据到缓冲区

    /*  把串口作为文件打开  */
    hCom=CreateFile("COM1",                       //打开串口1
                GENERIC_READ|GENERIC_WRITE,       //允许读写
                0,                                //通讯设备必须以独占方式打开
                NULL,                             //安全属性
                OPEN_EXISTING,                    //通讯设备已存在
                FILE_FLAG_OVERLAPPED,             //异步I/O
                0,                                //通讯设备不能用模板打开
                NULL);   
    if(hCom==(HANDLE)-1)                          //打开串口失败返回
    {
    p("打开串口失败");
    return 0;
        }

    /*  串口超时结构体设置  */
     typedef COMMTIMEOUTS TimeOuts
    {
    TimeOuts.ReadIntervalTimeout=1000;            //接收时两字符之间的最大时延
    TimeOuts.ReadTotalTimeoutMultiplier=500;      //指定以毫秒为单位的累积值，用于计算读操作时的超时总数
    TimeOuts.ReadTotalTimeoutConstant=5000;       //指定以毫秒为单位的常数，用于计算读操作时的超时总数
    TimeOuts.WriteTotalTimeoutMultiplier=500;     //计算写操作时的超时总数
    TimeOuts.WriteTotalTimeoutConstant=2000       //计算写操作时的超时总数
     };
   
    if(!SetCommTimeouts(hCom,&TimeOuts))          //与串口绑定失败返回
    {
        p("与串口绑定失败")
        return 0;
    }
    /* 设置串口各项参数  */
    DCB dcb;
    {
        if(!GetCommState(hCom,&dcb))
            p("获取串口属性失败");
            return 0;
    }
    dcb.BaudRate=BAUD_RATE;     //波特率为9600
    dcb.ByteSize=8;             //设置数据位
    dcb.Parity=EVENPARITY;      //偶校验
    dcb.StopBits=2;             //两个停止位
    dcb.fBinary=TRUE;
    dcb.fParity=TRUE;

    if(!SetCommState(hCom,&dcb))                  //DCB绑定失败返回
    {
        p("串口设置出错！");
        return 0;
    }
   
    if(!SetupComm(hCom,1024,1024))                //设置串口的输入/输出缓冲区大小
    {
    p("设置串口读写缓冲区失败");
    return 0;
    }
    PurgeComm(hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);  //终止所有的后台读写操作并清空缓冲区
   
   /*  发送数据操作  */
    if(WriteFile(hCom,         //文件句柄
        outputData,            //数据缓冲区指针
        sizeBuffer,            //字节数
        &length,               //接收成功发送数据长度的指针
        NULL)==0)              //重叠I/O结构体        
    {
    p("写入串口数据失败");
    return FALSE;
    }

    /*  接收数据  */
        if(ReadFile(hCom,      //文件句柄
        inputData,             //数据缓冲区指针
        sizeBuffer,            //字节数
        &length,               //指向已经读入的字节数
        NULL)==0)              //重叠I/O结构体      
            
    {
    p("读取串口数据失败");
    return FALSE;
    }

   /*  关闭串口  */
   bool CloseHandle
        (
        hCom
        ); //关闭设备句柄
            
      

谢谢！

#include <windows.h>  
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <commdlg.h>
    #include <windef.h>

  

    #define BAUD_RATE  9600
    #define p  printf
    #define  size  1024                           //数据缓冲区大小

    int nread,nwrite;
  
    void main()
    {
    HANDLE hCom;
    COMMTIMEOUTS timeouts;
    COMMCONFIG dcb;
    char *buffRead;
    char *buffWrite;
    DWORD dwBytesWritten,dwBytesRead;
   
    retry:
    /*  把串口作为文件打开  */
    hCom=CreateFile("COM1",                       //打开串口1
                GENERIC_READ|GENERIC_WRITE,       //允许读写
                0,                                //通讯设备必须以独占方式打开
                NULL,                             //安全属性
                OPEN_EXISTING,                    //通讯设备已存在
                FILE_FLAG_OVERLAPPED,             //异步I/O                                             
                NULL);   
    if(hCom==(HANDLE)-1)                          //打开串口失败返回
    {
        if(GetLastError()==ERROR_FILE_NOT_FOUND)
        {
            p("serial port does exist.\n");
        }
        p("some other error occured, Inform user.\n");
    }
    else
        p("port open successed!\n");


    /*  串口超时结构体设置  */
    SetCommTimeouts(hCom,&timeouts);
    //COMMTIMEOUTS timeouts={0};
   
    timeouts.ReadIntervalTimeout=1000;            //接收时两字符之间的最大时延
    timeouts.ReadTotalTimeoutMultiplier=500;      //指定以毫秒为单位的累积值，用于计算读操作时的超时总数
    timeouts.ReadTotalTimeoutConstant=5000;       //指定以毫秒为单位的常数，用于计算读操作时的超时总数
    timeouts.WriteTotalTimeoutMultiplier=500;     //计算写操作时的超时总数
    timeouts.WriteTotalTimeoutConstant=2000;       //计算写操作时的超时总数
     
    if(!SetCommTimeouts(hCom,&timeouts))          //与串口绑定失败返回
    {
        p("error setting port state.\n");
    }
   
    /* 设置串口各项参数  */
    if(!GetCommState(hCom,&dcb.dcb))
    {
    p("error setting serial port state.\n");  //串口绑定失败
    }
    dcb.dcb.BaudRate=BAUD_RATE;     //波特率为9600
    dcb.dcb.ByteSize=8;             //设置数据位
    dcb.dcb.Parity=EVENPARITY;      //偶校验
    dcb.dcb.StopBits=2;             //两个停止位
    dcb.dcb.fBinary=TRUE;
    dcb.dcb.fParity=TRUE;

    if(!SetCommState(hCom,&dcb.dcb))                  //DCB绑定失败返回
    {
        p("串口设置出错！");
    }
   
/*    /*  设置串口输入输出缓冲区  
    if(!SetupComm(hCom,1024,1024))                //设置串口的输入/输出缓冲区大小
    {
    p("设置串口读写缓冲区失败");
    }
    PurgeComm(hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);  //终止所有的后台读写操作并清空缓冲区   */
   
    /*  将数据写入缓冲区操作  */
    buffWrite=(char *)malloc(size);             //输入缓冲区分配
        p("please input yourdata:");
    scanf("%s",buffWrite);
    nwrite=255;                                 //nwrite=1024
     
    if(!WriteFile(hCom,buffWrite,nwrite,&dwBytesWritten,NULL))
    {
        p("error writting to output buffer.\n");
    }
    else
        p("written data:%s\n",buffWrite);
        system("pause");                       //调用系统命令pause,输出类似于“press any key to exit”的字

    /*  从输出缓冲区读取数据操作  */
    // buffRead=0;
       buffRead=(char *)malloc(size);

    /*  在缓冲区设置当前的读写位置  */
         SetFilePointer(hCom,                 //问价句柄
             0,                               //偏移量（低位）
             0,                               //偏移量（高位）
             FILE_BEGIN);                     //基准位置
     nread=GetFileSize(hCom,NULL);            
     buffRead=(char *)malloc(nread+1);
     memset(buffRead,0,size);                 //将缓冲区的前1024个字节用0代替，相当于初始化

     if(!ReadFile(hCom,buffRead,nread,&dwBytesRead,NULL))
     {
     p("error reading from input buffer.\n");
     }
     else
         p("Data read from read buffer is:%s\n",buffRead);

    /*  关闭串口  */
  CloseHandle
        (
        hCom        //关闭设备句柄
        );
         
  Sleep(2000);
  goto retry;
  }
      
我在那个程序基础上又编写了一个，但是在读取缓冲区数据时出现错误，能再帮我改正一下吗？

编译是通过的，但就是运行读取缓冲区的数据时会出现乱码，运行两次后窗口出现错误，直接关闭。

[ 本帖最后由 一叶扁舟2014 于 2014-4-7 16:11 编辑 ]

不应该吧！下位机通过串口调试助手发送数据，波特率直接设置的就是9600啊。

麻烦你了，非常感谢！

/*  串口初始化程序  cominit.c   */  

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define BAUD_RATE 9600
#define pr printf
        
void  serialinit(int hcom)
{
   
    COMMTIMEOUTS timeouts;            //超时函数设置
    COMMCONFIG dcb;                   //dcb的参数配置

    /*  把串口作为文件打开  */
    hcom=CreateFile("COM1",               //打开串口1，hcom为串口句柄
        GENERIC_READ|GENERIC_WRITE,       //允许读写
        0,                                //通讯设备必须以独占方式打开
        NULL,                             //安全属性
        OPEN_EXISTING,                    //通讯设备已存在
        0,                                //异步I/O  /*FILE_FLAG_OVERLAPPED*/                  
        NULL);  
   
    if(hcom==(HANDLE)-1)                  //打开串口失败返回
    {
        if(GetLastError()==ERROR_FILE_NOT_FOUND)
        {
            pr("serial port does exist.\n");
        }
        pr("some other error occured, Inform user.\n");
    }
    else
        pr("port open successed!\n");
   
    /*  串口超时结构体设置  */
    SetCommTimeouts(hcom,&timeouts);
    //COMMTIMEOUTS timeouts={0};
   
    timeouts.ReadIntervalTimeout=1000;            //接收时两字符之间的最大时延
    timeouts.ReadTotalTimeoutMultiplier=500;      //指定以毫秒为单位的累积值，用于计算读操作时的超时总数
    timeouts.ReadTotalTimeoutConstant=5000;       //指定以毫秒为单位的常数，用于计算读操作时的超时总数
    timeouts.WriteTotalTimeoutMultiplier=500;     //计算写操作时的超时总数
    timeouts.WriteTotalTimeoutConstant=2000;       //计算写操作时的超时总数
   
    if(!SetCommTimeouts(hcom,&timeouts))          //与串口绑定失败返回
    {
        pr("error setting port state.\n");
    }
   
    /* 设置串口各项参数  */
    if(!GetCommState(hcom,&dcb.dcb))
    {
        pr("error setting serial port state.\n");  //串口绑定失败
    }
    dcb.dcb.BaudRate=BAUD_RATE;     //波特率为9600
    dcb.dcb.ByteSize=8;             //设置数据位
    dcb.dcb.Parity=EVENPARITY;      //偶校验
    dcb.dcb.StopBits=1;             //一个停止位
    dcb.dcb.fBinary=TRUE;
    dcb.dcb.fParity=TRUE;
   
    if(!SetCommState(hcom,&dcb.dcb))                  //DCB绑定失败返回
    {
        pr("串口设置出错!\n");
    }
}

   
/*=======================================*/
/*          depthrecv.c                  */
/*   数据接收程序，调用串口初始化程序    */
/*          hcom6对应串口描述符          */
/*=======================================*/

#include <string.h>
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include "cominit.c"


  #define size6 30
  #define pr printf
  char com[7];                          //串口接收的数据帧
// char depth_str1={"00000000"};        //截取后的数据帧，初始值为零

  //float depth1;                         //浮点型深度数据

  extern void serialinit(int hcom);
  
  void main()
  {  int hcom6;
     int nwrite;
     int inum=0,temp=0;
     int depthstate=1;
     char *readbuff6;                   //数据接收缓冲区
     char *writebuff6;                  //数据写入缓冲区
     int pos=0;
     DWORD dwBytesWritten,dwBytesRead;
     serialinit(hcom6);
      
     /* 设置串口输入输出缓冲区  */  
     if(!SetupComm(hcom6,1024,1024))
     {
         pr("设置串口读写缓冲区失败!\n");
     }
     PurgeComm(hcom6,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR);

    /*  将数据写入缓冲区操作  */
    writebuff6=(char *)malloc(size6);
    pr("please input your data:");
     scanf("%s",writebuff6);
    nwrite=0;
   for(temp = 0;writebuff6[temp]!='\0';temp++)
    {
        nwrite++;
    }
    if(!WriteFile(hcom6,writebuff6,nwrite,&dwBytesWritten,NULL))
     { pr("error writting to output buffer.\n");}
     else
       pr("written data:%s\n",writebuff6);
       system("pause");
   
    /* 从输出缓冲区读数据 */
    readbuff6=(char *)malloc(size6);  
    memset(readbuff6,0,size6);            //将缓冲区的前size6个字节用0代替，相当于初始化
    if(!ReadFile(hcom6,readbuff6,size6,&dwBytesRead,NULL))
    {   pr("error reading from input buffer\n");
    }
    else  
        pr("Data read from buffer is:%s\n",readbuff6);
    /*  关闭串口  */
    CloseHandle(hcom6);  //关闭设备句柄
    free(readbuff6);
    free(writebuff6);
 }