Serial通信的例子(二)

public override long Position { get { return 0; } set { } }

        public void SetTimeouts(int ReadIntervalTimeout, int ReadTotalTimeoutMultiplier, int ReadTotalTimeoutConstant,
                                int WriteTotalTimeoutMultiplier, int WriteTotalTimeoutConstant) {
            SerialTimeouts Timeouts = new SerialTimeouts(ReadIntervalTimeout, ReadTotalTimeoutMultiplier, ReadTotalTimeoutConstant,
                                         WriteTotalTimeoutMultiplier, WriteTotalTimeoutConstant);
            unsafe { SetCommTimeouts(m_hFile, &Timeouts); }
        }

        public enum Parity {None, Odd, Even, Mark, Space};
        public enum StopBits {One, OneAndHalf, Two};
        public enum FlowControl {None, XOnXOff, Hardware};

        [StructLayout(LayoutKind.Sequential)]
        public struct DCB {
            public int DCBlength;
            public uint BaudRate;
            public uint Flags;
            public uint fBinary { get { return Flags&0x0001; }
                                  set { Flags = Flags & ~1U | value; } }
            public uint fParity { get { return (Flags>>1)&1; }
                                  set { Flags = Flags & ~(1U << 1) | (value << 1); } }
            public uint fOutxCtsFlow { get { return (Flags>>2)&1; }
                                  set { Flags = Flags & ~(1U << 2) | (value << 2); } }
            public uint fOutxDsrFlow { get { return (Flags>>3)&1; }
                                  set { Flags = Flags & ~(1U << 3) | (value << 3); } }
            public uint fDtrControl { get { return (Flags>>4)&3; }
                                  set { Flags = Flags & ~(3U << 4) | (value << 4); } }
            public uint fDsrSensitivity { get { return (Flags>>6)&1; }
                                  set { Flags = Flags & ~(1U << 6) | (value << 6); } }
            public uint fTXContinueOnXoff { get { return (Flags>>7)&1; }
                                  set { Flags = Flags & ~(1U << 7) | (value << 7); } }
            public uint fOutX { get { return (Flags>>8)&1; }
                                  set { Flags = Flags & ~(1U << 8) | (value << 8); } }
            public uint fInX { get { return (Flags>>9)&1; }
                                  set { Flags = Flags & ~(1U << 9) | (value << 9); } }
            public uint fErrorChar { get { return (Flags>>10)&1; }
                                  set { Flags = Flags & ~(1U << 10) | (value << 10); } }
            public uint fNull { get { return (Flags>>11)&1; }
                                  set { Flags = Flags & ~(1U << 11) | (value << 11); } }
            public uint fRtsControl { get { return (Flags>>12)&3; }
                                  set { Flags = Flags & ~(3U << 12) | (value << 12); } }
            public uint fAbortOnError { get { return (Flags>>13)&1; }
                                  set { Flags = Flags & ~(1U << 13) | (value << 13); } }
            public ushort wReserved;
            public ushort XonLim;
            public ushort XoffLim;
            public byte ByteSize;
            public byte Parity;
            public byte StopBits;
            public sbyte XonChar;
            public sbyte XoffChar;
            public sbyte ErrorChar;
            public sbyte EofChar;
            public sbyte EvtChar;
            public ushort wReserved1;

            public override string ToString() {
                return "DCBlength: " + DCBlength + "\r\n" +
                    "BaudRate: " + BaudRate + "\r\n" +
                    "fBinary: " + fBinary + "\r\n" +
                    "fParity: " + fParity + "\r\n" +
                    "fOutxCtsFlow: " + fOutxCtsFlow + "\r\n" +
                    "fOutxDsrFlow: " + fOutxDsrFlow + "\r\n" +
                    "fDtrControl: " + fDtrControl + "\r\n" +
                    "fDsrSensitivity: " + fDsrSensitivity + "\r\n" +
                    "fTXContinueOnXoff: " + fTXContinueOnXoff + "\r\n" +
                    "fOutX: " + fOutX + "\r\n" +
                    "fInX: " + fInX + "\r\n" +
                    "fErrorChar: " + fErrorChar + "\r\n" +
                    "fNull: " + fNull + "\r\n" +
                    "fRtsControl: " + fRtsControl + "\r\n" +
                    "fAbortOnError: " + fAbortOnError + "\r\n" +
                    "XonLim: " + XonLim + "\r\n" +
                    "XoffLim: " + XoffLim + "\r\n" +
                    "ByteSize: " + ByteSize + "\r\n" +
                    "Parity: " + Parity + "\r\n" +
                    "StopBits: " + StopBits + "\r\n" +
                    "XonChar: " + XonChar + "\r\n" +
                    "XoffChar: " + XoffChar + "\r\n" +
                    "EofChar: " + EofChar + "\r\n" +
                    "EvtChar: " + EvtChar + "\r\n";
            }
        }

        public bool SetPortSettings(uint baudrate, byte databits, StopBits stopbits, Parity parity, FlowControl flowcontrol) {
            unsafe {
                DCB dcb = new DCB();
                dcb.DCBlength = sizeof(DCB);
                dcb.BaudRate = baudrate;
                dcb.ByteSize = databits;
                dcb.StopBits = (byte)stopbits;
                dcb.Parity = (byte)parity;
                dcb.fParity = (parity > 0)? 1U : 0U;
                dcb.fBinary = dcb.fDtrControl = dcb.fTXContinueOnXoff = 1;
                dcb.fOutxCtsFlow = dcb.fAbortOnError = (flowcontrol == FlowControl.Hardware)? 1U : 0U;
                dcb.fOutX = dcb.fInX = (flowcontrol == FlowControl.XOnXOff)? 1U : 0U;
                dcb.fRtsControl = (flowcontrol == FlowControl.Hardware)? 2U : 1U;
                dcb.XonLim = 2048;
                dcb.XoffLim = 512;
                dcb.XonChar = 0x11; // Ctrl-Q
                dcb.XoffChar = 0x13; // Ctrl-S
                return SetCommState(m_hFile, &dcb);
            }
        }

        public bool GetPortSettings(out DCB dcb) {
            unsafe {
                DCB dcb2 = new DCB();
                dcb2.DCBlength = sizeof(DCB);
                bool ret = GetCommState(m_hFile, &dcb2);
                dcb = dcb2;
                return ret;
            }
        }

        [DllImport("kernel32.dll", SetLastError=true, CharSet=CharSet.Auto)]
        static extern int CreateFile(string filename, uint aclearcase/" target="_blank" >ccess, uint sharemode, uint security_attributes, uint creation, uint flags, uint template);

        [DllImport("kernel32.dll", SetLastError=true)]
        static extern bool CloseHandle(int handle);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool ReadFile(int hFile, byte* lpBuffer, int nNumberOfBytesToRead, int* lpNumberOfBytesRead, NativeOverlapped* lpOverlapped);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool WriteFile(int hFile, byte* lpBuffer, int nNumberOfBytesToWrite, int* lpNumberOfBytesWritten, NativeOverlapped* lpOverlapped);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool SetCommTimeouts(int hFile, SerialTimeouts* lpCommTimeouts);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool SetCommState(int hFile, DCB* lpDCB);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool GetCommState(int hFile, DCB* lpDCB);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool BuildCommDCB(string def, DCB* lpDCB);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern int GetLastError();

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool FlushFileBuffers(int hFile);

        [DllImport("kernel32.dll", SetLastError=true)]
        static unsafe extern bool PurgeComm(int hFile, uint dwFlags);
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct SerialTimeouts {
        public int ReadIntervalTimeout;
        public int ReadTotalTimeoutMultiplier;
        public int ReadTotalTimeoutConstant;
        public int WriteTotalTimeoutMultiplier;
        public int WriteTotalTimeoutConstant;

        public SerialTimeouts(int r1, int r2, int r3, int w1, int w2) {
            ReadIntervalTimeout = r1;
            ReadTotalTimeoutMultiplier = r2;
            ReadTotalTimeoutConstant = r3;
            WriteTotalTimeoutMultiplier = w1;
            WriteTotalTimeoutConstant = w2;
        }

        public override string ToString() {
            return "ReadIntervalTimeout: " + ReadIntervalTimeout + "\r\n" +
                   "ReadTotalTimeoutMultiplier: " + ReadTotalTimeoutMultiplier + "\r\n" +
                   "ReadTotalTimeoutConstant: " + ReadTotalTimeoutConstant + "\r\n" +
                   "WriteTotalTimeoutMultiplier: " + WriteTotalTimeoutMultiplier + "\r\n" +
                   "WriteTotalTimeoutConstant: " + WriteTotalTimeoutConstant + "\r\n";
        }
    }

    public class SerialSettings {
        private bool m_bDirty = false;
        public bool Dirty { get { return m_bDirty; } }

        // Timeouts
        private SerialTimeouts Timeouts = new SerialTimeouts(1, 0, 0, 0, 0);

        public int ReadIntervalTimeout {
            get { return Timeouts.ReadIntervalTimeout; }
            set { if (Timeouts.ReadIntervalTimeout != value) {
                      Timeouts.ReadIntervalTimeout = value;
                      m_bDirty = true;
                  }
            }
        }

        public int ReadTotalTimeoutMultiplier {
            get { return Timeouts.ReadTotalTimeoutMultiplier; }
            set { if (Timeouts.ReadTotalTimeoutMultiplier != value) {
                    Timeouts.ReadTotalTimeoutMultiplier = value;
                    m_bDirty = true;
                  }
            }
        }

        public int ReadTotalTimeoutConstant {
            get { return Timeouts.ReadTotalTimeoutConstant; }
            set { if (Timeouts.ReadTotalTimeoutConstant != value) {
                      Timeouts.ReadTotalTimeoutConstant = value;
                      m_bDirty = true;
                  }
            }
        }

        public int WriteTotalTimeoutMultiplier {
            get { return Timeouts.WriteTotalTimeoutMultiplier; }
            set { if (Timeouts.WriteTotalTimeoutMultiplier != value) {
                      Timeouts.WriteTotalTimeoutMultiplier = value;
                      m_bDirty = true;
                  }
            }
        }

        public int WriteTotalTimeoutConstant {
            get { return Timeouts.WriteTotalTimeoutConstant; }
            set { if (Timeouts.WriteTotalTimeoutConstant != value) {
                      Timeouts.WriteTotalTimeoutConstant = value;
                      m_bDirty = true;
                  }
            }
        }

        // Valid stuff
        private static readonly object[] s_iValidBitRates = new object[] {75u, 110u, 134u, 150u, 300u, 600u, 1200u, 1800u, 2400u, 4800u,
                7200u, 9600u, 14400u, 19200u, 38400u, 57600u, 115200u, 128000u};
        public static object[] ValidBitRates {
            get { return s_iValidBitRates; }
        }

        private static readonly object[] s_iValidDataBits = new object[] {(byte)5, (byte)6, (byte)7, (byte)8};
        public static object[] ValidDataBits {
            get { return s_iValidDataBits; }
        }

        // Port settings
        private uint m_iBitRate = 57600;
        public uint BitRate {
            get { return m_iBitRate; }
            set { if (m_iBitRate != value) {
                      m_iBitRate = value;
                      m_bDirty = true;
                  }
            }
        }

        private byte m_iDataBits = 8;
        public byte DataBits {
            get { return m_iDataBits; }
            set { if (m_iDataBits != value) {
                      m_iDataBits = value;
                      m_bDirty = true;
                  }
            }
        }

        private SerialStream.Parity m_Parity = SerialStream.Parity.None;
        public SerialStream.Parity Parity {
            get { return m_Parity; }
            set { if (m_Parity != value) {
                      m_Parity = value;
                      m_bDirty = true;
                  }
            }
        }

        private SerialStream.StopBits m_StopBits = SerialStream.StopBits.One;
        public SerialStream.StopBits StopBits {
            get { return m_StopBits; }
            set { if (m_StopBits != value) {
                      m_StopBits = value;
                      m_bDirty = true;
                  }
            }
        }

        private SerialStream.FlowControl m_FlowControl = SerialStream.FlowControl.None;
        public SerialStream.FlowControl FlowControl {
            get { return m_FlowControl; }
            set { if (m_FlowControl != value) {
                      m_FlowControl = value;
                      m_bDirty = true;
                  }
            }
        }
    }
/*
    public class SerialTest {
        public static void Main() {
            SerialStream s = new SerialStream("COM1", FileAccess.ReadWrite);
            byte[] inBuffer = new byte[1000];

            s.SetPortSettings(9600, 8, SerialStream.StopBits.One, SerialStream.Parity.None, SerialStream.FlowControl.Hardware);
            s.SetTimeouts(2000, 0, 0, 0, 0);
            int read = s.Read(inBuffer, 0, inBuffer.Length);
            for (int i=0; i<read; i++)
                Console.Write("{0:X}", inBuffer[i]);
            s.Close();
        }
    }
*/
}

原文转自：http://www.ltesting.net