imcs_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 IMCS_CCS.Utils.DeviceProtocol;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using S7.Net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IMCS.CCS.Models;


namespace IMCS.CCS.Service.Impl
{
    /// <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 string LOG_TITLE_OPCUA = "OPCUA采集";

        private string LOG_TITLE_S7 = "S7采集";

        private string LOG_TITLE_CALLBACK = "回调任务";

        private string LOG_TITLE_DEVICE = "设备监控";

        private string callback_redis_key = "IMCS_CCS:CallbackTaskList";

        private string device_redis_key = "IMCS_CCS:DeviceList";

        public IConfiguration Configuration { get; }


        public TaskJobService(IRedisService redisService,
                              ITaskCallbackService taskCallbackService,
                              IDeviceService deviceService,
                              IApiRequestService apiRequestService,
                              ICcsTagValueService ccsTagValueService,
                              IEquipmentMonitorService equipmentMonitorService,
                              IDictionaryService dictionaryService,
                              ICcsActionAddressService ccsActionAddressService,
                              IConfiguration configuration)
        {
            _redisService = redisService;
            _taskCallbackService = taskCallbackService;
            _deviceService = deviceService;
            _apiRequestService = apiRequestService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _dictionaryService = dictionaryService;
            _ccsActionAddressService = ccsActionAddressService;
            Configuration = configuration;
            ecsUrlContext = Configuration.GetConnectionString("ecsUrlContext");
            fanucUrlContext = Configuration.GetConnectionString("fanucUrlContext");
            opcuacUrlContext = Configuration.GetConnectionString("opcuacUrlContext");
            hdhUrlContext = Configuration.GetConnectionString("hdhUrlContext");
            ecsRootUrlContext = Configuration.GetConnectionString("ecsRootUrlContext");
            syncStatusMap.Add("离线", 0);
            syncStatusMap.Add("空闲", 1);
            syncStatusMap.Add("生产中", 2);
            syncStatusMap.Add("报警", 3);
            //在线状态默认传参后台空闲状态
            syncStatusMap.Add("在线", 1);
        }

        /// <summary>
        /// 采集数据OPCUA
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectOPCUAJob()
        {
            try
            {
                List<Device> deviceList = new List<Device>();
                var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
                if (deviceListData.IsNullOrEmpty)
                {
                    deviceList = _deviceService.GetDeviceList();
                    await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
                }
                else
                {
                    deviceList = JsonConvert.DeserializeObject<List<Device>>(deviceListData);
                }

                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString())).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)
                    {
                        List<CcsTagValue> changTagValues = new List<CcsTagValue>();

                        List<string> addresses = new List<string>();
                        foreach (CcsTagValue tagValue in tagValues)
                        {
                            addresses.Add(tagValue.Address);
                        }
                        //调用opcua是否连接接口
                        RequestOpcUaData opcUaReq = new RequestOpcUaData();
                        opcUaReq.ServerUrl = device.ServerUrl;
                        opcUaReq.UserName = device.UserName;
                        opcUaReq.Password = device.Password;
                        opcUaReq.Type = OpcUaActionTypeEnum.Read.ToString();
                        opcUaReq.Addresses = addresses;
                        var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                        ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                        if (!Result.IsSuccess || !responseOpcUaData.result)
                        {
                            device.State = false;
                            await _deviceService.UpdateDevice(device);
                            Log.Instance.WriteLogAdd("OpcUA采集异常,连不上设备", LOG_TITLE_OPCUA);
                            return "采集失败，连不上设备";
                        }
                        List<string> values = responseOpcUaData.values;
                        if (values != null)
                        {
                            for (int i = 0; i < tagValues.Count; i++)
                            {
                                CcsTagValue tagValueData = (CcsTagValue)tagValues[i];
                                //科学计数法转换
                                if (values[i].Contains("E") && tagValueData.Type == TagValueReadTypeEnum.Double.ToString())
                                {
                                    Decimal d = ChangeToDecimal(values[i]);
                                    values[i] = d.ToString();
                                }
                                if (tagValueData.TagValue != values[i])
                                {
                                    tagValueData.TagValue = values[i];
                                    tagValueData.UpdateTime = DateTime.Now;
                                    changTagValues.Add(tagValueData);
                                    Log.Instance.WriteLogAdd("OpcUA采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_OPCUA);
                                    //有变化更新数据库
                                    await _ccsTagValueService.Update(tagValueData);
                                }
                            }
                        }

                        //值有变化，重新设置一次redis
                        if (changTagValues != null && changTagValues.Count > 0)
                        {
                            await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                        }


                        CcsTagValue tagQuery = new CcsTagValue();
                        tagQuery.ProtocolType = device.ProtocolType;
                        tagQuery.Ip = device.Ip;
                        tagValues = _ccsTagValueService.GetList(tagQuery);

                        //机床复位
                        CcsTagValue tagValue1 = tagValues.Where(t => t.Address == "ns=2;s=/Plc/M1500.2").FirstOrDefault();
                        CcsTagValue tagValue2 = tagValues.Where(t => t.Address == "ns=2;s=/Plc/M1500.4").FirstOrDefault();
                        if (tagValue1.TagValue == "True" && tagValue2.TagValue == "True")
                        {
                            opcUaReq.Addresses = new List<string>() { "ns=2;s=/Plc/M1999.1" };
                            opcUaReq.Values = new List<string>() { "False" };
                            opcUaReq.Type = OpcUaActionTypeEnum.Write.ToString();
                            await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                        }
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd("OpcUA采集异常,没有采集数据===", LOG_TITLE_OPCUA);
                        return "没有采集数据";
                    }
                }
                return "OpcUA采集成功";
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("OpcUA采集异常===>>" + ex.Message, LOG_TITLE_OPCUA);
                return "OpcUA采集失败";
            }
        }

        /// <summary>
        /// 采集数据S7
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectS7Job()
        {
            try
            {
                List<Device> deviceList = new List<Device>();
                var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
                if (deviceListData.IsNullOrEmpty)
                {
                    deviceList = _deviceService.GetDeviceList();
                    await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
                }
                else
                {
                    deviceList = JsonConvert.DeserializeObject<List<Device>>(deviceListData);
                }
                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString())).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连不上", LOG_TITLE_S7);
                            return "采集失败，plc连不上";
                        }
                        else
                        {
                            foreach (CcsTagValue tagValueData in tagValues)
                            {
                                //string Address = ToolUtils.AddressConvertDBW(tagValueData.Address);
                                //var operateResult = ((ushort)s7.Read(Address)).ConvertToShort();
                                string operateResult = "";
                                if (tagValueData.Type.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                                {
                                    operateResult = s7.ReadBool(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                                {
                                    operateResult = s7.ReadInt16(tagValueData.Address).Content.ToString();
                                }
                                else if (tagValueData.Type.Equals(TagValueReadTypeEnum.String.ToString()))
                                {
                                    operateResult = s7.ReadString(tagValueData.Address).Content.ToString();
                                }

                                if (!string.IsNullOrEmpty(operateResult) && tagValueData.TagValue != operateResult)
                                {
                                    tagValueData.TagValue = operateResult.ToString();
                                    tagValueData.UpdateTime = DateTime.Now;
                                    changTagValues.Add(tagValueData);
                                    Log.Instance.WriteLogAdd("S7采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
                                    //有变化更新数据库
                                    await _ccsTagValueService.Update(tagValueData);
                                }
                                Thread.Sleep(50);
                            }
                            s7.ConnectClose();
                            //值有变化，重新设置一次redis
                            if (changTagValues != null && changTagValues.Count > 0)
                            {
                                await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                            }
                        }

                    }
                }
                return "S7采集成功";
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("S7采集异常===>>" + ex.Message, LOG_TITLE_S7);
                return "S7采集失败";
            }
        }

        /// <summary>
        /// 采集数据FANUC
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DataCollectFanucJob()
        {
            try
            {
                List<Device> deviceList = new List<Device>();
                var deviceListData = await _redisService.Database.StringGetAsync(device_redis_key);
                if (deviceListData.IsNullOrEmpty)
                {
                    deviceList = _deviceService.GetDeviceList();
                    await _redisService.Database.StringSetAsync(device_redis_key, JsonConvert.SerializeObject(deviceList));
                }
                else
                {
                    deviceList = JsonConvert.DeserializeObject<List<Device>>(deviceListData);
                }
                deviceList = deviceList.Where(x => x.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString())).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>();
                        string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                        //调用发那科是否连接接口
                        var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=Connect", null, null);

                        if (!Result.IsSuccess || Result.Message != "0")
                        {
                            device.State = false;
                            await _deviceService.UpdateDevice(device);
                            Log.Instance.WriteLogAdd("FANUC采集异常,FANUC连不上", LOG_TITLE_S7);
                            return "采集失败，FANUC连不上";
                        }
                        else
                        {
                            //调用发那科采集接口
                            Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=All", null, null);
                            ResponseFanucData fanucData = JsonConvert.DeserializeObject<ResponseFanucData>(Result.Message);
                            foreach (CcsTagValue tagValueData in tagValues)
                            {
                                string operateResult = GetFanucValue(fanucData, tagValueData.Address);
                                if (tagValueData.TagValue != operateResult)
                                {
                                    tagValueData.TagValue = operateResult.ToString();
                                    tagValueData.UpdateTime = DateTime.Now;
                                    changTagValues.Add(tagValueData);
                                    Log.Instance.WriteLogAdd("FANUC采集,Ip:" + tagValueData.Ip + " 地址:" + tagValueData.Address + ",值:" + tagValueData.TagValue + ",发生变化", LOG_TITLE_S7);
                                    //有变化更新数据库
                                    await _ccsTagValueService.Update(tagValueData);
                                }
                                Thread.Sleep(50);
                            }

                            //值有变化，重新设置一次redis
                            if (changTagValues != null && changTagValues.Count > 0)
                            {
                                await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(tagValues));
                            }
                        }

                    }
                }
                return "FANUC采集成功";
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("FANUC采集异常===>>" + ex.Message, LOG_TITLE_S7);
                return "FANUC采集失败";
            }
        }

        /// <summary>
        /// 上传程序回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob1()
        {
            List<TaskCallback> list = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            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()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await _taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备
            List<Device> deviceList = _deviceService.GetDeviceList();

            taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.GetFlexibleWire.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendFlexibleWire.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.MoveRobotPosition.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.GetIntelligenceUnit.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendIntelligenceUnit.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.GetQualityCenter.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendQualityCenter.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.GetServoStacker.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendServoStacker.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendLinShift.ToString())
                                 || x.OperateType.Equals(ActionTypeEnum.SendLinShiftFine.ToString())).ToList();

            TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault() ; 
            if (task == null)
            {
                return "无回调任务" ;
            } 
            string message = "";
            try
            { 
                    DateTime currentTime = DateTime.Now;
                    CcsTagValue tagValueQuery = new CcsTagValue();
                    tagValueQuery.Ip = task.IP;
                    //tagValueQuery.Address = task.Address;
                    List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
                    CcsTagValue callBacktagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();

                    if (callBacktagValue != null && callBacktagValue.TagValue == task.CallbackValue)
                    {
                        CallBackRequestData requestData = new CallBackRequestData();
                        requestData.taskId = long.Parse(task.TaskId);
                        requestData.taskNodeId = long.Parse(task.TaskNodeId);
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<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);
                            if (result.IsSuccess)
                            {
                                task.State = false;
                                task.UpdateTime = DateTime.Now;
                                await _taskCallbackService.CreateOrUpdateAndCache(task);
                                message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + message + ",请求结果:" + result.Message + ";";
                                Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
                            }
                            else
                            {
                                message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
                                Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
                            }
                        }
                    }
 
                return string.IsNullOrEmpty(message) ? "无回调任务" : message;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("回调异常===>>" + ex.Message, LOG_TITLE_CALLBACK);
                return "回调异常" + ex.Message;
            }
        }

        /// <summary>
        /// 打标机回调任务
        /// </summary> 
        /// <returns></returns>
        public async Task<string> CallbackJob3()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await _taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备
            List<Device> deviceList = _deviceService.GetDeviceList();

            taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartLabelMachine.ToString())).ToList();
            TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
            if (task == null)
            {
                return "无回调任务";
            }
            string message = "";
            try
            {
               
                    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();
                    CcsTagValue callBacktagValue2 = tagValues.Where(o => o.Address == task.Address2).FirstOrDefault();
                    if (callBacktagValue != null && callBacktagValue2 != null && callBacktagValue.TagValue == task.CallbackValue && callBacktagValue2.TagValue == task.CallbackValue2)
                    {
                        CallBackRequestData requestData = new CallBackRequestData();
                        requestData.taskId = long.Parse(task.TaskId);
                        requestData.taskNodeId = long.Parse(task.TaskNodeId);
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseECSCallbackData>(result.Message);
                        if (result.IsSuccess && responseECSCallback.code == 0)
                        {
                            if (!string.IsNullOrEmpty(task.SuccessResetAddress))
                            {
                                Plc s7 = DevicePlcS7.S7(task.IP, ProtocalTypeEnum.S7_1500.ToString());
                                if (s7.IsConnected == true)
                                {
                                    string ResetAddress = ToolUtils.AddressConvertDBW(task.SuccessResetAddress);
                                    //short mc = 0;
                                    short mc = (short)int.Parse(task.SuccessResetValue);
                                    s7.Write(ResetAddress, mc);
                                    s7.Close();
                                }
                            }

                            task.State = false;
                            task.UpdateTime = DateTime.Now;
                            await _taskCallbackService.CreateOrUpdateAndCache(task);
                            message = task.OperateName + "==>taskId:" + task.TaskId + ",taskNodeId:" + task.TaskNodeId + ",请求结果:" + result.Message + ";";
                            Log.Instance.WriteLogAdd(message, LOG_TITLE_CALLBACK);
                        }
                        else
                        {
                            message = message + JsonConvert.SerializeObject(task) + ",请求失败! WebApi 返回结果" + ";";
                            Log.Instance.WriteLogAdd("回调异常，请求接口失败" + JsonConvert.SerializeObject(task), LOG_TITLE_CALLBACK);
                        }

                    }

                    //回调检测到失败，回调通知ecs
                    if (!string.IsNullOrEmpty(task.FailAddress) || !string.IsNullOrEmpty(task.FailAddress2) || !string.IsNullOrEmpty(task.FailAddress3))
                    {
                        bool failFalg = false;
                        if (!string.IsNullOrEmpty(task.FailAddress))
                        {
                            List<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()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await _taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备
            List<Device> deviceList = _deviceService.GetDeviceList();

            taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartNCProgram.ToString())).ToList();
            TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
            if (task == null)
            {
                return "无回调任务";
            }
            string message = "";
            try
            {
              
                    DateTime currentTime = DateTime.Now;
                    CcsTagValue tagValueQuery = new CcsTagValue();
                    tagValueQuery.Ip = task.IP;
                    //tagValueQuery.Address = task.Address;
                    List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery);
                    CcsTagValue tagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();

                    if (tagValue != null && tagValue.TagValue == task.CallbackValue)
                    {
                        CallBackRequestData requestData = new CallBackRequestData();
                        requestData.taskId = long.Parse(task.TaskId);
                        requestData.taskNodeId = long.Parse(task.TaskNodeId);
                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<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);
                            }
                        }
                    }
                
                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()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await _taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备
            List<Device> deviceList = _deviceService.GetDeviceList();

            taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.StartCleanMachine.ToString())).ToList();
            TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
            if (task == null)
            {
                return "无回调任务";
            }
            string message = "";
            try
            { 
                    DateTime currentTime = DateTime.Now;
                    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)
                    {
                        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);
                            }
                        }
                    } 
                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> CallbackJob6()
        {
            List<TaskCallback> taskList = new List<TaskCallback>();
            var taskCallbackListData = await _redisService.Database.StringGetAsync(callback_redis_key);
            if (taskCallbackListData.IsNullOrEmpty)
            {
                taskList = await _taskCallbackService.GetAllList();
            }
            else
            {
                taskList = JsonConvert.DeserializeObject<List<TaskCallback>>(taskCallbackListData);
            }
            //在线设备
            List<Device> deviceList = _deviceService.GetDeviceList();

            taskList = taskList.Where(x => x.OperateType.Equals(ActionTypeEnum.SendThreeCoordinates.ToString())).ToList();
            TaskCallback task = taskList.Where(key => deviceList.Any(device => device.Ip == key.IP)).FirstOrDefault();
            if (task == null)
            {
                return "无回调任务";
            }
            string message = "";
            try
            { 
                    DateTime currentTime = DateTime.Now;
                    CcsTagValue tagValueQuery = new CcsTagValue();
                    tagValueQuery.Ip = task.IP;
                    List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery).ToList();
                    CcsTagValue tagValue = tagValues.Where(o => o.Address == task.Address).FirstOrDefault();
                    //点位放在描述里判断左中右
                    string pos = task.Description;
                    string posValue = "";
                    int key = 0;
                    if (pos == "L")
                    {
                        posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.L);
                        key = (int)ThreeCoordinatesPosEnum.L;
                    }
                    else if (pos == "M")
                    {
                        posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.M);
                        key = (int)ThreeCoordinatesPosEnum.M;
                    }
                    else if (pos == "R")
                    {
                        posValue = EnumHelper.GetDescription(ThreeCoordinatesFinishedEnum.R);
                        key = (int)ThreeCoordinatesPosEnum.R;
                    }

                    CcsTagValue tagValue2 = tagValues.Where(o => o.Address == posValue && o.TagValue != "0").FirstOrDefault();
                    if (tagValue != null && tagValue2 != null && (tagValue.TagValue == task.CallbackValue))
                    {
                        CallBackThreeCoordinatesRequestData requestData = new CallBackThreeCoordinatesRequestData();
                        requestData.taskId = long.Parse(task.TaskId);
                        requestData.taskNodeId = long.Parse(task.TaskNodeId);

                        //查询三坐标已测量工件id和工位
                        SiemensS7Net s7 = DevicePlcS7.SiemensS7(task.IP);
                        HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                        if (!ConnectionResult.IsSuccess)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "放三坐标异常===>>" + "PLC连接不上",
                            EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                        }


                        /*  CcsActionAddress actionAddressQuery = new CcsActionAddress();
                         actionAddressQuery.Type = "CALLBACK_CHECK_COOR";
                         List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                           CcsActionAddress freeActionAdress = new CcsActionAddress();
                          //查询空闲位置
                           List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                           foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                           {
                               if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                               {
                                   var operateResult = s7.ReadInt16(actionAddress.Address);
                                   if (operateResult.ToString() == actionAddress.Value)
                                   {
                                       freeActionAdress = actionAddress;
                                       break;
                                   }
                               }
                           }
                           //判断是否可取滑台
                           if (freeActionAdress != null)
                           {*/
                        //根据sort顺序,查询左中右可取位置,写入地址列表
                        CcsActionAddress actionAddressGet = new CcsActionAddress();
                        actionAddressGet.Type = "CALLBACK_GET_COOR";
                        actionAddressGet.Sort = key;
                        List<CcsActionAddress> GetCcsActionAddresses = _ccsActionAddressService.GetList(actionAddressGet);

                        //赋值测量结果
                        requestData.result = tagValue2.TagValue;
                        //根据工件id确认哪个位置已测量,赋值工位id
                        string srcWorkId = task.CallbackFailValue3; //原工件id
                        var workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.L));
                        if (workIdResult.ToString() == srcWorkId)
                        {
                            requestData.stationId = "L";
                        }
                        if (string.IsNullOrEmpty(requestData.stationId))
                        {
                            workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.M));
                            if (workIdResult.ToString() == srcWorkId)
                            {
                                requestData.stationId = "M";
                            }
                        }
                        if (string.IsNullOrEmpty(requestData.stationId))
                        {
                            workIdResult = s7.ReadString(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.R));
                            if (workIdResult.ToString() == srcWorkId)
                            {
                                requestData.stationId = "R";
                            }
                        }

                        foreach (CcsActionAddress actionAddress in GetCcsActionAddresses)
                        {
                            if (!string.IsNullOrEmpty(actionAddress.Address))
                            {
                                if (actionAddress.Value == "workId")
                                {
                                    var operateResult = s7.ReadString(actionAddress.Address);
                                    requestData.workId = operateResult.ToString();
                                }
                                else if (actionAddress.Value == "procedureNo")
                                {
                                    var operateResult = s7.ReadString(actionAddress.Address);
                                    requestData.procedureNo = operateResult.ToString();
                                }
                                else if (actionAddress.Value == "workProgramName")
                                {
                                    var operateResult = s7.ReadString(actionAddress.Address);
                                    requestData.workProgramName = operateResult.ToString();

                                }
                            }
                        }


                        // }
                        s7.ConnectClose();

                        var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, ecsUrlContext, requestData, null);
                        ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<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);
                            }
                        }
                    } 
                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调度成功";
                List<Device> devices = new List<Device>();
                string device_redis_key = "IMCS_CCS:DeviceList";
                var deviceData = await _redisService.Database.StringGetAsync(device_redis_key);
                if (deviceData.IsNullOrEmpty)
                {
                    devices = _deviceService.GetDeviceList();
                }
                else
                {
                    devices = JsonConvert.DeserializeObject<List<Device>>(deviceData);
                }
                //ftp不监控
                devices = devices.Where(x => !x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString()) && x.State).ToList();
                CcsTagValue tagQuery = new CcsTagValue();
                List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagQuery);
                List<EquipmentMonitor> equipmentMonitors = new List<EquipmentMonitor>();
                string redis_key = "IMCS_CCS:MonitorEquipmentStatusJob";
                var data = await _redisService.Database.StringGetAsync(redis_key);
                if (data.IsNullOrEmpty)
                {
                    equipmentMonitors = await _equipmentMonitorService.GetList();
                    //首次设置redis
                    if (tagValues != null && tagValues.Count > 0)
                    {
                        await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(equipmentMonitors));
                    }
                }
                else
                {
                    equipmentMonitors = JsonConvert.DeserializeObject<List<EquipmentMonitor>>(data);
                }
                //变化的设备
                List<EquipmentMonitor> changeEquipmentMonitors = new List<EquipmentMonitor>();
                foreach (EquipmentMonitor equipment in equipmentMonitors)
                {
                    Device device = devices.Where(x => x.Ip.Equals(equipment.IP)).FirstOrDefault();
                    if (device == null)
                    {
                        if (equipment.Status != "离线")
                        {
                            equipment.Status = "离线";
                            changeEquipmentMonitors.Add(equipment);
                        }

                        continue;
                    }
                    else if (equipment.Name == "机械手")
                    {
                        CcsTagValue ccsTagValue = tagValues.Where(x => x.Ip.Equals(equipment.IP) && x.Address.Equals(equipment.Address)).FirstOrDefault();
                        if (ccsTagValue != null)
                        {
                            if (ccsTagValue.TagValue == "3")
                            {
                                if (equipment.Status != "报警")
                                {
                                    equipment.Status = "报警";
                                    changeEquipmentMonitors.Add(equipment);
                                }

                                continue;
                            }
                        }
                        CcsTagValue ccsTagValue2 = tagValues.Where(x => x.Ip.Equals(equipment.IP) && x.Address.Equals(equipment.Address2)).FirstOrDefault();
                        if (ccsTagValue2 != null)
                        {
                            if (ccsTagValue2.TagValue == "9")
                            {
                                if (equipment.Status != "报警")
                                {
                                    equipment.Status = "报警";
                                    changeEquipmentMonitors.Add(equipment);
                                }
                                continue;
                            }
                        }

                        if (ccsTagValue2.TagValue == "0" || ccsTagValue2.TagValue == "3" || ccsTagValue2.TagValue == "6" || ccsTagValue2.TagValue == "8")
                        {
                            if (equipment.Status != "空闲")
                            {
                                equipment.Status = "空闲";
                                changeEquipmentMonitors.Add(equipment);
                            }
                            continue;
                        }
                        if (equipment.Status != "生产中")
                        {
                            equipment.Status = "生产中";
                            changeEquipmentMonitors.Add(equipment);
                        }
                    }
                    else
                    {
                        if (equipment.Status != "在线")
                        {
                            equipment.Status = "在线";
                            changeEquipmentMonitors.Add(equipment);
                        }
                    }

                }
                //变化的修改 并且更新缓存
                if (changeEquipmentMonitors.Count > 0)
                {
                    List<ProductionStatus> productionStatusList = new List<ProductionStatus>();
                    foreach (EquipmentMonitor changeEquipment in changeEquipmentMonitors)
                    {
                        ProductionStatus productionStatus = new ProductionStatus();
                        productionStatus.id = changeEquipment.Id.ToString();
                        productionStatus.onlineStatus = syncStatusMap[changeEquipment.Status].ToString();
                        //equipment.Status == "离线" ? "0" : "1";
                        //productionStatus.alertMsg = equipment.AlertMsg;
                        if (productionStatus.onlineStatus != "3" && !string.IsNullOrEmpty(changeEquipment.Type))
                        {
                            if (changeEquipment.Type == "HEIDEHAIN")
                            {
                                RequestHeidhData hdhReq = new RequestHeidhData();
                                Device device = devices.Where(x => x.Ip.Equals(changeEquipment.IP)).FirstOrDefault();
                                hdhReq.ServerUrl = device.ServerUrl;
                                hdhReq.MachineName = device.UserName;
                                hdhReq.Type = OpcUaActionTypeEnum.Connect.ToString();
                                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                                if (Result.IsSuccess)
                                {
                                    ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                                    if (!string.IsNullOrEmpty(responseData.errorsInfo))
                                    {
                                        productionStatus.alertMsg = responseData.errorsInfo;
                                    }
                                }
                            }
                            else if (changeEquipment.Type == "FANUC")
                            {
                                Device device = devices.Where(x => x.Ip.Equals(changeEquipment.IP)).FirstOrDefault();
                                string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                                //调用发那科接口
                                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=AlmInfo", null, null);
                                if (Result.IsSuccess)
                                {
                                    ResponseFanucData fncReq = new ResponseFanucData();
                                    fncReq = JsonConvert.DeserializeObject<ResponseFanucData>(Result.Message);
                                    List<AlmInfo> AlmMsg = fncReq.AlmMsg;
                                    if (AlmMsg != null && AlmMsg.Count > 0)
                                    {
                                        var msgs = from o in AlmMsg select o.msg;
                                        productionStatus.alertMsg = string.Join(",", msgs.ToArray());
                                    }
                                }
                            }
                        }
                        else
                        {
                            //获取机械手报警信息
                            CcsTagValue plcWarnValue = tagValues.Where(x => x.Ip.Equals(changeEquipment.IP) && x.Address.Equals("DB200.34")).FirstOrDefault();
                            if (plcWarnValue != null)
                            {
                                ToolDto ccsDictionary = new ToolDto();
                                ccsDictionary.Type = "PlcWarnInfo";

                                List<ToolDto> dictList = await _dictionaryService.GetList(ccsDictionary);
                                if (dictList.Count > 0 && dictList[0] != null)
                                {
                                    ToolDto dictObj = dictList.Where(x => x.Code.Equals(plcWarnValue.TagValue) && x.state).FirstOrDefault();
                                    if (!string.IsNullOrEmpty(dictObj.DictValue.Trim()))
                                    {
                                        productionStatus.alertMsg = dictObj.DictValue.Trim();
                                    }
                                }
                            }
                        }
                        productionStatusList.Add(productionStatus);
                        await _equipmentMonitorService.Update(changeEquipment);
                    }
                    await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(equipmentMonitors));


                    //主动推送同步状态数据接口
                    RequestSynStatusData requestData = new RequestSynStatusData();
                    requestData.productionStatus = JsonConvert.SerializeObject(productionStatusList);
                    String synStatusUrl = ecsRootUrlContext + "api/authority/synStatus/synProductionStatus";
                    var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, synStatusUrl, requestData, null);
                    //解析回调数据结果
                    ResponseECSCallbackData responseECSCallback = JsonConvert.DeserializeObject<ResponseECSCallbackData>(result.Message);
                    if (responseECSCallback != null && responseECSCallback.code == 0)
                    {
                        Log.Instance.WriteLogAdd("同步设备状态成功", LOG_TITLE_CALLBACK);
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd("同步设备状态操作失败:" + responseECSCallback.msg, LOG_TITLE_CALLBACK);
                    }
                }
                return message;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("MonitorEquipmentStatusJob:" + ex.Message, LOG_TITLE_DEVICE);

                return "MonitorEquipmentStatusJob : " + ex.Message;
            }
        }

        /// <summary>
        /// 监控设备状态
        /// </summary> 
        /// <returns></returns>
        public async Task<string> DeviceStatusJob()
        {
            try
            {
                string message = "";
                List<Device> devices = new List<Device>();
                List<Device> changeDevices = new List<Device>();
                string redis_key = "IMCS_CCS:DeviceList";
                var data = await _redisService.Database.StringGetAsync(redis_key);
                if (data.IsNullOrEmpty)
                {
                    devices = _deviceService.GetDeviceAllList();
                    await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(devices));
                }
                else
                {
                    devices = JsonConvert.DeserializeObject<List<Device>>(data);
                }

                //ftp不监控
                devices = devices.Where(x => !x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).ToList();
                foreach (Device device in devices)
                {
                    if (device.ProtocolType.Equals(ProtocalTypeEnum.S7_1500.ToString()))
                    {
                        try
                        {

                            Plc s7 = DevicePlcS7.S7(device.ServerUrl, ProtocalTypeEnum.S7_1500.ToString());

                            if (s7.IsConnected != true)
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (oldDevice.State)
                                {
                                    device.State = false;
                                    await _deviceService.UpdateDevice(device);
                                    changeDevices.Add(device);
                                }
                                s7.Close();
                                Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
                                message = message + ",plc连接失败,或已离线，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
                                continue;
                            }
                            else
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (!oldDevice.State)
                                {
                                    device.State = true;
                                    await _deviceService.UpdateDevice(device);
                                    changeDevices.Add(device);
                                }
                                s7.Close();
                                Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
                                message = message + ",plc连接成功，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
                                continue;
                            }
                        }
                        catch (Exception s7ex)
                        {
                            Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                            if (oldDevice.State)
                            {
                                device.State = false;
                                await _deviceService.UpdateDevice(device);
                                changeDevices.Add(device);
                            }
                            Log.Instance.WriteLogAdd("plc连接失败,或已离线", LOG_TITLE_DEVICE);
                            message = message + ",plc连接失败，plc连不上" + s7ex.Message + "，ip:" + device.Ip + ",协议类型:" + device.ProtocolType;
                        }
                    }
                    else if (device.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString()))
                    {
                        try
                        {
                            //调用opcua是否连接接口
                            RequestOpcUaData opcUaReq = new RequestOpcUaData();
                            opcUaReq.ServerUrl = device.ServerUrl;
                            opcUaReq.UserName = device.UserName;
                            opcUaReq.Password = device.Password;
                            opcUaReq.Type = OpcUaActionTypeEnum.Connect.ToString();
                            var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                            ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                            if (!Result.IsSuccess || !responseOpcUaData.result)
                            {
                                device.State = false;
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (oldDevice.State)
                                {
                                    await _deviceService.UpdateDevice(device);
                                    changeDevices.Add(device);
                                }
                                Log.Instance.WriteLogAdd("OPCUA连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
                                message = message + ",OPCUA连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
                                continue;
                            }
                            else
                            {
                                device.State = true;
                                await _deviceService.UpdateDevice(device);
                                changeDevices.Add(device);
                                Log.Instance.WriteLogAdd("OPCUA连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
                                continue;
                            }
                        }
                        catch (Exception opcex)
                        {
                            Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                            if (oldDevice.State)
                            {
                                device.State = false;
                                await _deviceService.UpdateDevice(device);
                                changeDevices.Add(device);
                            }
                            Log.Instance.WriteLogAdd("OPCUA连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
                            continue;
                        }
                    }
                    else if (device.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString()))
                    {
                        try
                        {
                            string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                            //调用发那科是否连接接口
                            var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=Connect", null, null);

                            if (Result.IsSuccess && Result.Message == "0")
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (!oldDevice.State)
                                {
                                    oldDevice.State = true;
                                    await _deviceService.UpdateDevice(oldDevice);
                                    changeDevices.Add(oldDevice);
                                }
                                Log.Instance.WriteLogAdd("Fanuc连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
                                continue;
                            }
                            else
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (oldDevice.State)
                                {
                                    oldDevice.State = false;
                                    await _deviceService.UpdateDevice(oldDevice);
                                    changeDevices.Add(oldDevice);
                                }
                                Log.Instance.WriteLogAdd("Fanuc连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
                                message = message + ",Fanuc连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
                                continue;
                            }
                        }
                        catch (Exception opcex)
                        {
                            Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                            if (oldDevice.State)
                            {
                                oldDevice.State = false;
                                await _deviceService.UpdateDevice(oldDevice);
                                changeDevices.Add(oldDevice);
                            }
                            Log.Instance.WriteLogAdd("Fanuc连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
                            continue;
                        }
                    }
                    else if (device.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString()))
                    {
                        try
                        {
                            RequestHeidhData hdhReq = new RequestHeidhData();
                            hdhReq.ServerUrl = device.ServerUrl;
                            hdhReq.MachineName = device.UserName;
                            hdhReq.Type = OpcUaActionTypeEnum.Connect.ToString();
                            var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                            ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);

                            if (!Result.IsSuccess || !responseData.result)
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (oldDevice.State)
                                {
                                    oldDevice.State = false;
                                    await _deviceService.UpdateDevice(oldDevice);
                                    changeDevices.Add(oldDevice);
                                }
                                Log.Instance.WriteLogAdd("海德汉连接异常,或已离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_OPCUA);
                                message = message + ",海德汉连接异常，或以离线,ip:" + device.Ip + ",协议类型:" + device.ProtocolType; ;
                                continue;
                            }
                            else
                            {
                                Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                                if (!oldDevice.State)
                                {
                                    oldDevice.State = true;
                                    await _deviceService.UpdateDevice(oldDevice);
                                    changeDevices.Add(oldDevice);
                                }
                                Log.Instance.WriteLogAdd("海德汉连接成功,ip:" + device.Ip + ",协议类型:" + device.ProtocolType, LOG_TITLE_DEVICE);
                                continue;
                            }
                        }
                        catch (Exception opcex)
                        {
                            Device oldDevice = await _deviceService.GetDeviceById(device.Id);
                            if (oldDevice.State)
                            {
                                oldDevice.State = false;
                                await _deviceService.UpdateDevice(oldDevice);
                                changeDevices.Add(oldDevice);
                            }
                            Log.Instance.WriteLogAdd("Fanuc连接异常,或以离线" + opcex.Message + ",ip:" + device.Ip + ", 协议类型: " + device.ProtocolType, LOG_TITLE_DEVICE);
                            continue;
                        }
                    }
                }
                if (changeDevices != null)
                {
                    await _redisService.Database.StringSetAsync(redis_key, JsonConvert.SerializeObject(devices));
                }
                return message;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("设备连接异常,或以离线" + ex.Message, LOG_TITLE_DEVICE);

                return "设备连接异常,或以离线" + ex.Message;
            }
        }
        /// <summary>
        /// 删除redis
        /// </summary> 
        /// <returns></returns>
        public void removeRedis()
        {
            List<Device> devices = _deviceService.GetDeviceAllList();
            string redis_key = "IMCS_CCS:";
            _redisService.Database.KeyDelete(device_redis_key);
            _redisService.Database.KeyDelete(callback_redis_key);
            foreach (Device device in devices)
            {
                _redisService.Database.KeyDelete(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;
        } 
    }
}