public static void TrigerErrorMessage(IReaderMessage e)
{
if (AbstractReader.OnErrorMessage != null)
{
AbstractReader.OnErrorMessage(e);
}
}
private void iConn_OnMsgReceived(IReaderMessage e)
{
if (this.OnReaderMessageReceived != null)
{
this.OnReaderMessageReceived(this, e);
}
}
public void Log(string msg, IReaderMessage e)
{
Console.WriteLine(msg);
Log(string.Format("MessageID:{0}" +
"\r\nStatus:{1}" +
"\r\nErrorInfo.ErrCode:{2}" +
"\r\nErrorInfo.ErrMsg:{3}" +
"\r\nReceivedData={4}", e.MessageID, e.Status, e.ErrorInfo.ErrCode, e.ErrorInfo.ErrMsg, ByteFormat.ToHex(e.ReceivedData, "", " ")));
}
public override async Task <Boolean> ProcessMessageInputAsync(IReaderMessage <T> message)
{
if (message.Count > 0 && Rules.TryGetValue(message[0], out ICommandRule <T> rule))
{
return(await rule.ExecuteAsync(message).ConfigureAwait(false));
}
return(await Rule.ExecuteAsync(message).ConfigureAwait(false));
}
public IReaderMessage ParseMessageNotification(byte[] recvMsg)
{
IReaderMessage readerMessage = null;
ushort messageType = GetMessageType(recvMsg);
if (MessageType.msgType.ContainsKey(messageType))
{
Type type = Type.GetType("NetAPI.Protocol.VRP." + MessageType.msgType[messageType], throwOnError: true);
readerMessage = (IReaderMessage)Activator.CreateInstance(type, null);
readerMessage.ReceivedData = recvMsg;
}
return(readerMessage);
}
protected override async Task <Boolean> RunAsync(IConsoleRule <T> rule, IReaderMessage <T> message)
{
if (message.Count > 0 && Rules.TryGetValue(message[0], out ICommandRule <T> nrule))
{
return(await nrule.ExecuteAsync(message).ConfigureAwait(false));
}
if (DefaultHandler is null)
{
return(false);
}
return(await DefaultHandler.Invoke(this, message).ConfigureAwait(false));
}
internal void process()
{
while (isConnected)
{
List <byte[]> msgs = null;
byte[] bufferQueue = BufferQueue;
iProcess.Parse(bufferQueue, out msgs);
if (msgs != null && msgs.Count > 0)
{
foreach (byte[] item in msgs)
{
try
{
Console.WriteLine("[" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "]接收数据：" + Util.ConvertbyteArrayToHexWordstring(item));
Console.WriteLine("");
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
lock (lockinfo)
{
if (info != null && !info.isDone && iProcess.GetMessageID(item) == info.msg.MessageID)
{
info.msg.ReceivedData = item;
info.isDone = true;
info.ev.Set();
continue;
}
}
IReaderMessage readerMessage = null;
try
{
readerMessage = iProcess.ParseMessageNotification(item);
if (this.OnMsgReceived != null && readerMessage != null)
{
this.OnMsgReceived.BeginInvoke(readerMessage, null, null);
}
}
catch (Exception ex2)
{
string text = "";
if (readerMessage != null)
{
text = readerMessage.MessageID.ToString("X4");
}
if (text.Length % 2 == 1)
{
text = "0" + text;
}
Log.Error("ICommunication:" + ex2.Message + "|MsgID:" + text);
}
}
}
if (this.OnBuffReceived != null)
{
this.OnBuffReceived(bufferQueue);
}
}
Log.Info("ICommunication:线程退出");
}
protected override Boolean Check(IReaderMessage <T> message)
{
return(message.Count > 0 && Equals(message[0], Id));
}
protected override Boolean CheckMessage(IReaderMessage <String> message)
{
return(message.IsExternal);
}
protected override Task <Boolean> DefaultHandlerAsync(IConsoleRule <String> rule, IReaderMessage <String> message)
{
return(TaskUtils.True);
}
protected sealed override async Task <Boolean> RunAsync(IConsoleRule <ConsoleKeyInfo> rule, IReaderMessage <ConsoleKeyInfo> message)
{
if (_active is not null)
{
if (message.Value.Key != ConsoleKey.Escape)
{
return(await _active.ExecuteAsync(message).ConfigureAwait(false));
}
_active = null;
return(true);
}
if (Rules.Count < 1)
{
return(true);
}
Action action = message.Value.Key switch
{
ConsoleKey.Enter => Enter,
ConsoleKey.UpArrow => RuleUp,
ConsoleKey.DownArrow => RuleDown,
_ => null
};
if (action is null)
{
return(true);
}
action.Invoke();
await RefreshAsync().ConfigureAwait(false);
return(true);
}
protected override Boolean Check(IReaderMessage <T> message)
{
return(true);
}
private void Reader_OnMessageNotificationReceived(AbstractReader reader, IReaderMessage msg)
{
if (msg.Status == MsgStatus.Success || msg is MsgActiveTagActive || msg is MsgActiveTagSleep)
{
if (msg is MsgTagInventory)
{
if (isStart_AutoPowerConfig && !isPause_AutoPowerConfig)
{
if (this.OnAutoPowerConfigInventoryReceived != null)
{
MsgTagInventory msgTagInventory = msg as MsgTagInventory;
if (IsEnableAntenna || IsEnableRSSI)
{
msgTagInventory.ReceivedMessage.setAntennaAndRSSI(IsEnableAntenna, IsEnableRSSI);
}
this.OnAutoPowerConfigInventoryReceived(reader.ReaderName, msgTagInventory.ReceivedMessage.TagData);
}
}
else if (this.OnInventoryReceived != null)
{
MsgTagInventory msgTagInventory2 = msg as MsgTagInventory;
if (msgTagInventory2.isRS485)
{
RS485Item[] rS485Items = RS485Items;
foreach (RS485Item rS485Item in rS485Items)
{
if (rS485Item.Address == msgTagInventory2.address)
{
if (rS485Item.IsEnableAntenna || rS485Item.IsEnableRSSI)
{
msgTagInventory2.ReceivedMessage.setAntennaAndRSSI(IsEnableAntenna, IsEnableRSSI);
}
break;
}
}
}
else if (IsEnableAntenna || IsEnableRSSI)
{
msgTagInventory2.ReceivedMessage.setAntennaAndRSSI(IsEnableAntenna, IsEnableRSSI);
}
this.OnInventoryReceived(reader.ReaderName, msgTagInventory2.ReceivedMessage.TagData);
}
}
if (msg is MsgTagRead && this.OnInventoryReceived != null)
{
MsgTagRead msgTagRead = msg as MsgTagRead;
if (msgTagRead.isRS485)
{
RS485Item[] rS485Items2 = RS485Items;
foreach (RS485Item rS485Item2 in rS485Items2)
{
if (rS485Item2.Address == msgTagRead.address)
{
if (rS485Item2.IsEnableAntenna || rS485Item2.IsEnableRSSI)
{
msgTagRead.ReceivedMessage.setAntennaAndRSSI(IsEnableAntenna, IsEnableRSSI);
}
break;
}
}
}
else if (IsEnableAntenna || IsEnableRSSI)
{
msgTagRead.ReceivedMessage.setAntennaAndRSSI(IsEnableAntenna, IsEnableRSSI);
}
this.OnInventoryReceived(reader.ReaderName, msgTagRead.ReceivedMessage.TagData);
}
if (msg is MsgAlarmInfo_AccessControl && this.OnMsgAlarmInfo_AccessControl != null)
{
MsgAlarmInfo_AccessControl msgAlarmInfo_AccessControl = msg as MsgAlarmInfo_AccessControl;
this.OnMsgAlarmInfo_AccessControl(reader.ReaderName, msgAlarmInfo_AccessControl.ReceivedMessage.TagData);
}
if (msg is MsgActiveTagInventory && this.OnActiveTagInventoryReceived != null)
{
MsgActiveTagInventory msgActiveTagInventory = msg as MsgActiveTagInventory;
this.OnActiveTagInventoryReceived(reader.ReaderName, msgActiveTagInventory.ReceivedMessage.ActiveTagList);
}
if (msg is MsgActiveTagInventory2 && this.OnActiveTagInventoryReceived != null)
{
MsgActiveTagInventory2 msgActiveTagInventory2 = msg as MsgActiveTagInventory2;
this.OnActiveTagInventoryReceived(reader.ReaderName, msgActiveTagInventory2.ReceivedMessage.ActiveTagList);
}
if (msg is MsgActiveTagActive && this.OnMsgActiveTagActiveReceivedHandle != null)
{
MsgActiveTagActive msg2 = msg as MsgActiveTagActive;
this.OnMsgActiveTagActiveReceivedHandle(reader.ReaderName, msg2);
}
if (msg is MsgActiveTagSleep && this.OnMsgActiveTagSleepReceivedHandle != null)
{
MsgActiveTagSleep msg3 = msg as MsgActiveTagSleep;
this.OnMsgActiveTagSleepReceivedHandle(reader.ReaderName, msg3);
}
if (msg is MsgFirmwareOnlineUpgrade && this.OnFirmwareOnlineUpgradeReceived != null)
{
MsgFirmwareOnlineUpgrade msgFirmwareOnlineUpgrade = msg as MsgFirmwareOnlineUpgrade;
uint frameAddress = msgFirmwareOnlineUpgrade.ReceivedMessage.FrameAddress;
ushort total = (ushort)(frameAddress >> 16);
ushort rate = (ushort)frameAddress;
this.OnFirmwareOnlineUpgradeReceived(total, rate);
}
if (msg is MsgAppFirmwareOnlineUpgrade && this.OnFirmwareOnlineUpgradeReceived != null)
{
MsgAppFirmwareOnlineUpgrade msgAppFirmwareOnlineUpgrade = msg as MsgAppFirmwareOnlineUpgrade;
uint frameAddress2 = msgAppFirmwareOnlineUpgrade.ReceivedMessage.FrameAddress;
ushort total2 = (ushort)(frameAddress2 >> 16);
ushort rate2 = (ushort)frameAddress2;
this.OnAppFirmwareOnlineUpgradeReceived(total2, rate2);
}
if (msg is MsgCtrlUpdata_YC001 && this.OnCtrlUpdata_YC001 != null)
{
MsgCtrlUpdata_YC001 msgCtrlUpdata_YC = msg as MsgCtrlUpdata_YC001;
byte ctrlBoardNO = msgCtrlUpdata_YC.ReceivedMessage.CtrlBoardNO;
IrTrigger[] irStates = msgCtrlUpdata_YC.ReceivedMessage.IrStates;
SenssorTrigger[] senssorStates = msgCtrlUpdata_YC.ReceivedMessage.SenssorStates;
this.OnCtrlUpdata_YC001(ctrlBoardNO, irStates, senssorStates);
}
if (msg is MsgKeepAlive_YC001 && this.OnKeepAlive_YC001 != null)
{
this.OnKeepAlive_YC001();
}
if (msg is MsgKeepAlive)
{
if (keepAliveInterval == 0)
{
MsgKeepAliveConfig msgKeepAliveConfig = new MsgKeepAliveConfig();
if (Send(msgKeepAliveConfig, 2000))
{
isEnableKeepAlive = msgKeepAliveConfig.ReceivedMessage.IsEnable;
keepAliveInterval = msgKeepAliveConfig.ReceivedMessage.Interval;
}
}
if (threadKeepAlive == null || !threadKeepAlive.IsAlive)
{
threadKeepAlive = new Thread(threadKeepAliveMethod);
threadKeepAlive.Start();
}
dtKeepAlive = DateTime.Now;
}
if (msg is MsgSearchIp)
{
MsgSearchIp info = msg as MsgSearchIp;
if (this.OnUdpSearchIpReceived != null)
{
this.OnUdpSearchIpReceived(ReaderName, info);
}
}
}
}
protected virtual Task <Boolean> RunAsync(IConsoleRule <T> rule, IReaderMessage <T> message)
{
return(TaskUtils.False);
}
public async Task <Boolean> ExecuteAsync(IReaderMessage <T> message)
{
return(Check(message) && await Handler.Invoke(this, message.Next).ConfigureAwait(false));
}
protected virtual Boolean Check(IReaderMessage <T> message)
{
return(true);
}
