using HslCommunication;
using HslCommunication.Profinet.Siemens;
using IMCS.CCS.Common.Redis;
using IMCS.CCS.DeviceProtocol;
using IMCS.CCS.Entitys;
using IMCS.CCS.Models.vo;
using IMCS.CCS.Services;
using IMCS_CCS.Model.vo;
using IMCS_CCS.Utils;
using IMCS_CCS.Utils.DeviceProtocol;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using S7.Net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IMCS.CCS.Models;
namespace IMCS.CCS.Service.Impl
{
///
/// 任务调度服务
///
public class TaskJobService : ITaskJobService
{
private readonly IRedisService _redisService;
private readonly IDeviceService _deviceService;
private readonly IApiRequestService _apiRequestService;
private readonly ITaskCallbackService _taskCallbackService;
private readonly ICcsTagValueService _ccsTagValueService;
private readonly IEquipmentMonitorService _equipmentMonitorService;
private readonly IDictionaryService _dictionaryService;
private readonly ICcsActionAddressService _ccsActionAddressService;
private string ecsUrlContext;
private string ecsRootUrlContext;
private string fanucUrlContext;
private string opcuacUrlContext;
private string hdhUrlContext;
private Dictionary syncStatusMap = new Dictionary();
private string LOG_TITLE_OPCUA = "OPCUA采集";
private string LOG_TITLE_S7 = "S7采集";
private string LOG_TITLE_CALLBACK = "回调任务";
private string LOG_TITLE_DEVICE = "设备监控";
private string callback_redis_key = "IMCS_CCS:CallbackTaskList";
private string device_redis_key = "IMCS_CCS:DeviceList";
public IConfiguration Configuration { get; }
public TaskJobService(IRedisService redisService,
ITaskCallbackService taskCallbackService,
IDeviceService deviceService,
IApiRequestService apiRequestService,
ICcsTagValueService ccsTagValueService,
IEquipmentMonitorService equipmentMonitorService,
IDictionaryService dictionaryService,
ICcsActionAddressService ccsActionAddressService,
IConfiguration configuration)
{
_redisService = redisService;
_taskCallbackService = taskCallbackService;
_deviceService = deviceService;
_apiRequestService = apiRequestService;
_ccsTagValueService = ccsTagValueService;
_equipmentMonitorService = equipmentMonitorService;
_dictionaryService = dictionaryService;
_ccsActionAddressService = ccsActionAddressService;
Configuration = configuration;
ecsUrlContext = Configuration.GetConnectionString("ecsUrlContext");
fanucUrlContext = Configuration.GetConnectionString("fanucUrlContext");
opcuacUrlContext = Configuration.GetConnectionString("opcuacUrlContext");
hdhUrlContext = Configuration.GetConnectionString("hdhUrlContext");
ecsRootUrlContext = Configuration.GetConnectionString("ecsRootUrlContext");
syncStatusMap.Add("离线", 0);
syncStatusMap.Add("空闲", 1);
syncStatusMap.Add("生产中", 2);
syncStatusMap.Add("报警", 3);
//在线状态默认传参后台空闲状态
syncStatusMap.Add("在线", 1);
}
///
/// 采集数据OPCUA
///
///
public async Task DataCollectOPCUAJob()
{
try
{
List deviceList = new List();
var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
if (deviceListData.IsNullOrEmpty)
{
deviceList = _deviceService.GetDeviceList();
await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
}
else
{
deviceList = JsonConvert.DeserializeObject>(deviceListData);
}
deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString())).ToList();
foreach (Device device in deviceList)
{
List tagValues = new List();
string redis_key = "IMCS_CCS:" + device.Ip + ":" + device.ProtocolType;
var data = await _redisService.Database.StringGetAsync(redis_key);
if (data.IsNullOrEmpty)
{
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = device.ProtocolType;
tagQuery.Ip = device.Ip;
tagValues = _ccsTagValueService.GetList(tagQuery);
//首次设置redis
if (tagValues != null && tagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
}
else
{
tagValues = JsonConvert.DeserializeObject>(data);
}
if (tagValues != null && tagValues.Count > 0)
{
List changTagValues = new List();
List addresses = new List();
foreach (CcsTagValue tagValue in tagValues)
{
addresses.Add(tagValue.Address);
}
//调用opcua是否连接接口
RequestOpcUaData opcUaReq = new RequestOpcUaData();
opcUaReq.ServerUrl = device.ServerUrl;
opcUaReq.UserName = device.UserName;
opcUaReq.Password = device.Password;
opcUaReq.Type = OpcUaActionTypeEnum.Read.ToString();
opcUaReq.Addresses = addresses;
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject(Result.Message);
if (!Result.IsSuccess || !responseOpcUaData.result)
{
device.State = false;
await _deviceService.UpdateDevice(device);
Log.Instance.WriteLogAdd("OpcUA采集异常,连不上设备", LOG_TITLE_OPCUA);
return "采集失败，连不上设备";
}
List values = responseOpcUaData.values;
if (values != null)
{
for (int i = 0; i < tagValues.Count; i++)
{
CcsTagValue tagValueData = (CcsTagValue)tagValues[i];
//科学计数法转换
if (values[i].Contains("E") && tagValueData.Type == TagValueReadTypeEnum.Double.ToString())
{
Decimal d = ChangeToDecimal(values[i]);
values[i] = d.ToString();
}
if (tagValueData.TagValue != values[i])
{
tagValueData.TagValue = values[i];
tagValueData.UpdateTime = DateTime.Now;
changTagValues.Add(tagValueData);
Log.Instance.WriteLogAdd("OpcUA采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_OPCUA);
//有变化更新数据库
await _ccsTagValueService.Update(tagValueData);
}
}
}
//值有变化，重新设置一次redis
if (changTagValues != null && changTagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = device.ProtocolType;
tagQuery.Ip = device.Ip;
tagValues = _ccsTagValueService.GetList(tagQuery);
//机床复位
CcsTagValue tagValue1 = tagValues.Where(t => t.Address == "ns=2;s=/Plc/M1500.2").FirstOrDefault();
CcsTagValue tagValue2 = tagValues.Where(t => t.Address == "ns=2;s=/Plc/M1500.4").FirstOrDefault();
if (tagValue1.TagValue == "True" && tagValue2.TagValue == "True")
{
opcUaReq.Addresses = new List() { "ns=2;s=/Plc/M1999.1" };
opcUaReq.Values = new List() { "False" };
opcUaReq.Type = OpcUaActionTypeEnum.Write.ToString();
await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
}
}
else
{
Log.Instance.WriteLogAdd("OpcUA采集异常,没有采集数据===", LOG_TITLE_OPCUA);
return "没有采集数据";
}
}
return "OpcUA采集成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("OpcUA采集异常===>>" + ex.Message, LOG_TITLE_OPCUA);
return "OpcUA采集失败";
}
}
///
/// 采集数据S7
///
///
public async Task DataCollectS7Job()
{
try
{
List deviceList = new List();
var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
if (deviceListData.IsNullOrEmpty)
{
deviceList = _deviceService.GetDeviceList();
await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
}
else
{
deviceList = JsonConvert.DeserializeObject>(deviceListData);
}
deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString())).ToList();
foreach (Device device in deviceList)
{
List tagValues = new List();
string redis_key = "IMCS_CCS:" + device.Ip + ":" + device.ProtocolType;
var data = await _redisService.Database.StringGetAsync(redis_key);
if (data.IsNullOrEmpty)
{
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = device.ProtocolType;
tagQuery.Ip = device.Ip;
tagValues = _ccsTagValueService.GetList(tagQuery);
//首次设置redis
if (tagValues != null && tagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
}
else
{
tagValues = JsonConvert.DeserializeObject>(data);
}
if (tagValues != null && tagValues.Count > 0)
{
tagValues = JsonConvert.DeserializeObject>(data);
List changTagValues = new List();
//Plc s7 = DevicePlcS7.S7(device.ServerUrl, ProtocalTypeEnum.S7_1500.ToString());
SiemensS7Net s7 = DevicePlcS7.SiemensS7(device.ServerUrl);
OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
device.State = false;
await _deviceService.UpdateDevice(device);
s7.ConnectClose();
Log.Instance.WriteLogAdd("S7采集异常,plc连不上", LOG_TITLE_S7);
return "采集失败，plc连不上";
}
else
{
foreach (CcsTagValue tagValueData in tagValues)
{
//string Address = ToolUtils.AddressConvertDBW(tagValueData.Address);
//var operateResult = ((ushort)s7.Read(Address)).ConvertToShort();
string operateResult = "";
if (tagValueData.Type.Equals(TagValueReadTypeEnum.BOOL.ToString()))
{
operateResult = s7.ReadBool(tagValueData.Address).Content.ToString();
}
else if (tagValueData.Type.Equals(TagValueReadTypeEnum.SHORT.ToString()))
{
operateResult = s7.ReadInt16(tagValueData.Address).Content.ToString();
}
else if (tagValueData.Type.Equals(TagValueReadTypeEnum.String.ToString()))
{
operateResult = s7.ReadString(tagValueData.Address).Content.ToString();
}
if (!string.IsNullOrEmpty(operateResult) && tagValueData.TagValue != operateResult)
{
tagValueData.TagValue = operateResult.ToString();
tagValueData.UpdateTime = DateTime.Now;
changTagValues.Add(tagValueData);
Log.Instance.WriteLogAdd("S7采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
//有变化更新数据库
await _ccsTagValueService.Update(tagValueData);
}
Thread.Sleep(50);
}
s7.ConnectClose();
//值有变化，重新设置一次redis
if (changTagValues != null && changTagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
}
}
}
return "S7采集成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("S7采集异常===>>" + ex.Message, LOG_TITLE_S7);
return "S7采集失败";
}
}
///
/// 采集数据FANUC
///
///
public async Task DataCollectFanucJob()
{
try
{
List deviceList = new List();
var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
if (deviceListData.IsNullOrEmpty)
{
deviceList = _deviceService.GetDeviceList();
await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
}
else
{
deviceList = JsonConvert.DeserializeObject>(deviceListData);
}
deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString())).ToList();
foreach (Device device in deviceList)
{
List tagValues = new List();
string redis_key = "IMCS_CCS:" + device.Ip + ":" + device.ProtocolType;
var data = await _redisService.Database.StringGetAsync(redis_key);
if (data.IsNullOrEmpty)
{
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = device.ProtocolType;
tagQuery.Ip = device.Ip;
tagValues = _ccsTagValueService.GetList(tagQuery);
//首次设置redis
if (tagValues != null && tagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
}
else
{
tagValues = JsonConvert.DeserializeObject>(data);
}
if (tagValues != null && tagValues.Count > 0)
{
tagValues = JsonConvert.DeserializeObject>(data);
List changTagValues = new List();
string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
//调用发那科是否连接接口
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=Connect", null, null);
if (!Result.IsSuccess || Result.Message != "0")
{
device.State = false;
await _deviceService.UpdateDevice(device);
Log.Instance.WriteLogAdd("FANUC采集异常,FANUC连不上", LOG_TITLE_S7);
return "采集失败，FANUC连不上";
}
else
{
//调用发那科采集接口
Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=All", null, null);
ResponseFanucData fanucData = JsonConvert.DeserializeObject(Result.Message);
foreach (CcsTagValue tagValueData in tagValues)
{
string operateResult = GetFanucValue(fanucData, tagValueData.Address);
if (tagValueData.TagValue != operateResult)
{
tagValueData.TagValue = operateResult.ToString();
tagValueData.UpdateTime = DateTime.Now;
changTagValues.Add(tagValueData);
Log.Instance.WriteLogAdd("FANUC采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
//有变化更新数据库
await _ccsTagValueService.Update(tagValueData);
}
Thread.Sleep(50);
}
//值有变化，重新设置一次redis
if (changTagValues != null && changTagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
}
}
}
}
return "FANUC采集成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("FANUC采集异常===>>" + ex.Message, LOG_TITLE_S7);
return "FANUC采集失败";
}
}
///
/// 上传程序回调任务
///
///
public async Task CallbackJob1()
{
List list = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
list = await _taskCallbackService.GetAllList();
}
else
{
list = JsonConvert.DeserializeObject>(taskCallbackListData);
}
list = list.Where(x => x.OperateType.Equals(ActionTypeEnum.UploadFile.ToString())).ToList();
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
if (currentTime.Subtract(task.CreateTime).TotalSeconds > 5)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 柔性产线,伺服等取和放回调任务
///
///
public async Task CallbackJob2()
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = _deviceService.GetDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.GetFlexibleWire.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendFlexibleWire.ToString())
|| x.OperateType.Equals(ActionTypeEnum.MoveRobotPosition.ToString())
|| x.OperateType.Equals(ActionTypeEnum.GetIntelligenceUnit.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendIntelligenceUnit.ToString())
|| x.OperateType.Equals(ActionTypeEnum.GetQualityCenter.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendQualityCenter.ToString())
|| x.OperateType.Equals(ActionTypeEnum.GetServoStacker.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendServoStacker.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendLinShift.ToString())
|| x.OperateType.Equals(ActionTypeEnum.SendLinShiftFine.ToString())).ToList();
List list = new List();
foreach (Device device in deviceList)
{
foreach (TaskCallback task in taskList)
{
if (task.IP.Equals(device.Ip))
{
list.Add(task);
}
}
}
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
//tagValueQuery.Address = task.Address;
List tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
CcsTagValue callBacktagValue = tagValues.Where(o=>o.Address == task.Address).FirstOrDefault();
if (callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
//回调检测到失败，回调通知ecs
if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
{
bool failFalg = false;
if (!string.IsNullOrEmpty(task.FailAddress))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress2))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress3))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (failFalg)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
requestData.code = "0";
requestData.msg = "操作失败";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
if (result.IsSuccess)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
}
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 打标机回调任务
///
///
public async Task CallbackJob3()
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = _deviceService.GetDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartLabelMachine.ToString())).ToList();
List list = new List();
foreach (Device device in deviceList)
{
foreach (TaskCallback task in taskList)
{
if (task.IP.Equals(device.Ip))
{
list.Add(task);
}
}
}
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
List tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
CcsTagValue callBacktagValue = tagValues.Where(o=>o.Address == task.Address).FirstOrDefault();
CcsTagValue callBacktagValue2 = tagValues.Where(o => o.Address == task.Address2).FirstOrDefault();
if (callBacktagValue != null && callBacktagValue2 != null && callBacktagValue.TagValue == task.CallbackValue && callBacktagValue2.TagValue == task.CallbackValue2)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
if (!string.IsNullOrEmpty(task.SuccessResetAddress))
{
Plc s7 = DevicePlcS7.S7(task.IP, ProtocalTypeEnum.S7_1500.ToString());
if (s7.IsConnected == true)
{
string ResetAddress = ToolUtils.AddressConvertDBW(task.SuccessResetAddress);
//short mc = 0;
short mc = (short)int.Parse(task.SuccessResetValue);
s7.Write(ResetAddress, mc);
s7.Close();
}
}
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
}
}
//回调检测到失败，回调通知ecs
if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
{
bool failFalg = false;
if (!string.IsNullOrEmpty(task.FailAddress))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress2))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress3))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (failFalg)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
requestData.code = "0";
requestData.msg = "操作失败";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 启动机床程序回调任务
///
///
public async Task CallbackJob4()
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = _deviceService.GetDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartNCProgram.ToString())).ToList();
List list = new List();
foreach (Device device in deviceList)
{
foreach (TaskCallback task in taskList)
{
if (task.IP.Equals(device.Ip))
{
list.Add(task);
}
}
}
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
//tagValueQuery.Address = task.Address;
List tagValues = _ccsTagValueService.GetList(tagValueQuery);
CcsTagValue tagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault() ;
if (tagValue != null && tagValue.TagValue == task.CallbackValue)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
//回调检测到失败，回调通知ecs
if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
{
bool failFalg = false;
if (!string.IsNullOrEmpty(task.FailAddress))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress2))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress3))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (failFalg)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
requestData.code = "0";
requestData.msg = "操作失败";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 启动清洗机回调任务
///
///
public async Task CallbackJob5()
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = _deviceService.GetDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartCleanMachine.ToString())).ToList();
List list = new List();
foreach (Device device in deviceList)
{
foreach (TaskCallback task in taskList)
{
if (task.IP.Equals(device.Ip))
{
list.Add(task);
}
}
}
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
//tagValueQuery.Address = task.Address;
List tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
CcsTagValue tagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();
if (tagValue != null && tagValue.TagValue == task.CallbackValue)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
//回调检测到失败，回调通知ecs
if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
{
bool failFalg = false;
if (!string.IsNullOrEmpty(task.FailAddress))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress2))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress3))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (failFalg)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
requestData.code = "0";
requestData.msg = "操作失败";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 放三坐标回调任务
///
///
public async Task CallbackJob6()
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = _deviceService.GetDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.SendThreeCoordinates.ToString())).ToList();
List list = new List();
foreach (Device device in deviceList)
{
foreach (TaskCallback task in taskList)
{
if (task.IP.Equals(device.Ip))
{
list.Add(task);
}
}
}
string message = "";
try
{
foreach (TaskCallback task in list)
{
DateTime currentTime = DateTime.Now;
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
List tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
CcsTagValue tagValue = tagValues.Where(o=>o.Address == task.Address).FirstOrDefault();
//点位放在描述里判断左中右
string pos = task.Description;
string posValue = "";
int key = 0;
if (pos == "L")
{
posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.L);
key = (int)ThreeCoordinatesPosEnum.L;
}
else if (pos == "M")
{
posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.M);
key = (int)ThreeCoordinatesPosEnum.M;
}
else if (pos == "R")
{
posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.R);
key = (int)ThreeCoordinatesPosEnum.R;
}
CcsTagValue tagValue2 = tagValues.Where(o => o.Address == posValue && o.TagValue != "0").FirstOrDefault();
if (tagValue != null && tagValue2 != null && (tagValue.TagValue == task.CallbackValue ))
{
CallBackThreeCoordinatesRequestData requestData = new CallBackThreeCoordinatesRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
//查询三坐标已测量工件id和工位
SiemensS7Net s7 = DevicePlcS7.SiemensS7(task.IP);
HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
s7.ConnectClose();
Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "放三坐标异常===>>" + "PLC连接不上",
EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
}
/* CcsActionAddress actionAddressQuery = new CcsActionAddress();
actionAddressQuery.Type = "CALLBACK_CHECK_COOR";
List CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
CcsActionAddress freeActionAdress = new CcsActionAddress();
//查询空闲位置
List CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
{
if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
{
var operateResult = s7.ReadInt16(actionAddress.Address);
if (operateResult.ToString() == actionAddress.Value)
{
freeActionAdress = actionAddress;
break;
}
}
}
//判断是否可取滑台
if (freeActionAdress != null)
{*/
//根据sort顺序,查询左中右可取位置,写入地址列表
CcsActionAddress actionAddressGet = new CcsActionAddress();
actionAddressGet.Type = "CALLBACK_GET_COOR";
actionAddressGet.Sort = key;
List GetCcsActionAddresses = _ccsActionAddressService.GetList(actionAddressGet);
//赋值测量结果
requestData.result = tagValue2.TagValue;
//根据工件id确认哪个位置已测量,赋值工位id
string srcWorkId = task.CallbackFailValue3; //原工件id
var workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.L));
if(workIdResult.ToString() == srcWorkId)
{
requestData.stationId = "L";
}
if (string.IsNullOrEmpty(requestData.stationId))
{
workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.M));
if (workIdResult.ToString() == srcWorkId)
{
requestData.stationId = "M";
}
}
if (string.IsNullOrEmpty(requestData.stationId))
{
workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.R));
if (workIdResult.ToString() == srcWorkId)
{
requestData.stationId = "R";
}
}
foreach (CcsActionAddress actionAddress in GetCcsActionAddresses)
{
if (!string.IsNullOrEmpty(actionAddress.Address))
{
if (actionAddress.Value == "workId")
{
var operateResult = s7.ReadString(actionAddress.Address);
requestData.workId = operateResult.ToString();
}
else if (actionAddress.Value == "procedureNo")
{
var operateResult = s7.ReadString(actionAddress.Address);
requestData.procedureNo = operateResult.ToString();
}
else if (actionAddress.Value == "workProgramName")
{
var operateResult = s7.ReadString(actionAddress.Address);
requestData.workProgramName = operateResult.ToString();
}
}
}
// }
s7.ConnectClose();
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
//回调检测到失败，回调通知ecs
if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
{
bool failFalg = false;
if (!string.IsNullOrEmpty(task.FailAddress))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress && o.TagValue == task.CallbackFailValue).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress2))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress2 && o.TagValue == task.CallbackFailValue2).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (!string.IsNullOrEmpty(task.FailAddress3))
{
List FailCallbackTagValues = tagValues.Where(o => o.Address == task.FailAddress3 && o.TagValue == task.CallbackFailValue3).ToList();
if (FailCallbackTagValues != null && FailCallbackTagValues.Count > 0)
{
failFalg = true;
}
}
if (failFalg)
{
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
requestData.code = "0";
requestData.msg = "操作失败";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if (result.IsSuccess && responseECSCallback.code == 0)
{
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
}
else
{
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(result), LOG_TITLE_CALLBACK);
}
}
}
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 监控设备状态
///
///
public async Task MonitorEquipmentStatusJob()
{
try
{
string message = "MonitorEquipmentStatusJob调度成功";
List devices = new List() ;
string device_redis_key = "IMCS_CCS:DeviceList";
var deviceData = await _redisService.Database.StringGetAsync(device_redis_key);
if (deviceData.IsNullOrEmpty)
{
devices = _deviceService.GetDeviceList();
}
else
{
devices = JsonConvert.DeserializeObject>(deviceData);
}
//ftp不监控
devices = devices.Where(x => !x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString()) && x.State).ToList();
CcsTagValue tagQuery = new CcsTagValue();
List tagValues = _ccsTagValueService.GetList(tagQuery);
List equipmentMonitors = new List();
string redis_key = "IMCS_CCS:MonitorEquipmentStatusJob";
var data = await _redisService.Database.StringGetAsync(redis_key);
if (data.IsNullOrEmpty)
{
equipmentMonitors = await _equipmentMonitorService.GetList();
//首次设置redis
if (tagValues != null && tagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(equipmentMonitors));
}
}
else
{
equipmentMonitors = JsonConvert.DeserializeObject>(data);
}
//变化的设备
List changeEquipmentMonitors = new List();
foreach (EquipmentMonitor equipment in equipmentMonitors)
{
Device device = devices.Where(x => x.Ip.Equals(equipment.IP)).FirstOrDefault();
if (device == null)
{
if(equipment.Status != "离线")
{
equipment.Status = "离线";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
else if (equipment.Name == "机械手")
{
CcsTagValue ccsTagValue = tagValues.Where(x => x.Ip.Equals(equipment.IP) && x.Address.Equals(equipment.Address)).FirstOrDefault();
if (ccsTagValue != null)
{
if (ccsTagValue.TagValue == "3")
{
if (equipment.Status != "报警")
{
equipment.Status = "报警";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
}
CcsTagValue ccsTagValue2 = tagValues.Where(x => x.Ip.Equals(equipment.IP) && x.Address.Equals(equipment.Address2)).FirstOrDefault();
if (ccsTagValue2 != null)
{
if (ccsTagValue2.TagValue == "9")
{
if (equipment.Status != "报警")
{
equipment.Status = "报警";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
}
if (ccsTagValue2.TagValue == "0" || ccsTagValue2.TagValue == "3" || ccsTagValue2.TagValue == "6" || ccsTagValue2.TagValue == "8")
{
if (equipment.Status != "空闲")
{
equipment.Status = "空闲";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
if (equipment.Status != "生产中")
{
equipment.Status = "生产中";
changeEquipmentMonitors.Add(equipment);
}
}
else
{
if (equipment.Status != "在线")
{
equipment.Status = "在线";
changeEquipmentMonitors.Add(equipment);
}
}
}
//变化的修改 并且更新缓存
if(changeEquipmentMonitors.Count > 0)
{
List productionStatusList = new List();
foreach (EquipmentMonitor changeEquipment in changeEquipmentMonitors)
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = changeEquipment.Id.ToString();
productionStatus.onlineStatus = syncStatusMap[changeEquipment.Status].ToString();
//equipment.Status == "离线" ? "0" : "1";
//productionStatus.alertMsg = equipment.AlertMsg;
if (productionStatus.onlineStatus !="3" && !string.IsNullOrEmpty(changeEquipment.Type))
{
if(changeEquipment.Type == "HEIDEHAIN")
{
RequestHeidhData hdhReq = new RequestHeidhData();
Device device = devices.Where(x => x.Ip.Equals(changeEquipment.IP)).FirstOrDefault();
hdhReq.ServerUrl = device.ServerUrl;
hdhReq.MachineName = device.UserName;
hdhReq.Type = OpcUaActionTypeEnum.Connect.ToString();
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
if (Result.IsSuccess)
{
ResponseHeidhData responseData = JsonConvert.DeserializeObject(Result.Message);
if (!string.IsNullOrEmpty(responseData.errorsInfo))
{
productionStatus.alertMsg = responseData.errorsInfo;
}
}
}
else if(changeEquipment.Type == "FANUC")
{
Device device = devices.Where(x => x.Ip.Equals(changeEquipment.IP)).FirstOrDefault();
string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
//调用发那科接口
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=AlmInfo", null, null);
if (Result.IsSuccess)
{
ResponseFanucData fncReq = new ResponseFanucData();
fncReq = JsonConvert.DeserializeObject(Result.Message);
List AlmMsg = fncReq.AlmMsg;
if (AlmMsg!=null && AlmMsg.Count>0)
{
var msgs = from o in AlmMsg select o.msg;
productionStatus.alertMsg = string.Join(",", msgs.ToArray());
}
}
}
}
else
{
//获取机械手报警信息
CcsTagValue plcWarnValue = tagValues.Where(x => x.Ip.Equals(changeEquipment.IP) && x.Address.Equals("DB200.34")).FirstOrDefault();
if (plcWarnValue != null)
{
ToolDto ccsDictionary = new ToolDto();
ccsDictionary.Type = "PlcWarnInfo";
List dictList = await _dictionaryService.GetList(ccsDictionary);
if (dictList.Count > 0 && dictList[0] != null)
{
ToolDto dictObj = dictList.Where(x => x.Code.Equals(plcWarnValue.TagValue) && x.state).FirstOrDefault();
if (!string.IsNullOrEmpty(dictObj.DictValue.Trim()))
{
productionStatus.alertMsg = dictObj.DictValue.Trim();
}
}
}
}
productionStatusList.Add(productionStatus);
await _equipmentMonitorService.Update(changeEquipment);
}
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(equipmentMonitors));
//主动推送同步状态数据接口
RequestSynStatusData requestData = new RequestSynStatusData();
requestData.productionStatus = JsonConvert.SerializeObject(productionStatusList);
String synStatusUrl = ecsRootUrlContext + "api/authority/synStatus/synProductionStatus";
var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, synStatusUrl, requestData, null);
//解析回调数据结果
ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject(result.Message);
if(responseECSCallback!=null && responseECSCallback.code == 0)
{
Log.Instance.WriteLogAdd("同步设备状态成功", LOG_TITLE_CALLBACK);
}
else
{
Log.Instance.WriteLogAdd("同步设备状态操作失败:" + responseECSCallback.msg, LOG_TITLE_CALLBACK);
}
}
return message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("MonitorEquipmentStatusJob:" + ex.Message, LOG_TITLE_DEVICE);
return "MonitorEquipmentStatusJob : " + ex.Message;
}
}
///
/// 监控设备状态
///
///
public async Task DeviceStatusJob()
{
try
{
string message = "";
List devices = new List();
List changeDevices = new List();
string redis_key = "IMCS_CCS:DeviceList";
var data = await _redisService.Database.StringGetAsync(redis_key);
if (data.IsNullOrEmpty)
{
devices = _deviceService.GetDeviceAllList();
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(devices));
}
else
{
devices = JsonConvert.DeserializeObject>(data);
}
//ftp不监控
devices = devices.Where(x => !x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).ToList();
foreach (Device device in devices)
{
if (device.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()))
{
try
{
Plc s7 = DevicePlcS7.S7(device.ServerUrl, ProtocalTypeEnum.S7_1500.ToString());
if (s7.IsConnected != true)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
device.State = false;
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
}
s7.Close();
Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
message = message + ",plc连接失败,或已离线，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
continue;
}
else
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (!oldDevice.State)
{
device.State = true;
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
}
s7.Close();
Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
message = message + ",plc连接成功，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
continue;
}
}
catch (Exception s7ex)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
device.State = false;
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
}
Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
message = message + ",plc连接失败，plc连不上" + s7ex.Message + "，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
}
}
else if (device.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString()))
{
try
{
//调用opcua是否连接接口
RequestOpcUaData opcUaReq = new RequestOpcUaData();
opcUaReq.ServerUrl = device.ServerUrl;
opcUaReq.UserName = device.UserName;
opcUaReq.Password = device.Password;
opcUaReq.Type = OpcUaActionTypeEnum.Connect.ToString();
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject(Result.Message);
if (!Result.IsSuccess || !responseOpcUaData.result)
{
device.State = false;
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
}
Log.Instance.WriteLogAdd("OPCUA连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
message = message + ",OPCUA连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
continue;
}
else
{
device.State = true;
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
Log.Instance.WriteLogAdd("OPCUA连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
}
catch (Exception opcex)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
device.State = false;
await _deviceService.UpdateDevice(device);
changeDevices.Add(device);
}
Log.Instance.WriteLogAdd("OPCUA连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
}
else if (device.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString()))
{
try
{
string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
//调用发那科是否连接接口
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=Connect", null, null);
if (Result.IsSuccess && Result.Message == "0")
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (!oldDevice.State)
{
oldDevice.State = true;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("Fanuc连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
else
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
oldDevice.State = false;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("Fanuc连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
message = message + ",Fanuc连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
continue;
}
}
catch (Exception opcex)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
oldDevice.State = false;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("Fanuc连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
}
else if (device.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString()))
{
try
{
RequestHeidhData hdhReq = new RequestHeidhData();
hdhReq.ServerUrl = device.ServerUrl;
hdhReq.MachineName = device.UserName;
hdhReq.Type = OpcUaActionTypeEnum.Connect.ToString();
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
ResponseHeidhData responseData = JsonConvert.DeserializeObject(Result.Message);
if (!Result.IsSuccess || !responseData.result)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
oldDevice.State = false;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("海德汉连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
message = message + ",海德汉连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
continue;
}
else
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (!oldDevice.State)
{
oldDevice.State = true;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("海德汉连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
}
catch (Exception opcex)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice.State)
{
oldDevice.State = false;
await _deviceService.UpdateDevice(oldDevice);
changeDevices.Add(oldDevice);
}
Log.Instance.WriteLogAdd("Fanuc连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
continue;
}
}
}
if(changeDevices != null)
{
await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(devices));
}
return message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("设备连接异常,或以离线" + ex.Message, LOG_TITLE_DEVICE);
return "设备连接异常,或以离线" + ex.Message;
}
}
///
/// fanuc根据类型获取值
///
///
private string GetFanucValue(ResponseFanucData fanucData, string address)
{
string value = "";
if (address == FanucAddressEnum.MainProg.ToString())
{
value = fanucData.MainProg;
}
else if (address == FanucAddressEnum.Status.ToString())
{
value = fanucData.Status;
}
else if (address == FanucAddressEnum.PowerOnTime.ToString())
{
value = fanucData.PowerOnTime;
}
else if (address == FanucAddressEnum.ActSpindle.ToString())
{
value = fanucData.ActSpindle;
}
return value;
}
///
/// 数字科学计数法处理
///
///
///
private Decimal ChangeToDecimal(string strData)
{
Decimal dData = 0.0M;
if (strData.Contains("E"))
{
dData = Convert.ToDecimal(Decimal.Parse(strData.ToString(), System.Globalization.NumberStyles.Float));
}
else
{
dData = Convert.ToDecimal(strData);
}
return dData;
}
}
}