public static void Get_XAGL_WM2000KZG_ControllerStatus_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var iotDataOilWellControllerState = new IotDataOilWellControllerState()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
iotDataOilWellControllerState.WellId = par.DeviceId;
iotDataOilWellControllerState.DeviceTypeId = par.DeviceTypeId;
iotDataOilWellControllerState.DateTime = DateTime.Now;
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);
}
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 void Get_XAGL_WM2000YXGT_IndicatorDiagram_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
indicatorDiagram.WellId = par.DeviceId;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.DateTime = DateTime.Now;
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);
}
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 void Post_XAGL_WM2000KZG_StartWell(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
if (!par.UseMockData)
{
var startAddress = (ushort)4131;
var address = $"s={par.ModbusAddress};{startAddress}";
client.WriteOneRegister(address, (ushort)(1));
}
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "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 Post_XAGL_WM1000KZG_StopWell(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
return;
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
//写入0值到4121(Holding register)寄存器，设置油井的状态为开启。
// var result2 = await client.WriteAsync("4126", 2);
var startAddress = (ushort)4126;
var address = $"s={par.ModbusAddress};{startAddress}";
var result2 = await client.WriteOneRegisterAsync(address, (ushort)(2));
if (result2.IsSuccess)
{
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
}
else
{
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, "error");
}
}
}
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 Post_BJBC_WII_InjectionAllocation(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
try
{
if (!par.CommandParameter.IsNullOrEmpty())
{
var parDict = par.CommandParameter.FromJson <Dictionary <long, double> >();
if (parDict != null)
{
foreach (var item in parDict)
{
var slotId = item.Key;
//30201 原始地址
var startAddress = (ushort)(201 + slotId - 1);
var value = (ushort)(item.Value * 100);
var read = await client.WriteOneRegisterAsync($"s={par.ModbusAddress};{startAddress}", value);
if (read.IsSuccess)
{
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
}
else
{
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, "error");
}
}
}
}
}
}
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_GJL_Pressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
IotDataOilWellPressure oillPress = new IotDataOilWellPressure
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
oillPress.WellId = par.DeviceId;
oillPress.DeviceTypeId = par.DeviceTypeId;
oillPress.Mock = false;
var failed = await SetPressure(redisClient, client, modbusAddress, oillPress, logIotModbusPoll, par);
oillPress.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (!failed || par.UseMockData)
{
oillPress.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_Pressure", oillPress.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:Pressure", oillPress);
redisClient.Set($"Single:OilWell:Pressure:{par.DeviceName}-{par.DeviceId}", oillPress);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, failed ? -2 : 0, oillPress.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_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 void Post_XAAS_WII_StopWell(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
if (!par.UseMockData)
{
//写入82值到40491(Holding register)寄存器，设置油井的状态为停止。
var startAddress = (ushort)40491;
var address = $"s={par.ModbusAddress};{startAddress}";
client.WriteOneRegister(address, (ushort)(82));
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
}
else
{
}
}
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 void Get_XAGL_PumpPressure_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var pumpPressure = new IotDataPumpPressure();
pumpPressure.DeviceTypeId = par.DeviceTypeId;
try
{
pumpPressure.AlarmCode = 0;
pumpPressure.AlarmMsg = "mock数据";
pumpPressure.Mock = par.UseMockData;
pumpPressure.PumpId = par.DeviceId; //泵编号
pumpPressure.Mock = par.UseMockData;
pumpPressure.DateTime = DateTime.Now;
//用于将读取的结果写入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);
}
}
}
/// <summary>
/// 读取配水间干压mock
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
public static void Get_ZJJH_WTPM_TrunkPressure_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterStation = new IotDataWaterStation();
waterStation.DeviceTypeId = par.DeviceTypeId;
try
{
waterStation.AlarmCode = 0;
waterStation.AlarmMsg = "mock数据";
waterStation.StationId = par.DeviceId; //注水间ID
waterStation.Mock = par.UseMockData;
waterStation.Mock = par.UseMockData;
waterStation.DateTime = DateTime.Now;
//用于将读取的结果写入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 POST_LYQH_KZG_controllerstate(ModbusRtuOverTcp client, RedisClient redisClient, string messageString, int state = 1)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
// 0 - 关井，1 - 开井
//写入1值到0x0080(Holding register)寄存器，设置油井的状态为开启或者关闭
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
var slotId = Convert.ToInt32(jo1["1"].ToString());
var startAddress = (ushort)((slotId * 0x100) + 0x0080);
var read = await client.WriteAsync($"s={par.ModbusAddress};{startAddress}", new byte[] { 00, (byte)state, 20, 07, 23, 11, 34, 00 });
if (read.IsSuccess)
{
}
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 void Get_XAGY_WII_WaterInjectingInstrument_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterWell = new IotDataWaterWell
{
AlarmCode = 0,
AlarmMsg = ""
};
try
{
waterWell.AlarmCode = 0;
waterWell.AlarmMsg = "Mock数据";
waterWell.Mock = par.UseMockData;
waterWell.WellId = par.DeviceId;
waterWell.DateTime = DateTime.Now;
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);
}
}
}
/// <summary>
/// 设置冲次
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
/// <returns></returns>
public static async Task Post_XAGL_WM2000KZG_StrokeFrequency(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var stroke = (int)(float.Parse(par.CommandParameter) * 10);
//4132(Holding register)寄存器为47，代表当前设定冲次4.7次。
var startAddress = (ushort)4132;
var address = $"s={par.ModbusAddress};{startAddress}";
await client.WriteOneRegisterAsync(address, (ushort)(stroke));
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "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 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_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);
}
}
}
public static async Task Post_XAGL_WM1000KZG_StartWell(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
return;
try
{
var modbusAddress = par.ModbusAddress;
//var reg = new AMWD.Modbus.Common.Structures.Register
//{
// Address = 4126,
// HiByte = 0,
// LoByte = 1
//};
//（2）写入1值到4121(Holding register)寄存器，设置油井的状态为开启。
// var result2 = await client.WriteAsync("4126", 1);
var startAddress = (ushort)4126;
var address = $"s={par.ModbusAddress};{startAddress}";
var result2 = await client.WriteOneRegisterAsync(address, (ushort)(1));
if (result2.IsSuccess == true)
{
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
}
else
{
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, "error");
}
}
}
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);
}
}
}
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);
}
}
/// <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 void Post_XAGL_WM3000KZG_StopWell(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
/*
* 65 03 10 06 00 01 68 ef
* 65 03 1a 32 00 01 2a f9
* 65 03 10 0a 00 01 a8 ec
* 65 06 10 19 00 06 d4 eb
*/
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
if (!par.UseMockData)
{
//var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4102", 1);
//read = await client.ReadAsync($"s={par.ModbusAddress};x=3;6706", 1);
//（1）读4106(Holding register)寄存器为1表示正转运行，3表示停机状态。
//read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4106", 1);
//写入0值到4121(Holding register)寄存器，设置油井的状态为开启。
//var result2 = await client.WriteAsync($"s={ par.ModbusAddress};x=6;4121", (ushort)(6));
var startaddress = (ushort)4121;
var address = $"s={par.ModbusAddress};{startaddress}";
client.WriteOneRegister(address, (ushort)(6));
//（3）读取4121(Holding register)寄存器，判断状态是否写入。
//var result3 = await client.ReadHoldingRegisters(modbusAddress, 4121, 1);
//（4）读取1283(Input status)寄存器，置位为1表示喇叭正在报警。
//var result4 = await client.ReadHoldingRegisters(modbusAddress, 4102, 1); //1
//（5）读取1537(Holding register)寄存器，读取告警时间长度。
//var result5 = await client.ReadHoldingRegisters(modbusAddress, 6706, 1); //100
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "ok");
}
}
else
{
}
}
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_LYQH_GJL_Tankmeasure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var tankmeasure = new IotDataOilOmeter()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
tankmeasure.DateTime = DateTime.Now;
tankmeasure.OilOmeterId = par.DeviceId;
tankmeasure.DeviceTypeId = par.DeviceTypeId;
tankmeasure.Mock = false;
//从罐Id中获取大罐编号(0-3),此编号是协议中定的
var gId = int.Parse(par.DeviceId.ToString().Last().ToString());
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
var slotId = Convert.ToInt32(jo1["1"].ToString());
var startAddress = (ushort)(slotId * 0x600 + gId * 16);
var isSuccess = await SetGJL(redisClient, client, modbusAddress, startAddress, tankmeasure, logIotModbusPoll, par);
tankmeasure.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (isSuccess || par.UseMockData)
{
tankmeasure.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_WellField_Tankmeasure", tankmeasure.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:Tankmeasure", tankmeasure);
redisClient.Set($"Single:OilWell:Tankmeasure:{par.DeviceName}-{par.DeviceId}", tankmeasure);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, isSuccess ? 0 : -2, tankmeasure.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 POST_LYQH_GJLShiShiCaiJI(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 jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
indicatorDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
var slotId = Convert.ToInt32(jo1["1"].ToString());
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var startAddress = (ushort)((slotId * 0x100) + 0x0030);
var read = await client.WriteAsync($"s={par.ModbusAddress};{startAddress}", new byte[] { 00, 01, 20, 08, 27, 17, 21, 0 });
var flag = true;
if (read.IsSuccess)
{
}
else
{
flag = false;
FailLog.Write(redisClient, par, indicatorDiagram, logIotModbusPoll, "Get_LYQH_WG_IndicatorDiagram", "实时采集异常！");
}
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
indicatorDiagram.Mock = par.UseMockData;
}
//用于通过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);
}
}
}
public static async Task POST_LYQH_GJLSetting(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;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
var startAddress = (ushort)0x5140;
/*
* 仪表类型：0x70
* 仪表编号：2020010002
* modbus地址：240
* modbus槽位：0
* 采集周期：1800
* 液位模式：0
* 校正K: 106
* 零偏B：0
* 井场安装编号：3
* 64位长地址：86 92 50 FE FF 14 2E 84
*/
byte[] macAddress = { 0x86, 0x92, 0x50, 0xFE, 0xFF, 0x14, 0x2E, 0x84 };
var data = GetSettingData(2020010002, 240, 0, 1800, 0, 106, 0, 3, macAddress);
//ushort[] data = { 0x70, 9088, 30748, 1, 1, 400, 0, 0x00, 1, 1, 1, 513, 1027, 1541, 2055 };
var read = await client.WriteAsync($"s={par.ModbusAddress};{startAddress}", data);
var flag = true;
if (read.IsSuccess)
{
}
else
{
flag = false;
FailLog.Write(redisClient, par, indicatorDiagram, logIotModbusPoll, "Get_LYQH_WG_IndicatorDiagram", "实时采集异常！");
}
indicatorDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
indicatorDiagram.Mock = par.UseMockData;
}
//用于通过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);
}
}
}
public static async Task Post_XAGL_WM3000KZG_StrokeFrequency(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
//await client.WriteAsync($"s={ par.ModbusAddress};x=6;7629", (ushort)(1));
var startAddress = (ushort)7629;
var address = $"s={par.ModbusAddress};{startAddress}";
/*
* 65 06 1d cd 00 01 d7 bd
* 65 06 1d ce 00 19 27 b7
* 65 05 08 80 ff 00 87 96
*/
client.WriteOneRegister(address, (ushort)(1));
var stroke = (int)(float.Parse(par.CommandParameter) * 10);
//（1）7630(Holding register)寄存器为47，代表当前设定冲次4.7次。
//await client.WriteAsync($"s={ par.ModbusAddress};x=6;7630", (ushort)(stroke));
startAddress = (ushort)7630;
address = $"s={par.ModbusAddress};{startAddress}";
//
client.WriteOneRegister(address, (ushort)(stroke));
//（2）写2176（Coil status）置位此寄存器。
await client.WriteAsync($"s={ par.ModbusAddress};x=5;2176", true);
//（3）读7627(Holding register)寄存器为47，代表当前设定冲次4.7次。
//var result4 = await client.ReadHoldingRegisters(modbusAddress, 7627, 1);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, "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 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_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_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);
}
}
}
/// <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);
}
}
}
