public void DecodeCommand(IProtocolPackage <byte[]> package)
{
var currentIndex = 0;
var container = package[StructureNames.Data].ComponentContent;
for (var i = 0; i < package.Command.CommandDatas.Count; i++)
{
var data = package.Command.CommandDatas.First(obj => obj.DataIndex == i);
if (currentIndex + data.DataLength > container.Length)
{
package.Status = PackageStatus.NoEnoughBuffer;
return;
}
var component = new PackageComponent <byte[]>
{
ComponentName = data.DataName,
DataType = data.DataConvertType,
ComponentIndex = data.DataIndex,
ComponentContent = container.SubBytes(currentIndex, currentIndex + data.DataLength)
};
currentIndex += data.DataLength;
package.AppendData(component);
}
package.DeviceNodeId = (string)DataConverter.DecodeComponentData(package[StructureNames.NodeId]);
package.Finalization();
}
/// <summary>
/// 解码固定顺序数据段
/// </summary>
/// <param name="package"></param>
/// <param name="container"></param>
private void DecodeOrderedData(IProtocolPackage <byte[]> package, byte[] container)
{
var currentIndex = 0;
for (var i = 0; i < package.Command.CommandDatas.Count; i++)
{
var data = package.Command.CommandDatas.First(obj => obj.DataIndex == i);
if (currentIndex + data.DataLength > container.Length)
{
package.Status = PackageStatus.NoEnoughBuffer;
return;
}
var component = new PackageComponent <byte[]>
{
ComponentName = data.DataName,
DataType = data.DataConvertType,
ComponentIndex = data.DataIndex,
ComponentContent = container.SubBytes(currentIndex, currentIndex + data.DataLength)
};
currentIndex += data.DataLength;
package.AppendData(component);
}
}
public AuthResult(AuthResultType type, IProtocolPackage package, IDevice device = null, bool needReply = false)
{
ResultType = type;
AuthDevice = device;
Package = package;
NeedReply = needReply;
}
/// <summary>
/// 存储协议包携带的数据
/// </summary>
/// <param name="package">接收到的协议包</param>
/// <param name="source">接收数据源</param>
public void StoreData(IProtocolPackage <byte[]> package, IPackageSource source)
{
var monitorDataList = new List <MonitorData>();
for (var i = 0; i < package.Command.CommandDatas.Count; i++)
{
var monitorData = new MonitorDataRepository().CreateDefaultModel();
monitorData.DomainId = package.Device.DomainId;
var commandData = package.Command.CommandDatas.First(obj => obj.DataIndex == i);
var temp = _dataConverter.DecodeComponentData(package[commandData.DataName]);
monitorData.DoubleValue = Convert.ToDouble(temp);
monitorData.ProtocolDataId = package.ProtocolData.Id;
monitorData.UpdateTime = DateTime.Now;
monitorData.CommandDataId = commandData.Id;
monitorData.DeviceIdentity = package.Device.Identity;
monitorData.ProjectIdentity = package.Device.Project.Identity;
monitorDataList.Add(monitorData);
}
if (package[ProtocolDataName.DataValidFlag] != null)
{
ProcessDataValidFlag(package, monitorDataList);
}
lock (TempMonitorDatas)
{
TempMonitorDatas.AddRange(monitorDataList);
}
OnMonitorDataReceived();
}
/// <summary>
/// 油烟系统报警信息处理
/// </summary>
/// <param name="package"></param>
/// <param name="source"></param>
public static void LampblackAlarm(IProtocolPackage <byte[]> package, IPackageSource source)
{
var exception = package[ProtocolDataName.LampblackException];
if (exception == null)
{
return;
}
var alarmList = new List <Alarm>();
var flag = Globals.BytesToUint16(exception.ComponentContent, 0, false);
for (var i = 0; i < 8; i++)
{
var error = (1 << i);
if ((flag & error) == 0)
{
continue;
}
var record = new AlarmRepository().CreateDefaultModel();
record.AlarmType = AlarmType.Lampblack;
record.AlarmCode = error;
record.AlarmDeviceId = package.Device.Id;
record.UpdateTime = package.ReceiveDateTime;
record.DomainId = package.Device.DomainId;
alarmList.Add(record);
}
if (alarmList.Count > 0)
{
ProcessInvoke.Instance <ProtocolPackageProcess>().AddOrUpdateAlarm(alarmList);
}
}
private void ParseMonitorData(IProtocolPackage <string> package)
{
var ksDevice = ((KsDustClientSource)package.ClientSource).Device;
if (!package.Command.DeliverParams.Contains("Store"))
{
return;
}
var monitorData = new KsDustMonitorData
{
DeviceId = Guid.Parse(package.ClientSource.ClientIdentity),
ProjectId = ksDevice.ProjectId,
EnterpriseId = ksDevice.Project.EnterpriseId,
DistrictId = ksDevice.Project.DistrictId,
ParticulateMatter = double.Parse(package.GetDataValueString(Properties.Resource.TSP)),
Pm25 = double.Parse(package.GetDataValueString(Properties.Resource.PM25)),
Pm100 = double.Parse(package.GetDataValueString(Properties.Resource.PM100)),
Noise = double.Parse(package.GetDataValueString(Properties.Resource.NOISE)),
Templeture = double.Parse(package.GetDataValueString(Properties.Resource.TEMPERATURE)),
Humidity = double.Parse(package.GetDataValueString(Properties.Resource.HUMIDITY)),
WindSpeed = double.Parse(package.GetDataValueString(Properties.Resource.WINDSPEED)),
WindDirection = (int)double.Parse(package.GetDataValueString(Properties.Resource.WINDDIRECTION)),
MonitorType = ParseMonitorType(package["CmdByte"].ComponentValue),
UpdateTime = DateTime.Now
};
var ctx = new KsDustDbContext();
ctx.KsDustMonitorDatas.Add(monitorData);
ctx.SaveChanges();
ctx.Dispose();
}
/// <summary>
/// 校验协议
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public static bool CheckProtocol <T>(IProtocolPackage <T> package)
{
var convertMethod = Convert.GetMethod($"{package.Protocol.CheckType}Checker");
convertMethod = convertMethod.MakeGenericMethod(typeof(T));
return((bool)convertMethod.Invoke(convertMethod, new object[] { package }));
}
/// <summary>
/// CRC16校验器
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public static bool Crc16Checker(IProtocolPackage package)
{
var calcCrc = Check.GetCCITTCheck(package.GetBytes(), (ushort)(package.PackageLenth - 3));
var protocolCrc = NumberConvert.BytesToUint16(package[StructureNames.CRCValue].ComponentBytes, 0, false);
return(calcCrc == protocolCrc);
}
/// <summary>
/// 将收到的协议包按原样回发
/// </summary>
/// <param name="package">接收到的协议包</param>
/// <param name="source">接收数据源</param>
public void ReplyOriginal(IProtocolPackage <T> package, IPackageSource source)
{
if (source.Type != PackageSourceType.CommunicationServer)
{
return;
}
source.Send(package.GetBytes());
}
public void DetectCommand(IProtocolPackage <byte[]> package, IProtocol matchedProtocol)
{
foreach (var command in matchedProtocol.ProtocolCommands.Where(command =>
(package[StructureNames.CmdType].ComponentContent.SequenceEqual(command.CommandTypeCode)) &&
(package[StructureNames.CmdByte].ComponentContent.SequenceEqual(command.CommandCode))))
{
package.Command = command;
}
}
public void DetectCommand(IProtocolPackage <string> package, IProtocol matchedProtocol)
{
foreach (var command in matchedProtocol.ProtocolCommands.Where(command =>
(package[StructureNames.CmdType].ComponentValue == Encoding.ASCII.GetString(command.CommandTypeCode)) &&
(package[StructureNames.CmdByte].ComponentValue == Encoding.ASCII.GetString(command.CommandCode))))
{
package.Command = command;
}
}
public void DoDelive(IProtocolPackage package, IPackageSource source)
{
var bytesPackage = (IProtocolPackage <string>)package;
if (bytesPackage == null)
{
return;
}
_deliver.Delive(bytesPackage, source);
}
/// <summary>
/// 处理协议数据有效性标志位
/// </summary>
/// <param name="package">协议数据包</param>
/// <param name="monitorDatas">监测数据</param>
public void ProcessDataValidFlag(IProtocolPackage <byte[]> package, List <MonitorData> monitorDatas)
{
var dataValidFlag = BytesDataConverter.GetDataValidFlag(package[ProtocolDataName.DataValidFlag].ComponentContent);
foreach (var commandData in package.Command.CommandDatas)
{
var monitorData = monitorDatas.First(obj => obj.CommandDataId == commandData.Id);
monitorData.DataIsValid = dataValidFlag[commandData.ValidFlagIndex];
}
}
/// <summary>
/// 收到客户端请求，通过 REQ/REP的模式向远端Actor请求处理,并获得数据
/// </summary>
/// <param name="protocolPackage"></param>
/// <param name="body"></param>
public virtual Out ProcessRequest(IProtocolPackage protocolPackage, byte[] body)
{
//LRU
//REQ --- Router/Router --- REQ
if (protocolPackage == null)
{
return(null);
}
if (Logger.IsDebugEnabled)
{
Logger.Debug($"request from #{protocolPackage.Id}# {protocolPackage.RemoteEndPoint}");
}
if (protocolPackage.CryptoByte > 0)
{
var last = NetSend.GetProtocolPackage(protocolPackage.Rid);
if (!Equals(last.Id, protocolPackage.Id))
{
if (Logger.IsDebugEnabled)
{
Logger.Warn($"!Equals(last.Id, protocolPackage.Id)");
}
protocolPackage.Close();
if (Logger.IsDebugEnabled)
{
Logger.Debug($"#{protocolPackage.Id}# !Equals(last.Id, protocolPackage.Id)");
}
return(null);
}
}
//解密Cient数据包
var request = protocolPackage.UnPackToPacket(body);
var din = new In()
{
Version = 1,
Action = PirateXAction.Req,
HeaderBytes = request.HeaderBytes,
QueryBytes = request.ContentBytes,
Ip = (protocolPackage.RemoteEndPoint as IPEndPoint).Address.ToString(),
LastNo = protocolPackage.LastNo,
SessionId = protocolPackage.Id,
FrontendID = FrontendID,
};
if (ProfilerLog.ProfilerLogger.IsInfoEnabled)
{
din.Profile.Add("_tin_", $"{DateTime.UtcNow.Ticks}");
}
return(RequestToRemoteResponseSocket(din));
}
public void RunHandler(IProtocolPackage package)
{
if (!(package is IProtocolPackage <string>))
{
return;
}
var ksPackage = (IProtocolPackage <string>)package;
if (ksPackage.Command.CommandCategory == "TimingAutoReport")
{
ParseMonitorData(ksPackage);
}
}
/// <summary>
/// 尝试查找设备信息
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
private static void TryGetClientSource(IProtocolPackage package)
{
foreach (var clientSourceProvider in ClientSourceProviders)
{
var client = clientSourceProvider.GetClientSource(package.DeviceNodeId);
if (client == null)
{
continue;
}
package.ClientSource = client;
break;
}
}
protected virtual void DoDelive(IProtocolPackage <T> package, IPackageSource source)
{
var deliverParams = package.DeliverParams;
if (deliverParams.Count == 0)
{
return;
}
foreach (var deliverMethod in deliverParams.Select(param => Deliver.GetMethod(param)))
{
deliverMethod.Invoke(this, new object[] { package, source });
}
}
/// <summary>
/// CRC16校验器
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public static bool Crc16Checker <T>(IProtocolPackage <T> package)
{
var realpackage = package as BytesProtocolPackage;
if (realpackage == null)
{
return(false);
}
var calcCrc = Globals.GetUsmbcrc16(realpackage.GetBytes(), (ushort)(package.PackageLenth - 3));
var protocolCrc = Globals.BytesToUint16(realpackage[StructureNames.CRCValue].ComponentContent, 0, false);
return(calcCrc == protocolCrc);
}
public static bool CrcModBusChecker <T>(IProtocolPackage <T> package)
{
var realpackage = package as StringProtocolPackage;
if (realpackage == null)
{
return(false);
}
var protocolBytes = realpackage.GetBytes();
var calcCrc = Globals.GetCrcModBus(protocolBytes.SubBytes(6, protocolBytes.Length - 6));
var protocolCrc = realpackage[StructureNames.CrcModBus].ComponentContent;
return(calcCrc == protocolCrc);
}
/// <summary>
/// 存储协议包数据
/// </summary>
/// <param name="package">协议数据包</param>
/// <returns>保存数据包相关信息</returns>
public static void ParseProtocolData(IProtocolPackage package)
{
var protocolData = new ProtocolDataRepository().CreateDefaultModel();
protocolData.DeviceIdentity = package.Device.Identity;
protocolData.ProtocolId = package.Protocol.Id;
protocolData.ProtocolTime = package.ReceiveDateTime;
protocolData.UpdateTime = DateTime.Now;
protocolData.DomainId = package.Device.DomainId;
protocolData.ProtocolContent = package.GetBytes();
protocolData.Length = protocolData.ProtocolContent.Length;
package.ProtocolData = protocolData;
ProcessInvoke.Instance <ProtocolPackageProcess>().AddOrUpdateProtocolData(protocolData);
}
public virtual void OnSessionClosed(IProtocolPackage protocolPackage)
{
if (protocolPackage == null)
{
return;
}
// 加入队列
RequestToRemoteResponseSocket(new In()
{
Version = 1,
Action = PirateXAction.Closed,
Ip = (protocolPackage.RemoteEndPoint as IPEndPoint)?.Address.ToString(),
LastNo = protocolPackage.LastNo,
SessionId = protocolPackage.Id,
});
}
/// <summary>
/// 处理缓存
/// </summary>
public void Process()
{
lock (_processBuffer)
{
while (_processBuffer.Count > 0)
{
if (_isDisposed)
{
return;
}
try
{
IProtocolPackage package = null;
switch (_authStatus)
{
case AuthenticationStatus.NotAuthed:
package = Authentication();
break;
case AuthenticationStatus.AuthFailed:
Close();
break;
case AuthenticationStatus.Authed:
package = Decode();
break;
}
AsyncCleanBuffer(package);
}
catch (Exception ex)
{
LogService.Instance.Warn("协议解码错误！", ex);
var innerException = ex.InnerException;
while (innerException != null)
{
LogService.Instance.Warn("协议解码异常详情。", innerException);
innerException = innerException.InnerException;
}
_processBuffer.Clear();
return;
}
}
}
}
public void DecodeCommand(IProtocolPackage <byte[]> package)
{
var container = package[StructureNames.Data].ComponentContent;
switch (package.Command.DataOrderType)
{
case DataOrderType.Order:
DecodeOrderedData(package, container);
break;
case DataOrderType.Random:
DecodeRandomData(package, container);
break;
}
package.DeviceNodeId = (string)DataConverter.DecodeComponentData(package["NodeId"]);
package.Finalization();
}
/// <summary>
/// 解码自由组合数据段
/// </summary>
/// <param name="package"></param>
/// <param name="container"></param>
private void DecodeRandomData(IProtocolPackage <byte[]> package, byte[] container)
{
var currentIndex = 0;
while (currentIndex < container.Length)
{
var dataIndex = currentIndex + 2;
var flagIndex = currentIndex + 1;
var dataFlag = container[flagIndex] & 0x7F; //0x7F = 0111 1111
var data = package.Command.CommandDatas.First(obj => obj.DataFlag == dataFlag);
if (currentIndex + data.DataLength > container.Length)
{
package.Status = PackageStatus.NoEnoughBuffer;
return;
}
var channel = container[currentIndex];
var component = new PackageComponent <byte[]>
{
ComponentName = $"{data.DataName}-{channel}",
ComponentChannel = channel,
CommandData = data,
DataValueType = data.DataValueType,
DataType = data.DataConvertType,
ComponentIndex = data.DataIndex,
ValidFlag = container[flagIndex],
ComponentContent = container.SubBytes(dataIndex, dataIndex + data.DataLength)
};
currentIndex = data.DataLength + dataIndex;
package.AppendData(component);
}
}
protected override void DecodeCommand(IProtocolPackage <string> package)
{
var container = package[StructureNames.Data].ComponentContent;
container = container.Replace("CP=&&", string.Empty).Replace("&&", string.Empty);
var dataGroups = container.Split(';');
var commandDataDicts = (from dataGroup in dataGroups
where dataGroup.Contains(",")
from data in dataGroup.Split(',')
select data.Split('='))
.ToDictionary(dataKeyValuePair => dataKeyValuePair[0], dataKeyValuePair => dataKeyValuePair[1]);
foreach (var commandDataDic in commandDataDicts)
{
var commandData = package.Command.CommandDatas.FirstOrDefault(obj => obj.DataName == commandDataDic.Key);
if (commandData == null)
{
continue;
}
var component = new PackageComponent <string>
{
ComponentName = commandDataDic.Key,
DataType = commandData.DataConvertType,
ComponentIndex = commandData.DataIndex,
ComponentContent = commandDataDic.Value
};
component.ComponentValue = component.ComponentContent;
package.AppendData(component);
}
package.DeviceNodeId = package[StructureNames.NodeId].ComponentValue;
package.Finalization();
}
/// <summary>
/// 同步清除处理BUFF
/// </summary>
/// <param name="package">当前处理中的协议包</param>
private void AsyncCleanBuffer(IProtocolPackage package)
{
if (package == null)
{
return;
}
switch (package.Status)
{
case PackageStatus.NoEnoughBuffer:
return;
case PackageStatus.InvalidHead:
_processBuffer.RemoveAt(0);
return;
case PackageStatus.InvalidPackage:
_processBuffer.RemoveRange(0, package.PackageLenth);
return;
case PackageStatus.Finalized:
_processBuffer.RemoveRange(0, package.PackageLenth);
return;
}
}
/// <summary>
/// 校验协议
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public static bool CheckProtocol(IProtocolPackage package)
{
var convertMethod = Convert.GetMethod($"{package.Protocol.CheckType}Checker");
return((bool)convertMethod.Invoke(convertMethod, new object[] { package }));
}
/// <summary>
/// 执行业务处理程序
/// </summary>
/// <param name="package"></param>
public static void RunBuinessHandler(IProtocolPackage package)
{
var handler = BuinessHandlers.FirstOrDefault(h => h.BusinessName == package.ClientSource.BusinessName);
handler?.RunHandler(package);
}
public void Delive(IProtocolPackage package, IPackageSource source)
{
var coder = GetCommandCoder(package.Protocol.ProtocolName);
coder.DoDelive(package, source);
}
public void Delive(IProtocolPackage <T> package, IPackageSource source)
{
ParseProtocolData(package);
DoDelive(package, source);
}
