imcs_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;

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 int SLEEP_TIME = 1000;

        string LocalPath = "D:\\PROG";

        private string fanucUrlContext;

        private string opcuacUrlContext;

        private string hdhUrlContext;

        private string ftpUrlContext;

        private string ftpUserContext;

        private string ftpPwdContext;

        private string ecsRootUrlContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

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

        /// <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> GetIntelligenceUnit(RequestData<LocationData> 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.GetIntelligenceUnit + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                            responseData.result = "false";
                            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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.Close();

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

                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 柔性线取物品
        /// </summary> 
        public async Task<ResponseECSData> GetFlexibleWire(RequestData<LocationData> 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.GetFlexibleWire + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                            responseData.result = "false";
                            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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.Close(); 

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

                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 质量中心取物品
        /// </summary> 
        public async Task<ResponseECSData> GetQualityCenter(RequestData<LocationData> 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.GetQualityCenter + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }
                //移动取放条件
                bool IsAllowFlag = await robotActionCondition(req.url, req.data.IsAllowFlag, ActionTypeEnum.GetQualityCenter.ToString());
                if (!IsAllowFlag)
                {
                    Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter) + "并发动作异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                    responseData.result = "false";
                    responseData.concurrency = "true";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetQualityCenter + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.GetQualityCenter + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                            responseData.result = "false";
                            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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                } 

                s7.Close();

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

        /// <summary>
        /// 智能单元送物品
        /// </summary> 
        public async Task<ResponseECSData> SendIntelligenceUnit(RequestData<LocationData> 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.SendIntelligenceUnit + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendIntelligenceUnit + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.SendIntelligenceUnit + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                            responseData.result = "false";
                            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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.Close();

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

        /// <summary>
        /// 柔性线送物品
        /// </summary> 
        public async Task<ResponseECSData> SendFlexibleWire(RequestData<LocationData> 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.SendFlexibleWire + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }
                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                            responseData.result = "false";
                            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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.Close();

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

        /// <summary>
        /// 质量中心送物品
        /// </summary> 
        public async Task<ResponseECSData> SendQualityCenter(RequestData<LocationData> 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.SendQualityCenter + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }
                //移动取放条件
                bool IsAllowFlag = await robotActionCondition(req.url, req.data.IsAllowFlag, ActionTypeEnum.SendQualityCenter.ToString());
                if (!IsAllowFlag)
                {
                    Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter) + "并发动作异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                    responseData.result = "false";
                    responseData.concurrency = "true";
                    return responseData;
                }

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

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.Close();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }
                //放入恒轮工位,作为启动
                string currentWorkStation = "";
                if (req.url == "192.168.11.150" && req.data.Location == "127")
                {
                    string workStationAddress = ToolUtils.AddressConvertDBW("DB200.332");
                    currentWorkStation = ((ushort)s7.Read(workStationAddress)).ConvertToShort().ToString();
                    //string currentWorkStation = s7.ReadInt16("DB200.332").Content.ToString();
                    string writeValue = "128";
                    if (currentWorkStation == "1")//工作台1
                    {
                        writeValue = "128";
                    }
                    else if (currentWorkStation == "2")//工作台2
                    {
                        writeValue = "127";
                    }
                    if (string.IsNullOrEmpty(req.data.fileName))
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品异常===>>" + "恒轮程序名为空" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                        responseData.result = "false";
                        return responseData;
                    }
                    string proNo = Path.GetFileNameWithoutExtension(req.data.fileName); 
                    s7.Write("DB200.334", Convert.ToInt16(proNo));
                    Thread.Sleep(SLEEP_TIME);
                    s7.Write("DB200.46", Convert.ToInt16(writeValue)); 
                    Thread.Sleep(SLEEP_TIME);
                    s7.Write("DB200.50", Convert.ToInt16("4"));
                }
                else
                {
                    List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            string Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                            s7.Write(Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                }
               
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendQualityCenter.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                //放入恒轮工位,作为启动 ,传递给后续启动
                if (req.url == "192.168.11.150" && req.data.Location == "127")
                {
                    taskCallbackData.Description = currentWorkStation;
                }
                    /*//清洗机启动时更新回调值
                    if(!string.IsNullOrEmpty(req.data.Location) && req.data.Location == "123")
                    { 
                        taskCallbackData.Address = "DB200.48";
                        taskCallbackData.CallbackValue = "1";
                    }*/
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 柔性线机器人移动物品
        /// </summary> 
        public async Task<ResponseECSData> MoveRobotPosition(RequestData<LocationData> 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.MoveRobotPosition + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                    responseData.result = "false";
                    return responseData;
                }

                //移动取放条件
                bool IsAllowFlag = await robotActionCondition(req.url, req.data.IsAllowFlag, ActionTypeEnum.MoveRobotPosition.ToString());
                if (!IsAllowFlag)
                {
                    Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition) + "并发动作异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                    responseData.result = "false";
                    responseData.concurrency = "true";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.MoveRobotPosition.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.MoveRobotPosition + "移动物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                    responseData.result = "false";
                    return responseData;
                }

                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))
                    { 
                        var operateResult = s7.ReadInt16(actionAddress.Address);
                        if (actionAddress.CheckType ? operateResult.Content.ToString().Equals(actionAddress.Value) : operateResult.Content.ToString() != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    { 
                        s7.Write(actionAddress.Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.MoveRobotPosition.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition), req.taskId, req.taskNodeId); 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition) + "移动物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                responseData.result = "false";
                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 deviceFanuc = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString())).FirstOrDefault();
                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceOpcUa == null && deviceFanuc == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    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";
                        return responseData;
                    }
                }
                else if (deviceFanuc != null)
                {                    
                    Regex regex = new Regex(@"^(?<fpath>([a-zA-Z]:\\)([\s\.\-\w]+\\)*)(?<fname>[\w]+)(?<namext>(\.[\w]+)*)(?<suffix>\.[\w]+)");
                    Match result = regex.Match(req.data.fileName);                     
                    string strResult = result.Success ? result.Result("${fname}") + result.Result("${suffix}"): req.data.fileName;
                    
                    string Url = fanucUrlContext + "?ip=" + deviceFanuc.Ip + "&port=" + deviceFanuc.Port + "&prgname=" + strResult;
                    //调用发那科上传接口
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=" + ActionTypeEnum.UploadFile.ToString(), null, null);
                    if (!Result.IsSuccess)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常,scp连接失败," + Result.Message + "，" + JsonConvert.SerializeObject(req),
                     EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        return responseData;
                    }

                }else if(deviceHeidenhain != null)
                { 
                    //海德汉程序上传后,同时写入编号 
                    if (string.IsNullOrEmpty(req.data.fileName))
                    {
                        Log.Instance.WriteLogAdd("ECS编号传空不处理逻辑===>>" + req.data.fileName ,
                         EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    }
                    else
                    {
                        if (deviceHeidenhain.Description.Contains("哈默"))
                        {

                        
                            //写入程序编号  
                            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);

                        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.UploadFile));
                            responseData.result = "false";
                            return responseData;
                        }

                        //查询写入地址列表
                        List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                        if (CcsActionAddressWrites.Count < 2)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd("写入程序编号异常===>>" + "地址错误" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            return responseData;
                        }

                        string prgNo = !string.IsNullOrEmpty(req.data.fileName) ? System.IO.Path.GetFileNameWithoutExtension(req.data.fileName) : CcsActionAddressWrites[0].Value;
                        s7.Write(CcsActionAddressWrites[0].Address, Convert.ToInt16(prgNo));
                        s7.ConnectClose();
                            Log.Instance.WriteLogAdd("写入编号成功===>>编号位:" + prgNo + ",写入地址==" + CcsActionAddressWrites[0].Address,
                           EnumHelper.GetDescription(ActionTypeEnum.UploadFile)); 
                        }
                        else if (deviceHeidenhain.Description.Contains("德玛吉"))
                        {
                            RequestHeidhData hdhReq = new RequestHeidhData();
                            hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                            hdhReq.MachineName = deviceHeidenhain.UserName;
                            hdhReq.Path = req.data.fileName;
                            hdhReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                            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";
                                return responseData;
                            }  
                        } 
                        //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.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 预上传文件,不插入回调
        /// </summary> 
        public async Task<ResponseECSData> PreUploadFile(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 deviceFanuc = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FANUC.ToString())).FirstOrDefault();
                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceOpcUa == null && deviceFanuc == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    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";
                        return responseData;
                    }
                }
                else if (deviceFanuc != null)
                {
                    Regex regex = new Regex(@"^(?<fpath>([a-zA-Z]:\\)([\s\.\-\w]+\\)*)(?<fname>[\w]+)(?<namext>(\.[\w]+)*)(?<suffix>\.[\w]+)");
                    Match result = regex.Match(req.data.fileName);
                    string strResult = result.Success ? result.Result("${fname}") + result.Result("${suffix}") : req.data.fileName;

                    string Url = fanucUrlContext + "?ip=" + deviceFanuc.Ip + "&port=" + deviceFanuc.Port + "&prgname=" + strResult;
                    //调用发那科上传接口
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=" + ActionTypeEnum.UploadFile.ToString(), null, null);
                    if (!Result.IsSuccess)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常,scp连接失败," + Result.Message + "，" + JsonConvert.SerializeObject(req),
                     EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        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();
                    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";
                        return responseData;
                    }


                }
                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.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";
                    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())
                {
                    //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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                    //        var operateResult = s7.ReadInt16(CheckAddress).Content.ToString();
                    //        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                    //        {
                    //            s7.ConnectClose();
                    //            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                    //            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    //            responseData.result = "false";
                    //            return responseData;
                    //        }
                    //    }
                    //} 

                    //string currentWorkStation = s7.ReadInt16("DB200.332").Content.ToString();
                    //string writeValue = "128";
                    //if (currentWorkStation == "1")//工作台1
                    //{
                    //    writeValue = "128";
                    //}
                    //else if (currentWorkStation == "2")//工作台2
                    //{
                    //    writeValue = "127";
                    //}

                    ////查询写入地址列表
                    //List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                    //foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                    //{
                    //    if (!string.IsNullOrEmpty(actionAddress.Address))
                    //    { 
                    //        if (actionAddress.Sort == 1)
                    //        {
                    //            string proNo = Path.GetFileNameWithoutExtension(req.data.remotePath);
                    //            s7.Write(actionAddress.Address, Convert.ToInt16(proNo));
                    //        } else if (actionAddress.Sort == 2)
                    //        {
                    //            string proNo = Path.GetFileNameWithoutExtension(req.data.remotePath);
                    //            s7.Write(actionAddress.Address, Convert.ToInt16(writeValue));
                    //        }
                    //        else
                    //        {
                    //            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    //        } 
                    //        Thread.Sleep(SLEEP_TIME);
                    //    }
                    //}
                    //s7.ConnectClose();
                    //插入回调
                    //获取启动前放的 工位
                    TaskCallback queryTaskCallBack = new TaskCallback();
                    queryTaskCallBack.IP = actionInfo.PlcIp;
                    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.Description;
                    }
                    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.FANUC.ToString())
                {
                    string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                    //调用发那科是否连接接口
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=" + OpcUaActionTypeEnum.SelectNcProgram.ToString()+"&prgname=" + req.data.remotePath, null, null);
                    if(!Result.IsSuccess || Result.Message != "0")
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>"  + JsonConvert.SerializeObject(req),
                                                EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        return responseData;
                    }
                    //Plc s7 = DevicePlcS7.S7(actionInfo.PlcIp, ProtocalTypeEnum.S7_1500.ToString());
                    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;
                    }
                    /*
                    if (s7.IsConnected != true)
                    {
                        s7.Close();
                        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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                            var operateResult = s7.ReadInt16(CheckAddress).Content.ToString();
                            if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                            {
                                s7.ConnectClose();
                                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                                EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                                responseData.result = "false";
                                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 Address = ToolUtils.AddressConvertDBW(actionAddress.Address);
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                    s7.ConnectClose();
                    //插入回调
                    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 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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                            string operateResult = s7.ReadInt16(CheckAddress).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;
                            }
                        }
                    }
                    if(device.Description.Contains("哈默"))
                    {                    
                        //查询写入地址列表
                        List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                        if(CcsActionAddressWrites.Count < 2)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "地址错误" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                            responseData.result = "false";
                            return responseData;
                        }
                    
                        CcsActionAddress CcsActionAddressWriteCheck = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).FirstOrDefault();
                        string writeCheckResult = s7.ReadInt16(CcsActionAddressWriteCheck.Address).Content.ToString();
                        if(writeCheckResult == "0")
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "程序编号没有应用" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                            responseData.result = "false";
                            return responseData;
                        } 
                        //写入海德汉启动信号
                        s7.Write(CcsActionAddressWrites[1].Address, Convert.ToInt16(CcsActionAddressWrites[1].Value) );
                        //重置清零
                        s7.Write(CcsActionAddressWrites[0].Address, Convert.ToInt16("0"));
                        s7.Write(CcsActionAddressWriteCheck.Address, Convert.ToInt16("0"));
                    }else if (device.Description.Contains("德玛吉"))
                    {
                        RequestHeidhData hdhReq = new RequestHeidhData();
                        hdhReq.ServerUrl = device.ServerUrl;
                        hdhReq.MachineName = device.UserName;
                        hdhReq.Path = req.data.remotePath;  
                        hdhReq.Type = OpcUaActionTypeEnum.StartNcProgram.ToString();
                        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";
                            return responseData;
                        }

                    }

                    s7.ConnectClose();

                    //插入回调
                    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";
                    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> hellerFreeStatus(RequestData<RequestToolData> 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";
                    return responseData;
                }

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

                //恒轮设备 对应plc ip 
                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd("查询恒轮是否空闲异常===>PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    return responseData;
                }
                string status = s7.ReadInt16("DB200.336").Content.ToString();
                if (status == "1")//状态1  有料
                {
                    responseData.result = "true";
                    Log.Instance.WriteLogAdd("查询恒轮当前外面工作台有料===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    return responseData;
                }
                else if(status == "2")//状态2  无料
                {
                    Log.Instance.WriteLogAdd("查询恒轮当前外面工作台无料===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                }
                s7.ConnectClose();
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd("查询恒轮是否程序异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 粗偏写入
        /// </summary> 
        public async Task<ResponseECSData> SendLinShift(RequestData<SendLinShiftData> 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.SendLinShift + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    responseData.result = "false";
                    return responseData;
                }

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

                DeviceOPCUat opcUa = new DeviceOPCUat(device.ServerUrl, device.UserName, device.Password);
                Thread.Sleep(500);
                if (opcUa.IsConnection)
                {
                    List<string> Tags = new List<string>();
                    string TagName = "";// actionInfo.Address;
                    string OpcTagNameX = TagName + "01]";
                    Tags.Add(OpcTagNameX);
                    string OpcTagNameY = TagName + "02]";
                    Tags.Add(OpcTagNameY);
                    string OpcTagNameZ = TagName + "03]";
                    Tags.Add(OpcTagNameZ);
                    string OpcTagNameA = TagName + "04]";
                    Tags.Add(OpcTagNameA);
                    string OpcTagNameB = TagName + "05]";

                    Tags.Add(OpcTagNameB);
                    List<string> values = new List<string>();

                    values.Add(req.data.X);
                    values.Add(req.data.Y);
                    values.Add(req.data.Z);
                    values.Add(req.data.A);
                    values.Add(req.data.B);
                    opcUa.OpcUa_WriteValue(values, Tags);
                    opcUa.disConnect();

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendLinShift.ToString(),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShift), req.taskId, req.taskNodeId);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    responseData.result = "false";
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 精偏写入
        /// </summary> 
        public async Task<ResponseECSData> SendLinShiftFine(RequestData<SendLinShiftData> 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.SendLinShiftFine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    responseData.result = "false";
                    return responseData;
                }

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

                DeviceOPCUat opcUa = new DeviceOPCUat(device.ServerUrl, device.UserName, device.Password);
                Thread.Sleep(500);
                if (opcUa.IsConnection)
                {
                    List<string> Tags = new List<string>();
                    string TagName = "";// actionInfo.Address;
                    string OpcTagNameX = TagName + "06]";
                    Tags.Add(OpcTagNameX);
                    string OpcTagNameY = TagName + "07]";
                    Tags.Add(OpcTagNameY);
                    string OpcTagNameZ = TagName + "08]";
                    Tags.Add(OpcTagNameZ);
                    string OpcTagNameA = TagName + "09]";
                    Tags.Add(OpcTagNameA);
                    string OpcTagNameB = TagName + "10]";
                    Tags.Add(OpcTagNameB);

                    Tags.Add(OpcTagNameB);
                    List<string> values = new List<string>();

                    values.Add(req.data.X);
                    values.Add(req.data.Y);
                    values.Add(req.data.Z);
                    values.Add(req.data.A);
                    values.Add(req.data.B);
                    opcUa.OpcUa_WriteValue(values, Tags);
                    opcUa.disConnect();

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendLinShift.ToString(),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine), req.taskId, req.taskNodeId);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    responseData.result = "false";
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                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";
                    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);

                //查询条件
                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 CheckAddress = ToolUtils.AddressConvertDBW(actionAddress.Address);
                        var operateResult = s7.ReadBool(CheckAddress);
                        if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "启动异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        Thread.Sleep(200);
                    }
                }*/
                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> StartLabelMachine(RequestData<LabelData> 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.StartLabelMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                    responseData.result = "false";
                    return responseData;

                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartLabelMachine.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];
                string TypeNo = string.IsNullOrEmpty(req.data.TypeNo) ? "C" : req.data.TypeNo;
                string SmallTypeNo = string.IsNullOrEmpty(req.data.SmallTypeNo) ? "K" :  req.data.SmallTypeNo;
                string OrderNo = req.data.OrderNo;
                string TaskNo = req.data.TaskNo;
                string ProductNo = req.data.TaskNo;
                string BatchNo = req.data.BatchNo;
                string SerialNo = string.IsNullOrEmpty(req.data.SerialNo) ? "4" :  req.data.SerialNo;


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

                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))
                    {
                       
                        if (actionAddress.Sort == 1)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(TypeNo));
                        }else if (actionAddress.Sort == 2)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(SmallTypeNo));
                        }
                        else if (actionAddress.Sort == 3)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(OrderNo, 128));
                        }
                        else if (actionAddress.Sort == 4)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(TaskNo, 128));
                        }
                        else if (actionAddress.Sort == 5)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(ProductNo, 128));
                        }
                        else if (actionAddress.Sort == 6)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(BatchNo, 32));
                        }
                        else if (actionAddress.Sort == 7)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(SerialNo, 100));
                        }
                        else if (actionAddress.Sort == 8 || actionAddress.Sort == 9)
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        } 
                        Thread.Sleep(100);
                    }  
                }

                s7.ConnectClose();

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

        /// <summary>
        /// 查询三坐标检测空闲位置
        /// </summary> 
        public async Task<ResponseECSData> QueryThreeCoordinatesFreePos(RequestToolData req)
        {
            ResponseECSData responseData = new ResponseECSData("", "");
            
            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.QueryThreeCoordinatesFreePos + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.QueryThreeCoordinatesFreePos));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.QueryThreeCoordinatesFreePos.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.QueryThreeCoordinatesFreePos + "查询三坐标检测空闲位置===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.QueryThreeCoordinatesFreePos));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                //初始化为false,否则返回点位
                responseData.result = "false";
                //查询条件
                List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        var operateResult = s7.ReadInt16(actionAddress.Address);
                        if (operateResult.Content.ToString() == actionAddress.Value )
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.QueryThreeCoordinatesFreePos + "三坐标检测空闲位置===>>"+ actionAddress.Address + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.QueryThreeCoordinatesFreePos));
                            responseData.result = Enum.GetName(typeof(ThreeCoordinatesPosEnum), actionAddress.Sort);  //actionAddress.Address;
                            return responseData;
                        }
                    }
                }
 
                s7.ConnectClose();
 
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.QueryThreeCoordinatesFreePos + "查询三坐标检测空闲位置===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.QueryThreeCoordinatesFreePos));
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 三坐标中间位是否可取
        /// </summary>
        public async Task<ResponseECSData> GetMiddleThreeCoordinates(RequestToolData req)
        {
            ResponseECSData responseData = new ResponseECSData("", "");

            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.SendThreeCoordinates + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                } 

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位是否可取===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }
                var operateResult = s7.ReadInt16("DB200.10");
                if (operateResult.Content.ToString() != "1")
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位不可取===>>" + operateResult.Content.ToString() + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }   
                s7.ConnectClose(); 
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 三坐标中间位工件ID
        /// </summary>
        public async Task<ResponseECSData> GetMiddleWorkIdThreeCoordinates(RequestToolData req)
        {
            ResponseECSData responseData = new ResponseECSData("", "");

            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.SendThreeCoordinates + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位工件Id===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }

                var workIdResult = s7.Read(EnumHelper.GetDescription(ThreeCoordinatesFinishedWrokIdEnum.M), 40); 
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位工件Id===>>" + ToolUtils.ReturnStringByBytes(workIdResult.Content) + JsonConvert.SerializeObject(req),
                EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                responseData.result = ToolUtils.ReturnStringByBytes(workIdResult.Content);

                s7.ConnectClose(); 
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "三坐标中间位工件Id===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 放三坐标滑台
        /// </summary> 
        public async Task<ResponseECSData> SendThreeCoordinates(RequestData<WorkData> 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.SendThreeCoordinates + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendThreeCoordinates.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.SendThreeCoordinates + "启动三坐标异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                    responseData.result = "false";
                    return responseData;
                }

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

                string stationId = string.IsNullOrEmpty(req.data.stationId) ? "M" : req.data.stationId;
                //int key = 0;
                //if(stationId == "L")
                //{
                //    key = (int)ThreeCoordinatesPosEnum.L;
                //}
                //else if (stationId == "M")
                //{
                //    key = (int)ThreeCoordinatesPosEnum.M;
                //}
                //else if (stationId == "R")
                //{
                //    key = (int)ThreeCoordinatesPosEnum.R;
                //}


                //根据sort顺序,查询左中右空闲位置,写入地址列表
                //List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString() && o.Sort == key).ToList();
                //foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                //{
                //    if (!string.IsNullOrEmpty(actionAddress.Address))
                //    {
                //        if(actionAddress.Value == "workProgramName")
                //        { 
                //            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workProgramName, 40));
                //        }
                //        else if (actionAddress.Value == "workId")
                //        {
                //            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workId, 60));
                //        }
                //        else if (actionAddress.Value == "procedureNo")
                //        {
                //            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.procedureNo, 40));
                //        }

                //        Thread.Sleep(100);  
                //    }
                //}

                ////查询写入地址列表
                //List<CcsActionAddress> CcsActionAddressWriteSends = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SEND.ToString()).OrderBy(o=>o.Sort).ToList();

                //foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSends)
                //{
                //    if (!string.IsNullOrEmpty(actionAddress.Address))
                //    {
                //        s7.Write(actionAddress.Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value));  

                //        Thread.Sleep(SLEEP_TIME); 
                //    }
                //} 
                Thread.Sleep(SLEEP_TIME);
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendThreeCoordinates.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData); 
                taskCallbackData.Description = stationId;
                taskCallbackData.CallbackFailValue3 = req.data.workId;
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates) + "放测量三坐标成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendThreeCoordinates + "放测量三坐标故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendThreeCoordinates));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 伺服舵机取物品
        /// </summary> 
        public async Task<ResponseECSData> GetServoStacker(RequestData<LocationData> 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.GetServoStacker + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.GetServoStacker.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.GetServoStacker + "取物品故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                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))
                    {
                        var operateResult = s7.ReadInt16(actionAddress.Address);
                        if (actionAddress.CheckType ? (operateResult.Content.ToString() == actionAddress.Value) : operateResult.Content.ToString() != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                if (req.data.Location == "373")
                {
                    s7.Write("DB200.46", Convert.ToInt16("373"));
                    s7.Write("DB200.48", Convert.ToInt16("16"));
                    Thread.Sleep(SLEEP_TIME);
                    s7.Write("DB200.50", Convert.ToInt16("1"));
                }
                else
                {
                    //非打标机取动作操作取
                    if (string.IsNullOrEmpty(req.data.Location) || req.data.Location != "370")
                    {
                        foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                        {
                            if (!string.IsNullOrEmpty(actionAddress.Address))
                            {

                                if (actionAddress.Sort != 3)
                                {
                                    s7.Write(actionAddress.Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value));
                                }
                                else if (actionAddress.Sort == 3 && !string.IsNullOrEmpty(req.data.DestLocation))
                                {
                                    s7.Write(actionAddress.Address, Convert.ToInt16(req.data.DestLocation));
                                } 

                                Thread.Sleep(SLEEP_TIME);
                            }
                        }
                    }
                     
                }

                s7.ConnectClose(); 

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.GetServoStacker.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                //当是打标机取操作,插入回调打标机取标志
                if (!string.IsNullOrEmpty(req.data.Location) && req.data.Location == "370")
                {
                    taskCallbackData.Description = req.data.Location;
                }
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
 
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 伺服舵机放物品
        /// </summary> 
        public async Task<ResponseECSData> SendServoStacker(RequestData<WorkData> 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.SendServoStacker + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendServoStacker.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

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

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                List<CcsActionAddress> CcsActionAddresses = new List<CcsActionAddress>();
                //保障中心 放三坐标
                if (!string.IsNullOrEmpty(req.data.Location) && req.data.Location == "373" && req.url == "192.168.11.130")
                {
                    //强制三坐标动作ID
                    actionAddressQuery.ActionId = 47;
                    CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                    string stationId = req.data.stationId;
                    int key = 0;
                    if (stationId == "L")
                    {
                        key = (int)ThreeCoordinatesPosEnum.L;
                    }
                    else if (stationId == "M")
                    {
                        key = (int)ThreeCoordinatesPosEnum.M;
                    }
                    else if (stationId == "R")
                    {
                        key = (int)ThreeCoordinatesPosEnum.R;
                    }


                    //根据sort顺序,查询左中右空闲位置,写入地址列表
                    List<CcsActionAddress> CcsActionAddressThreeCoordinatesWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString() && o.Sort == key).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressThreeCoordinatesWrites)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            if (actionAddress.Value == "workProgramName")
                            {
                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workProgramName, 40));
                            }
                            else if (actionAddress.Value == "workId")
                            {
                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workId, 40));
                            }
                            else if (actionAddress.Value == "procedureNo")
                            {
                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.procedureNo, 40));
                            }

                            Thread.Sleep(100);
                        }
                    }

                    //查询写入地址列表
                    List<CcsActionAddress> CcsActionAddressWriteSends = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SEND.ToString()).OrderBy(o => o.Sort).ToList();

                    foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSends)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value));

                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                }
                else
                {
                    actionAddressQuery.ActionId = actionInfo.Id;
                    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))
                        {

                            var operateResult = s7.ReadInt16(actionAddress.Address);
                            if (actionAddress.CheckType ? (operateResult.Content.ToString() == actionAddress.Value) : operateResult.Content.ToString() != actionAddress.Value)
                            {
                                s7.ConnectClose();
                                Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                                EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                                responseData.result = "false";
                                return responseData;
                            }
                        }
                    }

                    //查询写入地址列表
                    List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(string.IsNullOrEmpty(actionAddress.Value) ? req.data.Location : actionAddress.Value)); ;
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                } 
                
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendServoStacker.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                if(!string.IsNullOrEmpty(req.data.Location) && req.data.Location == "373")
                {
                    taskCallbackData.Description = req.data.stationId;
                }
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                responseData.result = "false";
                return responseData;
            }
        }

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

            Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).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>
        /// 读RFID
        /// </summary> 
        public async Task<ResponseECSData> ReadRFID(RequestData<RFIData> 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.ReadRFID + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.ReadRFID.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.ReadRFID + "读取RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                actionAddressQuery.Type = ActionAddressTypeEnum.WRITE.ToString() + req.data.positionIndex;        //根据positionIndex确认哪个工作台
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
           
                foreach (CcsActionAddress actionAddress in CcsActionAddresses)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            var resultBytes = s7.Read(actionAddress.Address, 360); 
                            responseData.result = ToolUtils.ReturnStringByBytes(resultBytes.Content);
                            req.data.content = responseData.result;
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }

                    }
                }

                s7.ConnectClose();
 
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.ReadRFID) + " 读取RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "读取RFID故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 写RFID
        /// </summary> 
        public async Task<ResponseECSData> WriteRFID(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            List<Device> devices = _deviceService.GetDeviceList();
            try
            {
                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

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

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.WriteRFID.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.WriteRFID + "写RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                actionAddressQuery.Type = ActionAddressTypeEnum.WRITE.ToString() + req.data.positionIndex;        //根据positionIndex确认哪个工作台
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                foreach (CcsActionAddress actionAddress in CcsActionAddresses)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {

                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString("", 360));
                            Thread.Sleep(100);
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.content, 360));
                             //var resultBytes = s7.Read("DB200.868", 40);
                             //Console.WriteLine(ToolUtils.ReturnStringByBytes(resultBytes.Content));
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }
                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                s7.ConnectClose();
                
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + " 写RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <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 async Task<bool> robotActionCondition(string ip ,string isAllowFlag,string currentAction)
        {
            //isAllowFlag 不传或为1时限制条件
            if (string.IsNullOrEmpty(isAllowFlag) || isAllowFlag == "1")
            {
                //查询当前执行过的任务 
                TaskCallback queryTaskCallback = new TaskCallback();
                queryTaskCallback.IP = ip;
                TaskCallback taskCallBack = await _taskCallbackService.GetRobotActionList(queryTaskCallback);
                
                 if(taskCallBack != null)
                { 
                    if (taskCallBack.State
                        || (currentAction == ActionTypeEnum.MoveRobotPosition.ToString() && taskCallBack.OperateType != ActionTypeEnum.SendQualityCenter.ToString())
                        || (currentAction == ActionTypeEnum.GetQualityCenter.ToString() && taskCallBack.OperateType != ActionTypeEnum.MoveRobotPosition.ToString())
                        || (currentAction == ActionTypeEnum.SendQualityCenter.ToString() && taskCallBack.OperateType != ActionTypeEnum.GetQualityCenter.ToString()))
                    {
                        return false;
                    }
                }

                return true;
            }
            return true;
        }

        //设置回调值
        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;
        }

    }
}