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;

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));
                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 = twinsData.feedRate;
                            responseDigitalTwinsData.spindleMagnification = 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 = responseFanucData.ActFeed;
                        responseDigitalTwinsData.spindleMagnification = responseFanucData.ActSpindle;
                        //responseDigitalTwinsData.spindleSpeed = responseFanucData.
                        //responseDigitalTwinsData.spindleLoad = responseFanucData.
                    }
                }
            }

            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";
                    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); 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, 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";
                    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.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.SendQualityCenter.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                /*//清洗机启动时更新回调值
                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";
                    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.GetDeviceAllList();
                Device deviceFtp = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FTP.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 (deviceFtp == null && deviceFanuc == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    return responseData;
                }
                //西门子系统上传
                if (deviceFtp != null)
                {
                    FtpClient ftpClient = new DeviceFtp().Connect(ftpUrlContext, ftpUserContext, ftpPwdContext);
                    ftpClient.Get(req.data.fileName, LocalPath, req.data.fileName);
                    ftpClient.DisConnect();
                    try
                    {
                        DeviceSFTP sftp = new DeviceSFTP(deviceFtp.Ip, deviceFtp.Port, deviceFtp.UserName, deviceFtp.Password);
                        bool ifcon = sftp.Connect();
                        if (ifcon)
                        {
                            sftp.Put(LocalPath + "\\" + req.data.fileName, req.data.remotePath + req.data.fileName);
                            sftp.Disconnect();
                        }

                    }
                    catch (Exception exscp)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常,scp连接失败," + exscp.Message + "，" + 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;
                    //}

                    //海德汉程序上传后,同时写入编号
                    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.remotePath) ? req.data.remotePath.Substring(0, req.data.remotePath.Length - 2) : CcsActionAddressWrites[0].Value;
                    s7.Write(CcsActionAddressWrites[0].Address, Convert.ToInt16(prgNo));

                    Log.Instance.WriteLogAdd("写入编号成功===>>编号位:"  + prgNo + ",写入地址=="+ CcsActionAddressWrites[0].Address,
                     EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                }
                //插入回调
                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.GetDeviceAllList();
                Device deviceFtp = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FTP.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 (deviceFtp == null && deviceFanuc == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    return responseData;
                }
                //西门子系统上传
                if (deviceFtp != null)
                {
                    FtpClient ftpClient = new DeviceFtp().Connect(ftpUrlContext, ftpUserContext, ftpPwdContext);
                    ftpClient.Get(req.data.fileName, LocalPath, req.data.fileName);
                    ftpClient.DisConnect();
                    try
                    {
                        DeviceSFTP sftp = new DeviceSFTP(deviceFtp.Ip, deviceFtp.Port, deviceFtp.UserName, deviceFtp.Password);
                        bool ifcon = sftp.Connect();
                        if (ifcon)
                        {
                            sftp.Put(LocalPath + "\\" + req.data.fileName, req.data.remotePath + req.data.fileName);
                            sftp.Disconnect();
                        }

                    }
                    catch (Exception exscp)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常,scp连接失败," + exscp.Message + "，" + 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())
                {
                    RequestOpcUaData opcUaReq = new RequestOpcUaData();
                    opcUaReq.ServerUrl = device.ServerUrl;
                    opcUaReq.UserName = device.UserName;
                    opcUaReq.Password = device.Password;
                    opcUaReq.Path = actionInfo.FilePath + req.data.remotePath;
                    opcUaReq.Type = OpcUaActionTypeEnum.Connect.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (Result.IsSuccess && responseOpcUaData.result)
                    {

                        Thread.Sleep(1000);
                        List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                        if (CcsActionAddressChecks != null)
                        {
                            List<string> checkAddresses = CcsActionAddressChecks.Select(t => t.Address).ToList();
                            opcUaReq.Type = OpcUaActionTypeEnum.Read.ToString();
                            opcUaReq.Addresses = checkAddresses;
                            Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                            responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                            if (Result.IsSuccess && responseOpcUaData.result)
                            {
                                //条件校验
                                for (int i = 0; i < CcsActionAddressChecks.Count; i++)
                                {
                                    CcsActionAddress checkActionAddress = CcsActionAddressChecks[i];
                                    string checkValue = responseOpcUaData.values[i];
                                    if (checkValue != checkActionAddress.Value)
                                    {
                                        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();
                        List<string> writeAddresses = CcsActionAddressWrites.Select(t => t.Address).ToList();
                        List<string> writeValues = CcsActionAddressWrites.Select(t => t.Value).ToList();
                        opcUaReq.Type = OpcUaActionTypeEnum.Write.ToString();
                        opcUaReq.Addresses = writeAddresses;
                        opcUaReq.Values = writeValues;
                        /*opcUaReq.Addresses = new List<string>() { actionInfo.Address };
                        opcUaReq.Values = new List<string>() { "True" };*/
                        Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                        responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                        if (Result.IsSuccess && responseOpcUaData.result)
                        {
                            //插入回调
                            TaskCallback taskCallbackData = new TaskCallback(req.url, 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;
                        }
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        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(req.url, 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;
                            }
                        }
                    }

                    //查询写入地址列表
                    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"));
                    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> 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 = req.data.TypeNo;
                string SmallTypeNo = 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 = 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> 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 = 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, 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();
                /*s7.Write("DB200.46", Convert.ToInt16(req.data.beginLocation));
                Thread.Sleep(SLEEP_TIME);
                s7.Write("DB200.50", Convert.ToInt16("1"));*/
               /* Thread.Sleep(SLEEP_TIME);
                s7.Write("DB200.48", Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);
                s7.Write("DB200.50", Convert.ToInt16("4"));
                Thread.Sleep(2000);*/
                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); 
                    }
                } 
                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
                {
                    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.GetServoStacker.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker), req.taskId, req.taskNodeId);
 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, 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<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.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();
                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.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); 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, 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;
            }
        }

        //移动取放 条件限制
        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;
        }

    }
}