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;

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

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

        public HttpRequestService(IDeviceService deviceService, ITaskCallbackService taskCallbackService,
                                  ICcsActionService ccsActionService, ICcsTagValueService ccsTagValueService,
                                  IEquipmentMonitorService equipmentMonitorService, ICcsActionAddressService ccsActionAddressService,
                                  IApiRequestService apiRequestService,
                                  IConfiguration configuration)
        {
            _deviceService = deviceService;
            _taskCallbackService = taskCallbackService;
            _ccsActionService = ccsActionService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _ccsActionAddressService = ccsActionAddressService;
            _apiRequestService = apiRequestService;
            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");
        }

        /// <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<ResponseDigitalTwinsData> list = new List<ResponseDigitalTwinsData>();

            List<EquipmentMonitor> equipmentMonitors = await _equipmentMonitorService.GetList();
            foreach (EquipmentMonitor equipment in equipmentMonitors)
            {
                ResponseDigitalTwinsData digitalTwinsData = new ResponseDigitalTwinsData();
                digitalTwinsData.id = equipment.Id.ToString();
                digitalTwinsData.deviceType = equipment.Type;
                digitalTwinsData.deviceName = equipment.Name;
                digitalTwinsData.monitoringStatus = equipment.Status;
                digitalTwinsData.operationName = "工序名称";
                digitalTwinsData.orderName = "100001";
                digitalTwinsData.orderNumber = "100002";
                digitalTwinsData.productName = "100003";
                digitalTwinsData.productNumber = "100004";
                digitalTwinsData.feedRate = "50";
                digitalTwinsData.spindleLoad = "100";
                digitalTwinsData.spindleMagnification = "80";
                digitalTwinsData.spindleSpeed = "40";
                list.Add(digitalTwinsData);
            }
            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;
                }

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

                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); 
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, 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;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.MoveRobotPosition.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.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))
                    {
                        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.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))
                    {
                        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.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)
                {
                    string Url = fanucUrlContext + "?ip=" + deviceFanuc.Ip + "&port=" + deviceFanuc.Port + "&prgname=" + req.data.fileName;
                    //调用发那科上传接口
                    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.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;
                    }
                }
                //插入回调
                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> 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=" + ActionTypeEnum.StartNCProgram.ToString()+ "&prgname="+req.data.remotePath, null, null);
                    if (Result.IsSuccess && Result.Message == "0")
                    {
                        //插入回调
                        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 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());
                    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 = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                            if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                            {
                                s7.Close();
                                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(Address, Convert.ToInt16(actionAddress.Value));
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                    s7.Close();
                    //插入回调
                    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()) 
                {
                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = device.ServerUrl;
                    hdhReq.MachineName = device.UserName;
                    hdhReq.Type = OpcUaActionTypeEnum.SelectNcProgram.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if(!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        return responseData;
                    }
                    //调用机器人plc启动海德汉程序
                    Plc s7 = DevicePlcS7.S7(actionInfo.PlcIp, ProtocalTypeEnum.S7_1500.ToString());
                    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 = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                            if (actionAddress.CheckType ? operateResult.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                            {
                                s7.Close();
                                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(Address, Convert.ToInt16(actionAddress.Value)); 
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }
                    s7.Close();

                    //插入回调
                    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;
                }


            }
            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, bool.Parse(actionAddress.Value));
                        Thread.Sleep(1500);
                    }
                }
                s7.ConnectClose();

                /*
                                //string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                                s7.Write(actionInfo.Address, true);
                                //s7.Write(Address1, true);
                                Thread.Sleep(1500);
                                s7.Write(actionInfo.Address, false);
                                Thread.Sleep(1500);
                                //string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                                //s7.Write(Address2, true);
                                s7.Write(actionInfo.Address2, true);
                                Thread.Sleep(1500);
                                s7.Write(actionInfo.Address2, false);
                                //s7.Write(Address2, false); */


                //插入回调
                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<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.StartLabelMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                    responseData.result = "false";
                    return responseData;

                }

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


                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartLabelMachine + "启动打标机异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                    responseData.result = "false";
                    return responseData;
                }
                string[] sArray;

                /*if (!string.IsNullOrEmpty(actionInfo.Address5) && !string.IsNullOrEmpty(TypeNo))
                {
                    sArray = actionInfo.Address5.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(TypeNo, 1));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address6) && !string.IsNullOrEmpty(SmallTypeNo))
                {
                    sArray = actionInfo.Address6.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(SmallTypeNo, 1));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address7) && !string.IsNullOrEmpty(SmallTypeNo))
                {
                    sArray = actionInfo.Address7.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(OrderNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address8) && !string.IsNullOrEmpty(TaskNo))
                {
                    sArray = actionInfo.Address8.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(TaskNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address9) && !string.IsNullOrEmpty(ProductNo))
                {
                    sArray = actionInfo.Address9.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(ProductNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address10) && !string.IsNullOrEmpty(BatchNo))
                {
                    sArray = actionInfo.Address10.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(BatchNo, 32));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address11) && !string.IsNullOrEmpty(SerialNo))
                {
                    sArray = actionInfo.Address11.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(SerialNo, 6));
                }


                short mc = 0;
                s7.Write(ToolUtils.AddressConvertDBW(actionInfo.Address), mc);

                Thread.Sleep(SLEEP_TIME);
                mc = 1;
                s7.Write(ToolUtils.AddressConvertDBW(actionInfo.Address2), mc);*/
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartLabelMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine), req.taskId, req.taskNodeId); 
                await _taskCallbackService.CreateOrUpdateAndCache(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> StartCoordinateMeasuringMachine(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.StartCoordinateMeasuringMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartCoordinateMeasuringMachine.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.StartCoordinateMeasuringMachine + "启动三坐标异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                    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.ToString().Equals(actionAddress.Value) : operateResult.ToString() != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartCoordinateMeasuringMachine + "启动异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                            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); 
                        if (actionAddress.Sort == 1)
                        {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workId, 40));
                            Thread.Sleep(SLEEP_TIME);
                        } else if (actionAddress.Sort == 2) {
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.workType, 20));
                            Thread.Sleep(SLEEP_TIME);
                        }
                        else if (actionAddress.Sort == 3)
                        {
                            short n = 1;
                            s7.Write(actionAddress.Address, n);
                            Thread.Sleep(SLEEP_TIME);
                        }
                        else if (actionAddress.Sort == 4)
                        {
                            short n = 0;
                            s7.Write(actionAddress.Address, n);
                            Thread.Sleep(SLEEP_TIME);
                        } 
                    }
                }  
                s7.ConnectClose();

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

                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses , taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine) + "启动三坐标成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartCoordinateMeasuringMachine + "启动三坐标故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                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(); 

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    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))
                    {
                        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.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();
                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.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];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    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))
                    {
                        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.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))
                    {
                        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.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 = JsonConvert.DeserializeObject<List<ResponseToolData>>(Result.Message);
                }
            }

            return list;
        }

        /// <summary>
        /// 读RFID
        /// </summary> 
        public async Task<ResponseECSData> ReadRFID(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.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;
                actionQuery.OrderIndex = req.data.orderIndex;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];
                string Content = req.data.content;

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


              /*  string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                string[] sArray = actionInfo.Address.Split('.');
                s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(Content, 128));
                Thread.Sleep(SLEEP_TIME);

                short n = 1;
                s7.Write(actionInfo.Address2, n);
                Thread.Sleep(SLEEP_TIME);
                n = 0;
                s7.Write(actionInfo.Address2, n);*/
                s7.Close();

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

                // await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.ReadRFID) + "读取RFID故障===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                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<WorkData> 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;
                actionQuery.OrderIndex = req.data.orderIndex;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault(); 
                string Content = req.data.content;

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                    responseData.result = "false";
                    return responseData;
                }


                /*string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                string[] sArray = actionInfo.Address.Split('.');
                s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(Content, 128));
                Thread.Sleep(SLEEP_TIME);

                short n = 1;
                s7.Write(actionInfo.Address2, n);
                Thread.Sleep(SLEEP_TIME);
                n = 0;
                s7.Write(actionInfo.Address2, n);*/
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.WriteRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID), req.taskId, req.taskNodeId); 
                // await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + "写RFID故障===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                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 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;
        }

    }
}