623 lines
20 KiB
C#
623 lines
20 KiB
C#
using MECF.Framework.Common.Communications;
|
|
using MECF.Framework.Common.Utilities;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.RFMatchs.Comet
|
|
{
|
|
|
|
public enum RFMatchResponseResult
|
|
{
|
|
InvalidResonse,
|
|
TriggerAck,
|
|
TriggerNAK,
|
|
CheckInProcess,
|
|
CheckCompleted
|
|
}
|
|
public abstract class CometRFMatchHandler : HandlerBase
|
|
{
|
|
public CometRFMatch Device { get; }
|
|
|
|
public string _command;
|
|
protected string _parameter;
|
|
protected string _completeEvent;
|
|
|
|
|
|
|
|
protected CometRFMatchHandler(CometRFMatch device, string command, string completeEvent, string parameter)
|
|
: base(BuildMessage(StringToByteArray(command), StringToByteArray(parameter)))
|
|
{
|
|
Device = device;
|
|
_command = command;
|
|
_completeEvent = completeEvent;
|
|
_parameter = parameter;
|
|
_address = Convert.ToByte(Device.Address, 16);
|
|
Name = command;
|
|
}
|
|
|
|
protected CometRFMatchHandler(CometRFMatch device, string command)
|
|
: base(BuildMessage(StringToByteArray(command)))
|
|
{
|
|
Device = device;
|
|
_command = command;
|
|
_address = Convert.ToByte(Device.Address, 16);
|
|
Name = command;
|
|
}
|
|
|
|
|
|
protected CometRFMatchHandler(CometRFMatch device, string command, string parameter)
|
|
: base(BuildMessage(StringToByteArray(command), StringToByteArray(parameter)))
|
|
{
|
|
Device = device;
|
|
_command = command;
|
|
_parameter = parameter;
|
|
_address = Convert.ToByte(Device.Address, 16);
|
|
Name = command;
|
|
}
|
|
|
|
protected CometRFMatchHandler(CometRFMatch device, string command, byte[] parameter)
|
|
: base(BuildMessage(StringToByteArray(command), parameter))
|
|
{
|
|
Device = device;
|
|
_command = command;
|
|
//_parameter = parameter;
|
|
Name = command;
|
|
}
|
|
|
|
private static byte _start = 0xAA;
|
|
private static byte _address = 0x21;
|
|
|
|
protected static byte[] BuildMessage(byte[] commandArray, byte[] argumentArray = null)
|
|
{
|
|
List<byte> buffer = new List<byte>();
|
|
|
|
buffer.Add(_start);
|
|
buffer.Add(_address);
|
|
|
|
if (commandArray != null && commandArray.Length > 0)
|
|
{
|
|
buffer.AddRange(commandArray);
|
|
}
|
|
if (argumentArray != null && argumentArray.Length > 0)
|
|
{
|
|
buffer.AddRange(argumentArray);
|
|
}
|
|
byte checkSum = 0;
|
|
for(int i = 0; i < buffer.Count; i++)
|
|
{
|
|
checkSum += buffer[i];
|
|
}
|
|
buffer.Add(checkSum);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
protected static byte[] BuildMessage(string commandStr, byte[] argumentArray = null)
|
|
{
|
|
byte[] commandArray = StringToByteArray(commandStr);
|
|
List<byte> buffer = new List<byte>();
|
|
|
|
buffer.Add(_start);
|
|
buffer.Add(_address);
|
|
|
|
if (commandArray != null && commandArray.Length > 0)
|
|
{
|
|
buffer.AddRange(commandArray);
|
|
}
|
|
if (argumentArray != null && argumentArray.Length > 0)
|
|
{
|
|
buffer.AddRange(argumentArray);
|
|
}
|
|
byte checkSum = 0;
|
|
for (int i = 0; i < buffer.Count; i++)
|
|
{
|
|
checkSum += buffer[i];
|
|
}
|
|
buffer.Add(checkSum);
|
|
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
|
|
protected static byte[] BuildByteArray(byte para1, short para2)
|
|
{
|
|
List<byte> buffer = new List<byte>();
|
|
buffer.Add(para1);
|
|
buffer.AddRange(IntToByteArray(para2));
|
|
return buffer.ToArray();
|
|
}
|
|
|
|
//public override bool HandleMessage(MessageBase msg, out bool transactionComplete)
|
|
//{
|
|
// CometRFMatchMessage response = msg as CometRFMatchMessage;
|
|
// ResponseMessage = msg;
|
|
|
|
// string reponseData = string.Join(",", response.Data.Select(bt => bt.ToString("X2")).ToArray());
|
|
// if(_completeEvent.Contains("|"))
|
|
// {
|
|
// var eventArray = _completeEvent.Split('|');
|
|
// var subRes = reponseData.Substring(0, eventArray[0].Length);
|
|
// if(!eventArray.Contains(subRes))
|
|
// {
|
|
// Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
// msg.IsFormatError = true;
|
|
|
|
// transactionComplete = false;
|
|
// return false;
|
|
// }
|
|
// }
|
|
// else if (reponseData.IndexOf(_completeEvent) == -1)
|
|
// {
|
|
// Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
// msg.IsFormatError = true;
|
|
|
|
// transactionComplete = false;
|
|
// return false;
|
|
// }
|
|
|
|
|
|
// if (response.IsAck)
|
|
// {
|
|
// SetState(EnumHandlerState.Acked);
|
|
// }
|
|
// if (this.IsAcked && response.IsComplete)
|
|
// {
|
|
// SetState(EnumHandlerState.Completed);
|
|
// transactionComplete = true;
|
|
// return true;
|
|
// }
|
|
|
|
// transactionComplete = false;
|
|
// return false;
|
|
//}
|
|
|
|
|
|
protected ResponseNAK CheckNak(string reponseData)
|
|
{
|
|
if (reponseData.IndexOf("90") >= 0)
|
|
{
|
|
return ResponseNAK.CommandNotDefined;
|
|
}
|
|
if (reponseData.IndexOf("92") >= 0)
|
|
{
|
|
return ResponseNAK.CheckSumFailed;
|
|
}
|
|
if (reponseData.IndexOf("93") >= 0)
|
|
{
|
|
return ResponseNAK.PositionOverLimit;
|
|
}
|
|
if (reponseData.IndexOf("93") >= 0)
|
|
{
|
|
return ResponseNAK.IndexOutOfRange;
|
|
}
|
|
|
|
return ResponseNAK.NotNak;
|
|
}
|
|
bool _startWaitCheckResonse = false;
|
|
protected RFMatchResponseResult HandleTriggerMessage(MessageBase msg)
|
|
{
|
|
CometRFMatchMessage response = msg as CometRFMatchMessage;
|
|
|
|
string triggerAck = "50";
|
|
string[] checkResponseArray = new string[] { "53", "52", "51" };
|
|
|
|
string reponseData = string.Join(",", response.Data.Select(bt => bt.ToString("X2")).ToArray());
|
|
|
|
if (!_startWaitCheckResonse)
|
|
{
|
|
if (reponseData.IndexOf(triggerAck) >= 0)
|
|
{
|
|
_startWaitCheckResonse = true;
|
|
return RFMatchResponseResult.TriggerAck;
|
|
}
|
|
else if (CheckNak(reponseData) != ResponseNAK.NotNak)
|
|
{
|
|
Device.NoteNAK(CheckNak(reponseData));
|
|
return RFMatchResponseResult.TriggerNAK;
|
|
}
|
|
else
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
return RFMatchResponseResult.InvalidResonse;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var subRes = reponseData.Substring(0, checkResponseArray[0].Length);
|
|
if (checkResponseArray.Contains(subRes))
|
|
{
|
|
if(subRes == checkResponseArray[2])
|
|
{
|
|
return RFMatchResponseResult.CheckCompleted;
|
|
}
|
|
else
|
|
{
|
|
return RFMatchResponseResult.CheckInProcess;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
return RFMatchResponseResult.InvalidResonse;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
protected bool HandleSetMessage(MessageBase msg)
|
|
{
|
|
CometRFMatchMessage response = msg as CometRFMatchMessage;
|
|
|
|
string setOK = _command;
|
|
string[] checkResponseArray = new string[] { "53", "52", "51" };
|
|
|
|
string reponseData = string.Join(",", response.Data.Select(bt => bt.ToString("X2")).ToArray());
|
|
if (reponseData.IndexOf(setOK) >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
else if (CheckNak(reponseData) != ResponseNAK.NotNak)
|
|
{
|
|
Device.NoteNAK(CheckNak(reponseData));
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected bool HandleGetMessage(MessageBase msg)
|
|
{
|
|
CometRFMatchMessage response = msg as CometRFMatchMessage;
|
|
|
|
string setOK = _completeEvent;
|
|
string reponseData = string.Join(",", response.Data.Select(bt => bt.ToString("X2")).ToArray());
|
|
if (reponseData.IndexOf(setOK) >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
protected static byte[] StringToByteArray(string parameter)
|
|
{
|
|
if (parameter == null)
|
|
return new byte[] { };
|
|
|
|
return parameter.Split(',').Select(para => Convert.ToByte(para, 16)).ToArray();
|
|
}
|
|
protected static byte[] IntToByteArray(int num)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(num);
|
|
return bytes;
|
|
}
|
|
|
|
protected static byte[] ShortToByteArray(short num)
|
|
{
|
|
byte[] bytes = BitConverter.GetBytes(num);
|
|
return bytes;
|
|
}
|
|
|
|
protected uint ByteArrayToUInt(byte[] bytes)
|
|
{
|
|
uint temp = BitConverter.ToUInt32(bytes.Reverse().ToArray(), 0);
|
|
return temp;
|
|
}
|
|
protected short ByteArrayToShort(byte[] bytes)
|
|
{
|
|
short temp = BitConverter.ToInt16(bytes.Reverse().ToArray(), 0);
|
|
return temp;
|
|
}
|
|
|
|
protected void SetDevicePropValue<T>(string propName, T value)
|
|
{
|
|
try
|
|
{
|
|
Type objType = Device.GetType();
|
|
objType.GetProperty(propName).SetValue(Device, value, null);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public string DevicePropName;
|
|
}
|
|
|
|
public class CommetRFMatchRawCommandHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchRawCommandHandler(CometRFMatch device, string command, string completeEvent, string parameter)
|
|
: base(device, command, completeEvent, parameter)
|
|
{
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool transactionComplete)
|
|
{
|
|
CometRFMatchMessage response = msg as CometRFMatchMessage;
|
|
ResponseMessage = msg;
|
|
|
|
string reponseData = string.Join(",", response.Data.Select(bt => bt.ToString("X2")).ToArray());
|
|
if (_completeEvent.Contains("|"))
|
|
{
|
|
var eventArray = _completeEvent.Split('|');
|
|
var subRes = reponseData.Substring(0, eventArray[0].Length);
|
|
if (!eventArray.Contains(subRes))
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
|
|
transactionComplete = false;
|
|
return false;
|
|
}
|
|
}
|
|
else if (reponseData.IndexOf(_completeEvent) == -1)
|
|
{
|
|
Device.NoteError($"Invalid response, no expected command feedback: {reponseData}");
|
|
msg.IsFormatError = true;
|
|
|
|
transactionComplete = false;
|
|
return false;
|
|
}
|
|
|
|
else if (CheckNak(reponseData) != ResponseNAK.NotNak)
|
|
{
|
|
Device.NoteNAK(CheckNak(reponseData));
|
|
|
|
transactionComplete = false;
|
|
return false;
|
|
}
|
|
|
|
if (response.IsAck)
|
|
{
|
|
SetState(EnumHandlerState.Acked);
|
|
}
|
|
if (this.IsAcked && response.IsComplete)
|
|
{
|
|
SetState(EnumHandlerState.Completed);
|
|
transactionComplete = true;
|
|
Device.NoteRawCommandInfo(_command, string.Join(",", response.RawMessage.Select(bt => bt.ToString("X2")).ToArray()));
|
|
return true;
|
|
}
|
|
|
|
transactionComplete = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class CommetRFMatchTriggerHandler : CometRFMatchHandler
|
|
{
|
|
string _checkCommand;
|
|
public CommetRFMatchTriggerHandler(CometRFMatch device, string triggerCommand, string checkCommand, string propName)
|
|
: base(device, triggerCommand)
|
|
{
|
|
_checkCommand = checkCommand;
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
var resonseResult = HandleTriggerMessage(msg);
|
|
if (resonseResult == RFMatchResponseResult.TriggerAck || resonseResult == RFMatchResponseResult.CheckInProcess)
|
|
{
|
|
Device.Connection.SendMessage(BuildMessage(_checkCommand, null));
|
|
}
|
|
else if (resonseResult == RFMatchResponseResult.CheckCompleted)
|
|
{
|
|
SetDevicePropValue<bool>(DevicePropName, true);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
else if (resonseResult == RFMatchResponseResult.TriggerNAK || resonseResult == RFMatchResponseResult.InvalidResonse)
|
|
{
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public class CommetRFMatchSetHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchSetHandler(CometRFMatch device,string command, string parameter)
|
|
: base(device, command, parameter)
|
|
{
|
|
}
|
|
|
|
public CommetRFMatchSetHandler(CometRFMatch device, string command, short parameter)
|
|
: base(device, command, ShortToByteArray(parameter))
|
|
{
|
|
}
|
|
public CommetRFMatchSetHandler(CometRFMatch device, string command, byte para1, short para2)
|
|
: base(device, command, BuildByteArray(para1, para2))
|
|
{
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleSetMessage(msg))
|
|
{
|
|
Device.NoteSetComplted();
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
public class CommetRFMatchGet3ByteHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchGet3ByteHandler(CometRFMatch device, string command, string completeEvent, string propName, string parameter)
|
|
: base(device, command, completeEvent, parameter)
|
|
{
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
|
|
if (result.Data[3].ToString("X2") != _parameter)
|
|
{
|
|
handled = false;
|
|
return false;
|
|
}
|
|
short oriValue = ByteArrayToShort(result.Data.Skip(3).ToArray());
|
|
SetDevicePropValue<short>(DevicePropName, oriValue);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
public class CommetRFMatchGetLimitHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchGetLimitHandler(CometRFMatch device, string command, string completeEvent, string propName, string parameter)
|
|
: base(device, command, completeEvent, parameter)
|
|
{
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
|
|
if (result.Data[3].ToString("X2") != _parameter)
|
|
{
|
|
handled = false;
|
|
return false;
|
|
}
|
|
short oriValue = ByteArrayToShort(result.Data.Skip(3).ToArray());
|
|
SetDevicePropValue<double>(DevicePropName, oriValue * 0.1);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
public class CommetRFMatchGetDoubleValueHandler : CometRFMatchHandler
|
|
{
|
|
double _factor = 1.0f;
|
|
public CommetRFMatchGetDoubleValueHandler(CometRFMatch device, string command, string completeEvent, string propName, double factor)
|
|
: base(device, command, completeEvent, null)
|
|
{
|
|
DevicePropName = propName;
|
|
_factor = factor;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
short oriValue = ByteArrayToShort(result.Data.Skip(2).ToArray());
|
|
SetDevicePropValue<double>(DevicePropName, oriValue * _factor);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class CommetRFMatchGetIntValueHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchGetIntValueHandler(CometRFMatch device, string command, string completeEvent, string propName)
|
|
: base(device, command, completeEvent, null)
|
|
{
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
uint oriValue = ByteArrayToUInt(result.Data.Skip(2).ToArray());
|
|
SetDevicePropValue<uint>(DevicePropName, oriValue);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class CommetRFMatchGetShortValueHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchGetShortValueHandler(CometRFMatch device, string command, string completeEvent, string propName)
|
|
: base(device, command, completeEvent, null)
|
|
{
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
short oriValue = ByteArrayToShort(result.Data.Skip(2).ToArray());
|
|
SetDevicePropValue<short>(DevicePropName, oriValue);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public class CommetRFMatchGetByteValueHandler : CometRFMatchHandler
|
|
{
|
|
public CommetRFMatchGetByteValueHandler(CometRFMatch device, string command, string completeEvent, string propName)
|
|
: base(device, command, completeEvent, null)
|
|
{
|
|
DevicePropName = propName;
|
|
}
|
|
|
|
public override bool HandleMessage(MessageBase msg, out bool handled)
|
|
{
|
|
if (HandleGetMessage(msg))
|
|
{
|
|
var result = msg as CometRFMatchMessage;
|
|
SetDevicePropValue<byte>(DevicePropName, result.Data[2]);
|
|
handled = true;
|
|
return true;
|
|
}
|
|
handled = false;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|