開發C#相關的項目有很多年了，一直沒有接觸串口的開發，近期由于工作的需要，需要了解熟悉對硬件串口的開發，通過對串口的深入了解，串口也不再是什么神秘的東西，利用SerailPort組件，對串口的各種操作也非常的方便，由于本人總是喜歡把一些常用的東西封裝成可供重復利用的類庫，因此，閱百家代碼，提煉總結優化，把對串口的操作封裝成一個公用的類庫，應付日常的串口編程開發，也算是工作的一個階段性總結吧。

　　先上圖，了解串口的一些基本的東西，并逐步介紹相關的知識。

　　微軟在 .NET FrameWork2.0中對串口通訊進行了封裝，我們可以在.net2.0及以上版本開發時直接使用SerialPort類對串口進行讀寫操作。 SerialPort類的屬性主要包括：    

1）串口名稱（PortName）   

 2）波特率（BaudRate）  

3）數據位 DataBits    

4）停止位 StopBits

5）奇偶校驗 Parity  SerialPort類的事件主要包括：     DataReceived：用于異步接收串口數據事件

    ErrorReceived：錯誤處理事件

SerialPort類的方法主要包括： 

    Open();Close();Read();Write()、DiscardInBuffer()、DiscardOutBuffer()等

　　從上面的測試例子圖中，我們可以看到，一般對串口的操作，需要提供串口號、波特率、數據位、停止位、奇偶校驗的參數，用來構造一個串口操作類，以便實現具體的串口操作，而這些參數有的是系統內置的枚舉參數，我們可以通過遍歷枚舉對象來綁定下來列表（如停止位、奇偶校驗）；但有些參數卻不是系統內置的枚舉類型，例如波特率、數據位等，而且對這些參數操作也是串口開發經常用到的，因此，第一步，我對這些參數的綁定做了一個簡單的封裝。

　　1、先構造波特率、數據位這兩個枚舉對象，方便實際操作。

    /// <summary>
     /// 串口數據位列表（5,6,7,8）
     ///  </summary>
     public enum SerialPortDatabits : int
     {
         FiveBits = 5,
         SixBits = 6,
         SeventBits = 7,
         EightBits = 8
     }

     ///  <summary>
     /// 串口波特率列表。
     /// 

75,110,150,300,600,1200,2400,4800,9600,

14400,19200,28800,38400,56000,57600,
     /// 115200,128000,230400,256000
     ///  </summary>
     public enum SerialPortBaudRates : int
     {
         BaudRate_75 = 75,
         BaudRate_110 = 110,
         BaudRate_150 = 150,
         BaudRate_300 = 300,
         BaudRate_600 = 600,
         BaudRate_1200 = 1200,
         BaudRate_2400 = 2400,
         BaudRate_4800 = 4800,
         BaudRate_9600 = 9600,
         BaudRate_14400 = 14400,
         BaudRate_19200 = 19200,
         BaudRate_28800 = 28800,
         BaudRate_38400 = 38400,
         BaudRate_56000 = 56000,
         BaudRate_57600 = 57600,
         BaudRate_115200 = 115200,
         BaudRate_128000 = 128000,
         BaudRate_230400 = 230400,
         BaudRate_256000 = 256000
   } 

　　2、對常用的參數下拉列表綁定做一個封裝。

        /// <summary>
         /// 設置串口號
         ///  </summary>
         ///  <param name="obj"></param>
         public static void SetPortNameValues(ComboBox obj)
         {
             obj.Items.Clear();
             foreach (string str in SerialPort.GetPortNames())
             {
                 obj.Items.Add(str);
             }
         }

         ///  <summary>
         /// 設置波特率
         ///  </summary>
         public static void SetBauRateValues(ComboBox obj)
         {
             obj.Items.Clear();
              foreach (SerialPortBaudRates rate in Enum.

GetValues(typeof(SerialPortBaudRates)))
             {
                 obj.Items.Add(((int)rate).ToString());
             }
         }

         ///  <summary>
         /// 設置數據位
         ///  </summary>
         public static void SetDataBitsValues(ComboBox obj)
         {
             obj.Items.Clear();
              foreach (SerialPortDatabits databit in Enum.

GetValues(typeof(SerialPortDatabits)))
             {
                 obj.Items.Add(((int)databit).ToString());
             }
         }

         ///  <summary>
         /// 設置校驗位列表
         ///  </summary>
         public static  void SetParityValues(ComboBox obj)
         {
             obj.Items.Clear();
             foreach (string str in Enum.GetNames(typeof(Parity)))
             {
                 obj.Items.Add(str);
             }
         }

         ///  <summary>
         /// 設置停止位
         ///  </summary>
         public static void SetStopBitValues(ComboBox obj)
         {
             obj.Items.Clear();
             foreach (string str in Enum.GetNames(typeof(StopBits)))
             {
                 obj.Items.Add(str);
             } 
        }

　　這樣我們在窗體界面代碼中，綁定相關參數的數據源就很方便了，如下所示。

        private void Form1_Load(object sender, EventArgs e)
         {
             BindData();
         }

         private void BindData()
         {
             //綁定端口號
             SerialPortUtil.SetPortNameValues(txtPort);
             txtPort.SelectedIndex = 0;

             //波特率
             SerialPortUtil.SetBauRateValues(txtBaudRate);
             txtBaudRate.SelectedText =  "57600";

             //數據位
             SerialPortUtil.SetDataBitsValues(txtDataBits);
             this.txtDataBits.SelectedText =  "8";

             //校驗位
             SerialPortUtil.SetParityValues(txtParity);
             this.txtParity.SelectedIndex = 0;

             //停止位
             SerialPortUtil.SetStopBitValues(txtStopBit);
             this.txtStopBit.SelectedIndex = 1;
          
             this.btnSend.Enabled = isOpened;
          }

　　3、 為了方便構造封裝的窗口類，提供了兩個不同類型參數的串口輔助類構造函數，一個可以使用枚舉參數，一個使用字符串參數（最終轉換為枚舉參數對象），如下所示。使用枚舉對象，不需要記住不同參數應該填寫那些值，只需要從枚舉中選擇即可，方便又直觀。

        /// <summary>
         /// 參數構造函數（使用枚舉參數構造）
         ///  </summary>
         ///  <param name="baud">波特率</param>
         ///  <param name="par">奇偶校驗位</param>
         ///  <param name="sBits">停止位</param>
         ///  <param name="dBits">數據位</param>
         ///  <param name="name">串口號</param>
          public SerialPortUtil(string name, SerialPortBaudRates baud, 

Parity par, SerialPortDatabits dBits, StopBits sBits)
         {
             _portName = name;
             _baudRate = baud;
             _parity = par;
             _dataBits = dBits;
             _stopBits = sBits;

   comPort.DataReceived +=

 new SerialDataReceivedEventHandler(comPort_DataReceived);
comPort.ErrorReceived += 

new SerialErrorReceivedEventHandler(comPort_ErrorReceived);
         }

         ///  <summary>
         /// 參數構造函數（使用字符串參數構造）
         ///  </summary>
         ///  <param name="baud">波特率</param>
         ///  <param name="par">奇偶校驗位</param>
         ///  <param name="sBits">停止位</param>
         ///  <param name="dBits">數據位</param>
         ///  <param name="name">串口號</param>
          public SerialPortUtil(string name, string baud, 

string par, string dBits, string sBits)
         {
             _portName = name;
              _baudRate = (SerialPortBaudRates)Enum.

Parse(typeof(SerialPortBaudRates), baud);
             _parity = (Parity)Enum.Parse(typeof(Parity), par);
              _dataBits = (SerialPortDatabits)Enum.

Parse(typeof(SerialPortDatabits), dBits);
             _stopBits = (StopBits)Enum.Parse(typeof(StopBits), sBits);

  comPort.DataReceived += 

new SerialDataReceivedEventHandler(comPort_DataReceived);
  comPort.ErrorReceived +=

 new SerialErrorReceivedEventHandler(comPort_ErrorReceived);
        }

　　構造函數做好了，就很方便在實際的窗體界面函數中構造串口實例了，如下使用代碼所示：

private void btnConnect_Click(object sender, EventArgs e)
         {
             try
             {
                 if (serial == null)
                 {
                     try
                     {
                         string portname = this.txtPort.Text;
                          SerialPortBaudRates rate = (SerialPortBaudRates)

　　Enum.Parse(typeof(SerialPortBaudRates),

 this.txtBaudRate.Text);//int.Parse(this.txtBaudRate.Text);
SerialPortDatabits databit = (SerialPortDatabits)int.Parse(this.txtDataBits.Text);
Parity party = (Parity)Enum.Parse(typeof(Parity), this.txtParity.Text);
StopBits stopbit = (StopBits)Enum.Parse(typeof(StopBits), this.txtStopBit.Text);

//使用枚舉參數構造
//serial = new SerialPortUtil(portname, rate, party, databit, stopbit);

//使用字符串參數構造
 serial = new SerialPortUtil(portname, this.txtBaudRate.Text, 

this.txtParity.Text, this.txtDataBits.Text, this.txtStopBit.Text);
serial.DataReceived +=

 new DataReceivedEventHandler(serial_DataReceived);

}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
serial = null;
return;
}
}

if (!isOpened)
{                    
serial.OpenPort();
btnConnect.Text =  "斷開";
}
else
{
serial.ClosePort();
serial = null;

btnConnect.Text =  "連接";
}

isOpened = !isOpened;
this.btnSend.Enabled = isOpened;
this.lblTips.Text = isOpened ?  "已連接" : "未連接";
}
catch (Exception ex)
{
this.lblTips.Text = ex.Message;
MessageBox.Show(ex.Message);
}
}

　　4、對串口數據的發送以及串口的一些基本操作進行簡單封裝，方便輔助類對串口進行相關操作。

        /// <summary>
         /// 端口是否已經打開
         ///  </summary>
         public bool IsOpen
         {
             get
             {
                 return comPort.IsOpen;
             }
         }

         ///  <summary>
         /// 打開端口
         ///  </summary>
         ///  <returns></returns>
         public void OpenPort()
         {
             if (comPort.IsOpen) comPort.Close();

             comPort.PortName = _portName;
             comPort.BaudRate = (int)_baudRate;
             comPort.Parity = _parity;
             comPort.DataBits = (int)_dataBits;
             comPort.StopBits = _stopBits;

             comPort.Open();
         }

         ///  <summary>
         /// 關閉端口
         ///  </summary>
         public void ClosePort()
         {
             if (comPort.IsOpen) comPort.Close();
         }

         ///  <summary>
         /// 丟棄來自串行驅動程序的接收和發送緩沖區的數據
         ///  </summary>
         public void DiscardBuffer()
         {
             comPort.DiscardInBuffer();
             comPort.DiscardOutBuffer();
         }

         ///  <summary>
         /// 寫入數據
         ///  </summary>
         ///  <param name="msg"></param>
         public void WriteData(string msg)
         {
             if (!(comPort.IsOpen)) comPort.Open();

             comPort.Write(msg);
         }

         ///  <summary>
         /// 寫入數據
         ///  </summary>
         ///  <param name="msg">寫入端口的字節數組</param>
         public void WriteData(byte[] msg)
         {
             if (!(comPort.IsOpen)) comPort.Open();

             comPort.Write(msg, 0, msg.Length);
         }

         ///  <summary>
         /// 寫入數據
         ///  </summary>
         ///  <param name="msg">包含要寫入端口的字節數組</param>
         ///  <param name="offset">參數從0字節開始的字節偏移量</param>
         ///  <param name="count">要寫入的字節數</param>
         public void WriteData(byte[] msg, int offset, int count)
         {
             if (!(comPort.IsOpen)) comPort.Open();

             comPort.Write(msg, offset, count);
        }

　　6、接收數據的還原

　　這樣基本上就對串口封裝的差不多了，不過還有一個重要的操作就是對串口的數據進行接收，并進行處理。由于串口獲取數據不是一次性完整的獲取的，可能會被拆分為好幾段，因此，如何還原接收到的數據也就是一個值得注意的問題，這個最好能根據協議來確定，如我的協議基本上是以“~”符號開始，以“#”符號結束，因此我對協議數據的還原，就有可依據的準則。

1）首先要構造一個數據處理的代理，和一個數據處理的事件參數類，如下所示。 

    public class DataReceivedEventArgs : EventArgs
     {
         public string DataReceived;
         public DataReceivedEventArgs(string m_DataReceived)
         {
             this.DataReceived = m_DataReceived;
         }
     }

      public delegate void DataReceivedEventHandler(DataReceivedEventArgs e); 

2）然后構造一個數據接收和錯誤處理的事件，如下所示

        /// <summary>
         /// 完整協議的記錄處理事件
         ///  </summary>
         public event DataReceivedEventHandler DataReceived;
          public event SerialErrorReceivedEventHandler Error; 

3）在構造函數添加相關的事件處理，如下所示

        /// <summary>
         /// 參數構造函數（使用枚舉參數構造）
         ///  </summary>
         ///  <param name="baud">波特率</param>
         ///  <param name="par">奇偶校驗位</param>
         ///  <param name="sBits">停止位</param>
         ///  <param name="dBits">數據位</param>
         ///  <param name="name">串口號</param>
          public SerialPortUtil(string name, SerialPortBaudRates baud, Parity par, 

SerialPortDatabits dBits, StopBits sBits)
         {
             _portName = name;
             _baudRate = baud;
             _parity = par;
             _dataBits = dBits;
             _stopBits = sBits;

              comPort.DataReceived += 

new SerialDataReceivedEventHandler(comPort_DataReceived);
              comPort.ErrorReceived += 

new SerialErrorReceivedEventHandler(comPort_ErrorReceived);
      }

 4）實現對數據的接收和錯誤的處理 

        /// <summary>  

      /// 結束符比特      

  /// </summary>  

      public byte EndByte = 0x23;//string End = "#";
         ///  <summary>
         /// 數據接收處理
         ///  </summary>
void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
         {
             //禁止接收事件時直接退出
             if (ReceiveEventFlag) return;

             #region 根據結束字節來判斷是否全部獲取完成
             List <byte> _byteData = new List<byte>();
             bool found = false;//是否檢測到結束符號
             while (comPort.BytesToRead  > 0 || !found)
             {
                 byte[] readBuffer = new byte[comPort.ReadBufferSize + 1];
                 int count = comPort.Read(readBuffer, 0, comPort.ReadBufferSize);
                 for (int i = 0; i  < count; i++)
                 {
                     _byteData.Add(readBuffer[i]);

                     if (readBuffer[i] == EndByte)
                     {
                         found = true;
                     }
                 }
             } 
             #endregion
            
             //字符轉換
              string readString = 

System.Text.Encoding.Default.GetString(_byteData.ToArray(), 0, _byteData.Count);
            
             //觸發整條記錄的處理
             if (DataReceived != null)
             {
                 DataReceived(new DataReceivedEventArgs(readString));
             }
         }

         ///  <summary>
         /// 錯誤處理函數
         ///  </summary>
         void comPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
         {
             if (Error != null)
             {
                 Error(sender, e);
             }
        }

　　在數據的接收還原中，我們用到了 EndByte的變量，這個變量是協議數據的結束字符，如果檢測到有這個字符的，就表明收到了一條完整的協議，可以把收到的字節數組組裝成文本字符串，然后交給委托事件進行處理即可。

　　在外部的宿主程序中，當有數據收到的時候，輔助類會通知其對數據進行處理，如我們在宿主程序中綁定處理代碼如下所示。

        void serial_DataReceived(DataReceivedEventArgs e)
         {
             this.txtReceived.Invoke(new MethodInvoker(delegate
             {
                 this.txtReceived.AppendText(e.DataReceived + Environment.NewLine);
             }));
        }

　　這樣，一旦收到一條完整的協議，界面上就會在文本框中增加一行數據，如前面的圖所示