用于串行端口操作的类，包括写和读操作。类可以设置串口参数，设置接收函数，打开串口资源，关闭串口资源。操作完成后，它必须关闭串口，接收串行数据事件，接收数据错误事件，获取所有当前串口，并将字节类型转换为十六进制字符串。此串行端口类已经过调试，可以使用:
使用系统；
使用系统。***。泛型；
使用系统。文本；
使用系统。IO .端口；
使用系统。全球化；
命名空间SerialClass
{
公共类串行类
{
SerialPort _ serialPort = null
//定义委托
公共委托void SerialPortDataReceiveEventArgs(对象发送方，SerialDataReceivedEventArgs e，byte[]bits)；
//定义接收数据事件
公共事件SerialPortDataReceiveEventArgs data received；
//定义接收错误事件
//公共事件serial errorreceivedeventhandler错误；
//接收事件是否有效。false表示有效。
public bool ReceiveEventFlag = false；
#region获取串行端口名称
私有字符串protName
公共字符串端口名
{
获取{ return _serialPort。端口名；}
设置
{
_串行端口。PortName = value
protName = value
}
}
#结束区域
#区域获取比特率
private int baudRate
公共int波特率
{
获取{ return _serialPort。波德拉特；}
设置
{
_串行端口。BaudRate =值；
baudRate =值；
}
}
#结束区域
#区域默认构造函数
///<总结& gt
///默认构造函数，运算COM1，速度9600，无奇偶校验，8位字节，停止位为1 “COM1 & # 8221，9600，平价。无，8，停止位。一个
///</sum***ry >
公共SerialClass()
{
_ serial port = new serial port()；
}
#结束区域
#区域构造函数
///<总结& gt
///构造函数，
///</sum***ry >
///<param name = & # 8221comPortName & # 8221& gt& lt/param >
公共SerialClass(字符串组件名)
{
_ serial port = new serial port(comport name)；
_串行端口。波德拉特= 9600；
_串行端口。平价=平价。甚至；
_串行端口。数据位数= 8；
_串行端口。停止位=停止位。一；
_串行端口。握手=握手。无；
_串行端口。RtsEnable = true
_串行端口。ReadTimeout = 2000
set serial port()；
}
#结束区域
#region构造函数，可以自定义串口的初始化参数。
///<总结& gt
///构造函数，可以自定义串口的初始化参数。
///</sum***ry >
///<param name = & # 8221comPortName & # 8221& gt操作需要COM端口名
///<param name = & # 8221波德拉特”& gtCOM速度
///<param name = & # 8221平价”& gt奇偶校验位
///<param name = & # 8221数据比特”& gt数据长度
///<param name = & # 8221停止位”& gt停止位
public SerialClass(字符串组件名，整数波特率，奇偶校验，整数数据位，停止位停止位)
{
_ serial port = new serial port(comport name，baudRate，parity，dataBits，stop bits)；
_串行端口。RtsEnable = true//自动请求
_串行端口。ReadTimeout = 3000//超时
set serial port()；
}
#结束区域
#区域析构函数
///<总结& gt
///析构函数，关闭串口
///</sum***ry >
~SerialClass()
{
if (_serialPort。IsOpen)
_串行端口。close()；
}
#结束区域
#区域设置串行端口参数
///<总结& gt
///设置串口参数
///</sum***ry >
///<param name = & # 8221comPortName & # 8221& gt操作需要COM端口名
///<param name = & # 8221波德拉特”& gtCOM速度
///<param name = & # 8221数据比特”& gt数据长度
///<param name = & # 8221停止位”& gt停止位
public void set serial port(string comport name，int baudRate，int dataBits，int stopBits)
{
if (_serialPort。IsOpen)
_串行端口。close()；
_串行端口。PortName = comPortName
_串行端口。波德拉特=波德拉特；
_串行端口。平价=平价。无；
_串行端口。数据比特=数据比特；
_串行端口。StopBits = (StopBits)停止位；
_串行端口。握手=握手。无；
_串行端口。RtsEnable = false
_串行端口。ReadTimeout = 3000
_串行端口。NewLine = & # 8220/r/n ”；
set serial port()；
}
#结束区域
# RegionSets设置接收功能。
///<总结& gt
///设置串口资源，需要重载多个设置串口的函数。
///</sum***ry >
void setSerialPort()
{
if (_serialPort！=空)
{
//将触发DataReceived事件的字节数设置为1
_串行端口。ReceivedBytesThreshold = 1；
//当接收到一个字节时，DataReceived事件也会被触发。
_串行端口。data received+= new serial datareceivedeventhandler(_ serial port _ data received)；
//接收数据出错，触发事件
_串行端口。error received+= new serial errorreceivedeventhandler(_ serial port _ error received)；
//打开串口
//open port()；
}
}
#结束区域
#区域开放串行端口资源
///<总结& gt
///打开串口资源
///<returns & gt返回布尔类型
///</sum***ry >
public bool openPort()
{
bool ok = false
//如果串口是打开的，先关闭它
if (_serialPort。IsOpen)
_串行端口。close()；
尝试
{
//打开串口
_串行端口。open()；
ok = true
}
catch(例外Ex)
{
扔Ex；
}
退货ok；
}
#结束区域
#区域关闭串行端口
///<总结& gt
///关闭串口资源。操作完成后，一定要关闭串口。
///</sum***ry >
public void closePort()
{
//如果串口是打开的，它会被关闭
if (_serialPort。IsOpen)
_串行端口。close()；
}
#结束区域
#区域接收串行数据事件
///<总结& gt
///接收串行数据事件
///</sum***ry >
///<param name = & # 8221发件人”& gt& lt/param >
///<param name = & # 8221e & # 8221& gt& lt/param >
void _serialPort_DataReceived(对象发送方，SerialDataReceivedEventArgs e)
{
//接收事件时禁止直接退出。
if (ReceiveEventFlag)
{
返回；
}
尝试
{
系统。线程. thread . sleep(20)；
byte[] _data =新字节[_serialPort。BytesToRead]；
_串行端口。Read(_data，0，_data。长度)；
if(_数据。长度= = 0){ return；}
如果(DataReceived！=空)
{
DataReceived(发送方，e，_ data)；
}
//_serialPort。DiscardInBuffer()；//清除空接收缓冲区
}
catch(例外ex)
{
扔ex；
}
}
#结束区域
#区域接收数据错误事件
///<总结& gt
///接收数据错误事件
///</sum***ry >
///<param name = & # 8221发件人”& gt& lt/param >
///<param name = & # 8221e & # 8221& gt& lt/param >
void _serialPort_ErrorReceived(对象发送方，SerialErrorReceivedEventArgs e)
{
}
#结束区域
#区域发送数据字符串类型
公共void SendData(字符串数据)
{
//发送数据
//接收事件时禁止直接退出。
if (ReceiveEventFlag)
{
返回；
}
if (_serialPort。IsOpen)
{
_串行端口。写(数据)；
}
}
#结束区域
#区域发送数据字节类型
///<总结& gt
///数据发送
///</sum***ry >
///<param name = & # 8221数据”& gt要发送的数据字节
public void SendData(byte[] data，int offset，int count)
{
//接收事件时禁止直接退出。
if (ReceiveEventFlag)
{
返回；
}
尝试
{
if (_serialPort。IsOpen)
{
//_serialPort。DiscardInBuffer()；//清除空接收缓冲区
_串行端口。写(数据、偏移量、计数)；
}
}
catch(例外ex)
{
扔ex；
}
}
#结束区域
#区域发送命令
///<总结& gt
///发送命令
///</sum***ry >
///<param name = & # 8221发送数据”& gt发送数据
///<param name = & # 8221接收数据”& gt接收数据
///<param name = & # 8221加班”& gt超时时间
///<returns & gt& lt/returns >
public int send com***nd(byte[]send data，ref byte[] ReceiveData，int Overtime)
{
if (_serialPort。IsOpen)
{
尝试
{
ReceiveEventFlag = true//关闭接收事件
_串行端口。DiscardInBuffer()；//清除空接收缓冲区
_串行端口。写(SendData，0，SendData。长度)；
int num = 0，ret = 0；
系统。Threading.Thread.Sleep(十)；
ReceiveEventFlag = false//打开事件
while(num++ <加班)
{
if (_serialPort。BytesToRead & gt=接收数据。长度)
打破；
系统。Threading.Thread.Sleep(十)；
}
if (_serialPort。BytesToRead & gt=接收数据。长度)
{
ret = _serialPort。Read(接收数据，0，接收数据。长度)；
}
其他
{
ret = _serialPort。Read(ReceiveData，0，_serialPort。BytesToRead)；
}
ReceiveEventFlag = false//打开事件
返回ret
}
catch(例外ex)
{
ReceiveEventFlag = false
扔ex；
}
}
return-1；
}
#结束区域
#获取串行端口的区域
///<总结& gt
///获取所有连接的SMS cat设备的串行端口
///</sum***ry >
///<returns & gt& lt/returns >
公共字符串[]serialisconnected()
{
列表& lt字符串& gtlists =新列表& lt字符串& gt();
string[]serial list = get serials()；
foreach(序列列表中的字符串s)
{
}
返回列表。to array()；
}
#结束区域
#获取所有当前串行端口资源的区域
///<总结& gt
///获取当前计算机上的所有串行端口资源
///</sum***ry >
///<returns & gt& lt/returns >
公共字符串[] getSerials()
{
返回串行端口。getport names()；
}
#结束区域
#区域字节转换16
///<总结& gt
///将字节类型转换为十六进制字符串
///</sum***ry >
///<param name = & # 8221InBytes & # 8221& gt& lt/param >
///<returns & gt& lt/returns >
公共静态字符串ByteToString(byte[] InBytes)
{
string StringOut = & # 8220”；
foreach(字节中的字节)
{
StringOut = StringOut + String。格式(“{ 0:X2 } “，以字节为单位)；
}
return StringOut
}
#结束区域
#区域十六进制字符串到字节类型
///<总结& gt
///将十六进制字符串转换为字节类型(方法1)
///</sum***ry >
///<param name = & # 8221英斯特灵”& gt& lt/param >
///<returns & gt& lt/returns >
public static byte[]string tobyte(string in string)
{
string[]bytes string；
ByteStrings = InString。拆分(”“。ToCharArray())；
byte[]byte out；
ByteOut =新字节[字节字符串。长度]；
for(int I = 0；我& lt=字节字符串。长度-1；i++)
{
//ByteOut[i] = System。text . encoding . ascii . getbytes(bytes strings[I])；
ByteOut[i] =字节。parse(bytes strings[I]，System。globalization . number styles . hex number)；
//ByteOut[i] =Convert。ToByte(“0x & # 8221+bytes strings[I])；
}
返回ByteOut
}
#结束区域
#区域十六进制字符串到字节类型
///<总结& gt
///字符串转换为十六进制字节数组(方法2)
///</sum***ry >
///<param name = & # 8221hexString & # 8221& gt& lt/param >
///<returns & gt& lt/returns >
公共静态字节[] strToToHexByte(字符串hexString)
{
hexString = hexString。替换(”“, “”);
if ((hexString。长度% 2)！= 0)
hex string+= ”“；
byte[]return bytes = new byte[hex string。长度/2]；
for(int I = 0；我& ltreturnBytes字节。长度；i++)
returnBytes[i] = Convert。ToByte(十六进制字符串。Substring(i * 2，2)，16)；
返回returnBytes
}
#结束区域
#区域字节到十六进制字符串
///<总结& gt
///将字节数组转换为十六进制字符串
///</sum***ry >
///<param name = & # 8221字节”& gt& lt/param >
///<returns & gt& lt/returns >
公共静态字符串byteToHexStr(byte[] bytes)
{
string returnStr = & # 8220”；
如果(字节！=空)
{
for(int I = 0；我& lt字节。长度；i++)
{
returnStr += bytes[i]。ToString(“X2 ”);
}
}
return returnStr
}
#结束区域
}
}
======================================================================================
调用方法:
static serial class sc = new serial class()；
静态void Main(string[] Args)
{
即DataReceived +=新的SerialClass。SerialPortDataReceiveEventArgs(sc _ data received)；
sc . writedata(“在”);
控制台。ReadLine()；
sc . close port()；
}
静态void sc_DataReceived(对象发送方，SerialDataReceivedEventArgs e，byte[] bits)
{
控制台。WriteLine(编码。default . GetString(bits))；
}
本文来自长街旧人投稿，不代表舒华文档立场，如若转载，请注明出处：https://www.chinashuhua.cn/24/633958.html
微信扫一扫 
