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 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;
using System.Net.NetworkInformation;
using IMCS_CCS.Model;
using MySqlX.XDevAPI.Common;
using Microsoft.AspNetCore.Mvc;
using Org.BouncyCastle.Ocsp;
using System.Text;
using IMCS.CCS.Entitys.Dto;
using System.IO.Pipelines;
using Microsoft.IdentityModel.Tokens;
using StackExchange.Redis;
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 Dictionary jcAddressDict = new Dictionary();
private Dictionary jcIpDict = new Dictionary();
private string LOG_TITLE_OPCUA = "OPCUA采集";
private string LOG_TITLE_FUNC = "发那科采集";
private string LOG_TITLE_HEIDEHAIN = "海德汉采集";
private string LOG_TITLE_S7 = "S7采集";
private string LOG_TITLE_CALLBACK = "回调任务";
private string LOG_TITLE_DEVICE = "设备监控";
private string LOG_HEART_PLC = "PLC心跳";
private string PLC_ALARM_INFO = "PLC有异常";
private string imcs_redis_key = "IMCS_CCS:";
private string RFID = "RFID:";
private string LOG_RESOURCE_STATE = "设备状态";
private static List sList = new List();
private static List jList = new List();
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);
syncStatusMap.Add("掉线", -1);
if(sList.Count == 0)
{
sList.Add("201");
sList.Add("202");
}
if (jList.Count == 0)
{
jList.Add("1");
jList.Add("2");
jList.Add("3");
}
}
///
/// 采集数据S7
///
///
public async Task DataCollectS7Job()
{
try
{
List deviceList = await getDeviceList();
deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()) && x.State).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连不上==>"+ device.ServerUrl, LOG_TITLE_S7);
return "采集失败，plc连不上";
}
else
{
foreach (CcsTagValue tagValueData in tagValues)
{
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();
}
else if (tagValueData.Type.Equals(TagValueReadTypeEnum.Array.ToString()))
{
operateResult = ToolUtils.ReturnStringByBytes(s7.Read(tagValueData.Address,2048).Content);
}
if (!string.IsNullOrEmpty(operateResult) && tagValueData.TagValue != operateResult)
{
if(tagValueData.Address == "DB1.20")
{
continue;
}
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));
}
//存储采集数据
CollectDataLog.Instance.WriteLogAdd(data, LOG_TITLE_S7);
}
}
}
return "S7采集成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("S7采集异常===>>" + ex.Message, LOG_TITLE_S7);
return "S7采集失败";
}
}
///
/// 采集数据HEIDEHAIN
///
///
public async Task DataCollectHeidehainJob()
{
try
{
List deviceList = await getDeviceList();
deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString()) && x.State).ToList();
foreach (Device device in deviceList)
{
RequestHeidhData hdhReq = new RequestHeidhData();
hdhReq.ServerUrl = device.ServerUrl;
hdhReq.MachineName = device.UserName;
hdhReq.Type = "Collect";
//调用海德汉采集接口
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
{
string redis_key = "IMCS_CCS:" + device.Ip + ":" + device.ProtocolType;
//采集数据放入缓存
await _redisService.Database.StringSetAsync(redis_key, Result.Message);
//存储采集数据
CollectDataLog.Instance.WriteLogAdd(Result.Message, LOG_TITLE_HEIDEHAIN);
}
}
return "HEIDEHAIN采集成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("HEIDEHAIN采集异常===>>" + ex.Message, LOG_TITLE_S7);
return "HEIDEHAIN采集失败";
}
}
///
/// 上传程序回调任务
///
///
public async Task CallbackJob1()
{
List list = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
if (taskCallbackListData.IsNullOrEmpty)
{
list = await _taskCallbackService.GetAllList();
}
else
{
list = JsonConvert.DeserializeObject>(taskCallbackListData);
}
TaskCallback task = list.Where(x => x.OperateType.Equals(ActionTypeEnum.UploadFile.ToString())).FirstOrDefault();
if (task == null)
{
return "无回调任务";
}
string message = "";
try
{
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;
}
}
// rfid校验，true为通过，false为回滚
private async Task CheckRFid(TaskCallback task) {
Rfid rfid = new Rfid();
rfid.success = true;
// 读取初始化的数据，判断是否RFID校验生效
var rfidFlag = await _redisService.Database.StringGetAsync(RFID + RedisKeyEnum.Flag);
Boolean flag = true;
if (!rfidFlag.IsNullOrEmpty && rfidFlag=="false")
{
Log.Instance.WriteLogAdd("RFID逻辑块==》放弃RFID生效，放行操作,执行的任务：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
rfid.success = true;
rfid.msg = "放弃RFID生效，放行操作";
return rfid;
}
// 读取imcs缓存的托盘编码以及零件编码
string imcsRFID = _redisService.Database.StringGetAsync(RFID + task.TaskNodeId).Result;
// 读取ccs缓存的托盘编码
SiemensS7Net plcS7 = DevicePlcS7.SiemensS7(task.IP);
HslCommunication.OperateResult plcConnectionResult = plcS7.ConnectServer();
if (!plcConnectionResult.IsSuccess)
{
Log.Instance.WriteLogAdd("RFID逻辑块==》PLC连接失败,执行的任务：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
rfid.success = false;
rfid.msg = "PLC连接失败====》"+ task.IP;
return rfid;
}
string plcResult = plcS7.ReadInt16("DB1.16").Content.ToString();
if (plcResult == "5") {
Log.Instance.WriteLogAdd("RFID逻辑块==》任务已完成状态，放行操作,执行的任务：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
plcS7.Write("DB2.12", Convert.ToInt16("0"));
plcS7.ConnectClose();
rfid.success = true;
rfid.msg = "任务已完成状态，放行操作";
return rfid;
}
else
if (plcResult != "1" && plcResult != "2" && plcResult != "3")
{
Log.Instance.WriteLogAdd("RFID逻辑块==》DB1.16结果不满足,执行的任务：" + JsonConvert.SerializeObject(task)+ "DB1.16 应该为2实际为"+ plcResult, LOG_TITLE_CALLBACK);
rfid.success = false;
rfid.msg = "未取完成====》DB1.16 应该为2实际为"+ plcResult;
plcS7.ConnectClose();
return rfid;
}
// 获取读写状态
string plcRead = plcS7.ReadInt16("DB1.18").Content.ToString();
Console.WriteLine("====================================状态 DB1.18：" + plcRead);
// 判断读写状态,DB1.DBB18
if (plcRead == "1")
{ //下发读指令
plcS7.Write("DB2.12", Convert.ToInt16("1"));
Log.Instance.WriteLogAdd("RFID逻辑块==》rfid读命令已下发,执行的任务：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
rfid.success = false;
rfid.msg = "RFID读命令已下发";
return rfid;
}
else if (plcRead == "3")//表示真正读完成了，这个时候我要去比较数据
{ // 取rfid数据，并比对数据
// imcs缓存的托盘编码数据
string[] strings = imcsRFID.Replace("\"", "").Split("&");
Rfid imcsRfid = new Rfid();
imcsRfid.trayNo = strings[0];
imcsRfid.uniqueCode = strings[1];
//读取PLC中的RFID的托盘编码
string readResult = ToolUtils.ReturnStringByBytes(plcS7.Read("DB1.20", 39).Content).Replace(" ","");
Console.WriteLine("====================================数据 DB1.20：" + readResult);
if (imcsRfid.trayNo != readResult)
{
//TODO 可能要往PLC中写入一个值，表示校验错误
Log.Instance.WriteLogAdd("RFID逻辑块==》RFID校验托盘失败:" + "读取imcs_redis数据_" + JsonConvert.SerializeObject(imcsRfid) + ",读取RFID数据_" + readResult.ToString(), LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
rfid.success = false;
rfid.msg = task.Id + ":RFID托盘校验失败,imcs和RFID托盘信息不一致";
return rfid;
}
else
{
plcS7.Write("DB2.12", Convert.ToInt16("2"));
//读 源位置 是上下料站还是机床
string up = plcS7.ReadInt16("DB1.12").Content.ToString();
//如果是上下料站，往RFID中写state(1毛坯)和PID（零件编码）
if (sList.Contains(up))
{
if (imcsRfid.uniqueCode == null)
{
plcS7.Write("DB2.55", Convert.ToInt16("0"));
plcS7.Write("DB2.56", ToolUtils.ReturnBtyesWtitString("", 39));
}
else
{
plcS7.Write("DB2.55", Convert.ToInt16("1"));
plcS7.Write("DB2.56", ToolUtils.ReturnBtyesWtitString(imcsRfid.uniqueCode, 39));
}
}
else if (jList.Contains(up))
{ //如果是机床，往RFID中写state(2 成品)和PID（零件编码）
plcS7.Write("DB2.55", Convert.ToInt16("2"));
string readResult1 = ToolUtils.ReturnStringByBytes(plcS7.Read("DB1.62", 39).Content);
plcS7.Write("DB2.56", ToolUtils.ReturnBtyesWtitString(readResult1, 39));
}
else
{
string readResult1 = plcS7.ReadInt16("DB1.61").Content.ToString();
string readResult2 = ToolUtils.ReturnStringByBytes(plcS7.Read("DB1.62", 39).Content).Replace(" ","");
plcS7.Write("DB2.55", Convert.ToInt16(readResult1));
plcS7.Write("DB2.56", ToolUtils.ReturnBtyesWtitString(readResult2, 39));
}
}
Log.Instance.WriteLogAdd("RFID逻辑块==》重新写入RFID命令已下发:" + "读取imcs_redis数据_" + JsonConvert.SerializeObject(imcsRfid) + ",读取RFID数据_" + readResult.ToString(), LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
rfid.success = false;
rfid.msg = task.Id + "重新写入RFID命令已下发";
return rfid;
}
else if (plcRead == "5")
{
await _redisService.Database.StringSetAsync(RFID + task.TaskId + task.TaskNodeId, "2");
// 二次下发读的命令
plcS7.Write("DB2.12", Convert.ToInt16("1"));
Log.Instance.WriteLogAdd("RFID逻辑块==》rfid已写入，二次下发读,执行的任务：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
rfid.success = false;
rfid.msg = "RFID二次读命令已下发";
return rfid;
}
else {
Log.Instance.WriteLogAdd("RFID逻辑块==》RFID比对状态匹配失败,查询不出任务状态:"+ plcRead, LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
rfid.success = false;
rfid.msg = "RFID比对状态匹配失败，任务状态为："+ plcRead;
return rfid;
}
}
///
/// 取和放回调任务
///
///
public async Task CallbackJob2()
{
try
{
Console.WriteLine("取和放回调任务开始：" + DateTime.Now.ToString());
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
//在线设备
List deviceList = await getDeviceList();
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.RobotAction.ToString())).ToList();
taskList = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).ToList();
//TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault() ;
if (taskList == null || taskList.Count == 0)
{
return "无回调任务" ;
}
string message = "";
foreach(TaskCallback task in taskList)
{
CcsTagValue tagValueQuery = new CcsTagValue();
tagValueQuery.Ip = task.IP;
//tagValueQuery.Address = task.Address;
List tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
//系统操作模式
CcsTagValue tagValueMode = tagValues.Where(o => o.Address == "DB1.2").FirstOrDefault();
if (tagValueMode.TagValue != "257")
{
return "当前操作模式非自动并运行";
}
// RFID ============= 比对开始
/* string rfidFlag = _redisService.Database.StringGetAsync(RFID+ task.TaskId + task.TaskNodeId).Result;
if (rfidFlag.IsNullOrEmpty()) {
Rfid aa = await this.CheckRFid(task);
if (aa.success == false) {
return aa.msg;
}
} else if (rfidFlag == "2") {
// 获取读写状态
SiemensS7Net plcS7 = DevicePlcS7.SiemensS7(task.IP);
string plcRead = plcS7.ReadInt16("DB1.18").Content.ToString();
Console.WriteLine("====================================第二次状态 DB1.18：" + plcRead);
if (plcRead == "3")
{ //下发归零任务
await _redisService.Database.StringSetAsync(RFID + task.TaskId + task.TaskNodeId, "3");
string readResult = ToolUtils.ReturnStringByBytes(plcS7.Read("DB1.20", 39).Content).Replace(" ", "");
Console.WriteLine("====================================第二次读完成写的数据：" + readResult);
plcS7.Write("DB2.12", Convert.ToInt16("0"));
plcS7.ConnectClose();
}
else {
// 二次下发读的命令
Log.Instance.WriteLogAdd("等待二次读命令完成RFID读命令已下发：" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
plcS7.ConnectClose();
return "等待二次读命令完成RFID读命令已下发";
}
}*/
// RFID ============= 比对结束
CcsTagValue callBacktagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();
if ((callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue) )
{
// 任务执行完毕，删除临时存储的缓存数据
Console.WriteLine("任务执行完成，删除临时校验的缓存数据,任务状态"+task.CallbackValue+"==taskID："+ task.TaskId+"==taskNodeID："+ task.TaskNodeId);
await _redisService.Database.KeyDeleteAsync(RFID + task.TaskId + task.TaskNodeId);
//执行位清零
SiemensS7Net s7 = DevicePlcS7.SiemensS7(task.IP);
HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
if (ConnectionResult.IsSuccess)
{
Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调清零，plc点位：" + task.Address + "值：" + callBacktagValue.TagValue, LOG_TITLE_CALLBACK);
s7.Write("DB2.2", Convert.ToInt16("0"));
s7.Write("DB2.4", Convert.ToInt16("0"));
s7.Write("DB2.6", Convert.ToInt16("0"));
s7.Write("DB2.8", Convert.ToInt16("0"));
s7.Write("DB2.10", Convert.ToInt16("0"));
s7.Write("DB2.12", Convert.ToInt16("0"));
}
else
{
Log.Instance.WriteLogAdd("回调异常，PLC连接不上==>", LOG_TITLE_CALLBACK);
return "回调异常，PLC连接不上==>";
}
s7.ConnectClose();
task.State = false;
task.UpdateTime = DateTime.Now;
await _taskCallbackService.CreateOrUpdateAndCache(task);
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
{
//ecs返回-5 任务作废
if (result.IsSuccess && responseECSCallback.code == -5)
{
task.State = false;
task.UpdateTime = DateTime.Now;
task.Description = "ecs返回-5,回调任务作废";
await _taskCallbackService.CreateOrUpdateAndCache(task);
message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
Log.Instance.WriteLogAdd("回调异常，请求接口失败,ecs通知任务作废==>" + JsonConvert.SerializeObject(result), 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);
}
}
}
Thread.Sleep(1000);
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 读写回调任务
///
///
public async Task CallbackJob3()
{
try
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
List deviceList = await getDeviceList();
//在线设备
taskList = taskList.Where(x => (x.OperateType.Equals(ActionTypeEnum.ReadRFID.ToString())
|| x.OperateType.Equals(ActionTypeEnum.WriteRFID.ToString())) && x.State).ToList();
TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
if (task == null)
{
return "无回调任务";
}
string message = "";
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();
if (callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue )
{
CcsTagValue callBacktagValue2 = null;
if (task.OperateType.Equals(ActionTypeEnum.ReadRFID.ToString())){
callBacktagValue2 = tagValues.Where(o => o.Address == task.Address2).FirstOrDefault();
}
CallBackRequestData requestData = new CallBackRequestData();
requestData.taskId = long.Parse(task.TaskId);
requestData.taskNodeId = long.Parse(task.TaskNodeId);
//读RFID的值返回ecs
if (callBacktagValue2 != null)
{
requestData.content = callBacktagValue2.TagValue;
}
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(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()
{
try
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
List deviceList = await getDeviceList();
//在线设备
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartNCProgram.ToString()) && x.State && deviceList.Any(device => device.Ip == x.IP)).ToList();
if (taskList == null || taskList.Count == 0)
{
return "无回调任务";
}
string message = "";
DateTime currentTime = DateTime.Now;
foreach (TaskCallback task in taskList)
{
CcsTagValue tagValueQuery = new CcsTagValue();
//tagValueQuery.Ip = task.IP;
//tagValueQuery.Address = task.Address;
List tagValues = _ccsTagValueService.GetList(tagValueQuery);
//系统操作模式
CcsTagValue tagValueMode = tagValues.Where(o => o.Address == "DB1.2").FirstOrDefault();
if (tagValueMode.TagValue != "257")
{
return "当前操作模式非自动并运行";
}
CcsTagValue tagValue = tagValues.Where(o => o.Address == task.Address.Trim()).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);
}
}
}
Thread.Sleep(1000);
}
return string.IsNullOrEmpty(message) ? "无回调任务" : message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
return "回调异常" + ex.Message;
}
}
///
/// 启动清洗机回调任务
///
///
public async Task CallbackJob5()
{
try
{
List taskList = new List();
var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
if (taskCallbackListData.IsNullOrEmpty)
{
taskList = await _taskCallbackService.GetAllList();
}
else
{
taskList = JsonConvert.DeserializeObject>(taskCallbackListData);
}
List deviceList = await getDeviceList();
//在线设备
taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartCleanMachine.ToString()) && x.State && deviceList.Any(device => device.Ip == x.IP)).ToList();
// TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
if (taskList == null || taskList.Count == 0)
{
return "无回调任务";
}
string message = "";
DateTime currentTime = DateTime.Now;
foreach (TaskCallback task in taskList)
{
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)
//临时处理以解决ecs配置问题
//if(currentTime.Subtract(task.CreateTime).TotalSeconds > 10)
{
SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
s7.ConnectClose();
Log.Instance.WriteLogAdd("回调异常，PLC连接不上", LOG_TITLE_CALLBACK);
return "PLC连接不上";
}
//清除配方内容和配方编号
CcsActionAddress actionAddressQuery = new CcsActionAddress();
actionAddressQuery.ActionId = 7;
List CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
//查询写入地址列表
List CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
{
if (!string.IsNullOrEmpty(actionAddress.Address))
{
if (actionAddress.dataType == "bytes")
{
s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString("", 64));
}
else if (actionAddress.dataType == "int")
{
s7.Write(actionAddress.Address, Convert.ToInt16("0"));
}
}
}
Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】喷墨回调清零", LOG_TITLE_CALLBACK);
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);
}
}
}
Thread.Sleep(1000);
}
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调度成功";
//查询全部使用设备包括不在线和离线
string all_device_redis_key = imcs_redis_key + RedisKeyEnum.ALLDeviceList ;
List devices = new List();
var deviceListData = await _redisService.Database.StringGetAsync(all_device_redis_key);
if (deviceListData.IsNullOrEmpty)
{
devices = _deviceService.GetDevices();
await _redisService.Database.StringSetAsync(all_device_redis_key, JsonConvert.SerializeObject(devices));
}
else
{
devices = JsonConvert.DeserializeObject>(deviceListData);
}
List equipmentMonitors = new List();
string equipment_monitors_redis_key = imcs_redis_key + RedisKeyEnum.MonitorEquipmentStatusJob;
var data = await _redisService.Database.StringGetAsync(equipment_monitors_redis_key);
if (data.IsNullOrEmpty)
{
equipmentMonitors = await _equipmentMonitorService.GetList();
//首次设置redis
if (equipmentMonitors != null && equipmentMonitors.Count > 0)
{
await _redisService.Database.StringSetAsync(equipment_monitors_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 == equipment.IP).FirstOrDefault();
//缓存取PLC tagvalue 值
List tagValues = new List();
if(device == null)
{
continue;
}
string tag_value_redis_key = imcs_redis_key + device.Ip + ":" + device.ProtocolType;
var tagData = await _redisService.Database.StringGetAsync(tag_value_redis_key);
if (tagData.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(tag_value_redis_key, JsonConvert.SerializeObject(tagValues));
}
}
else
{
tagValues = JsonConvert.DeserializeObject>(tagData);
}
CcsTagValue ccsTagValue = tagValues.Where(x => x.Ip == equipment.IP && x.Address == equipment.Address).FirstOrDefault();
if (device != null && !device.UseState)
{
if (equipment.Status != "离线")
{
equipment.Status = "离线";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
else if(device != null && !device.State)
{
if (equipment.Status != "掉线")
{
equipment.Status = "掉线";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
else if (device != null && device.State && device.UseState && (equipment.Type == "HEIDEHAIN" || equipment.Type == "FANUC"))
{
//通过数组获取机床对应的PLC ip地址
string plcIp = jcIpDict[device.Ip];
string ktRedisKey = imcs_redis_key + plcIp + ":" + ProtocalTypeEnum.S7_1500;
string plcAddress = jcAddressDict[device.Ip];
var ktTagData = await _redisService.Database.StringGetAsync(ktRedisKey);
List ktTagValues = new List();
if (ktTagData.IsNullOrEmpty)
{
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = ProtocalTypeEnum.S7_1500.ToString();
tagQuery.Ip = plcIp;
ktTagValues = _ccsTagValueService.GetList(tagQuery);
//首次设置redis
if (ktTagValues != null && ktTagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(ktRedisKey, JsonConvert.SerializeObject(ktTagValues));
}
}
else
{
ktTagValues = JsonConvert.DeserializeObject>(ktTagData);
}
CcsTagValue ktTagValue = ktTagValues.Where(x => x.Ip.Trim() == plcIp && x.Address.Trim() == plcAddress).FirstOrDefault();
if(ktTagValue != null)
{
if (ktTagValue.TagValue == "1")
{
if (equipment.Status != "生产中")
{
equipment.Status = "生产中";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
if (ktTagValue.TagValue == "2")
{
if (equipment.Status != "空闲")
{
equipment.Status = "空闲";
changeEquipmentMonitors.Add(equipment);
}
continue;
}
}
}
else if (device != null && (equipment.Name == "机械手" || equipment.Name == "保障中心_伺服舵机"))
{
ccsTagValue = tagValues.Where(x => x.Ip == equipment.IP && x.Address == 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 == equipment.IP && x.Address == 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);
}
}
}
//初始化推送列表
List productionStatusList = new List();
//变化的修改 并且更新缓存
if (changeEquipmentMonitors.Count > 0)
{
foreach (EquipmentMonitor changeEquipment in changeEquipmentMonitors)
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = changeEquipment.Id.ToString();
productionStatus.onlineStatus = syncStatusMap[changeEquipment.Status].ToString();
productionStatusList.Add(productionStatus);
}
//修改并重置缓存
await _equipmentMonitorService.UpdateAndCache(equipmentMonitors);
}
//在线设备,报警放入推送数组
List onlineDeviceList = await getDeviceList();
foreach (Device onlineDevice in onlineDeviceList)
{
EquipmentMonitor alarmEquipment = equipmentMonitors.Where(x => x.IP == onlineDevice.Ip && x.Type == onlineDevice.ProtocolType).FirstOrDefault();
if (alarmEquipment != null && alarmEquipment.Type == "HEIDEHAIN")
{
Thread.Sleep(1000);
RequestHeidhData hdhReq = new RequestHeidhData();
hdhReq.ServerUrl = onlineDevice.ServerUrl;
hdhReq.MachineName = onlineDevice.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) && !Result.Message.Contains("无报警"))
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = alarmEquipment.Id.ToString();
productionStatus.ip = onlineDevice.Ip;
productionStatus.alertMsg = responseData.errorsInfo;
productionStatus.alarmState = true;//报警
productionStatus.onlineStatus = "1";
productionStatusList.Add(productionStatus);
}
}
}
else if (alarmEquipment != null && alarmEquipment.Type == "FANUC")
{
Thread.Sleep(1000);
string Url = fanucUrlContext + "?ip=" + onlineDevice.Ip + "&port=" + onlineDevice.Port;
//调用发那科接口
var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=AlmInfo", null, null);
if (Result.IsSuccess)
{
//ResponseFanucData fncReq = new ResponseFanucData();
List AlmMsg = JsonConvert.DeserializeObject>(Result.Message);
//List AlmMsg = fncReq.AlmMsg;
if (AlmMsg != null && AlmMsg.Count > 0)
{
var msgs = from o in AlmMsg select o.msg;
if(msgs != null && !Result.Message.Contains("无报警"))
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = alarmEquipment.Id.ToString();
productionStatus.ip = onlineDevice.Ip;
productionStatus.alertMsg = string.Join(",", msgs.ToArray());
productionStatus.alarmState = true;//报警
productionStatus.onlineStatus = "1";
productionStatusList.Add(productionStatus);
}
}
}
}
else if(alarmEquipment != null && onlineDevice.ProtocolType == "S7_1500")
{
//缓存取PLCagvalue 值
List tagValues = new List();
string tag_value_redis_key = imcs_redis_key + onlineDevice.Ip + ":" + onlineDevice.ProtocolType;
var tagData = await _redisService.Database.StringGetAsync(tag_value_redis_key);
if (tagData.IsNullOrEmpty)
{
CcsTagValue tagQuery = new CcsTagValue();
tagQuery.ProtocolType = onlineDevice.ProtocolType;
tagQuery.Ip = onlineDevice.Ip;
tagValues = _ccsTagValueService.GetList(tagQuery);
//首次设置redis
if (tagValues != null && tagValues.Count > 0)
{
await _redisService.Database.StringSetAsync(tag_value_redis_key, JsonConvert.SerializeObject(tagValues));
}
}
else
{
tagValues = JsonConvert.DeserializeObject>(tagData);
}
//获取机械手报警信息
CcsTagValue plcWarnValue = tagValues.Where(x => x.Ip == alarmEquipment.IP && x.Address == "DB200.34").FirstOrDefault();
if (plcWarnValue != null && plcWarnValue.TagValue != "0")
{
//从字典中查询具体描述
List dictList = new List() ;
string dict_value_redis_key = imcs_redis_key + RedisKeyEnum.DictKeyList;
var dictData = await _redisService.Database.StringGetAsync(dict_value_redis_key);
if (dictData.IsNullOrEmpty)
{
Dictionary ccsDictionary = new Dictionary();
dictList = await _dictionaryService.GetList(ccsDictionary);
//首次设置redis
if (dictList != null && dictList.Count > 0)
{
await _redisService.Database.StringSetAsync(dict_value_redis_key, JsonConvert.SerializeObject(dictList));
}
}
else
{
dictList = JsonConvert.DeserializeObject>(dictData);
}
Dictionary dictObj = dictList.Where(x => x.Type == onlineDevice.Ip && x.Code.ToString() == plcWarnValue.TagValue && x.state).FirstOrDefault();
if (null != dictObj && !string.IsNullOrEmpty(dictObj.DictValue.Trim()))
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = alarmEquipment.Id.ToString();
productionStatus.ip = onlineDevice.Ip;
productionStatus.alertMsg = dictObj.Description.Trim();
productionStatus.onlineStatus = "1";
productionStatus.alarmState = true; //报警
productionStatusList.Add(productionStatus);
}
}
}
}
//推送
if (productionStatusList != null && productionStatusList.Count > 0)
{
//主动推送同步状态数据接口
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("同步设备状态成功==>" + JsonConvert.SerializeObject(productionStatusList), PLC_ALARM_INFO);
}
else
{
Log.Instance.WriteLogAdd("同步设备状态操作失败==>:"+JsonConvert.SerializeObject(productionStatusList) + responseECSCallback.msg, PLC_ALARM_INFO);
}
}
return message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("MonitorEquipmentStatusJob:" + ex.Message, PLC_ALARM_INFO);
return "MonitorEquipmentStatusJob : " + ex.Message;
}
}
///
/// 监控设备状态
///
///
public async Task DeviceStatusJob()
{
try
{
string message = "";
string all_use_device_redis_key = imcs_redis_key + RedisKeyEnum.ALLUseDeviceList ;
List devices = new List();
//查询全部使用设备包括在线和不在线
var deviceListData = await _redisService.Database.StringGetAsync(all_use_device_redis_key);
if (deviceListData.IsNullOrEmpty)
{
devices = _deviceService.GetDeviceAllList();
await _redisService.Database.StringSetAsync(all_use_device_redis_key, JsonConvert.SerializeObject(devices));
}
else
{
devices = JsonConvert.DeserializeObject>(deviceListData);
}
//ftp不监控
devices = devices.Where(x => !x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).ToList();
foreach (Device device in devices)
{
Ping pingSender = new Ping();
PingReply reply = pingSender.Send(device.Ip);
if (reply.Status != IPStatus.Success)
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice != null && oldDevice.State)
{
device.State = false;
device.DisconnectUpdateTime = DateTime.Now;
await _deviceService.UpdateAndCache(device);
}
Log.Instance.WriteLogAdd(device.Ip + ":" + device.ProtocolType + "连接失败,或已离线", LOG_TITLE_DEVICE);
message = message + device.Ip + ",连接失败,或已离线，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
continue;
}
else
{
Device oldDevice = await _deviceService.GetDeviceById(device.Id);
if (oldDevice != null && !oldDevice.State)
{
oldDevice.State = true;
device.DisconnectUpdateTime = DateTime.Now;
await _deviceService.UpdateAndCache(oldDevice);
}
Log.Instance.WriteLogAdd(device.Ip + ":"+ device.ProtocolType + "连接成功", LOG_TITLE_DEVICE);
message = message + ",plc连接成功，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
continue;
}
//Thread.Sleep(50);
}
return message;
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("设备连接异常,或以离线" + ex.Message, LOG_TITLE_DEVICE);
return "设备连接异常,或以离线" + ex.Message;
}
}
///
/// 删除redis
///
///
public void removeRedis()
{
List devices = _deviceService.GetDeviceAllList();
_redisService.Database.KeyDelete(imcs_redis_key + RedisKeyEnum.ALLUseDeviceList);
_redisService.Database.KeyDelete(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
foreach (Device device in devices)
{
_redisService.Database.KeyDelete(imcs_redis_key + device.Ip + ":" + device.ProtocolType);
}
}
///
/// 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;
}
///
/// 获取redis 设备在线列表
///
///
///
private async Task> getDeviceList()
{
List deviceList = new List();
var deviceListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.DeviceList);
if (deviceListData.IsNullOrEmpty || deviceListData.Length() == 0)
{
deviceList = _deviceService.GetDeviceList();
await _redisService.Database.StringSetAsync(imcs_redis_key + RedisKeyEnum.DeviceList, JsonConvert.SerializeObject(deviceList));
}
else
{
deviceList = JsonConvert.DeserializeObject>(deviceListData);
}
return deviceList;
}
///
/// 心跳任务
///
public async Task PlcHeartbeatJob()
{
try
{
SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
s7.ConnectClose();
Log.Instance.WriteLogAdd("S7心跳写入异常,plc连不上==>" + "10.161.30.248", LOG_HEART_PLC);
return "心跳写入失败，plc连不上";
}
else
{
string heartAdress = "DB2.0";
string operateResult = s7.ReadInt16(heartAdress).Content.ToString();
if (operateResult == "0")
{
s7.Write(heartAdress, Convert.ToInt16("1"));
}
else
{
s7.Write(heartAdress, Convert.ToInt16("0"));
}
}
s7.ConnectClose();
}catch (Exception ex)
{
Log.Instance.WriteLogAdd("心跳写入异常" + ex.Message, LOG_HEART_PLC);
Console.WriteLine("心跳写入异常");
return "心跳写入异常" + ex.Message;
}
Console.WriteLine("心跳写入成功");
return "心跳写入成功";
}
///
/// 监控设备状态
///
///
public async Task MonitorEquipmentStatusJob2()
{
try
{
SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
s7.ConnectClose();
Log.Instance.WriteLogAdd("监控设备状态写入异常,plc连不上==>" + "10.161.30.248", LOG_RESOURCE_STATE);
return "监控设备状态写入异常,plc连不上";
}
List equipmentMonitors = new List();
string equipment_monitors_redis_key = imcs_redis_key + RedisKeyEnum.MonitorEquipmentStatusJob;
var data = await _redisService.Database.StringGetAsync(equipment_monitors_redis_key);
if (data.IsNullOrEmpty)
{
equipmentMonitors = await _equipmentMonitorService.GetList();
//首次设置redis
if (equipmentMonitors != null && equipmentMonitors.Count > 0)
{
await _redisService.Database.StringSetAsync(equipment_monitors_redis_key, JsonConvert.SerializeObject(equipmentMonitors));
}
}
else
{
equipmentMonitors = JsonConvert.DeserializeObject>(data);
}
//变化的设备
List changeEquipmentMonitors = new List();
foreach (EquipmentMonitor equipment in equipmentMonitors)
{
string operateResult = s7.ReadInt16(equipment.Address).Content.ToString();
string state = operateResult == "0" ? "离线" : operateResult == "1" ? "生产中" : "空闲";
if(equipment.Status == null || equipment.Status != state)
{
equipment.Status = state;
changeEquipmentMonitors.Add(equipment);
}
}
//初始化推送列表
List productionStatusList = new List();
//变化的修改 并且更新缓存
if (changeEquipmentMonitors.Count > 0)
{
foreach (EquipmentMonitor changeEquipment in changeEquipmentMonitors)
{
ProductionStatus productionStatus = new ProductionStatus();
productionStatus.id = changeEquipment.Id.ToString();
productionStatus.onlineStatus = syncStatusMap[changeEquipment.Status].ToString();
if (changeEquipment.Description != null)
{
productionStatus.ip = changeEquipment.IP;
}
productionStatusList.Add(productionStatus);
}
//修改并重置缓存
await _equipmentMonitorService.UpdateAndCache(equipmentMonitors);
}
//推送
if (productionStatusList != null && productionStatusList.Count > 0)
{
//主动推送同步状态数据接口
RequestSynStatusData requestData = new RequestSynStatusData();
requestData.productionStatus = JsonConvert.SerializeObject(productionStatusList);
String synStatusUrl = ecsRootUrlContext + "/api/authority/synStatus/synDeviceStatus";
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("同步设备状态成功==>" + JsonConvert.SerializeObject(productionStatusList), LOG_RESOURCE_STATE);
}
else
{
Log.Instance.WriteLogAdd("同步设备状态操作失败==>:" + JsonConvert.SerializeObject(productionStatusList) + responseECSCallback.msg, LOG_RESOURCE_STATE);
}
}
return "监控设备状态成功";
}
catch (Exception ex)
{
Log.Instance.WriteLogAdd("MonitorEquipmentStatusJob:" + ex.Message, LOG_RESOURCE_STATE);
return "MonitorEquipmentStatusJob : " + ex.Message;
}
}
///
/// 采集数据S7报警数据
///
///
public async Task> DataCollectS7JobWarn()
{
var data = await _redisService.Database.StringGetAsync("PLC_COSTOM_ADDRESS");
List returnList=new List();
List dataList = data.ToString().Split(',').ToList();
SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
OperateResult ConnectionResult = s7.ConnectServer();
if (!ConnectionResult.IsSuccess)
{
s7.ConnectClose();
Log.Instance.WriteLogAdd("S7采集异常,plc连不上==>10.161.30.248" , LOG_TITLE_S7);
return null;
}
else
{
foreach(string st in dataList)
{
string operateResult = s7.ReadBool(st).Content.ToString();
returnList.Add(operateResult);
}
}
s7.ConnectClose();
return returnList;
}
public async Task remoteRedis()
{
_redisService.Database.KeyDelete("IMCS_CCS:10.161.30.248:S7_1500");
_redisService.Database.KeyDelete("IMCS_CCS:ALLDeviceList");
_redisService.Database.KeyDelete("IMCS_CCS:ALLUseDeviceList");
_redisService.Database.KeyDelete("IMCS_CCS:DeviceList");
_redisService.Database.KeyDelete("IMCS_CCS:MonitorEquipmentStatusJob");
_redisService.Database.KeyDelete("IMCS_CCS:CallbackTaskList");
return "清除成功";
}
}
}