1.   动机

1. 应用程序开发语言为C#
2. 应用程序要求既能在PDA上运行，又能在PC上运行，具备良好的兼容性
3. 应用程序要求尽可能多的兼容不同PDA上的红外线设备
4. .net自带的SerialPort在HP某型号PDA上操作红外线设备时，只能接受，不能发射

2.   目标

1. 具备良好的兼容性，既能够在PC上运行也能够在PDA上运行。
2. 挡在PDA上运行时，尽可能多的兼容红外设备。

3.   局限性

1. 单线程
2. 仅提供send/receive模式的接口，无事件驱动机制

4.   关键技术问题及典型测试案例

最关键的是对EscapeCommFunction的调用，当串口为红外设备时，必须调用此函数才能确保串口工作正常。当串口为一般的COM口时，出于兼容性的考虑，切勿调用此函数。

1. 在HP某PDA上测试时，不管串口是否为红外设备，均调用此函数启用红外功能，均能够工作正常。
2. 在SIEMENS某PDA上测试时，如果串口为一般COM接口，并且调用了此函数，那么串口不能正常工作，屏蔽此函数后，一切正常。

5.   源码

SerialPort Source Code
using System;
using System.Runtime.InteropServices;

namespace NativeDll
{
    public class SerialPort
    {
        serial port api#region serial port api
        //for ir control
        private const int SETIR = 10;
        private const int CLRIR = 11;
        //win32 api constants
        private const uint GENERIC_READ = 0x80000000;
        private const uint GENERIC_WRITE = 0x40000000;
        private const int OPEN_EXISTING = 3;
        private const int INVALID_HANDLE_VALUE = -1;
        private const int MAXBLOCK = 4096;

        private const uint PURGE_TXABORT = 0x0001;
        // Kill the pending/current writes to the comm port.
        private const uint PURGE_RXABORT = 0x0002;
        // Kill the pending/current reads to the comm port.
        private const uint PURGE_TXCLEAR = 0x0004;
        // Kill the transmit queue if there.
        private const uint PURGE_RXCLEAR = 0x0008;
        // Kill the typeahead buffer if there.

        [StructLayout(LayoutKind.Sequential)]
        private struct DCB
        {
            //taken from c struct in platform sdk
            public int DCBlength; // sizeof(DCB)
            public int BaudRate; // current baud rate
            public int fBinary; // binary mode, no EOF check
            public int fParity; // enable parity checking
            public int fOutxCtsFlow; // CTS output flow control
            public int fOutxDsrFlow; // DSR output flow control
            public int fDtrControl; // DTR flow control type
            public int fDsrSensitivity; // DSR sensitivity
            public int fTXContinueOnXoff; // XOFF continues Tx
            public int fOutX; // XON/XOFF out flow control
            public int fInX; // XON/XOFF in flow control
            public int fErrorChar; // enable error replacement
            public int fNull; // enable null stripping
            public int fRtsControl; // RTS flow control
            public int fAbortOnError; // abort on error
            public int fDummy2; // reserved
            public ushort wReserved; // not currently used
            public ushort XonLim; // transmit XON threshold
            public ushort XoffLim; // transmit XOFF threshold
            public byte ByteSize; // number of bits/byte, 4-8
            public byte Parity; // 0-4=no,odd,even,mark,space
            public byte StopBits; // 0,1,2 = 1, 1.5, 2
            public char XonChar; // Tx and Rx XON character
            public char XoffChar; // Tx and Rx XOFF character
            public char ErrorChar; // error replacement character
            public char EofChar; // end of input character
            public char EvtChar; // received event character
            public ushort wReserved1; // reserved; do not use
        }

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

        [StructLayout(LayoutKind.Sequential)]
        private struct OVERLAPPED
        {
            public int Internal;
            public int InternalHigh;
            public int Offset;
            public int OffsetHigh;
            public int hEvent;
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct COMSTAT
        {
            /**//*public int fCtsHold;
            public int fDsrHold;
            public int fRlsdHold;
            public int fXoffHold;
            public int fXoffSent;
            public int fEof;
            public int fTxim;
            public int fReserved;
            public int cbInQue;
            public int cbOutQue;*/
            // Should have a reverse, i don't know why!!!!!
            public int cbOutQue;
            public int cbInQue;
            public int fReserved;
            public int fTxim;
            public int fEof;
            public int fXoffSent;
            public int fXoffHold;
            public int fRlsdHold;
            public int fDsrHold;
            public int fCtsHold;
        }

        #endregion

        private int hComm = INVALID_HANDLE_VALUE;
        private bool bOpened = false;
        private API api = null;

        public SerialPort()
        {
            if (System.Environment.OSVersion.Platform != PlatformID.WinCE)
                api = new PCAPI();
            else
                api = new PDAAPI();
        }

        public bool Opened
        {
            get
            {
                return bOpened;
            }
        }

        /**//// <summary>
        /// open port
        /// </summary>
        /// <param name="lpFileName"></param>
        /// <param name="baudRate"></param>
        /// <param name="parity"></param>
        /// <param name="byteSize"></param>
        /// <param name="stopBits"></param>
        /// <returns></returns>
        public bool OpenPort(string lpFileName, int baudRate, byte parity, byte
            byteSize, byte stopBits)
        {
            // OPEN THE COMM PORT.
            hComm = api.CreateFile(lpFileName, GENERIC_READ | GENERIC_WRITE, 0,
                0, OPEN_EXISTING, 0, 0);
            // IF THE PORT CANNOT BE OPENED, BAIL OUT.
            if (hComm == INVALID_HANDLE_VALUE)
            {
                return false;
            }

            api.SetupComm(hComm, MAXBLOCK, MAXBLOCK);


            // SET THE COMM TIMEOUTS.
            COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS();
            api.GetCommTimeouts(hComm, ref ctoCommPort);
            ctoCommPort.ReadIntervalTimeout = Int32.MaxValue;
            ctoCommPort.ReadTotalTimeoutConstant = 1000;
            ctoCommPort.ReadTotalTimeoutMultiplier = 0;
            ctoCommPort.WriteTotalTimeoutMultiplier = 0;
            ctoCommPort.WriteTotalTimeoutConstant = 1000;
            api.SetCommTimeouts(hComm, ref ctoCommPort);

            // SET BAUD RATE, PARITY, word SIZE, AND STOP BITS.
            // THERE ARE OTHER WAYS OF DOING SETTING THESE BUT THIS IS THE EASIEST.
            // IF YOU WANT TO LATER ADD CODE FOR OTHER BAUD RATES, REMEMBER
            // THAT THE ARGUMENT FOR BuildCommDCB MUST BE A POINTER TO A STRING.
            // ALSO NOTE THAT BuildCommDCB() DEFAULTS TO NO HANDSHAKING.
            DCB dcbCommPort = new DCB();
            dcbCommPort.DCBlength = Marshal.SizeOf(dcbCommPort);
            api.GetCommState(hComm, ref dcbCommPort);
            dcbCommPort.BaudRate = baudRate;
            dcbCommPort.Parity = parity;
            dcbCommPort.ByteSize = byteSize;
            dcbCommPort.StopBits = stopBits;
            api.SetCommState(hComm, ref dcbCommPort);

            api.PurgeComm(hComm, PURGE_RXCLEAR | PURGE_RXABORT);
            api.PurgeComm(hComm, PURGE_TXCLEAR | PURGE_TXABORT);

            bOpened = true;
            return true;
        }
        /**//// <summary>
        /// when set this property ,be sure the port is opened.
        /// </summary>
        public bool IREnable
        {
            set
            {
                if (bOpened)
                {
                    if (System.Environment.OSVersion.Platform == PlatformID.WinCE)
                    {
                        if (value)
                        {
                            api.EscapeCommFunction(hComm, SETIR);//enable ir
                        }
                        else
                        {
                            api.EscapeCommFunction(hComm, CLRIR);//disable ir
                        }
                    }
                }
            }
        }
        /**//// <summary>
        /// get/set baudrate
        /// </summary>
        public int BaudRate
        {
            get
            {
                DCB dcbCommPort = new DCB();
                dcbCommPort.DCBlength = Marshal.SizeOf(dcbCommPort);
                api.GetCommState(hComm, ref dcbCommPort);
                return dcbCommPort.BaudRate;
            }
            set
            {
                DCB dcbCommPort = new DCB();
                dcbCommPort.DCBlength = Marshal.SizeOf(dcbCommPort);
                api.GetCommState(hComm, ref dcbCommPort);
                dcbCommPort.BaudRate = value;
                api.SetCommState(hComm, ref dcbCommPort);

                //12/21/2006 wang
                //api.PurgeComm(hComm, PURGE_RXCLEAR | PURGE_RXABORT);
                //api.PurgeComm(hComm, PURGE_TXCLEAR | PURGE_TXABORT);
            }
        }
        /**//// <summary>
        /// close port
        /// </summary>
        /// <returns></returns>
        public bool ClosePort()
        {
            if (hComm == INVALID_HANDLE_VALUE)
            {
                return false;
            }

            if (api.CloseHandle(hComm))
            {
                hComm = INVALID_HANDLE_VALUE;
                bOpened = false;
                return true;
            }
            else
            {
                return false;
            }
        }