康耐视 扫码枪

private bool ScanBarcodeDown()
{
Utility.OutputInfo(txtInfo, "下扫描枪发送读码命令");
if (Program.Config.ScanTimes <= 0) Program.Config.ScanTimes = 3;
if (Program.Config.ScanTimeout <= 0) Program.Config.ScanTimeout = 100;
//开始扫码
//SerialPortUtil.listCs[0].WriteData("+");
areScanerDown.Reset();
SerialPortUtil.listCs[3].WriteData("+");

for (int i = 0; i < Program.Config.ScanTimes; i++)
{
if (i == Program.Config.ScanTimes - 1)
{
Utility.OutputInfo(txtInfo, "下扫码失败!");
SerialPortUtil.listCs[3].WriteData("-");

return false;
}

if (!areScanerDown.WaitOne(Program.Config.ScanTimeout, false))
{
continue;
}
else
{
SerialPortUtil.listCs[3].WriteData("-");
break;

}
}
SerialPortUtil.listCs[3].WriteData("-");
if (Program.bTrayOrDut)
Utility.OutputInfo(txtInfo, " 下读取到托盘条码: " + Program.StrBarcodeDut);
else
{
Utility.OutputInfo(txtInfo, " 下读取到产品条码: " + Program.StrBarcodeDown);
//Program.PlateLoad.Products[Program.IndexLoad].SN = Program.StrBarcodeDown;
}
return true;
}

 

 

using System;
using System.Collections.Generic;
using System.Text;
using System.IO.Ports;
using System.Windows.Forms;
using System.Threading;
using System.Linq;
using System.Xml;
using System.Xml.Linq;

namespace Common
{
public enum EnumSerialPortReceiveEvent
{
EndChar,
NewLine,
ByteCount,
}
/// <summary>
/// 串口开发辅助类
/// </summary>
public class SerialPortUtil:CsBase
{
//public static string[] Attrs = new string[] {"ID","Alias", "PortName", "BaudRate", "DataBits", "Parity", "StopBits", "EnumEvent", "EndChar", "Threshold", "Remarks" };
public static string[] Attrs = new string[] {"ID","Alias", "PortName", "BaudRate", "DataBits", "Parity", "StopBits", "Remarks" };

public static string gcXEleName = "SerialPort";
public static List<SerialPortUtil> listCs = null;
public static int gcMaxID = 0;
private int _receivedBytesThreshold = 6;
List<byte> _byteData = new List<byte>(); //保存接收的字节
private string strRec = string.Empty; // 接收到的字符串

EnumSerialPortReceiveEvent espr = EnumSerialPortReceiveEvent.NewLine;
public AutoResetEvent areRec = new AutoResetEvent(false);

/// <summary>
/// 接收事件是否有效 false表示有效
/// </summary>
public bool ReceiveEventFlag = false;
/// <summary>
/// 结束符比特
/// </summary>
///
public byte EndByte = 0x0D;//string End = "#";

/// <summary>
/// 完整协议的记录处理事件
/// </summary>
public event DataReceivedEventHandler DataReceived;
public event SerialErrorReceivedEventHandler Error;

#region 变量属性
private string _portName = "COM1";//串口号，默认COM1
private SerialPortBaudRates _baudRate = SerialPortBaudRates.BaudRate_9600;//波特率
private Parity _parity = Parity.None;//校验位
private StopBits _stopBits = StopBits.One;//停止位
private SerialPortDatabits _dataBits = SerialPortDatabits.EightBits;//数据位

private SerialPort comPort = new SerialPort();

static SerialPortUtil()
{
if (listCs == null)
{
listCs = new List<SerialPortUtil>();
}
}
// 接收的字节
public List<byte> ByteData
{
get { return _byteData; }
set { _byteData = value; }
}
public string StrRec
{
get { return strRec; }
}
/// <summary>
/// 串口号
/// </summary>
public string PortName
{
get { return _portName; }
set { _portName = value; }
}

/// <summary>
/// 波特率
/// </summary>
public SerialPortBaudRates BaudRate
{
get { return _baudRate; }
set { _baudRate = value; }
}

/// <summary>
/// 奇偶校验位
/// </summary>
public Parity Parity
{
get { return _parity; }
set { _parity = value; }
}

/// <summary>
/// 数据位
/// </summary>
public SerialPortDatabits DataBits
{
get { return _dataBits; }
set { _dataBits = value; }
}

/// <summary>
/// 停止位
/// </summary>
public StopBits StopBits
{
get { return _stopBits; }
set { _stopBits = value; }
}
public int RecivedBytesThrehold
{
get { return _receivedBytesThreshold; }
set { _receivedBytesThreshold = value; }
}

public EnumSerialPortReceiveEvent SerialPortReceiveEvent
{
get { return espr; }
set { espr = value; }
}
#endregion

#region 构造函数

/// <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);
gcMaxID++;
}

/// <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);
gcMaxID++;
ID = gcMaxID;

}

/// <summary>
/// 默认构造函数
/// </summary>
public SerialPortUtil()
{
_portName = "COM" + (gcMaxID+1).ToString();
Alias = _portName;
_baudRate = SerialPortBaudRates.BaudRate_9600;
_parity = Parity.None;
_dataBits = SerialPortDatabits.EightBits;
_stopBits = StopBits.One;

comPort.DataReceived += new SerialDataReceivedEventHandler(comPort_DataReceived);
comPort.ErrorReceived += new SerialErrorReceivedEventHandler(comPort_ErrorReceived);
gcMaxID++;
ID = gcMaxID;

}

#endregion

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

/// <summary>
/// 打开端口
/// </summary>
/// <returns></returns>
public void OpenPort()
{
try
{
if (comPort.IsOpen) comPort.Close();
comPort.PortName = _portName;
comPort.BaudRate = (int)_baudRate;
comPort.Parity = _parity;
comPort.DataBits = (int)_dataBits;
comPort.StopBits = _stopBits;
if (espr == EnumSerialPortReceiveEvent.ByteCount)
comPort.ReceivedBytesThreshold = _receivedBytesThreshold;

comPort.Open();

}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}

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

/// <summary>
/// 丢弃来自串行驱动程序的接收和发送缓冲区的数据
/// </summary>
public void DiscardBuffer()
{
comPort.DiscardInBuffer();
comPort.DiscardOutBuffer();
}
/// <summary>
/// 数据接收处理
/// 查找结束字符为结束
/// 或者以字节个数触发接收事件
/// </summary>
void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
//禁止接收事件时直接退出
if (ReceiveEventFlag) return;

#region 根据1.结束字节2.换行符3.字节数量 来判断是否全部获取完成
Utility.Delay(20);

switch (espr)
{
case EnumSerialPortReceiveEvent.EndChar:
{
{
byte[] readBuffer = new byte[comPort.ReadBufferSize + 1];
int count = comPort.Read(readBuffer, 0, 128);
int bytes = 0;
for (int i = 0; i < 128; i++)
{
if (readBuffer[i] == EndByte)
{
bytes = i;
break;
}
}
if (bytes == 0) return;
byte[] rec = new byte[bytes + 1];
Array.Copy(readBuffer, rec, bytes + 1);
strRec = ByteToStr(rec);
}
//strRec = System.Text.Encoding.Default.GetString(_byteData.ToArray(), 0, _byteData.Count);
break;

//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;
// }
// }
//}
}
strRec = System.Text.Encoding.Default.GetString(_byteData.ToArray(), 0, _byteData.Count);
break;
case EnumSerialPortReceiveEvent.NewLine:
{
strRec = comPort.ReadLine();
}
break;
case EnumSerialPortReceiveEvent.ByteCount:
{
byte[] readBuffer = new byte[comPort.ReadBufferSize + 1];
int count = comPort.Read(readBuffer, 0, _receivedBytesThreshold);
_byteData.Clear();
for (int i = 0; i < count; i++)
{
_byteData.Add(readBuffer[i]);
}
}
//strRec = System.Text.Encoding.Default.GetString(_byteData.ToArray(), 0, _byteData.Count);
strRec = ByteToHex(_byteData.ToArray());
break;
default:
break;
}

#endregion

areRec.Set();
comPort.DiscardInBuffer();
//触发整条记录的处理
if (DataReceived != null)
{
DataReceived(this, new DataReceivedEventArgs(strRec));
}
}
/// <summary>
/// 错误处理函数
/// </summary>
void comPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
{
if (Error != null)
{
Error(sender, e);
}
}

#region 数据写入操作

/// <summary>
/// 写入数据
/// </summary>
/// <param name="msg"></param>
public void WriteData(string msg)
{
if (!(comPort.IsOpen)) comPort.Open();
areRec.Reset();
comPort.Write(msg);
Utility.Delay(50);
}

/// <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>
/// 发送串口命令
/// </summary>
/// <param name="SendData">发送数据</param>
/// <param name="ReceiveData">接收数据</param>
/// <param name="Overtime">重复次数</param>
/// <returns></returns>
public int SendCommand(byte[] SendData, ref byte[] ReceiveData, int Overtime)
{
if (!(comPort.IsOpen)) comPort.Open();

ReceiveEventFlag = true; //关闭接收事件
comPort.DiscardInBuffer(); //清空接收缓冲区
comPort.Write(SendData, 0, SendData.Length);

int num = 0, ret = 0;
while (num++ < Overtime)
{
if (comPort.BytesToRead >= ReceiveData.Length) break;
System.Threading.Thread.Sleep(1);
}

if (comPort.BytesToRead >= ReceiveData.Length)
{
ret = comPort.Read(ReceiveData, 0, ReceiveData.Length);
}

ReceiveEventFlag = false; //打开事件
return ret;
}

#endregion

#region 常用的列表数据获取和绑定操作

/// <summary>
/// 封装获取串口号列表
/// </summary>
/// <returns></returns>
public static string[] GetPortNames()
{
return SerialPort.GetPortNames();
}

/// <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);
}
//foreach (Parity party in Enum.GetValues(typeof(Parity)))
//{
// obj.Items.Add(((int)party).ToString());
//}
}

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

#endregion

#region 格式转换
/// <summary>
/// 转换十六进制字符串到字节数组
/// </summary>
/// <param name="msg">待转换字符串</param>
/// <returns>字节数组</returns>
public static byte[] HexToByte(string msg)
{
msg = msg.Replace(" ", "");//移除空格

//create a byte array the length of the
//divided by 2 (Hex is 2 characters in length)
byte[] comBuffer = new byte[msg.Length / 2];
for (int i = 0; i < msg.Length; i += 2)
{
//convert each set of 2 characters to a byte and add to the array
comBuffer[i / 2] = (byte)Convert.ToByte(msg.Substring(i, 2), 16);
}

return comBuffer;
}

/// <summary>
/// 转换字节数组到十六进制字符串
/// </summary>
/// <param name="comByte">待转换字节数组</param>
/// <returns>十六进制字符串</returns>
public static string ByteToHex(byte[] comByte)
{
StringBuilder builder = new StringBuilder(comByte.Length * 3);
foreach (byte data in comByte)
{
builder.Append(Convert.ToString(data, 16).PadLeft(2, '0').PadRight(3, ' '));
}
builder.Remove(builder.Length - 1, 1);//移除最后的空格
return builder.ToString().ToUpper();
}

public static string ByteToStr(byte[] comByte)
{
StringBuilder builder = new StringBuilder(comByte.Length);
foreach (byte data in comByte)
{
builder.Append(Convert.ToChar(data));
}
//builder.Remove(builder.Length - 1, 1);//移除最后的空格
return builder.ToString();
}

#endregion

/// <summary>
/// 检查端口名称是否存在
/// </summary>
/// <param name="port_name"></param>
/// <returns></returns>
public static bool Exists(string port_name)
{
foreach (string port in SerialPort.GetPortNames()) if (port == port_name) return true;
return false;
}

/// <summary>
/// 格式化端口相关属性
/// </summary>
/// <param name="port"></param>
/// <returns></returns>
public static string Format(SerialPort port)
{
return String.Format("{0} ({1},{2},{3},{4},{5})",
port.PortName, port.BaudRate, port.DataBits, port.StopBits, port.Parity, port.Handshake);
}

//序列化
//{ "ID", "Alias", "PortName", "BaudRates", "Parity", "DataBits", "StopBits", "Remarks" };
public object[] ToObjects()
{
return new object[] { ID, Alias, PortName, (int)BaudRate, (int)DataBits, Parity, StopBits, Remarks };
}
public XElement ToXml()
{
try
{
return CsXml.Init(gcXEleName, Attrs, ToObjects());

}
catch (System.Exception ex)
{
OnNotify("SerialPortUtil.ToXml :" + ex.Message);
return null;
}
}
public static SerialPortUtil XmlTo(XElement xe)
{
try
{
SerialPortUtil cs = new SerialPortUtil();
cs.ID = int.Parse(xe.Attribute("ID").Value);
cs.Alias = xe.Attribute("Alias").Value;
cs.PortName = xe.Attribute("PortName").Value;
cs.BaudRate = (SerialPortBaudRates)(Enum.Parse(typeof(SerialPortBaudRates), xe.Attribute("BaudRate").Value));
cs.Parity = (Parity)(Enum.Parse(typeof(Parity), xe.Attribute("Parity").Value));
cs.DataBits = (SerialPortDatabits)(Enum.Parse(typeof(SerialPortDatabits), xe.Attribute("DataBits").Value));
cs.StopBits = (StopBits)(Enum.Parse(typeof(StopBits), xe.Attribute("StopBits").Value));
cs.Remarks = xe.Attribute("Remarks").Value;

return cs;

}
catch (System.Exception ex)
{
MessageBox.Show("Cs.XmlTo: " + ex.Message);
return null;
}
}
public static void UpdateXml(XElement xe, SerialPortUtil cs)
{
try
{
XElement rootNode = XElement.Load(CsCommon.xmlFileConfig);
string id = xe.Attribute("ID").Value;
var temp = rootNode.Elements("SerialPortItems").Elements("SerialPort").Where(p => p.Attribute("ID").Value == id);
XElement xeNew = null;
if (temp != null)
xeNew = temp.First();
else
xeNew = new XElement(gcXEleName);
xeNew.SetAttributeValue("ID", cs.ID);
xeNew.SetAttributeValue("Alias", cs.Alias);
xeNew.SetAttributeValue("PortName", cs.PortName);
xeNew.SetAttributeValue("BaudRate", cs.BaudRate);
xeNew.SetAttributeValue("Parity", cs.Parity);
xeNew.SetAttributeValue("DataBits", cs.DataBits);
xeNew.SetAttributeValue("StopBits", cs.StopBits);
xeNew.SetAttributeValue("Remarks", cs.Remarks);
rootNode.Save(CsCommon.xmlFileConfig);

 

}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message, "SerialPortUtil.UpdateToXml");
return;
}
}

public static void Init()
{

if (listCs == null)
{
listCs = new List<SerialPortUtil>();
}
if (listCs.Count != 0)
{
listCs.Clear();
}
XElement rootNode = XElement.Load(CsCommon.xmlFileConfig);
var temp = rootNode.Elements("SerialPortItems").Elements("SerialPort");//.Where(p => p.Attribute("SystemID").Value.StartsWith("Element."));
if (temp == null) return;
for (int i = 0; i < temp.Count(); i++)
{
XElement xe = temp.ElementAt(i);
SerialPortUtil cs = SerialPortUtil.XmlTo(xe);
listCs.Add(cs);
//cs.OpenPort();
}
return;

}

public static List<SerialPortUtil> ListItems
{
get { return listCs; }
set { listCs = value; }
}
public static SerialPortUtil Items(int id)
{
SerialPortUtil cs = listCs.Find(p => p.ID == id);
return cs;
}
public static SerialPortUtil Items(string alias)
{
SerialPortUtil cs = listCs.Find(p => p.Alias == alias);
return cs;
}
public static SerialPortUtil ItemsPort(string port)
{
SerialPortUtil cs = listCs.Find(p => p.PortName == port);
return cs;
}
public static void ToDgv(DataGridView dgv)
{
foreach (SerialPortUtil cs in listCs)
{
dgv.Rows.Add(cs.ToObjects());
}
}

public static object [] DataBitsItems = new object[] { 5, 6, 7, 8 };
public static object [] BaudRateItems = new object[]
{
75,
110,
150,
300,
600,
1200,
2400,
4800,
9600,
14400,
19200,
28800,
38400,
56000,
57600,
115200,
128000,
230400,
256000
};

}

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

public delegate void DataReceivedEventHandler(SerialPortUtil sp, DataReceivedEventArgs e);

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