316 lines
13 KiB
C#
316 lines
13 KiB
C#
using log4net;
|
|
using Sensus.iPerl.NfcHandler;
|
|
using Sensus.iPerl.RfidCom.Exceptions;
|
|
using System;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using static Sensus.iPerl.NfcHandler.MCI_Protocol;
|
|
|
|
namespace TBF.Rig.TestMethods.iPerlCommunication.iPerlHead
|
|
{
|
|
internal class NfcServices
|
|
{
|
|
protected static readonly ILog rfidDataLogger = LogManager.GetLogger("RfidData");
|
|
internal static int ReadRequest(TestMethodCfg cfg, IperlHead iperlHead, MCI_Protocol.StructName structName, int offset, int length, out byte[] buffer)
|
|
{
|
|
for (int i = 0; i < cfg.MaxCommRetries; i++)
|
|
{
|
|
|
|
NfcDataHandler _nfcDataHandler = new NfcDataHandler();
|
|
MessageEventHandlers(_nfcDataHandler);
|
|
CR95HF_MessageEventHandlers(_nfcDataHandler._CR95HF_Reader);
|
|
ST25DV_MessageEventHandlers(_nfcDataHandler._ST25DV_Device);
|
|
MCI_MessageEventHandlers(_nfcDataHandler._MCI_Protocol);
|
|
NFCHeadConfig_MessageEventHandlers(_nfcDataHandler._NFCHead_Config);
|
|
try
|
|
{
|
|
rfidDataLogger.Info($"NFC COM{iperlHead.RfidComPortNr} ReadRequest : {structName}, {offset}, {length}");
|
|
OpenConnection(_nfcDataHandler, cfg, iperlHead);
|
|
|
|
buffer = MciRead(_nfcDataHandler, cfg, structName, (ushort)offset, length);
|
|
_nfcDataHandler.RFProtocolOFF(); // turn off rf antenna due to possible interference
|
|
|
|
CloseComPort(_nfcDataHandler);
|
|
|
|
rfidDataLogger.Info($"NFC COM{iperlHead.RfidComPortNr} ReadRequest : {structName}, {offset}, {length} ; Response= {ByteArrayToHexString(buffer)} ; Error: {_nfcDataHandler.LastErrorMessage}");
|
|
|
|
if (_nfcDataHandler.LastErrorCode != 0)
|
|
{
|
|
throw new RfidValidationException(_nfcDataHandler.LastErrorMessage);
|
|
}
|
|
|
|
return Convert.ToInt32(_nfcDataHandler.LastErrorCode); //return 0;
|
|
}
|
|
catch (RfidValidationException)
|
|
{
|
|
Thread.Sleep(cfg.WaitTimeAfterFailure);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rfidDataLogger.Error($"NFC COM{iperlHead.RfidComPortNr} ReadRequest Error: {ex.Message}");
|
|
buffer = new byte[length];
|
|
return 3;
|
|
}
|
|
}
|
|
buffer = new byte[length];
|
|
return 3;
|
|
}
|
|
|
|
internal static int WriteRequest(TestMethodCfg cfg, IperlHead iperlHead, MCI_Protocol.StructName structName, int offset, int length, byte[] buffer)
|
|
{
|
|
NfcDataHandler _nfcDataHandler = new NfcDataHandler();
|
|
MessageEventHandlers(_nfcDataHandler);
|
|
CR95HF_MessageEventHandlers(_nfcDataHandler._CR95HF_Reader);
|
|
ST25DV_MessageEventHandlers(_nfcDataHandler._ST25DV_Device);
|
|
MCI_MessageEventHandlers(_nfcDataHandler._MCI_Protocol);
|
|
NFCHeadConfig_MessageEventHandlers(_nfcDataHandler._NFCHead_Config);
|
|
try
|
|
{
|
|
rfidDataLogger.Info($"NFC COM{iperlHead.RfidComPortNr} WriteRequest : {structName}, {offset}, {length}, {ByteArrayToHexString(buffer)}");
|
|
OpenConnection(_nfcDataHandler, cfg, iperlHead);
|
|
|
|
MciWrite(_nfcDataHandler, cfg, structName, (ushort)offset, length, buffer);
|
|
_nfcDataHandler.RFProtocolOFF(); // turn off rf antenna due to possible interference
|
|
|
|
CloseComPort(_nfcDataHandler);
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rfidDataLogger.Error($"NFC COM{iperlHead.RfidComPortNr} WriteRequest Error: {ex.Message}");
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
private static void OpenConnection(NfcDataHandler nfcDataHandler, TestMethodCfg cfg, IperlHead iperlHead)
|
|
{
|
|
string comPort = $"COM{iperlHead.RfidComPortNr}";
|
|
int retryCount = 0 ;
|
|
Open:
|
|
nfcDataHandler.Close();
|
|
Thread.Sleep(100);
|
|
if (nfcDataHandler.OpenConnection(comPort, cfg.BaudRate, cfg.DataBits, cfg.ParityBit, cfg.StopBits))
|
|
{
|
|
rfidDataLogger.Info($"NFC COM{iperlHead.RfidComPortNr} Port Open");
|
|
|
|
if (nfcDataHandler.ConnectReader())
|
|
{
|
|
rfidDataLogger.Info($"NFC COM{iperlHead.RfidComPortNr} Reader connected");
|
|
if (!nfcDataHandler.ConnectDevice())
|
|
{
|
|
rfidDataLogger.Error($"NFC COM{iperlHead.RfidComPortNr} Error connect device.");
|
|
for (int i = 0; i < cfg.MaxCommRetries; i++)
|
|
{
|
|
if (nfcDataHandler.Echo()) break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retryCount++;
|
|
rfidDataLogger.Error($"NFC COM{iperlHead.RfidComPortNr} Error connect reader. Reconnect comport {retryCount}");
|
|
if (retryCount < cfg.MaxCommRetries)
|
|
{
|
|
nfcDataHandler.Close();
|
|
iperlHead.ResetNfcInterface(); // reset NFC head via optoport - switch to RFID and back to NFC interface
|
|
goto Open;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
rfidDataLogger.Error($"Open NFC COM{iperlHead.RfidComPortNr} Port Failed");
|
|
}
|
|
|
|
private static void CloseComPort(NfcDataHandler nfcDataHandler)
|
|
{
|
|
nfcDataHandler.Close();
|
|
}
|
|
|
|
private static byte[] MciRead(NfcDataHandler nfcDataHandler, TestMethodCfg cfg, StructName structName, ushort offset, int length)
|
|
{
|
|
bool isReadValues = false;
|
|
int retryCount = 0;
|
|
Read:
|
|
try
|
|
{
|
|
isReadValues = false;
|
|
long num1 = (long)length;
|
|
int timeoutMs = 4000;
|
|
byte payloadlength = Convert.ToByte(num1.ToString("X2"), 16);
|
|
if (nfcDataHandler.MCI_Read(structName, offset, payloadlength, timeoutMs))
|
|
{
|
|
byte[] lastData = nfcDataHandler.LastData;
|
|
if ((long)lastData.Length >= num1)
|
|
{
|
|
rfidDataLogger.Info($"COM: MciRead ({structName},{offset},{length}) = {ByteArrayToHexString(lastData)}");
|
|
return lastData;
|
|
}
|
|
else
|
|
rfidDataLogger.Info($"COM: MciRead ({structName},{offset},{length}) = {ByteArrayToHexString(lastData)}");
|
|
}
|
|
else if (nfcDataHandler.LastErrorCode == (byte)0)
|
|
{
|
|
rfidDataLogger.Info($"MCI Error: Unidentified");
|
|
retryCount++;
|
|
if (retryCount < cfg.MaxCommRetries)
|
|
goto Read;
|
|
}
|
|
else
|
|
{
|
|
rfidDataLogger.Info("Last error message: " + nfcDataHandler.LastErrorMessage);
|
|
retryCount++;
|
|
if (retryCount < cfg.MaxCommRetries)
|
|
goto Read;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rfidDataLogger.Error("MciRead Last error message: " + ex.Message);
|
|
retryCount++;
|
|
if (retryCount < cfg.MaxCommRetries)
|
|
goto Read;
|
|
}
|
|
return new byte[length];
|
|
}
|
|
|
|
private static void MciWrite(NfcDataHandler nfcDataHandler, TestMethodCfg cfg, MCI_Protocol.StructName structName, ushort offset, int length, byte[] payload)
|
|
{
|
|
int retryCount = 0;
|
|
Write:
|
|
try
|
|
{
|
|
long num1 = (long)length;
|
|
int timeoutMs = 4000;
|
|
byte payloadlength = Convert.ToByte(num1);
|
|
if ((int)payloadlength != payload.Length)
|
|
rfidDataLogger.Error("Insufficient Payload -- Payload lenth : " + (object)payload.Length);
|
|
else if (nfcDataHandler.MCI_Write(structName, offset, payloadlength, payload, timeoutMs))
|
|
{
|
|
// OK
|
|
}
|
|
else if (nfcDataHandler.LastErrorCode > (byte)0)
|
|
{
|
|
rfidDataLogger.Error("Last error message: " + nfcDataHandler.LastErrorMessage);
|
|
//int num2 = (int)MessageBox.Show(this._nfcDataHandler.LastErrorMessage);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rfidDataLogger.Error("MciWrite error message: " + ex.Message);
|
|
retryCount++;
|
|
if (retryCount < cfg.MaxCommRetries)
|
|
goto Write;
|
|
}
|
|
}
|
|
|
|
private static void MciWriteCommand(NfcDataHandler nfcDataHandler, byte commandcode)
|
|
{
|
|
try
|
|
{
|
|
ushort offset = 0;
|
|
int timeoutMs = 4000;
|
|
byte payloadlength = 1;
|
|
byte[] payload = new byte[1] { commandcode };
|
|
if (nfcDataHandler.MCI_Write(MCI_Protocol.StructName.Command, offset, payloadlength, payload, timeoutMs) || nfcDataHandler.LastErrorCode <= (byte)0)
|
|
return;
|
|
rfidDataLogger.Error("MciWriteCommand Last error message: " + nfcDataHandler.LastErrorMessage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
rfidDataLogger.Error("MciWriteCommand Last error message: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
public static string ByteArrayToHexString(byte[] data)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
foreach (byte num in data)
|
|
stringBuilder.Append(num.ToString("X2"));
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
private static byte[] BuildPayLoad(string strPayLoad, int length)
|
|
{
|
|
byte[] collection;
|
|
|
|
if (strPayLoad.Split(':').Length > 1)
|
|
{
|
|
uint timestamp = ConvertDateTimeToTimestamp(Convert.ToDateTime(DateTime.ParseExact(strPayLoad, "HH:mm:ss dd/MM/yyyy", (IFormatProvider)CultureInfo.InvariantCulture)));
|
|
byte[] bytes = BitConverter.GetBytes(timestamp);
|
|
return bytes;
|
|
}
|
|
else if (strPayLoad.Split(',').Length > 1)
|
|
{
|
|
string[] strArray = strPayLoad.Split(',');
|
|
collection = new byte[strArray.Length];
|
|
for (int index3 = 0; index3 < strArray.Length; ++index3)
|
|
collection[index3] = Convert.ToByte(strArray[index3], 16);
|
|
return collection;
|
|
}
|
|
else
|
|
{
|
|
//int num = strPayLoad.Split(',').Length;
|
|
collection = HexStringToByteArray(strPayLoad.Substring(strPayLoad.Length - length * 2).ToUpper());
|
|
Array.Reverse((Array)collection);
|
|
return collection;
|
|
}
|
|
}
|
|
|
|
public static byte[] HexStringToByteArray(string hexString)
|
|
{
|
|
int length = hexString.Length;
|
|
byte[] byteArray = new byte[length / 2];
|
|
for (int startIndex = 0; startIndex < length; startIndex += 2)
|
|
byteArray[startIndex / 2] = Convert.ToByte(hexString.Substring(startIndex, 2), 16);
|
|
return byteArray;
|
|
}
|
|
|
|
private static uint ConvertDateTimeToTimestamp(DateTime datetime)
|
|
{
|
|
TimeSpan utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
|
|
return (uint)((datetime - new DateTime(2000, 1, 1, 0, 0, 0).ToLocalTime()).TotalSeconds + utcOffset.TotalSeconds);
|
|
}
|
|
|
|
#region EventHandlers
|
|
public static void MCI_MessageEventHandlers(MCI_Protocol e)
|
|
{
|
|
DelNfc_MCI_MessageHandler mciMessageHandler = new DelNfc_MCI_MessageHandler(OnHandler);
|
|
e.MessageEvent += mciMessageHandler;
|
|
}
|
|
|
|
public static void ST25DV_MessageEventHandlers(ST25DV_Device e)
|
|
{
|
|
DelNfc_ST25DV_MessageHandler dvMessageHandler = new DelNfc_ST25DV_MessageHandler(OnHandler);
|
|
e.MessageEvent += dvMessageHandler;
|
|
}
|
|
|
|
public static void CR95HF_MessageEventHandlers(CR95HF_Reader e)
|
|
{
|
|
DelNfc_CR95HF_MessageHandler hfMessageHandler = new DelNfc_CR95HF_MessageHandler(OnHandler);
|
|
e.MessageEvent += hfMessageHandler;
|
|
}
|
|
|
|
public static void NFCHeadConfig_MessageEventHandlers(NFCHeadConfig e)
|
|
{
|
|
DelNfc_NFCHeadConfig_MessageHandler configMessageHandler = new DelNfc_NFCHeadConfig_MessageHandler(OnHandler);
|
|
e.MessageEvent += configMessageHandler;
|
|
}
|
|
|
|
public static void MessageEventHandlers(NfcDataHandler e)
|
|
{
|
|
DelNfcMessageHandler nfcMessageHandler = new DelNfcMessageHandler(OnHandler);
|
|
e.MessageEvent += nfcMessageHandler;
|
|
}
|
|
|
|
public static void OnHandler(object sender, NfcMessageEventArgs e)
|
|
{
|
|
if (e.Message == null)
|
|
return;
|
|
string message = e.Message.Replace("\n", " ").Replace("\r", "");
|
|
rfidDataLogger.Debug(message);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|