public static async Task <bool> GetDateTime(ModbusRtuOverTcp client, int modbusAddress, IotDataOilOmeter tankmeasure, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var year = client.ByteTransform.TransByte(read.Content, 0);
var month = client.ByteTransform.TransByte(read.Content, 1);
var date = client.ByteTransform.TransByte(read.Content, 2);
var h = client.ByteTransform.TransByte(read.Content, 3);
var m = client.ByteTransform.TransByte(read.Content, 4);
var s = client.ByteTransform.TransByte(read.Content, 5);
if (year != 0 && month != 0 && date != 0)
{
tankmeasure.DateTime = new DateTime(2000 + year, month, date, h, m, s);
}
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetDateTime(client, modbusAddress, tankmeasure, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetDateTime(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellMovefluidlevel dytDiagram, ushort startAddress, ushort regCount, int tryReadTimes = 3)
{
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var year = client.ByteTransform.TransUInt16(read.Content, 0);
var month = client.ByteTransform.TransUInt16(read.Content, 1);
var date = client.ByteTransform.TransUInt16(read.Content, 2);
var h = client.ByteTransform.TransUInt16(read.Content, 3);
var m = client.ByteTransform.TransUInt16(read.Content, 4);
var s = client.ByteTransform.TransUInt16(read.Content, 5);
dytDiagram.DateTime = new DateTime(2000 + year, month, date, h, m, s);
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetDateTime(client, modbusAddress, dytDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetCount(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellIndicatorDiagram indicatorDiagram, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
indicatorDiagram.Count = value;
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetCount(client, modbusAddress, indicatorDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetGJL(ModbusRtuOverTcp client, int modbusAddress, IotDataOilOmeter tankmeasure, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
//毫米
tankmeasure.CurrentElevation = value;
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetGJL(client, modbusAddress, tankmeasure, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task Get_XAGL_WM3000KZG_ControllerParameter(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 10;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;7596", 5);
if (read.IsSuccess && read.Content.Length == 2 * 5)
{
// 电机额定功率 7596 变比 0.1
var value = client.ByteTransform.TransInt16(read.Content, 0);
var eDingGongLv = Math.Round(value * 0.1, 2);
// 电机额定电压 7597 变比 1
value = client.ByteTransform.TransInt16(read.Content, 2);
var eDingDianYa = value;
// 电机额定电流 7598 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 4);
var eDingDianliu = Math.Round(value * 0.01, 2);
// 电机额定频率 7599 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 6);
var eDingPingLv = Math.Round(value * 0.01, 2);
// 电机额定转速 7600 变比 1
value = client.ByteTransform.TransInt16(read.Content, 8);
var eDingZhuanSu = value;
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_LYQH_KZG_StartWellTime(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
// 读取0x0081 开井时间
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
var slotId = Convert.ToInt32(jo1["1"].ToString());
var startAddress = (ushort)((slotId * 0x100) + 0x0081);
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 4 * 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};3;{startAddress}", 4);
if (read.IsSuccess)
{
var year = client.ByteTransform.TransByte(read.Content, 0);
var month = client.ByteTransform.TransByte(read.Content, 1);
var date = client.ByteTransform.TransByte(read.Content, 2);
var h = client.ByteTransform.TransByte(read.Content, 3);
var m = client.ByteTransform.TransByte(read.Content, 4);
var s = client.ByteTransform.TransByte(read.Content, 5);
var DateTime = new DateTime(2000 + year, month, date, h, m, s);
}
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, read.IsSuccess ? 0 : -2, "ok");
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task <bool> GetAll(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellMovefluidlevel dytDiagram, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
//读取时间
var year = client.ByteTransform.TransByte(read.Content, 0);
var month = client.ByteTransform.TransByte(read.Content, 1);
var date = client.ByteTransform.TransByte(read.Content, 2);
var h = client.ByteTransform.TransByte(read.Content, 3);
var m = client.ByteTransform.TransByte(read.Content, 4);
var s = client.ByteTransform.TransByte(read.Content, 5);
dytDiagram.DateTime = new DateTime(2000 + year, month, date, h, m, s);
//采样周期
var value = client.ByteTransform.TransInt16(read.Content, 6);
dytDiagram.Period = (int)(value * 0.01);
//模式
value = client.ByteTransform.TransInt16(read.Content, 8);
dytDiagram.Model = value;
//点数
value = client.ByteTransform.TransInt16(read.Content, 10);
dytDiagram.Count = value;
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetAll(client, modbusAddress, dytDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetMode(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellMovefluidlevel dytDiagram, ushort startAddress, ushort regCount, int tryReadTimes)
{
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
dytDiagram.Model = value;
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetMode(client, modbusAddress, dytDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetCData(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellCurrentDiagram currentDiagram, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
for (var j = 0; j < regCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
if (value != 0)
{
//变比0.001，没有按协议文档，按实际的情况定
var L = value * 0.001;
currentDiagram.C.Add(Math.Round(L, 2));
}
else
{
currentDiagram.C.Add(value);
}
}
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetCData(client, modbusAddress, currentDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
public static async Task <bool> GetDData(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellMovefluidlevel dytDiagram, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
for (var j = 0; j < regCount; j++)
{
//无符号数0-65535
var value = client.ByteTransform.TransUInt16(read.Content, j * 2);
if (value != 0)
{
var L = value;
dytDiagram.Y.Add(value);
}
else
{
dytDiagram.Y.Add(value);
}
}
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetDData(client, modbusAddress, dytDiagram, startAddress, regCount, tryReadTimes));
}
return(false);
}
}
/// <summary>
/// 读取控制器数据
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Get_XAGL_WM3000KZG_ControllerStatus(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var iotDataOilWellControllerState = new IotDataOilWellControllerState()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.DeviceTypeId = par.DeviceTypeId;
iotDataOilWellControllerState.Mock = false;
var flag = true;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.WellId = par.DeviceId;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 29 * 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4096", 4124 - 4096 + 1);
if (read.IsSuccess)
{
// 耗电量 4096 变比 1
var value = client.ByteTransform.TransInt16(read.Content, 0);
iotDataOilWellControllerState.FrequencyConversionActivePower = value;
// 当前冲次 4097 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 2);
iotDataOilWellControllerState.Stroke = Math.Round(value * 0.1, 2);
// 电流平衡度 4098 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 4);
iotDataOilWellControllerState.CurrentBalance = Math.Round(value * 0.01 * 100, 2);
// 上行最大电流 4099 变比 0.0
value = client.ByteTransform.TransInt16(read.Content, 6);
iotDataOilWellControllerState.MaxUpCurrent = Math.Round(value * 0.01, 2);
// 下行最大电流 4100 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 8);
iotDataOilWellControllerState.MaxDownCurrent = Math.Round(value * 0.01, 2);
//变频器报警代码 4101 变比 1
value = client.ByteTransform.TransInt16(read.Content, 10);
iotDataOilWellControllerState.AlarmCode = value;
// 起停状态 4103 变比 1--->4102
value = client.ByteTransform.TransInt16(read.Content, 16);
iotDataOilWellControllerState.StartAndStopStatus = value; //2020-04-15 由6变为8
#region 去掉启停状态抛弃 后期可修改为插入异常标识 yangzx 20201014
////当启停状态非1和3时候，直接抛弃
//if (value != 1 && value != 3)
//{
// iotDataOilWellControllerState.AlarmCode = -1;
// iotDataOilWellControllerState.AlarmMsg = "数据异常";
// iotDataOilWellControllerState.Mock = par.UseMockData;
// logIotModbusPoll.DateTime = DateTime.Now;
// logIotModbusPoll.State = -1;
// logIotModbusPoll.Result = $"读取变频器启停状态异常，读取异常值为:{value}";
// redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
// return;
//}
#endregion
// 运行频率 4105 变比 1--->4103
value = client.ByteTransform.TransInt16(read.Content, 14);
iotDataOilWellControllerState.Frequency = Math.Round(value * 0.01, 2);
// 运行状态 4106 变比 1--->4104
value = client.ByteTransform.TransInt16(read.Content, 12);
iotDataOilWellControllerState.RunState = value; //2020-04-15 由8变为6
//变频累积运行时间4105
value = client.ByteTransform.TransInt16(read.Content, 18);
iotDataOilWellControllerState.TotalRunTime = value;
//变频母线电压4106
value = client.ByteTransform.TransInt16(read.Content, 20);
iotDataOilWellControllerState.BusBarVoltage = Math.Round(value * 0.1, 2);
//工变频切换 4122
value = client.ByteTransform.TransInt16(read.Content, 52);
iotDataOilWellControllerState.WorkAndChangeFrequencySwitch = value;
//就地远程切换4123
value = client.ByteTransform.TransInt16(read.Content, 54);
iotDataOilWellControllerState.LocalAndFarSwitch = value;
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取变频器状态数据异常！{read.Message}";
$"{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 4;
}
//抽油机冲程7632--
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;7632", 2);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
iotDataOilWellControllerState.MaxDisplacement = Math.Round(value * 0.1, 2);
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取冲程数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
iotDataOilWellControllerState.NetworkNode = ClientInfo.ManyIpAddress;
//Redis中写入设备最后状态
if (flag == true || par.UseMockData)
{
iotDataOilWellControllerState.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_ControllerState", iotDataOilWellControllerState.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:ControllerState", iotDataOilWellControllerState);
redisClient.Set($"Single:OilWell:ControllerState:{par.DeviceName}-{par.DeviceId}", iotDataOilWellControllerState);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, iotDataOilWellControllerState.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
/// <summary>
/// 读取电表数据
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Get_XAAS_WII_PowerMeter(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var powerMeter = new IotDataOilWellPowerMeter()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
ClientInfo.LinkId = par.LinkId;
powerMeter.DateTime = DateTime.Now;
powerMeter.WellId = par.DeviceId;
powerMeter.DeviceTypeId = par.DeviceTypeId;
powerMeter.Mock = false;
var flag = true;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;40532", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 1)
{
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
powerMeter.AlarmCode = 3;
powerMeter.AlarmMsg = "停井";
}
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取电参数据异常！[{read.Message}]";
$"DB:{par.DeviceName}-{par.DeviceId}{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 30;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;40533", 15);
if (read.IsSuccess)
{
// A相电流 40533 变比 0.01
var value = client.ByteTransform.TransInt16(read.Content, 0);
powerMeter.APhaseCurrent = Math.Round(value * 0.01, 1);
// B相电流 40534 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 2);
powerMeter.BPhaseCurrent = Math.Round(value * 0.01, 1);
// C相电流 40535 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 4);
powerMeter.CPhaseCurrent = Math.Round(value * 0.01, 1);
// A相电压 40536 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 6);
powerMeter.APhaseVoltage = Math.Round(value * 0.1, 1);
// B相电压 40537 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 8);
powerMeter.BPhaseVoltage = Math.Round(value * 0.1, 1);
// C相电压 40538 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 10);
powerMeter.CPhaseVoltage = Math.Round(value * 0.1, 1);
// 总有功功率 40539 变比0.01
value = client.ByteTransform.TransInt16(read.Content, 12);
powerMeter.TotalActivePower = Math.Round(value * 0.01, 1);
// 总无功功率 40540 变比0.01
value = client.ByteTransform.TransInt16(read.Content, 14);
powerMeter.TotalReactivePower = Math.Round(value * 0.01, 1);
//总视在功率 40541 变比0.01
value = client.ByteTransform.TransInt16(read.Content, 16);
powerMeter.TotalApparentPower = Math.Round(value * 0.01, 1);
// 总功率因素(功率因数) 40547 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 28);
powerMeter.TotalPowerFactor = Math.Round(value * 0.01, 1);
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取电参数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 8;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;40543", 4);
if (read.IsSuccess)
{
var value0 = client.ByteTransform.TransInt16(read.Content, 0);
var value1 = client.ByteTransform.TransInt16(read.Content, 2);
var value2 = client.ByteTransform.TransInt16(read.Content, 4);
var value3 = client.ByteTransform.TransInt16(read.Content, 6);
//总有功电能
powerMeter.TotalActiveEnergy = Math.Round(((value1 * 65536 + value0) * 0.01), 2);
//电参模型中缺少总无功电能
//powerMeter.TotalReactivePower = Math.Round(((value3 * 65536 + value2) * 0.01), 2);
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取总有功电能数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (flag == true || par.UseMockData)
{
$"DB:{par.DeviceName}-{par.DeviceId}已获取到数据".Info();
powerMeter.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_PowerMeter", powerMeter.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:PowerMeter", powerMeter);
redisClient.Set($"Single:OilWell:PowerMeter:{par.DeviceName}-{par.DeviceId}", powerMeter);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, powerMeter.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_WM2000GLT_PowerDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var powerDiagram = new IotDataOilWellPowerDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
powerDiagram.DeviceTypeId = par.DeviceTypeId;
powerDiagram.Mock = false;
var flag = true;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
powerDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
powerDiagram.D = new List <double>(); //位移
powerDiagram.P = new List <double>(); //功率
powerDiagram.DateTime = DateTime.Now;
powerDiagram.WellId = par.DeviceId;
#region 判断井状态
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4103", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 3) //1：正转运行；3：变频停机
{
powerDiagram.NetworkNode = ClientInfo.ManyIpAddress;
powerDiagram.AlarmCode = 3;
powerDiagram.AlarmMsg = "停井";
}
}
else
{
flag = false;
powerDiagram.AlarmCode = -1;
powerDiagram.AlarmMsg = "数据异常";
powerDiagram.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取功率图井状态数据异常！[{read.Message}]";
$"GLT:{par.DeviceName}-{par.DeviceId}{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
#endregion
const ushort step = 100;
//ToDo:确认采样间隔和点数
powerDiagram.Count = 300;
if (flag && powerDiagram.Count <= 300 && powerDiagram.Count >= step)
{
const ushort regAddress = 38268; //读取功率数据
for (ushort i = 0; i < powerDiagram.Count && flag; i += step)
{
var itemCount = (i + step > powerDiagram.Count) ? (ushort)(powerDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (!read.IsSuccess)
{
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
}
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
var P = Math.Round((value / 4000.0) * 36, 2);
powerDiagram.P.Add(P);
}
}
else
{
flag = false;
powerDiagram.AlarmCode = -1;
powerDiagram.AlarmMsg = "数据异常";
powerDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM2000GLT_PowerDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result =
"从 " + (regAddress + i).ToString() + " 个开始，读取 " + itemCount.ToString() +
$" 个功率图功率数据异常!{read.Message}";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
if (powerDiagram.P.Count > 0)
{
powerDiagram.MaxPower = powerDiagram.P.Max(); //最大功率
powerDiagram.MinPower = powerDiagram.P.Min(); //最小功率
powerDiagram.AvgPower = Math.Round(powerDiagram.P.Average(), 2); //平均功率
}
}
else
{
flag = false;
}
powerDiagram.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (flag == true || par.UseMockData)
{
$"GLT:{par.DeviceName}-{par.DeviceId}已获取到数据".Info();
powerDiagram.Mock = par.UseMockData;
if (powerDiagram.Count != null)
{
if (powerDiagram.Displacement != null)
{
powerDiagram.D =
DisplacementUtils.FitDisplacement((ushort)powerDiagram.Count,
(double)powerDiagram.Displacement);
}
}
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_PowerDiagram", powerDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:PowerDiagram", powerDiagram);
redisClient.Set($"Single:OilWell:PowerDiagram:{par.DeviceName}-{par.DeviceId}", powerDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, powerDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_WM1000KZG_ControllerStatus(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var iotDataOilWellControllerState = new IotDataOilWellControllerState()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
iotDataOilWellControllerState.DeviceTypeId = par.DeviceTypeId;
iotDataOilWellControllerState.Mock = false;
var flag = true;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.WellId = par.DeviceId;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 6;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4116", 3);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 4);
iotDataOilWellControllerState.AlarmCode = value;
value = client.ByteTransform.TransInt16(read.Content, 2);
iotDataOilWellControllerState.StartAndStopStatus = value;
value = client.ByteTransform.TransInt16(read.Content, 0);
iotDataOilWellControllerState.LocalAndFarSwitch = value;
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取变频器状态数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
iotDataOilWellControllerState.NetworkNode = ClientInfo.ManyIpAddress;
//Redis中写入设备最后状态
if (flag == true || par.UseMockData)
{
iotDataOilWellControllerState.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_ControllerState", iotDataOilWellControllerState.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:ControllerState", iotDataOilWellControllerState);
redisClient.Set($"Single:OilWell:ControllerState:{par.DeviceName}-{par.DeviceId}", iotDataOilWellControllerState);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, iotDataOilWellControllerState.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_WM1000DB_PowerMeter(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var powerMeter = new IotDataOilWellPowerMeter()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
powerMeter.DateTime = DateTime.Now;
powerMeter.WellId = par.DeviceId;
powerMeter.DeviceTypeId = par.DeviceTypeId;
powerMeter.Mock = false;
var flag = true;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4117", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 0)
{
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
powerMeter.AlarmCode = 3;
powerMeter.AlarmMsg = "停井";
}
}
else
{
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 9 * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4096", 9);
if (read.IsSuccess)
{
// A相电压 4097 变比 0.1
var value = client.ByteTransform.TransInt16(read.Content, 0);
powerMeter.APhaseVoltage = Math.Round(value * 0.1, 1);
// B相电压 4098 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 2);
powerMeter.BPhaseVoltage = Math.Round(value * 0.1, 1);
// C相电压 4099 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 4);
powerMeter.CPhaseVoltage = Math.Round(value * 0.1, 1);
// A相电流 4100 变比 0.001
value = client.ByteTransform.TransInt16(read.Content, 6);
powerMeter.APhaseCurrent = Math.Round(value * 0.001, 1);
// B相电流 4101 变比 0.001
value = client.ByteTransform.TransInt16(read.Content, 8);
powerMeter.BPhaseCurrent = Math.Round(value * 0.001, 1);
// C相电流 4102 变比 0.001
value = client.ByteTransform.TransInt16(read.Content, 10);
powerMeter.CPhaseCurrent = Math.Round(value * 0.001, 1);
//有功电能
var value1 = client.ByteTransform.TransInt16(read.Content, 12);
var value2 = client.ByteTransform.TransInt16(read.Content, 14);
powerMeter.TotalActiveEnergy = Math.Round((value1 * 65535 + value2) * 0.15, 3);
//总功率因素 4105 变比 1
value = client.ByteTransform.TransInt16(read.Content, 16);
powerMeter.TotalPowerFactor = Math.Round(value * 0.001, 1);
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取电参数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (flag == true || par.UseMockData)
{
powerMeter.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_PowerMeter", powerMeter.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:PowerMeter", powerMeter);
redisClient.Set($"Single:OilWell:PowerMeter:{par.DeviceName}-{par.DeviceId}", powerMeter);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, powerMeter.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
//
}
public static async Task Get_ZJJH_WTPM_TrunkPressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterStation = new IotDataWaterStation();
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
waterStation.DeviceTypeId = par.DeviceTypeId;
var flag = true;
try
{
var read = await client.ReadAsync($"s={modbusAddress};x=3;220", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
waterStation.StationId = par.DeviceId; //注水间ID
waterStation.TrunkPressure = value / 100.0; //总汇管压力
waterStation.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
waterStation.AlarmCode = -1;
waterStation.AlarmMsg = "数据异常";
waterStation.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取注水间干压数据异常！";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
waterStation.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
waterStation.Mock = par.UseMockData;
//用于将读取的结果写入Redis队列
redisClient.AddItemToList("YCIOT:IOT_Data_WaterStation", waterStation.ToJson().IndentJson());
redisClient.Set($"Group:WaterStation:{par.DeviceName}-{par.DeviceId}", waterStation);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterStation.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
/// <summary>
/// 读取控制器数据
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Get_XAGL_WM2000KZG_ControllerStatus(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var iotDataOilWellControllerState = new IotDataOilWellControllerState()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.DeviceTypeId = par.DeviceTypeId;
iotDataOilWellControllerState.Mock = false;
var flag = true;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.WellId = par.DeviceId;
#region 变频器基本监视参数
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 9 * 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4096", 4104 - 4096 + 1);
if (read.IsSuccess)
{
// 耗电量 4096 变比 1
var value = client.ByteTransform.TransInt16(read.Content, 0);
iotDataOilWellControllerState.FrequencyConversionActivePower = value;
//电流平衡度 4097 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 2);
iotDataOilWellControllerState.CurrentBalance = Math.Round(value * 0.01, 2);
// 上行最大电流 4098 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 4);
iotDataOilWellControllerState.MaxUpCurrent = Math.Round(value * 0.01, 2);
// 下行最大电流 4099 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 6);
iotDataOilWellControllerState.MaxDownCurrent = Math.Round(value * 0.01, 2);
//变频器报警代码 4100 变比 1
value = client.ByteTransform.TransInt16(read.Content, 8);
iotDataOilWellControllerState.AlarmCode = value;
// 起停状态 4101 变比 1
value = client.ByteTransform.TransInt16(read.Content, 10);
iotDataOilWellControllerState.StartAndStopStatus = value;
// 运行频率 4102 变比0.01
value = client.ByteTransform.TransInt16(read.Content, 12);
iotDataOilWellControllerState.Frequency = Math.Round(value * 0.01, 2);
// 运行状态 4103 变比 1
value = client.ByteTransform.TransInt16(read.Content, 14);
iotDataOilWellControllerState.RunState = value;
//变频功率因素角度
value = client.ByteTransform.TransInt16(read.Content, 16);
iotDataOilWellControllerState.PowerFactorAngle = value;
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取变频器基本监视参数异常！{read.Message}";
$"{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
#endregion
#region 工变频切换、就地远程切换
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 4;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4128", 3);
if (read.IsSuccess)
{
//工变频切换 4128 0工；1变
var value = client.ByteTransform.TransInt16(read.Content, 0);
iotDataOilWellControllerState.WorkAndChangeFrequencySwitch = value;
//就地远程切换4129 0就；1远
value = client.ByteTransform.TransInt16(read.Content, 2);
iotDataOilWellControllerState.LocalAndFarSwitch = value;
//点数采集4130
value = client.ByteTransform.TransInt16(read.Content, 4);
iotDataOilWellControllerState.CountFetchAddress = value;
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取工变频切换和就地远程切换异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
#endregion
#region 双字节监视参数
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 8 * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4133", 8);
if (read.IsSuccess)
{
//变频累积运行时间
var value0 = client.ByteTransform.TransInt16(read.Content, 0);
var value1 = client.ByteTransform.TransInt16(read.Content, 2);
iotDataOilWellControllerState.TotalRunTime = value1 * 10000 + value0;
//变频累积上电时间
value0 = client.ByteTransform.TransInt16(read.Content, 4);
value1 = client.ByteTransform.TransInt16(read.Content, 6);
iotDataOilWellControllerState.TotalPowerupTime = value1 * 10000 + value0;
//变频当前上电时间
value0 = client.ByteTransform.TransInt16(read.Content, 8);
value1 = client.ByteTransform.TransInt16(read.Content, 10);
iotDataOilWellControllerState.CurrentPowerupTime = value1 * 10000 + value0;
//变频当前运行时间
value0 = client.ByteTransform.TransInt16(read.Content, 12);
value1 = client.ByteTransform.TransInt16(read.Content, 14);
iotDataOilWellControllerState.CurrentRunTime = value1 * 10000 + value0;
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取变频累积运行时间异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
#endregion
#region 其它参数(井口压力）
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 3 * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4166", 3);
if (read.IsSuccess)
{
//井口压力1 4166
var value = client.ByteTransform.TransInt16(read.Content, 0);
//井口压力2 4167
value = client.ByteTransform.TransInt16(read.Content, 2);
//井口压力3 4168
value = client.ByteTransform.TransInt16(read.Content, 4);
}
else
{
flag = false;
iotDataOilWellControllerState.AlarmCode = -1;
iotDataOilWellControllerState.AlarmMsg = "数据异常";
iotDataOilWellControllerState.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取井口压力数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
#endregion
iotDataOilWellControllerState.NetworkNode = ClientInfo.ManyIpAddress;
//写入设备最后状态
if (flag == true || par.UseMockData)
{
iotDataOilWellControllerState.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_ControllerState", iotDataOilWellControllerState.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:ControllerState", iotDataOilWellControllerState);
redisClient.Set($"Single:OilWell:ControllerState:{par.DeviceName}-{par.DeviceId}", iotDataOilWellControllerState);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, iotDataOilWellControllerState.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_ZKAW_IndicatorDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.Mock = false;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
indicatorDiagram.D = new List <double>(); //位移
indicatorDiagram.L = new List <double>(); //载荷
indicatorDiagram.DateTime = DateTime.Now;
indicatorDiagram.WellId = par.DeviceId;
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var flag = true;
var read = await client.ReadAsync($"s={modbusAddress};x=3;980", 4); //功图实际点数
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 6);
indicatorDiagram.Count = value; //采样点数
value = client.ByteTransform.TransInt16(read.Content, 0);
indicatorDiagram.Interval = value * 0.001; //采样间隔
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取采样间隔、采样点数数据异常！";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
read = await client.ReadAsync($"s={modbusAddress};x=3;990", 2); //冲次
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
indicatorDiagram.Stroke = value; //冲次
value = client.ByteTransform.TransInt16(read.Content, 2);
indicatorDiagram.Displacement = value; //冲程
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取冲次、冲程数据异常！";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
const ushort step = 50;
if (flag)
{
//读取载荷数据
ushort regAddress = 1250;
for (ushort i = 0; i < indicatorDiagram.Count; i += step)
{
var itemCount = (i + step > indicatorDiagram.Count)
? (ushort)(indicatorDiagram.Count - i)
: step;
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
read = await client.ReadAsync($"s={modbusAddress};x=3;{(ushort)(regAddress + i)}", itemCount);
if (!read.IsSuccess)
{
read = await client.ReadAsync($"s={modbusAddress};x=3;{(ushort)(regAddress + i)}", itemCount);
}
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
indicatorDiagram.L.Add(Math.Round(value * 0.01, 3));
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " +
itemCount.ToString() + " 个有线功图载荷数据异常!";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll",
logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(20);
}
}
if (flag)
{
//读取位移数据
var regAddress = 1000;
for (ushort i = 0; i < indicatorDiagram.Count; i += step)
{
var itemCount = (i + step > indicatorDiagram.Count)
? (ushort)(indicatorDiagram.Count - i)
: step;
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
read = await client.ReadAsync($"s={modbusAddress};x=3;{(ushort)(regAddress + i)}", itemCount);
if (!read.IsSuccess)
{
read = await client.ReadAsync($"s={modbusAddress};x=3;{(ushort)(regAddress + i)}", itemCount);
}
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
indicatorDiagram.D.Add(Math.Round(value * 0.01, 3));
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " +
itemCount.ToString() + " 个有线功图载荷数据异常!";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll",
logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(20);
}
}
if (flag)
{
var maxLoad = indicatorDiagram.D.Max();
var minLoad = indicatorDiagram.D.Min();
for (var i = 0; i < indicatorDiagram.D.Count; i++)
{
indicatorDiagram.D[i] = Math.Round(((indicatorDiagram.D[i] - minLoad) / (maxLoad - minLoad) * (double)indicatorDiagram.Displacement), 2);
}
if (indicatorDiagram.D.Count > 0)
{
indicatorDiagram.Displacement = Math.Round(indicatorDiagram.D.Max(), 2);
indicatorDiagram.MaxLoad = Math.Round(indicatorDiagram.L.Max(), 2); //最大载荷
indicatorDiagram.MinLoad = Math.Round(indicatorDiagram.L.Min(), 2); //最小载荷
indicatorDiagram.AvgLoad = Math.Round(indicatorDiagram.L.Average(), 2); //平均载荷
}
}
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true)
{
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram", indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, indicatorDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task <bool> GetPowerMeter(ModbusRtuOverTcp client, int modbusAddress, IotDataOilWellPowerMeter powerMeter, ushort startAddress, ushort regCount, int tryReadTimes)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = regCount * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", regCount);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
// A相电压 1606 变比 0.1
powerMeter.APhaseVoltage = Math.Round(value * 0.1, 1);
value = client.ByteTransform.TransInt16(read.Content, 2);
// B相电压 1607 变比 0.1
powerMeter.BPhaseVoltage = Math.Round(value * 0.1, 1);
value = client.ByteTransform.TransInt16(read.Content, 4);
// C相电压 1608 变比 0.1
powerMeter.CPhaseVoltage = Math.Round(value * 0.1, 1);
value = client.ByteTransform.TransInt16(read.Content, 6);
// A相电流 1609 变比 0.001 未按协议文档，按照实际情况定
powerMeter.APhaseCurrent = Math.Round(value * 0.001, 1);
value = client.ByteTransform.TransInt16(read.Content, 8);
// B相电流 1610 变比 0.001
powerMeter.BPhaseCurrent = Math.Round(value * 0.001, 1);
value = client.ByteTransform.TransInt16(read.Content, 10);
// C相电流 1611 变比 0.001
powerMeter.CPhaseCurrent = Math.Round(value * 0.001, 1);
value = client.ByteTransform.TransInt16(read.Content, 12);
//当前有功功率 1612 变比 0.01
var currentYGGL = Math.Round(value * 0.01, 2);
Console.WriteLine("当前有功功率:" + currentYGGL);
value = client.ByteTransform.TransInt16(read.Content, 14);
//当前总功率 1613 变比 0.01
powerMeter.TotalActivePower = Math.Round(value * 0.01, 2);
value = client.ByteTransform.TransInt16(read.Content, 16);
//当前功率因数 1614 变比 1
var currentGLFactor = value;
powerMeter.TotalPowerFactor = currentGLFactor;
return(true);
}
else
{
tryReadTimes--;
if (tryReadTimes > 0)
{
return(await GetPowerMeter(client, modbusAddress, powerMeter, startAddress, regCount, tryReadTimes));
}
powerMeter.AlarmMsg = read.Message;
return(false);
}
}
public static async Task Get_XAGL_WM1000YXGT_IndicatorDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.Mock = false;
var flag = true;
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
indicatorDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
indicatorDiagram.D = new List <double>(); //位移
indicatorDiagram.L = new List <double>(); //载荷
indicatorDiagram.DateTime = DateTime.Now;
indicatorDiagram.WellId = par.DeviceId;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4117", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 0)
{
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
indicatorDiagram.AlarmCode = 3;
indicatorDiagram.AlarmMsg = "停井";
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram",
indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0,
indicatorDiagram.ToJson().IndentJson());
}
return;
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
logIotModbusPoll.Type = "Get_XAGL_WM1000YXGT_IndicatorDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取采样间隔数据异常！{read.Message}";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;8097", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
indicatorDiagram.Count = 250;
indicatorDiagram.Interval = Math.Round(value * 0.01, 3);
indicatorDiagram.Stroke = Math.Round((60.0 / ((int)indicatorDiagram.Count * (float)indicatorDiagram.Interval)), 2);
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM1000YXGT_IndicatorDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取采样间隔数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
const ushort step = 100;
if (flag && indicatorDiagram.Count <= 300 && indicatorDiagram.Count >= step)
{
const ushort regAddress = 38268; //读取载荷数据
for (ushort i = 0; i < indicatorDiagram.Count && flag; i += step)
{
var itemCount = (i + step > indicatorDiagram.Count) ? (ushort)(indicatorDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
if (value == 0)
{
indicatorDiagram.L.Add(value);
}
else
{
var L = (value - 800) * 150 / 3200.0;
indicatorDiagram.L.Add(Math.Round(L, 2));
}
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM1000YXGT_IndicatorDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " + itemCount.ToString() + $" 个有线功图载荷数据异常!{read.Message}";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
//读取冲程
indicatorDiagram.MaxLoad = Math.Round(indicatorDiagram.L.Max(), 2); //最大载荷
indicatorDiagram.MinLoad = Math.Round(indicatorDiagram.L.Min(), 2); //最小载荷
indicatorDiagram.AvgLoad = Math.Round(indicatorDiagram.L.Average(), 2); //平均载荷
if (indicatorDiagram.D.Count > 0)
{
indicatorDiagram.D.Add(indicatorDiagram.D[0]);
}
if (indicatorDiagram.L.Count > 0)
{
indicatorDiagram.L.Add(indicatorDiagram.L[0]);
}
}
else
{
flag = false;
}
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (flag == true || par.UseMockData)
{
indicatorDiagram.Mock = par.UseMockData;
if (indicatorDiagram.Count != null)
{
indicatorDiagram.D = DisplacementUtils.FitDisplacement((ushort)indicatorDiagram.Count, (double)indicatorDiagram.Displacement);
}
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram", indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, indicatorDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
/// <summary>
/// 读取电表数据
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Get_XAGL_WM2000DB_PowerMeter(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var powerMeter = new IotDataOilWellPowerMeter()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
ClientInfo.LinkId = par.LinkId;
powerMeter.DateTime = DateTime.Now;
powerMeter.WellId = par.DeviceId;
powerMeter.DeviceTypeId = par.DeviceTypeId;
powerMeter.Mock = false;
var flag = true;
#region 判断井状态
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4103", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 3) //1：正转运行；3：变频停机
{
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
powerMeter.AlarmCode = 3;
powerMeter.AlarmMsg = "停井";
}
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取电参井状态数据异常！[{read.Message}]";
$"DB:{par.DeviceName}-{par.DeviceId}{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
#endregion
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 18;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4121", 7);
if (read.IsSuccess)
{
// A相电流 4121 变比 0.01
var value = client.ByteTransform.TransInt16(read.Content, 0);
powerMeter.APhaseCurrent = Math.Round(value * 0.01, 1);
// B相电流 4122 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 2);
powerMeter.BPhaseCurrent = Math.Round(value * 0.01, 1);
// C相电流 4123 变比 0.01
value = client.ByteTransform.TransInt16(read.Content, 4);
powerMeter.CPhaseCurrent = Math.Round(value * 0.01, 1);
// 总功率因素 4124 变比 0.001
value = client.ByteTransform.TransInt16(read.Content, 6);
powerMeter.TotalPowerFactor = Math.Round(value * 0.001, 1);
// A相电压 4125 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 8);
powerMeter.APhaseVoltage = Math.Round(value * 0.1, 1);
// B相电压 4126 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 10);
powerMeter.BPhaseVoltage = Math.Round(value * 0.1, 1);
// C相电压 4127 变比 0.1
value = client.ByteTransform.TransInt16(read.Content, 12);
powerMeter.CPhaseVoltage = Math.Round(value * 0.1, 1);
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取电参数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 8;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4141", 4);
if (read.IsSuccess)
{
var value0 = client.ByteTransform.TransInt16(read.Content, 0);
var value1 = client.ByteTransform.TransInt16(read.Content, 2);
var value2 = client.ByteTransform.TransInt16(read.Content, 4);
var value3 = client.ByteTransform.TransInt16(read.Content, 6);
//这是总有功电能
powerMeter.TotalActivePower = Math.Round(((value1 * 10000 + value0) * 0.001) * 15, 2);
//这是总无功电能
powerMeter.TotalReactivePower = Math.Round(((value3 * 10000 + value2) * 0.001) * 15, 2);
}
else
{
flag = false;
powerMeter.AlarmCode = -1;
powerMeter.AlarmMsg = "数据异常";
powerMeter.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取总有功电能数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
powerMeter.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
$"DB:{par.DeviceName}-{par.DeviceId}已获取到数据".Info();
powerMeter.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_PowerMeter", powerMeter.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:PowerMeter", powerMeter);
redisClient.Set($"Single:OilWell:PowerMeter:{par.DeviceName}-{par.DeviceId}", powerMeter);
}
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, powerMeter.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_PumpPressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var pumpPressure = new IotDataPumpPressure();
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
pumpPressure.DeviceTypeId = par.DeviceTypeId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var flag = true;
try
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 0x02;
}
//偏移地址根据项目待定
var read = await client.ReadAsync($"s={modbusAddress};x=4;10", 1);
if (read.IsSuccess)
{
pumpPressure.PumpId = par.DeviceId; //泵编号
var value = client.ByteTransform.TransInt16(read.Content, 0);
//是否有变比根据项目待定
pumpPressure.PumpPressure = value / 100.0; //泵压
pumpPressure.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
pumpPressure.AlarmCode = -1;
pumpPressure.AlarmMsg = "数据异常";
pumpPressure.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取泵压数据异常！";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag == true || par.UseMockData)
{
pumpPressure.Mock = par.UseMockData;
pumpPressure.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
redisClient.AddItemToList("YCIOT:IOT_Data_PumpPressure", pumpPressure.ToJson().IndentJson());
redisClient.Set($"Group:PumpPressure:{par.DeviceName}-{par.DeviceId}", pumpPressure);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, pumpPressure.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAAS_WII_WaterInjectingInstrument(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterWell = new IotDataWaterWell();
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
//par.ModbusAddress = 1;
var modbusAddress = par.ModbusAddress;
waterWell.DeviceTypeId = par.DeviceTypeId;
ClientInfo.LinkId = par.LinkId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var flag = true;
try
{
if (!par.CommandParameter.IsNullOrEmpty())
{
var parDict = par.CommandParameter.FromJson <Dictionary <long, string> >();
if (parDict != null)
{
var startAddress = (ushort)10;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 0x08;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=4;{startAddress}", 4);
if (read.IsSuccess)
{
var value1 = client.ByteTransform.TransInt16(read.Content, 0);
var value2 = client.ByteTransform.TransInt16(read.Content, 2);
var value3 = client.ByteTransform.TransInt16(read.Content, 4);
var value4 = client.ByteTransform.TransInt16(read.Content, 6);
var v1 = BCDUtils.BCDToUshort((ushort)value1) / 100.0;
var v2 = BCDUtils.BCDToUshort((ushort)value2) / 100.0;
var v3 = BCDUtils.BCDToUshort((ushort)value3) / 100.0;
var v4 = BCDUtils.BCDToUshort((ushort)value4) / 100.0;
double[] values = { v1, v2, v3, v4 };
waterWell.TrunkPressure = values.Max(); //总汇管压力
waterWell.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
waterWell.AlarmCode = -1;
waterWell.AlarmMsg = "数据异常";
waterWell.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
string msg = $"{par.DeviceName}-{par.DeviceId}";
Logger.Warn($"{msg}:读取注水间干压数据异常！[{read.Message}]");
logIotModbusPoll.Result = $"{msg}:读取注水间干压数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
var dic = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
if (dic != null)
{
var slotId = Convert.ToInt32(dic["1"]);
flag = true;
startAddress = (ushort)(14 + 10 * (slotId - 1));
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 0x14 + 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=4;{startAddress}", 11);
if (read.IsSuccess)
{
waterWell.WellId = par.DeviceId; //水井ID
var value = client.ByteTransform.TransInt16(read.Content, 0);
waterWell.ValveStatus = (BCDUtils.BCDToUshort(read.Content[0]) >> 4) & 0x01; //阀门状态
waterWell.ValveMode = (BCDUtils.BCDToUshort(read.Content[0]) >> 1) & 0x01; //阀门工作模式
value = client.ByteTransform.TransInt16(read.Content, 2);
waterWell.SettedFlow = BCDUtils.BCDToUshort((ushort)value) / 100.0; //设定流量回读
value = client.ByteTransform.TransInt16(read.Content, 4);
waterWell.InstantaneousFlow = BCDUtils.BCDToUshort((ushort)value) / 100.0; //瞬时流量
var value1 = client.ByteTransform.TransInt16(read.Content, 6);
var value2 = client.ByteTransform.TransInt16(read.Content, 8);
waterWell.CumulativeFlow = BCDUtils.BCDToUshort((ushort)value1) * 100 + BCDUtils.BCDToUshort((ushort)value2) / 100.0;//表头累计
value = client.ByteTransform.TransInt16(read.Content, 14);
waterWell.TubePressure = BCDUtils.BCDToUshort((ushort)value) / 100.0; //管压
waterWell.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
waterWell.AlarmCode = -1;
waterWell.AlarmMsg = "数据异常";
waterWell.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
string msg = $"{par.DeviceName}-{par.DeviceId}";
Logger.Warn($"{msg}:读取注水井数据异常！[{read.Message}]");
logIotModbusPoll.Result = $"{msg}:读取注水井数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
waterWell.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
waterWell.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_WaterWell", waterWell.ToJson().IndentJson());
redisClient.Set($"Group:WaterWell:{par.DeviceName}-{par.DeviceId}", waterWell);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterWell.ToJson().IndentJson());
}
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_ZJJH_WII_WaterInjectingInstrument(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterWell = new IotDataWaterWell
{
AlarmCode = 0,
AlarmMsg = ""
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
waterWell.DeviceTypeId = par.DeviceTypeId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
try
{
if (!par.CommandParameter.IsNullOrEmpty())
{
var dic = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
if (dic != null)
{
var slotId = Convert.ToInt32(dic["1"]);
var flag = true;
var startAddress = (ushort)(1 + 6 * (slotId - 1));
var read = await client.ReadAsync($"s={modbusAddress};x=4;{startAddress}", 6);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 10);
waterWell.SettedFlow = value / 100.0; //设定流量回读
value = client.ByteTransform.TransInt16(read.Content, 4);
waterWell.InstantaneousFlow = value / 100.0; //瞬时流量
var value3 = client.ByteTransform.TransInt16(read.Content, 6);
var value4 = client.ByteTransform.TransInt16(read.Content, 8);
waterWell.CumulativeFlow = (value3 << 16 + value4) / 100.0;//表头累计
value = client.ByteTransform.TransInt16(read.Content, 0);
waterWell.ValveStatus = value; //阀门状态
value = client.ByteTransform.TransInt16(read.Content, 2);
waterWell.ValveMode = value; //阀门工作模式
waterWell.DateTime = DateTime.Now; //采集时间
//var result1 = await client.ReadHoldingRegisters(modbusAddress, (ushort)(30015 + 6 + 6 * (slotId - 1)), 1);
//waterWell.TubePressure = result1[0].Value / 100.0;//管压
}
else
{
flag = false;
waterWell.AlarmCode = -1;
waterWell.AlarmMsg = "数据异常";
waterWell.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取注水井数据异常！";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
waterWell.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
waterWell.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_WaterWell", waterWell.ToJson().IndentJson());
redisClient.Set($"Group:WaterWell:{par.DeviceName}-{par.DeviceId}", waterWell);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterWell.ToJson().IndentJson());
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
}
}
public static async Task Get_XAAS_WTPM_TrunkPressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterStation = new IotDataWaterStation();
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.LinkId = par.LinkId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
waterStation.DeviceTypeId = par.DeviceTypeId;
var flag = true;
try
{
var startAddress = (ushort)10;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 0x08;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=4;{startAddress}", 4);
if (read.IsSuccess)
{
waterStation.StationId = par.DeviceId; //注水间ID
var value1 = client.ByteTransform.TransInt16(read.Content, 0);
var value2 = client.ByteTransform.TransInt16(read.Content, 2);
var value3 = client.ByteTransform.TransInt16(read.Content, 4);
var value4 = client.ByteTransform.TransInt16(read.Content, 6);
var v1 = BCDUtils.BCDToUshort((ushort)value1) / 100.0;
var v2 = BCDUtils.BCDToUshort((ushort)value2) / 100.0;
var v3 = BCDUtils.BCDToUshort((ushort)value3) / 100.0;
var v4 = BCDUtils.BCDToUshort((ushort)value4) / 100.0;
double[] values = { v1, v2, v3, v4 };
waterStation.TrunkPressure = values.Max(); //总汇管压力
waterStation.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
waterStation.AlarmCode = -1;
waterStation.AlarmMsg = "数据异常";
waterStation.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
string msg = $"{par.DeviceName}-{par.DeviceId}";
Logger.Warn($"{msg}:读取注水间干压数据异常！[{read.Message}]");
logIotModbusPoll.Result = $"{msg}:读取注水间干压数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
waterStation.NetworkNode = ClientInfo.ManyIpAddress;
waterStation.StationId = par.DeviceId;
if (flag == true || par.UseMockData)
{
waterStation.Mock = par.UseMockData;
//用于将读取的结果写入Redis队列
redisClient.AddItemToList("YCIOT:IOT_Data_WaterStation", waterStation.ToJson().IndentJson());
redisClient.Set($"Group:WaterStation:{par.DeviceName}-{par.DeviceId}", waterStation);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterStation.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_WM2000YXGT_IndicatorDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.Mock = false;
var flag = true;
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
if (jo1["0"] != null)
{
indicatorDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
}
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
indicatorDiagram.D = new List <double>(); //位移
indicatorDiagram.L = new List <double>(); //载荷
indicatorDiagram.DateTime = DateTime.Now;
indicatorDiagram.WellId = par.DeviceId;
#region 判断井状态
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4103", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 3) //1：正转运行；3：变频停机
{
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
indicatorDiagram.AlarmCode = 3;
indicatorDiagram.AlarmMsg = "停井";
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"读取功图井状态数据异常！[{read.Message}]";
$"GT:{par.DeviceName}-{par.DeviceId}{logIotModbusPoll.Result}".Info();
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
#endregion
const ushort step = 100;
//ToDo:确认采样间隔和点数
indicatorDiagram.Count = 300;
if (flag && indicatorDiagram.Count <= 300 && indicatorDiagram.Count >= step)
{
ushort regAddress = 38768;//读取载荷数据
for (ushort i = 0; i < indicatorDiagram.Count && flag; i += step)
{
var itemCount = (i + step > indicatorDiagram.Count) ? (ushort)(indicatorDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (!read.IsSuccess)
{
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
}
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
if (value != 0)
{
var Load = (value - 800) * 150 / 3200.0;
indicatorDiagram.L.Add(Math.Round(Load, 2));
}
else
{
indicatorDiagram.L.Add(value);
}
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM2000YXGT_IndicatorDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " + itemCount.ToString() + $" 个有线功图载荷数据异常![{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
regAddress = 37268;//读取位移数据
for (var i = 0; i < indicatorDiagram.Count && flag; i += step)
{
var itemCount = (i + step > indicatorDiagram.Count) ? (ushort)(indicatorDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (!read.IsSuccess)
{
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
}
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j * 2);
var d = (value - 800) * 100 / 3200.0 - 50;
indicatorDiagram.D.Add(Math.Round(d, 2));
}
}
else
{
flag = false;
indicatorDiagram.AlarmCode = -1;
indicatorDiagram.AlarmMsg = "数据异常";
indicatorDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM2000YXGT_IndicatorDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " +
itemCount.ToString() + $" 个有线功图位移数据异常![{read.Message}]";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll",
logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
var maxDis = indicatorDiagram.D.Max();
var minDis = indicatorDiagram.D.Min();
if (!indicatorDiagram.Displacement.HasValue)
{
indicatorDiagram.Displacement = maxDis;
}
for (var i = 0; i < indicatorDiagram.D.Count; i++)
{
if (Math.Abs(maxDis - minDis) > 0.1)
{
indicatorDiagram.D[i] = Math.Round(((indicatorDiagram.D[i] - minDis) / (maxDis - minDis) * (double)indicatorDiagram.Displacement), 2);
}
}
if (indicatorDiagram.D.Count > 0)
{
indicatorDiagram.MaxLoad = Math.Round(indicatorDiagram.L.Max(), 2); //最大载荷
indicatorDiagram.MinLoad = Math.Round(indicatorDiagram.L.Min(), 2); //最小载荷
indicatorDiagram.AvgLoad = Math.Round(indicatorDiagram.L.Average(), 2); //平均载荷
indicatorDiagram.D.Add(indicatorDiagram.D[0]);
indicatorDiagram.L.Add(indicatorDiagram.L[0]);
}
}
else
{
flag = false;
}
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true)
{
$"YXGT:{par.DeviceName}-{par.DeviceId}已获取到数据".Info();
indicatorDiagram.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram", indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, indicatorDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
/// <summary>
/// 获取油压套压
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Get_XAAS_WII_Pressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterWell = new IotDataWaterWell();
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
waterWell.DeviceTypeId = par.DeviceTypeId;
ClientInfo.LinkId = par.LinkId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var flag = true;
try
{
if (!par.CommandParameter.IsNullOrEmpty())
{
var parDict = par.CommandParameter.FromJson <Dictionary <long, string> >();
if (parDict != null)
{
var startAddress = (ushort)30044;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 0x04;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=4;{startAddress}", 2);
if (read.IsSuccess)
{
//油压，默认值：0
var value = client.ByteTransform.TransInt16(read.Content, 0);
//套压，默认值：0
value = client.ByteTransform.TransInt16(read.Content, 2);
waterWell.DateTime = DateTime.Now; //采集时间
}
else
{
flag = false;
waterWell.AlarmCode = -1;
waterWell.AlarmMsg = "数据异常";
waterWell.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
string msg = $"{par.DeviceName}-{par.DeviceId}";
Logger.Warn($"{msg}:读取油压套压数据异常！[{read.Message}]");
logIotModbusPoll.Result = $"{msg}:读取油压套压数据异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
startAddress = 40083;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x04;
ClientInfo.ExpectedDataLen = 16;
}
//读取油压套压系数
read = await client.ReadAsync($"s={par.ModbusAddress};x=4;{startAddress}", 8);
if (read.IsSuccess)
{
waterWell.WellId = par.DeviceId; //水井ID
//油压增益系数,float-ABCD,默认值：0.059
var value1 = client.ByteTransform.TransUInt16(read.Content, 0);
var value2 = client.ByteTransform.TransUInt16(read.Content, 2);
var value = value1 << 16 | value2;
//油压偏移系数，float-ABCD,默认值：786.3
value1 = client.ByteTransform.TransUInt16(read.Content, 4);
value2 = client.ByteTransform.TransUInt16(read.Content, 6);
value = value1 << 16 | value2;
//套压增益系数，float-ABCD,默认值：0.059
value1 = client.ByteTransform.TransUInt16(read.Content, 8);
value2 = client.ByteTransform.TransUInt16(read.Content, 10);
value = value1 << 16 | value2;
//套压偏移系数，float-ABCD,默认值：786.3
value1 = client.ByteTransform.TransUInt16(read.Content, 12);
value2 = client.ByteTransform.TransUInt16(read.Content, 14);
value = value1 << 16 | value2;
}
else
{
flag = false;
waterWell.AlarmCode = -1;
waterWell.AlarmMsg = "数据异常";
waterWell.Mock = par.UseMockData;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
string msg = $"{par.DeviceName}-{par.DeviceId}";
Logger.Warn($"{msg}:读取油压套压系数异常！[{read.Message}]");
logIotModbusPoll.Result = $"{msg}:读取油压套压系数异常！[{read.Message}]";
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
waterWell.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
waterWell.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_WaterWell", waterWell.ToJson().IndentJson());
redisClient.Set($"Group:WaterWell:{par.DeviceName}-{par.DeviceId}", waterWell);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterWell.ToJson().IndentJson());
}
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_XAGL_WM1000DLT_CurrentDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var currentDiagram = new IotDataOilWellCurrentDiagram()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
currentDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
currentDiagram.D = new List <double>(); //位移
currentDiagram.C = new List <double>(); //电流
currentDiagram.DateTime = DateTime.Now;
currentDiagram.WellId = par.DeviceId;
currentDiagram.DeviceTypeId = par.DeviceTypeId;
currentDiagram.Mock = false;
var flag = true;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4117", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 0)
{
currentDiagram.NetworkNode = ClientInfo.ManyIpAddress;
currentDiagram.AlarmCode = 3;
currentDiagram.AlarmMsg = "停井";
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_CurrentDiagram", currentDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:CurrentDiagram", currentDiagram);
redisClient.Set($"Single:OilWell:CurrentDiagram:{par.DeviceName}-{par.DeviceId}", currentDiagram);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0,
currentDiagram.ToJson().IndentJson());
}
return;
}
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取采样间隔数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;8097", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
currentDiagram.Count = 250;
currentDiagram.Interval = Math.Round(value * 0.01, 3);
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
logIotModbusPoll.Type = "Get_XAGL_WM1000DLT_CurrentDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取采样间隔数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
ushort step = 100;
if (flag && currentDiagram.Count <= 300 && currentDiagram.Count >= step)
{
var regAddress = 37768;//读取电流数据
for (ushort i = 0; i < currentDiagram.Count && flag; i += step)
{
var itemCount = (i + step > currentDiagram.Count) ? (ushort)(currentDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j++);
if (value != 0)
{
var C = Math.Round(((value - 800) * 5 / 3200.0) * 15, 2);
currentDiagram.C.Add(C);
}
else
{
currentDiagram.C.Add(value);
}
}
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM1000DLT_CurrentDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " + itemCount.ToString() + " 个电流图电流数据异常!";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
currentDiagram.MaxCurrent = currentDiagram.C.Max(); //最大电流
currentDiagram.MinCurrent = currentDiagram.C.Min(); //最小电流
currentDiagram.AvgCurrent = Math.Round(currentDiagram.C.Average(), 2); //平均电流
}
else
{
flag = false;
}
currentDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
currentDiagram.Mock = par.UseMockData;
if (currentDiagram.Count != null)
{
currentDiagram.D = DisplacementUtils.FitDisplacement((ushort)currentDiagram.Count,
(double)currentDiagram.Displacement);
}
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_CurrentDiagram", currentDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:CurrentDiagram", currentDiagram);
redisClient.Set($"Single:OilWell:CurrentDiagram:{par.DeviceName}-{par.DeviceId}", currentDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, currentDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static async Task Get_DEHUI_LLJ(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequestDeHui>();
try
{
var lLJ = new IotDataOilwellDHMeasure()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
lLJ.DeviceTypeId = par.DeviceTypeId;
lLJ.Mock = false;
ClientInfo.LinkId = par.LinkId;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
lLJ.DateTime = DateTime.Now;
var flag = true;
//计量自动 0地址表示线圈寄存器，读取线圈寄存器，功能码为1
var startAddress = (ushort)(2059 - 1);
flag = await ReadCoil(modbusAddress, startAddress, client, (value) => lLJ.JLZD = value, redisClient, par, lLJ, logIotModbusPoll, "计量自动");
#region 批量按位读取线圈，从切井：002569 到温度保护：002576
if (flag)
{
"从切井自动批量开始读取8个线圈，读到温度保护: ---------------".Info();
startAddress = (ushort)(2569 - 1);
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x01;
ClientInfo.ExpectedDataLen = 1;
}
var readCoil = await client.ReadCoilAsync($"s={modbusAddress};x=1;{startAddress}", 8);
if (readCoil.IsSuccess)
{
//False,False,False,False,True,True,False,True
var values = readCoil.Content;
lLJ.QJZD = values[0]; //切井自动
lLJ.WXAN = values[1]; //维修按钮
//[2]; //定时判断
//[3]; //循井测液
lLJ.SBGYBH = values[4]; //设备高压保护
lLJ.QTBH = values[5]; //气体保护
lLJ.SDBH = values[6]; //湿度保护
lLJ.WDBH = values[7]; //温度保护
}
else
{
FailLog.Write(redisClient, par, lLJ, logIotModbusPoll, "Get_LLJ", "读取切井自动批量异常！");
flag = false;
}
"切井自动批量结束: ---------------".Info();
}
#endregion
//排风机
if (flag)
{
startAddress = (ushort)(1281 - 1);
flag = await ReadCoil(modbusAddress, startAddress, client, (value) => lLJ.PFJ = value, redisClient, par, lLJ, logIotModbusPoll, "排风机");
}
//加热器
if (flag)
{
startAddress = (ushort)(1282 - 1);
flag = await ReadCoil(modbusAddress, startAddress, client, (value) => lLJ.JRQ = value, redisClient, par, lLJ, logIotModbusPoll, "加热器");
}
#region from:进液压力:404097 to:分钟含水:404121
if (flag)
{
startAddress = (ushort)(4097 - 1);
("进液压力开始: ---------------").Info();
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 26 * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=3;{startAddress}", 26);
if (read.IsSuccess)
{
var souce = Tools.CDAB(read.Content, 0);
var value = client.ByteTransform.TransSingle(souce, 0);
lLJ.JYYL = value;
souce = Tools.CDAB(read.Content, 4);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.CYYL = value;
souce = Tools.CDAB(read.Content, 8);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.HJWD = value;
souce = Tools.CDAB(read.Content, 12);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.HJSD = value;
souce = Tools.CDAB(read.Content, 16);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.HJND = value;
souce = Tools.CDAB(read.Content, 20);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.HSWZ = value;
souce = Tools.CDAB(read.Content, 24);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SFFK = value;
souce = Tools.CDAB(read.Content, 28);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.XFFK = value;
souce = Tools.CDAB(read.Content, 32);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.WTF1FK = value;
souce = Tools.CDAB(read.Content, 36);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.WTF2FK = value;
souce = Tools.CDAB(read.Content, 40);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.WTF3FK = value;
souce = Tools.CDAB(read.Content, 44);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.PGWD = value;
souce = Tools.CDAB(read.Content, 48);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.FZHS = value;
}
else
{
FailLog.Write(redisClient, par, lLJ, logIotModbusPoll, "Get_LLJ", "读取进液压力异常！");
flag = false;
}
"进液压力结束: ---------------".Info();
}
#endregion
#region from:累计产液：404505 to:右限液位：404553
if (flag)
{
startAddress = (ushort)(4505 - 1);
"累计产液开始: ---------------".Info();
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 50 * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=3;{startAddress}", 50);
if (read.IsSuccess)
{
var souce = Tools.CDAB(read.Content, 0);
var value = client.ByteTransform.TransSingle(souce, 0);
lLJ.LJCY = value;
souce = Tools.CDAB(read.Content, 4);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.DCRJ = value;
souce = Tools.CDAB(read.Content, 8);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SSCY = value;
souce = Tools.CDAB(read.Content, 12);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SSPJHS = value;
souce = Tools.CDAB(read.Content, 16);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.ZRHS = value;
souce = Tools.CDAB(read.Content, 20);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.YLGX = value;
souce = Tools.CDAB(read.Content, 24);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.ZRCY = value;
souce = Tools.CDAB(read.Content, 28);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.YLDX = value;
var valueInt = client.ByteTransform.TransInt16(read.Content, 32);
lLJ.QYBH = valueInt;
valueInt = client.ByteTransform.TransInt16(read.Content, 34);
lLJ.JLQLX = valueInt;
souce = Tools.CDAB(read.Content, 36);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SFKZ = value;
souce = Tools.CDAB(read.Content, 40);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.XFKZ = value;
valueInt = client.ByteTransform.TransInt16(read.Content, 44);
lLJ.SSYJH = valueInt;
lLJ.WellId = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 46);
lLJ.ZRYJH = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 48);
lLJ.ZRJH = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 50);
lLJ.SSJH = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 52);
lLJ.ZCJS = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 54);
lLJ.SZXS = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 56);
lLJ.SZFZ = valueInt;
//巡井手切小时、分钟没有读
value = client.ByteTransform.TransInt16(read.Content, 62);
lLJ.YCYSSJ = valueInt;
//加热器次数、排风机次数没有读
value = client.ByteTransform.TransInt16(read.Content, 68);
lLJ.ZTMFM = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 70);
lLJ.ZTMJSY = valueInt;
value = client.ByteTransform.TransInt16(read.Content, 72);
lLJ.SZZDQJZQ = valueInt;
//4542预留
souce = Tools.CDAB(read.Content, 76);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.WDDX = value;
souce = Tools.CDAB(read.Content, 80);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.WDGX = value;
souce = Tools.CDAB(read.Content, 84);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.NDDX = value;
souce = Tools.CDAB(read.Content, 88);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.NDGX = value;
souce = Tools.CDAB(read.Content, 92);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.ZXYW = value;
souce = Tools.CDAB(read.Content, 96);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.YXYW = value;
}
else
{
FailLog.Write(redisClient, par, lLJ, logIotModbusPoll, "Get_LLJ", "读取累计产液异常！");
flag = false;
}
"累计产液结束: ---------------".Info();
}
#endregion
#region 湿度高限：404567 to:湿度低限：404569
if (flag)
{
startAddress = (ushort)(4567 - 1);
("湿度高限开始: ---------------").Info();
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 4 * 2;
}
var read = await client.ReadAsync($"s={modbusAddress};x=3;{startAddress}", 4);
if (read.IsSuccess)
{
var souce = Tools.CDAB(read.Content, 0);
var value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SDGX = value;
souce = Tools.CDAB(read.Content, 4);
value = client.ByteTransform.TransSingle(souce, 0);
lLJ.SDDX = value;
}
else
{
flag = false;
FailLog.Write(redisClient, par, lLJ, logIotModbusPoll, "Get_LLJ", "读取湿度高限异常！");
}
"湿度高限结束: ---------------".Info();
}
#endregion
lLJ.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
lLJ.Mock = par.UseMockData;
$"CommandParameter;{par.CommandParameter}".Info();
//根据获取的井映射到实际的井
var wellIdDic = JsonConvert.DeserializeObject <Dictionary <int, int> >(par.CommandParameter);
if (wellIdDic.ContainsKey(lLJ.SSJH))
{
lLJ.WellId = wellIdDic[lLJ.SSJH];
lLJ.StationId = par.StationId;
lLJ.StationName = par.StationName;
lLJ.WellFieldId = par.DeviceId;
lLJ.WellFieldName = par.DeviceName;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_lLJ", lLJ.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{lLJ.WellId}:lLJ", lLJ);
redisClient.Set($"Single:OilWell:lLJ:{lLJ.WellId}", lLJ);
}
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, lLJ.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
