htl_ccs/IMCS_CCS/Service/Impl/TaskJobService.cs

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 AutoMapper.Execution;
using Org.BouncyCastle.Asn1.Ocsp;
using System.Reflection;
using Org.BouncyCastle.Ocsp;

namespace IMCS.CCS.Service.Impl
{
    /// <summary>
    /// 任务调度服务
    /// </summary>
    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<String, int> syncStatusMap = new Dictionary<String, int>();

        private Dictionary<String, String> jcAddressDict = new Dictionary<String, String>();

        private Dictionary<String, String> jcIpDict = new Dictionary<String, String>();

        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 LOG_RESOURCE_STATE = "设备状态";

        private Boolean repeatFlag = false;

        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);
            
        }

      

        /// <summary>
        /// 采集数据S7
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectS7Job()
        {
            try
            { 
                List<Device> deviceList = await getDeviceList();
                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()) && x.State).ToList();
                foreach (Device device in deviceList)
                {
             
                    List<CcsTagValue> tagValues = new List<CcsTagValue>();
                    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<List<CcsTagValue>>(data);
                    }
                   
                    if (tagValues != null && tagValues.Count > 0)
                    {
               
                        tagValues = JsonConvert.DeserializeObject<List<CcsTagValue>>(data);
                        List<CcsTagValue> changTagValues = new List<CcsTagValue>();


                        //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采集失败";
            }
        }

       

        /// <summary>
        /// 采集数据HEIDEHAIN
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectHeidehainJob()
        {
            try
            {
                List<Device> 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采集失败";
            }
        }

        /// <summary>
        /// 上传程序回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob1()
        {
            List<TaskCallback> list = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                list = await _taskCallbackService.GetAllList();
            }
            else
            {
                list = JsonConvert.DeserializeObject<List<TaskCallback>>(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<ResponseECSCallbackData>(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;
            }
        }

        /// <summary>
        /// 取和放回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob2()
        {
            try
            {
                
                List<TaskCallback> taskList = new List<TaskCallback>();
                var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
                if (taskCallbackListData.IsNullOrEmpty)
                {
                    taskList = await _taskCallbackService.GetAllList();
                }
                else
                {
                    taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
                }
                //在线设备 
                List<Device> 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<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();

                    //系统操作模式
                    CcsTagValue tagValueMode = tagValues.Where(o => o.Address == "DB1.2").FirstOrDefault();
                    if (tagValueMode.TagValue != "257")
                    {
                        return "当前操作模式非自动并运行";
                    }

                    //执行位清零
                    SiemensS7Net s7 = DevicePlcS7.SiemensS7(task.IP);
                    HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                    if (!ConnectionResult.IsSuccess)
                    {
                        Log.Instance.WriteLogAdd("回调异常，PLC连接不上==>", LOG_TITLE_CALLBACK);
                        return "回调异常，PLC连接不上==>";
                    }

                    //判断RFID是否读完成
                    string rfidResult = s7.ReadInt16("DB1.18").Content.ToString();
                    RFIData rFIData = new RFIData();
                    if (rfidResult == "3" && !repeatFlag)
                    {
                        repeatFlag = true;
                        //读完成，读RFID
                        if (task.CallbackValue == "5")
                        {
                            //托盘动作回调,读取RFID
                            CcsActionAddress actionAddressQuery = new CcsActionAddress();
                            actionAddressQuery.ActionId = 26;
                            List<CcsActionAddress> CcsActionAddressRead = _ccsActionAddressService.GetList(actionAddressQuery);
                            foreach (CcsActionAddress actionAddress in CcsActionAddressRead)
                            {
                                string value = "";
                                if (actionAddress.dataType == "bytes")
                                {
                                    byte[] bytes = s7.Read(actionAddress.Address, 40).Content;
                                    value = ToolUtils.ReturnStringByBytes(bytes);
                                    value = value.Trim();
                                }
                                else if (actionAddress.dataType == "int")
                                {
                                    value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                                }
                                else if (actionAddress.dataType == "float")
                                {
                                    value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                                }
                                else if (actionAddress.dataType == "byte")
                                {
                                    value = s7.ReadByte(actionAddress.Address).Content.ToString();
                                }
                                SetProperty(rFIData, actionAddress.Description, value);
                            }

                            if (string.IsNullOrEmpty(rFIData.trayNo))
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取redis托盘RFID信息为空====>" + JsonConvert.SerializeObject(rFIData), LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，读取redis托盘RFID信息为空";
                            }
                            string rfidDataObj = JsonConvert.SerializeObject(rFIData);
                            await _redisService.Database.StringSetAsync("CCS_TRAY_RFID_" + task.TaskNodeId, JsonConvert.SerializeObject(rfidDataObj));

                            Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取托盘RFID信息：" + JsonConvert.SerializeObject(rFIData), LOG_TITLE_CALLBACK);

                            //判断当前托盘是否和缓存托盘RFID一致
                            string callback_redis_key = "TRAY_RFID_";
                            var trayRfid = await _redisService.Database.StringGetAsync(callback_redis_key + task.TaskNodeId);

                            RFIData rfidWrite = new RFIData();
                            if (!trayRfid.IsNullOrEmpty)
                            {
                                string bb = JsonConvert.DeserializeObject<string>(trayRfid);
                                RFIData trayRdisRfid = JsonConvert.DeserializeObject<RFIData>(bb);
                                //比较是否为同一托盘
                                if (rFIData.trayNo != trayRdisRfid.trayNo)
                                {
                                    s7.ConnectClose();
                                    repeatFlag = false;
                                    Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，缓存托盘【" + trayRdisRfid.trayNo + "】 和从RFID读出托盘【" + rFIData.trayNo + "】不一致", LOG_TITLE_CALLBACK);
                                    return "任务【" + task.TaskNodeId + "】回调，缓存托盘【" + trayRdisRfid.trayNo + "】 和从RFID读出托盘【" + rFIData.trayNo + "】不一致";
                                }
                                rfidWrite = trayRdisRfid;
                            }
                            else
                            {
                                rfidWrite = rFIData;
                            }


                            //写刀具信息
                            CcsActionAddress actionAddressQueryWrite = new CcsActionAddress();
                            actionAddressQueryWrite.ActionId = 27;
                            List<CcsActionAddress> CcsActionAddressWrites = _ccsActionAddressService.GetList(actionAddressQueryWrite);
                            foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                            {
                                if (!string.IsNullOrEmpty(actionAddress.Address))
                                {
                                    if (string.IsNullOrEmpty(actionAddress.Value))
                                    {
                                        //取参数传参值
                                        string dataValue = getProperties(rfidWrite, actionAddress.Description);
                                        if (!string.IsNullOrEmpty(dataValue))
                                        {
                                            if (actionAddress.dataType == "bytes")
                                            {
                                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(dataValue, dataValue.Length));
                                            }
                                            else if (actionAddress.dataType == "int")
                                            {
                                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                            }
                                            else if (actionAddress.dataType == "float")
                                            {
                                                s7.Write(actionAddress.Address, float.Parse(dataValue));
                                            }
                                            else if (actionAddress.dataType == "byte")
                                            {
                                                s7.Write(actionAddress.Address, Convert.ToByte(dataValue));
                                            }
                                        }

                                    }
                                    else
                                    {
                                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                                    }
                                }
                            }

                            //写入启动
                            s7.Write("DB2.12", Convert.ToInt16("2"));

                            Boolean nextFlag = true;
                            //进入循环等待写入完成
                            int count = 0;
                            string writeResult = "";
                            while (true)
                            {
                                Thread.Sleep(2000);
                                writeResult = s7.ReadInt16("DB1.18").Content.ToString();
                                if (writeResult == "5")
                                {
                                    //写完成,跳出循环
                                    break;
                                }

                                /*if (count == 10)
                                {
                                    //超时，跳出循环
                                    nextFlag = false;
                                    break;
                                }*/
                                count++;
                            }

                            if (!nextFlag)
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，写入RFID超时，当前DB1.18值【" + writeResult + "】", LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，写入RFID超时，当前DB1.18值【" + writeResult + "】";
                            }

                            //校验是否已写入RFID---读一下
                            s7.Write("DB2.12", Convert.ToInt16("1"));

                            //进入循环等待读完成
                            count = 0;
                            writeResult = "";
                            while (true)
                            {
                                Thread.Sleep(2000);
                                writeResult = s7.ReadInt16("DB1.18").Content.ToString();
                                if (writeResult == "3")
                                {
                                    //写完成,跳出循环
                                    break;
                                }

                                /*if (count == 10)
                                {
                                    //超时，跳出循环
                                    nextFlag = false;
                                    break;
                                }*/
                                count++;
                            }

                            if (!nextFlag)
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取RFID超时，当前DB1.18值【" + writeResult + "】", LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，读取RFID超时，当前DB1.18值【" + writeResult + "】";
                            }

                            foreach (CcsActionAddress actionAddress in CcsActionAddressRead)
                            {
                                if (!string.IsNullOrEmpty(actionAddress.Address))
                                {
                                    //取参数传参值
                                    string dataValue = getProperties(rfidWrite, actionAddress.Description);
                                    //读取写入结果
                                    string value = "";
                                    if (actionAddress.dataType == "bytes")
                                    {
                                        byte[] bytes = s7.Read(actionAddress.Address, 40).Content;
                                        value = ToolUtils.ReturnStringByBytes(bytes);
                                        value = value.Trim();
                                    }
                                    else if (actionAddress.dataType == "int")
                                    {
                                        value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                                    }
                                    else if (actionAddress.dataType == "float")
                                    {
                                        value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                                    }
                                    else if (actionAddress.dataType == "byte")
                                    {
                                        value = s7.ReadByte(actionAddress.Address).Content.ToString();
                                    }
                                    if (value != dataValue)
                                    {
                                        s7.ConnectClose();
                                        repeatFlag = false;
                                        Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，RFID中【" + actionAddress.Description + "】,地址【" + actionAddress.Address + "】重新写入值【" + dataValue + "】 和从RFID读出值【" + value + "】不一致", LOG_TITLE_CALLBACK);
                                        return "任务【" + task.TaskNodeId + "】回调，RFID中【" + actionAddress.Description + "】,地址【" + actionAddress.Address + "】重新写入值【" + dataValue + "】 和从RFID读出值【" + value + "】不一致";

                                    }
                                }
                            }

                            //点位清零
                            s7.Write("DB2.12", Convert.ToInt16("0"));
                        }
                        else
                        {
                            //刀具动作回调,读取RFID
                            CcsActionAddress actionAddressQuery = new CcsActionAddress();
                            actionAddressQuery.ActionId = 15;
                            List<CcsActionAddress> CcsActionAddressRead = _ccsActionAddressService.GetList(actionAddressQuery);
                            foreach (CcsActionAddress actionAddress in CcsActionAddressRead)
                            {
                                string value = "";
                                if (actionAddress.dataType == "bytes")
                                {
                                    byte[] bytes = s7.Read(actionAddress.Address, 19).Content;
                                    value = ToolUtils.ReturnStringByBytes(bytes);
                                }
                                else if (actionAddress.dataType == "int")
                                {
                                    value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                                }
                                else if (actionAddress.dataType == "float")
                                {
                                    value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                                }
                                else if (actionAddress.dataType == "byte")
                                {
                                    value = s7.ReadByte(actionAddress.Address).Content.ToString();
                                }
                                SetProperty(rFIData, actionAddress.Description, value);
                            }

                            if(string.IsNullOrEmpty(rFIData.toolId) || rFIData.toolId == "0")
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取redis刀具RFID信息为空====>"+ JsonConvert.SerializeObject(rFIData), LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，读取redis刀具RFID信息为空";
                            }
                            string rfidDataObj = JsonConvert.SerializeObject(rFIData);
                            await _redisService.Database.StringSetAsync("CCS_TOOL_RFID_" + task.TaskNodeId, JsonConvert.SerializeObject(rfidDataObj));

                            Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取刀具RFID信息：" + JsonConvert.SerializeObject(rFIData), LOG_TITLE_CALLBACK);
                            
                            //判断当前刀具是否和缓存刀具RFID一致
                            string callback_redis_key = "CUTTING_TOOL_RFID_";
                            var cuttingToolRfid = await _redisService.Database.StringGetAsync(callback_redis_key + task.TaskNodeId);

                            RFIData rfidWrite = new RFIData();
                            if (!cuttingToolRfid.IsNullOrEmpty)
                            {
                                string bb = JsonConvert.DeserializeObject<string>(cuttingToolRfid);
                                RFIData toolRdisRfid = JsonConvert.DeserializeObject<RFIData>(bb);
                                //比较是否为同一把刀
                                if (rFIData.toolId != toolRdisRfid.toolId)
                                {
                                    s7.ConnectClose();
                                    repeatFlag = false;
                                    Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，缓存刀具【" + toolRdisRfid.toolId + "】 和从RFID读出刀具【" + rFIData.toolId + "】不一致", LOG_TITLE_CALLBACK);
                                    return "任务【" + task.TaskNodeId + "】回调，缓存刀具【" + toolRdisRfid.toolId + "】 和从RFID读出刀具【" + rFIData.toolId + "】不一致";
                                }
                                rfidWrite = toolRdisRfid;
                            }
                            else
                            {
                                rfidWrite = rFIData;
                            }
                            

                            //写刀具信息
                            CcsActionAddress actionAddressQueryWrite = new CcsActionAddress();
                            actionAddressQueryWrite.ActionId = 16;
                            List<CcsActionAddress> CcsActionAddressWrites = _ccsActionAddressService.GetList(actionAddressQueryWrite);
                            foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                            {
                                if (!string.IsNullOrEmpty(actionAddress.Address))
                                {
                                    if (string.IsNullOrEmpty(actionAddress.Value))
                                    {
                                        //取参数传参值
                                        string dataValue = getProperties(rfidWrite, actionAddress.Description);
                                        if (!string.IsNullOrEmpty(dataValue))
                                        {
                                            if (actionAddress.dataType == "bytes")
                                            {
                                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(dataValue, 19));
                                            }
                                            else if (actionAddress.dataType == "int")
                                            {
                                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                            }
                                            else if (actionAddress.dataType == "float")
                                            {
                                                s7.Write(actionAddress.Address, float.Parse(dataValue));
                                            }
                                            else if (actionAddress.dataType == "byte")
                                            {
                                                s7.Write(actionAddress.Address, Convert.ToByte(dataValue));
                                            }
                                        }

                                    }
                                    else
                                    {
                                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                                    }
                                }
                            }

                            //写入启动
                            s7.Write("DB2.12", Convert.ToInt16("2"));

                            Boolean nextFlag = true;
                            //进入循环等待写入完成
                            int count = 0;
                            string writeResult = "";
                            while (true)
                            {
                                Thread.Sleep(2000);
                                writeResult  = s7.ReadInt16("DB1.18").Content.ToString();
                                if(writeResult == "5")
                                {
                                    //写完成,跳出循环
                                    break;
                                }

                                if(count == 10)
                                {
                                    //超时，跳出循环
                                    nextFlag = false;
                                    break;
                                }
                                count++;
                            }

                            if (!nextFlag)
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，写入RFID超时，当前DB1.18值【"+writeResult+"】", LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，写入RFID超时，当前DB1.18值【" + writeResult + "】";
                            }

                            //校验是否已写入RFID---读一下
                            s7.Write("DB2.12", Convert.ToInt16("1"));

                            //进入循环等待读完成
                            count = 0;
                            writeResult = "";
                            while (true)
                            {
                                Thread.Sleep(2000);
                                writeResult = s7.ReadInt16("DB1.18").Content.ToString();
                                if (writeResult == "3")
                                {
                                    //写完成,跳出循环
                                    break;
                                }

                                if (count == 10)
                                {
                                    //超时，跳出循环
                                    nextFlag = false;
                                    break;
                                }
                                count++;
                            }

                            if (!nextFlag)
                            {
                                s7.ConnectClose();
                                repeatFlag = false;
                                Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，读取RFID超时，当前DB1.18值【" + writeResult + "】", LOG_TITLE_CALLBACK);
                                return "任务【" + task.TaskNodeId + "】回调，读取RFID超时，当前DB1.18值【" + writeResult + "】";
                            }

                            foreach (CcsActionAddress actionAddress in CcsActionAddressRead)
                            {
                                if (!string.IsNullOrEmpty(actionAddress.Address))
                                {
                                    //取参数传参值
                                    string dataValue = getProperties(rfidWrite, actionAddress.Description);
                                    //读取写入结果
                                    string value = "";
                                    if (actionAddress.dataType == "bytes")
                                    {
                                        byte[] bytes = s7.Read(actionAddress.Address, 19).Content;
                                        value = ToolUtils.ReturnStringByBytes(bytes);
                                    }
                                    else if (actionAddress.dataType == "int")
                                    {
                                        value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                                    }
                                    else if (actionAddress.dataType == "float")
                                    {
                                        value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                                    }
                                    else if (actionAddress.dataType == "byte")
                                    {
                                        value = s7.ReadByte(actionAddress.Address).Content.ToString();
                                    }
                                    if (value != dataValue)
                                    {
                                        s7.ConnectClose();
                                        repeatFlag = false;
                                        Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，RFID中【"+ actionAddress .Description+ "】,地址【"+actionAddress.Address+"】重新写入值【" + dataValue + "】 和从RFID读出值【" + value + "】不一致", LOG_TITLE_CALLBACK);
                                        return "任务【" + task.TaskNodeId + "】回调，RFID中【" + actionAddress.Description + "】,地址【" + actionAddress.Address + "】重新写入值【" + dataValue + "】 和从RFID读出值【" + value + "】不一致";

                                    }
                                }
                            }

                            //点位清零
                            s7.Write("DB2.12", Convert.ToInt16("0"));

                        }

                        repeatFlag = false;
                    }


                    CcsTagValue callBacktagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();

                    if ((callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue) )
                    {   
                        
                        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"));
                        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);
                        requestData.content = JsonConvert.SerializeObject(rFIData);
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseECSCallbackData>(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);
                            }

                        }

                    }
                    else
                    {
                        s7.ConnectClose();
                    }
                    //回调检测到失败，回调通知ecs
                    if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
                    {
                        bool failFalg = false;
                        if (!string.IsNullOrEmpty(task.FailAddress))
                        {
                            List<CcsTagValue> 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<CcsTagValue> 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<CcsTagValue> 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)
            {
                repeatFlag = false;
                Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
                return "回调异常" + ex.Message;
            }
        }

        public string getProperties<T>(T t, string propertyName)
        {
            string tStr = string.Empty;
            if (t == null)
            {
                return tStr;
            }
            System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

            if (properties.Length <= 0)
            {
                return tStr;
            }
            foreach (System.Reflection.PropertyInfo item in properties)
            {
                string name = item.Name;
                object value = item.GetValue(t, null);
                if ((item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String")) && name == propertyName)
                {
                    tStr = value.ToString();
                    break;
                }

            }
            return tStr;
        }

        public void SetProperty<T>(T t, string propertyName, object value)
        {
            // 获取对象的类型
            Type type = t.GetType();

            // 获取指定名称的属性
            PropertyInfo propertyInfo = type.GetProperty(propertyName);

            if (propertyInfo != null && propertyInfo.CanWrite)
            {
                // 设置属性值
                propertyInfo.SetValue(t, value);
            }
        }

        /// <summary>
        /// 读写回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob3()
        {
            try
            {
             
                List<TaskCallback> taskList = new List<TaskCallback>();
                var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
                if (taskCallbackListData.IsNullOrEmpty)
                {
                    taskList = await _taskCallbackService.GetAllList();
                }
                else
                {
                    taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
                }
            
                List<Device> 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<CcsTagValue> 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<ResponseECSCallbackData>(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<CcsTagValue> 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<CcsTagValue> 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<CcsTagValue> 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<ResponseECSCallbackData>(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;
            }
        }

        /// <summary>
        /// 启动机床程序回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob4()
        {
            try
            {
                

                List<TaskCallback> taskList = new List<TaskCallback>();
                var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
                if (taskCallbackListData.IsNullOrEmpty)
                {
                    taskList = await _taskCallbackService.GetAllList();
                }
                else
                {
                    taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
                }
                List<Device> 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<CcsTagValue> 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<ResponseECSCallbackData>(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<CcsTagValue> 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<CcsTagValue> 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<CcsTagValue> 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<ResponseECSCallbackData>(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;
            }
        }
        /// <summary>
        /// 启动清洗机回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob5()
        {
            try
            {
                List<TaskCallback> taskList = new List<TaskCallback>();
                var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
                if (taskCallbackListData.IsNullOrEmpty)
                {
                    taskList = await _taskCallbackService.GetAllList();
                }
                else
                {
                    taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
                }
                List<Device> 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<CcsTagValue> 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)
                    {
                        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<ResponseECSCallbackData>(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<CcsTagValue> 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<CcsTagValue> 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<CcsTagValue> 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<ResponseECSCallbackData>(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;
            }
        }
 

        /// <summary>
        /// 监控设备状态
        /// </summary> 
        /// <returns></returns>
        public async Task<string> MonitorEquipmentStatusJob()
        {
            try
            {
                string message = "MonitorEquipmentStatusJob调度成功";
                //查询全部使用设备包括不在线和离线
                string all_device_redis_key = imcs_redis_key + RedisKeyEnum.ALLDeviceList ;
                List<Device> devices = new List<Device>(); 
                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<List<Device>>(deviceListData);
                }

                List<EquipmentMonitor> equipmentMonitors = new List<EquipmentMonitor>();
                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<List<EquipmentMonitor>>(data);
                }
                //变化的设备
                List<EquipmentMonitor> changeEquipmentMonitors = new List<EquipmentMonitor>();
                foreach (EquipmentMonitor equipment in equipmentMonitors)
                {
                    Device device = devices.Where(x => x.Ip == equipment.IP).FirstOrDefault();

                    //缓存取PLC tagvalue 值
                    List<CcsTagValue> tagValues = new List<CcsTagValue>();
                    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<List<CcsTagValue>>(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<CcsTagValue> ktTagValues = new List<CcsTagValue>();
                        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<List<CcsTagValue>>(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<ProductionStatus> productionStatusList = new List<ProductionStatus>();
               
                //变化的修改 并且更新缓存
                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<Device> 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<ResponseHeidhData>(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<AlmInfo> AlmMsg = JsonConvert.DeserializeObject<List<AlmInfo>>(Result.Message);
                            //List<AlmInfo> 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<CcsTagValue> tagValues = new List<CcsTagValue>();
                        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<List<CcsTagValue>>(tagData);
                        }
                        //获取机械手报警信息
                        CcsTagValue plcWarnValue = tagValues.Where(x => x.Ip == alarmEquipment.IP && x.Address == "DB200.34").FirstOrDefault();
                        if (plcWarnValue != null && plcWarnValue.TagValue != "0")
                        { 
                            //从字典中查询具体描述
                            List<Dictionary> dictList = new List<Dictionary>() ;
                            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<List<Dictionary>>(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<ResponseECSCallbackData>(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;
            }
        }

        /// <summary>
        /// 监控设备状态
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DeviceStatusJob()
        {
            try
            {
                string message = "";
                string all_use_device_redis_key = imcs_redis_key + RedisKeyEnum.ALLUseDeviceList ;
                List<Device> devices = new List<Device>();
                //查询全部使用设备包括在线和不在线
                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<List<Device>>(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;
            }
        }
        /// <summary>
        /// 删除redis
        /// </summary> 
        /// <returns></returns>
        public void removeRedis()
        {
            List<Device> 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);
            }
        }

        /// <summary>
        /// fanuc根据类型获取值
        /// </summary> 
        /// <returns></returns>
        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;

        }

        /// <summary>
        /// 数字科学计数法处理
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 获取redis 设备在线列表
        /// </summary>
        /// <param name="strData"></param>
        /// <returns></returns>
        private async Task<List<Device>> getDeviceList()
        {
            List<Device> deviceList = new List<Device>();
            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<List<Device>>(deviceListData);
            }
            return deviceList;
        }
        /// <summary>
        /// 心跳任务
        /// </summary>
        public async Task<string> PlcHeartbeatJob()
        {
            try
            {
                SiemensS7Net s7 = DevicePlcS7.SiemensS7("192.168.1.1");
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
       
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd("S7心跳写入异常,plc连不上==>" + "192.168.1.1", 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);
                return "心跳写入异常" + ex.Message;
            }
            return "心跳写入成功";
        }

        /// <summary>
        /// 监控设备状态
        /// </summary>
        /// <returns></returns>
        public async Task<string> MonitorEquipmentStatusJob2()
        {
            try
            {
                SiemensS7Net s7 = DevicePlcS7.SiemensS7("192.168.1.1");
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {

                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd("监控设备状态写入异常,plc连不上==>" + "192.168.1.1", LOG_RESOURCE_STATE);
                    return "监控设备状态写入异常,plc连不上";
                }

                List<EquipmentMonitor> equipmentMonitors = new List<EquipmentMonitor>();
                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<List<EquipmentMonitor>>(data);
                }
                //变化的设备
                List<EquipmentMonitor> changeEquipmentMonitors = new List<EquipmentMonitor>();
                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<ProductionStatus> productionStatusList = new List<ProductionStatus>();

                //变化的修改 并且更新缓存
                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<ResponseECSCallbackData>(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;
            }
        }

        /// <summary>
        /// 拍照回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallTakePhoto()
        {   
            try
            {
                List<TaskCallback> taskList = new List<TaskCallback>();
                var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
                if (taskCallbackListData.IsNullOrEmpty)
                {
                    taskList = await _taskCallbackService.GetAllList();
                }
                else
                {
                    taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
                }
                //在线设备 
                List<Device> deviceList = await getDeviceList();

                taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.TakePhoto.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<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();

                    //系统操作模式
                    CcsTagValue tagValueMode = tagValues.Where(o => o.Address == "DB1.2").FirstOrDefault();
                    if (tagValueMode.TagValue != "257")
                    {
                        return "当前操作模式非自动并运行";
                    }

                    CcsTagValue callBacktagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();

                    if ((callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue))
                    {
                        //执行位清零
                        SiemensS7Net s7 = DevicePlcS7.SiemensS7(task.IP);
                        HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                        if (!ConnectionResult.IsSuccess)
                        {
                            Log.Instance.WriteLogAdd("回调异常，PLC连接不上==>", LOG_TITLE_CALLBACK);
                            return "回调异常，PLC连接不上==>";
                        }

                        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"));
                       

                        short resultContent = s7.ReadInt16("DB1.2090").Content;
                        Log.Instance.WriteLogAdd("任务【" + task.TaskNodeId + "】回调，拍照结果：" + resultContent, LOG_TITLE_CALLBACK);

                        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);
                        requestData.content = Convert.ToString(resultContent, 2); //拍照结果
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseECSCallbackData>(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<CcsTagValue> 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<CcsTagValue> 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<CcsTagValue> 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;
            }
        }

        /// <summary>
        /// PLC报警信息
        /// </summary> 
        /// <returns></returns>
        public async Task<string> PlcAlarm()
        {
            try
            {
                SiemensS7Net s7 = DevicePlcS7.SiemensS7("192.168.1.1");
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {

                    s7.ConnectClose();
                    return "PLC报警信息采集失败，plc连不上";
                }

                CcsActionAddress actionAddressQueryRead = new CcsActionAddress();
                actionAddressQueryRead.ActionId = 17;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQueryRead);
                string errorInfo = "@";
                foreach (CcsActionAddress actionAddress in CcsActionAddresses)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        bool result = s7.ReadBool(actionAddress.Address).Content;
                        if (result)
                        {
                            errorInfo += actionAddress.Description + "@";
                        }
                    }
                }
                string plc_alarm_redis_key = imcs_redis_key + RedisKeyEnum.PlcAlarm;
                var data = await _redisService.Database.StringGetAsync(plc_alarm_redis_key);

                if (data.IsNullOrEmpty)
                {
                    data = "@";
                    await _redisService.Database.StringSetAsync(plc_alarm_redis_key, data);
                }
                string hisErrorInfo = data.ToString();

                if (hisErrorInfo != errorInfo)
                {
                    //两次报警信息不一致
                    //主动推送同步状态数据接口
                    RequestSynStatusData requestData = new RequestSynStatusData();
                    requestData.productionStatus = errorInfo;
                    String synStatusUrl = ecsRootUrlContext + "/api/authority/synStatus/synPlcInfo";
                    var returnResult = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, synStatusUrl, requestData, null);
                    //解析回调数据结果
                    ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseECSCallbackData>(returnResult.Message);
                    if (responseECSCallback != null && responseECSCallback.code == 0)
                    {
                        Log.Instance.WriteLogAdd("同步PLC状态成功==>" + JsonConvert.SerializeObject(errorInfo), LOG_RESOURCE_STATE);
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd("同步PLC状状态操作失败==>:" + JsonConvert.SerializeObject(errorInfo) + responseECSCallback.msg, LOG_RESOURCE_STATE);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("同步PLC状态:" + ex.Message, LOG_RESOURCE_STATE);

                return "同步PLC状态 : " + ex.Message;
            }
            return "PLC报警信息采集成功";
        }

        /// <summary>
        /// 更新机床刀库回调
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallUpdateMachineTool()
        {
            List<TaskCallback> list = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(imcs_redis_key + RedisKeyEnum.CallbackTaskList);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                list = await _taskCallbackService.GetAllList();
            }
            else
            {
                list = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }

            TaskCallback task = list.Where(x => x.OperateType.Equals(ActionTypeEnum.UpdateMachineTool.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<ResponseECSCallbackData>(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;
            }
        }
    }
}