serialcnfg.cs

常见的串口通信程序

namespace SerialPorts
{
    using System;
    using System.IO;

    public class SerialCnfg
    {
        // Methods
        public SerialCnfg(int index)
        {
            this.Initialize(index);
        }

        public SerialCnfg(int index, string fName)
        {
            this.Initialize(index);
            this.Load(fName);
        }

        public void Initialize(int index)
        {
            this.portName = "COM" + index.ToString() + ":";
            this.baudRate = LineSpeed.Baud_9600;
            this.txFlowCTS = false;
            this.txFlowDSR = false;
            this.dtrControl = PinState.Disable;
            this.rxDSRsense = false;
            this.txContinue = true;
            this.txFlowXoff = false;
            this.rxFlowXoff = false;
            this.errReplace = false;
            this.nulDiscard = false;
            this.rtsControl = PinState.Disable;
            this.abortOnErr = false;
            this.xonLimit = 0;
            this.xoffLimit = 0;
            this.dataBits = ByteSize.Eight;
            this.parity = SerialPorts.Parity.None;
            this.stopBits = SerialPorts.StopBits.One;
            this.xonChar = 0x11;
            this.xoffChar = 0x13;
            this.errChar = 0x3f;
            this.eofChar = 0x1a;
            this.evtChar = 0;
            this.handshake = Handshake.None;
            this.rxQueLen = 0;
            this.txQueLen = 0;
            this.txTmoMulti = 0;
            this.txTmoConst = 0;
            this.receiveMode = false;
        }

        public void Load(string fName)
        {
            FileInfo info1 = new FileInfo(fName);
            if (!info1.Exists)
            {
                return;
            }
            FileStream stream1 = new FileStream(fName, FileMode.Open, FileAccess.Read);
            StreamReader reader1 = new StreamReader(stream1);
            reader1.BaseStream.Seek((long) 0, SeekOrigin.Begin);
            string text1 = "";
            string text2 = "";
            while ((text1 = reader1.ReadLine()) != null)
            {
                text2 = text1.Substring(text1.IndexOf(":") + 1);
                if (text1.StartsWith("<Port Name>"))
                {
                    this.portName = text2;
                }
                if (text1.StartsWith("<Baud Rate>"))
                {
                    this.baudRate = (LineSpeed) int.Parse(text2);
                }
                if (text1.StartsWith("<CTS Flow>"))
                {
                    this.txFlowCTS = bool.Parse(text2);
                }
                if (text1.StartsWith("<DSR Flow>"))
                {
                    this.txFlowDSR = bool.Parse(text2);
                }
                if (text1.StartsWith("<DTR Ctrl>"))
                {
                    this.dtrControl = (PinState) byte.Parse(text2);
                }
                if (text1.StartsWith("<DSR Sense>"))
                {
                    this.rxDSRsense = bool.Parse(text2);
                }
                if (text1.StartsWith("<TX Continue>"))
                {
                    this.txContinue = bool.Parse(text2);
                }
                if (text1.StartsWith("<TX Xoff Flow>"))
                {
                    this.txFlowXoff = bool.Parse(text2);
                }
                if (text1.StartsWith("<RX Xoff Flow>"))
                {
                    this.rxFlowXoff = bool.Parse(text2);
                }
                if (text1.StartsWith("<Error Replace>"))
                {
                    this.errReplace = bool.Parse(text2);
                }
                if (text1.StartsWith("<Null Discard>"))
                {
                    this.nulDiscard = bool.Parse(text2);
                }
                if (text1.StartsWith("<RTS Control>"))
                {
                    this.rtsControl = (PinState) byte.Parse(text2);
                }
                if (text1.StartsWith("<Abort On Error>"))
                {
                    this.abortOnErr = bool.Parse(text2);
                }
                if (text1.StartsWith("<Xon Limit>"))
                {
                    this.xonLimit = short.Parse(text2);
                }
                if (text1.StartsWith("<Xoff Limit>"))
                {
                    this.xoffLimit = short.Parse(text2);
                }
                if (text1.StartsWith("<Bits/Byte>"))
                {
                    this.dataBits = (ByteSize) byte.Parse(text2);
                }
                if (text1.StartsWith("<Parity>"))
                {
                    this.parity = (SerialPorts.Parity) byte.Parse(text2);
                }
                if (text1.StartsWith("<Stop Bits>"))
                {
                    this.stopBits = (SerialPorts.StopBits) byte.Parse(text2);
                }
                if (text1.StartsWith("<Xon Char>"))
                {
                    this.xonChar = byte.Parse(text2);
                }
                if (text1.StartsWith("<Xoff Char>"))
                {
                    this.xoffChar = byte.Parse(text2);
                }
                if (text1.StartsWith("<Error Char>"))
                {
                    this.errChar = byte.Parse(text2);
                }
                if (text1.StartsWith("<EOF Char>"))
                {
                    this.eofChar = byte.Parse(text2);
                }
                if (text1.StartsWith("<Event Char>"))
                {
                    this.evtChar = byte.Parse(text2);
                }
                if (text1.StartsWith("<Handshaking>"))
                {
                    this.handshake = (Handshake) byte.Parse(text2);
                }
                if (text1.StartsWith("<RX Q Length>"))
                {
                    this.rxQueLen = int.Parse(text2);
                }
                if (text1.StartsWith("<TX Q Length>"))
                {
                    this.txQueLen = int.Parse(text2);
                }
                if (text1.StartsWith("<TX Timeout(M)>"))
                {
                    this.txTmoMulti = uint.Parse(text2);
                }
                if (text1.StartsWith("<TX Timeout(C)>"))
                {
                    this.txTmoConst = uint.Parse(text2);
                }
                if (text1.StartsWith("<Receive Mode>"))
                {
                    this.receiveMode = bool.Parse(text2);
                }
            }
            stream1.Close();
        }

        public void Save(string fName)
        {
            FileStream stream1 = new FileStream(fName, FileMode.Create, FileAccess.Write);
            StreamWriter writer1 = new StreamWriter(stream1);
            writer1.BaseStream.Seek((long) 0, SeekOrigin.Begin);
            writer1.WriteLine("<Port Name>      :{0}", this.portName);
            writer1.WriteLine("<Baud Rate>      :{0}", this.baudRate.ToString());
            writer1.WriteLine("<CTS Flow>       :{0}", this.txFlowCTS.ToString());
            writer1.WriteLine("<DSR Flow>       :{0}", this.txFlowDSR.ToString());
            writer1.WriteLine("<DTR Ctrl>       :{0}", this.dtrControl.ToString());
            writer1.WriteLine("<DSR Sense>      :{0}", this.rxDSRsense.ToString());
            writer1.WriteLine("<TX Continue>    :{0}", this.txContinue.ToString());
            writer1.WriteLine("<TX Xoff Flow>   :{0}", this.txFlowXoff.ToString());
            writer1.WriteLine("<RX Xoff Flow>   :{0}", this.rxFlowXoff.ToString());
            writer1.WriteLine("<Error Replace>  :{0}", this.errReplace.ToString());
            writer1.WriteLine("<Null Discard>   :{0}", this.nulDiscard.ToString());
            writer1.WriteLine("<RTS Control>    :{0}", this.rtsControl.ToString());
            writer1.WriteLine("<Abort On Error> :{0}", this.abortOnErr.ToString());
            writer1.WriteLine("<Xon Limit>      :{0}", this.xonLimit.ToString());
            writer1.WriteLine("<Xoff Limit>     :{0}", this.xoffLimit.ToString());
            writer1.WriteLine("<Bits/Byte>      :{0}", this.dataBits.ToString());
            writer1.WriteLine("<Parity>         :{0}", this.parity.ToString());
            writer1.WriteLine("<Stop Bits>      :{0}", this.stopBits.ToString());
            writer1.WriteLine("<Xon Char>       :{0:X}", this.xonChar.ToString());
            writer1.WriteLine("<Xoff Char>      :{0:X}", this.xoffChar.ToString());
            writer1.WriteLine("<Error Char>     :{0:X}", this.errChar.ToString());
            writer1.WriteLine("<EOF Char>       :{0:X}", this.eofChar.ToString());
            writer1.WriteLine("<Event Char>     :{0:X}", this.evtChar.ToString());
            writer1.WriteLine("<Handshaking>    :{0}", this.handshake.ToString());
            writer1.WriteLine("<RX Q Length>    :{0}", this.rxQueLen.ToString());
            writer1.WriteLine("<TX Q Length>    :{0}", this.txQueLen.ToString());
            writer1.WriteLine("<TX Timeout(M)>  :{0}", this.txTmoMulti.ToString());
            writer1.WriteLine("<TX Timeout(C)>  :{0}", this.txTmoConst.ToString());
            writer1.WriteLine("<Receive Mode>   :{0}", this.receiveMode.ToString());
            writer1.Flush();
            stream1.Close();
        }

        public void SetFlowControl()
        {
            switch (this.handshake)
            {
                case Handshake.None:
                {
                    this.txFlowCTS = false;
                    this.txFlowDSR = false;
                    this.txFlowXoff = false;
                    this.rxFlowXoff = false;
                    this.rtsControl = PinState.Disable;
                    this.dtrControl = PinState.Disable;
                    return;
                }
                case Handshake.CtsRts:
                {
                    this.txFlowCTS = true;
                    this.txFlowDSR = false;
                    this.txFlowXoff = false;
                    this.rxFlowXoff = false;
                    this.rtsControl = PinState.Handshake;
                    this.dtrControl = PinState.Disable;
                    return;
                }
                case Handshake.DsrDtr:
                {
                    this.txFlowCTS = false;
                    this.txFlowDSR = true;
                    this.txFlowXoff = false;
                    this.rxFlowXoff = false;
                    this.rtsControl = PinState.Disable;
                    this.dtrControl = PinState.Handshake;
                    return;
                }
                case Handshake.XonXoff:
                {
                    this.txFlowCTS = false;
                    this.txFlowDSR = false;
                    this.txFlowXoff = true;
                    this.rxFlowXoff = true;
                    this.rtsControl = PinState.Enable;
                    this.dtrControl = PinState.Enable;
                    return;
                }
            }
        }


        // Properties
        public bool AbortOnErr
        {
            get
            {
                return this.abortOnErr;
            }
            set
            {
                this.abortOnErr = value;
            }
        }

        public LineSpeed BaudRate
        {
            get
            {
                return this.baudRate;
            }
            set
            {
                this.baudRate = value;
            }
        }

        public ByteSize DataBits
        {
            get
            {
                return this.dataBits;
            }
            set
            {
                this.dataBits = value;
            }
        }

        public PinState DtrControl
        {
            get
            {
                return this.dtrControl;
            }
            set
            {
                this.dtrControl = value;
            }
        }

        public byte EofChar
        {
            get
            {
                return this.eofChar;
            }
            set