开发C#相关的项目有很多年了，一直没有接触串口的开发，近期由于工作的需要，需要了解熟悉对硬件串口的开发，通过对串口的深入了解，串口也不再是什么神秘的东西，利用SerailPort组件，对串口的各种操作也非常的方便，由于本人总是喜欢把一些常用的东西封装成可供重复利用的类库，因此，阅百家代码，提炼总结优化，把对串口的操作封装成一个公用的类库，应付日常的串口编程开发，也算是工作的一个阶段性总结吧。
先上图，了解串口的一些基本的东西，并逐步介绍相关的知识。
微软在 .NET FrameWork2.0中对串口通讯进行了封装，我们可以在.net2.0及以上版本开发时直接使用SerialPort类对串口进行读写操作。
SerialPort类的属性主要包括：
1）串口名称（PortName）
2）波特率（BaudRate）
3）数据位 DataBits
4）停止位 StopBits
5）奇偶校验 Parity
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
}
/// 串口数据位列表（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);
}
}
/// 设置串口号
/// </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;
}
{
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);
}
/// 参数构造函数（使用枚举参数构造）
/// </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);
}
}
{
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);
}
/// 端口是否已经打开
/// </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);
{
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;
/// 完整协议的记录处理事件
/// </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);
}
/// 参数构造函数（使用枚举参数构造）
/// </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);
}
}
在数据的接收还原中，我们用到了
在外部的宿主程序中，当有数据收到的时候，辅助类会通知其对数据进行处理，如我们在宿主程序中绑定处理代码如下所示。
void
serial_DataReceived(DataReceivedEventArgs e)
{
this .txtReceived.Invoke( new MethodInvoker( delegate
{
this .txtReceived.AppendText(e.DataReceived + Environment.NewLine);
}));
}
{
this .txtReceived.Invoke( new MethodInvoker( delegate
{
this .txtReceived.AppendText(e.DataReceived + Environment.NewLine);
}));
}
这样，一旦收到一条完整的协议，界面上就会在文本框中增加一行数据，如前面的图所示
最后呈上该串口辅助类库提供下载，欢迎大家提供改善意见，多多交流。
http://files.cnblogs.com/wuhuacong/SerialPortUtil.rar
本文转自博客园伍华聪的博客，原文链接：C#开发串口总结，并提炼串口辅助类到公用类库中，如需转载请自行联系原博主。
