serialcomm.cs

常见的串口通信程序

namespace SerialPorts
{
    using System;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading;

    public abstract class SerialComm
		//定义一个SerialComm类
    {
        // Methods　方法


		/// <summary>
		/// 构造函数
		/// </summary>
        protected SerialComm()
			//构造函数
        {
        }



　　　　///
        public bool Available(string portName)
			//声明一个Avialable的函数，返回型　bool，形参为一字符串（端口名称　）
        {
            Win32Com com1 = new Win32Com();
			//分配com1为Win32COM类的一个新的对象
            bool flag1 = com1.Open(portName, false);
			//调用Open函数，并返回一个bool值
            if (flag1)
            {
                com1.Close();
				//关闭串行口，
            }
            com1 = null;
			//并置com1为空
            return flag1;
			//返回flag1值
        }



		/// <summary>
		/// 判断端口是否错误的函数
		/// </summary>
		/// <param name="fault"></param>
        private void CommError(string fault)
			//声明一个CommError函数，用于判断端口是否正确，无返回值
        {
            this.fault = fault;
			//给出出错信息
            this.OnError(fault);
			//调用OnError函数，形参为fault字符串
        }
        /// <summary>
        /// 建立连接的一个函数
        /// </summary>
        /// <param name="cfg"></param>
        /// <returns></returns>
        protected bool Create(SerialCnfg cfg)
			//声明一个建立连接的函数，返加一个BOOL值，形参为一个类SerialCnfg的一个实例
        {
            if (this.portOpen)
				//bool型变量PortOpen（用于判断端口是否打开）
            {
                this.CommError("Com Port Already Open.");
				//调用出错信息函数，指出端口已打开，无须建立连接
                return false;
				//并返回bool值，表示连接建立失败
            }
            this.fault = "";
			//如上不成立，则出错字符串为空
            this.rxThread = null;
			//指定通迅线路为空
            this.writeEvent = new ManualResetEvent(false);
            //为ManualResetEvent(false)方法创建一个实例，用于发送信息，其中的ManualResetEvent函数用于初始化连接状态，TRUE则通，FALSE则不通
			this.recvrEvent = new ManualResetEvent(false);
            //为ManualResetEvent(false)方法创建一个实例，用于接收信息，其中的ManualResetEvent函数用于初始化连接状态，TRUE则通，FALSE则不通
            this.dcb = new Win32DCB(cfg);
			//为Win32DCB创建一个实例dcb，
            this.port = new Win32Com();
			//为Win32Com()创建一个实例port,
            if (!(this.portOpen = this.port.Open(cfg.PortName, true)))
				//调用Open函数，并返回值予portOpen变量，判断打开端口是否成功
            {
                this.CommError(this.port.Fault);
				//调用CommError函数，用于指明打开端口的错误。
                return false;
				//最后返回值false，指出建立连接失败
            }
            this.portName = cfg.PortName;
			//若成功建立，则赋端口名给portName字符串
            this.stats = new Win32Status();
			//为Win32Status创建一个实例
            this.tmout = new Win32Tmout();
			//为Win32Tmout创建一个实例
            this.props = new Win32Props();
			//为Win32Props创建一个实例
            this.escape = new Win32Escape(this.port.Handle);
			//为Win32Escape创建一个实例
            this.tmout.WriteConstant = cfg.TxTmoConst;
			//为Win32Tmout的实例tmout下的WriteConstant变量赋值，表示写不变量所用时间
            this.tmout.WriteMultiplier = cfg.TxTmoMulti;
			//为Win32Tmout的实例tmout下的WriteMultiplier变量赋值，表示读累加器量所用时间
            if (!this.tmout.Set(this.port.Handle))
				//调用中断信息出错
            {
                this.Destroy();
				//销毁连接
                this.CommError(this.tmout.Fault);
				//指出中断错误
                return false;
				//返回建立不成功的false值
            }
            if (((cfg.RxQueLen != 0) || (cfg.TxQueLen != 0)) && !this.props.Set(this.port.Handle, (uint) cfg.RxQueLen, (uint) cfg.TxQueLen))
            {
                this.Destroy();
                this.CommError(this.props.Fault);
                return false;
            }
            if (!this.props.Get(this.port.Handle))
            {
                this.Destroy();
                this.CommError(this.props.Fault);
                return false;
            }
            this.dcb.Limits(cfg, this.props.RxCurSize);
            if (!this.dcb.Set(this.port.Handle))
            {
                this.Destroy();
                this.CommError(this.dcb.Fault);
                return false;
            }
            this.escape.XOFFavailable = true;
            if (cfg.RtsControl == PinState.Disable)
            {
                this.escape.RTS = false;
            }
            else if (cfg.RtsControl == PinState.Enable)
            {
                this.escape.RTS = true;
            }
            else if (cfg.RtsControl == PinState.Handshake)
            {
                this.escape.RTSavailable = false;
            }
            if (cfg.DtrControl == PinState.Disable)
            {
                this.escape.DTR = false;
            }
            else if (cfg.DtrControl == PinState.Enable)
            {
                this.escape.DTR = true;
            }
            else if (cfg.DtrControl == PinState.Toggle)
            {
                this.escape.DTR = false;
            }
            else if (cfg.DtrControl == PinState.Handshake)
            {
                this.escape.DTRavailable = false;
            }
            this.txOvr = new Win32Ovrlap(this.port.Handle, this.writeEvent.Handle);
            this.immediate = cfg.ReceiveMode;
            this.rxThread = new Thread(new ThreadStart(this.ReceiveThread));
            this.rxThread.Name = "COMReceiver";
            this.rxThread.Priority = ThreadPriority.AboveNormal;
            this.rxThread.Start();
            this.recvrEvent.WaitOne(500, false);
            return true;
			//连接成功，返回true值
        }

        protected void Destroy()
			//销毁连接
        {
            if (this.portOpen)
            {
                this.port.Cancel();
                if (this.rxThread != null)
                {
                    this.rxThread.Abort();
                    this.rxThread = null;
                }
                this.port.Close();
                this.portOpen = false;
            }
            this.dcb = null;
            this.port = null;
            this.stats = null;
            this.props = null;
            this.tmout = null;
            this.rxOvr = null;
            this.txOvr = null;
            this.escape = null;
            this.writeEvent = null;
            this.recvrEvent = null;
        }

        ~SerialComm()
			//析构
        {
            this.Destroy();
        }

        public void Flush()
        {
            if (!this.portOpen)
            {
                this.CommError("Flush() Failed. " + this.portName + " Is Closed.");
            }
            else if (!this.port.Flush())
            {
                this.CommError(this.port.Fault);
            }
        }

        protected virtual void OnBreak()
        {
        }

        protected virtual void OnCTS(bool cts)
        {
        }

        protected virtual void OnDSR(bool dsr)
        {
        }

        protected virtual void OnError(string fault)
        {
        }

        protected virtual void OnRING(bool ring)
        {
        }

        protected virtual void OnRLSD(bool rlsd)
        {
        }

        protected virtual void OnRxChar(byte[] b)
        {
        }

        protected virtual void OnTxDone()
        {
        }
        /// <summary>
        /// 用于判断端口是否已为连接做好准备，返回uint型变量，为0时，则表示失败，为其非0时，表示准许连接
        /// </summary>
        /// <returns></returns>
        public uint Ready()
        {
            uint num1 = 0;
            if (!this.portOpen)
            {
                this.CommError("Ready() Failed. " + this.portName + " Is Closed.");
                return num1;
            }
            if (!this.stats.Clear(this.port.Handle))
            {
                this.CommError(this.stats.Fault);
                return num1;
            }
            return this.stats.Ready;
        }
        /// <summary>
        /// 接收线程　
        /// </summary>
        private void ReceiveThread()
        {
            uint num1 = 0;