1303 lines
45 KiB
C#
1303 lines
45 KiB
C#
using Aitex.Core.Util;
|
|
using MECF.Framework.Common.Utilities;
|
|
using MECF.Framework.Simulator.Core.Driver;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Timers;
|
|
|
|
namespace MECF.Framework.Simulator.Core.Commons
|
|
{
|
|
public class SerialPortDeviceSimulatorFactory
|
|
{
|
|
public static CommonSerialPortDeviceSimulator GetCommonSerialPortDeviceSimulator(string port, string deviceName)
|
|
{
|
|
if(deviceName == "SiasunPhoenixB")
|
|
{
|
|
return new SiasunPhoenixBSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "Siasun1500C800C")
|
|
{
|
|
return new Siasun1500C800CSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "BrooksVCE")
|
|
{
|
|
return new BrooksVCESimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "Hanbell")
|
|
{
|
|
return new HanbellPumpSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "HirataR4")
|
|
{
|
|
return new HirataR4Simulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "BrooksSMIF")
|
|
{
|
|
return new BrooksSMIFSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "SiasunAligner")
|
|
{
|
|
return new SiasunAlignerSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "RisshiChiller")
|
|
{
|
|
return new RisshiChillerSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "SiasunVCE")
|
|
{
|
|
return new SiasunVCESimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "TazmoRobot")
|
|
{
|
|
return new TazmoRobotSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "VATS651")
|
|
{
|
|
return new VATS651Simulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "TruPlasmaRF")
|
|
{
|
|
return new TruPlasmaRFSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "SkyPump")
|
|
{
|
|
return new SkyPumpSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "CommetRFMatch")
|
|
{
|
|
return new CommetRFMatchSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "FujikinMFC")
|
|
{
|
|
return new FujikinMFCSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "PfeifferPumpA603")
|
|
{
|
|
return new PfeifferPumpA603Simulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "PfeifferPumpA100")
|
|
{
|
|
return new PfeifferPumpA100Simulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "EdwardsPump")
|
|
{
|
|
return new EdwardsPumpSimulator(port, deviceName);
|
|
}
|
|
else if (deviceName == "KaimeiRFMatch")
|
|
{
|
|
return new KaimeiRFMatchSimulator(port, deviceName);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public class CommonSerialPortDeviceSimulator : SerialPortDeviceSimulator
|
|
{
|
|
public bool Failed { get; set; }
|
|
public bool AutoReply { get; set; } = true;
|
|
|
|
public bool IsAtSpeed { get; set; }
|
|
|
|
Stopwatch _timer = new Stopwatch();
|
|
|
|
private System.Timers.Timer _tick;
|
|
|
|
private object _locker = new object();
|
|
|
|
public string ResultValue { get; set; }
|
|
|
|
public List<IOSimulatorItemViewModel> IOSimulatorItemList { get; set; }
|
|
|
|
public event Action<IOSimulatorItemViewModel> SimulatorItemActived;
|
|
|
|
string _deviceName;
|
|
public CommonSerialPortDeviceSimulator(string port, string deviceName, bool isAscii = false, string newLine = "\r")
|
|
: base(port, -1, newLine, ' ', isAscii)
|
|
{
|
|
_deviceName = deviceName;
|
|
ResultValue = "";
|
|
|
|
_tick = new System.Timers.Timer();
|
|
_tick.Interval = 200;
|
|
|
|
_tick.Elapsed += _tick_Elapsed;
|
|
_tick.Start();
|
|
|
|
IsAtSpeed = true;
|
|
}
|
|
|
|
public CommonSerialPortDeviceSimulator(string port, string deviceName, bool isAscii, string newLine, int dataBits)
|
|
: base(port, -1, newLine, ' ', isAscii, dataBits)
|
|
{
|
|
_deviceName = deviceName;
|
|
ResultValue = "";
|
|
|
|
_tick = new System.Timers.Timer();
|
|
_tick.Interval = 200;
|
|
|
|
_tick.Elapsed += _tick_Elapsed;
|
|
_tick.Start();
|
|
|
|
IsAtSpeed = true;
|
|
}
|
|
|
|
private void _tick_Elapsed(object sender, ElapsedEventArgs e)
|
|
{
|
|
|
|
lock (_locker)
|
|
{
|
|
if (_timer.IsRunning && _timer.Elapsed > TimeSpan.FromSeconds(10))
|
|
{
|
|
_timer.Stop();
|
|
|
|
IsAtSpeed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//private string GetCharsFormFromBinaryString(String binary)
|
|
//{
|
|
// return Encoding.ASCII.GetString(GetBytesFromBinaryString(binary));
|
|
//}
|
|
|
|
private string GetCharsFormFromBinaryString(byte[] binary)
|
|
{
|
|
return Encoding.ASCII.GetString(binary);
|
|
}
|
|
|
|
protected override void ProcessUnsplitMessage(byte[] binaryMessage)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var activeSimulatorItem = GetActiveIOSimulatorItemViewModel(binaryMessage);
|
|
if (activeSimulatorItem == null) return;
|
|
|
|
activeSimulatorItem.CommandContent = string.Join("," , binaryMessage.Select(bt=>bt.ToString("X2")).ToArray());
|
|
activeSimulatorItem.CommandRecievedTime = DateTime.Now;
|
|
|
|
if (SimulatorItemActived != null)
|
|
SimulatorItemActived(activeSimulatorItem);
|
|
|
|
if (AutoReply)
|
|
{
|
|
OnWriteSimulatorItem(activeSimulatorItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void ProcessUnsplitMessage(string msg)
|
|
{
|
|
lock (_locker)
|
|
{
|
|
var activeSimulatorItem = GetActiveIOSimulatorItemViewModel(msg);
|
|
if (activeSimulatorItem == null) return;
|
|
|
|
activeSimulatorItem.CommandContent = msg;
|
|
activeSimulatorItem.CommandRecievedTime = DateTime.Now;
|
|
|
|
if (SimulatorItemActived != null)
|
|
SimulatorItemActived(activeSimulatorItem);
|
|
|
|
if(AutoReply)
|
|
{
|
|
OnWriteSimulatorItem(activeSimulatorItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
return null;
|
|
}
|
|
protected virtual IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
return null;
|
|
}
|
|
protected virtual void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
}
|
|
|
|
|
|
public void ManualWriteMessage(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteSimulatorItem(activeSimulatorItem);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public class SiasunPhoenixBSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
public SiasunPhoenixBSimulator(string port, string deviceName):base(port, deviceName)
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommandName))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if(activeSimulatorItem.SourceCommandName.StartsWith("RQ"))
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.Response + "\r");
|
|
Thread.Sleep(1000);
|
|
OnWriteMessage("_RDY" + "\r");
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.Response + "\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Siasun1500C800CSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
public Siasun1500C800CSimulator(string port, string deviceName) : base(port, deviceName)
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommandName))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if (activeSimulatorItem.SourceCommandName.StartsWith("RQ"))
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.Response + "\r");
|
|
Thread.Sleep(1000);
|
|
OnWriteMessage("_RDY" + "\r");
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.Response + "\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
public class RisshiChillerSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static char _startLine = (char)1;
|
|
private static char _endLine = (char)3;
|
|
public RisshiChillerSimulator(string port, string deviceName) : base(port, deviceName, true, _endLine.ToString())
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem.Response));
|
|
}
|
|
|
|
private string BuildMessage(string response)
|
|
{
|
|
string sLength = response.Length.ToString("D2");
|
|
var charArray = (sLength + response).ToArray();
|
|
int sum = charArray.Sum(chr => (int)chr);
|
|
string sSum = sum.ToString("X");
|
|
|
|
if (sSum.Length < 2)
|
|
return _startLine + sLength + response + "0" + sSum + _endLine.ToString();
|
|
else
|
|
return _startLine + sLength + response + sSum.Substring(sSum.Length - 2) + _endLine.ToString();
|
|
}
|
|
}
|
|
public class SiasunAlignerSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static char _startLine = (char)1;
|
|
private static char _endLine = (char)3;
|
|
public SiasunAlignerSimulator(string port, string deviceName) : base(port, deviceName, true, _endLine.ToString())
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem.Response));
|
|
}
|
|
|
|
private string BuildMessage(string response)
|
|
{
|
|
string sLength = response.Length.ToString("D2");
|
|
var charArray = (sLength + response).ToArray();
|
|
int sum = charArray.Sum(chr=>(int)chr);
|
|
string sSum = sum.ToString("X");
|
|
|
|
if(sSum.Length < 2)
|
|
return _startLine + sLength + response + "0" + sSum + _endLine.ToString();
|
|
else
|
|
return _startLine + sLength + response + sSum.Substring(sSum.Length-2) + _endLine.ToString();
|
|
}
|
|
}
|
|
|
|
|
|
public class TruPlasmaRFResponse
|
|
{
|
|
public string GS { get; set; }
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string Status { get; set; }
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string Type { get; set; }
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string Data { get; set; }
|
|
}
|
|
public class TruPlasmaRFSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static byte _start = 0xAA;
|
|
private static byte _address = 0x01;
|
|
private static byte _stop = 0x55;
|
|
private static byte _ack = 0x06;
|
|
public TruPlasmaRFSimulator(string port, string deviceName) : base(port, deviceName, false, "",8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
if(msg.Length < 8)
|
|
return null;
|
|
var msgArray = msg.Select(bt => bt.ToString("X2")).ToArray();
|
|
string msgCommand = string.Join(",", msgArray, 4, 4);
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msgCommand == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
|
|
return IOSimulatorItemList.Find(item=>item.SourceCommandName == "ExecuteAnyCommand");
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(new byte[] { _ack });
|
|
Thread.Sleep(1000);
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem));
|
|
}
|
|
|
|
private static byte[] BuildMessage(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
TruPlasmaRFResponse rfResponse = JsonConvert.DeserializeObject<TruPlasmaRFResponse>(activeSimulatorItem.Response);
|
|
|
|
List<byte> buffer = new List<byte>();
|
|
|
|
buffer.Add(_start);
|
|
buffer.Add(_address);
|
|
int length = 4;
|
|
if (rfResponse.Status != null)
|
|
length++;
|
|
if (rfResponse.Type != null)
|
|
length++;
|
|
if (rfResponse.Data != null)
|
|
{
|
|
length += rfResponse.Data.Split(',').Length;
|
|
}
|
|
|
|
buffer.Add((byte)length);
|
|
buffer.Add(Convert.ToByte(rfResponse.GS, 16));
|
|
|
|
buffer.AddRange(activeSimulatorItem.SourceCommand.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
|
|
|
|
if (rfResponse.Status != null)
|
|
buffer.Add(Convert.ToByte(rfResponse.Status, 16));
|
|
if (rfResponse.Type != null)
|
|
buffer.Add(Convert.ToByte(rfResponse.Type, 16));
|
|
if (rfResponse.Data != null)
|
|
{
|
|
buffer.AddRange(rfResponse.Data.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
}
|
|
var contentBuffer = buffer.Skip(3).Take(buffer.Count - 3).ToArray();
|
|
buffer.AddRange(BitConverter.GetBytes(Crc16.Crc16Ccitt(contentBuffer)));
|
|
buffer.Add(_stop);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
}
|
|
public class CommetRFMatchSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static byte _start = 0xAA;
|
|
private static byte _address = 0x21;
|
|
public CommetRFMatchSimulator(string port, string deviceName) : base(port, deviceName, false, "", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
var msgArray = msg.Select(bt => bt.ToString("X2")).ToArray();
|
|
string msgCommand = string.Join(",", msgArray, 2, 2);
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msgCommand == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static int iCount = 0;
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
|
|
if (activeSimulatorItem.Response.Contains("|"))
|
|
{
|
|
var resArray = activeSimulatorItem.Response.Split('|');
|
|
int length = resArray.Length;
|
|
OnWriteMessage(BuildMessage(resArray[iCount%length]));
|
|
iCount++;
|
|
if (iCount > 100)
|
|
iCount = 0;
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem.Response));
|
|
}
|
|
}
|
|
|
|
private static byte[] BuildMessage(string reponse)
|
|
{
|
|
List<byte> buffer = new List<byte>();
|
|
|
|
buffer.Add(_start);
|
|
buffer.Add(_address);
|
|
|
|
buffer.AddRange(reponse.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
|
|
byte checkSum = 0;
|
|
for (int i = 0; i < buffer.Count; i++)
|
|
{
|
|
checkSum += buffer[i];
|
|
}
|
|
buffer.Add(checkSum);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
}
|
|
|
|
public class KaimeiRFMatchSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
//private byte _address = 0x01;
|
|
private string _load = "01,F4";
|
|
private string _tune = "01,F4";
|
|
private string _mode = "01,00";
|
|
private List<byte> _msgBuffer = new List<byte>();
|
|
public KaimeiRFMatchSimulator(string port, string deviceName) : base(port, deviceName, false, "", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
_msgBuffer.AddRange(msg);
|
|
if(_msgBuffer.Count < 8)
|
|
{
|
|
return null;
|
|
}
|
|
if(_msgBuffer[1] == 0x03)
|
|
{
|
|
if(_msgBuffer.Count >= 8)
|
|
{
|
|
var msgArray = _msgBuffer.Select(bt => bt.ToString("X2")).ToArray();
|
|
string msgCommand = string.Join(",", msgArray, 0, 4);
|
|
_msgBuffer.RemoveRange(0, msgArray.Length);
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msgCommand == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(_msgBuffer[1] == 0x10)
|
|
{
|
|
var length = _msgBuffer[6];
|
|
if (_msgBuffer.Count >= 7 + length + 2)
|
|
{
|
|
var msgArray = _msgBuffer.Select(bt => bt.ToString("X2")).ToArray();
|
|
string msgCommand = string.Join(",", msgArray, 0, 4);
|
|
_msgBuffer.RemoveRange(0, msgArray.Length);
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msgCommand == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if(activeSimulatorItem.SourceCommandName == "SetPresetAbsoluteMode")
|
|
{
|
|
var contentArray = activeSimulatorItem.CommandContent.Split(',');
|
|
if (contentArray.Length >= 15)
|
|
{
|
|
var modeArray = contentArray.Skip(7).Take(2).ToArray();
|
|
var tuneArray = contentArray.Skip(9).Take(2).ToArray();
|
|
var loadArray = contentArray.Skip(11).Take(2);
|
|
_tune = $"0{string.Join(",", tuneArray).Substring(1)}";
|
|
_load = $"0{string.Join(",", loadArray).Substring(1)}";
|
|
_mode = string.Join(",", modeArray.Reverse());
|
|
}
|
|
}
|
|
|
|
if (activeSimulatorItem.SourceCommandName == "GetStatus")
|
|
{
|
|
OnWriteMessage(BuildMessage($"{activeSimulatorItem.Response},{_tune},{_load},{_mode}"));
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem.Response));
|
|
}
|
|
}
|
|
|
|
private byte[] BuildMessage(string reponse)
|
|
{
|
|
List<byte> buffer = new List<byte>();
|
|
|
|
buffer.AddRange(reponse.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
|
|
var checkSum = Crc16.CRC16_ModbusRTU(buffer.ToArray());
|
|
var ret = BitConverter.GetBytes(checkSum);
|
|
buffer.AddRange(ret);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
}
|
|
|
|
public class FujikinMFCSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static byte _start = 0x02;
|
|
private static byte _end = 0x00;
|
|
private static byte _address = 0x00;
|
|
private static byte _ack = 0x06;
|
|
private static byte _nak = 0x16;
|
|
public FujikinMFCSimulator(string port, string deviceName) : base(port, deviceName, false, "", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
var msgArray = msg.Select(bt => bt.ToString("X2")).ToArray();
|
|
string commandType = msgArray[2];
|
|
string msgCommand = string.Join(",", msgArray, 4, 3);
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (commandType == simulatorItem.SourceCommandType && msgCommand == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if(activeSimulatorItem.Response == activeSimulatorItem.SuccessResponse.ToString())
|
|
{
|
|
OnWriteMessage(new byte[] {0x06});
|
|
Thread.Sleep(1000);
|
|
|
|
var resArray = activeSimulatorItem.Response.Split('|');
|
|
int iIndex = new Random().Next(0, resArray.Length - 1);
|
|
string responseData = resArray[iIndex];
|
|
if(responseData == "06" )
|
|
{
|
|
OnWriteMessage(new byte[] { _ack });
|
|
}
|
|
else if (responseData == "16")
|
|
{
|
|
OnWriteMessage(new byte[] { _nak });
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem, responseData));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(new byte[] { _nak });
|
|
}
|
|
}
|
|
|
|
private static byte[] BuildMessage(IOSimulatorItemViewModel activeSimulatorItem, string responseData)
|
|
{
|
|
string reponse = activeSimulatorItem.Response;
|
|
List<byte> buffer = new List<byte>();
|
|
var responseArray = responseData.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray();
|
|
buffer.Add(_address);
|
|
buffer.Add(_start);
|
|
buffer.Add(Convert.ToByte(activeSimulatorItem.SourceCommandType, 16));
|
|
buffer.Add((byte)(3+ responseArray.Length));
|
|
buffer.AddRange(activeSimulatorItem.SourceCommand.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
buffer.AddRange(responseArray);
|
|
buffer.Add(_end);
|
|
|
|
byte checkSum = 0;
|
|
for (int i = 1; i < buffer.Count-1; i++)
|
|
{
|
|
checkSum += buffer[i];
|
|
}
|
|
buffer.Add(checkSum);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
}
|
|
|
|
|
|
public class PfeifferPumpA603Simulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static string _start = "#";
|
|
private static string _address = "005";
|
|
private static string _end = "\r";
|
|
public PfeifferPumpA603Simulator(string port, string deviceName) : base(port, deviceName, true, "\r", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(_start + _address + activeSimulatorItem.Response + _end);
|
|
}
|
|
}
|
|
|
|
public class PfeifferPumpA100Simulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static string _start = "#";
|
|
private static string _address = "005";
|
|
private static string _end = "\r";
|
|
public PfeifferPumpA100Simulator(string port, string deviceName) : base(port, deviceName, true, "\r", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(_start + _address + "," + activeSimulatorItem.Response + _end);
|
|
}
|
|
}
|
|
public class EdwardsPumpSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static string _end = "\r\n";
|
|
private bool _isPumpOn;
|
|
public EdwardsPumpSimulator(string port, string deviceName) : base(port, deviceName, true, "\r", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if (activeSimulatorItem.SourceCommandName == "SwitchPump")
|
|
{
|
|
if (activeSimulatorItem.CommandContent.Contains("0"))
|
|
_isPumpOn = false;
|
|
else
|
|
_isPumpOn = true;
|
|
}
|
|
|
|
if (activeSimulatorItem.SourceCommandName == "ReadPumpStatus")
|
|
{
|
|
OnWriteMessage($"{(_isPumpOn?"4":"0")},{activeSimulatorItem.Response}{_end}");
|
|
}
|
|
else
|
|
OnWriteMessage(activeSimulatorItem.Response + _end);
|
|
}
|
|
}
|
|
|
|
public class SkyPumpSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private static string _start = "@";
|
|
private static string _address = "00";
|
|
private static string _end = "\0\r\n";
|
|
public SkyPumpSimulator(string port, string deviceName) : base(port, deviceName, true, "\r", 8)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.Contains(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(_start + _address + " " + activeSimulatorItem.Response + _end);
|
|
}
|
|
}
|
|
|
|
public class VATS651Simulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
static string _endLine = "\r\n";
|
|
public VATS651Simulator(string port, string deviceName) : base(port, deviceName, true, _endLine.ToString())
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg.IndexOf(simulatorItem.SourceCommand) == 0)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if(activeSimulatorItem.Response == activeSimulatorItem.SuccessResponseStr)
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.SourceCommand + activeSimulatorItem.Response + _endLine);
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage("E" + activeSimulatorItem.Response + _endLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TazmoRobotSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
static string _enq = ((char)0x05).ToString();
|
|
static string _ack = ((char)0x06).ToString();
|
|
static string _nak = ((char)0x15).ToString();
|
|
static string _busy = ((char)0x11).ToString();
|
|
static string _cr = ((char)0x0D).ToString();
|
|
static string _endLine = ((char)0x0A).ToString();
|
|
|
|
public TazmoRobotSimulator(string port, string deviceName) : base(port, deviceName)
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
string content = msg.Remove(msg.Length - 1);
|
|
var contentArray = content.Split(',');
|
|
if (contentArray.Length > 0)
|
|
{
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (simulatorItem.SourceCommand != null && contentArray[0] == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
//1) action: ack & completeEvent==command + send ack after complete process
|
|
//2) query: command,parameterlist,,,respone
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if (activeSimulatorItem.SourceCommandName == "SendError")
|
|
{
|
|
OnWriteMessage("ERR," + activeSimulatorItem.Response + _endLine);
|
|
return;
|
|
}
|
|
if (activeSimulatorItem.SourceCommandName.Contains("Read"))
|
|
{
|
|
if (activeSimulatorItem.Response != null)
|
|
OnWriteMessage(activeSimulatorItem.SourceCommand + "," + activeSimulatorItem.Response + _endLine);
|
|
else
|
|
OnWriteMessage(activeSimulatorItem.SourceCommand + _endLine);
|
|
}
|
|
else
|
|
{
|
|
OnWriteMessage(_ack);
|
|
if (activeSimulatorItem.Response == "CompleteEvent")
|
|
{
|
|
Thread.Sleep(1000);
|
|
OnWriteMessage(activeSimulatorItem.SourceCommand + _endLine);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SiasunVCESimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
public SiasunVCESimulator(string port, string deviceName) : base(port, deviceName)
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
//id,E
|
|
//id,A,DC
|
|
string content = msg.Remove(msg.Length - 1);
|
|
var contentArray = content.Split(',');
|
|
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (contentArray.Length == 2)
|
|
{
|
|
if (simulatorItem.SourceCommandType != null && contentArray[1] == simulatorItem.SourceCommandType)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
else if (contentArray.Length > 2)
|
|
{
|
|
if (simulatorItem.SourceCommandType != null && contentArray[1] == simulatorItem.SourceCommandType &&
|
|
simulatorItem.SourceCommand != null && contentArray[2] == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
//if (activeSimulatorItem.Response.First() == '{')
|
|
//{
|
|
// var response = activeSimulatorItem.Response.Substring(1, activeSimulatorItem.Response.Length - 2);
|
|
// OnWriteMessage("00," + response + "\r");
|
|
//}
|
|
//else
|
|
//{
|
|
// var responseArray = activeSimulatorItem.Response.Split(',');
|
|
// foreach (var response in responseArray)
|
|
// {
|
|
// OnWriteMessage("00," + response + "\r");
|
|
// Thread.Sleep(1000);
|
|
// }
|
|
//}
|
|
|
|
if(activeSimulatorItem.SourceCommandType == "A" || activeSimulatorItem.SourceCommandType == "S" || activeSimulatorItem.SourceCommandType == "P")
|
|
{
|
|
OnWriteMessage("M," + activeSimulatorItem.Response + "\r");
|
|
}
|
|
else if (activeSimulatorItem.SourceCommandType == "R")
|
|
{
|
|
OnWriteMessage("X," + activeSimulatorItem.Response + "\r");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public class BrooksVCESimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
public BrooksVCESimulator(string port, string deviceName) : base(port, deviceName)
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
//id,E
|
|
//id,A,DC
|
|
string content = msg.Remove(msg.Length - 1);
|
|
var contentArray = content.Split(',');
|
|
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (contentArray.Length == 2)
|
|
{
|
|
if (simulatorItem.SourceCommandType != null && contentArray[1] == simulatorItem.SourceCommandType)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
else if (contentArray.Length > 2)
|
|
{
|
|
if (simulatorItem.SourceCommandType != null && contentArray[1] == simulatorItem.SourceCommandType &&
|
|
simulatorItem.SourceCommand != null && contentArray[2] == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
if (activeSimulatorItem.Response.First() == '{')
|
|
{
|
|
var response = activeSimulatorItem.Response.Substring(1, activeSimulatorItem.Response.Length - 2);
|
|
OnWriteMessage("00," + response + "\r");
|
|
}
|
|
else
|
|
{
|
|
var responseArray = activeSimulatorItem.Response.Split(',');
|
|
foreach (var response in responseArray)
|
|
{
|
|
OnWriteMessage("00," + response + "\r");
|
|
Thread.Sleep(1000);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class HanbellPumpSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
public HanbellPumpSimulator(string port, string deviceName) : base(port, deviceName,false)
|
|
{
|
|
}
|
|
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(byte[] msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (msg[1] == byte.Parse(simulatorItem.SourceCommand))
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(activeSimulatorItem.Response.Split(',').Select(s => Convert.ToByte(s, 16)).ToArray());
|
|
}
|
|
}
|
|
|
|
public class HirataR4Simulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private string _address = "002";
|
|
protected static char _stx = '\u0002';
|
|
protected static char _etx = '\u0003';
|
|
protected static char _space = '\u0020';
|
|
|
|
private int _lpIndex = 1;
|
|
|
|
public HirataR4Simulator(string port, string deviceName) : base(port, deviceName,false,"\0")
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
IOSimulatorItemViewModel theSimulatorItem = null;
|
|
int maxMatachLength = -1;
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
int iIndex = msg.IndexOf(simulatorItem.SourceCommand);
|
|
if(iIndex > 0)
|
|
{
|
|
int matchLength = simulatorItem.SourceCommand.Length;
|
|
if (matchLength > maxMatachLength)
|
|
{
|
|
maxMatachLength = matchLength;
|
|
theSimulatorItem = simulatorItem;
|
|
}
|
|
}
|
|
|
|
}
|
|
return theSimulatorItem;
|
|
}
|
|
|
|
|
|
List<byte> _cache = new List<byte>();
|
|
protected override void ProcessUnsplitMessage(byte[] binaryMessage)
|
|
{
|
|
_cache.AddRange(binaryMessage);
|
|
if (!_cache.Contains((byte) (3)))
|
|
return;
|
|
|
|
string message = Encoding.ASCII.GetString(_cache.ToArray());
|
|
|
|
_cache.Clear();
|
|
|
|
OnReadMessage(message);
|
|
|
|
if (message.Contains("GP 1"))
|
|
_lpIndex = 1;
|
|
if (message.Contains("GP 2"))
|
|
_lpIndex = 2;
|
|
if (message.Contains("GP 3"))
|
|
_lpIndex = 3;
|
|
if (message.Contains("GP 4"))
|
|
_lpIndex = 4;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
OnWriteMessage(BuildMessage(activeSimulatorItem.SourceCommand, activeSimulatorItem.Response) + "\0");
|
|
}
|
|
|
|
private string BuildMessage(string command, string response)
|
|
{
|
|
if (command == "LE 100")
|
|
{
|
|
if (_lpIndex == 1)
|
|
response = Convert.ToInt32("1111111111111111111111111", 2).ToString();
|
|
if (_lpIndex == 2)
|
|
response = "0";
|
|
if (_lpIndex == 3)
|
|
response = Convert.ToInt32("1100000000000000000000000", 2).ToString();
|
|
if (_lpIndex == 4)
|
|
response = Convert.ToInt32("0000000000000000000000011", 2).ToString();
|
|
|
|
}
|
|
if (command == "LE 101")
|
|
{
|
|
if (_lpIndex == 1)
|
|
response = "0";
|
|
if (_lpIndex == 2)
|
|
response = "0";
|
|
if (_lpIndex == 3)
|
|
response = "0";
|
|
if (_lpIndex == 4)
|
|
response = "0";
|
|
}
|
|
|
|
string msg1 = $"{_address} {response}{_etx}";
|
|
if(response.First() == '-')
|
|
{
|
|
msg1 = $"{_address}{response}{_etx}";
|
|
}
|
|
|
|
byte lrc = CalcLRC(Encoding.ASCII.GetBytes(msg1).ToList());
|
|
string msg = $"{_stx}{msg1}{(char)(lrc)}";
|
|
return msg;
|
|
}
|
|
private static byte CalcLRC(List<byte> data)
|
|
{
|
|
byte ret = 0x00;
|
|
for (var i = 0; i < data.Count; i++)
|
|
{
|
|
ret ^= data[i];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
}
|
|
|
|
public class BrooksSMIFSimulator : CommonSerialPortDeviceSimulator
|
|
{
|
|
private bool _isPodPresent = true;
|
|
private DeviceTimer _timer = new DeviceTimer();
|
|
private int _motionTime = 3000;//ms
|
|
public BrooksSMIFSimulator(string port, string deviceName) : base(port, deviceName, true, "\r\n")
|
|
{
|
|
}
|
|
protected override IOSimulatorItemViewModel GetActiveIOSimulatorItemViewModel(string msg)
|
|
{
|
|
if (IOSimulatorItemList == null)
|
|
return null;
|
|
|
|
string content = msg.Remove(msg.Length - 2);
|
|
var contentArray = content.Split(' ');
|
|
if (contentArray.Length < 2)
|
|
return null;
|
|
|
|
foreach (var simulatorItem in IOSimulatorItemList)
|
|
{
|
|
if (contentArray[0] == simulatorItem.SourceCommandType)
|
|
{
|
|
if(simulatorItem.SourceCommand == null)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
else if(contentArray[1] == simulatorItem.SourceCommand)
|
|
{
|
|
return simulatorItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected override void OnWriteSimulatorItem(IOSimulatorItemViewModel activeSimulatorItem)
|
|
{
|
|
string newLine = "\r\n";
|
|
string commandType = activeSimulatorItem.SourceCommandType;
|
|
if (activeSimulatorItem.SourceCommandName.ToUpper() == "LOAD")
|
|
_isPodPresent = true;
|
|
if (activeSimulatorItem.SourceCommandName.ToUpper() == "UNLOAD")
|
|
_isPodPresent = true;
|
|
|
|
if(activeSimulatorItem.SourceCommandName.ToUpper() == "LOAD" ||
|
|
activeSimulatorItem.SourceCommandName.ToUpper() == "UNLOAD" ||
|
|
activeSimulatorItem.SourceCommandName.ToUpper() == "HOME" ||
|
|
activeSimulatorItem.SourceCommandName.ToUpper() == "RECOVERY")
|
|
{
|
|
if (_timer.IsIdle())
|
|
_timer.Stop();
|
|
_timer.Start(0);
|
|
}
|
|
|
|
if (commandType == "AERS" || commandType == "ARS")
|
|
{
|
|
OnWriteMessage(commandType + " " + activeSimulatorItem.Response + newLine);
|
|
}
|
|
else if (commandType == "ECR")
|
|
{
|
|
OnWriteMessage("ECD " + activeSimulatorItem.Response + newLine);
|
|
}
|
|
else if (commandType == "FSR")
|
|
{
|
|
var response = activeSimulatorItem.Response;
|
|
if (_isPodPresent)
|
|
response += " PIP=TRUE";
|
|
else
|
|
response += " PIP=FALSE";
|
|
|
|
if(_timer.IsIdle() || _timer.GetElapseTime() >= _motionTime)
|
|
response += " READY=TRUE";
|
|
else
|
|
response += " READY=FALSE";
|
|
OnWriteMessage(response + newLine);
|
|
}
|
|
else
|
|
{
|
|
if (activeSimulatorItem.Response == "OK")
|
|
{
|
|
OnWriteMessage("HCA OK" + newLine);
|
|
}
|
|
else
|
|
{
|
|
var resArray = activeSimulatorItem.Response.Split('|');
|
|
int iIndex = new Random().Next(0, resArray.Length - 1);
|
|
OnWriteMessage("HCA " + resArray[iIndex] + newLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|