精华内容
下载资源
问答
  • C#编写串口程序(详细教程) 中文PDF版,侧可以正常使用。C#编写串口程序(详细教程) 中文PDF版
  • matlab编写串口程序代码CGNS4分钟 介绍 CGNS4m (以前称为mexCGNS )使您可以借助MATLAB或GNU Octave来访问(aka cgnslib )的串行API提供的几乎所有功能。 它还提供了两个高级功能readcgns和writecgns用于读写基于...
  • C#编写串口程序(详细教程)
  • Pyserial-Demo 串口程序源代码,使用PyQt5编写
  • C#编写串口程序(详细教程)

    万次阅读 2017-11-20 17:00:22
    https://wenku.baidu.com/view/8c6822f9a0116c175e0e4823.html
    https://wenku.baidu.com/view/8c6822f9a0116c175e0e4823.html
    展开全文
  • 夏夜星语电子科技工作室 ... } catch (Exception { lblStatus.Text = "关闭串口时发生错误; } } } private void sp_DataReceived(object sender, SerialDataReceivedEventArgs e { System.Threading.Thread.Sleep(10
  • C# 编写串口程序

    千次阅读 2017-11-14 00:02:50
    最近参考百度《C#编写串口程序》的pdf做了一个串口调试工具,以此为模版用于开发更复杂的上位机软件,PDF中叙述很完整。需要了解编写过程的请认真看资料。 下面阐述一下几点: (1)需要调用serialPort类 ...

           最近参考百度《C#编写串口程序》的pdf做了一个串口调试工具,以此为模版用于开发更复杂的上位机软件,PDF中叙述很完整。需要了解编写过程的请认真看资料。


    下面阐述一下几点:

    (1)需要调用serialPort类         https://msdn.microsoft.com/zh-cn/library/system.io.ports.serialport(v=vs.110).aspx

          示例代码:

    public static void Main()
    {
        string name;
        string message;
        StringComparer stringComparer = StringComparer.OrdinalIgnoreCase;
        Thread readThread = new Thread(Read);
    
        // Create a new SerialPort object with default settings.
        _serialPort = new SerialPort();
    
        // Allow the user to set the appropriate properties.
        _serialPort.PortName = SetPortName(_serialPort.PortName);
        _serialPort.BaudRate = SetPortBaudRate(_serialPort.BaudRate);
        _serialPort.Parity = SetPortParity(_serialPort.Parity);
        _serialPort.DataBits = SetPortDataBits(_serialPort.DataBits);
        _serialPort.StopBits = SetPortStopBits(_serialPort.StopBits);
        _serialPort.Handshake = SetPortHandshake(_serialPort.Handshake);
    
        // Set the read/write timeouts
        _serialPort.ReadTimeout = 500;
        _serialPort.WriteTimeout = 500;
    
        _serialPort.Open();
        _continue = true;
        readThread.Start();
    
        Console.Write("Name: ");
        name = Console.ReadLine();
    
        Console.WriteLine("Type QUIT to exit");
    
        while (_continue)
        {
            message = Console.ReadLine();
    
            if (stringComparer.Equals("quit", message))
            {
                _continue = false;
            }
            else
            {
                _serialPort.WriteLine(
                    String.Format("<{0}>: {1}", name, message));
            }
        }
    
        readThread.Join();
        _serialPort.Close();
    }
    
    public static void Read()
    {
        while (_continue)
        {
            try
            {
                string message = _serialPort.ReadLine();
                Console.WriteLine(message);
            }
            catch (TimeoutException) { }
        }
    }
    (2)serialDataReceivedEventHandler委托: https://msdn.microsoft.com/zh-cn/library/system.io.ports.serialport.datareceived(v=vs.110).aspx#示例

    用来处理接受的数据。

    using System;
    using System.IO.Ports;
    
    class PortDataReceived
    {
        public static void Main()
        {
            SerialPort mySerialPort = new SerialPort("COM1");
    
            mySerialPort.BaudRate = 9600;
            mySerialPort.Parity = Parity.None;
            mySerialPort.StopBits = StopBits.One;
            mySerialPort.DataBits = 8;
            mySerialPort.Handshake = Handshake.None;
            mySerialPort.RtsEnable = true;
    
            mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
    
            mySerialPort.Open();
    
            Console.WriteLine("Press any key to continue...");
            Console.WriteLine();
            Console.ReadKey();
            mySerialPort.Close();
        }
    
        private static void DataReceivedHandler(
                            object sender,
                            SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string indata = sp.ReadExisting();
            Console.WriteLine("Data Received:");
            Console.Write(indata);
        }
    }

    (3)try   catch

    try-catch 语句由一个 try 块后跟一个或多个 catch 子句构成,这些子句指定不同的异常处理程序。


    下面是项目的完整代码:

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    using System.IO.Ports;
    
    namespace 串口配置工具
    {
        public partial class FormMain : Form
        {
            SerialPort sp = null;//声明串口类
            bool isOpen = false;//打开串口标志位
            bool isSetProperty = false;//属性设置标志位
            bool isHex = false;//十六进制显示标志位
            public FormMain()
            {
                InitializeComponent();
            }
            //初始化配置
            private void FormMain_Load(object sender, EventArgs e)
            {
                this.MaximumSize = this.Size;
                this.MinimumSize = this.Size;
                this.MaximizeBox = false;//禁止用最大化
    
                int i;
                for (i = 0; i < 15; i++)//最大支持到串口15,根据需求添加
                {
                    cbxCOMPort.Items.Add("COM" + (i + 1).ToString());
                }
                cbxCOMPort.SelectedIndex = 0;
    
                //列出常用的波特率
                cbxBaudRate.Items.Add("1200");
                cbxBaudRate.Items.Add("2400");
                cbxBaudRate.Items.Add("4800");
                cbxBaudRate.Items.Add("9600");
                cbxBaudRate.Items.Add("19200");
                cbxBaudRate.Items.Add("38400");
                cbxBaudRate.Items.Add("43000");
                cbxBaudRate.Items.Add("56000");
                cbxBaudRate.Items.Add("57600");
                cbxBaudRate.Items.Add("115200");
                cbxBaudRate.SelectedIndex = 3;
                //列出停止位
                cbxStopBits.Items.Add("0");
                cbxStopBits.Items.Add("1");
                cbxStopBits.Items.Add("1.5");
                cbxStopBits.Items.Add("2");
                cbxStopBits.SelectedIndex = 1;
                //列出奇偶校验位
                cbxParity.Items.Add("无");
                cbxParity.Items.Add("奇校验");
                cbxParity.Items.Add("偶校验");
                cbxParity.SelectedIndex = 0;
                //列出数据位
                cbxDataBits.Items.Add("8");
                cbxDataBits.Items.Add("7");
                cbxDataBits.Items.Add("6");
                cbxDataBits.Items.Add("5");
                cbxDataBits.SelectedIndex = 0;
                //默认显示char
                rbnChar.Checked = true;
            }
            //串口检测
            private void btnCheckCOM_Click(object sender, EventArgs e)//检测那些串口可用
            {
                bool comExistence = false;//有可用串口标志位
                cbxCOMPort.Items.Clear();
                
                for (int i = 0; i < 15; i++)
                {
                    try
                    {
                        SerialPort sp = new SerialPort("COM" + (i + 1).ToString());
                        sp.Open();
                        sp.Close();
                        cbxCOMPort.Items.Add("COM" + (i + 1).ToString());
                        comExistence = true;
    
                    }
                    catch (Exception)
                    {
                        continue;
                    }
    
                }
    
                if (comExistence)
                {
                    cbxCOMPort.SelectedIndex = 0;
                }
                else
                {
                    MessageBox.Show("没有找到串口!", "错误提示");
                }
    
            }
    
           
    
            /私有函数
            /*        检测串口是否设置        */
            private bool CheckPortSetting()
            {
                
                if (cbxCOMPort.Text.Trim() == "") return false;
                if (cbxBaudRate.Text.Trim() == "") return false;
                if (cbxDataBits.Text.Trim() == "") return false;
                if (cbxParity.Text.Trim() == "") return false;
                if (cbxStopBits.Text.Trim() == "") return false;
                return true;
            }
            /私有函数
            /*        检测发送数据        */
            private bool CheckSendData()
            {
                if (cbxCOMPort.Text.Trim() == "") return false;
                return true;
            }
            /私有函数
            /*       设置串口的属性        */
            private void SetPortProperty()
            {
                sp = new SerialPort();
                sp.PortName = cbxCOMPort.Text.Trim();//串口名称
                sp.BaudRate = Convert.ToInt32(cbxBaudRate.Text.Trim());//波特率
    
                float f = Convert.ToSingle(cbxStopBits.Text.Trim());//设置停止位
                if (f == 0)
                {
                    sp.StopBits = StopBits.None;
                }
                else if (f == 1.5)
                {
                    sp.StopBits = StopBits.OnePointFive;
                }
                else if (f == 1)
                {
                    sp.StopBits = StopBits.One;
                }
                else if (f == 2)
                {
                    sp.StopBits = StopBits.Two;
                }
                else
                {
                    sp.StopBits = StopBits.One;
                }
    
                sp.DataBits = Convert.ToInt16(cbxDataBits.Text.Trim());//设置数据位
                string s = cbxParity.Text.Trim();//设置奇偶位
    
                if (s == "无")
                {
                    sp.Parity = Parity.None;
                }
                else if (s == "奇校验")
                {
                    sp.Parity = Parity.Odd;
                }
                else if (s == "偶校验")
                {
                    sp.Parity = Parity.Even;
                }
                else
                {
                    sp.Parity = Parity.None;
                }
    
                sp.ReadTimeout = -1;//设置超时读取函数
                sp.RtsEnable = true;
    
                //定义 DataReceive 事件
    
                sp.ReceivedBytesThreshold = 1;
    
                sp.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);//该方法加载就运行,
    
                if (rbnHex.Checked)
                {
                    
                    isHex = true;
                }
                else
                {
                    isHex = false;
                }
    
    
            }
    
            private void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
            {
    
    
                System.Threading.Thread.Sleep(100);//延时100ms等待数据接收
    
    
                this.Invoke((EventHandler)(delegate
                {
                    if (isHex == false)
                    {
    
                        tbxRecvData.Text += sp.ReadLine();
                    }
                    else
                    {
                        Byte[] ReceivedData = new Byte[sp.BytesToRead];//创建接受的数组
                        sp.Read(ReceivedData, 0, ReceivedData.Length);
                        String RecvDataText = null;
                        for (int i = 0; i < ReceivedData.Length - 1; i++)
                        {
                            RecvDataText += ("0x" + ReceivedData[i].ToString("X2") + " ");
                        }
                        tbxRecvData.Text += RecvDataText;
                    }
                    sp.DiscardInBuffer();
                }));
    
            }
    
            //打开串口
            private void btnOpenCOM_Click(object sender, EventArgs e)
            {
                if (isOpen == false)
                {
                    if (!CheckPortSetting())
                    {
                        MessageBox.Show("串口未设置!", "错误提示");
                        return;
    
                    }
                    if (!isSetProperty)
                    {
                        SetPortProperty();
                        isSetProperty = true;
                    }
                    try
                    {
                        sp.Open();
                        isOpen = true;
                        btnCheckCOM.Text = "关闭串口";
                        cbxCOMPort.Enabled = false;
                        cbxBaudRate.Enabled = false;
                        cbxDataBits.Enabled = false;
                        cbxParity.Enabled = false;
                        cbxStopBits.Enabled = false;
                        rbnChar.Enabled = false;
                        rbnHex.Enabled = false;   
                    }
                    catch (Exception)
                    {
                        isSetProperty = false;
                        isOpen = false;
                        MessageBox.Show("串口无效或已被占用!", "错误提示");
    
                    }
    
                }
                else
                {
                    try
                    {
                        sp.Close();
                        isOpen = false;
                        isSetProperty = false;
                        btnCheckCOM.Text = "打开串口";
                        cbxCOMPort.Enabled = true;
                        cbxBaudRate.Enabled = true;
                        cbxDataBits.Enabled = true;
                        cbxParity.Enabled = true;
                        cbxStopBits.Enabled = true;
                        rbnChar.Enabled = true;
                        rbnHex.Enabled = true;
                    }
                    catch (Exception)
                    {
                        MessageBox.Show("关闭时发生错误!", "错误提示");
    
                    }
    
    
    
                }
    
    
            }
            //发送数据
            private void btnSend_Click(object sender, EventArgs e)
            {
                if (isOpen)
                {
                    try
                    {
    
                        sp.WriteLine(tbxSendData.Text);
                        //MessageBox.Show("发送完成!", "错误提示");
    
                    }
                    catch (Exception)
                    {
                        MessageBox.Show("发送数据时发送错误!", "错误提示");
                        return;
                    }
    
    
                }
                else
                {
                    MessageBox.Show("串口尚未打开!", "错误提示");
                    return;
    
                }
    
    
                if (!CheckSendData())
                {
                    MessageBox.Show("请输入要发送的数据!", "错误提示");
                    return;
                }
    
            }
            //清楚缓冲区
            private void btnCleanData_Click(object sender, EventArgs e)
            {
    
                tbxRecvData.Text = "";
                tbxSendData.Text = "";
            }
    
    
    
     
        }
    }
    

    源代码下载链接:

    链接:http://pan.baidu.com/s/1o8iM0qQ 密码:tbii


    展开全文
  • C#写的串口程序

    2018-10-15 20:17:23
    平台VS2013,语言C#写的串口程序,串口可以连续发送数据,间隔在10ms以上
  • Python编写的简单串口读写程序,适合Python初学者参考,调试可用
  • 用C语言编写串口程序

    2012-01-07 22:50:02
    单片机上用的串口收发程序,通用功能,底层可以替换成各个系列的单片机
  • 程序中实现了c++串口异步通信,并对主要的函数功能及形参含义做了详细的注释,代码实测正确! 关于程序的解释可参见本人撰写博客: https://blog.csdn.net/sinat_35728816/article/details/81632310
  • c++串口程序

    2018-11-29 14:07:40
    c++ win32 串口程序
  • 往上整理的一个例子!谢谢做这个例子的人!...我用Posix_qextserialport类实现了串口的写数据,看到数据接收到的一刻,突然感觉所有的事情都不再困难。而之前所有的努力也因为这一刻的到来而充满了意义。
  • 有关于串口通信程序编写

    千次阅读 2019-03-29 13:48:03
    最近在看串口编程方面的知识,转自:https://blog.csdn.net/lanyzh0909/article/details/6001165   Win 32系统把文件的概念进行了扩展。无论是文件、通信设备、命名管道、邮件槽、磁盘...

    最近在看串口编程方面的知识,转自:https://blog.csdn.net/lanyzh0909/article/details/6001165

      Win 32系统把文件的概念进行了扩展。无论是文件、通信设备、命名管道、邮件槽、磁盘、还是控制台,都是用API函数CreateFile来打开或创建的。该函数的声明为:
    HANDLE CreateFile(
    LPCTSTR lpFileName, //
    文件名  
    DWORD dwDesiredAccess, //
    访问模式  
    DWORD dwShareMode, //
    共享模式  
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, //
    通常为NULL
    DWORD dwCreationDistribution, //
    创建方式  
    DWORD dwFlagsAndAttributes, //
    文件属性和标志
    HANDLE hTemplateFile //
    临时文件的句柄,通常为NULL  
    );
      如果调用成功,那么该函数返回文件的句柄,如果调用失败,则函数返回INVALID_HANDLE_VALUE
    在打开通信设备句柄后,常常需要对串行口进行一些初始化工作。这需要通过一个DCB结构来进行。DCB结构包含了诸如波特率、每个字符的数据位数、奇偶校验和停止位数等信息。在查询或配置置串行口的属性时,都要用DCB结构来作为缓冲区。
      调用GetCommState函数可以获得串口的配置,该函数把当前配置填充到一个DCB结构中。一般在用CreateFile打开串行口后,可以调用GetCommState函数来获取串行口的初始配置。要修改串行口的配置,应该先修改DCB结构,然后再调用SetCommState函数用指定的DCB结构来设置串行口。
      除了在DCB中的设置外,程序一般还需要设置I/O缓冲区的大小和超时。WindowsI/O缓冲区来暂存串行口输入和输出的数据,如果通信的速率较高,则应该设置较大的缓冲区。调用SetupComm函数可以设置串行口的输入和输出缓冲区的大小。
      在用ReadFileWriteFile读写串行口时,需要考虑超时问题。如果在指定的时间内没有读出或写入指定数量的字符,那么ReadFileWriteFile的操作就会结束。要查询当前的超时设置应调用GetCommTimeouts函数,该函数会填充一个COMMTIMEOUTS结构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS结构的内容来设置超时。
      有两种超时:间隔超时和总超时。间隔超时是指在接收时两个字符之间的最大时延,总超时是指读写操作总共花费的最大时间。写操作只支持总超时,而读操作两种超时均支持。用COMMTIMEOUTS结构可以规定读/写操作的超时,该结构的定义为:
    typedef struct _COMMTIMEOUTS {  
    DWORD ReadIntervalTimeout; //
    读间隔超时
    DWORD ReadTotalTimeoutMultiplier; //
    读时间系数
    DWORD ReadTotalTimeoutConstant; //
    读时间常量
    DWORD WriteTotalTimeoutMultiplier; //
    写时间系数
    DWORD WriteTotalTimeoutConstant; //
    写时间常量
    } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
      COMMTIMEOUTS结构的成员都以毫秒为单位。总超时的计算公式是:
    总超时=时间系数×要求读/写的字符数 + 时间常量
      例如,如果要读入10个字符,那么读操作的总超时的计算公式为:
    读总超时=ReadTotalTimeoutMultiplier×10 + ReadTotalTimeoutConstant
      可以看出,间隔超时和总超时的设置是不相关的,这可以方便通信程序灵活地设置各种超时。
      如果所有写超时参数均为0,那么就不使用写超时。如果ReadIntervalTimeout0,那么就不使用读间隔超时,如果ReadTotalTimeoutMultiplierReadTotalTimeoutConstant都为0,则不使用读总超时。如果读间隔超时被设置成MAXDWORD并且两个读总超时为0,那么在读一次输入缓冲区中的内容后读操作就立即完成,而不管是否读入了要求的字符。
      在用重叠方式读写串行口时,虽然ReadFileWriteFile在完成操作以前就可能返回,但超时仍然是起作用的。在这种情况下,超时规定的是操作的完成时间,而不是ReadFileWriteFile的返回时间。
    在用ReadFileWriteFile读写串行口时,既可以同步执行,也可以重叠(异步)执行。在同步执行时,函数直到操作完成后才返回。这意味着在同步执行时线程会被阻塞,从而导致效率下降。在重叠执行时,即使操作还未完成,调用的函数也会立即返回。费时的I/O操作在后台进行,这样线程就可以干别的事情。例如,线程可以在不同的句柄上同时执行I/O操作,甚至可以在同一句柄上同时进行读写操作。重叠一词的含义就在于此。
      ReadFile函数只要在串行口输入缓冲区中读入指定数量的字符,就算完成操作。而WriteFile函数不但要把指定数量的字符拷入到输出缓冲中,而且要等这些字符从串行口送出去后才算完成操作。
      ReadFileWriteFile函数是否为执行重叠操作是由CreateFile函数决定的。如果在调用CreateFile创建句柄时指定了FILE_FLAG_OVERLAPPED标志,那么调用ReadFileWriteFile对该句柄进行的读写操作就是重叠的,如果未指定重叠标志,则读写操作是同步的。
      函数ReadFileWriteFile的参数和返回值很相似。这里仅列出ReadFile函数的声明:
    BOOL ReadFile(
    HANDLE hFile, //
    文件句柄
    LPVOID lpBuffer, //
    读缓冲区
    DWORD nNumberOfBytesToRead, //
    要求读入的字节数  
    LPDWORD lpNumberOfBytesRead, //
    实际读入的字节数
    LPOVERLAPPED lpOverlapped //
    指向一个OVERLAPPED结构
    ); //
    若返回TRUE则表明操作成功 
      需要注意的是如果该函数因为超时而返回,那么返回值是TRUE。参数lpOverlapped在重叠操作时应该指向一个OVERLAPPED结构,如果该参数为NULL,那么函数将进行同步操作,而不管句柄是否是由FILE_FLAG_OVERLAPPED标志建立的。
      当ReadFileWriteFile返回FALSE时,不一定就是操作失败,线程应该调用GetLastError函数分析返回的结果。例如,在重叠操作时如果操作还未完成函数就返回,那么函数就返回FALSE,而且GetLastError函数返回ERROR_IO_PENDING
      在使用重叠I/O时,线程需要创建OVERLAPPED结构以供读写函数使用。OVERLAPPED结构最重要的成员是hEventhEvent是一个事件对象句柄,线程应该用CreateEvent函数为hEvent成员创建一个手工重置事件,hEvent成员将作为线程的同步对象使用。如果读写函数未完成操作就返回,就那么把hEvent成员设置成无信号的。操作完成后(包括超时),hEvent会变成有信号的。
      如果GetLastError函数返回ERROR_IO_PENDING,则说明重叠操作还为完成,线程可以等待操作完成。有两种等待办法:一种办法是用象WaitForSingleObject这样的等待函数来等待OVERLAPPED结构的hEvent成员,可以规定等待的时间,在等待函数返回后,调用GetOverlappedResult。另一种办法是调用GetOverlappedResult函数等待,如果指定该函数的bWait参数为TRUE,那么该函数将等待OVERLAPPED结构的hEvent 事件。GetOverlappedResult可以返回一个OVERLAPPED结构来报告包括实际传输字节在内的重叠操作结果。
      如果规定了读/写操作的超时,那么当超过规定时间后,hEvent成员会变成有信号的。因此,在超时发生后,WaitForSingleObjectGetOverlappedResult都会结束等待。WaitForSingleObjectdwMilliseconds参数会规定一个等待超时,该函数实际等待的时间是两个超时的最小值。注意GetOverlappedResult不能设置等待的时限,因此如果hEvent成员无信号,则该函数将一直等待下去。
      在调用ReadFileWriteFile之前,线程应该调用ClearCommError函数清除错误标志。该函数负责报告指定的错误和设备的当前状态。
      调用PurgeComm函数可以终止正在进行的读写操作,该函数还会清除输入或输出缓冲区中的内容。

    .2  调用Win32 API函数实现串行通信编程

        Windows操作系统对系统底层操作采取了屏蔽的策略,禁止应用程序直接访问计算机I/O端口,而由设备驱动程序统一管理,Windows封装了Windows的通信机制,这种方式称为通信应用程序接口API(Application Programming Interfaces)Windows 9x/NT/2000提供的API一般都支持32位的操作,又称为Win32 API,程序员可以利用Win32 API的通信函数进行编程,不用对硬件直接进行操作,使得应用程序的编制更加方便。

    2.2.1  Win32 API常用通信函数

        在进行串口通信时,经常需要用到下列一些API函数:

    CreateFile():用于打开一个文件访问串口;

    GetCommState():获取串口的当前配置,放入设备控制块DCB中;

    SetCommState():根据DCB重新配置串口参数;

    SetCommTimeouts():设置串口读写操作的溢出时间;

    ReadFile():从串口的输入缓冲区读取数据;

    WriteFile():向串口的输出缓冲区写入数据;

    SetCommMask():监视指定通信资源上的事件;

    WaitCommEvent():等待通信事件发生;

    CloseHandle():关闭由CreateFile函数打开的串口。

        以上这些函数的原形可在参考文献[1]中找到。

     

    1-C++ Builder 6.0下基于api函数编写串口通信程序简介:

     

    dos/win95/win98的年代,操作系统对串口是不保护的,也就是说将串口的的资源完全开放给用户,用户可以用直接操作硬件的函数(比如说 TC2.0下的inport()outport()函数) 跟串口直接打交道,这时候用户使用直接操作串口的函数怎样"折磨"串口都是没有问题的,操作系统根本就不管不问,对串口操作所造成的一切后果都是用户一个 人承担的,这时候用户对串口具有高度自由的支配权;但是,这种情况好景不长,从win2000操作系统开始,微软为了"照顾好"计算机上的硬件,开始实施 了对硬件的保护策略,也就是说任何用户在他的操作系统下企图操纵串口时必须经过他的同意方可进行,其实也就是变相的将用户往必须使用他的通信api函数才 能操作串口这条"羊肠小路"上赶(当然也有别的方法操作串口,但那些并非我等普通用户能研究明白的),形象一点说就好像你想怎样操作串口的意图必须经过 win2000的翻译(其实是win2000的设备驱动程序)才能转达给串口一样,基于这一点我们说(其实是很多资料上说的)win2000下通过api 函数操作串口是具有"设备无关性的",什么意思呢?就是说你想怎样操作串口就用相应的api函数告诉操作系统你想对串口干什么,然后操作系统就把你的意思 转告给串口让其做出相应的动作,相对于dos/win95/win98下来说,据我理解也就相当于你原来写的直接操作串口的函数在win2000下他替你 完成了,但是你必须用win2000通信api函数清楚地向操作系统表达清楚你到底想干什么,所以说在这种情况下要想写好串口驱动程序你就必须至少弄明白 win2000下的通信api函数都是干什么的方可,啰里啰唆唠叨了这么多... ...sorry, 还没完呢,至少还有一件事我想说,原来在dos/win95/win98系统下有好多高手用c/c++对串口进行直接操作是非常熟练的,尤其是dos时代 的turbo 2.0操作串口的高手他们写的串口驱动程序直到win98的时候还用的非常洋洋得意,但是到了win2000的时候,他们的程序突然不好使了,而他们有的 可能还会因为知识结构上的滞后始终弄不明白怎么回事儿,兄弟们,你们该明白了吧?闲话少叙,下面介绍笔者写串口通信函数时用到的各个api函数----- ----

     

    2-CreateFile()

     

    用途:打开串口

    原型:HANDLE CreateFile(LPCTSTR lpFileName,

    DWORD dwDesiredAccess,

    DWORD dwShareMode,

    LPSECURITY_ATTRIBUTES lpSecurityAttributes,

    DWORD dwCreationDistribution,

    DWORD dwFlagsAndAttributes,

    HANDLE hTemplateFile);

    参数说明:

    -lpFileName:要打开的文件名称。对串口通信来说就是COM1COM2

    -dwDesiredAccess:读写模式设置。此处应该用GENERIC_READGENERIC_WRITE

    -dwShareMode:串口共享模式。此处不允许其他应用程序共享,应为0

    -lpSecurityAttributes:串口的安全属性,应为0,表示该串口不可被子程序继承。

    -dwCreationDistribution:创建文件的性质,此处为OPEN_EXISTING.

    -dwFlagsAndAttributes:属性及相关标志,这里使用异步方式应该用FILE_FLAG_OVERLAPPED

    -hTemplateFile:此处为0

    操作说明:若文件打开成功,串口即可使用了,该函数返回串口的句柄,以后对串口操作时

    即可使用该句柄。

    举例:HANDLE hComm;

    hComm=CreateFile("COM1", //串口号

    GENERIC_READ|GENERIC_WRITE, //允许读写

    0, //通讯设备必须以独占方式打开

    NULL, //无安全属性

    OPEN_EXISTING, //通讯设备已存在

    FILE_FLAG_OVERLAPPED, //异步I/O

    0); //通讯设备不能用模板打开

    hComm即为函数返回的串口1的句柄。

     

    3-CloseHandle()

     

    用途:关闭串口

    原型:BOOL CloseHandle(HANDLE hObjedt)

    参数说明:

    -hObjedt:串口句柄

    操作说明:成功关闭串口时返回true,否则返回false

    举例:CloseHandle(hComm);

     

    4-GetCommState()

     

    用途:取得串口当前状态

    原型:BOOL GetCommState(HANDLE hFile,

    LPDCB lpDCB);

    参数说明:

    -hFile:串口句柄

    -lpDCB:设备控制块(Device Control Block)结构地址。此结构中含有和设备相关的

    参数。此处是与串口相关的参数。由于参数非常多,当需要设置串口参数

    时,通常是先取得串口的参数结构,修改部分参数后再将参数结构写入。

    在此仅介绍少数的几个常用的参数:

    DWORD BaudRate:串口波特率

    DWORD fParity:为1的话激活奇偶校验检查

    DWORD Parity:校验方式,值0~4分别对应无校验、奇校验、偶校验、校验

    置位、校验清零

    DWORD ByteSize:一个字节的数据位个数,范围是5~8

    DWORD StopBits:停止位个数,0~2分别对应1位、1.5位、2位停止位

    操作举例:DCB ComDCB; //串口设备控制块

    GetCommState(hComm,&ComDCB);

     

    5-SetCommState()

     

    用途:设置串口状态,包括常用的更改串口号、波特率、奇偶校验方式、数据位数等

    原型:BOOL SetCommState(HANDLE hFile,

    LPDCB lpDCB);

    参数说明:

    -hFile:串口句柄

    -lpDCB:设备控制块(Device Control Block)结构地址。要更改的串口参数包含在此结构中。

    操作举例:DCB ComDCB;

    GetCommState(hComm,&ComDCB);//取得当前串口状态

    ComDCB.BaudRate=9600;//更改为9600bps,该值即为你要修改后的波特率

    SetCommState(hComm,&ComDCB;//将更改后的参数写入串口

     

    6-WriteFile()

     

    用途:向串口写数据

    原型:BOOL WriteFile(HANDLE hFile,

    LPCVOID lpBuffer,

    DWORD nNumberOfBytesToWrite,

    LPDWORD lpNumberOfBytesWritten,

    LPOVERLAPPED lpOverlapped);

    参数说明:

    -hFile:串口句柄

    -lpBuffer:待写入数据的首地址

    -nNumberOfBytesToWrite:待写入数据的字节数长度

    -lpNumberOfBytesWritten:函数返回的实际写入串口的数据个数的地址,利用此变量可判断

    实际写入的字节数和准备写入的字节数是否相同。

    -lpOverlapped:重叠I/O结构的指针

    操作举例:DWORD BytesSent=0;

    unsigned char SendBytes[5]={1,2,3,4,5};

    OVERLAPPED ov_Write;

    ov_Write.Offset=0;

    ov_Write.OffsetHigh=0;

    WriteFile(hComm, //调用成功返回非零,失败返回零

    SendBytes, //输出缓冲区

    5, //准备发送的字符长度

    &BytesSent, //实际发出的字符数

    &ov_Write); //重叠结构

    如果函数执行成功的话检查BytesSent的值应该为5,此函数是WriteFile函数执行完毕后

    自行填充的,利用此变量的填充值可以用来检查该函数是否将所有的数据成功写入串口

     

    7-ReadFile()

     

    用途:读串口数据

    原型:BOOL ReadFile(HANDLE hFile,

    LPVOID lpBuffer,

    DWORD nNumberOfBytesToRead,

    lpNumberOfBytesRead,

    lpOverlapped);

    参数说明:

    -hFile:串口句柄

    -lpBuffer:存储被读出数据的首地址

    -nNumberOfBytesToRead:准备读出的字节个数

    -NumberOfBytesRead:实际读出的字节个数

    -lpOverlapped:异步I/O结构,

    操作举例:unsigned char ucRxBuff[20];

    COMSTAT ComStat;

    DWORD dwError=0;

    DWORD BytesRead=0;

    OVERLAPPED ov_Read;

    ov_Read.hEvent=CreateEvent(NULL, true, false, NULL);//必须创建有效事件

     

    ClearCommError(hComm,&dwError,&ComStat);//检查串口接收缓冲区中的数据个数

    bResult=ReadFile(hComm, //串口句柄

    ucRxBuff, //输入缓冲区地址

    ComStat.cbInQue, //想读入的字符数

    &BytesRead, //实际读出的字节数的变量指针

    &ov_Read); //重叠结构指针

    假如当前串口中有5个字节数据的话,那么执行完ClearCommError()函数后,ComStat

    结构中的ComStat.cbInQue将被填充为5,此值在ReadFile函数中可被直接利用。

     

    8-ClearCommError()

     

    用途:清除串口错误或者读取串口现在的状态

    原型:BOOL ClearCommError(HANDLE hFile,

    LPDWORD lpErrors,

    LPCOMATAT lpStat

    );

    参数说明:

    -hFile:串口句柄

    -lpErrors:返回错误数值,错误常数如下:

    1-CE_BREAK:检测到中断信号。意思是说检测到某个字节数据缺少合法的停止位。

    2-CE_FRAME:硬件检测到帧错误。

    3-CE_IOE:通信设备发生输入/输出错误。

    4-CE_MODE:设置模式错误,或是hFile值错误。

    5-CE_OVERRUN:溢出错误,缓冲区容量不足,数据将丢失。

    6-CE_RXOVER:溢出错误。

    7-CE_RXPARITY:硬件检查到校验位错误。

    8-CE_TXFULL:发送缓冲区已满。

    -lpStat:指向通信端口状态的结构变量,原型如下:

    typedef struct _COMSTAT{

    ...

    ...

    DWORD cbInQue; //输入缓冲区中的字节数

    DWORD cbOutQue;//输出缓冲区中的字节数

    }COMSTAT,*LPCOMSTAT;

    该结构中对我们很重要的只有上面两个参数,其他的我们可以不用管。

    操作举例:COMSTAT ComStat;

    DWORD dwError=0;

    ClearCommError(hComm,&dwError,&ComStat);

    上式执行完后,ComStat.cbInQue就是串口中当前含有的数据字节个数,我们利用此

    数值就可以用ReadFile()函数去读串口中的数据了。

     

    9-PurgeComm()

     

    用途:清除串口缓冲区

    原型:BOOL PurgeComm(HANDLE hFile,

    DWORD dwFlags

    );

    参数说明:

    -hFile:串口句柄

    -dwFlags:指定串口执行的动作,由以下参数组成:

    -PURGE_TXABORT:停止目前所有的传输工作立即返回不管是否完成传输动作。

    -PURGE_RXABORT:停止目前所有的读取工作立即返回不管是否完成读取动作。

    -PURGE_TXCLEAR:清除发送缓冲区的所有数据。

    -PURGE_RXCLEAR:清除接收缓冲区的所有数据。

    操作举例:PurgeComm(hComm, PURGE_RXCLEAR|PURGE_TXCLEAR|PURGE_RXABORT|PURGE_TXABORT);

    清除串口的所有操作。

     

    10-SetCommMask()

     

    用途:设置串口通信事件。

    原型:BOOL SetCommMask(HANDLE hFile,

    DWORD dwEvtMask

    );

    参数说明:

    -hFile:串口句柄

    -dwEvtMask:准备监视的串口事件掩码

    注:在用api函数撰写串口通信函数时大体上有两种方法,一种是查寻法,另外一种是事件通知法。

    这两种方法的区别在于收串口数据时,前一种方法是主动的周期性的查询串口中当前有没有

    数据;后一种方法是事先设置好需要监视的串口通信事件,然后依靠单独开设的辅助线程进行

    监视该事件是否已发生,如果没有发生的话该线程就一直不停的等待直到该事件发生后,将

    该串口事件以消息的方式通知主窗体,然后主窗体收到该消息后依据不同的事件性质进行处理。

    比如说当主窗体收到监视线程发来的RX_CHAR(串口中有数据)的消息后,就可以用ReadFile()

    函数去读串口。该参数有如下信息掩码位值:

    EV_BREAK:收到BREAK信号

    EV_CTS:CTS(clear to send)线路发生变化

    EV_DSR:DST(Data Set Ready)线路发生变化

    EV_ERR:线路状态错误,包括了CE_FRAME/CE_OVERRUN/CE_RXPARITY 3钟错误。

    EV_RING:检测到振铃信号。

    EV_RLSD:CD(Carrier Detect)线路信号发生变化。

    EV_RXCHAR:输入缓冲区中已收到数据。

    EV_RXFLAG:使用SetCommState()函数设置的DCB结构中的等待字符已被传入输入缓冲区中。

    EV_TXEMPTY:输出缓冲区中的数据已被完全送出。

    操作举例:SetCommMask(hComm,EV_RXCHAR|EV_TXEMPTY);

    上面函数执行完毕后将监视串口中有无数据和发送缓冲区中的数据是否全部发送完毕。

     

    11-WaitCommEvent()

     

    用途:用来判断用SetCommMask()函数设置的串口通信事件是否已发生。

    原型:BOOL WaitCommEvent(HANDLE hFile,

    LPDWORD lpEvtMask,

    LPOVERLAPPED lpOverlapped

    );

    参数说明:

    -hFile:串口句柄

    -lpEvtMask:函数执行完后如果检测到串口通信事件的话就将其写入该参数中。

    -lpOverlapped:异步结构,用来保存异步操作结果。

    操作举例:OVERLAPPED os;

    DWORD dwMask,dwTrans,dwError=0,err;

     

    memset(&os,0,sizeof(OVERLAPPED));

    os.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);

    if(!WaitCommEvent(hComm,&dwMask,&os)){

    //如果异步操作不能立即完成的话,函数返回FALSE,并且调用GetLastError()

    //数分析错误原因后返回ERROR_IO_PENDING,指示异步操作正在后台进行.这种情

    //况下,在函数返回之前系统设置OVERLAPPED结构中的事件为无信号状态,该函数

    //等待用SetCommMask()函数设置的串口事件发生,共有9种事件可被监视:

    //EV_BREAKEV_CTSEV_DSREV_ERREV_RINGEV_RLSDEV_RXCHAR

    //EV_RXFLAGEV_TXEMPTY;当其中一个事件发生或错误发生时,函数将

    //OVERLAPPED结构中的事件置为有信号状态,并将事件掩码填充到dwMask参数中

    if(GetLastError()==ERROR_IO_PENDING){

    /**************************************************************/

    /*在此等待异步操作结果,直到异步操作结束时才返回.实际上此时 */

    /*WaitCommEvent()函数一直在等待串口监控的事件之一发生,当事件发*/

    /*生时该函数将OVERLAPPED结构中的事件句柄置为有信号状态,此时 */

    /*GetOverlappedResult()函数发现此事件有信号后马上返回,然后下面*/

    /*的程序马上分析WaitCommEvent()函数等到的事件是被监视的串口事 */

    /*件中的哪一个,然后执行相应的动作并发出相应消息. */

    /**************************************************************/

    GetOverlappedResult(hComm,&os,&dwTrans,true);

    switch(dwMask){

    case EV_RXCHAR:

    PostMessage(Parent,WM_COMM_RXCHAR,0,0);

    break;

    case EV_TXEMPTY:

    PostMessage(Parent,WM_COMM_TXEMPTY,0,0);

    break;

    case EV_ERR:

    switch(dwError){

    case CE_FRAME:

    err=0;

    break;

    case CE_OVERRUN:

    err=1;

    break;

    case CE_RXPARITY:

    err=2;

    break;

    default:break;

    }

    PostMessage(Parent,WM_COMM_ERR,(WPARAM)0,(LPARAM)err);

    break;

    case EV_BREAK:

    PostMessage(Parent,WM_COMM_BREAK,0,0);

    break;

    case ...://其他用SetCommMask()函数设置的被监视的串口通信事件。

    ... ...

    break;

    default:break;

    }

    }

    //

    Win32串口编程

    金贝贝

    一、基本知识

       Win32下串口通信与16位串口通信有很大的区别。在Win32下,可以使用两种编程方式实现串口通信,其一是调用的WindowsAPI函数,其二是使用ActiveX控件。使用API 调用,可以清楚地掌握串口通信的机制,熟悉各种配置和自由灵活采用不同的流控进行串口通信。下面介绍串口操作的基本知识。

      打开串口:使用CreateFile()函数,可以打开串口。有两种方法可以打开串口,一种是同步方式(NonOverlapped,另外一种异步方式(Overlapped)。使用Overlapped打开时,适当的方法是:

     HANDLE hComm;

     hComm = CreateFile( gszPort,

     GENERIC_READ | GENERIC_WRITE,

     0,

     0,

     OPEN_EXISTING,

     FILE_FLAG_OVERLAPPED,

     0);

     if (hComm == INVALID_HANDLE_VALUE)

     // error opening port; abort

      配置串口:

      1.DCB配置

       DCBDevice Control Block)结构定义了串口通信设备的控制设置。许多重要设置都是在DCB结构中设置的,有三种方式可以初始化DCB

      (1)通过GetCommState()函数得DCB的初始值,其使用方式为:

    DCB dcb = {0};

    if (!GetCommState(hComm, dcb))

    // Error getting current DCB settings

    else

    // DCB is ready for use.

      (2)BuildCommDCB()函数初始化DCB结构,该函数填充 DCB的波特率、奇偶校验类型、数据位、停止位。对于流控成员函数设置了缺省值。其用法是:

    DCB dcb;

    FillMemory(dcb, sizeof(dcb), 0);

    dcb.DCBlength = sizeof(dcb);

    if (!BuildCommDCB(9600,n,8,1", dcb)) {

    // Couldn't build the DCB. Usually a problem

    // with the communications specification string.

    return FALSE;

    }

    else

    // DCB is ready for use.

      (3)SetCommState()函数手动设置DCB初值。用法如下:

    DCB dcb;

    FillMemory(dcb, sizeof(dcb), 0);

    if (!GetCommState(hComm, dcb)) // get current DCB

    // Error in GetCommState

    return FALSE;

    // Update DCB rate.

    dcb.BaudRate = CBR_9600 ;

    // Set new state.

    if (!SetCommState(hComm, dcb))

    // Error in SetCommState.

     Possibly a problem with the communications

    // port handle or a problem with the DCB structure itself.

      手动设置DCB值时,DCB的结构的各成员的含义,可以参看MSDN帮助。

       2.流控设置

      硬件流控:串口通信中的硬件流控有两种,DTE/DSR方式和RTS/CTS方式,这与DCB结构的初始化有关系,DCB结构中的OutxCtsFlow fOutxDsrFlowfDsrSensitivityfRtsControlfDtrControl几个成员的初始值很关键,不同的值代表不同流控,也可以自己设置流控,但建议采用标准流行的流控方式。采用硬件流控时,DTEDSRRTSCTS的逻辑位直接影响到数据的读写及收发数据的缓冲区控制。

       软件流控:串口通信中采用特殊字符XONXOFF作为控制串口数据的收发。与此相关的DCB成员是:fOutfInXXoffCharXonChar XoffLimXonLim。具体含义参见MSDN帮助。

       串口读写操作:串口读写有两种方式:同步方式(NonOverlapped)和异步方式(Overlapped)。同步方式是指必须完成了读写操作,函数才返回,这可能造成程序死掉,因为如果在读写时发生了错误,永远不返回就会出错,可能线程将永远等待在那儿。而异步方式则灵活得多,一旦读写不成功,就将读写挂起,函数直接返回,可以通过GetLastError函数得知读写未成功的原因,所以常常采用异步方式操作。

       读操作:ReadFile()函数用于完成读操作。异步方式的读操作为:

     DWORD dwRead;

     BOOL fWaitingOnRead = FALSE;

     OVERLAPPED osReader = {0};

     // Create the overlapped event. Must be closed before exiting

     // to avoid a handle leak.

     osReader.hEvent = CreateEvent

     (NULL, TRUE, FALSE, NULL);

     if (osReader.hEvent == NULL)

     // Error creating overlapped event; abort.

     if (!fWaitingOnRead) {

     // Issue read operation.

     if (!ReadFile(hComm, lpBuf, READ_BUF_SIZE,

      &dwRead, osReader)) {

     if (GetLastError() != ERROR_IO_PENDING)

      // read not delayed?

     // Error in communications; report it.

     else

     fWaitingOnRead = TRUE;

     }

     else {

     // read completed immediately

     HandleASuccessfulRead(lpBuf, dwRead);

     }

     }

       如果读操作被挂起,可以调用WaitForSingleObject()函数或WaitForMuntilpleObjects()函数等待读操作完成或者超时发生,再调用 GetOverlappedResult()得到想要的信息。

       写操作:与读操作相似,故不详述,调用的API函数是: WriteFile函数。

       串口状态:

      (1)通信事件:用SetCommMask()函数设置想要得到的通信事件的掩码,再调用WaitCommEvent()函数检测通信事件的发生。可设置的通信事件标志(即SetCommMask()函数所设置的掩码)可以有EV_BREAKEV_CTSEV_DSR EV_ERREV_RINGEV_RLSDEV_RXCHAREV_RXFLAGEV_TXEMPTY

     

       注意:1对于EV_RING标志的设置,WIN95是不会返回EV_RING事件的,因为WIN95不检测该事件。2设置EV_RXCHAR,可以检测到字符到达,但是在绑定此事件和ReadFile()函数一起读取串口接收数据时,可能会出现错误,造成少读字节数,具体原因查看MSDN帮助。可以采用循环读的办法,另外一个比较好的解决办法是调用ClearCommError()函数,确定在一次读操作中在缓冲区中等待被读的字节数。

      (2)错误处理和通信状态:在串口通信中,可能会产生很多的错误,使用ClearCommError()函数可以检测错误并且清除错误条件。

       (3Modem状态:用SetcommMask()可以包含很多事件标志,但是这些事件标志只指示在串口线路上的电压变化情况。而调用 GetCommModemStatus()函数可以获得线路上真正的电压状态。

       扩展函数:如果应用程序想用自己的流控,可以使用 EscapeCommFunction()函数设置DTRRTS线路的电平。

       通信超时:在通信中,超时是个很重要的考虑因素,因为如果在数据接收过程中由于某种原因突然中断或停止,如果不采取超时控制机制,将会使得I/O线程被挂起或无限阻塞。串口通信中的超时设置分为两步,首先设置 COMMTIMEOUTS结构的五个变量,然后调用SetcommTimeouts()设置超时值。对于使用异步方式读写的操作,如果操作挂起后,异步成功完成了读写,WaitForSingleObject() WaitForMultipleObjects()函数将返回WAIT_OBJECT_0GetOverlappedResult()返回TRUE。其实还可以用GetCommTimeouts()得到系统初始值。

       关闭串口:程序结束或需要释放串口资源时,应该正确关闭串口,关闭串口比较简单,使用API调用CloseHandle()关闭串口的句柄就可以了。

      调用方法为:CloseHandle(hComm);

       但是值得注意的是在关闭串口之前必须保证读写串口线程已经退出,否则会引起误操作,一般采用的办法是使用事件驱动机制,启动一事件,通知串口读写线程强制退出,在线程退出之前,通知主线程可以关闭串口。

    二、实现

      1.程序设计思路

       对于不同的应用程序,虽然界面不同,但是如果采用串口与主机之间的通信,对串口的处理方式大致相似,无非就是通过串口收发数据,对于通过串口接收到的数据,交给上层软件处理显示,对于上层要发给串口的数据,进行转发。但在实际编程中,由于采用的通信方式和流控不同,串口设置也不同,这就涉及到 DCB的初始化问题和读写串口等细节问题。串口通信应用程序设计的总体思路(即操作过程)是:首先,确定要打开的串口名、波特率、奇偶校验方式、数据位、停止位,传递给CreateFile()函数打开特定串口;其次,为了保护系统对串口的初始设置,调用 GetCommTimeouts()得到串口的原始超时设置;然后,初始化DCB对象,调用SetCommState() 设置DCB,调用SetCommTimeouts()设置串口超时控制;再次,调用SetupComm()设置串口接收发送数据的缓冲区大小,串口的设置就基本完成,之后就可以启动读写线程了。

      一般来说,串口的读写由串口读写线程完成,这样可以避免读写阻塞时主程序死锁。对于全双工的串口读写,应该分别开启读线程和写线程;对于半双工和单工的,建议只需开启一个线程即可。在线程中,按照预定好的通信握手方式,正确检测串口状态,读取发送串口数据。

      2.实现细节

      在半双工的情况下,首先完成必要的串口配置,成功打开串口、DCB设置、超时设置;然后开启线程,如: CwinThread hSerialThread = (CWinThread) AfxBeginThread(SerialOperationhWndTHREAD_PRIORITY_NORMAL); 其中开启之线程为SerialOperation,优先级为普通。

       全双工情况下的串口编程,与单工差不多,区别仅仅在于启动双线程,分别为读线程和写线程,读线程根据不同的事件或消息,通过不断查询串口所收到的有效数据,完成读操作;写线程通过接收主线程的发送数据事件和要发送的数据,向串口发送。  

    //

    2.3.1 利用SPComm组件实现串行通信编程

    串行口VCL组件SPComm封装有丰富的与串口通信密切相关的属性和事件,是目前功能比较完善的串行通信组件,提供有完整的源代码。

    1SPComm的主要属性

    CommName:填写所要打开的串口名字,如“COM1

    RaudRate:设定实际的串行通信波特率。

    ParityCheek:奇偶校验。

    ByteSize:设定字节长度。

    Parity:奇偶校验位。

    StopBits:停止位。

        SendDataEmpty:布尔属性,为True时表示发送缓存为空,或者发送队列里没有信息;为False时表示发送缓存不为空,或者发送队列里有信息。

    2SPComm的主要方法和事件

        StartComm()过程用于打开串口,当操作失败时通常会报错,错误主要有7种:串口已经打开;打开串口错误;文件句柄不是通讯句柄;不能安装通讯缓存;不能产生事件;不能产生读进程;不能产生写进程。

    StopComm()过程用于关闭串口,没有返回值。

        WriteCommData()函数把要发送的字符串写入发送缓冲区,发送成功返回True,发送失败返回False。执行此函数将立即得到返回值,发送操作随后执行。此函数有两个参数:pDataToWrite是要发送的字符串;dwSixeofDataToWrite是发送数据帧的长度。

        OnReceiveData(Tobject * Sender, Pointer Buffer, WORD BufferLength) 事件的功能是当输入缓存有数据时将触发该事件,可在该事件中对从串口收到的数据进行处理。参数Buffer是接收到的数据,BufferLength是接收到的数据长度。

        OnReceiveError(Tobject * Sender,DWORD EventMask)事件功能是当接收数据时出现错误将触发该事件,EventMask是错误事件的代码。

        OnSendDataEmpty(Tobject * Sender)事件的功能是当发交通安全数据完成时将触发该事件。

        SPComm组件的应用与MSComm控件相似,基本编程时只要给组件的相关属性正确赋值就可配置串行通信参数,通过组件的方法打开/关闭串口和发送数据,在组件相应的通信事件处理函数中接收数据和处理通信事件。与MSComm ActiveX控件不同的是,SPComm组件是标准的VCL组件,提供多线程编程的支持,能够更可靠地进行串行数据通信。

      Win 32系统把文件的概念进行了扩展。无论是文件、通信设备、命名管道、邮件槽、磁盘、还是控制台,都是用API函数CreateFile来打开或创建的。该函数的声明为:
    HANDLE CreateFile(
    LPCTSTR lpFileName, //
    文件名  
    DWORD dwDesiredAccess, //
    访问模式  
    DWORD dwShareMode, //
    共享模式  
    LPSECURITY_ATTRIBUTES lpSecurityAttributes, //
    通常为NULL
    DWORD dwCreationDistribution, //
    创建方式  
    DWORD dwFlagsAndAttributes, //
    文件属性和标志
    HANDLE hTemplateFile //
    临时文件的句柄,通常为NULL  
    );
      如果调用成功,那么该函数返回文件的句柄,如果调用失败,则函数返回INVALID_HANDLE_VALUE
    在打开通信设备句柄后,常常需要对串行口进行一些初始化工作。这需要通过一个DCB结构来进行。DCB结构包含了诸如波特率、每个字符的数据位数、奇偶校验和停止位数等信息。在查询或配置置串行口的属性时,都要用DCB结构来作为缓冲区。
      调用GetCommState函数可以获得串口的配置,该函数把当前配置填充到一个DCB结构中。一般在用CreateFile打开串行口后,可以调用GetCommState函数来获取串行口的初始配置。要修改串行口的配置,应该先修改DCB结构,然后再调用SetCommState函数用指定的DCB结构来设置串行口。
      除了在DCB中的设置外,程序一般还需要设置I/O缓冲区的大小和超时。WindowsI/O缓冲区来暂存串行口输入和输出的数据,如果通信的速率较高,则应该设置较大的缓冲区。调用SetupComm函数可以设置串行口的输入和输出缓冲区的大小。
      在用ReadFileWriteFile读写串行口时,需要考虑超时问题。如果在指定的时间内没有读出或写入指定数量的字符,那么ReadFileWriteFile的操作就会结束。要查询当前的超时设置应调用GetCommTimeouts函数,该函数会填充一个COMMTIMEOUTS结构。调用SetCommTimeouts可以用某一个COMMTIMEOUTS结构的内容来设置超时。
      有两种超时:间隔超时和总超时。间隔超时是指在接收时两个字符之间的最大时延,总超时是指读写操作总共花费的最大时间。写操作只支持总超时,而读操作两种超时均支持。用COMMTIMEOUTS结构可以规定读/写操作的超时,该结构的定义为:
    typedef struct _COMMTIMEOUTS {  
    DWORD ReadIntervalTimeout; //
    读间隔超时
    DWORD ReadTotalTimeoutMultiplier; //
    读时间系数
    DWORD ReadTotalTimeoutConstant; //
    读时间常量
    DWORD WriteTotalTimeoutMultiplier; //
    写时间系数
    DWORD WriteTotalTimeoutConstant; //
    写时间常量
    } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
      COMMTIMEOUTS结构的成员都以毫秒为单位。总超时的计算公式是:
    总超时=时间系数×要求读/写的字符数 + 时间常量
      例如,如果要读入10个字符,那么读操作的总超时的计算公式为:
    读总超时=ReadTotalTimeoutMultiplier×10 + ReadTotalTimeoutConstant
      可以看出,间隔超时和总超时的设置是不相关的,这可以方便通信程序灵活地设置各种超时。
      如果所有写超时参数均为0,那么就不使用写超时。如果ReadIntervalTimeout0,那么就不使用读间隔超时,如果ReadTotalTimeoutMultiplierReadTotalTimeoutConstant都为0,则不使用读总超时。如果读间隔超时被设置成MAXDWORD并且两个读总超时为0,那么在读一次输入缓冲区中的内容后读操作就立即完成,而不管是否读入了要求的字符。
      在用重叠方式读写串行口时,虽然ReadFileWriteFile在完成操作以前就可能返回,但超时仍然是起作用的。在这种情况下,超时规定的是操作的完成时间,而不是ReadFileWriteFile的返回时间。
    在用ReadFileWriteFile读写串行口时,既可以同步执行,也可以重叠(异步)执行。在同步执行时,函数直到操作完成后才返回。这意味着在同步执行时线程会被阻塞,从而导致效率下降。在重叠执行时,即使操作还未完成,调用的函数也会立即返回。费时的I/O操作在后台进行,这样线程就可以干别的事情。例如,线程可以在不同的句柄上同时执行I/O操作,甚至可以在同一句柄上同时进行读写操作。重叠一词的含义就在于此。
      ReadFile函数只要在串行口输入缓冲区中读入指定数量的字符,就算完成操作。而WriteFile函数不但要把指定数量的字符拷入到输出缓冲中,而且要等这些字符从串行口送出去后才算完成操作。
      ReadFileWriteFile函数是否为执行重叠操作是由CreateFile函数决定的。如果在调用CreateFile创建句柄时指定了FILE_FLAG_OVERLAPPED标志,那么调用ReadFileWriteFile对该句柄进行的读写操作就是重叠的,如果未指定重叠标志,则读写操作是同步的。
      函数ReadFileWriteFile的参数和返回值很相似。这里仅列出ReadFile函数的声明:
    BOOL ReadFile(
    HANDLE hFile, //
    文件句柄
    LPVOID lpBuffer, //
    读缓冲区
    DWORD nNumberOfBytesToRead, //
    要求读入的字节数  
    LPDWORD lpNumberOfBytesRead, //
    实际读入的字节数
    LPOVERLAPPED lpOverlapped //
    指向一个OVERLAPPED结构
    ); //
    若返回TRUE则表明操作成功 
      需要注意的是如果该函数因为超时而返回,那么返回值是TRUE。参数lpOverlapped在重叠操作时应该指向一个OVERLAPPED结构,如果该参数为NULL,那么函数将进行同步操作,而不管句柄是否是由FILE_FLAG_OVERLAPPED标志建立的。
      当ReadFileWriteFile返回FALSE时,不一定就是操作失败,线程应该调用GetLastError函数分析返回的结果。例如,在重叠操作时如果操作还未完成函数就返回,那么函数就返回FALSE,而且GetLastError函数返回ERROR_IO_PENDING
      在使用重叠I/O时,线程需要创建OVERLAPPED结构以供读写函数使用。OVERLAPPED结构最重要的成员是hEventhEvent是一个事件对象句柄,线程应该用CreateEvent

    展开全文
  • python编写串口程序

    万次阅读 2014-06-06 10:27:24
    最近导师给了个GSM模块,需要通过RS232串口发送AT

    最近导师给了个GSM模块,需要通过RS232串口发送AT指令来对模块进行控制,于是看了看python的GUI设计和串口部分的资料,自己编写了一个串口发送的小程序,虽然有不少的bug,但是总体上还是能用的,先把程序留在这,以便后续修改。

    感觉python确实是一个很容易上手的语言,因为我事先都没看过pythonGUI设计和串口的资料,也就只用了一天就完成了这个小程序,感觉主要是python的语句确实很简洁,比方说在串口上,几句话就能实现串口发送和接收了。不过在做GUI设计方面,还是希望能像MFC那样可以拖拉控件,这样就方便了许多。

    下面先发一张界面的截图:


    好了,下面贴程序:


    import wx
    import serial
    import time
    import threading
    
    
    class MyFrame(wx.Frame):
    
        def __init__(self,parent):
            print "MyFrame __init__"
            wx.Frame.__init__(self,parent,-1,'My COM',size=(500,500))#窗口标题栏和大小
    
            panel=wx.Panel(self)
            sizer=wx.BoxSizer(wx.VERTICAL)
            panel.SetSizer(sizer)
    
            self.sendtxt=wx.StaticText(panel,-1,u'发送',(20,50),(50,15))#发送静态文本框 
            self.rectxt=wx.StaticText(panel,-1,u'接收',(20,200),(50,15))#接收静态文本框
            self.baudratetxt=wx.StaticText(panel,-1,u'波特率',(20,320),(50,15))#波特率静态文本框
            self.comtxt=wx.StaticText(panel,-1,'com',(20,350),(50,15))#com口静态文本框
            baudratelist=['300','600','1200','2400','4800','9600','19200','38400'
                         ,'43000','56000','57600','115200']
            comlist=['com1','com2','com3','com4','com5','com6','com7','com8','com9']
    
            self.baudratelistctr=wx.Choice(panel, -1, (70, 320), choices=baudratelist)
            self.Bind(wx.EVT_CHOICE,self.OnbaudrateCH,self.baudratelistctr)#波特率下拉列表响应函数
            self.comlistctr=wx.Choice(panel, -1, (70, 350), choices=comlist)
            self.Bind(wx.EVT_CHOICE,self.OncomlistCH,self.comlistctr)#com下拉列表响应函数
            self.baudratelistctr.SetSelection(5)
            self.comlistctr.SetSelection(3)
            self.sendctr = wx.TextCtrl(panel, -1,              
                        pos = (100, 50), size = (200, 100),
                        style=wx.TE_MULTILINE|wx.TE_CENTER)
            self.recctr = wx.TextCtrl(panel, -1,              
                        pos = (100, 200), size = (200, 100),
                        style=wx.TE_MULTILINE|wx.TE_CENTER)
            
            self.sendbutton=wx.Button(panel,-1,u'发送',pos=(350,50))#发送按钮
            self.Bind(wx.EVT_BUTTON,self.OnSend,self.sendbutton)
            self.ClearRecbutton=wx.Button(panel,-1,u'清空接收列表',pos=(350,200))
            self.Bind(wx.EVT_BUTTON,self.OnClearRec,self.ClearRecbutton)
           
            index=self.baudratelistctr.GetSelection()
            BaudRate=self.baudratelistctr.GetString(index)#获取波特率
            index=self.comlistctr.GetSelection()
            ComNum=self.comlistctr.GetString(index)#获取com口
            t = threading.Timer(0.1,self.myreceive)
            t.start()
            self.Centre()
            global mycom
            
            try:  
                mycom= serial.Serial(ComNum,BaudRate,timeout=1)
                    
            except:
                wx.MessageBox('open com fail','error')
                return None
            
            
        def myreceive(self):
            try:
                n=mycom.inWaiting()
            except:
                return None
            if n!=0:
                str1=mycom.read(n)
                self.recctr.Value=str1   
            t = threading.Timer(0.1,self.myreceive)
            t.start()
        def OnClearRec(self,event):
            self.recctr.Value=''
        
        def OnbaudrateCH(self,event):
            global mycom
            index=self.baudratelistctr.GetSelection()
            BaudRate=self.baudratelistctr.GetString(index)#获取波特率
            mycom.setBaudrate(BaudRate)
            print mycom.inWaiting               
        def OncomlistCH(self,event):
            global mycom
            index=self.comlistctr.GetSelection()
            ComNum=self.comlistctr.GetString(index)#获取com口
            
            try:
                mycom.setPort(ComNum)
            except:
                wx.MessageBox('change port fail','error')
                return None
            print mycom.inWaiting
        def OnSend(self,event):                    #发送处理程序
            value=self.sendctr.GetValue()
            n=mycom.write(value)       
    '''    def OnRec(self,event):                     #接收处理程序
            n=mycom.inWaiting()
            str1=mycom.read(n)
            self.recctr.Value=str1'''
    class MyApp(wx.App): #自定义应用程序对象
    
        def OnInit(self):
            print "MyApp OnInit"
            self.frame = MyFrame(None)
            id=self.frame.GetId()
            print "Frame ID:",id
            self.frame.Show(True)
            return True
        def OnExit(self):
            print "MyApp OnExit"
            
            mycom.close()
            
            time.sleep(2)        
    
    
    
    if __name__ == '__main__': 
        print "Main start"
        
        app = MyApp() #使用从wx.App继承的子类
        print "Before MainLoop"
        app.MainLoop()
        print "After MainLoop"


    展开全文
  • 串口API 编写串口程序,带有演示函数,性能很高
  • 基于quartus ii 13.1 编写的verilog编写串口收发程序,包含了接收和发送两个工程,可设置成不同波特率进行通信。
  • C++编写串口通信程序

    万次阅读 多人点赞 2018-08-13 19:55:30
    声明:本博客的内容主要是本人学习其他串口通信博客之后的总结,主要参考的博客地址如下: https://blog.csdn.net/wlk1229/article/details/52566701 ... ...
  • vs2013用qt编写串口通信程序

    千次阅读 2017-11-14 20:13:31
    1. 文件->新建项目-> QT5 project->QT application,命名为...2. 在main.cpp和helloserialport.h中都会有未定义标识符这种错误提示,解决办法为:右键选择项目名HelloSerialPort->属性->VC++目录->在包含
  • 在VC6.0开发环境编写的一个串口调试程序,包括接收和发送程序
  • 主要为大家详细介绍了基于Java编写的一个带有图形界面的简单串口通信工具,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 这个是用python编写串口调试助手,内含可执行程序和源代码,有详细注释,还有运行代码所必须的dll库文件,保证好用,希望对大家有帮助
  • VB编写串口调试程序t..rar 介绍了关于VB编写串口调试程序t.的详细说明,提供其它知识的技术资料的下载。
  • mfc编写串口助手

    2014-12-19 16:52:23
    初学MFC 而串口是相对简单的mfc程序所以自己编写了一个简单的串口通信工具。这个工具可以实现串口收发数据,以十六进制收发数据 可以发送txt或二进制文件 ,将收取的数据保存为txt或二进制文件。 不足之处 一个是...
  • c++编写串口程序

    2010-03-21 18:45:47
    c++编写串口程序,已通过验证,使用的是Visual studio 2005
  • 直接写的关于串口接收和发送的两个小程序,初学者可用来参考一下。
  • 与硬件通信的程序基本上要用到串口,虽然qt5以后集成了串口通信类,但是个人觉得那个串口通信类有点问题,在linux上表现很好,windows上大数据会有怪怪的问题出现,而且只能在qt5以上的版本才能用,无奈大部分的...
  • 用vs2010编写的基于MFC的串口通信程序,内含详细讲解教程、MSComm控件以及调试成功的程序以供参考。 用vs2010编写的基于MFC的串口通信程序,内含详细讲解教程、MSComm控件以及调试成功的程序以供参考。
  • 利用QT编写的简单的串口收发程序,可以自动识别可用的串口,实现数据的采集显示与发送。
  • C#编写串口界面程序

    2014-12-16 16:58:03
    用C#编写串口界面入门简单易懂,大家可以看看

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,298
精华内容 14,519
关键字:

如何编写串口程序