串口收发数据

串口收发数据

一、串口收发数据的类
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace zhouxl.MyCom
{
class MyCom
{
private int iPort; //端口号：0-8
private int iRate; //波特率
private int bSize; //数据位：5-8
private byte bParity; // 校验位 0-4=no,odd,even,mark,space
private byte bStopBits; // 0,1,2 = 1, 1.5, 2
private int iTimeout = 2000; //超时时间

public int IPort //端口属性外露
{
get { return iPort; }
set { iPort = value; }
}

public int IRate //波特率属性外露
{
get { return iRate; }
set { iRate = value; }
}

public int BSize //数据位属性外露
{
get { return bSize; }
set { bSize = value; }
}

public byte BParity //奇偶校验属性外露
{
get { return bParity; }
set { bParity = value; }
}

public byte BStopBits //停止位属性外露
{
get { return bStopBits; }
set { bStopBits = value; }
}

public MyCom() //无参构造函数
{
iPort = 0;//串口1
iRate = 9600;//波特率9600
bSize = 8;//数据位8
bParity = 2;//无效验
bStopBits = 0;//停止位1
}

public MyCom(int com, int rate, int size, byte parity, byte stopbits)//构造函数
{
iPort = com;
iRate = rate;
bSize = size;
bParity = parity;
bStopBits = stopbits;
}

//public mycom mycom1 = new mycom();
//public byte[] recb;

//comm port win32 file handle
private int hComm = -1;

public bool Opened = false;

//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;

[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;
}

[DllImport("kernel32.dll")]
private static extern int CreateFile(
string lpFileName, // file name
uint dwDesiredAccess, // access mode
int dwShareMode, // share mode
int lpSecurityAttributes, // SD
int dwCreationDisposition, // how to create
int dwFlagsAndAttributes, // file attributes
int hTemplateFile // handle to template file
);
[DllImport("kernel32.dll")]
private static extern bool GetCommState(
int hFile, // handle to communications device
ref DCB lpDCB // device-control block
);
[DllImport("kernel32.dll")]
private static extern bool BuildCommDCB(
string lpDef, // device-control string
ref DCB lpDCB // device-control block
);
[DllImport("kernel32.dll")]
private static extern bool SetCommState(
int hFile, // handle to communications device
ref DCB lpDCB // device-control block
);
[DllImport("kernel32.dll")]
private static extern bool GetCommTimeouts(
int hFile, // handle to comm device
ref COMMTIMEOUTS lpCommTimeouts // time-out values
);
[DllImport("kernel32.dll")]
private static extern bool SetCommTimeouts(
int hFile, // handle to comm device
ref COMMTIMEOUTS lpCommTimeouts // time-out values
);
[DllImport("kernel32.dll")]
private static extern bool ReadFile(
int hFile, // handle to file
byte[] lpBuffer, // data buffer
int nNumberOfBytesToRead, // number of bytes to read
ref int lpNumberOfBytesRead, // number of bytes read
ref OVERLAPPED lpOverlapped // overlapped buffer
);
[DllImport("kernel32.dll")]
private static extern bool WriteFile(
int hFile, // handle to file
byte[] lpBuffer, // data buffer
int nNumberOfBytesToWrite, // number of bytes to write
ref int lpNumberOfBytesWritten, // number of bytes written
ref OVERLAPPED lpOverlapped // overlapped buffer
);
[DllImport("kernel32.dll")]
private static extern bool CloseHandle(
int hObject // handle to object
);

/// <summary>
/// 打开串口
/// </summary>
public void Open()
{

DCB dcbCommPort = new DCB();
COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS();

// OPEN THE COMM PORT.

hComm = CreateFile("COM" + iPort, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
// IF THE PORT CANNOT BE OPENED, BAIL OUT.
if (hComm == INVALID_HANDLE_VALUE)
{
Opened= false;
throw (new ApplicationException("打开所选串口失败！！"));
}
else
{
// SET THE COMM TIMEOUTS.

GetCommTimeouts(hComm, ref ctoCommPort);
ctoCommPort.ReadTotalTimeoutConstant = iTimeout;
ctoCommPort.ReadTotalTimeoutMultiplier = 0;
ctoCommPort.WriteTotalTimeoutMultiplier = 0;
ctoCommPort.WriteTotalTimeoutConstant = 0;
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.

dcbCommPort.DCBlength = Marshal.SizeOf(dcbCommPort);
GetCommState(hComm, ref dcbCommPort);
dcbCommPort.BaudRate =iRate ;
dcbCommPort.Parity = bParity;
dcbCommPort.ByteSize = (byte)bSize;
dcbCommPort.StopBits = bStopBits;
SetCommState(hComm, ref dcbCommPort);
Opened= true;
}
}

/// <summary>
/// 关闭串口
/// </summary>
public void Close()
{
if (hComm != INVALID_HANDLE_VALUE)
{
CloseHandle(hComm);
Opened = false;
}
}

/// <summary>
/// 从串口读取数据(返回读到的字节数组)
/// </summary>
/// <param name="NumBytes"></param>
/// <returns></returns>
public byte[] Read(int NumBytes)
{
byte[] BufBytes;
byte[] OutBytes;
BufBytes = new byte[NumBytes];
if (hComm != INVALID_HANDLE_VALUE)
{
OVERLAPPED ovlCommPort = new OVERLAPPED();
int BytesRead = 0;
ReadFile(hComm, BufBytes, NumBytes, ref BytesRead, ref ovlCommPort);
OutBytes = new byte[BytesRead];
Array.Copy(BufBytes, OutBytes, BytesRead);
}
else
{
throw (new ApplicationException("串口没有打开"));
}
return OutBytes;
}

public string ReadS(int NumBytes)
{
byte[] BufBytes;
byte[] OutBytes;
BufBytes = new byte[NumBytes];
if (hComm != INVALID_HANDLE_VALUE)
{
OVERLAPPED ovlCommPort = new OVERLAPPED();
int BytesRead = 0;
ReadFile(hComm, BufBytes, NumBytes, ref BytesRead, ref ovlCommPort);
OutBytes = new byte[BytesRead];
Array.Copy(BufBytes, OutBytes, BytesRead);
}
else
{
throw (new ApplicationException("串口没有打开"));
}
return System.Text.Encoding.Default.GetString(OutBytes);
}

/// <summary>
/// 向串口发送指定数据(发送字节)
/// </summary>
/// <param name="WriteBytes"></param>
/// <returns></returns>
public int Write(byte[] WriteBytes)
{
int BytesWritten = 0;
if (hComm != INVALID_HANDLE_VALUE)
{
OVERLAPPED ovlCommPort = new OVERLAPPED();
WriteFile(hComm, WriteBytes, WriteBytes.Length, ref BytesWritten, ref ovlCommPort);
}
else
{
throw (new ApplicationException("串口没有打开"));
}
return BytesWritten;
}

/// <summary>
/// 向串口发送指定数据(发送字符串)
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public int Write(string s)
{
byte[] WriteBytes = System.Text.Encoding.Default.GetBytes(s);
int BytesWritten = 0;
if (hComm != INVALID_HANDLE_VALUE)
{
OVERLAPPED ovlCommPort = new OVERLAPPED();
WriteFile(hComm, WriteBytes, WriteBytes.Length, ref BytesWritten, ref ovlCommPort);
}
else
{
throw (new ApplicationException("串口没有打开"));
}
return BytesWritten;
}
}
}

二、测试实例
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using zhouxl.MyCom;
using System.IO;
namespace CommTest
{
public partial class Form1 : Form
{
private MyCom mycom1;
public byte[] recb;
public Form1()
{
InitializeComponent();
}

//显示包信息
public string dis_package(byte[] reb)
{
string temp = "";
foreach (byte b in reb)
temp += b.ToString("X2")+" ";
return temp;
}
//打开串口
public bool OpenCom()
{
try
{
if (mycom1.Opened)
{
mycom1.Close();
mycom1.Open(); //打开串口
}
else
{
mycom1.Open();//打开串口
}
return true;
}
catch (Exception e)
{
MessageBox.Show("错误：" + e.Message);
return false;
}

}

private void comboBox5_SelectedIndexChanged(object sender, EventArgs e)
{

}

private void Form1_Load(object sender, EventArgs e)
{
//初始化端口列表
ComPort.Items.Clear();
ComPort.Items.Add("Com1");
ComPort.Items.Add("Com2");
ComPort.Items.Add("Com3");
ComPort.Items.Add("Com4");
ComPort.Items.Add("Com5");
ComPort.Items.Add("Com6");
ComPort.Items.Add("Com7");
ComPort.Items.Add("Com8");
ComPort.Items.Add("Com9");
ComPort.DropDownStyle = ComboBoxStyle.DropDownList;
ComPort.MaxDropDownItems = 9;
ComPort.SelectedIndex = 0;

//初始化波特率列表
BaudRate.Items.Clear();
BaudRate.Items.Add(110);
BaudRate.Items.Add(300);
BaudRate.Items.Add(1200);
BaudRate.Items.Add(2400);
BaudRate.Items.Add(4800);
BaudRate.Items.Add(9600);
BaudRate.Items.Add(19200);
BaudRate.Items.Add(38400);
BaudRate.Items.Add(57600);
BaudRate.Items.Add(115200);
BaudRate.Items.Add(230400);
BaudRate.Items.Add(460800);
BaudRate.Items.Add(921600);
BaudRate.DropDownStyle = ComboBoxStyle.DropDownList;
BaudRate.MaxDropDownItems = 13;
BaudRate.SelectedIndex = 5;

//初始化数据位
DatBit.Items.Clear();
DatBit.Items.Add(5);
DatBit.Items.Add(6);
DatBit.Items.Add(7);
DatBit.Items.Add(8);
DatBit.DropDownStyle = ComboBoxStyle.DropDownList;
DatBit.MaxDropDownItems = 4;
DatBit.SelectedIndex = 3;

//初始化停止位
Stopbit.Items.Clear();
Stopbit.Items.Add(1);
Stopbit.Items.Add(1.5);
Stopbit.Items.Add(2);
Stopbit.DropDownStyle = ComboBoxStyle.DropDownList;
Stopbit.MaxDropDownItems = 3;
Stopbit.SelectedIndex = 0;

//初始化校验位 0-4=no,odd,even,mark,space
Parity.Items.Clear();
Parity.Items.Add("0-无(no)");
Parity.Items.Add("1-奇(odd)");
Parity.Items.Add("2-偶(even)");
Parity.Items.Add("3-标识(mark)");
Parity.Items.Add("4-空格(space)");
Parity.DropDownStyle = ComboBoxStyle.DropDownList;
Parity.MaxDropDownItems = 5;
Parity.SelectedIndex = 0;

//初始化流控制
Flowctrl.Items.Clear();
Flowctrl.Items.Add("Xon / Xoff");
Flowctrl.Items.Add("硬件");
Flowctrl.Items.Add("无");
Flowctrl.DropDownStyle = ComboBoxStyle.DropDownList;
Flowctrl.MaxDropDownItems = 3;
Flowctrl.SelectedIndex = 2;

//初始化串口
mycom1 = new MyCom();
}

private void button1_Click(object sender, EventArgs e)
{
int c,b,d;
byte p,s;
c=ComPort.SelectedIndex; //串口号
b=int.Parse(BaudRate.SelectedItem.ToString());//波特率
d=int.Parse(DatBit.SelectedItem.ToString());//数据位
p=byte.Parse(Parity.SelectedIndex.ToString());//奇偶校验位
s=byte.Parse(Stopbit.SelectedIndex.ToString());//停止位

//mycom1 = new MyCom();
mycom1.IPort = c+1;
mycom1.IRate = b;
mycom1.BSize = d;
mycom1.BParity = p;
mycom1.BStopBits = s;

if (OpenCom())
{
textBox3.AppendText("打开串口成功。。。/r/n");
}
}

private void button2_Click(object sender, EventArgs e)
{
mycom1.Close();
textBox3.AppendText("/r/n串口被关闭……");
}

//字节转换为字符串
private string byteTostring(byte[] bytes)
{
string s="";
s = System.Text.Encoding.Default.GetString(bytes);
return s;

}
//字符串转换成字节
private byte[] stringTobyte(string s)
{
ArrayList al = new ArrayList();
for (int i = 0; i < s.Length; i++)
{
al.Add((byte)s[i]);
}
return (byte[])al.ToArray(System.Type.GetType("System.Byte"));

//或用下面语句
//return System.Text.Encoding.Default.GetBytes(s);
}
//去掉发送数组中的空格
public string delspace(string putin)
{
string putout = "";
for (int i = 0; i < putin.Length; i++)
{
if (putin[i] != ' ')
putout += putin[i];
}
return putout;
}

//提取数据包
public byte[] mysendb(string s)
{
string temps = delspace(s);
if (temps.Length % 2 != 0)
temps ="0"+temps;
byte[] tempb = new byte[50];
int j = 0;
for (int i = 0; i < temps.Length; i = i + 2, j++)
tempb[j] = Convert.ToByte(temps.Substring(i, 2), 16);
byte[] send = new byte[j];
Array.Copy(tempb, send, j);
return send;
}
private void button3_Click(object sender, EventArgs e)
{
if (textBox1.Text=="")
{ MessageBox.Show("发送数据为空！"); return; }
int sendnumb = 0;
try
{
if (checkBox1.Checked)
{
byte[] temp1 = mysendb(delspace(textBox1.Text)); //发送十六进制字符时用这行
sendnumb = mycom1.Write(temp1);
textBox3.AppendText("/r/n字节方式发送数据(" + sendnumb + ")：" + dis_package(temp1));
}
else
{
sendnumb = mycom1.Write(textBox1.Text);
byte[] bytes = System.Text.Encoding.Default.GetBytes(textBox1.Text);//这行主要是为了显示编用。先编成字节数组，显示时再从数组解析成字符
textBox3.AppendText("/r/n字符串方式发送数据(" + sendnumb + ")：" + System.Text.Encoding.Default.GetString(bytes));
}

}
catch (Exception ex)
{ textBox3.AppendText(ex.Message + "/r/n"); return; }

}

private void button4_Click(object sender, EventArgs e)
{
try
{
byte[] recbs = mycom1.Read(1024);
if (recbs.Length != 0)
{ textBox4.AppendText("/r/n接收到数据包：" + dis_package(recbs)); }
else
{ textBox4.AppendText("/r/n接收到数据包（"+recbs.Length.ToString()+"）：" + dis_package(recbs)); }
}
catch (Exception ex)
{
textBox4.AppendText(ex.Message);
}
}
}
}