331_ccs/IMCS_CCS/Service/Impl/HttpRequestService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading;
using IMCS.CCS.Entitys;
using IMCS.CCS.Models.vo;
using IMCS.CCS.Models;
using IMCS.CCS.DeviceProtocol;
using System;
using S7.Net;
using IMCS_CCS.Utils;
using Newtonsoft.Json;
using IMCS_CCS.Utils.DeviceProtocol;
using HslCommunication.Profinet.Siemens;
using Microsoft.Extensions.Configuration;
using IMCS.CCS.Service;
using IMCS_CCS.Model.vo;
using FTP;
using HslCommunication;
using System.Text.RegularExpressions;
using System.IO;
using Org.BouncyCastle.Ocsp;
using MySqlX.XDevAPI.Common;
using IMCS_CCS.Service.Impl;
using IMCS_CCS.Service;
using IMCS_CCS.Entitys;
using static Google.Protobuf.Reflection.SourceCodeInfo.Types;
using Newtonsoft.Json.Linq;
using static AutoMapper.Internal.ExpressionFactory;
using Microsoft.EntityFrameworkCore.Internal;

namespace IMCS.CCS.Services
{
    public class HttpRequestService : IHttpRequestService
    {
        private readonly IDeviceService _deviceService;

        private readonly ITaskCallbackService _taskCallbackService;

        private readonly ICcsActionService _ccsActionService;

        private readonly ICcsTagValueService _ccsTagValueService;

        private readonly IEquipmentMonitorService _equipmentMonitorService;

        private readonly ICcsActionAddressService _ccsActionAddressService;

        private readonly ITaskJobService _taskJobService;

        private readonly ICcsActionDeviceSourceCheckService _ccsActionDeviceSourceCheckService;

        private int SLEEP_TIME = 100;

        string LocalPath = "D:\\PROG";

        private string fanucUrlContext;

        private string opcuacUrlContext;

        private string hdhUrlContext; 

        private string ecsRootUrlContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

        // 物料装载站
        private static Dictionary<string, string> shangLiaoQaingQiu = new Dictionary<string, string>();
        private static Dictionary<string, string> xiaLiaoQaingQiu = new Dictionary<string, string>();
        private static Dictionary<string, string> shangLiaoZhuangTai = new Dictionary<string, string>();
        private static Dictionary<string, string> xiaLiaoZhuangTai = new Dictionary<string, string>();

        // 刀具装载站
        private static Dictionary<string, string> cutterPutRequest = new Dictionary<string, string>();
        private static Dictionary<string, string> cutterTakeRequest = new Dictionary<string, string>();
        private static Dictionary<string, string> cutterPutStatus = new Dictionary<string, string>();
        private static Dictionary<string, string> cutterTakeStatus = new Dictionary<string, string>();

        public HttpRequestService(IDeviceService deviceService, ITaskCallbackService taskCallbackService,
                                  ICcsActionService ccsActionService, ICcsTagValueService ccsTagValueService,
                                  IEquipmentMonitorService equipmentMonitorService, ICcsActionAddressService ccsActionAddressService,
                                  IApiRequestService apiRequestService, ITaskJobService taskJobService, ICcsActionDeviceSourceCheckService ccsActionDeviceSourceCheckService,
                                  IConfiguration configuration)
        {
            _deviceService = deviceService;
            _taskCallbackService = taskCallbackService;
            _ccsActionService = ccsActionService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _ccsActionAddressService = ccsActionAddressService;
            _apiRequestService = apiRequestService;
            _taskJobService = taskJobService;
            _ccsActionDeviceSourceCheckService = ccsActionDeviceSourceCheckService;
            Configuration = configuration;
            fanucUrlContext = Configuration.GetConnectionString("fanucUrlContext");
            opcuacUrlContext = Configuration.GetConnectionString("opcuacUrlContext");
            hdhUrlContext = Configuration.GetConnectionString("hdhUrlContext"); 
            ecsRootUrlContext = Configuration.GetConnectionString("ecsRootUrlContext");

            if (shangLiaoQaingQiu.Count == 0) {
                shangLiaoQaingQiu.Add("LAUP000101", "DB1001.784.1");
                shangLiaoQaingQiu.Add("LAUP000102", "DB1001.784.2");
            }
            if (xiaLiaoQaingQiu.Count == 0) {
                xiaLiaoQaingQiu.Add("LAUP000101", "DB1001.782.1");
                xiaLiaoQaingQiu.Add("LAUP000102", "DB1001.782.2");
            }
            if (shangLiaoZhuangTai.Count == 0) {
                shangLiaoZhuangTai.Add("LAUP000101", "DB1000.294.1");
                shangLiaoZhuangTai.Add("LAUP000102", "DB1000.294.2");
            }
            if (xiaLiaoZhuangTai.Count == 0) {
                xiaLiaoZhuangTai.Add("LAUP000101", "DB1000.296.1");
                xiaLiaoZhuangTai.Add("LAUP000102", "DB1000.296.2");
            }

            if (cutterPutRequest.Count == 0)
            {
                cutterPutRequest.Add("LAUPT00101", "DB1001.788.1");
                cutterPutRequest.Add("LAUPT00102", "DB1001.788.2");
            }
            if (cutterTakeRequest.Count == 0)
            {
                cutterTakeRequest.Add("LAUPT00101", "DB1001.786.1");
                cutterTakeRequest.Add("LAUPT00102", "DB1001.786.2");
            }
            if (cutterPutStatus.Count == 0) {
                cutterPutStatus.Add("LAUPT00101", "DB1000.322.1");
                cutterPutStatus.Add("LAUPT00102", "DB1000.322.2");
            }
            if (cutterTakeStatus.Count == 0)
            {
                cutterTakeStatus.Add("LAUPT00101", "DB1000.324.1");
                cutterTakeStatus.Add("LAUPT00102", "DB1000.324.2");
            }


        }

        /// <summary>
        /// 获取状态当前值
        /// </summary> 
        public string GetTagValue(RequestTagValueData req)
        {
            CcsTagValue queryParam = new CcsTagValue();
            queryParam.Ip = req.ip;
            queryParam.Address = req.tagname;
            List<CcsTagValue> tagValues = _ccsTagValueService.GetList(queryParam);
            string tagValue = "0";
            if (tagValues != null && tagValues.Count > 0)
            {
                tagValue = tagValues[0].TagValue;
            }
            return tagValue;

        }

        /// <summary>
        /// 益模调用接口，显示3D
        /// </summary> 
        public async Task<List<ResponseDigitalTwinsData>> GetDigitalTwins()
        {
            List<Device> devices = _deviceService.GetDeviceList();            
            List<ResponseDigitalTwinsData> list = new List<ResponseDigitalTwinsData>();

            String query3dUrl = ecsRootUrlContext + "/api/authority/agv/agvCallbackService/query3dResouceDataInfo";
            var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, query3dUrl, new Object(), null);
            ResponsePageData<ResponseDigitalTwinsData> responseData = JsonConvert.DeserializeObject<ResponsePageData<ResponseDigitalTwinsData>>(result.Message);
            list = responseData.Data;
            foreach(ResponseDigitalTwinsData responseDigitalTwinsData in list)
            {
                EquipmentMonitor equipmentMonitor = await _equipmentMonitorService.GetById(long.Parse(responseDigitalTwinsData.resourceId));
                if (equipmentMonitor==null || equipmentMonitor.IP == null)
                {
                    continue;
                }
                Device device = devices.Where(x => x.Ip.Equals(equipmentMonitor.IP)).FirstOrDefault();
                if (null!=device && equipmentMonitor.Type == "HEIDEHAIN")
                {
                    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);
                    if (Result.IsSuccess)
                    {
                        ResponseHeidhData retData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                        if (!string.IsNullOrEmpty(retData.runDatasInfo.Trim()))
                        {                            
                            ResponseDigitalTwinsData twinsData = JsonConvert.DeserializeObject<ResponseDigitalTwinsData>(retData.runDatasInfo);
                            responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(twinsData.feedRate)? twinsData.feedRate : "0";
                            responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(twinsData.spindleMagnification)? twinsData.spindleMagnification:"0";
                            responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(twinsData.spindleSpeed) ? twinsData.spindleSpeed + "00" : "0";
                            responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(twinsData.spindleLoad) ? twinsData.spindleMagnification : "-";
                        }
                    }
                }
                else if(null != device && equipmentMonitor.Type == "FANUC")
                {
                    string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                    //调用发那科接口
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=All", null, null);

                    if (Result.IsSuccess)
                    {
                        ResponseFanucData responseFanucData = JsonConvert.DeserializeObject<ResponseFanucData>(Result.Message);
                        responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(responseFanucData.ActFeed)? responseFanucData.ActFeed:"0";
                        responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(responseFanucData.SpindleMagnification)? responseFanucData.SpindleMagnification:"0";
                        responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(responseFanucData.ActSpindle)? responseFanucData.ActSpindle : "0";
                        responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(responseFanucData.SpindleLoad)? responseFanucData.SpindleLoad : "-";
                    }
                }
            }

            return list;

        }

        /// <summary>
        /// 查询设备状态
        /// </summary> 
        public async Task<List<EquipmentMonitor>> GetEquipMent()
        {
            return await _equipmentMonitorService.GetList();

        }
     

        /// <summary>
        /// 机器人取放动作
        /// </summary> 
        public async Task<ResponseECSData> RobotAction(RequestData<LocationData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId,"执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线："+ req.url;
                    return responseData;
                } 

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.RobotAction.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 检查出发地，目的地比对数据开始====
                if (req.data.LocationDevice != null)
                {  // 判断取料设备是否满足条件
                    CcsActionDeviceSourceCheck ccsActionDeviceSourceCheck = new CcsActionDeviceSourceCheck();
                    ccsActionDeviceSourceCheck.Type = CcsActionDeviceSourceCheckTypeEnum.CHECK.ToString();
                    ccsActionDeviceSourceCheck.ActionId = actionInfo.Id;
                    ccsActionDeviceSourceCheck.DeviceCode = req.data.LocationDevice;
                    ccsActionDeviceSourceCheck.DeviceSource = "out";
                    ResponseECSCallbackData callbackData = _ccsActionDeviceSourceCheckService.checkDataAddress(ccsActionDeviceSourceCheck, s7);

                    if (!callbackData.isSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====" + callbackData.msg + "====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = callbackData.msg;
                        return responseData;
                    }
                }

                if (req.data.DestLocationDevice != null)
                {
                    CcsActionDeviceSourceCheck ccsActionDeviceSourceCheck = new CcsActionDeviceSourceCheck();
                    ccsActionDeviceSourceCheck.Type = CcsActionDeviceSourceCheckTypeEnum.CHECK.ToString();
                    ccsActionDeviceSourceCheck.ActionId = actionInfo.Id;
                    ccsActionDeviceSourceCheck.DeviceCode = req.data.DestLocationDevice;
                    ccsActionDeviceSourceCheck.DeviceSource = "in";
                    ResponseECSCallbackData callbackData = _ccsActionDeviceSourceCheckService.checkDataAddress(ccsActionDeviceSourceCheck, s7);

                    if (!callbackData.isSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====" + callbackData.msg + "====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = callbackData.msg;
                        return responseData;
                    }
                }
                // 检查出发地，目的地比对数据结束===

                //=========================上下料站请求判断 开始======================
                // 目标点位是上下料站的判断下料请求是否为true，上料请求为false,
                // 如果不是判断上料请求是否为true，
                // 是提示状态不对，否则写下料请求状态

                // 上料料请求
                if (shangLiaoQaingQiu.ContainsKey(req.data.DestLocation)) {
                    string shangliaoqingqiuDB = shangLiaoQaingQiu[req.data.DestLocation];
                    string xialiaoqingqiuDB = xiaLiaoQaingQiu[req.data.DestLocation];
                    string shangliaoyunxuDB = shangLiaoZhuangTai[req.data.DestLocation];
                    string xialiaoyunxuDB = xiaLiaoZhuangTai[req.data.DestLocation];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(shangliaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====已发送上料请求，等待上料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送上料请求，等待上料允许";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "False" && xialiaoqingqiu == "True")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====状态不对，现在下料请求状态，等待下料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被下料请求占用，等待下料任务完成";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "True" && shangliaoyunxu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====已经发送上料请求，上料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送上料请求，上料允许状态不满";
                        return responseData;
                    }

                }

                // 下料允许
                if (xiaLiaoQaingQiu.ContainsKey(req.data.Location))
                {

                    string shangliaoqingqiuDB = shangLiaoQaingQiu[req.data.Location];
                    string xialiaoqingqiuDB = xiaLiaoQaingQiu[req.data.Location];
                    string shangliaoyunxuDB = shangLiaoZhuangTai[req.data.Location];
                    string xialiaoyunxuDB = xiaLiaoZhuangTai[req.data.Location];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(xialiaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====已发送下料请求，等待下料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送上料请求，等待上料允许";
                        return responseData;
                    }else if (shangliaoqingqiu == "True" && xialiaoqingqiu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====状态不对，现在上料请求状态，等待上料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被上料请求占用，等待上料任务完成";
                        return responseData;
                    }
                    else if (xialiaoqingqiu == "True" && xialiaoyunxu == "False") {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "====已经发送下料请求，下料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送下料请求，下料允许状态不满足";
                        return responseData;
                    } 
                }
                //=========================上下料站请求判断 结束======================


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery); 
               
                //查询出需要检查的地址列表
                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))
                    {



                        string operateResult = "";
                        if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                        {
                            operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                        {
                            operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                        {
                            operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                        {
                            operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }

                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult +"，要查询的参数"+ JsonConvert.SerializeObject(actionAddress) +", 请求参数"+ JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        // 写入取放点位、需要进行点位拼接
                        if (actionAddress.Sort == 1)
                        {
                            //区域块为七位，点位为三位
                            //parValue = req.data.LocationArea.PadRight(7,'0')+ req.data.Location.PadLeft(3, '0') + req.data.DestLocationArea.PadRight(7, '0') + req.data.DestLocation.PadLeft(3, '0');
                            parValue =req.data.Location + req.data.DestLocation;
                            s7.Write(actionAddress.Address, Convert.ToString(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            // 需要写入启动状态
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = req.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }


                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.RobotAction.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
               
                // 保存数据
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "取成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                return responseData;
            }
            catch (Exception ex)
            {
                // 记录日志
                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                responseData.resultMsg = ActionTypeEnum.RobotAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";

                // 关闭plc连接
                if (s7 != null)
                {
                    s7.ConnectClose();
                }
                return responseData;
            }
        }


        /// <summary>
        /// 天轨机器人取放动作
        /// </summary> 
        /// 

        public async Task<ResponseECSData> CutterRobotAction(RequestData<CutterLocationData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.CutterRobotAction.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.CutterRobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 检查出发地，目的地比对数据开始====
                if (req.data.LocationDevice != null)
                {  // 判断取料设备是否满足条件
                    CcsActionDeviceSourceCheck ccsActionDeviceSourceCheck = new CcsActionDeviceSourceCheck();
                    ccsActionDeviceSourceCheck.Type = CcsActionDeviceSourceCheckTypeEnum.CHECK.ToString();
                    ccsActionDeviceSourceCheck.ActionId = actionInfo.Id;
                    ccsActionDeviceSourceCheck.DeviceCode = req.data.LocationDevice;
                    ccsActionDeviceSourceCheck.DeviceSource = "out";
                    ResponseECSCallbackData callbackData = _ccsActionDeviceSourceCheckService.checkDataAddress(ccsActionDeviceSourceCheck, s7);

                    if (!callbackData.isSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====" + callbackData.msg + "====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = callbackData.msg;
                        return responseData;
                    }
                }

                if (req.data.DestLocationDevice != null)
                {
                    CcsActionDeviceSourceCheck ccsActionDeviceSourceCheck = new CcsActionDeviceSourceCheck();
                    ccsActionDeviceSourceCheck.Type = CcsActionDeviceSourceCheckTypeEnum.CHECK.ToString();
                    ccsActionDeviceSourceCheck.ActionId = actionInfo.Id;
                    ccsActionDeviceSourceCheck.DeviceCode = req.data.DestLocationDevice;
                    ccsActionDeviceSourceCheck.DeviceSource = "in";
                    ResponseECSCallbackData callbackData = _ccsActionDeviceSourceCheckService.checkDataAddress(ccsActionDeviceSourceCheck, s7);

                    if (!callbackData.isSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====" + callbackData.msg + "====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = callbackData.msg;
                        return responseData;
                    }
                }
                // 检查出发地，目的地比对数据结束===


                //=========================上下料站请求判断 开始======================
                // 目标点位是上下料站的判断下料请求是否为true，上料请求为false,
                // 如果不是判断上料请求是否为true，
                // 是提示状态不对，否则写下料请求状态

                // 上料料请求
                if (cutterPutRequest.ContainsKey(req.data.DestLocation))
                {
                    string shangliaoqingqiuDB = cutterPutRequest[req.data.DestLocation];
                    string xialiaoqingqiuDB = cutterTakeRequest[req.data.DestLocation];
                    string shangliaoyunxuDB = cutterPutStatus[req.data.DestLocation];
                    string xialiaoyunxuDB = cutterTakeStatus[req.data.DestLocation];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(shangliaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已发送上料请求，等待上料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送上料请求，等待上料允许";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "False" && xialiaoqingqiu == "True")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====状态不对，现在下料请求状态，等待下料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被下料请求占用，等待下料任务完成";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "True" && shangliaoyunxu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已经发送上料请求，上料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送上料请求，上料允许状态不满";
                        return responseData;
                    }

                }

                // 下料允许
                if (cutterTakeRequest.ContainsKey(req.data.Location))
                {

                    string shangliaoqingqiuDB = cutterPutRequest[req.data.Location];
                    string xialiaoqingqiuDB = cutterTakeRequest[req.data.Location];
                    string shangliaoyunxuDB = cutterPutStatus[req.data.Location];
                    string xialiaoyunxuDB = cutterTakeStatus[req.data.Location];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(xialiaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已发送下料请求，等待下料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送下料请求，等待下料允许";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "True" && xialiaoqingqiu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====状态不对，现在上料请求状态，等待上料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被上料请求占用，等待上料任务完成";
                        return responseData;
                    }
                    else if (xialiaoqingqiu == "True" && xialiaoyunxu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已经发送下料请求，下料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送下料请求，下料允许状态不满足";
                        return responseData;
                    }
                }
                //=========================上下料站请求判断 结束======================


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        // 写入取放点位、需要进行点位拼接
                        if (actionAddress.Sort == 1)
                        {
                            //区域块为七位，点位为三位
                            //parValue = req.data.LocationArea.PadRight(7,'0')+ req.data.Location.PadLeft(3, '0') + req.data.DestLocationArea.PadRight(7, '0') + req.data.DestLocation.PadLeft(3, '0');
                            parValue = req.data.Location + req.data.DestLocation;
                            s7.Write(actionAddress.Address, Convert.ToString(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            // 需要写入启动状态
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }
                        else if (actionAddress.Sort == 3)
                        {
                            // 写入源刀位号
                            parValue = req.data.LocationNo;
                            if (req.data.LocationNo == null || req.data.LocationNo == "")
                            {
                                parValue = "0";
                            }
                            s7.Write(actionAddress.Address, Convert.ToByte(parValue));
                        }
                        else if (actionAddress.Sort == 4)
                        {
                            // 写入目的刀位号
                            parValue = req.data.DestLocationNo;
                            if (req.data.DestLocationNo == null || req.data.DestLocationNo == "")
                            {
                                parValue = "0";
                            }
                            s7.Write(actionAddress.Address, Convert.ToByte(parValue));
                        }
                        else if (actionAddress.Sort == 5) {
                            parValue = req.data.rfid;
                            s7.Write(actionAddress.Address, Convert.ToInt16(parValue));
                        }

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = req.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }


                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.CutterRobotAction.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);

                // 保存数据
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction) + "取成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                return responseData;
            }
            catch (Exception ex)
            {
                // 记录日志
                Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                responseData.resultMsg = ActionTypeEnum.CutterRobotAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";

                // 关闭plc连接
                if (s7 != null)
                {
                    s7.ConnectClose();
                }
                return responseData;
            }
        }

        /// <summary>
        /// CNC刀具库请求上下料动作
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public async Task<ResponseECSData> CutterDeviceTakeOrPutRequest(RequestData<CutterLocationData> req)
        {
            Log.Instance.WriteLogAdd("CNC刀具库请求上下料动作===>> " + JsonConvert.SerializeObject(req), "CNC刀具库请求上下料动作");

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.CutterCncDeviceAction + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterCncDeviceAction));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.CutterCncDeviceAction.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.CutterCncDeviceAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterCncDeviceAction));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.CutterCncDeviceAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.CutterCncDeviceAction + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.CutterCncDeviceAction));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        // 写入取放点位、需要进行点位拼接
                        if (actionAddress.Sort == 1)
                        {

                            string before = "EMPTY00000";
                            if (req.data.Location != null && req.data.Location.Length>0) {

                                int separatorIndex = req.data.LocationNo.IndexOf(".");
                                string substring = req.data.LocationNo.Substring(separatorIndex+1); // 从第7个字符开始截取5个字符
                                int num = int.Parse(substring);
                                string formatted = num.ToString("D2");  

                                before = "ATC00" + formatted + req.data.Location.Substring(7, 3);
                            }
                            string theTail = "EMPTY00000";
                            if (req.data.DestLocation != null && req.data.DestLocation.Length>0) {

                                int separatorIndex = req.data.DestLocationNo.IndexOf(".");
                                string substring = req.data.DestLocationNo.Substring(separatorIndex+1); // 从第7个字符开始截取5个字符
                                int num = int.Parse(substring);
                                string formatted = num.ToString("D2");


                                theTail = "ATC00" + formatted + req.data.DestLocation.Substring(7, 3);
                            }
                            parValue = before + theTail;

                            s7.Write(actionAddress.Address, Convert.ToString(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            // 需要写入启动状态
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }
                        

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = req.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }


                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();
                
                return responseData;
            }
            catch (Exception ex)
            {
                // 记录日志
                Log.Instance.WriteLogAdd(ActionTypeEnum.CutterCncDeviceAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.CutterCncDeviceAction));
                responseData.resultMsg = ActionTypeEnum.CutterCncDeviceAction + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";

                // 关闭plc连接
                if (s7 != null)
                {
                    s7.ConnectClose();
                }
                return responseData;
            }
        }




        /// <summary>
        /// 上传文件
        /// </summary> 
        public async Task<ResponseECSData> UploadFile(RequestData<UploadFileData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

            try
            {
                List<Device> devices = _deviceService.GetDeviceList();
                Device deviceFtp = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).FirstOrDefault();
                Device deviceOpcUa = devices.Where(x => x.Ip.Equals(req.url)
                                           && x.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString())).FirstOrDefault();
           
                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceOpcUa == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }
                //西门子系统上传
                if (deviceOpcUa != null)
                {
                    RequestOpcUaData opcUaReq = new RequestOpcUaData();
                    opcUaReq.ServerUrl = deviceOpcUa.ServerUrl;
                    opcUaReq.UserName = deviceOpcUa.UserName;
                    opcUaReq.Password = deviceOpcUa.Password;
                    opcUaReq.Path = req.data.fileName;
                    opcUaReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (!Result.IsSuccess || !responseOpcUaData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        responseData.resultMsg = Result.Message;
                        return responseData;
                    }
                }
                else if(deviceHeidenhain != null)
                { 
                 
                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                    hdhReq.MachineName = deviceHeidenhain.UserName;
                    hdhReq.Path = req.data.fileName;
                    hdhReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    //远程机床相对路径
                    hdhReq.Address = req.data.remotePath;
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "预上传异常===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        responseData.resultMsg = responseHeidhData.msg;
                        return responseData;
                    }  
                }  
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.UploadFile.ToString(),
                EnumHelper.GetDescription(ActionTypeEnum.UploadFile), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传成功===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.resultMsg = ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";
                return responseData;
            }
        }

       
        /// <summary>
        /// 启动机床程序
        /// </summary> 
        public async Task<ResponseECSData> StartNCProgram(RequestData<StartNCProgramData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.StartNCProgram + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartNCProgram.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                //opcua启动程序
                if (actionInfo.ProtocolType == ProtocalTypeEnum.OPCUA.ToString())
                { 
                    //插入回调
                    //获取启动前放的 工位
                    TaskCallback queryTaskCallBack = new TaskCallback();
                    queryTaskCallBack.IP = actionInfo.PlcIp;
                    queryTaskCallBack.Description = ProtocalTypeEnum.OPCUA.ToString();
                    TaskCallback TaskBean = await _taskCallbackService.GetRobotActionList(queryTaskCallBack);

                    TaskCallback taskCallbackData = new TaskCallback(actionInfo.PlcIp, ActionTypeEnum.StartNCProgram.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram), req.taskId, req.taskNodeId);
                    taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                    taskCallbackData.Description = ProtocalTypeEnum.OPCUA.ToString();
                    if(TaskBean != null)
                    {
                        taskCallbackData.Data = TaskBean.Data;
                    }
                    else
                    {
                       Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "失败,上一放动作 没有工位信息===>>" + JsonConvert.SerializeObject(req),
                      EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        return responseData;
                    }
                    
                    await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    return responseData; 

                }  else if (actionInfo.ProtocolType == ProtocalTypeEnum.HEIDEHAIN.ToString()) 
                {
                    //调用机器人plc启动海德汉程序 
                    //SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                    //OperateResult ConnectionResult = s7.ConnectServer();
                    //if (!ConnectionResult.IsSuccess)
                    //{
                    //    s7.ConnectClose();
                    //    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    //    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    //    responseData.result = "false";
                    //    return responseData;
                    //}

                    ////查询条件
                    //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))
                    //    {

                    //        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                    //        if (actionAddress.CheckType ? operateResult.Equals(actionAddress.Value) : operateResult != actionAddress.Value)
                    //        {
                    //            s7.ConnectClose();
                    //            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                    //            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    //            responseData.result = "false";
                    //            return responseData;
                    //        }
                    //    }
                    //}


                    //s7.ConnectClose();

                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = device.ServerUrl;
                    hdhReq.MachineName = device.UserName;
                    hdhReq.Path = req.data.remotePath;
                    hdhReq.Type = OpcUaActionTypeEnum.StartNcProgram.ToString();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动参数===>>" + JsonConvert.SerializeObject(hdhReq),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        responseData.resultMsg = responseHeidhData.msg;
                        responseData.resultMsg = ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req);
                        return responseData;
                    }

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(actionInfo.PlcIp, ActionTypeEnum.StartNCProgram.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram), req.taskId, req.taskNodeId);
                    await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));                    
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                     EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "程序异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                responseData.result = "false";
                return responseData;
            }
        }
    

        /// <summary>
        /// 启动清洗机
        /// </summary> 
        public async Task<ResponseECSData> StartCleanMachine(RequestData<object> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    responseData.resultMsg= ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;

                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartCleanMachine.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault(); 

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
              
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "启动故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                     
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartCleanMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine) + "启动成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "启动故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 启动吹干
        /// </summary> 
        public async Task<ResponseECSData> StartDryMachine(RequestData<object> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartDryMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                    responseData.result = "false";
                    return responseData;

                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartDryMachine.ToString();
                actionQuery.Ip = req.url;
                CcsAction action = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = action.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartDryMachine + "启动吹干机异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                    responseData.result = "false";
                    return responseData;
                } 

                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartDryMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine), req.taskId, req.taskNodeId); 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine) + "启动吹干机成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartDryMachine + "启动吹干机故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                responseData.result = "false";
                return responseData;
            }
        }

        
       

        /// <summary>
        /// 刀具接口列表
        /// </summary> 
        public async Task<List<ResponseToolData>> GetTools(RequestToolData req)
        {
            List<Device> devices = _deviceService.GetDeviceList();

            List<Device> deviceList = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).ToList();

            if (deviceList ==null || deviceList.Count <= 0) {
                throw new InvalidOperationException("没查询到在线设备数据");
            }

            Device device = deviceList.FirstOrDefault();
            List<ResponseToolData> list = new List<ResponseToolData>();

            if (device.ProtocolType == ProtocalTypeEnum.OPCUA.ToString())
            {
                CcsTagValue tagValueQuery = new CcsTagValue();
                tagValueQuery.Ip = req.url;
                tagValueQuery.Component = "刀具";
                List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery);
                List<CcsTagValue> toolNumberList = tagValues.GroupBy(x => x.ComponentNumber)
                .Select(group => new CcsTagValue
                {
                    ComponentNumber = group.Key
                }).ToList();
                foreach (CcsTagValue toolNumber in toolNumberList)
                {
                    ResponseToolData toolData = new ResponseToolData();
                    foreach (CcsTagValue tagValue in tagValues)
                    {
                        if (toolNumber.ComponentNumber == tagValue.ComponentNumber)
                        {
                            toolData.number = toolNumber.ComponentNumber;
                            if (tagValue.Description == "刀具寿命预警")
                            {
                                toolData.warnLife = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "刀具寿命目标值")
                            {
                                toolData.targetLife = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "工件数")
                            {
                                toolData.workPiece = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "工件数预警值")
                            {
                                toolData.workPieceWarn = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "工件数目标值")
                            {
                                toolData.workPieceTarget = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "磨损量")
                            {
                                toolData.wear = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "磨损量预警值")
                            {
                                toolData.wearWarn = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "磨损量目标值")
                            {
                                toolData.wearTarget = tagValue.TagValue;
                            }
                            else if (tagValue.Description == "刀具名称")
                            {
                                toolData.name = tagValue.TagValue;
                            }
                        }

                    }

                    list.Add(toolData);


                }
            }
            else if (device.ProtocolType == ProtocalTypeEnum.FANUC.ToString())
            {
                string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                //调用发那科接口
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=ToolList", null, null);

                if (Result.IsSuccess)
                {
                    List<ResponseToolData> responseFanucData = JsonConvert.DeserializeObject<List<ResponseToolData>>(Result.Message);
                    //list = JsonConvert.DeserializeObject<List<ResponseToolData>>(Result.Message.ToolLife);                    
                    //list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseFanucData.ToolLife);
                    list = responseFanucData;
                }
            }else if(device.ProtocolType == ProtocalTypeEnum.HEIDEHAIN.ToString())
            {
                RequestHeidhData hdhReq = new RequestHeidhData();
                hdhReq.ServerUrl = device.ServerUrl;
                hdhReq.MachineName = device.UserName;
                hdhReq.Type = "ToolList";
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);                
                if (Result.IsSuccess)
                {
                    ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseData.toolsInfo);
                }
            }

            return list;
        }

      

        /// <summary>
        /// 设备上线离线
        /// </summary> 
        public async Task<ResponseCommonData> UpdateDeviceState(RequestDeviceUpdateData req)
        {
            ResponseCommonData responseData = new ResponseCommonData();
            List<Device> devices = _deviceService.GetDevices();
            try
            {
                Device device = devices.Where(x => x.Ip == req.ip).FirstOrDefault();

                if (device == null)
                {
                    responseData.msg = "设备不存在";
                    responseData.result = "false";
                    return responseData;
                }
                device.UseState = req.useState;
                device.OfflineUpdateTime = DateTime.Now;
                await _deviceService.UpdateAndCache(device); 
                return responseData;
            }
            catch (Exception ex)
            {
                responseData.msg = ex.Message;
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 获取回调列表
        /// </summary> 
        public async Task<List<TaskCallback>> GetCallBackListByCondition(RequestCallBackData vo)
        {
            List<TaskCallback> list = new List<TaskCallback>();
            try {
                TaskCallback taskCallback = new TaskCallback();
                if (!string.IsNullOrEmpty(vo.IP))
                {
                    taskCallback.IP = vo.IP;
                } 
                if (!string.IsNullOrEmpty(vo.TaskId))
                {
                    taskCallback.TaskId = vo.TaskId;
                }
                if (!string.IsNullOrEmpty(vo.TaskNodeId))
                {
                    taskCallback.TaskNodeId = vo.TaskNodeId;
                }
                list = await _taskCallbackService.GetListByCondition(taskCallback);

            }
            catch (Exception ex)
            { 
                return list;
            }
            return list;
        }
 

        //设置回调值
        private TaskCallback setCallBackValue(List<CcsActionAddress> CcsActionAddresses, TaskCallback taskCallbackData)
        {
            List<CcsActionAddress> CcsActionAddressCallBacks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackFails = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK_FAIL.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackResets = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.RESET.ToString()).ToList();
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBacks)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.Address = actionAddress.Address;
                    taskCallbackData.CallbackValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.Address2 = actionAddress.Address;
                    taskCallbackData.CallbackValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.Address3 = actionAddress.Address;
                    taskCallbackData.CallbackValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackFails)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.FailAddress = actionAddress.Address;
                    taskCallbackData.CallbackFailValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.FailAddress2 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.FailAddress3 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackResets)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.SuccessResetAddress = actionAddress.Address;
                    taskCallbackData.SuccessResetValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.SuccessResetAddress2 = actionAddress.Address;
                    taskCallbackData.SuccessResetValue2 = actionAddress.Value;
                }
                
            }
            return taskCallbackData;
        }

        public async Task<ResponseECSData> PushPushToMachine(RequestData<CutterTestData> req)
        {
            Log.Instance.WriteLogAdd("机外对刀仪数据接受===>> "+ JsonConvert.SerializeObject(req),"机外对刀仪");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                if (device.ProtocolType == ProtocalTypeEnum.HEIDEHAIN.ToString())
                {

                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = device.ServerUrl;
                    hdhReq.MachineName = device.UserName;
                    hdhReq.Type = "ReadAndWriteTool";
                    hdhReq.CutterData = JsonConvert.SerializeObject(req.data);

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    JObject jsonObject = JObject.Parse(Result.Message);
                    
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "机外对刀仪数据上传异常===>>" + JsonConvert.SerializeObject(req)+"======结果数据："+ Result, "机外对刀仪");
                        responseData.result = "false";
                        responseData.resultMsg = jsonObject.GetValue("msg").ToString();
                    }
                    else
                    {
 
                        if (jsonObject.GetValue("result")!=null  && bool.Parse(jsonObject.GetValue("result").ToString())) { 
                            responseData.result = "true";
                            responseData.resultMsg = jsonObject.GetValue("msg").ToString();
                            responseData.returnData = jsonObject.GetValue("returnData").ToString();

                        }
                        else {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "机外对刀仪数据上传异常===>>" + JsonConvert.SerializeObject(req) + "======结果数据：" + Result, "机外对刀仪");
                            responseData.result = "false";
                            responseData.resultMsg = jsonObject.GetValue("msg").ToString();
                        }
                    }
                }
                else {
                    responseData.result = "false";
                    responseData.resultMsg = "没找到对应的类型方法";
                }
            }
            catch (Exception ex) {

                Log.Instance.WriteLogAdd(ActionTypeEnum.StartDryMachine + "任务下发异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
                return responseData;
            }


            return responseData;    
        }



        /// <summary>
        /// 查询三坐标是否允许取
        /// </summary> 
        public async Task<ResponseECSData> GetMiddleThreeCoordinates(RequestData<RequestToolData> req) {
            Log.Instance.WriteLogAdd("查询三坐标是否允许取===>> " + JsonConvert.SerializeObject(req), "机外对刀仪");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "允许下料");
            SiemensS7Net s7 = null;
            try
            {
                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalTakeStatus + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalTakeStatus));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询配置的字节数据
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.ThreeDimensionalTakeStatus.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalTakeStatus + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalTakeStatus));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.ThreeDimensionalTakeStatus + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = "";
                        if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                        {
                            operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                        {
                            operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                        {
                            operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                        {
                            operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }

                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalTakeStatus + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalTakeStatus));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //  关闭连接
                s7.ConnectClose();

            }
            catch (Exception ex)
            {
                s7.ConnectClose();
                Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalTakeStatus + "任务下发异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalTakeStatus));
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
                return responseData;
            }

            return responseData;
        }

        /// <summary>
        /// 查询三坐标是否允许放
        /// </summary> 
        public async Task<ResponseECSData> QueryThreeCoordinatesFreePos(RequestData<RequestToolData> req) {

            Log.Instance.WriteLogAdd("查询三坐标是否允许放===>> " + JsonConvert.SerializeObject(req), "机外对刀仪");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "允许上料");
            SiemensS7Net s7 = null;
            try
            {
                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalPutStatus + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalPutStatus));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询配置的字节数据
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.ThreeDimensionalPutStatus.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalPutStatus + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalPutStatus));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.ThreeDimensionalPutStatus + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = "";                        
                        if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                        {
                            operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                        {
                            operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                        {
                            operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                        {
                            operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }
                      
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalPutStatus + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalPutStatus));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //  关闭连接
                s7.ConnectClose();

            }
            catch (Exception ex)
            {
                //  关闭连接
                s7.ConnectClose();

                Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalPutStatus + "任务下发异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalPutStatus));
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
                return responseData;
            }

            return responseData;
        }


        
        /// <summary>
        /// 三坐标启动
        /// </summary> 
        public async Task<ResponseECSData> SendThreeCoordinates(RequestData<ThreeDimensional> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalRun + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.ThreeDimensionalRun.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalRun + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.ThreeDimensionalRun + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalRun + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        // 写入取放点位、需要进行点位拼接
                        if (actionAddress.Sort == 1)
                        {
                            parValue = req.data.workType;
                            s7.Write(actionAddress.Address, Convert.ToString(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            // 需要写入启动状态
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = req.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }


                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();

                // 睡100毫秒，保证plc那边进行数据处理完成,防止回调时候，plc状态不是最新状态
                Thread.Sleep(100);

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.ThreeDimensionalRun.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);

                // 保存数据
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun) + "取成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun));
                return responseData;
            }
            catch (Exception ex)
            {
                // 记录日志
                Log.Instance.WriteLogAdd(ActionTypeEnum.ThreeDimensionalRun + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ThreeDimensionalRun));
                responseData.resultMsg = ActionTypeEnum.ThreeDimensionalRun + "取放异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";

                // 关闭plc连接
                if (s7 != null)
                {
                    s7.ConnectClose();
                }
                return responseData;
            }
        }



        /// <summary>
        /// 坐标系偏移量设置
        /// </summary> 
        public async Task<ResponseECSData> SendOffsetSetting(RequestData<ThreeDimensionalOffset> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId,"设置成功");

            try
            {
                List<Device> devices = _deviceService.GetDeviceList();
   
                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.WriteDeviationValue + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteDeviationValue));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.WriteDeviationValue + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                if (deviceHeidenhain != null)
                {

                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                    hdhReq.MachineName = deviceHeidenhain.UserName;
                    hdhReq.Type = OpcUaActionTypeEnum.WriteDeviationValue.ToString();
                    hdhReq.DeviationValue = JsonConvert.SerializeObject(req.data);
                    
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.WriteDeviationValue + "坐标系偏差值设置失败===>>" + JsonConvert.SerializeObject(req) + "======结果数据：" + Result, "机外对刀仪");
                        responseData.result = "false";
                        responseData.resultMsg = Result.Message;
                        return responseData;
                    }
                    else
                    {
                        responseData.result = "true";
                        responseData.resultMsg = "消费成功";
                    }
                }
                else
                {
                    responseData.result = "false";
                    responseData.resultMsg = "没找到对应的类型方法";

                    return responseData;
                }

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.WriteDeviationValue.ToString(),
                EnumHelper.GetDescription(ActionTypeEnum.WriteDeviationValue), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(ActionTypeEnum.WriteDeviationValue + "设置成功===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteDeviationValue));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.WriteDeviationValue + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteDeviationValue));
                responseData.resultMsg = ActionTypeEnum.WriteDeviationValue + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";
                return responseData;
            }
        }

        public async Task<ResponseECSData> findRfidData(RequestData<RequestToolData> reqs)

        {
            Log.Instance.WriteLogAdd("查询rfid数据===>> " + JsonConvert.SerializeObject(reqs), "查询rfid数据");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(reqs.taskId, reqs.taskNodeId, "执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == reqs.url && x.Port == reqs.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RfidRead + "设备已离线===>>" + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidRead));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + reqs.url;
                    return responseData;
                }

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.RfidRead.ToString();
                actionQuery.Ip = reqs.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RfidRead + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidRead));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.RfidRead + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(reqs);
                    return responseData;
                }


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(reqs),
                            EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                // 查询需要读取的地址列表
                List<CcsActionAddress> CcsActionAddressReads = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.READ.ToString()).ToList();
                Dictionary<string, string> map = new Dictionary<string, string>();

                int i = 1;
                foreach (CcsActionAddress actionAddress in CcsActionAddressReads)
                {
                    if (string.IsNullOrEmpty(actionAddress.Address)) {
                        continue;
                    }


                    string operateResult = "";
                    if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                    {
                        operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                    }
                    else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                    {
                        operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                    }
                    else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                    {
                        operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                    }
                    else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                    {
                        operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                    }

                    map.Add("par"+1, operateResult);

                }
                responseData.returnData = JsonConvert.SerializeObject(map, Formatting.Indented);


                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        if (actionAddress.Sort == 1)
                        {
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = reqs.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RfidRead) + "取成功===>>" + JsonConvert.SerializeObject(reqs)
                   , EnumHelper.GetDescription(ActionTypeEnum.RfidRead));

                return responseData;

            }
            catch (Exception ex)
            {
                s7.ConnectClose();
                Log.Instance.WriteLogAdd(ActionTypeEnum.RfidRead + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidRead));
                responseData.resultMsg = ActionTypeEnum.RfidRead + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(reqs);
                responseData.result = "false";
                return responseData;
            }

        }


        public async Task<ResponseECSData> rfidReset(RequestData<RequestToolData> reqs)
        {
            Log.Instance.WriteLogAdd("rfid重置===>> " + JsonConvert.SerializeObject(reqs), "查询rfid数据");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(reqs.taskId, reqs.taskNodeId, "执行成功");
            SiemensS7Net s7 = null;
            try
            {

                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == reqs.url && x.Port == reqs.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RfidReset + "设备已离线===>>" + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidReset));
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + reqs.url;
                    return responseData;
                }

                // 根据ip查询设备
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.RfidReset.ToString();
                actionQuery.Ip = reqs.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RfidReset + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidReset));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.RfidReset + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(reqs);
                    return responseData;
                }


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询需要写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string parValue = "";
                        if (actionAddress.Sort == 1)
                        {
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            parValue = actionAddress.Value;
                            s7.Write(actionAddress.Address, Convert.ToBoolean(parValue));
                        }

                        // 同步TagValue数据状态
                        CcsTagValue tagValueQuery = new CcsTagValue();
                        tagValueQuery.Ip = reqs.url;
                        tagValueQuery.Address = actionAddress.Address;
                        CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault();
                        if (tagValue != null)
                        {
                            tagValue.TagValue = parValue;
                            await _ccsTagValueService.Update(tagValue);
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RfidReset) + "取成功===>>" + JsonConvert.SerializeObject(reqs)
                   , EnumHelper.GetDescription(ActionTypeEnum.RfidReset));

                return responseData;

            }
            catch (Exception ex)
            {
                s7.ConnectClose();
                Log.Instance.WriteLogAdd(ActionTypeEnum.RfidReset + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(reqs),
                    EnumHelper.GetDescription(ActionTypeEnum.RfidReset));
                responseData.resultMsg = ActionTypeEnum.RfidReset + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(reqs);
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 查询刀具上下料站、机床刀具位是否允许取
        /// </summary> 
        /// <returns></returns>
        public async Task<ResponseECSData> getCutterDeviceIsTake(RequestData<RequestToolData> req)
        {

            Log.Instance.WriteLogAdd("查询刀具上下料站、机床刀具位是否允许取===>> " + JsonConvert.SerializeObject(req), "刀具取放状态");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "允许下料");
            SiemensS7Net s7 = null;
            try
            {
                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd("CutterTake" + req.data.location + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 根据ip查询配置的字节数据
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = "CutterTake" + req.data.location.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                if (actionInfo == null)
                {
                    Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "异常===>>" + "没有查询到配置方法，默认通过" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "true";
                    responseData.resultMsg = "CutterPut" + req.data.location + "异常===>>" + "没有查询到配置方法，默认通过" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd("CutterTake" + req.data.location + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "false";
                    responseData.resultMsg = "CutterTake" + req.data.location + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }


                //=========================上下料站请求判断 开始======================
                // 目标点位是上下料站的判断下料请求是否为true，上料请求为false,
                // 如果不是判断上料请求是否为true，
                // 是提示状态不对，否则写下料请求状态

                // 下料允许
                if (cutterTakeRequest.ContainsKey(req.data.location))
                {

                    string shangliaoqingqiuDB = cutterPutRequest[req.data.location];
                    string xialiaoqingqiuDB = cutterTakeRequest[req.data.location];
                    string shangliaoyunxuDB = cutterPutStatus[req.data.location];
                    string xialiaoyunxuDB = cutterTakeStatus[req.data.location];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(xialiaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已发送下料请求，等待下料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送下料请求，等待下料允许";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "True" && xialiaoqingqiu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====状态不对，现在上料请求状态，等待上料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被上料请求占用，等待上料任务完成";
                        return responseData;
                    }
                    else if (xialiaoqingqiu == "True" && xialiaoyunxu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已经发送下料请求，下料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送下料请求，下料允许状态不满足";
                        return responseData;
                    }
                }
                //=========================上下料站请求判断 结束======================


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = "";
                        if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                        {
                            operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                        {
                            operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                        {
                            operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                        {
                            operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }

                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd("CutterTake" + req.data.location + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            "刀具取放状态");
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //  关闭连接
                s7.ConnectClose();

            }
            catch (Exception ex)
            {
                //  关闭连接
                s7.ConnectClose();

                Log.Instance.WriteLogAdd("CutterTake" + req.data.location + "任务下发异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
                return responseData;
            }

            return responseData;
        }

        /// <summary>
        /// 查询刀具上下料站、机床刀具位是否允许放
        /// </summary> 
        /// <returns></returns>
        public async Task<ResponseECSData> getCutterDeviceIsPut(RequestData<RequestToolData> req)
        {

            Log.Instance.WriteLogAdd("查询刀具上下料站、机床刀具位是否允许放===>> " + JsonConvert.SerializeObject(req), "刀具取放状态");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "允许下料");
            SiemensS7Net s7 = null;
            try
            {
                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }



                // 根据ip查询配置的字节数据
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = "CutterPut" + req.data.location.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                if (actionInfo == null) {
                    Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "异常===>>" + "没有查询到配置方法，默认通过" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "true";
                    responseData.resultMsg = "CutterPut" + req.data.location + "异常===>>" + "没有查询到配置方法，默认通过" + JsonConvert.SerializeObject(req);
                    return responseData;
                }


                // 进行plc的连接
                s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                    responseData.result = "false";
                    responseData.resultMsg = "CutterPut" + req.data.location + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                //=========================上下料站请求判断 开始======================
                // 目标点位是上下料站的判断下料请求是否为true，上料请求为false,
                // 如果不是判断上料请求是否为true，
                // 是提示状态不对，否则写下料请求状态
                // 上料料请求
                if (cutterPutRequest.ContainsKey(req.data.location))
                {
                    string shangliaoqingqiuDB = cutterPutRequest[req.data.location];
                    string xialiaoqingqiuDB = cutterTakeRequest[req.data.location];
                    string shangliaoyunxuDB = cutterPutStatus[req.data.location];
                    string xialiaoyunxuDB = cutterTakeStatus[req.data.location];

                    string shangliaoqingqiu = s7.ReadBool(shangliaoqingqiuDB).Content.ToString();
                    string xialiaoqingqiu = s7.ReadBool(xialiaoqingqiuDB).Content.ToString();
                    string shangliaoyunxu = s7.ReadBool(shangliaoyunxuDB).Content.ToString();
                    string xialiaoyunxu = s7.ReadBool(xialiaoyunxuDB).Content.ToString();

                    if (shangliaoqingqiu == "False" && xialiaoqingqiu == "False")
                    {
                        s7.Write(shangliaoqingqiuDB, true);
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已发送上料请求，等待上料允许====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已发送上料请求，等待上料允许";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "False" && xialiaoqingqiu == "True")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====状态不对，现在下料请求状态，等待下料任务完成====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已被下料请求占用，等待下料任务完成";
                        return responseData;
                    }
                    else if (shangliaoqingqiu == "True" && shangliaoyunxu == "False")
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.CutterRobotAction + "====已经发送上料请求，上料允许状态不满足====" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.CutterRobotAction));
                        responseData.result = "false";
                        responseData.resultMsg = "已经发送上料请求，上料允许状态不满";
                        return responseData;
                    }

                }
                //=========================上下料站请求判断 结束======================


                // 查询需要操作的plc的db块
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询出需要检查的地址列表
                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))
                    {
                        string operateResult = "";
                        if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.BOOL.ToString()))
                        {
                            operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.SHORT.ToString()))
                        {
                            operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.String.ToString()))
                        {
                            operateResult = s7.ReadString(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.AddressType.Equals(TagValueReadTypeEnum.Byte.ToString()))
                        {
                            operateResult = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }

                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "====实际为：" + operateResult + JsonConvert.SerializeObject(req),
                            "刀具取放状态");
                            responseData.result = "false";
                            responseData.resultMsg = "异常===>>" + "条件不满足" + actionAddress.Address + "值应为：" + actionAddress.Value + "==实际为：" + operateResult;
                            return responseData;
                        }
                    }
                }

                //  关闭连接
                s7.ConnectClose();

            }
            catch (Exception ex)
            {

                //  关闭连接
                s7.ConnectClose();
                Log.Instance.WriteLogAdd("CutterPut" + req.data.location + "任务下发异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    "刀具取放状态");
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
                return responseData;
            }

            return responseData;
        }

        public async Task<ResponseECSData> setWriteTakeCutter(RequestData<CutterTestData> req)
        {
            Log.Instance.WriteLogAdd("设置刀具取状态===>> " + JsonConvert.SerializeObject(req), "设置刀具取状态");
            // 1、根据url查询设备信息   2、调用httpserveer 发送执行消息

            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "设置刀具取状态");
            try
            {
                // 获取所有在线的设备
                List<Device> devices = _deviceService.GetDeviceList();

                // 比较在线设备是否在其中
                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd("设备已离线===>>" + JsonConvert.SerializeObject(req),
                    "设置刀具取状态");
                    responseData.result = "false";
                    responseData.resultMsg = "设备已离线：" + req.url;
                    return responseData;
                }

                // 调用httpserver 设置参数
                if (null != device && device.ProtocolType == "HEIDEHAIN")
                {
                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = device.ServerUrl;
                    hdhReq.MachineName = device.UserName;
                    hdhReq.Type = "WriteTakeCutter";
                    hdhReq.CutterData = JsonConvert.SerializeObject(req.data);

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.WriteDeviationValue + "设置失败===>>" + JsonConvert.SerializeObject(req) + "======结果数据：" + Result, "设置刀具取状态");
                        responseData.result = "false";
                        responseData.resultMsg = Result.Message;
                        return responseData;
                    }
                    else
                    {
                        responseData.result = "true";
                        responseData.resultMsg = "消费成功";
                    }

                }


            }
            catch (Exception ex)
            {
                //  关闭连接
                Log.Instance.WriteLogAdd("任务执行异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    "设置刀具取状态");
                responseData.result = "false";
                responseData.resultMsg = ex.Message;
            }
            return responseData;

        }

        public async Task<ResponseECSData> sendTheBindingInfo(RequestData<BindInfo> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId, "设置成功");

            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.BindingInfo + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.BindingInfo));
                    responseData.result = "false";
                    responseData.resultMsg = ActionTypeEnum.BindingInfo + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }

                if (deviceHeidenhain != null)
                {

                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                    hdhReq.MachineName = deviceHeidenhain.UserName;
                    hdhReq.Type = OpcUaActionTypeEnum.BindingInfo.ToString();
                    hdhReq.BindInfo = JsonConvert.SerializeObject(req.data);

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.BindingInfo + "绑定数据设置失败===>>" + JsonConvert.SerializeObject(req) + "======结果数据：" + Result, "设备绑定数据设置");
                        responseData.result = "false";
                        responseData.resultMsg = Result.Message;
                        return responseData;
                    }
                    else
                    {
                        responseData.result = "true";
                        responseData.resultMsg = "消费成功";
                    }
                }
                else
                {
                    responseData.result = "false";
                    responseData.resultMsg = "没找到对应的类型方法";

                    return responseData;
                }

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.BindingInfo.ToString(),
                EnumHelper.GetDescription(ActionTypeEnum.BindingInfo), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(ActionTypeEnum.BindingInfo + "设置成功===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.BindingInfo));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.BindingInfo + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.BindingInfo));
                responseData.resultMsg = ActionTypeEnum.BindingInfo + "设置异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";
                return responseData;
            }
        }
    }
}