admin/JiShe.CollectBus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

添加报文解析

Browse Source
This commit is contained in:
zenghongyao 2025-04-24 19:31:28 +08:00
parent 8da5fee0a2
commit cc35ad2664
67 changed files with 3139 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
protocols/JiShe.CollectBus.Protocol.Contracts/Abstracts/ProtocolPlugin.cs
View File

@ -93,8 +93,9 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
/// 控制域C解析 /// 控制域C解析
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public virtual C? Analysis_C(List<string> hexStringList) public virtual C Analysis_C(List<string> hexStringList)
{ {
C c = new C();
try try
{ {
if (hexStringList.Count > 6) if (hexStringList.Count > 6)
@ -107,7 +108,7 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
if (baseHexMessage.HexMessageList.Count == 0) if (baseHexMessage.HexMessageList.Count == 0)
return null; return null;
string binStr = baseHexMessage.HexMessageString.HexTo4BinZero(); string binStr = baseHexMessage.HexMessageString.HexTo4BinZero();
C c = new C c = new C
{ {
BaseHexMessage = baseHexMessage, BaseHexMessage = baseHexMessage,
FC = binStr.Substring(binStr.Length - 4, 4).BinToDec(), FC = binStr.Substring(binStr.Length - 4, 4).BinToDec(),
@ -124,7 +125,7 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
_logger.LogError($"解析Analysis_C错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_C错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return c;
} }
/// <summary> /// <summary>
@ -132,8 +133,9 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
/// </summary> /// </summary>
/// <param name="hexStringList"></param> /// <param name="hexStringList"></param>
/// <returns></returns> /// <returns></returns>
public virtual A? Analysis_A(List<string> hexStringList) public virtual A Analysis_A(List<string> hexStringList)
{ {
A a = new A();
try try
{ {
if (hexStringList.Count > 7) if (hexStringList.Count > 7)
@ -143,17 +145,15 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
HexMessageList = hexStringList.GetRange(7, 5) // 地址域 5个字节 HexMessageList = hexStringList.GetRange(7, 5) // 地址域 5个字节
}; };
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
if (baseHexMessage.HexMessageList.Count == 0) a = new A
return null;
A a = new A
{ {
BaseHexMessage = baseHexMessage, BaseHexMessage = baseHexMessage,
A1 = baseHexMessage.HexMessageList.ListReverseToStr(0, 2),//.DataConvert(10);//行政区划码A1 A1 = baseHexMessage.HexMessageList.ListReverseToStr(0, 2),//.DataConvert(10);//行政区划码A1
A2 = baseHexMessage.HexMessageList.ListReverseToStr(2, 2).PadLeft(5, '0').HexToDec(),//终端地址A2 A2 = baseHexMessage.HexMessageList.ListReverseToStr(2, 2).PadLeft(5, '0').HexToDec(),//终端地址A2
A3 = Analysis_A3(baseHexMessage.HexMessageList) //主站地址和组地址标志A3 A3 = Analysis_A3(baseHexMessage.HexMessageList) //主站地址和组地址标志A3
}; };
a.Code = $"{a.A1.PadLeft(4, '0')}{a.A2.ToString().PadLeft(5, '0')}"; a.Code = $"{a.A1.PadLeft(4, '0')}{a.A2.ToString()!.PadLeft(5, '0')}";
return a;
} }
} }
catch (Exception ex) catch (Exception ex)
@ -161,7 +161,7 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
_logger.LogError($"解析Analysis_A错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_A错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return a;
} }
@ -170,185 +170,192 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
/// </summary> /// </summary>
/// <param name="hexAList">地址域A集合</param> /// <param name="hexAList">地址域A集合</param>
/// <returns></returns> /// <returns></returns>
public virtual A3? Analysis_A3(List<string> hexAList) public virtual A3 Analysis_A3(List<string> hexAList)
{ {
A3 a3 = new A3();
try try
{ {
BaseHexMessage baseHexMessage = new BaseHexMessage if (hexAList.Count != 0)
{ {
HexMessageList = hexAList.GetRange(4, 1) // 站地址和组地址标志A3 1个字节 BaseHexMessage baseHexMessage = new BaseHexMessage
}; {
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); HexMessageList = hexAList.GetRange(4, 1) // 站地址和组地址标志A3 1个字节
if (baseHexMessage.HexMessageList.Count == 0) };
return null; baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
var binStr = baseHexMessage.HexMessageString.HexTo4BinZero(); var binStr = baseHexMessage.HexMessageString.HexTo4BinZero();
A3 a3 = new A3 a3 = new A3
{ {
BaseHexMessage = baseHexMessage, BaseHexMessage = baseHexMessage,
D0 = binStr.Substring(binStr.Length - 1, 1).BinToDec(), D0 = binStr.Substring(binStr.Length - 1, 1).BinToDec(),
D1_D7 = binStr.Substring(0, binStr.Length - 1).BinToDec() D1_D7 = binStr.Substring(0, binStr.Length - 1).BinToDec()
}; };
return a3; }
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_A3错误,报文：{string.Join("", hexAList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_A3错误,报文：{string.Join("", hexAList)},异常：{ex.Message}");
} }
return null; return a3;
} }
/// <summary> /// <summary>
/// AFN_FC功能码 /// AFN_FC功能码
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public virtual AFN_FC? Analysis_AFN_FC(List<string> hexStringList) public virtual AFN_FC Analysis_AFN_FC(List<string> hexStringList)
{ {
AFN_FC aFN_FC = new AFN_FC();
try try
{ {
BaseHexMessage baseHexMessage = new BaseHexMessage if (hexStringList.Count == 0)
{ {
HexMessageList = hexStringList.GetRange(12, 1) //AFN功能码 1个字节
}; BaseHexMessage baseHexMessage = new BaseHexMessage
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); {
if (baseHexMessage.HexMessageList.Count == 0) HexMessageList = hexStringList.GetRange(12, 1) //AFN功能码 1个字节
return null; };
AFN_FC aFN_FC = new AFN_FC baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
{
BaseHexMessage = baseHexMessage, aFN_FC = new AFN_FC
AFN = baseHexMessage.HexMessageString.HexToDec(), {
}; BaseHexMessage = baseHexMessage,
return aFN_FC; AFN = baseHexMessage.HexMessageString.HexToDec(),
};
}
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_AFN_FC错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_AFN_FC错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return aFN_FC;
} }
/// <summary> /// <summary>
/// 解析帧序列域SEQ /// 解析帧序列域SEQ
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public virtual SEQ? Analysis_SEQ(List<string> hexStringList) public virtual SEQ Analysis_SEQ(List<string> hexStringList)
{ {
SEQ seq = new SEQ();
try try
{ {
BaseHexMessage baseHexMessage = new BaseHexMessage if (hexStringList.Count != 0)
{ {
HexMessageList = hexStringList.GetRange(13, 1) //帧序列域 SEQ 1个字节 BaseHexMessage baseHexMessage = new BaseHexMessage
}; {
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); HexMessageList = hexStringList.GetRange(13, 1) //帧序列域 SEQ 1个字节
if (baseHexMessage.HexMessageList.Count == 0) };
return null; baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
var binStr = baseHexMessage.HexMessageString.HexTo4BinZero(); var binStr = baseHexMessage.HexMessageString.HexTo4BinZero();
SEQ seq = new SEQ seq = new SEQ
{ {
PSEQ = binStr.Substring(binStr.Length - 4, 4).BinToDec(), PSEQ = binStr.Substring(binStr.Length - 4, 4).BinToDec(),
CON = binStr.Substring(3, 1).BinToDec(), CON = binStr.Substring(3, 1).BinToDec(),
FIN = binStr.Substring(2, 1).BinToDec(), FIN = binStr.Substring(2, 1).BinToDec(),
FIR = binStr.Substring(1, 1).BinToDec(), FIR = binStr.Substring(1, 1).BinToDec(),
TpV = binStr.Substring(0, 1).BinToDec() TpV = binStr.Substring(0, 1).BinToDec()
}; };
return seq; }
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_SEQ错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_SEQ错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return seq;
} }
/// <summary> /// <summary>
/// 数据单元标识及数据单元数据 /// 数据单元标识及数据单元数据
/// </summary> /// </summary>
public virtual UnitData? Analysis_UnitData(List<string> hexStringList) public virtual UnitData Analysis_UnitData(List<string> hexStringList)
{ {
UnitData unitData = new UnitData();
try try
{ {
if (hexStringList.Count != 0)
UnitData unitData = new UnitData
{ {
HexMessageList = hexStringList.GetRange(14, hexStringList.Count - 14 - 2) //总数字节数-固定长度报文头-控制域C-地址域A-校验和CS-结束字符（16H） unitData = new UnitData
}; {
unitData.HexMessageString = string.Join("", unitData.HexMessageList); HexMessageList = hexStringList.GetRange(14, hexStringList.Count - 14 - 2) //总数字节数-固定长度报文头-控制域C-地址域A-校验和CS-结束字符（16H）
if (unitData.HexMessageList.Count == 0) };
return null; unitData.HexMessageString = string.Join("", unitData.HexMessageList);
return unitData; }
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_UnitData错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_UnitData错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return unitData;
} }
/// <summary> /// <summary>
/// 信息点DA Pn /// 信息点DA Pn
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public virtual DA? Analysis_DA(List<string> hexStringList) public virtual DA Analysis_DA(List<string> hexStringList)
{ {
DA da = new DA();
try try
{ {
BaseHexMessage baseHexMessage = new BaseHexMessage if (hexStringList.Count != 0)
{ {
HexMessageList = hexStringList.GetRange(14, 2) //信息点DA Pn 2个字节 BaseHexMessage baseHexMessage = new BaseHexMessage
}; {
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); HexMessageList = hexStringList.GetRange(14, 2) //信息点DA Pn 2个字节
if (baseHexMessage.HexMessageList.Count == 0) };
return null; baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
var da1 = baseHexMessage.HexMessageList[0]; var da1 = baseHexMessage.HexMessageList[0];
var da2 = baseHexMessage.HexMessageList[1]; var da2 = baseHexMessage.HexMessageList[1];
DA da = new DA() da = new DA()
{ {
BaseHexMessage = baseHexMessage, BaseHexMessage = baseHexMessage,
Pn = CalculatePn(da1, da2) Pn = CalculatePn(da1, da2)
}; };
return da; }
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_DA错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_DA错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return da;
} }
/// <summary> /// <summary>
/// 信息类DT Fn /// 信息类DT Fn
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public virtual DT? Analysis_DT(List<string> hexStringList) public virtual DT Analysis_DT(List<string> hexStringList)
{ {
DT dt = new DT();
try try
{ {
BaseHexMessage baseHexMessage = new BaseHexMessage if (hexStringList.Count != 0)
{ {
HexMessageList = hexStringList.GetRange(16, 2) //信息类DT Fn 2个字节 BaseHexMessage baseHexMessage = new BaseHexMessage
}; {
baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList); HexMessageList = hexStringList.GetRange(16, 2) //信息类DT Fn 2个字节
if (baseHexMessage.HexMessageList.Count == 0) };
return null; baseHexMessage.HexMessageString = string.Join("", baseHexMessage.HexMessageList);
var dt1 = baseHexMessage.HexMessageList[0]; var dt1 = baseHexMessage.HexMessageList[0];
var dt2 = baseHexMessage.HexMessageList[1]; var dt2 = baseHexMessage.HexMessageList[1];
DT dt = new DT() dt = new DT()
{ {
BaseHexMessage = baseHexMessage, BaseHexMessage = baseHexMessage,
Fn = CalculateFn(dt1, dt2) Fn = CalculateFn(dt1, dt2)
}; };
return dt; }
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError($"解析Analysis_DT错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}"); _logger.LogError($"解析Analysis_DT错误,报文：{string.Join("", hexStringList)},异常：{ex.Message}");
} }
return null; return dt;
} }
@ -359,7 +366,7 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
/// <param name="da1"></param> /// <param name="da1"></param>
/// <param name="da2"></param> /// <param name="da2"></param>
/// <returns></returns> /// <returns></returns>
public int CalculatePn(string da1, string da2) => (da2.HexToDec() - 1) * 8 + (8 - da1.HexTo4BinZero().IndexOf(da1.Equals("00") ? "0" : "1")); public static int CalculatePn(string da1, string da2) => (da2.HexToDec() - 1) * 8 + (8 - da1.HexTo4BinZero().IndexOf(da1.Equals("00") ? "0" : "1"));
/// <summary> /// <summary>
@ -368,7 +375,7 @@ namespace JiShe.CollectBus.Protocol.Contracts.Abstracts
/// <param name="dt1"></param> /// <param name="dt1"></param>
/// <param name="dt2"></param> /// <param name="dt2"></param>
/// <returns></returns> /// <returns></returns>
public int CalculateFn(string dt1, string dt2) => dt2.HexToDec() * 8 + (8 - dt1.HexTo4BinZero().IndexOf("1")); public static int CalculateFn(string dt1, string dt2) => dt2.HexToDec() * 8 + (8 - dt1.HexTo4BinZero().IndexOf("1"));
} }
} }

16
protocols/JiShe.CollectBus.Protocol.Contracts/Models/TB3761.cs
View File

@ -15,45 +15,45 @@ namespace JiShe.CollectBus.Protocol.Contracts.Models
/// <summary> /// <summary>
/// 报文 /// 报文
/// </summary> /// </summary>
public BaseHexMessage? BaseHexMessage { get; set;} public BaseHexMessage BaseHexMessage { get; set;}=new BaseHexMessage();
/// <summary> /// <summary>
/// 控制域C /// 控制域C
/// </summary> /// </summary>
public C? C { get; set; } public C C { get; set; } = new C();
/// <summary> /// <summary>
/// 地址域A /// 地址域A
/// </summary> /// </summary>
public A? A { get; set; } public A A { get; set; } = new A();
/// <summary> /// <summary>
/// 帧序列域 SEQ /// 帧序列域 SEQ
/// </summary> /// </summary>
public SEQ? SEQ { get; set; } public SEQ SEQ { get; set; } = new SEQ();
/// <summary> /// <summary>
/// 用户数据区 /// 用户数据区
/// 功能码 /// 功能码
/// </summary> /// </summary>
public AFN_FC? AFN_FC { get; set; } public AFN_FC AFN_FC { get; set; } = new AFN_FC();
/// <summary> /// <summary>
/// 用户数据区 /// 用户数据区
/// 信息点DA Pn /// 信息点DA Pn
/// </summary> /// </summary>
public DA? DA { get; set; } public DA DA { get; set; } = new DA();
/// <summary> /// <summary>
/// 用户数据区 /// 用户数据区
/// 信息类DT Fn /// 信息类DT Fn
/// </summary> /// </summary>
public DT? DT { get; set; } public DT DT { get; set; } = new DT();
/// <summary> /// <summary>
/// 数据单元标识和数据单元格式 /// 数据单元标识和数据单元格式
/// </summary> /// </summary>
public UnitData? UnitData { get; set; } public UnitData UnitData { get; set; } = new UnitData();
} }
#region #region

13
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN0_F1_AnalysisDto.cs
View File

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Dto
{
public class AFN0_F1_AnalysisDto: UnitDataDto
{
public bool Verify { get; set; } = true;
}
}

95
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN10_F10_AnalysisDto.cs Normal file
View File

@ -0,0 +1,95 @@
using JiShe.CollectBus.Protocol.Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN10_F10_AnalysisDto
{
/// <summary>
/// 本次电能表/交流采样装置配置数量 n
/// </summary>
public int ConfigNum { get; set; }
/// <summary>
/// 电能表/交流采样装置配置信息
/// </summary>
public List<AFN10F10Entity> AFN10F10Entitys { get; set; } = new List<AFN10F10Entity>();
}
public class AFN10F10Entity
{
/// <summary>
/// 电能表/交流采样装置序号
/// </summary>
public int SerialNum { get; set; }
/// <summary>
/// 所属测量点号
/// </summary>
public int Point { get; set; }
/// <summary>
/// 通信速率
/// </summary>
public int BaudRate { get; set; }
/// <summary>
/// 端口号
/// </summary>
public int Port { get; set; }
/// <summary>
/// 通信协议类型
/// </summary>
public string RuleType { get; set; }
/// <summary>
/// 通信地址
/// </summary>
public string ComAddress { get; set; }
/// <summary>
/// 通信密码
/// </summary>
public string ComPwd { get; set; }
/// <summary>
/// 电能费率个数
/// </summary>
public int ElectricityRatesNum { get; set; }
/// <summary>
/// 有功电能示值整数位及小数位个数
/// </summary>
public int IntegerBitsNum { get; set; }
/// <summary>
/// 有功电能示值小数位个数
/// </summary>
public int DecimalPlacesNum { get; set; }
/// <summary>
/// 所属采集器通信地址
/// </summary>
public string CollectorAddress{ get; set; }
/// <summary>
/// 用户大类号
/// </summary>
public int UserCategoryNum { get; set;}
/// <summary>
/// 用户小类号
/// </summary>
public int UserSubclassNum { get; set; }
}
}

45
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN10_F66_AnalysisDto.cs Normal file
View File

@ -0,0 +1,45 @@
using JiShe.CollectBus.Protocol.Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN10_F66_AnalysisDto
{
/// <summary>
/// 定时发送周期
/// 1:用 D6～D7 编码表示，取值 0～3 依次表示分、时、日、月
/// 2:用 D0～D5 表示，为定时上报数据的时间周期
/// </summary>
public int Cycle { get; set; }
/// <summary>
/// 定时发送周期(单位)
/// </summary>
public int Unit { get; set; }
/// <summary>
/// 发送基准时间
/// </summary>
public DateTime BaseTime { get; set; }
/// <summary>
/// 曲线数据提取倍率
/// </summary>
public int CurveRatio { get; set; }
/// <summary>
/// 任务号
/// </summary>
public int Pn { get; set; }
public List<SetAutoItemCodeDetails> Details { get; set; } = new List<SetAutoItemCodeDetails>();
}
public class SetAutoItemCodeDetails
{
public int Pn { get; set; }
public int Fn { get; set; }
}
}

13
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F129_AnalysisDto.cs Normal file
View File

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F129_AnalysisDto : AnalysisBaseDto<decimal>
{
public DateTime ReadTime { get; set; }
}
}

13
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F130_AnalysisDto.cs Normal file
View File

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F130_AnalysisDto : AnalysisBaseDto<decimal>
{
public DateTime ReadTime { get; set; }
}
}

13
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F131_AnalysisDto.cs Normal file
View File

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F131_AnalysisDto: AnalysisBaseDto<decimal>
{
public DateTime ReadTime { get; set; }
}
}

13
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F132_AnalysisDto.cs Normal file
View File

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F132_AnalysisDto: AnalysisBaseDto<decimal>
{
public DateTime ReadTime { get; set; }
}
}

19
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F145_AnalysisDto.cs Normal file
View File

@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F145_AnalysisDto : AnalysisBaseDto<decimal>
{
/// <summary>
/// 最大需量时标
/// </summary>
public string TimeSpan { get; set; }
public DateTime ReadingDate { get; set; }
}
}

18
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F149_AnalysisDto.cs Normal file
View File

@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F149_AnalysisDto : AnalysisBaseDto<decimal>
{
/// <summary>
/// 最大需量时标
/// </summary>
public string TimeSpan { get; set; }
public DateTime ReadingDate { get; set; }
}
}

12
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F188_AnalysisDto.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F188_AnalysisDto : AnalysisBaseDto<decimal>
{
}
}

16
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F25_AnalysisDto.cs Normal file
View File

@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F25_AnalysisDto: AnalysisBaseDto<decimal>
{
/// <summary>
/// 读取时间
/// </summary>
public DateTime ReadTime { get; set; }
}
}

12
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F2_AnalysisDto.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F2_AnalysisDto: AnalysisBaseDto<string>
{
}
}

55
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F33_AnalysisDto.cs Normal file
View File

@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F33_AnalysisDto
{
/// <summary>
/// 终端抄表时间
/// </summary>
public string ReadTime { get; set; }
/// <summary>
/// 费率数M（1≤M≤12）
/// </summary>
public int RatingCount { get; set; }
/// <summary>
/// 当前正向有功总电能示值
/// </summary>
public ParentNodes F_A_Kwh { get; set; }
/// <summary>
/// 当前正向无功（组合无功1）总电能示值
/// </summary>
public ParentNodes R_R_Kvarh { get; set; }
/// <summary>
/// 当前一象限无功总电能示值
/// </summary>
public ParentNodes Q1_R_Kvarh { get; set; }
/// <summary>
/// 当前四象限无功总电能示值
/// </summary>
public ParentNodes Q4_R_Kvarh { get; set; }
}
public class ParentNodes
{
/// <summary>
/// 总电能示值
/// </summary>
public decimal Total_Value { get; set; }
public List<ChildNodes> childNodes { get; set; }
}
public class ChildNodes
{
/// <summary>
/// 费率总电能示值
/// </summary>
public decimal Value { get; set; }
}
}

15
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN12_F49_AnalysisDto.cs Normal file
View File

@ -0,0 +1,15 @@
using JiShe.CollectBus.Protocol.Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN12_F49_AnalysisDto: AnalysisBaseDto<decimal>
{
}
}

38
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AFN9_F1_AnalysisDto.cs Normal file
View File

@ -0,0 +1,38 @@
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AFN9_F1_AnalysisDto
{
public int FocusID { get; set; }
public string? AreaCode { get; set; }
public string? Address { get; set; }
/// <summary>
/// 厂商代号
/// </summary>
public string? MakerNo { get; set; }
/// <summary>
/// 设备编号
/// </summary>
public string? DeviceNo { get; set; }
/// <summary>
/// 终端软件版本号
/// </summary>
public string? SoftwareVersion { get; set; }
/// <summary>
/// 终端软件发布日期：日月年
/// </summary>
public string? SoftwareReleaseDate { get; set; }
/// <summary>
/// 硬件软件版本号
/// </summary>
public string? HardwareVersion { get; set; }
/// <summary>
/// 硬件软件发布日期：日月年
/// </summary>
public string? HardwareReleaseDate { get; set; }
public string? AddDate { get; set; }
}
}

46
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/AnalysisBaseDto.cs Normal file
View File

@ -0,0 +1,46 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Contracts.Protocol.Dto
{
public class AnalysisBaseDto
{
/// <summary>
/// 是否有效数据
/// </summary>
public bool ValidData { get; set; } = true;
/// <summary>
/// 数据类型
/// </summary>
public string DataType { get; set; }
/// <summary>
/// 错误码信息
/// </summary>
public string ErrorCodeMsg { get; set; }
/// <summary>
/// 字段名
/// </summary>
public string FiledName { get; set; }
/// <summary>
/// 字段描述
/// </summary>
public string FiledDesc { get; set; }
}
public class AnalysisBaseDto<T> : AnalysisBaseDto
{
/// <summary>
/// 抄读值
/// </summary>
public T? DataValue { get; set; }
}
}

22
protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/UnitDataDto.cs → protocols/JiShe.CollectBus.Protocol.Contracts/Protocol/Dto/UnitDataAnalysis.cs
View File

@ -1,12 +1,6 @@
using System; namespace JiShe.CollectBus.Protocol.Dto
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.Dto
{ {
public class UnitDataDto public class UnitDataAnalysis
{ {
/// <summary> /// <summary>
/// 集中器地址 /// 集中器地址
@ -28,15 +22,15 @@ namespace JiShe.CollectBus.Protocol.Dto
/// </summary> /// </summary>
public int Fn { get; set; } public int Fn { get; set; }
/// <summary>
/// 数据时标（最近数据时间点的时间），如：8:00 08:15 记录08:15
/// </summary>
public string? DataTime { get; set; }
}
public class UnitDataAnalysis<T>: UnitDataAnalysis
{
/// <summary> /// <summary>
/// 密度（分） /// 数据
/// </summary> /// </summary>
public int TimeDensity { get; set; } public T? Data { get; set; }
} }
} }

22
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_00H/AFN0_F1_Analysis.cs
View File

@ -13,9 +13,9 @@ using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_00H namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_00H
{ {
/// <summary> /// <summary>
/// 全部确认：对收到报文中的全部数据单元标识进行确认 /// 5.1.3.1 F1：全部确认：对收到报文中的全部数据单元标识进行确认
/// </summary> /// </summary>
public class AFN0_F1_Analysis: IAnalysisStrategy<TB3761, AFN0_F1_AnalysisDto> public class AFN0_F1_Analysis: IAnalysisStrategy<TB3761, UnitDataAnalysis<bool>>
{ {
private readonly ILogger<AFN0_F1_Analysis> _logger; private readonly ILogger<AFN0_F1_Analysis> _logger;
@ -23,24 +23,24 @@ namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_00H
{ {
_logger = logger; _logger = logger;
} }
public Task<UnitDataAnalysis<bool>> ExecuteAsync(TB3761 input)
public Task<AFN0_F1_AnalysisDto> ExecuteAsync(TB3761 tB3761)
{ {
try try
{ {
ArgumentNullException.ThrowIfNull(nameof(tB3761)); ArgumentNullException.ThrowIfNull(input);
AFN0_F1_AnalysisDto dto = new AFN0_F1_AnalysisDto UnitDataAnalysis<bool> dto = new UnitDataAnalysis<bool>
{ {
Code = tB3761.A?.Code, Code = input.A.Code,
AFN = tB3761.AFN_FC?.AFN ?? 0, AFN = input.AFN_FC.AFN,
Fn = tB3761.DT?.Fn ?? 0, Fn = input.DT.Fn,
Pn = tB3761.DA?.Pn ?? 0 Pn = input.DA.Pn ,
Data = true,
}; };
return Task.FromResult(dto); return Task.FromResult(dto);
} }
catch (Exception ex) catch (Exception ex)
{ {
_logger.LogError(ex, $"00_1解析失败:{tB3761.A?.Code}-{tB3761.DT?.Fn ?? 0}-{tB3761?.BaseHexMessage?.HexMessageString},{ex.Message}"); _logger.LogError(ex, $"00_1解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null; return null;
} }
} }

47
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_00H/AFN0_F2_Analysis.cs Normal file
View File

@ -0,0 +1,47 @@
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_00H
{
/// <summary>
/// 5.1.3.2 F2：全部否认
/// </summary>
public class AFN0_F2_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<bool>>
{
private readonly ILogger<AFN0_F2_Analysis> _logger;
public AFN0_F2_Analysis(ILogger<AFN0_F2_Analysis> logger)
{
_logger = logger;
}
public Task<UnitDataAnalysis<bool>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
UnitDataAnalysis<bool> dto = new UnitDataAnalysis<bool>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = false,
};
return Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"00_2解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
}
}

74
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_09H/AFN9_F1_Analysis.cs Normal file
View File

@ -0,0 +1,74 @@
using DeviceDetectorNET.Class;
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.AFN_00H;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using YamlDotNet.Core;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_09H
{
/// <summary>
/// 5.9.1.2 F1:终端版本信息
/// </summary>
public class AFN9_F1_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN9_F1_AnalysisDto>>
{
private readonly ILogger<AFN9_F1_Analysis> _logger;
public AFN9_F1_Analysis(ILogger<AFN9_F1_Analysis> logger)
{
_logger = logger;
}
public Task<UnitDataAnalysis<AFN9_F1_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
var data = AnalysisDataUnit(input.UnitData.HexMessageList);
data.AreaCode = input.A.Code?.Substring(0, 4);
data.Address = input.A.Code?.Substring(4, 5);
UnitDataAnalysis<AFN9_F1_AnalysisDto> dto = new UnitDataAnalysis<AFN9_F1_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data= data
};
return Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"09_1解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
private AFN9_F1_AnalysisDto AnalysisDataUnit(List<string> hexMessageList)
{
AFN9_F1_AnalysisDto version = new AFN9_F1_AnalysisDto();
version.MakerNo = Encoding.ASCII.GetString(string.Join("", hexMessageList.Skip(4).Take(4).ToList()).HexToByte());//厂商代号
version.DeviceNo = Encoding.ASCII.GetString(string.Join("", hexMessageList.Skip(8).Take(8).ToList()).HexToByte()).Replace("\0", "");//设备编号
version.SoftwareVersion = Encoding.ASCII.GetString(string.Join("", hexMessageList.Skip(16).Take(4).ToList()).HexToByte());//终端软件版本号
version.HardwareVersion = Encoding.ASCII.GetString(string.Join("", hexMessageList.Skip(38).Take(4).ToList()).HexToByte());//终端硬件版本号
version.AddDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
var dateArr = hexMessageList.Skip(20).Take(3).ToList();
var dateArr2 = hexMessageList.Skip(42).Take(3).ToList();
dateArr.Reverse();
dateArr2.Reverse();
version.SoftwareReleaseDate = $"{DateTime.Now.Year.ToString().Substring(0, 2)}{string.Join("-", dateArr)}";//终端软件发布日期：日月年
version.HardwareReleaseDate = $"{DateTime.Now.Year.ToString().Substring(0, 2)}{string.Join("-", dateArr2)}";//终端硬件发布日期：日月年
return version;
}
}
}

51
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_09H/AFN9_F9_Analysis.cs Normal file
View File

@ -0,0 +1,51 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.AFN_00H;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_09H
{
/// <summary>
/// 5.9.2.4.9 F9：远程通信模块版本信息(只读解析SIM卡号)
/// </summary>
public class AFN9_F9_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<string>>
{
private readonly ILogger<AFN9_F9_Analysis> _logger;
public AFN9_F9_Analysis(ILogger<AFN9_F9_Analysis> logger)
{
_logger = logger;
}
public Task<UnitDataAnalysis<string>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
UnitDataAnalysis<string> dto = new UnitDataAnalysis<string>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = Encoding.ASCII.GetString(string.Join("", input.UnitData.HexMessageList.Skip(30).Take(20).ToList()).HexToByte()).Replace("\0", "") //SIM卡
};
return Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"00_1解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
}
}

165
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0AH/AFN10_F10_Analysis.cs Normal file
View File

@ -0,0 +1,165 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.AFN_09H;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0AH
{
/// <summary>
/// 5.10.1.3.1 F10：终端电能表/交流采样装置配置参数
/// </summary>
internal class AFN10_F10_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN10_F10_AnalysisDto>>
{
private readonly ILogger<AFN10_F10_Analysis> _logger;
public AFN10_F10_Analysis(ILogger<AFN10_F10_Analysis> logger)
{
_logger = logger;
}
public Task<UnitDataAnalysis<AFN10_F10_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
Tuple<int, List<AFN10F10Entity>> tuple = AFN10F10EntityAnalysis(input.UnitData.HexMessageList);
UnitDataAnalysis<AFN10_F10_AnalysisDto> dto = new UnitDataAnalysis<AFN10_F10_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data=new AFN10_F10_AnalysisDto()
{
AFN10F10Entitys = tuple.Item2,
ConfigNum = tuple.Item1
}
};
return Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0A_10解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
public Tuple<int, List<AFN10F10Entity>> AFN10F10EntityAnalysis(List<string> hexMessageList)
{
List<Dictionary<string, string>> meterList = new List<Dictionary<string, string>>();
int total = $"{hexMessageList[5]}{hexMessageList[4]}".HexToDec();
List<AFN10F10Entity> aFN10F10Entitys = new List<AFN10F10Entity>();
for (int i = 0; i < total; i++)
{
List<string> sArray = hexMessageList.GetRange(6 + 27 * i, 27);
AFN10F10Entity aFN10F10Entity = new AFN10F10Entity()
{
SerialNum = $"{sArray[1]}{sArray[0]}".HexToDec(),
Point = $"{sArray[3]}{sArray[2]}".HexToDec(),
RuleType= GetProtocol(sArray[5]),
ComAddress= $"{sArray[11]}{sArray[10]}{sArray[9]}{sArray[8]}{sArray[7]}{sArray[6]}",
ComPwd= $"{sArray[17]}{sArray[16]}{sArray[15]}{sArray[14]}{sArray[13]}{sArray[12]}".Substring(6, 6),
ElectricityRatesNum= sArray[18].HexToBin().Substring(2, 6).BinToDec(),
CollectorAddress = $"{sArray[25]}{sArray[24]}{sArray[23]}{sArray[22]}{sArray[21]}{sArray[20]}",
};
string baudPort = sArray[4].HexToBin().PadLeft(8, '0'); //波特率和端口号放在一个字节内
aFN10F10Entity.BaudRate = GetBaudrate(baudPort.Substring(0, 3));
aFN10F10Entity.Port = baudPort.Substring(3, 5).BinToDec();
string dataDigit = sArray[19].HexToBin().PadLeft(8, '0'); //有功电能示值整数位及小数位个数
aFN10F10Entity.IntegerBitsNum = dataDigit.Substring(4, 2).BinToDec() + 4;
aFN10F10Entity.DecimalPlacesNum = dataDigit.Substring(6, 2).BinToDec() + 1;
string classNo = sArray[26].HexToBin().PadLeft(8, '0');//用户大类号及用户小类号
aFN10F10Entity.UserCategoryNum = classNo.Substring(0, 4).BinToDec() + 1;
aFN10F10Entity.UserCategoryNum = classNo.Substring(4, 4).BinToDec() + 1;
aFN10F10Entitys.Add(aFN10F10Entity);
}
return Tuple.Create(total, aFN10F10Entitys);
}
/// <summary>
/// 获取波特率
/// </summary>
/// <param name="binBaud"></param>
/// <returns></returns>
private int GetBaudrate(string binBaud)
{
int baudRate = 0;
switch (binBaud)
{
case "001":
baudRate = 600;
break;
case "010":
baudRate = 1200;
break;
case "011":
baudRate = 2400;
break;
case "100":
baudRate = 4800;
break;
case "101":
baudRate = 7200;
break;
case "110":
baudRate = 9600;
break;
case "111":
baudRate = 19200;
break;
default:
baudRate = 0;
break;
}
return baudRate;
}
/// <summary>
/// 获取通信协议文本说明
/// </summary>
/// <param name="protocol"></param>
/// <returns></returns>
private string GetProtocol(string protocol)
{
int dataUnit = protocol.HexToDec();
if (dataUnit == 1)
{
return "DL/T 645—1997";
}
if (dataUnit == 2)
{
return "交流采样装置通信协议";
}
if (dataUnit == 30)
{
return "DL/T 645—2007";
}
if (dataUnit == 31)
{
return "串行接口连接窄带低压载波通信模块";
}
if (dataUnit == 32)
{
return "CJ/T 188—2018协议";
}
return "其他协议";
}
}
}

84
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0AH/AFN10_F66_Analysis.cs Normal file
View File

@ -0,0 +1,84 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Abstracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0AH
{
/// <summary>
/// 5.5.1.3.53 F66：定时上报 2 类数据任务设置
/// </summary>
public class AFN10_F66_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN10_F66_AnalysisDto>>
{
private readonly ILogger<AFN10_F66_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN10_F66_Analysis(ILogger<AFN10_F66_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext= analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN10_F66_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
var data = await GenerateFinalResult(input.UnitData.HexMessageList);
data.Pn = input.DA.Pn;
UnitDataAnalysis<AFN10_F66_AnalysisDto> dto = new UnitDataAnalysis<AFN10_F66_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data= data
};
return await Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0A_66解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
public async Task<AFN10_F66_AnalysisDto> GenerateFinalResult(List<string> hexMessageList)
{
AFN10_F66_AnalysisDto entity = new AFN10_F66_AnalysisDto();
var cycleBin = hexMessageList[4].HexToBin().PadLeft(8, '0');
var cycleUnitBin = cycleBin.Substring(0, 2);
var cycleValueBin = cycleBin.Substring(2, 6);
entity.Cycle = cycleValueBin.BinToDec();//定时发送周期
entity.Unit = cycleUnitBin.BinToDec();//定时发送周期(单位)
//TODO:发送基准时间
var arrBaseTime = hexMessageList.GetRange(5, 6);
var baseTimeArrStr = await _analysisStrategyContext.ExecuteAsync<List<string>, string>("Appendix_A1", arrBaseTime);
var baseTimeArr= baseTimeArrStr.Split('_');
//entity.BaseTime = DateTime.Parse($"{DateTime.Now.Year.ToString().Substring(0, 2)}{arrBaseTime[0]}-{arrBaseTime[1]}-{arrBaseTime[2]} {arrBaseTime[3]}:{arrBaseTime[4]}:{arrBaseTime[5]}");
entity.BaseTime = Convert.ToDateTime(baseTimeArr[0]);
entity.CurveRatio = hexMessageList[11].HexToDec();
var count = hexMessageList[12].HexToDec();
var dataArr = hexMessageList.GetRange(13, 4 * count);
for (int i = 0; i < count; i++)
{
var pnfnArr = dataArr.GetRange(0, 4);
var tempPn = ProtocolPlugin.CalculatePn(pnfnArr[0], pnfnArr[1]);
var tempFn = ProtocolPlugin.CalculateFn(pnfnArr[2], pnfnArr[3]);
entity.Details.Add(new SetAutoItemCodeDetails() { Fn = tempFn, Pn = tempPn });
dataArr.RemoveRange(0, 4);
}
return entity;
}
}
}

49
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0AH/AFN10_F68_Analysis.cs Normal file
View File

@ -0,0 +1,49 @@
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0AH
{
/// <summary>
/// 5.5.1.3.55 F68：定时上报 2 类数据任务启动/停止设置
/// </summary>
public class AFN10_F68_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<bool>>
{
private readonly ILogger<AFN10_F68_Analysis> _logger;
public AFN10_F68_Analysis(ILogger<AFN10_F68_Analysis> logger)
{
_logger = logger;
}
public Task<UnitDataAnalysis<bool>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
UnitDataAnalysis<bool> dto = new UnitDataAnalysis<bool>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = input.UnitData.HexMessageList[4].Equals("55")
};
return Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0A_68解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
}
}

103
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F129_Analysis.cs Normal file
View File

@ -0,0 +1,103 @@
using JiShe.CollectBus.Common.Enums;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.85 F129：当前正向有功电能示值（总、费率1～M）
/// </summary>
public class AFN12_F129_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F129_AnalysisDto>>>
{
private readonly ILogger<AFN12_F129_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F129_Analysis(ILogger<AFN12_F129_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<List<AFN12_F129_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
List<AFN12_F129_AnalysisDto> list = GenerateFinalResult(2, datas, "正向有功电能示值", input.AFN_FC.AFN, input.DT.Fn);
UnitDataAnalysis<List<AFN12_F129_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F129_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_129解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
#region 单元数据值解析
/// <summary>
/// 单元数据值解析
/// </summary>
/// <returns></returns>
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int rationgCount = hexMessageList.GetRatingCount(9, 1);
values.Add(rationgCount.ToString());
for (int i = 0; i < rationgCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + (i * 5), 5);
var errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A14), arr); //从第10个开始，每加5个字节为下一个值的开始
values.Add(value.ToString());
}
}
return values;
}
#endregion
public List<AFN12_F129_AnalysisDto> GenerateFinalResult(int index, List<string> data, string remark = "", int afn = 0, int fn = 0)
{
List<AFN12_F129_AnalysisDto> list = new List<AFN12_F129_AnalysisDto>();
for (int i = index; i < data.Count; i++)
{
AFN12_F129_AnalysisDto meter = new AFN12_F129_AnalysisDto();
decimal value = 0;
var errorCode = data[i].CheckErrorCode();
if (errorCode != null)
meter.ValidData = false;
else
decimal.TryParse(data[i], out value);
meter.DataValue = value;
meter.DataType = $"{afn.ToString().PadLeft(2, '0')}_{fn}_{i - index}";
meter.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
list.Add(meter);
}
return list;
}
}
}

94
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F130_Analysis.cs Normal file
View File

@ -0,0 +1,94 @@
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.86 F130：当前正向无功（组合无功 1）电能示值（总、费率 1～M）
/// </summary>
public class AFN12_F130_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F130_AnalysisDto>>>
{
private readonly ILogger<AFN12_F130_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F130_Analysis(ILogger<AFN12_F130_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<List<AFN12_F130_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
List<AFN12_F130_AnalysisDto> list = GenerateFinalResult(2, datas, "正向无功电能示值", input.AFN_FC.AFN, input.DT.Fn);
UnitDataAnalysis<List<AFN12_F130_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F130_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_130解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int ratingCount = hexMessageList.GetRatingCount(9, 1);
values.Add(ratingCount.ToString());
for (int i = 0; i < ratingCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + (i * 4), 4);
var errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A11), arr); //从第10个开始，每加5个字节为下一个值的开始
values.Add(value.ToString());
}
}
return values;
}
public List<AFN12_F130_AnalysisDto> GenerateFinalResult(int index, List<string> data, string remark = "", int afn = 0, int fn = 0)
{
List<AFN12_F130_AnalysisDto> list = new List<AFN12_F130_AnalysisDto>();
for (int i = index; i < data.Count; i++)
{
AFN12_F130_AnalysisDto meter = new AFN12_F130_AnalysisDto();
decimal value = 0;
var errorCode = data[i].CheckErrorCode();
if (errorCode != null)
meter.ValidData = false;
else
decimal.TryParse(data[i], out value);
meter.DataValue = value;
meter.DataType = $"{afn.ToString().PadLeft(2, '0')}_{fn}_{i - index}";
meter.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
list.Add(meter);
}
return list;
}
}
}

94
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F131_Analysis.cs Normal file
View File

@ -0,0 +1,94 @@
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.87 F131：当前反向有功电能示值（总、费率 1～M）
/// </summary>
public class AFN12_F131_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F131_AnalysisDto>>>
{
private readonly ILogger<AFN12_F131_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F131_Analysis(ILogger<AFN12_F131_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<List<AFN12_F131_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
List<AFN12_F131_AnalysisDto> list = GenerateFinalResult(2, datas, "反向有功总电能示值", input.AFN_FC.AFN, input.DT.Fn);
UnitDataAnalysis<List<AFN12_F131_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F131_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_131解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int ratingCount = hexMessageList.GetRatingCount(9, 1);
values.Add(ratingCount.ToString());
for (int i = 0; i < ratingCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + (i * 5), 5);
var errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A14), arr); //从第10个开始，每加5个字节为下一个值的开始
values.Add(value.ToString());
}
}
return values;
}
public List<AFN12_F131_AnalysisDto> GenerateFinalResult(int index, List<string> data, string remark = "", int afn = 0, int fn = 0)
{
List<AFN12_F131_AnalysisDto> list = new List<AFN12_F131_AnalysisDto>();
for (int i = index; i < data.Count; i++)
{
AFN12_F131_AnalysisDto meter = new AFN12_F131_AnalysisDto();
decimal value = 0;
var errorCode = data[i].CheckErrorCode();
if (errorCode != null)
meter.ValidData = false;
else
decimal.TryParse(data[i], out value);
meter.DataValue = value;
meter.DataType = $"{afn.ToString().PadLeft(2, '0')}_{fn}_{i - index}";
meter.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
list.Add(meter);
}
return list;
}
}
}

95
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F132_Analysis.cs Normal file
View File

@ -0,0 +1,95 @@
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.88 F132：当前反向无功（组合无功 2）电能示值（总、费率 1～M）
/// </summary>
public class AFN12_F132_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F132_AnalysisDto>>>
{
private readonly ILogger<AFN12_F132_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F132_Analysis(ILogger<AFN12_F132_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<List<AFN12_F132_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
List<AFN12_F132_AnalysisDto> list = GenerateFinalResult(2, datas, "反向无功电能示值", (int)input.AFN_FC.AFN!, (int)input.DT.Fn!);
UnitDataAnalysis<List<AFN12_F132_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F132_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn ,
Pn = input.DA.Pn,
Data = list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_132解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int ratingCount = hexMessageList.GetRatingCount(9, 1);
values.Add(ratingCount.ToString());
for (int i = 0; i < ratingCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + (i * 4), 4);
var errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A11), arr); //从第10个开始，每加4个字节为下一个值的开始
values.Add(value.ToString());
}
}
return values;
}
public List<AFN12_F132_AnalysisDto> GenerateFinalResult(int index, List<string> data, string remark = "",int afn=0,int fn=0)
{
List<AFN12_F132_AnalysisDto> list = new List<AFN12_F132_AnalysisDto>();
for (int i = index; i < data.Count; i++)
{
AFN12_F132_AnalysisDto meter = new AFN12_F132_AnalysisDto();
decimal value = 0;
var errorCode = data[i].CheckErrorCode();
if (errorCode != null)
meter.ValidData = false;
else
decimal.TryParse(data[i], out value);
meter.DataValue = value;
meter.DataType = $"{afn.ToString().PadLeft(2, '0')}_{fn}_{i - index}";
meter.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
list.Add(meter);
}
return list;
}
}
}

108
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F145_Analysis.cs Normal file
View File

@ -0,0 +1,108 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.101 F145：当月正向有功最大需量及发生时间（总、费率 1～M）
/// </summary>
public class AFN12_F145_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN12_F145_AnalysisDto>>
{
private readonly ILogger<AFN12_F145_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F145_Analysis(ILogger<AFN12_F145_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN12_F145_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
AFN12_F145_AnalysisDto data = GenerateFinalResult(2, datas, "当月正向有功最大需量及发生时间");
data.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}";
UnitDataAnalysis<AFN12_F145_AnalysisDto> unitDataAnalysis = new UnitDataAnalysis<AFN12_F145_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = data
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_145解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int ratingCount = hexMessageList.GetRatingCount(9, 1);
values.Add(ratingCount.ToString());
for (int i = 0; i < ratingCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + i * 7, 3);
var errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A23), arr);
values.Add(value.ToString());//正向有功总最大需量
}
arr = hexMessageList.GetRange(10 + i * 7 + 3, 4);
errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, string>(nameof(Appendix_A17), arr);
values.Add(value.ToString());//正向有功总最大需量发生时间
}
}
return values;
}
public AFN12_F145_AnalysisDto GenerateFinalResult(int index, List<string> data, string remark = "")
{
AFN12_F145_AnalysisDto dto = new AFN12_F145_AnalysisDto();
decimal value = 0;
var errorCode = data[2].CheckErrorCode();
if (errorCode != null)
dto.ValidData = false;
else
decimal.TryParse(data[2], out value);
dto.DataValue = value;
dto.TimeSpan = $"{DateTime.Now.Year}-{data[3].Substring(0, 2)}-{data[3].Substring(2, 2)} {data[3].Substring(4, 2)}:{data[3].Substring(6, 2)}:00";//$"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)}";
if (DateTime.TryParse(dto.TimeSpan, out DateTime readingDate))
{
dto.ReadingDate = readingDate;
}
return dto;
}
}
}

120
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F149_Analysis.cs Normal file
View File

@ -0,0 +1,120 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using Volo.Abp.Domain.Entities;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.105 F149：上月（上一结算日）正向有功最大需量及发生时间（总、费率 1～M）
/// </summary>
public class AFN12_F149_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN12_F149_AnalysisDto>>
{
private readonly ILogger<AFN12_F149_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F149_Analysis(ILogger<AFN12_F149_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN12_F149_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> datas = await AnalysisDataUnit(input.UnitData.HexMessageList);
AFN12_F149_AnalysisDto data = GenerateFinalResult(2, datas, "上月（上一结算日）正向有功最大需量及发生时间");
data.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}";
UnitDataAnalysis<AFN12_F149_AnalysisDto> unitDataAnalysis = new UnitDataAnalysis<AFN12_F149_AnalysisDto>
{
Code = input.A?.Code,
AFN = input.AFN_FC?.AFN ?? 0,
Fn = input.DT?.Fn ?? 0,
Pn = input.DA?.Pn ?? 0,
Data = data
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_149解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnit(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
int ratingCount = hexMessageList.GetRatingCount(9, 1);
values.Add(ratingCount.ToString());
for (int i = 0; i < ratingCount + 1; i++)
{
var arr = hexMessageList.GetRange(10 + i * 7, 3);
var errorCode = arr.CheckErrorCode();
if (errorCode!=null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(nameof(Appendix_A23), arr);
values.Add(value.ToString());//正向有功总最大需量
}
arr = hexMessageList.GetRange(13 + i * 7, 4);
errorCode = arr.CheckErrorCode();
if (errorCode != null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, string>(nameof(Appendix_A17), arr);//正向有功总最大需量发生时间
values.Add(value);//正向有功总最大需量
}
}
return values;
}
public AFN12_F149_AnalysisDto GenerateFinalResult(int index, List<string> data, string remark = "")
{
AFN12_F149_AnalysisDto dto = new AFN12_F149_AnalysisDto();
var errorCodeInfo = data[2].CheckErrorCode();
if (errorCodeInfo != null)
dto.ValidData = false;
decimal.TryParse(data[2], out decimal value);
dto.DataValue = value;
//TODO:最大需量发生时间
errorCodeInfo = data[3].CheckErrorCode();
if (data[3].Length != 8 && errorCodeInfo != null)
dto.ValidData = false;
else
dto.TimeSpan = $"{DateTime.Now.Year}-{data[3].Substring(0, 2)}-{data[3].Substring(2, 2)} {data[3].Substring(4, 2)}:{data[3].Substring(6, 2)}:00";
//TODO:时间标
if (!DateTime.TryParse(dto.TimeSpan, out DateTime readingDate))
dto.ValidData = false;
dto.ReadingDate = readingDate;
if (DateTime.Now.Month.Equals(1))//如果为1月份，则日期减去1年
{
dto.ReadingDate = dto.ReadingDate.AddYears(-1);
dto.TimeSpan = dto.ReadingDate.ToString("yyyy-MM-dd HH:mm:ss");
}
return dto;
}
}
}

73
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F188_Analysis.cs Normal file
View File

@ -0,0 +1,73 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 水表抄读取
/// </summary>
public class AFN12_F188_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN12_F149_AnalysisDto>>
{
private readonly ILogger<AFN12_F188_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F188_Analysis(ILogger<AFN12_F188_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN12_F149_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
ArgumentNullException.ThrowIfNull(input.AFN_FC.AFN);
ArgumentNullException.ThrowIfNull(input.DT.Fn);
var data = GenerateFinalResult(input.UnitData.HexMessageList);
data.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}";
UnitDataAnalysis<AFN12_F149_AnalysisDto> dto = new UnitDataAnalysis<AFN12_F149_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = data
};
return await Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_188解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
public AFN12_F149_AnalysisDto GenerateFinalResult(List<string> hexMessageList)
{
AFN12_F149_AnalysisDto dto = new AFN12_F149_AnalysisDto();
decimal value = 0;
var arr = hexMessageList.GetRange(11, 4);
var errorCodeInfo = arr.CheckErrorCode();
if (errorCodeInfo != null)
{
dto.ValidData = false;
dto.ErrorCodeMsg = errorCodeInfo.Item2;
}
else
decimal.TryParse($"{arr[11]}{arr[12]}{arr[13]}.{arr[14]}", out value);
dto.DataValue = value;
//dto.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
return dto;
}
}
}

120
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F25_Analysis.cs Normal file
View File

@ -0,0 +1,120 @@
using JiShe.CollectBus.Common.Enums;
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Volo.Abp.Domain.Entities;
using YamlDotNet.Core.Tokens;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.22 F25：当前三相及总有/无功功率、功率因数，三相电压、电流、零序电流、视在功率
/// </summary>
public class AFN12_F25_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F25_AnalysisDto>>>
{
private readonly ILogger<AFN12_F25_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F25_Analysis(ILogger<AFN12_F25_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public List<string> DataType { get; set; } = new List<string>() { "YGGL", "YGGL_A", "YGGL_B", "YGGL_C", "WGGL", "WGGL_A", "WGGL_B", "WGGL_C", "GLYS", "GLYS_A", "GLYS_B", "GLYS_C", "DY_A", "DY_B", "DY_C", "DL_A", "DL_B", "DL_C", "LXDL", "SZGL", "SZGL_A", "SZGL_B", "SZGL_C" };
public async Task<UnitDataAnalysis<List<AFN12_F25_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
List<string> remarks = new List<string>() { "当前总有功功率", "当前A相有功功率", "当前B相有功功率", "当前C相有功功率", "当前总无功功率", "当前A相无功功率", "当前B相无功功率", "当前C相无功功率", "当前总功率因数", "当前A相功率因数", "当前B相功率因数", "当前C相功率因数", "当前A相电压", "当前B相电压", "当前C相电压", "当前A相电流", "当前C相电流", "当前 C相电流", "当前零序电流", "当前总视在功率", "当前A相视在功率", "当前B相视在功率", "当前C相视在功率" };
List<AFN12_F25_AnalysisDto> list = new List<AFN12_F25_AnalysisDto>();
List<string> data = await AnalysisDataUnitAsync(input.UnitData.HexMessageList);
for (int i = 1; i < data.Count; i++)
{
AFN12_F25_AnalysisDto dto = new AFN12_F25_AnalysisDto();
decimal value = 0;
var errorCodeInfo = data[i].CheckErrorCode();
if (errorCodeInfo != null)
{
dto.ValidData = false;
dto.ErrorCodeMsg = errorCodeInfo.Item2;
}
else
decimal.TryParse(data[i], out value);
dto.DataValue = value;
dto.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}_{DataType[i-1]}";
dto.FiledName = DataType[i - 1];
dto.ReadTime = Convert.ToDateTime($"{data[0].Substring(0, 4)}-{data[0].Substring(4, 2)}-{data[0].Substring(6, 2)} {data[0].Substring(8, 2)}:{data[0].Substring(10, 2)}:00");
dto.FiledDesc = remarks[i - 1];
list.Add(dto);
}
UnitDataAnalysis<List<AFN12_F25_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F25_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_25解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
values.Add(hexMessageList.GetReadTime(4, 5));
values.AddRange(await CutOutAsync(9, 8, 3, nameof(Appendix_A9), hexMessageList));//解析 总/ABC相有功/无功功率
values.AddRange(await CutOutAsync(33, 4, 2, nameof(Appendix_A5), hexMessageList));//解析 总/ABC相功率因数
values.AddRange(await CutOutAsync(41, 3, 2, nameof(Appendix_A7), hexMessageList));//ABC相电压
values.AddRange(await CutOutAsync(47, 4, 3, nameof(Appendix_A25), hexMessageList));//ABC相/零序电流
values.AddRange(await CutOutAsync(59, 4, 3, nameof(Appendix_A9), hexMessageList));//总视\ABC相视在功率
return values;
}
/// <summary>
/// 截取值
/// </summary>
/// <param name="Index">开始位置</param>
/// <param name="count">总项数</param>
/// <param name="byteCount">每项字节数</param>
/// <param name="appendixName">解析方式</param>
/// <param name="hexMessageList">解析数据</param>
private async Task<List<string>> CutOutAsync(int Index, int count, int byteCount, string appendixName, List<string> hexMessageList)
{
List<string> values = new List<string>();
var temp = hexMessageList.GetRange(Index, count * byteCount);//截取位置(9),解析项*截取字节数(8*3)
for (int i = 0; i < count; i++)
{
var arr = temp.GetRange(i * byteCount, byteCount);
var errorCode = arr.CheckErrorCode();
if (errorCode!=null)
values.Add(errorCode.Item1);
else
{
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(appendixName, arr);
values.Add(value.ToString());
}
}
return values;
}
}
}

72
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F2_Analysis.cs Normal file
View File

@ -0,0 +1,72 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.1 F2：终端日历时钟
/// </summary>
public class AFN12_F2_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN12_F2_AnalysisDto>>
{
private readonly ILogger<AFN12_F2_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F2_Analysis(ILogger<AFN12_F2_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN12_F2_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData?.HexMessageList);
var data= await GenerateFinalResultAsync(input.UnitData.HexMessageList);
data.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}";
UnitDataAnalysis<AFN12_F2_AnalysisDto> dto = new UnitDataAnalysis<AFN12_F2_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = data
};
return await Task.FromResult(dto);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_2解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
public async Task<AFN12_F2_AnalysisDto> GenerateFinalResultAsync(List<string> hexMessageList)
{
AFN12_F2_AnalysisDto dto = new AFN12_F2_AnalysisDto();
var arr = hexMessageList.GetRange(4, 6);
var errorCodeInfo = arr.CheckErrorCode();
if (errorCodeInfo != null)
{
dto.ValidData = false;
dto.ErrorCodeMsg = errorCodeInfo.Item2;
}
else
dto.DataValue = await _analysisStrategyContext.ExecuteAsync<List<string>, string>(nameof(Appendix_A1), arr);
dto.FiledName = "TerminalTime";
dto.FiledDesc = "召读终端时间";
return await Task.FromResult(dto);
}
}
}

124
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F33_Analysis.cs Normal file
View File

@ -0,0 +1,124 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.30 F33：当前正向有/无功电能示值、一/四象限无功电能示值（总、费率 1～M，1≤M≤12）
/// </summary>
public class AFN12_F33_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<AFN12_F33_AnalysisDto>>
{
private List<string> DataUnitHexList { get; set; }=new List<string>();
private readonly ILogger<AFN12_F33_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F33_Analysis(ILogger<AFN12_F33_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<UnitDataAnalysis<AFN12_F33_AnalysisDto>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
ArgumentNullException.ThrowIfNull(input.UnitData.HexMessageList);
int rationgCount = input.UnitData.HexMessageList!.GetRatingCount(23, 1);
DataUnitHexList = input.UnitData.HexMessageList.GetRange(24, (5 * (rationgCount + 1)) + (4 * (rationgCount + 1)) * 3);
GetDataUnitHexString(input.UnitData.HexMessageList, rationgCount);
UnitDataAnalysis<AFN12_F33_AnalysisDto> unitDataAnalysis = new UnitDataAnalysis<AFN12_F33_AnalysisDto>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data = await AnalysisDataUnit(input.UnitData.HexMessageList, rationgCount)
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_33解析失败:{input.A?.Code}-{input.DT?.Fn ?? 0}-{input?.BaseHexMessage?.HexMessageString},{ex.Message}");
return null;
}
}
#region 获取当前正向有/无功电能示值数据单元格式 private void GetDataUnitHexString(int rationgCount)
private void GetDataUnitHexString(List<string> hexMessageList, int rationgCount)
{
//(5*(x+1))+(4*(x+1))*3
var lenght = (5 * (rationgCount + 1)) + (4 * (rationgCount + 1)) * 3;//(rationgCount * 5 + 5) + (4 * 3) + (rationgCount * 4) * 2;//费率数(R)：4 公式：5+5+（费率数*5）+ （4+（费率数*4））*2
DataUnitHexList = hexMessageList.GetRange(24, lenght);
}
#endregion
#region 单元数据值解析 private F33Entity AnalysisDataUnit()
private async Task<AFN12_F33_AnalysisDto> AnalysisDataUnit(List<string> hexMessageList, int rationgCount)
{
AFN12_F33_AnalysisDto f33Entity = new AFN12_F33_AnalysisDto();
f33Entity.ReadTime = hexMessageList.GetReadTime(18, 5); // 终端抄表时间
f33Entity.RatingCount = hexMessageList.GetRatingCount(23, 1); // 费率数 M（1≤M≤12）
f33Entity.F_A_Kwh = await GetDataAsync(f33Entity.RatingCount, 0, 5, nameof(Appendix_A14));//当前正向有功总电能示值
f33Entity.R_R_Kvarh = await GetDataAsync(f33Entity.RatingCount, 25, 4, nameof(Appendix_A11));//当前正向无功（组合无功1）总电能示值 0+5*5
f33Entity.Q1_R_Kvarh = await GetDataAsync(f33Entity.RatingCount, 45, 4, nameof(Appendix_A11));//当前一象限无功总电能示值 25+4*5
f33Entity.Q4_R_Kvarh = await GetDataAsync(f33Entity.RatingCount, 65, 4, nameof(Appendix_A11));//当前四象限无功总电能示值 45+4*5
return f33Entity;
}
#region 有功/无功、费率总电能示值
/// <summary>
/// 有功/无功、费率总电能示值
/// </summary>
/// <param name="ratingCount">费率数</param>
/// <param name="startIndex">开始位置</param>
/// <param name="len">长度</param>
/// <returns></returns>
private async Task<ParentNodes> GetDataAsync(int ratingCount, int startIndex, int len, string appendxName)
{
ParentNodes parent = new ParentNodes();
var value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(appendxName, DataUnitHexList.GetRange(startIndex, len));
parent.Total_Value = value;
parent.childNodes = await GetChildDataAsync(ratingCount, startIndex, len, appendxName);
return parent;
}
/// <summary>
/// 费率总电能示值
/// </summary>
/// <param name="RatingCount"></param>
/// <param name="startIndex"></param>
/// <param name="len"></param>
/// <param name="appendix"></param>
/// <returns></returns>
private async Task<List<ChildNodes>> GetChildDataAsync(int RatingCount, int startIndex, int len, string appendxName)
{
List<ChildNodes> children = new List<ChildNodes>();
for (int i = 0; i < RatingCount; i++)
{
ChildNodes model = new ChildNodes()
{
Value = await _analysisStrategyContext.ExecuteAsync<List<string>, decimal>(appendxName, DataUnitHexList.GetRange((i * len) + (startIndex + len), len)) //29,4 33,4 37,4 41,4
};
children.Add(model);
}
return children;
}
#endregion
#endregion
}
}

95
protocols/JiShe.CollectBus.Protocol/AnalysisData/AFN_0CH/AFN12_F49_Analysis.cs Normal file
View File

@ -0,0 +1,95 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.AnalysisData.Appendix;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.AFN_0CH
{
/// <summary>
/// 5.12.2.4.46 F49：当前电压、电流相位角
/// </summary>
public class AFN12_F49_Analysis : IAnalysisStrategy<TB3761, UnitDataAnalysis<List<AFN12_F49_AnalysisDto>>>
{
private readonly ILogger<AFN12_F49_Analysis> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public AFN12_F49_Analysis(ILogger<AFN12_F49_Analysis> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public List<string> DataType { get; set; } = new List<string>() { "Uab_Ua", "Ub", "Ucb_Uc", "Ia", "Ib", "Ic" };
public async Task<UnitDataAnalysis<List<AFN12_F49_AnalysisDto>>> ExecuteAsync(TB3761 input)
{
try
{
ArgumentNullException.ThrowIfNull(input);
List<string> data = await AnalysisDataUnitAsync(input.UnitData?.HexMessageList!);
List<string> remarks = new List<string>() { "Uab/Ua 相位角", "Ub 相位角", "Ucb/Uc 相位角", "Ia 相位角", "Ib 相位角", "Ic 相位角" };
List<AFN12_F49_AnalysisDto> list = new List<AFN12_F49_AnalysisDto>();
for (int i = 0; i < data.Count; i++)
{
AFN12_F49_AnalysisDto dto = new AFN12_F49_AnalysisDto();
decimal value = 0;
var errorCodeInfo = data[i].CheckErrorCode();
if (errorCodeInfo != null)
{
dto.ValidData = false;
dto.ErrorCodeMsg = errorCodeInfo.Item2;
}
else
decimal.TryParse(data[i], out value);
dto.DataValue = value;
dto.DataType = $"{input.AFN_FC.AFN.HexToDecStr().PadLeft(2, '0')}_{input.DT.Fn}_{DataType[i]}";
dto.FiledName = DataType[i];
dto.FiledDesc= remarks[i];
list.Add(dto);
}
UnitDataAnalysis<List<AFN12_F49_AnalysisDto>> unitDataAnalysis = new UnitDataAnalysis<List<AFN12_F49_AnalysisDto>>
{
Code = input.A.Code,
AFN = input.AFN_FC.AFN,
Fn = input.DT.Fn,
Pn = input.DA.Pn,
Data= list
};
return await Task.FromResult(unitDataAnalysis);
}
catch (Exception ex)
{
_logger.LogError(ex, $"0C_49解析失败:{input.A.Code}-{input.DT.Fn}-{input.BaseHexMessage.HexMessageString},{ex.Message}");
return null;
}
}
private async Task<List<string>> AnalysisDataUnitAsync(List<string> hexMessageList)
{
List<string> values = new List<string>();
for (int i = 0; i < 6; i++)
{
var arr = hexMessageList.GetRange(4 + (i * 2), 2);
var errorCode = arr.CheckErrorCode();
if (errorCode!=null)
values.Add(errorCode.Item1);
else
{
var value= await _analysisStrategyContext.ExecuteAsync<List<string>,decimal>(nameof(Appendix_A5), arr);
values.Add(value.ToString());
}
}
return values;
}
}
}

40
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_02800002.cs Normal file
View File

@ -0,0 +1,40 @@
using JiShe.CollectBus.Protocol.AnalysisData.AFN_09H;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Contracts.Protocol.Dto;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 2 日时段表数据
/// </summary>
public class Appendix_02800002 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_02800002> _logger;
public Appendix_02800002(ILogger<Appendix_02800002> logger)
{
_logger = logger;
}
public Task<List<string>> ExecuteAsync(List<string> data)
{
try
{
if (data.Count != 2)
return null;
var value = string.Join(".", data);
var values= new List<string>() { "电网频率", "10_97", "1", value };
return Task.FromResult(values);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Appendix_02800002解析失败:{ex.Message}");
return null;
}
}
}
}

33
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04000201.cs Normal file
View File

@ -0,0 +1,33 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 年时区数 p≤14
/// </summary>
public class Appendix_04000201 : IAnalysisStrategy<List<string>, List<string>>
{
private int valueByteCount = 1;
private readonly ILogger<Appendix_04000201> _logger;
public Appendix_04000201(ILogger<Appendix_04000201> logger)
{
_logger = logger;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
List<string> values = new List<string>();
values.Insert(0, "10_94");
values.Insert(0, "年时区数");
values.Add((data.Count / valueByteCount).ToString());//值总数
foreach (var item in data)
{
values.Add(item.HexToDec().ToString());
}
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04000202.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 日时段表数 q≤8
/// </summary>
public class Appendix_04000202 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04000202> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04000202(ILogger<Appendix_04000202> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04000201", data);
values[0] = "日时段表数";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04000203.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 日时段数(每日切换数) m≤14
/// </summary>
public class Appendix_04000203 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04000203> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04000203(ILogger<Appendix_04000203> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04000201", data);
values[0] = "日时段数(每日切换数)";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04000204.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 费率数 k≤63
/// </summary>
public class Appendix_04000204 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04000204> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04000204(ILogger<Appendix_04000204> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04000201", data);
values[0] = "费率数";
return await Task.FromResult(values);
}
}
}

38
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010000.cs Normal file
View File

@ -0,0 +1,38 @@
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套时区表数据
/// </summary>
public class Appendix_04010000 : IAnalysisStrategy<List<string>, List<string>>
{
/// <summary>
/// 每个值字节数
/// </summary>
private const int valueByteCount = 3;
private readonly ILogger<Appendix_04010000> _logger;
public Appendix_04010000(ILogger<Appendix_04010000> logger)
{
_logger = logger;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
List<string> values = new List<string>();
int valueCount = data.Count / valueByteCount;
values.Insert(0, "10_94");
values.Insert(0, "第一套第{0}时区起始日期及日时段表号");
values.Add(valueCount.ToString());//值总数 11 11 11 22 22 22 33 33 33
for (int i = 0; i < valueCount; i++)
{
var value = data.GetRange(i * 3, valueByteCount);//MMDDNN
values.Add($"{value[0]}:{value[1]}");//MM:DD 或hhmm
values.Add(value[2]);//NN 费率号
}
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010001.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 1 日时段表数据：
/// </summary>
public class Appendix_04010001 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010001> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010001(ILogger<Appendix_04010001> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第1日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010002.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 2 日时段表数据
/// </summary>
public class Appendix_04010002 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010002> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010002(ILogger<Appendix_04010002> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第2日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010003.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 3 日时段表数据
/// </summary>
public class Appendix_04010003 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010003> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010003(ILogger<Appendix_04010003> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第3日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

30
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010004.cs Normal file
View File

@ -0,0 +1,30 @@
using JiShe.CollectBus.Protocol.AnalysisData.AFN_09H;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using JiShe.CollectBus.Protocol.Contracts.Models;
using JiShe.CollectBus.Protocol.Dto;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 4 日时段表数据
/// </summary>
public class Appendix_04010004 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010004> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010004(ILogger<Appendix_04010004> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>> ("Appendix_04010000", data);
values[0] = "第一套第4日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010005.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 5 日时段表数据
/// </summary>
public class Appendix_04010005 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010005> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010005(ILogger<Appendix_04010005> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第5日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010006.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 6 日时段表数据
/// </summary>
public class Appendix_04010006 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010006> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010006(ILogger<Appendix_04010006> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第6日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

27
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010007.cs Normal file
View File

@ -0,0 +1,27 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 7 日时段表数据
/// </summary>
public class Appendix_04010007 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010007> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010007(ILogger<Appendix_04010007> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第7日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

28
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_04010008.cs Normal file
View File

@ -0,0 +1,28 @@
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 第一套第 8 日时段表数据
/// </summary>
public class Appendix_04010008 : IAnalysisStrategy<List<string>, List<string>>
{
private readonly ILogger<Appendix_04010008> _logger;
private readonly AnalysisStrategyContext _analysisStrategyContext;
public Appendix_04010008(ILogger<Appendix_04010008> logger, AnalysisStrategyContext analysisStrategyContext)
{
_logger = logger;
_analysisStrategyContext = analysisStrategyContext;
}
public async Task<List<string>> ExecuteAsync(List<string> data)
{
var values = await _analysisStrategyContext.ExecuteAsync<List<string>, List<string>>("Appendix_04010000", data);
values[0] = "第一套第8日第{0}时段起始时间及费率号";
return await Task.FromResult(values);
}
}
}

33
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A1.cs Normal file
View File

@ -0,0 +1,33 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A1 : IAnalysisStrategy<List<string>, string>
{
private readonly ILogger<Appendix_A1> _logger;
public Appendix_A1(ILogger<Appendix_A1> logger)
{
_logger = logger;
}
public async Task<string> ExecuteAsync(List<string> data)
{
var seconds = data[0];
var minutes = data[1];
var hours = data[2];
var day = data[3];
string binString = data[4].HexTo4BinZero();
var months = (binString.Substring(3, 1).BinToDec() * 10) + Convert.ToInt32(binString.Substring(4, 4).BinToHex());
var week = binString.Substring(0, 3).HexTo4BinZero();
var year = $"{DateTime.Now.ToString("yyyy").Substring(0, 2)}{data[5]}";
string date= $"{year}-{months.ToString().PadLeft(2, '0')}-{day} {hours}:{minutes}:{seconds}_{week}";
return await Task.FromResult(date);
}
}
}

57
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A11.cs Normal file
View File

@ -0,0 +1,57 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 附录A.11数据格式
/// </summary>
class Appendix_A11 : IAnalysisStrategy<List<string>, decimal>
{
private readonly ILogger<Appendix_A11> _logger;
public Appendix_A11(ILogger<Appendix_A11> logger)
{
_logger = logger;
}
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.00M;
List<decimal[]> decimalDCBList = new List<decimal[]>();
decimalDCBList.Add(new decimal[2] { 10M, 100M });
decimalDCBList.Add(new decimal[2] { 10M, 1M });
decimalDCBList.Add(new decimal[2] { 1000M, 100M });
decimalDCBList.Add(new decimal[2] { 100000M, 10000M });
for (int i = 0; i < data.Count; i++)
{
int CalcType = i > 0 ? 2 : 1;
value += GetByteDCD(data[i].HexTo4BinZero(), CalcType, decimalDCBList[i]);
}
return await Task.FromResult(value);
}
/// <summary>
/// 附录A.14数据格式计算规则方法
/// </summary>
/// <param name="binString">二进制字符串</param>
/// <param name="calcType">//计算类型,1为除法，2为乘法</param>
/// <param name="bcd">除数数组</param>
/// <returns></returns>
private decimal GetByteDCD(string binString, int calcType, decimal[] bcd)
{
decimal result = 0.00000M;
switch (calcType)
{
case 1:
result = (binString.Substring(0, 4).BinToDec() / bcd[0]) + (binString.Substring(4, 4).BinToDec() / bcd[1]);
break;
case 2:
result = (binString.Substring(0, 4).BinToDec() * bcd[0]) + (binString.Substring(4, 4).BinToDec() * bcd[1]);
break;
}
return result;
}
}
}

56
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A13.cs Normal file
View File

@ -0,0 +1,56 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 附录A.13数据格式
/// </summary>
class Appendix_A13 : IAnalysisStrategy<List<string>, decimal>
{
private readonly ILogger<Appendix_A13> _logger;
public Appendix_A13(ILogger<Appendix_A13> logger)
{
_logger = logger;
}
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.00M;
List<decimal[]> decimalDCBList = new List<decimal[]>();
decimalDCBList.Add(new decimal[2] { 1000M, 10000M });
decimalDCBList.Add(new decimal[2] { 10M, 100M });
decimalDCBList.Add(new decimal[2] { 10M, 1M });
decimalDCBList.Add(new decimal[2] { 1000M, 100M });
for (int i = 0; i < data.Count; i++)
{
int CalcType = i > 1 ? 2 : 1;
value += GetByteDCD(data[i].HexTo4BinZero(), CalcType, decimalDCBList[i]);
}
return await Task.FromResult(value);
}
/// <summary>
/// 附录A.13数据格式计算规则方法
/// </summary>
/// <param name="binString">二进制字符串</param>
/// <param name="calcType">//计算类型,1为除法，2为乘法</param>
/// <param name="bcd">除数数组</param>
/// <returns></returns>
private decimal GetByteDCD(string binString, int calcType, decimal[] bcd)
{
decimal result = 0.00000M;
switch (calcType)
{
case 1:
result = (binString.Substring(0, 4).BinToDec() / bcd[0]) + (binString.Substring(4, 4).BinToDec() / bcd[1]);
break;
case 2:
result = (binString.Substring(0, 4).BinToDec() * bcd[0]) + (binString.Substring(4, 4).BinToDec() * bcd[1]);
break;
}
return result;
}
}
}

57
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A14.cs Normal file
View File

@ -0,0 +1,57 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
/// <summary>
/// 附录A.14数据格式
/// </summary>
class Appendix_A14 : IAnalysisStrategy<List<string>, decimal>
{
private readonly ILogger<Appendix_A14> _logger;
public Appendix_A14(ILogger<Appendix_A14> logger)
{
_logger = logger;
}
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.0000M;
List<decimal[]> decimalDCBList = new List<decimal[]>();
decimalDCBList.Add(new decimal[2] { 1000M, 10000M });
decimalDCBList.Add(new decimal[2] { 10M, 100M });
decimalDCBList.Add(new decimal[2] { 10M, 1M });
decimalDCBList.Add(new decimal[2] { 1000M, 100M });
decimalDCBList.Add(new decimal[2] { 100000M, 10000M });
for (int i = 0; i < data.Count; i++)
{
int CalcType = i > 1 ? 2 : 1;
value += GetByteDCD(data[i].HexTo4BinZero(), CalcType, decimalDCBList[i]);
}
return await Task.FromResult(value);
}
/// <summary>
/// 附录A.14数据格式计算规则方法
/// </summary>
/// <param name="binString">二进制字符串</param>
/// <param name="calcType">//计算类型,1为除法，2为乘法</param>
/// <param name="bcd">除数数组</param>
/// <returns></returns>
private decimal GetByteDCD(string binString, int calcType, decimal[] bcd)
{
decimal result = 0.00000M;
switch (calcType)
{
case 1:
result = (binString.Substring(0, 4).BinToDec() / bcd[0]) + (binString.Substring(4, 4).BinToDec() / bcd[1]);
break;
case 2:
result = (binString.Substring(0, 4).BinToDec() * bcd[0]) + (binString.Substring(4, 4).BinToDec() * bcd[1]);
break;
}
return result;
}
}
}

24
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A15.cs Normal file
View File

@ -0,0 +1,24 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A15 : IAnalysisStrategy<List<string>, string>
{
private readonly ILogger<Appendix_A15> _logger;
public Appendix_A15(ILogger<Appendix_A15> logger)
{
_logger = logger;
}
public async Task<string> ExecuteAsync(List<string> data)
{
data.Reverse();
data.Insert(0, DateTime.Now.ToString("yyyy").Substring(0, 2));
string date= string.Join("", data);
return await Task.FromResult(date);
}
}
}

16
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A17.cs Normal file
View File

@ -0,0 +1,16 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
using Microsoft.Extensions.Logging;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A17 : IAnalysisStrategy<List<string>, string>
{
public async Task<string> ExecuteAsync(List<string> data)
{
data.Reverse();
string datasStr= string.Join("", data);
return await Task.FromResult(datasStr);
}
}
}

50
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A23.cs Normal file
View File

@ -0,0 +1,50 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A23 : IAnalysisStrategy<List<string>, decimal>
{
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.000M;
if (data[0].Check3761Byte())
value += GetValue(0, 4, 1000M, 4, 4, 10000M, data[0], 1);
if (data[1].Check3761Byte())
value += GetValue(0, 4, 10M, 4, 4, 100M, data[1], 1);
if (data[2].Check3761Byte())
value += GetValue(0, 4, 10M, 4, 4, 1M, data[2], 0);
return await Task.FromResult(value);
}
/// <summary>
/// 解析值
/// </summary>
/// <param name="startIndex">二进制低位字符串截取位置</param>
/// <param name="startLength">截取长度</param>
/// <param name="startQuantile">分位值，1000M</param>
/// <param name="endIndex">二进制高位字符串截取位置</param>
/// <param name="endLength">截取长度</param>
/// <param name="endQuantile">分位值，100M</param>
/// <param name="data">数据</param>
/// <param name="calType">计算类型,0:乘法，1：除法</param>
/// <returns></returns>
private decimal GetValue(int startIndex, int startLength, decimal startQuantile, int endIndex, int endLength, decimal endQuantile, string data, int calType = 0)
{
var value = 0M;
string binString = data.HexTo4BinZero();
switch (calType)
{
case 0:
value = (binString.Substring(startIndex, startLength).BinToDec() * startQuantile) + (binString.Substring(endIndex, endLength).BinToDec() * endQuantile);
break;
case 1:
value = (binString.Substring(startIndex, startLength).BinToDec() / startQuantile) + (binString.Substring(endIndex, endLength).BinToDec() / endQuantile);
break;
}
return value;
}
}
}

33
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A25.cs Normal file
View File

@ -0,0 +1,33 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A25 : IAnalysisStrategy<List<string>, decimal>
{
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.000M;
string binString = string.Empty;
if (data[0].Check3761Byte())
{
binString = data[0].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 100M) + (binString.Substring(4, 4).BinToDec() / 1000M);
}
if (data[1].Check3761Byte())
{
binString = data[1].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 1M) + (binString.Substring(4, 4).BinToDec() / 10M);
}
if (data[2].Check3761Byte())
{
binString = data[2].HexTo4BinZero();
value += (binString.Substring(1, 3).BinToDec() * 100M) + (binString.Substring(4, 4).BinToDec() * 10M);
int sign = Convert.ToInt32(binString.Substring(0, 1));//正负值标记
value = sign == 0 ? value * 1 : value * -1;
}
return await Task.FromResult(value);
}
}
}

27
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A5.cs Normal file
View File

@ -0,0 +1,27 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A5 : IAnalysisStrategy<List<string>, decimal>
{
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.0M;
string binString = string.Empty;
if (data[0].Check3761Byte())
{
binString = data[0].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 1M) + (binString.Substring(4, 4).BinToDec() / 10M);
}
if (data[1].Check3761Byte())
{
binString = data[1].HexTo4BinZero();
value += (binString.Substring(1, 3).BinToDec() * 100M) + (binString.Substring(4, 4).BinToDec() * 10M);
int sign = Convert.ToInt32(binString.Substring(0, 1));//正负值标记
value = sign == 0 ? value * 1 : value * -1;
}
return await Task.FromResult(value);
}
}
}

27
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A7.cs Normal file
View File

@ -0,0 +1,27 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A7 : IAnalysisStrategy<List<string>, decimal>
{
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.0M;
string binString = string.Empty;
if (data[0].Check3761Byte())
{
binString = data[0].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 1M) + (binString.Substring(4, 4).BinToDec() / 10M);
}
if (data[1].Check3761Byte())
{
binString = data[1].HexTo4BinZero();
if (binString.Check3761Byte())
value += (binString.Substring(0, 4).BinToDec() * 100M) + (binString.Substring(4, 4).BinToDec() * 10M);
}
return await Task.FromResult(value);
}
}
}

36
protocols/JiShe.CollectBus.Protocol/Appendix/Appendix_A9.cs Normal file
View File

@ -0,0 +1,36 @@
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Protocol.Contracts.Interfaces;
namespace JiShe.CollectBus.Protocol.AnalysisData.Appendix
{
public class Appendix_A9 : IAnalysisStrategy<List<string>, decimal>
{
public async Task<decimal> ExecuteAsync(List<string> data)
{
decimal value = 0.0000M;
string binString = string.Empty;
if (data[0].Check3761Byte())
{
binString = data[0].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 1000M) + (binString.Substring(4, 4).BinToDec() / 10000M);
}
if (data[1].Check3761Byte())
{
binString = data[1].HexTo4BinZero();
value += (binString.Substring(0, 4).BinToDec() / 10M) + (binString.Substring(4, 4).BinToDec() / 100M);
}
if (data[2].Check3761Byte())
{
binString = data[2].HexTo4BinZero();
value += (binString.Substring(1, 3).BinToDec() * 10M) + (binString.Substring(4, 4).BinToDec() * 1M);
int sign = Convert.ToInt32(binString.Substring(0, 1));//正负值标记
value = sign == 0 ? value * 1 : value * -1;
}
return await Task.FromResult(value);
}
}
}

129
protocols/JiShe.CollectBus.Protocol/Protocol3761Extensions.cs Normal file
View File

@ -0,0 +1,129 @@
using JiShe.CollectBus.Common.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Protocol
{
public static class Protocol3761Extensions
{
/// <summary>
/// 3761协议数据字节校验
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static bool Check3761Byte(this string value)
{
if (!value.ToUpper().Equals("FF") && !value.ToUpper().Equals("EE"))
return true;
return false;
}
/// <summary>
/// 字符串中是否包含字母
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static bool IsLetterExists(this string value)
{
return Regex.Matches(value, "[a-zA-Z]").Count > 0;
}
/// <summary>
/// 判断错误代码
/// </summary>
public static Tuple<string,string>? CheckErrorCode(this List<string> data)
{
var value = string.Join("", data);
if (value.IsLetterExists())
{
var code = ErrorCodes().Where(f => value.Contains(f.Key)).FirstOrDefault();
if (code.Key != null)
return Tuple.Create(code.Key,code.Value);
else
return Tuple.Create("EE", "未知数据错误");
}
return null;
}
/// <summary>
/// 判断错误代码
/// </summary>
public static Tuple<string, string>? CheckErrorCode(this string value)
{
if (value.IsLetterExists())
{
var code = ErrorCodes().Where(f => value.Contains(f.Key)).FirstOrDefault();
if (code.Key != null)
return Tuple.Create(code.Key, code.Value);
else
return Tuple.Create("EE", "未知数据错误");
}
return null;
}
/// <summary>
/// 错误信息
/// </summary>
/// <returns></returns>
public static Dictionary<string, string> ErrorCodes()
{
return new Dictionary<string, string>()
{
{ "FF", "电表无此数据项" },
{ "EE", "未知数据错误" },
{ "E1", "数据点缺少(停电)" },
{ "E2", "通讯异常" },
{ "E3", "集中器未配置数据项" },
{ "E4", "电表档案无效" },
{ "E5", "电表无此数据项" },
{ "E6", "电表时间异常" },
{ "E7","暂停抄表" }
};
}
/// <summary>
/// 费率数
/// </summary>
/// <param name="index"></param>
/// <param name="len"></param>
/// <returns></returns>
public static int GetRatingCount(this List<string> hexMessageList ,int index, int len)
{
var list = hexMessageList.GetRange(index, len);
return list.Count > 0 ? list[0].HexToDec() : 0;
}
/// <summary>
/// 抄表时间
/// </summary>
/// <param name="index"></param>
/// <param name="len"></param>
/// <returns></returns>
public static string GetReadTime(this List<string> hexMessageList, int index, int len)
{
var list = hexMessageList.GetRange(index, len);
return list.GetReadTime();
}
/// <summary>
/// 抄表时间
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static string GetReadTime(this List<string> data)
{
data.Reverse();
data.Insert(0, DateTime.Now.ToString("yyyy").Substring(0, 2));
return string.Join("", data);
}
}
}

8
protocols/JiShe.CollectBus.Protocol/StandardProtocolPlugin.cs
View File

@ -29,6 +29,7 @@ namespace JiShe.CollectBus.Protocol
private readonly IRepository<Device, Guid> _deviceRepository; private readonly IRepository<Device, Guid> _deviceRepository;
private readonly ITcpService _tcpService; private readonly ITcpService _tcpService;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="StandardProtocolPlugin"/> class. /// Initializes a new instance of the <see cref="StandardProtocolPlugin"/> class.
/// </summary> /// </summary>
@ -216,10 +217,7 @@ namespace JiShe.CollectBus.Protocol
DeviceNo = code, DeviceNo = code,
MessageId = Guid.NewGuid().ToString() MessageId = Guid.NewGuid().ToString()
}; };
//await _producerBus.PublishAsync(ProtocolConst.SubscriberHeartbeatReceivedEventName, messageReceivedHeartbeatEvent);
await _producerService.ProduceAsync(ProtocolConst.SubscriberHeartbeatReceivedEventName, messageReceivedHeartbeatEvent); await _producerService.ProduceAsync(ProtocolConst.SubscriberHeartbeatReceivedEventName, messageReceivedHeartbeatEvent);
//await _producerBus.Publish(messageReceivedHeartbeatEvent);
var reqParam = new ReqParameter2() var reqParam = new ReqParameter2()
{ {
@ -239,7 +237,6 @@ namespace JiShe.CollectBus.Protocol
Fn = 1 Fn = 1
}; };
var bytes = Build3761SendData.BuildSendCommandBytes(reqParam); var bytes = Build3761SendData.BuildSendCommandBytes(reqParam);
//await _producerBus.PublishAsync(ProtocolConst.SubscriberHeartbeatIssuedEventName, new IssuedEventMessage { ClientId = messageReceived.ClientId, DeviceNo = messageReceived.DeviceNo, Message = bytes, Type = IssuedEventType.Heartbeat, MessageId = messageReceived.MessageId });
IssuedEventMessage issuedEventMessage = new IssuedEventMessage IssuedEventMessage issuedEventMessage = new IssuedEventMessage
{ {
@ -255,9 +252,6 @@ namespace JiShe.CollectBus.Protocol
_logger.LogWarning($"集中器地址{issuedEventMessage.ClientId} 心跳回复下发内容:{Convert.ToHexString(bytes)}"); _logger.LogWarning($"集中器地址{issuedEventMessage.ClientId} 心跳回复下发内容:{Convert.ToHexString(bytes)}");
await _producerService.ProduceAsync(ProtocolConst.SubscriberHeartbeatIssuedEventName, issuedEventMessage); await _producerService.ProduceAsync(ProtocolConst.SubscriberHeartbeatIssuedEventName, issuedEventMessage);
} }
//await _producerBus.Publish(new IssuedEventMessage { ClientId = messageReceived.ClientId, DeviceNo = messageReceived.DeviceNo, Message = bytes, Type = IssuedEventType.Heartbeat, MessageId = messageReceived.MessageId });
} }

4
services/JiShe.CollectBus.Application/Plugins/TcpMonitor.cs
View File

@ -155,7 +155,7 @@ namespace JiShe.CollectBus.Plugins
// MessageId = NewId.NextGuid().ToString() // MessageId = NewId.NextGuid().ToString()
//}); //});
if(tB3761?.AFN_FC?.AFN==null || tB3761.DT?.Fn==null) if(tB3761?.AFN_FC.BaseHexMessage==null || tB3761.DT.BaseHexMessage == null)
{ {
_logger.LogError("376.1协议解析AFN失败"); _logger.LogError("376.1协议解析AFN失败");
return; return;
@ -165,7 +165,7 @@ namespace JiShe.CollectBus.Plugins
// return; // return;
//TODO：根据AFN进行分流推送到kafka //TODO：根据AFN进行分流推送到kafka
string topicName = string.Format(ProtocolConst.AFNTopicNameFormat, tB3761?.AFN_FC?.AFN.ToString().PadLeft(2,'0')); string topicName = string.Format(ProtocolConst.AFNTopicNameFormat, tB3761?.AFN_FC.AFN.ToString().PadLeft(2,'0'));
List<string> topics = ProtocolConstExtensions.GetAllTopicNamesByReceived(); List<string> topics = ProtocolConstExtensions.GetAllTopicNamesByReceived();

8
services/JiShe.CollectBus.Application/Subscribers/SubscriberAppService.cs
View File

@ -180,7 +180,7 @@ namespace JiShe.CollectBus.Subscribers
} }
[KafkaSubscribe(ProtocolConst.SubscriberAFN02HReceivedEventNameTemp)] //[KafkaSubscribe(ProtocolConst.SubscriberAFN02HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN00Event(MessageReceived receivedMessage) public async Task<ISubscribeAck> ReceivedAFN00Event(MessageReceived receivedMessage)
{ {
@ -205,12 +205,12 @@ namespace JiShe.CollectBus.Subscribers
string serverName = $"AFN{tB3761.AFN_FC.AFN}_F{tB3761.DT.Fn}_Analysis"; string serverName = $"AFN{tB3761.AFN_FC.AFN}_F{tB3761.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis"); //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<AFN0_F1_AnalysisDto>>(tB3761); //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>(); var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
AFN0_F1_AnalysisDto aFN0_F1_AnalysisDto= await executor.ExecuteAsync<TB3761,AFN0_F1_AnalysisDto>("AFN0_F1_Analysis", tB3761); bool isSucces= await executor.ExecuteAsync<TB3761, bool>("AFN0_F1_Analysis", tB3761);
} }
return SubscribeAck.Success(); return SubscribeAck.Fail();
} }

32
shared/JiShe.CollectBus.Common/Extensions/StringExtensions.cs
View File

@ -1178,6 +1178,17 @@ namespace JiShe.CollectBus.Common.Extensions
return decimalNumber; return decimalNumber;
} }
/// <summary>
/// 转十进制字符串
/// </summary>
/// <param name="hexString"></param>
/// <returns></returns>
public static string HexToDecStr(this int hexString)
{
var decimalString = Convert.ToString(hexString, 16);
return decimalString;
}
/// <summary> /// <summary>
/// 十六进制转二进制 /// 十六进制转二进制
/// </summary> /// </summary>
@ -1229,6 +1240,27 @@ namespace JiShe.CollectBus.Common.Extensions
return string.Join(" ", strArr); return string.Join(" ", strArr);
} }
/// <summary>
/// 16进制字符串转换成byte数组
/// </summary>
/// <param name="hexString">16进制字符串</param>
/// <returns>byte数组</returns>
public static byte[] HexToByte(this string hexString)
{
hexString = hexString.Replace(" ", "");
string tempStr = "";
byte by = 0;
List<byte> bytes = new List<byte>();
for (int i = 0; i < hexString.Length; i += 2)
{
tempStr = hexString.Substring(i, 2);
by = byte.Parse(tempStr, System.Globalization.NumberStyles.AllowHexSpecifier);
bytes.Add(by);
}
return bytes.ToArray();
}
/// <summary> /// <summary>
/// 判断数据是否有误 /// 判断数据是否有误
/// </summary> /// </summary>