/// <summary>
/// 停止
/// </summary>
/// <param name="id">id 16进制 00</param>
/// <returns></returns>
public void UbxMoveStart(Common.SerialDevice com, int id = 0)
{
string tmp = string.Format("{0} 01 FE 00 01 F4", id.ToString("X2"));
byte[] command = Common.HexStringToByteArray(tmp);
this.SerialSend(com, command);
}
/// <summary>
/// Serial数据接收
/// </summary>
/// <param name="device"></param>
/// <param name="dataB"></param>
/// <param name="dataS"></param>
public void SerialReceive(Common.SerialDevice device, byte[] dataB, string dataS)
{
Config.SerialItem item = this.GetConfig(device);
if (item.IsHex)
{
item.BuffReceive = Common.ByteArrayToHexString(dataB);
}
else
{
item.BuffReceive = dataS;
}
switch (item.SerialDevice)
{
default:
item.Value = item.BuffReceive;
item.Reset.Set();
business kylin = SystemHandle.Instance.GetMachineKylin(item.MachineID);
if (kylin != null)
{
// kylin.SerialReceive(device, dataS, dataB);
this.Async_SerialReceive(kylin, device, dataB, dataS);
}
break;
case Common.SerialDevice.TEST:
break;
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public void SerialSend(Common.SerialDevice device, byte[] data)
{
System.IO.Ports.SerialPort serial = (System.IO.Ports.SerialPort)Serials[device];
serial.DiscardInBuffer();
serial.DiscardOutBuffer();
serial.Write(data, 0, data.Length);
}
/// <summary>
/// 启动
/// </summary>
public override void DoStart()
{
try
{
IDictionaryEnumerator enumerator = this.Serials.GetEnumerator();
while (enumerator.MoveNext())
{
try
{
System.IO.Ports.SerialPort serial = enumerator.Value as System.IO.Ports.SerialPort;
serial.Open();
//打开正常
foreach (Config.SerialItem item in this.config.SerialItems)
{
if (item.Tag == serial)
{
if (serial == (System.IO.Ports.SerialPort)item.Tag)
{
item.IsConnected = true;
}
Common.SerialDevice device = (Common.SerialDevice)enumerator.Key;
//foreach (var cam in Config.ConfigManager.Instance.ConfigCamera.CamdeviceList)
//{
// if (cam.SerialDevice == device)
// {
// try
// {
// switch (device)
// {
// default:
// break;
// }
// }
// catch (Exception ex)
// {
// }
// break;
// }
//}
break;
}
}
}
catch
{
}
}
}
catch (Exception ex)
{
throw new StartException(this.ToString(), ex.ToString());
}
}
public string SerialReadLine(Common.SerialDevice device)
{
try
{
System.IO.Ports.SerialPort serial = (System.IO.Ports.SerialPort)Serials[device];
return(serial.ReadLine());
}
catch
{
return("ERROR");
}
}
public string SerialReadString(Common.SerialDevice device)
{
try
{
byte[] dataB = this.SerialRead(device);
return("");
}
catch
{
return(null);
}
}
public byte[] SerialRead(Common.SerialDevice device)
{
try
{
System.IO.Ports.SerialPort serial = (System.IO.Ports.SerialPort)Serials[device];
System.Threading.Thread.Sleep(20);
byte[] dataB = new byte[serial.BytesToRead];
serial.Read(dataB, 0, dataB.Length);
return(dataB);
}
catch
{
return(null);
}
}
public Config.SerialItem GetConfig(Common.SerialDevice device)
{
IEnumerable ie = from lst in this.Config.SerialItems
where lst.SerialDevice == device
select lst;
List <Config.SerialItem> ioLst = ie.Cast <Config.SerialItem>().ToList();
if (ioLst.Count > 0)
{
return(ioLst[0]);
}
else
{
return(null);
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public void SerialSend(Common.SerialDevice device, string data)
{
try
{
System.IO.Ports.SerialPort serial = (System.IO.Ports.SerialPort) this.Serials[device];
byte[] buff = System.Text.Encoding.Default.GetBytes(data);
serial.DiscardInBuffer();
serial.DiscardOutBuffer();
//this.SerialSend(device, buff);
serial.Write(buff, 0, buff.Length);
}
catch (Exception ex)
{
Log.LogWriter.WriteException(ex);
}
}
/// <summary>
/// 串口接收数据
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Seria_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
try
{
// lock (this.seriallock)
{
System.IO.Ports.SerialPort serial = (System.IO.Ports.SerialPort)sender;
string data = null;
byte[] dataB = null;
Common.SerialDevice device = Common.SerialDevice.NULL;
foreach (Config.SerialItem item in this.config.SerialItems)
{
if (item.Tag == serial)
{
if (item.CallReceive)
{
if (item.SleepMs <= 0)
{
item.SleepMs = 100;
}
System.Threading.Thread.Sleep(item.SleepMs);//等待保障缓冲区有一行数据
if (string.IsNullOrEmpty(item.NewLine))
{
dataB = new byte[serial.BytesToRead];
serial.Read(dataB, 0, dataB.Length);
//编码缺省
data = Encoding.Default.GetString(dataB, 0, dataB.Length);
device = item.SerialDevice;
}
else
{
data = serial.ReadLine();
dataB = Encoding.Default.GetBytes(data);
device = item.SerialDevice;
}
}
break;
}
}
Logic.SearialHandle.Instance.SerialReceive(device, dataB, data);
// if (!string.IsNullOrEmpty(data))
// this.Async_SerialReceive(device, dataB, data);
}
}
catch { }
}
/// <summary>
/// 串口加锁byte[]
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public string SerialSendReturn(Common.SerialDevice device, byte[] data)
{
LogHandle.Instance.WriteRunLog(this.CfgBase.MachineID, "Serial", "{0}:发送,{1}", device.ToString(), Encoding.Default.GetString(data));
lock (lock_send_serial_byte)
{
Config.SerialItem serial = SearialHandle.Instance.GetConfig(device);
//暂存包编号
serial.Value = "";
serial.Reset.Reset();
SearialHandle.Instance.SerialSend(device, data);
if (serial.ReadTimeout < 200)
{
serial.Reset.WaitOne(200);
}
else
{
serial.Reset.WaitOne(serial.ReadTimeout);
}
return(serial.Value.ToString());
}
}
/// <summary>
/// 串口发送string，返回string
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public string SerialSendReturn(Common.SerialDevice device, string data)
{
lock (lock_send_serial_string)
{
Config.SerialItem serial = SearialHandle.Instance.GetConfig(device);
//暂存包编号
serial.Value = "";
serial.Reset.Reset();
SearialHandle.Instance.SerialSend(device, data);
if (serial.ReadTimeout < 200)
{
serial.Reset.WaitOne(200);
}
else
{
serial.Reset.WaitOne(serial.ReadTimeout);
}
if (serial.Value == "")
{
}
return(serial.Value.ToString());
}
}
/// <summary>
/// 停止
/// </summary>
public override void DoStop()
{
try
{
IDictionaryEnumerator enumerator = this.Serials.GetEnumerator();
while (enumerator.MoveNext())
{
System.IO.Ports.SerialPort serial = enumerator.Value as System.IO.Ports.SerialPort;
serial.DataReceived -= new System.IO.Ports.SerialDataReceivedEventHandler(Seria_DataReceived);
Common.SerialDevice device = (Common.SerialDevice)enumerator.Key;
//foreach (var cam in Config.ConfigManager.Instance.ConfigCamera.CamdeviceList)
//{
// if (cam.SerialDevice == device)
// {
// try
// {
// switch (device)
// {
// default:
// break;
// }
// }
// catch (Exception ex)
// {
// }
// break;
// }
//}
serial.Close();
}
}
catch (Exception ex)
{
throw new StopException(this.ToString(), ex.ToString());
}
}
/// <summary>
/// PLC值改变
/// </summary>
///// <param name="item"></param>
//public override void PlcValueChange(Config.PlcDataItem item)
//{
// try
// {
// base.PlcValueChange(item);
// switch (item.PlcDevice)
// {
// case Common.PlcDevice.NULL:
// break;
// case Common.PlcDevice.ERROR:
// break;
// }
// }
// catch (Exception ex)
// {
// Log.LogWriter.WriteException(ex);
// }
//}
/// <summary>
/// 串口接收
/// </summary>
/// <param name="serial"></param>
/// <param name="data"></param>
/// <param name="data_byte"></param>
public override void SerialReceive(Common.SerialDevice serial, string data, byte[] data_byte)
{
base.SerialReceive(serial, data, data_byte);
}
/// <summary>
/// 串口发送string
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public void SerialSend(Common.SerialDevice device, string data)
{
Logic.SearialHandle.Instance.SerialSend(device, data);
}
public byte[] SerialRead(Common.SerialDevice device)
{
return(Device.DeviceManager.Instance.DeviceSerial.SerialRead(device));
}
public string SerialReadString(Common.SerialDevice device)
{
byte[] r = this.SerialRead(device);
return(Encoding.Default.GetString(r));
}
public void Async_SerialReceive(business business, Common.SerialDevice device, byte[] dataB, string dataS)
{
delegate_serial_receive rece = new delegate_serial_receive(business.SerialReceive);
rece.BeginInvoke(device, dataS, dataB, null, rece);
}
public void Async_SerialReceive(Common.SerialDevice device, byte[] dataB, string dataS)//异步调用委托
{
delegate_serial_receive rece = new delegate_serial_receive(Logic.SearialHandle.Instance.SerialReceive);
rece.BeginInvoke(device, dataB, dataS, null, rece);
}
public string SerialReadLine(Common.SerialDevice device)
{
return(Device.DeviceManager.Instance.DeviceSerial.SerialReadLine(device));
}
/// <summary>
/// 串口回调虚函数，机台重写
/// </summary>
/// <param name="serial"></param>
/// <param name="frid"></param>
public virtual void SerialReceive(Common.SerialDevice serial, string data, byte[] data_byte)
{
LogHandle.Instance.WriteRunLog(this.CfgBase.MachineID, "Serial", "收到:{0},{1}", serial, data);
//业务
}
/// <summary>
/// 发送该数据
/// </summary>
/// <param name="device"></param>
/// <param name="data"></param>
public void SerialSend(Common.SerialDevice device, byte[] data)
{
Device.DeviceManager.Instance.DeviceSerial.SerialSend(device, data);
}
