C#实现串口通信

一个小项目中应用到的串口通信,把核心源码整理一下.
C#实现串口通信其实非常简单，用到的类 SerialPort ,引用的命名空间System.IO.Ports.SerialPort类中主要用到的属性，有一下几个：
   PortName 通信端口名称
   BaudRate 串行波特率
   DataBits 每个字节的标准数据位长度
   Parity  奇偶校验检查协议
   StopBits 每个字节的标准停止位数
   HandShaking 串行端口数据传输的握手协议
SerialPort方法：
   Open 打开一个新的串行端口连接
   Write 将数据写入串行端口输出缓冲区
   WriteLine 将指定的字符串和NewLine值输出缓冲区
   Read 从缓冲区读取数据
   ReadLine 一直读取到输入缓冲区中的NewLine值
 
将SerialPort的类操作封装了一下，呵呵，见下类SerialPortCommunication          

1. using System;
2. using System.Collections.Generic;
3. 
   
4. using System.Text;
5. using System.IO.Ports;
6. using System.Threading;
7. namespace SerialPortComm
8. {
9.     public class SerialPortCommunication
10.     {
11.         #region SerialPort 基本设置
12.         /// <summary>
13.         /// 端口号
14.         /// </summary>
15.         public string PortName = "COM1";
16.         /// <summary>
17.         /// 波特率
18.         /// </summary>
19.         public Int32 BaudRate = 9600;
20.         /// <summary>
21.         /// 数据位
22.         /// </summary>
23.         public int DataBits = 8;
24.         /// <summary>
25.         /// 校验位
26.         /// </summary>
27.         public string Paritys = "None";
28.         /// <summary>
29.         /// 停止位
30.         /// </summary>
31.         public string StopBits = "One";
32.         /// <summary>
33.         /// 握手协议
34.         /// </summary>
35.         public string HandShaking = "None";
36.         #endregion
37. 
    
38. 
    
39.         private Thread thread = null;
40.         SerialPort serialPort = new SerialPort();
41. 
    
42.         public bool KeepRead = true;
43.         /// <summary>
44.         /// 接受数据
45.         /// </summary>
46.         public event SerialPortEventHandler ReceivedData;
47. 
    
48.         /// <summary>
49.         /// 异常处理
50.         /// </summary>
51.         public event SerialPortEventHandler SerialPortException;
52. 
    
53. 
    
54.         public SerialPortCommunication(string portName)
55.         {
56.             PortName = portName;
57. 
    
58.             //构造函数初始化
59. 
    
60.             SerialPortSetting spSetting = new SerialPortSetting("config.xml");
61.             PortConfig pConfig = spSetting.GetSerialPortName(PortName);
62.             if (pConfig == null)
63.             {
64.                 pConfig = new PortConfig();
65.                 pConfig.PortName = this.PortName;
66.                 spSetting.AddSerialPort(pConfig);//不存在则添加默认配置
67.             }
68.             //加载配置信息
69.             this.BaudRate = Int32.Parse(pConfig.BaudRate);
70.             this.DataBits = int.Parse(pConfig.DataBits);
71.             this.Paritys = pConfig.Paritys;
72.             this.StopBits = pConfig.StopBits;
73.             this.HandShaking = pConfig.HandShaking;
74.         }
75. 
    
76. 
    
77.         /// <summary>
78.         /// 打开端口
79.         /// </summary>
80.         public void Open()
81.         {
82.             serialPort.Encoding = Encoding.UTF8;//编码
83. 
    
84.             serialPort.PortName = PortName;
85.             serialPort.BaudRate = BaudRate;
86.             serialPort.DataBits = DataBits;
87.             serialPort.Parity = (Parity)Enum.Parse(typeof(Parity), Paritys);
88.             serialPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits), StopBits);
89.             serialPort.Handshake = (Handshake)Enum.Parse(typeof(Handshake), HandShaking);
90. 
    
91.             serialPort.WriteTimeout = 100;
92.             serialPort.ReadTimeout = 100;
93. 
    
94.             if (serialPort.IsOpen)
95.             {
96.                 serialPort.Close();
97.             }
98.             try
99.             {
100.                 serialPort.Open();
101.                 Start();
102.             }
103.             catch
104.             {
105.                 SerialPortException(this, new SerialPortEventArgs(serialPort.PortName, "打开异常,端口已经存在或已经占用！"));
106.             }
107.         }
108. 
     
109. 
     
110.         /// <summary>
111.         /// 返回端口打开状态
112.         /// </summary>
113.         public bool IsOpen
114.         {
115.             get { return serialPort.IsOpen; }
116.         }
117. 
     
118. 
     
119.         /// <summary>
120.         /// 发送字符串
121.         /// </summary>
122.         /// <param name="sendStrings"></param>
123.         public void SendLine(string sendStrings)
124.         {
125.             serialPort.WriteLine(sendStrings);
126. 
     
127.         }
128. 
     
129.         /// <summary>
130.         /// 发送字符串
131.         /// </summary>
132.         /// <param name="sendStrings"></param>
133.         public void Send(string sendStrings)
134.         {
135.             serialPort.Write(sendStrings);
136. 
     
137.         }
138. 
     
139.         /// <summary>
140.         /// 发送字符串(开始和结束的字符串)
141.         /// </summary>
142.         /// <param name="sendStrings">发送的字符串</param>
143.         /// <param name="StartStrings">开始字符串</param>
144.         /// <param name="EndStrings">结束字符串</param>
145.         public void Send(string sendStrings, string StartStrings, string EndStrings)
146.         {
147.             serialPort.Write(StartStrings + sendStrings + EndStrings);
148.         }
149. 
     
150.         /// <summary>
151.         /// 关闭端口
152.         /// </summary>
153.         public void Close()
154.         {
155.             if (thread != null && serialPort != null)
156.             {
157.                 KeepRead = false;
158.                 thread.Join();
159.                 thread = null;
160.                 serialPort.Close();
161.                 serialPort = null;
162.             }
163.         }
164. 
     
165. 
     
166.         //接受数据处理
167.         public void ReceiveProcess()
168.         {
169.             while (KeepRead)
170.             {
171.                 if (serialPort.IsOpen)
172.                 {
173.                     try
174.                     {
175.                         string ReceiveLine = serialPort.ReadLine();
176.                         ReceivedData(this, new SerialPortEventArgs(serialPort.PortName, ReceiveLine));
177.                     }
178.                     catch
179.                     {
180.                        //超时
181.                     }
182.                 }
183.             }
184.         }
185. 
     
186.         private void Start()
187.         {
188.             if (KeepRead)
189.             {
190.                 thread = new Thread(new ThreadStart(ReceiveProcess));
191.                 thread.Start();
192.             }
193.         }
194. 
     
195.     }
196. }
197. 
     

下面代码主要为 SerialPortCommunication 事件的参数

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. namespace SerialPortComm
6. {
8.     /// <summary>
9.     /// SerialPort事件处理委托
10.     /// </summary>
11.     /// <param name="sender"></param>
12.     /// <param name="e"></param>
13.     public delegate void SerialPortEventHandler(object sender, SerialPortEventArgs e);
15.     /// <summary>
16.     /// 事件参数
17.     /// </summary>
18.     public class SerialPortEventArgs : EventArgs
19.     {
21.         private string _Message;
23.         private string _PortName;
24.         /// <summary>
25.         /// 消息
26.         /// </summary>
27.         public string Message
28.         {
29.             set { _Message = value; }
30.             get { return _Message; }
31.         }
33.         /// <summary>
34.         /// 端口名
35.         /// </summary>
36.         public string PortName
37.         {
38.             set { _PortName = value; }
39.             get { return _PortName; }
40.         }
42.         /// <summary>
43.         /// 构造函数
44.         /// </summary>
45.         /// <param name="portName">端口名称</param>
46.         /// <param name="message">消息内容</param>
47.         public SerialPortEventArgs(string portName, string message)
48.         {
49.             this.PortName = portName;
50.             this.Message = message;
51.         }
53.     }
54. }

XML配置类 SerialPortSetting 代码略，可以见前一篇文章...


PS.1.通信双放设置必须一致；2.计算机与计算机串口通信时候记得用交叉线。