chf_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 IMCS_CCS.Utils.DeviceProtocol;
using HslCommunication.Profinet.Siemens;
using Microsoft.Extensions.Configuration;
using IMCS.CCS.Service;
using IMCS_CCS.Model.vo;
using FTP;
using HslCommunication;
using System.Text.RegularExpressions;
using System.IO;
using System.Reflection;
using Newtonsoft.Json;
using static Google.Protobuf.Reflection.SourceCodeInfo.Types;
using System.Drawing;
using Google.Protobuf.WellKnownTypes;
using Type = System.Type;
using Flurl.Util;
using HslCommunication.Enthernet;
using MySqlX.XDevAPI.Common;
using Newtonsoft.Json.Linq;
using StackExchange.Redis;
using IMCS.CCS.Common.Redis;
using Microsoft.AspNetCore.Mvc;

namespace IMCS.CCS.Services
{
    public class HttpRequestService : IHttpRequestService
    {
        private readonly IRedisService _redisService;

        private readonly IDeviceService _deviceService;

        private readonly ITaskCallbackService _taskCallbackService;

        private readonly ICcsActionService _ccsActionService;

        private readonly ICcsTagValueService _ccsTagValueService;

        private readonly IEquipmentMonitorService _equipmentMonitorService;

        private readonly ICcsActionAddressService _ccsActionAddressService;

        private readonly ITaskJobService _taskJobService;

        private int SLEEP_TIME = 3000;

        string LocalPath = "D:\\PROG";

        private string mazakUrlContext;

        private string ecsRootUrlContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

        private static Dictionary<string, string> pointDict = new Dictionary<string, string>();

        private static Dictionary<string, string> threeDengDict = new Dictionary<string, string>();

        private static Dictionary<string, string> threeDengPostDict = new Dictionary<string, string>();

        private static Dictionary<string, string> ipDict = new Dictionary<string, string>();

        private static List<string> jList = new List<string>();

        private static Dictionary<string, string> jIp = new Dictionary<string, string>();

        public HttpRequestService(IRedisService redisService, IDeviceService deviceService, ITaskCallbackService taskCallbackService,
                                  ICcsActionService ccsActionService, ICcsTagValueService ccsTagValueService,
                                  IEquipmentMonitorService equipmentMonitorService, ICcsActionAddressService ccsActionAddressService,
                                  IApiRequestService apiRequestService, ITaskJobService taskJobService,
                                  IConfiguration configuration)
        {
            _redisService = redisService;
            _deviceService = deviceService;
            _taskCallbackService = taskCallbackService;
            _ccsActionService = ccsActionService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _ccsActionAddressService = ccsActionAddressService;
            _apiRequestService = apiRequestService;
            _taskJobService = taskJobService;
            Configuration = configuration;
            mazakUrlContext = Configuration.GetConnectionString("mazakUrlContext"); 
            ecsRootUrlContext = Configuration.GetConnectionString("ecsRootUrlContext");

            if(pointDict.Count == 0)
            {
                pointDict.Add("1", "DB1.116");
                pointDict.Add("2", "DB1.118");
                pointDict.Add("3", "DB1.120");
                pointDict.Add("201", "DB1.124");
                pointDict.Add("202", "DB1.126");
                pointDict.Add("11", "DB1.122");

            }

            if (threeDengDict.Count == 0)
            {
                threeDengDict.Add("201", "DB1.124");
                threeDengDict.Add("202", "DB1.126");
            }

            if (threeDengPostDict.Count == 0)
            {
                threeDengPostDict.Add("201", "DB2.120");
                threeDengPostDict.Add("202", "DB2.122");
            }


            if (ipDict.Count == 0)
            {
                Console.WriteLine("ipDict:" + ipDict.Count);
                ipDict.Add("10.161.30.245", "DB1.116");
                ipDict.Add("10.161.30.246", "DB1.118");
                ipDict.Add("10.161.30.247", "DB1.120");
            }
            if (jList.Count == 0)
            {
                jList.Add("1");
                jList.Add("2");
                jList.Add("3");
            }
            if (jIp.Count == 0)
            {
                Console.WriteLine("jIp:" + jIp.Count);
                jIp.Add("1","10.161.30.245");
                jIp.Add("2","10.161.30.246");
                jIp.Add("3","10.161.30.247");
            }

        }

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

        }

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

            //String query3dUrl = ecsRootUrlContext + "/api/authority/agv/agvCallbackService/query3dResouceDataInfo";
            //var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, query3dUrl, new Object(), null);
            //ResponsePageData<ResponseDigitalTwinsData> responseData = JsonConvert.DeserializeObject<ResponsePageData<ResponseDigitalTwinsData>>(result.Message);
            //list = responseData.Data;
            ResponseDigitalTwinsData aa = new ResponseDigitalTwinsData();
            list.Add(aa);
            List<ResponseDigitalTwinsData> collectDatas = new List<ResponseDigitalTwinsData>();
            foreach (ResponseDigitalTwinsData responseDigitalTwinsData in list)
            {
                //EquipmentMonitor equipmentMonitor = await _equipmentMonitorService.GetById(long.Parse(responseDigitalTwinsData.resourceId));
                //if (equipmentMonitor == null || equipmentMonitor.IP == null)
                //{
                //    continue;
                //}
                //Device device = devices.Where(x => x.Ip.Equals(equipmentMonitor.IP)).FirstOrDefault();
                //if (null != device && equipmentMonitor.Type == ProtocalTypeEnum.MAZAK.ToString())
                if(1==1)
                {
                    RequestHeidhData reqBody = new RequestHeidhData();
                    reqBody.ServerUrl = "127.0.0.1";
                    reqBody.DeviceType = "Mazaka";
                    reqBody.Type = "Collect";
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, reqBody, null);
                    if (Result.IsSuccess)
                    {
                        ResponseHeidhData retData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                        if (retData != null && retData.code == 0)
                        {
                            ResponseDigitalTwinsData twinsData = JsonConvert.DeserializeObject<ResponseDigitalTwinsData>(retData.runDatasInfo);
                            //responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(twinsData.feedRate) ? twinsData.feedRate : "0";
                            //responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(twinsData.spindleMagnification) ? twinsData.spindleMagnification : "0";
                            //responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(twinsData.spindleSpeed) ? twinsData.spindleSpeed + "00" : "0";
                            //responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(twinsData.spindleLoad) ? twinsData.spindleMagnification : "-";
                            twinsData.toolsInfo = JsonConvert.DeserializeObject<List<ToolsInfo>>(retData.toolsInfo);
                            //twinsData.alarms = JsonConvert.DeserializeObject<List<ErrorInfo>>(retData.errorsInfo);
                            twinsData.id = responseDigitalTwinsData.id;
                            twinsData.deviceType = responseDigitalTwinsData.deviceType;
                            twinsData.resourceId = responseDigitalTwinsData.resourceId;
                            twinsData.deviceName = responseDigitalTwinsData.deviceName;
                            twinsData.monitoringStatus = responseDigitalTwinsData.monitoringStatus;
                            collectDatas.Add(twinsData);
                        }
                    }
                } 
            }

            return list;

        }

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

        }
     

        /// <summary>
        /// 机器人取放动作
        /// </summary> 
        public async Task<ResponseECSData> RobotAction(RequestData<LocationData> req)
        {   
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

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

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


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

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


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

                List<CcsActionAddress> CcsActionAddressChecks = new List<CcsActionAddress>();
                CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_PLC.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        Console.WriteLine(req.taskNodeId+ "RobotAction:" + actionAddress.Address + ":" + operateResult);
                        Log.Instance.WriteLogAdd(req.taskNodeId + "RobotAction:" + actionAddress.Address + ":" + operateResult,
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足==地址：" + actionAddress.Address + "实际值：" + operateResult + "期望值：" + actionAddress.Value,
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足==地址：" + actionAddress.Address + "实际值：" + operateResult + "期望值：" + actionAddress.Value;
                            return responseData;
                        }
                    }
                }

                //为装载站三色灯特殊判断
                if (threeDengDict.ContainsKey(req.data.location))
                {
                    //取
                    string location = threeDengDict[req.data.location];
                    string getResult = s7.ReadInt16(location).Content.ToString();
                    //判断装载站是否允许取料
                    if (getResult != "9")
                    {
                        //判断装载站是否有料
                        if (getResult != "1" && getResult != "3")
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,非有托盘状态" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,非有托盘状态";
                            s7.ConnectClose();
                            return responseData;
                        }
                        else
                        {

                            string postLocation = threeDengPostDict[req.data.location];
                            string postResult = s7.ReadInt16(postLocation).Content.ToString();
                            if (postResult == "8")
                            {
                                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,等待允许取料中" + JsonConvert.SerializeObject(req),
                                                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                                responseData.result = "false";
                                responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,等待允许取料中,请按装载站上的允许卸料按钮";
                                s7.ConnectClose();
                                return responseData;
                            }
                            //先请求取料
                            s7.Write(postLocation, Convert.ToInt16("8"));

                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,已请求取料" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,已请求取料";
                            s7.ConnectClose();
                            return responseData;
                        }
                    }
                    else if (getResult == "9")
                    {
                        //判断是否存在请求取料
                        string postLocation = threeDengPostDict[req.data.location];
                        string postResult = s7.ReadInt16(location).Content.ToString();
                        if (postResult == "9")
                        {
                            //消除请求
                            s7.Write(postLocation, Convert.ToInt16("0"));
                        }

                    }
                }
                else if (threeDengDict.ContainsKey(req.data.destLocation))
                {
                    //放
                    string destLocation = threeDengDict[req.data.destLocation];
                    string getResult = s7.ReadInt16(destLocation).Content.ToString();
                    //判断装载站是否允许放料
                    if (getResult != "16")
                    {
                        //判断装载站是否有料
                        if (getResult != "0" && getResult != "2")
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】,非无托盘状态" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】,非无托盘状态";
                            s7.ConnectClose();
                            return responseData;
                        }
                        else
                        {
                            string postLocation = threeDengPostDict[req.data.destLocation];
                            string postResult = s7.ReadInt16(postLocation).Content.ToString();
                             if (postResult == "16")
                            {
                                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "放条件不满足【" + getResult + "】,等待允许放料中" + JsonConvert.SerializeObject(req),
                                                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                                responseData.result = "false";
                                responseData.msg = "异常===>>" + "点位" + req.data.location + "放条件不满足【" + getResult + "】,等待允许放料中,请按装载站上的允许装载按钮";
                                s7.ConnectClose();
                                return responseData;
                            }
                            //先请求放料
                            s7.Write(postLocation, Convert.ToInt16("16"));

                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】，已请求放料" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】，已请求放料";
                            s7.ConnectClose();
                            return responseData;
                        }
                    }
                    else if (getResult == "16")
                    {
                        //判断是否存在请求取料
                        string postLocation = threeDengPostDict[req.data.destLocation];
                        string postResult = s7.ReadInt16(postLocation).Content.ToString();
                        if (postResult == "16")
                        {
                            //消除请求
                            s7.Write(postLocation, Convert.ToInt16("0"));
                        }
                    }
                }

                //判断取地址是否满足条件
                if (pointDict.ContainsKey(req.data.location))
                {
                    string location = pointDict[req.data.location]; //取
                    if (location != null)
                    {
                        string getResult = s7.ReadInt16(location).Content.ToString();
                        if (getResult != "9" && getResult != "8")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】";
                            return responseData;
                        }
                    }
                }

                //判断放地址是否满足条件
                if (pointDict.ContainsKey(req.data.destLocation))
                {
                    string destLocation = pointDict[req.data.destLocation]; //放
                    if (destLocation != null)
                    {
                        string putResult = s7.ReadInt16(destLocation).Content.ToString();
                        if (putResult != "16")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + putResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + putResult + "】";
                            return responseData;
                        }
                    }
                }


                //查询写入地址列表
                string log = "任务【" + req.taskNodeId + "】写入:";
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                log = log + "地址:" + actionAddress.Address + "【" + dataValue + "】";
                            }
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                            log = log + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                        }
                    }
                }

                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "===>>" + log
                  , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                Thread.Sleep(SLEEP_TIME);


                //写入检查
                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                bool checkFlag = true;
                string returnMsg = "";
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //取参数传参值
                        string dataValue = getProperties(req.data, actionAddress.Description);
                        //读取写入结果
                        string readWriteResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (dataValue != readWriteResult)
                        {
                            returnMsg = "地址位:" + actionAddress.Address + "写入值：" + dataValue + "读出值：" + readWriteResult;
                            checkFlag = false;
                            break;
                        }

                    }

                }
                //不通过不写执行
                if (!checkFlag)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "写入失败,plc没有写入相应的值" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.msg = "写入异常===>>" + returnMsg;
                    return responseData;
                }

                //二次写入地址列表
                string log2 = "任务【" + req.taskNodeId + "】二次写入:";
                List<CcsActionAddress> CcsActionAddressWriteSeconds = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSeconds)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                            }
                        }
                        else
                        {
                            log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "二次写入===>>" + log2
                  , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                s7.ConnectClose();

                //查询回调表是否存在此数据（避免在数据重复下发时，产生多条回调数据）
                TaskCallback vo = new TaskCallback(null, ActionTypeEnum.RobotAction.ToString(),
                    null, req.taskId, req.taskNodeId);
                
                List<TaskCallback> taskCallbackList = await _taskCallbackService.GetListByCondition(vo);
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback();
                if (taskCallbackList != null && taskCallbackList.Count > 0)
                {
                    taskCallbackData = taskCallbackList[0];
                    
                    taskCallbackData.State = true;
                }
                else
                {
                    taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.RobotAction.ToString(),
                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction), req.taskId, req.taskNodeId);
                }
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
               
                if(req.data.taskType == "1" && (req.data.destLocation == "30" || req.data.destLocation == "900")) //取料完成
                {
                    taskCallbackData.CallbackValue = "2";
                }else if (req.data.taskType == "1" && (req.data.destLocation != "30" && req.data.destLocation != "900")) //放料完成
                {
                    taskCallbackData.CallbackValue = "5";
                }
                else if (req.data.taskType == "512" ) //移动完成
                {
                    taskCallbackData.CallbackValue = "4"; //todo 待确定移动完成 值
                }

                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "操作成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));

                //try catch 包起来不影响正常流程
                try
                {
                    //下发任务成功后，查询千机质检结果
                    //如果源目标为是机床，才去查询
                    if (jList.Contains(req.data.location) && req.data.qj == "1")
                    {
                        RequestOpcUaData deviceReq = new RequestOpcUaData();
                        deviceReq.ServerUrl = "opc.tcp://" + jIp[req.data.location] + ":4840";
                        deviceReq.UserName = "OpcUaClient";
                        deviceReq.Password = "12345678";
                        deviceReq.Type = OpcUaActionTypeEnum.Collect.ToString();
                        deviceReq.Ip = jIp[req.data.location];
                        List<string> strings = new List<string>();
                        deviceReq.Addresses = strings;
                        deviceReq.check = "1";
                        Console.WriteLine("RequestOpcUaData:" + JsonConvert.SerializeObject(deviceReq));
                        var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                        Console.WriteLine("Result:" + Result.Message);
                        ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                        if (Result.IsSuccess && responseOpcUaData.result)
                        {
                            if (responseOpcUaData.values != null)
                            {
                                await _redisService.Database.StringSetAsync("QJ:" + req.taskNodeId, "\"" + responseOpcUaData.values[0] + "\"");
                            }
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "查询千机质检结果===>>" + JsonConvert.SerializeObject(responseOpcUaData),
                       EnumHelper.GetDescription(ActionTypeEnum.RobotAction));

                        }
                    }
                }catch(Exception e)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "查询千机质检结果异常===>>" + e.StackTrace + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                }
                

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

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

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

                if (deviceMazak == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.msg = "设备已离线";
                    responseData.result = "false";
                    return responseData;
                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartNCProgram.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();
// 成航发没有允许上传nc的状态的db块，隐藏此代码
/*                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.msg = "PLC连接不上";
                    responseData.result = "false";
                    return responseData;
                }

                //判断是是否允许上传
                if (ipDict.ContainsKey(req.url))
                {
                    string db = ipDict[req.url];
                    if (db != null)
                    {
                        string getResult = s7.ReadInt16(db).Content.ToString();
          *//*              if (getResult != "2")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "url" + req.url + "上传程序条件不满足【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            responseData.msg = req.url + "上传程序条件不满足【" + getResult + "】";
                            return responseData;
                        }*//*
                    }
                }
*/
                if(req.data.subFileList !=null && req.data.subFileList.Count > 0)
                {
                    //西门子one系统子文件上传
                    if (deviceMazak != null)
                    {
                        RequestOpcUaData deviceReq = new RequestOpcUaData();
                        deviceReq.ServerUrl = "opc.tcp://"+req.url+ ":4840";
                        deviceReq.UserName = "OpcUaClient";
                        deviceReq.Password = "12345678";
                        deviceReq.Type = OpcUaActionTypeEnum.UploadFileList.ToString();
                        deviceReq.prgName = req.data.fileName;
                        deviceReq.subFileList = req.data.subFileList;
                        deviceReq.toolFileList=req.data.toolFileList; 
                        deviceReq.Ip = req.url;
                        var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                        ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                        if (!Result.IsSuccess || !responseOpcUaData.result)
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + Result.Message + "===>>" + deviceReq.Path,
                           EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.msg = "上传失败===>>" + Result.Message + "===>>" + deviceReq.Path;
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>加工程序为空",
                                              EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.msg = "上传失败===>>加工程序为空";
                    responseData.result = "false";
                    return responseData;
                }
                
                //查询回调表是否存在此数据（避免在数据重复下发时，产生多条回调数据）
                TaskCallback vo = new TaskCallback(null, ActionTypeEnum.UploadFile.ToString(),
                    null, req.taskId, req.taskNodeId);

                List<TaskCallback> taskCallbackList = await _taskCallbackService.GetListByCondition(vo);
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback();
                if (taskCallbackList != null && taskCallbackList.Count > 0)
                {
                    taskCallbackData = taskCallbackList[0];
                    
                    taskCallbackData.State = true;
                }
                else
                {
                    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";
                    responseData.msg = req.url+ "设备已离线";
                    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);
                if (actionInfo.ProtocolType == ProtocalTypeEnum.OPCUA.ToString()) 
                {

                    SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                    OperateResult ConnectionResult = s7.ConnectServer();

                    if (!ConnectionResult.IsSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        responseData.msg = req.url + "PLC连接不上";
                        return responseData;
                    }

                    //判断是否允许启动
                    if (ipDict.ContainsKey(req.url))
                    {
                        string db = ipDict[req.url];
                        string getResult = s7.ReadInt16(db).Content.ToString();
                        if (getResult != "2")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "异常===>>" + "url:" + req.url + "启动程序条件不满足【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                            responseData.result = "false";
                            responseData.msg = req.url + "启动程序条件不满足【" + getResult + "】";
                            return responseData;
                        }
                    }
                    //查询条件
                    List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                        {

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


                    //查询写入地址列表
/*                    List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));

                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "写入正常===>>地址位:" + actionAddress.Address + "值：" + actionAddress.Value + JsonConvert.SerializeObject(req),
                                 EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));

                        }else
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {

                                s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(dataValue, dataValue.Length));
                                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "写入正常===>>地址位:" + actionAddress.Address + "值：" + dataValue + JsonConvert.SerializeObject(req),
                                 EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                            }
                            else
                            {
                                s7.ConnectClose();
                                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "程序名为空" + JsonConvert.SerializeObject(req),
                                EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                                responseData.result = "false";
                                responseData.msg = req.url + "条件不满足程序名为空";
                                return responseData;
                            }
                        }
                    }*/

                    //Thread.Sleep(2000);

                    //写入检查
                   /* List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                    bool checkFlag = true;
                    string returnMsg = "";
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            //读取写入结果
                            byte[] bytes = s7.Read(actionAddress.Address, 32).Content;
                            string value = ToolUtils.ReturnStringByBytes(bytes);
                            string readWriteResult = value.Trim();
                            if (dataValue != readWriteResult)
                            {
                                returnMsg = "地址位:" + actionAddress.Address + "写入值：" + dataValue + "读出值：" + readWriteResult;
                                checkFlag = false;
                                break;
                            }

                        }

                    }*/

                    //不通过不写执行
                 /*   if (!checkFlag)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "异常===>>" + "写入失败,plc没有写入相应的值" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        responseData.msg = "程序名写入异常===>>" + returnMsg;
                        return responseData;
                    }*/

                    //二次写入地址列表
                    string log2 = "任务【" + req.taskNodeId + "】二次写入:";
                    List<CcsActionAddress> CcsActionAddressWriteSeconds = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSeconds)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {
                            if (string.IsNullOrEmpty(actionAddress.Value))
                            {
                                //取参数传参值
                                string dataValue = getProperties(req.data, actionAddress.Description);
                                if (!string.IsNullOrEmpty(dataValue))
                                {
                                    log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                                    s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                }
                            }
                            else
                            {
                                log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                                s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                            }

                        }
                    }
                    Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram) + "二次写入===>>" + log2
                      , EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));

                    Thread.Sleep(5000);

                    //查询写入地址列表
                    List<CcsActionAddress> CcsActionAddressDeclear = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressDeclear)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {

                            s7.Write(actionAddress.Address, Convert.ToInt16("0"));
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "写入正常===>>地址位清零" + JsonConvert.SerializeObject(req),
                                 EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));

                        }
                    }

                    s7.ConnectClose();
                    //查询回调表是否存在此数据（避免在数据重复下发时，产生多条回调数据）
                    TaskCallback vo = new TaskCallback(null, ActionTypeEnum.StartNCProgram.ToString(),
                        null, req.taskId, req.taskNodeId);

                    List<TaskCallback> taskCallbackList = await _taskCallbackService.GetListByCondition(vo);
                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback();
                    if (taskCallbackList != null && taskCallbackList.Count > 0)
                    {
                        taskCallbackData = taskCallbackList[0];

                        taskCallbackData.State = true;

                    }
                    else
                    {
                        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> StartCleanMachine(RequestData<printingData> req)
        {
          
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

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

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    responseData.msg = "设备已离线";
                    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";
                    responseData.msg = "PLC连接不上";
                    return responseData;
                }
                s7.Write("DB2.220", ToolUtils.ReturnBtyesWtitString("", 64));
                s7.Write("DB2.118", Convert.ToInt16("0"));
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询写入地址列表
                string log = "任务【" + req.taskNodeId + "】写入:";
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString(); 

                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                if (actionAddress.dataType == "bytes")
                                {
                                    s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(dataValue, dataValue.Length));
                                    log = log + "地址:" + actionAddress.Address + "【" + dataValue + "】";
                                }
                                else if(actionAddress.dataType == "int")
                                {
                                    s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                    log = log + "地址:" + actionAddress.Address + "【" + dataValue + "】";
                                }
                                   
                            }
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                            log = log + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                        }
                    }
                }
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine) + "===>>" + log
                 , EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));

                Thread.Sleep(2000);


                //写入检查
                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                bool checkFlag = true;
                string returnMsg = "";
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //取参数传参值
                        string dataValue = getProperties(req.data, actionAddress.Description);
                        string readWriteResult = "";
                        //读取写入结果
                        if (actionAddress.dataType == "bytes")
                        {
                            byte[] bytes = s7.Read(actionAddress.Address, 64).Content;
                            readWriteResult = ToolUtils.ReturnStringByBytes(bytes);
                            readWriteResult = readWriteResult.Trim();
                        }
                        else if (actionAddress.dataType == "int")
                        {
                            readWriteResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }

                        if (dataValue != readWriteResult)
                        {
                            returnMsg = "地址位:" + actionAddress.Address + "写入值：" + dataValue + "读出值：" + readWriteResult;
                            checkFlag = false;
                            break;
                        }

                    }

                }
                //不通过不写执行
                if (!checkFlag)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "异常===>>" + "写入失败,plc没有写入相应的值" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    responseData.msg = "写入异常===>>" + returnMsg;
                    return responseData;
                }

                List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_PLC.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "异常===>>" + "启动条件不满足==地址：" + actionAddress.Address + "目标值：" + operateResult + "期望值：" + actionAddress.Value,
                            EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                            responseData.result = "false";
                            responseData.msg = "启动条件不满足==地址：" + actionAddress.Address + "目标值：" + operateResult + "期望值：" + actionAddress.Value;
                            return responseData;
                        }
                    }
                }

                //二次写入地址列表
                string log2 = "任务【" + req.taskNodeId + "】二次写入:";
                List<CcsActionAddress> CcsActionAddressWriteSeconds = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSeconds)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                            }
                        }
                        else
                        {
                            log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }

                    }
                }
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine) + "二次写入===>>" + log2
                  , EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));

                Thread.Sleep(5000);
                //清空
                List<CcsActionAddress> CcsActionAddressDeclear = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressDeclear)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {

                        s7.Write(actionAddress.Address, Convert.ToInt16("0"));
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "写入正常===>>地址位清零" + JsonConvert.SerializeObject(req),
                             EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));

                    }
                }


                //查询回调表是否存在此数据（避免在数据重复下发时，产生多条回调数据）
                TaskCallback vo = new TaskCallback(null, ActionTypeEnum.StartCleanMachine.ToString(),
                    null, req.taskId, req.taskNodeId);

                List<TaskCallback> taskCallbackList = await _taskCallbackService.GetListByCondition(vo);
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback();
                if (taskCallbackList != null && taskCallbackList.Count > 0)
                {
                    taskCallbackData = taskCallbackList[0];

                    taskCallbackData.State = true;
                }
                else
                {
                    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));
                //s7.ConnectClose();
                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>
        /// 读RFID
        /// </summary> 
        public async Task<ResponseECSData> ReadRFID(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

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

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

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

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

                //查询写入地址列表
                if (req.type == "AUTO")
                {

                }
                else
                {
                    //校验
                    if(req.type == "FIVE")
                    {
                        string state = s7.ReadInt16("DB1.2100").Content.ToString();
                        if (!(state == "1" || state == "3" || state == "5"))
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + "读写头未就绪" + JsonConvert.SerializeObject(req),
                                                EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                RFIData rFIData = new RFIData();
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                //actionAddressQuery.Type = ActionAddressTypeEnum.WRITE.ToString();       
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //读启动
                string typeReadStart = "TOOl_READ_" + req.type;
                List<CcsActionAddress> CcsActionAddressReadStart = CcsActionAddresses.Where(o => o.Type == typeReadStart + "_START").ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressReadStart)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    }
                }
                Thread.Sleep(1000);
                string type = "TOOl_READ_" + req.type;
                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == type).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    string value = "";
                    if (actionAddress.dataType == "bytes")
                    {
                        byte[] bytes = s7.Read(actionAddress.Address, 19).Content;
                        value = ToolUtils.ReturnStringByBytes(bytes);
                    }
                    else if (actionAddress.dataType == "int")
                    {
                        value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                    }
                    else if (actionAddress.dataType == "float")
                    {
                        value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                    }
                    else if (actionAddress.dataType == "byte")
                    {
                        value = s7.ReadByte(actionAddress.Address).Content.ToString();
                    }
                    SetProperty(rFIData, actionAddress.Description, value);
                }

                //读归零
                string typeReadZero = "TOOl_READ_" + req.type;
                List<CcsActionAddress> CcsActionAddressReadZero = CcsActionAddresses.Where(o => o.Type == typeReadStart + "_ZERO").ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressReadZero)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    }
                }
                /*  List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                  foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                  {
                      if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                      {
                          string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                          if (operateResult != actionAddress.Value)
                          {
                              s7.ConnectClose();
                              Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "异常===>>" + "写入失败" + JsonConvert.SerializeObject(req),
                              EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                              responseData.result = "false";
                              return responseData;
                          }
                      }
                  }

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

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

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

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

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

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;        
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                //查询写入地址列表
                if (req.type == "AUTO")
                {

                }
                else
                {
                    if(req.type == "FIVE"){
                        //校验
                        string state = s7.ReadInt16("DB1.2100").Content.ToString();
                        if (!(state == "1" || state == "3" || state == "5"))
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + "读写头未就绪" + JsonConvert.SerializeObject(req),
                                                EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                            responseData.result = "false";
                            return responseData;
                        }

                    }

                }
                string type = "TOOl_WRITE_" + req.type;
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == type).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {  
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {   
                                if(actionAddress.dataType == "bytes")
                                {
                                    s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(dataValue, 19));
                                }else if(actionAddress.dataType == "int")
                                {
                                    s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                }else if (actionAddress.dataType == "float")
                                {
                                    s7.Write(actionAddress.Address, float.Parse(dataValue));
                                }else if (actionAddress.dataType == "byte")
                                {
                                    s7.Write(actionAddress.Address, Convert.ToByte(dataValue));
                                }
                            }

                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        } 
                    }
                }

                //启动
                List<CcsActionAddress> CcsActionAddressWriteStart = CcsActionAddresses.Where(o => o.Type == type+ "_START").ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteStart)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    }
                }

                Thread.Sleep(2000);

                //校验是否已写入RFID---读一下
                CcsAction actionQueryRead = new CcsAction();
                actionQueryRead.OperateType = ActionTypeEnum.ReadRFID.ToString();
                actionQueryRead.Ip = req.url;
                CcsAction actionInfoRead = _ccsActionService.GetList(actionQueryRead).FirstOrDefault();

                CcsActionAddress actionAddressQueryRead = new CcsActionAddress();
                actionAddressQueryRead.ActionId = actionInfoRead.Id;
                List<CcsActionAddress> CcsActionAddressesRead = _ccsActionAddressService.GetList(actionAddressQueryRead);

                string typeReadStart = "TOOl_READ_" + req.type;
                List<CcsActionAddress> CcsActionAddressReadStart = CcsActionAddressesRead.Where(o => o.Type == typeReadStart+"_START").ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressReadStart)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    }
                }
                Thread.Sleep(1000);

                RFIData rFIData = new RFIData();

                string typeRead = "TOOl_READ_" + req.type;
                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressReads = CcsActionAddressesRead.Where(o => o.Type == typeRead).ToList();

                foreach (CcsActionAddress actionAddress in CcsActionAddressReads)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //取参数传参值
                        string dataValue = getProperties(req.data, actionAddress.Description);
                        //读取写入结果
                        string value = "";
                        if (actionAddress.dataType == "bytes")
                        {
                            byte[] bytes = s7.Read(actionAddress.Address, 19).Content;
                            value = ToolUtils.ReturnStringByBytes(bytes);
                        }
                        else if (actionAddress.dataType == "int")
                        {
                            value = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.dataType == "float")
                        {
                            value = s7.ReadFloat(actionAddress.Address).Content.ToString();
                        }
                        else if (actionAddress.dataType == "byte")
                        {
                            value = s7.ReadByte(actionAddress.Address).Content.ToString();
                        }
                        if (value != dataValue)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "异常===>>" + "写入失败:" + actionAddress.Description + "写入值【"+ dataValue + "】和读出值【"+ value + "】不一致" ,
                            EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                            responseData.msg = "写入失败:" + actionAddress.Description + "写入值【" + dataValue + "】和读出值【" + value + "】不一致";
                            responseData.result = "false";
                            return responseData;
                        }
                        SetProperty(rFIData, actionAddress.Description, value);
                    }
                }
                string typeReadZero = "TOOl_READ_" + req.type;
                List<CcsActionAddress> CcsActionAddressReadZero = CcsActionAddressesRead.Where(o => o.Type == typeReadStart + "_ZERO").ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressReadZero)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                    }
                }
                s7.ConnectClose();

                //插入回调
                /*TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.WriteRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + "写RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                return responseData;*/

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


        /// <summary>
        /// 刀具接口列表
        /// </summary> 
        public async Task<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.MAZAK.ToString())
            {
                RequestHeidhData hdhReq = new RequestHeidhData();
                hdhReq.ServerUrl = device.ServerUrl;
                
                hdhReq.Type = "ToolList";
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, hdhReq, null);                
                if (Result.IsSuccess)
                {
                    ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseData.toolsInfo);
                }
            }

            return list;
        }

      

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

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

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

        //设置回调值
        private TaskCallback setCallBackValue(List<CcsActionAddress> CcsActionAddresses, TaskCallback taskCallbackData)
        {
            List<CcsActionAddress> CcsActionAddressCallBacks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackFails = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK_FAIL.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackResets = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.RESET.ToString()).ToList();
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBacks)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.Address = actionAddress.Address;
                    taskCallbackData.CallbackValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.Address2 = actionAddress.Address;
                    taskCallbackData.CallbackValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.Address3 = actionAddress.Address;
                    taskCallbackData.CallbackValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackFails)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.FailAddress = actionAddress.Address;
                    taskCallbackData.CallbackFailValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.FailAddress2 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.FailAddress3 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackResets)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.SuccessResetAddress = actionAddress.Address;
                    taskCallbackData.SuccessResetValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.SuccessResetAddress2 = actionAddress.Address;
                    taskCallbackData.SuccessResetValue2 = actionAddress.Value;
                }
                
            }
            return taskCallbackData;
        }
        
        public string getProperties<T>(T t , string propertyName)
        {
            string tStr = string.Empty;
            if (t == null)
            {
                return tStr;
            }
            System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

            if (properties.Length <= 0)
            {
                return tStr;
            }
            foreach (System.Reflection.PropertyInfo item in properties)
            {
                string name = item.Name;
                object value = item.GetValue(t, null);
                if ((item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String")) && name == propertyName)
                {
                    tStr = value.ToString();
                    break;
                }
                
            }
            return tStr;
        }

        public void SetProperty<T>(T t, string propertyName, object value)
        {
            // 获取对象的类型
            Type type = t.GetType();

            // 获取指定名称的属性
            PropertyInfo propertyInfo = type.GetProperty(propertyName);

            if (propertyInfo != null && propertyInfo.CanWrite)
            {
                // 设置属性值
                propertyInfo.SetValue(t, value);
            }
        }

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

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

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

                if (deviceMazak == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = "上传异常===>>设备离线【" + req.url + "】";
                    return responseData;
                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartNCProgram.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = "上传异常===>>PLC连接不上" + req.url;
                    return responseData;
                }

                //判断是是否允许上传
                if (ipDict.ContainsKey(req.url))
                {
                    string db = ipDict[req.url];
                    if (db != null)
                    {
                        string getResult = s7.ReadInt16(db).Content.ToString();

                        /*if (getResult == "0")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "url：" + req.url + "当前机床不在线【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            responseData.msg = "上传失败===>>url：" + req.url + "当前机床不在线【" + getResult + "】";
                            return responseData;
                        }*/

                        if (getResult == "1")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "url：" + req.url + "当前机床正在加工【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            responseData.msg = "上传失败===>>url：" + req.url + "当前机床正在加工【" + getResult + "】";
                            return responseData;
                        }
                    }
                }

                //mazak系统上传
                if (deviceMazak != null)
                {
                    RequestOpcUaData deviceReq = new RequestOpcUaData();
                    deviceReq.ServerUrl = req.url;

                    deviceReq.Path = req.data.fileName;
                    deviceReq.Type = OpcUaActionTypeEnum.UploadNoSet.ToString();
                    deviceReq.deviceType = "Mazaka";
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (!Result.IsSuccess || !responseOpcUaData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.msg = "上传失败===>>" + Result.Message + "===>>" + JsonConvert.SerializeObject(req);
                        responseData.result = "false";
                        return responseData;
                    }
                }
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.result = "false";
                responseData.msg = "上传异常:" + ex.Message + "===>> " + JsonConvert.SerializeObject(req);
                return responseData;
            }
        }
        /// <summary>
        /// 非任务删除文件
        /// </summary> 
        public async Task<ResponseECSData> DeleteFileWithOutTask(RequestData<UploadFileData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

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

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

                if (deviceMazak == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = "删除异常===>>设备离线【" + req.url + "】";
                    return responseData;
                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartNCProgram.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = "删除异常===>>PLC连接不上" + req.url;
                    return responseData;
                }

                //判断是是否允许删除
                if (ipDict.ContainsKey(req.url))
                {
                    string db = ipDict[req.url];
                    if (db != null)
                    {
                        string getResult = s7.ReadInt16(db).Content.ToString();
                        if (getResult == "0")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "url：" + req.url + "当前机床不在线【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            responseData.msg = "删除失败===>>url：" + req.url + "当前机床不在线【" + getResult + "】";
                            return responseData;
                        }

                        if (getResult == "1")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "异常===>>" + "url：" + req.url + "当前机床正在加工【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                            responseData.result = "false";
                            responseData.msg = "上传失败===>>url：" + req.url + "当前机床正在加工【" + getResult + "】";
                            return responseData;
                        }
                    }
                }

                //mazak系统删除
                if (deviceMazak != null)
                {
                    RequestOpcUaData deviceReq = new RequestOpcUaData();
                    deviceReq.ServerUrl = req.url;

                    deviceReq.Path = req.data.fileName;
                    deviceReq.Type = OpcUaActionTypeEnum.DeleteNc.ToString();
                    deviceReq.deviceType = "Mazaka";
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (!Result.IsSuccess || !responseOpcUaData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "删除异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.msg = "删除失败===>>" + Result.Message + "===>>" + JsonConvert.SerializeObject(req);
                        responseData.result = "false";
                        return responseData;
                    }
                }
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "删除异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.result = "false";
                responseData.msg = "删除异常:" + ex.Message + "===>> " + JsonConvert.SerializeObject(req);
                return responseData;
            }
        }

        public async Task<ResponseCCSData<List<ResponseEcsPoint>>> readPoint(RequestData<RequestPoint> req)
        {
            ResponseCCSData<List<ResponseEcsPoint>> responseData = new ResponseCCSData<List<ResponseEcsPoint>>();

            List<string> pointList = req.data.pointList;

            if (pointList == null || pointList.Count == 0)
            {
                responseData.result = "false";
                responseData.msg = "参数点位集合为空";
                return responseData;
            }

            SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
            OperateResult ConnectionResult = s7.ConnectServer();
            if (!ConnectionResult.IsSuccess)
            {
                s7.ConnectClose();
                responseData.result = "false";
                responseData.msg = "PLC连接不上,"+ ConnectionResult.ErrorCode+","+ ConnectionResult.Message;
                return responseData;
            }
            List<ResponseEcsPoint> responseEcsPointList = new List<ResponseEcsPoint>();
            foreach (string point in pointList)
            {
                ResponseEcsPoint responseEcsPoint = new ResponseEcsPoint();
                string result = s7.ReadInt16(point).Content.ToString();
                responseEcsPoint.point = point;
                responseEcsPoint.result = result;
                responseEcsPointList.Add(responseEcsPoint);
            }
            responseData.result = "true";
            responseData.data = responseEcsPointList;
            s7.ConnectClose();
            return responseData;
        }

        public async Task<ResponseECSData> writePoint(RequestData<RequestPoint> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

            List<string> pointList = req.data.pointList;

            if (pointList == null || pointList.Count == 0)
            {
                responseData.result = "false";
                responseData.msg = "参数点位集合为空";
                return responseData;
            }

            SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
            OperateResult ConnectionResult = s7.ConnectServer();
            if (!ConnectionResult.IsSuccess)
            {
                s7.ConnectClose();
                responseData.result = "false";
                responseData.msg = "PLC连接不上";
                return responseData;
            }

            foreach (string point in pointList)
            {
                ResponseEcsPoint responseEcsPoint = new ResponseEcsPoint();
                s7.Write(point, Convert.ToInt16("0"));

            }
            responseData.result = "true";
            s7.ConnectClose();
            return responseData;
        }

        public async Task<ResponseECSData> updateToolInfo(RequestData<ToolData> req)
        {
            string type = req.type;
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

            SiemensS7Net s7 = DevicePlcS7.SiemensS7("10.161.30.248");
            HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();

            if (!ConnectionResult.IsSuccess)
            {
                s7.ConnectClose();
                responseData.result = "false";
                responseData.msg = "PLC连接不上";
                return responseData;
            }

            //判断是是否已执行换刀小程序
            if (type == "ONE")
            {
                //一号机床
            }
            else if (type == "TWO")
            {
                //二号机床
            }
            else if (type == "THREE")
            {
                //三号机床
            }
            else if (type == "FOUR")
            {
                //四号机床
            }
            else if (type == "FIVE")
            {
                //五号机床
                string state = s7.ReadInt16("DB1.2110").Content.ToString();
                if (state != "1")
                {
                    responseData.result = "false";
                    responseData.msg = "机床五换刀小程序未执行";
                    return responseData;
                }
            }

            RequestBody<ToolData> deviceReq = new RequestBody<ToolData>();
            deviceReq.serverUrl = req.url;
            deviceReq.type = OpcUaActionTypeEnum.DeleteOrSetTool.ToString();
            deviceReq.deviceType = "Mazaka";
            deviceReq.toolNo = req.toolNo;
            deviceReq.data = req.data;
            if(req.storgeFlag == "in")
            {
                deviceReq.value = "set";
            }else if(req.storgeFlag == "out")
            {
                deviceReq.value = "delete";
            }
            var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
            ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
            if (!responseOpcUaData.result || !responseOpcUaData.result)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "更新刀库信息异常===>>" + JsonConvert.SerializeObject(req),
               EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.msg = "更新刀库信息失败===>>" + Result.Message ;
                responseData.result = "false";
                return responseData;
            }

            responseData.data = responseOpcUaData.toolsData;
            //清除手动换刀信息
            if (type == "ONE")
            {
                //一号机床
            }
            else if (type == "TWO")
            {
                //二号机床
            }
            else if (type == "THREE")
            {
                //三号机床
            }
            else if (type == "FOUR")
            {
                //四号机床
            }
            else if (type == "FIVE")
            {
                //五号机床
                //取放刀标识
                s7.Write("DB2.3096", Convert.ToInt16("0"));
            }



            responseData.result = "true";
            return responseData;
        }

        /// <summary>
        /// 写RFID
        /// </summary> 
        public async Task<ResponseECSData> WriteRFIDTemp(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
            HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();

            //刀具ID
            s7.Write("DB2.14", ToolUtils.ReturnBtyesWtitString("2754691583333295000", 19));

            byte[] toolIdBt = s7.Read("DB2.14",19).Content;

            string toolId = ToolUtils.ReturnStringByBytes(toolIdBt);

            //刀柄ID
            s7.Write("DB2.54", ToolUtils.ReturnBtyesWtitString("1754691583333294081", 19));

            byte[] toolHandleIdBt = s7.Read("DB2.54", 19).Content;

            string toolHandleId = ToolUtils.ReturnStringByBytes(toolHandleIdBt);

            //刀号
            s7.Write("DB2.94", Convert.ToInt16("40"));

            string tno = s7.ReadInt16("DB2.94").Content.ToString();

            //刀长
            float len = float.Parse("153.26");
            s7.Write("DB2.96", len);

            string length = s7.ReadFloat("DB2.96").Content.ToString();

            //刀具名称
            s7.Write("DB2.100", Convert.ToByte("10"));

            string name = s7.ReadByte("DB2.100").Content.ToString();

            //公称径
            float intll = float.Parse("0.21");
            s7.Write("DB2.102", intll);

            string int0 = s7.ReadFloat("DB2.102").Content.ToString();

            //刀具径刀尖角
            float diametep = float.Parse("0.36");
            s7.Write("DB2.106", diametep);

            string diameter = s7.ReadFloat("DB2.106").Content.ToString();

            //刀具寿命
            s7.Write("DB2.110", Convert.ToInt16("480"));

            string lifetime = s7.ReadInt16("DB2.110").Content.ToString();

            //刀具次数
            s7.Write("DB2.112", Convert.ToInt16("50"));

            string lifenumber = s7.ReadInt16("DB2.112").Content.ToString();

            //刀具已使用寿命
            s7.Write("DB2.114", Convert.ToInt16("360"));

            string usetime = s7.ReadInt16("DB2.114").Content.ToString();

            //刀具已使用次数
            s7.Write("DB2.116", Convert.ToInt16("20"));

            string usenumber = s7.ReadInt16("DB2.116").Content.ToString();

            //组号
            s7.Write("DB2.118", Convert.ToInt16("104"));

            string int1 = s7.ReadInt16("DB2.118").Content.ToString();

            //磨损补偿

            s7.Write("DB2.120", float.Parse("20.265"));

            string wearcompZ = s7.ReadFloat("DB2.120").Content.ToString();

            //磨损极限
            s7.Write("DB2.124", float.Parse("120.253"));

            string maxwearZ = s7.ReadFloat("DB2.124").Content.ToString();

            //刀具补偿
            s7.Write("DB2.128", float.Parse("40.23"));

            string angle = s7.ReadFloat("DB2.128").Content.ToString();

            //最高转速
            s7.Write("DB2.132", float.Parse("50000"));

            string easycompX = s7.ReadFloat("DB2.132").Content.ToString();

            //径补偿量
            s7.Write("DB2.136", float.Parse("200"));

            string easycompY = s7.ReadFloat("DB2.136").Content.ToString();

            //长度补偿
            s7.Write("DB2.140", float.Parse("15.289"));

            string conscompZ = s7.ReadFloat("DB2.140").Content.ToString();


            //托盘
            //托盘ID
            s7.Write("DB2.144", ToolUtils.ReturnBtyesWtitString("1778980910222282754", 19));

            byte[] trayIdBt = s7.Read("DB2.144", 19).Content;

            string trayId = ToolUtils.ReturnStringByBytes(trayIdBt);

            //托盘类型
            s7.Write("DB2.184", Convert.ToByte("1"));

            string type = s7.ReadByte("DB2.184").Content.ToString();

            //零件状态
            s7.Write("DB2.185", Convert.ToByte("3"));

            string state = s7.ReadByte("DB2.185").Content.ToString();

            //零件ID
            s7.Write("DB2.186", ToolUtils.ReturnBtyesWtitString("1778980910222282755", 19));

            byte[] itemIdBt = s7.Read("DB2.186", 19).Content;

            string itemId = ToolUtils.ReturnStringByBytes(itemIdBt);

            return responseData;
        }


        /// <summary>
        /// 手动换刀
        /// </summary> 
        public async Task<ResponseECSData> HandleChangeTool(RequestData<HandleChangeTool> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
            HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();

            if (!ConnectionResult.IsSuccess)
            {
                s7.ConnectClose();
                responseData.result = "false";
                responseData.msg = "PLC连接不上";
                return responseData;
            }

            HandleChangeTool handleChangeTool = req.data;

            if(handleChangeTool.location == "ONE")
            {
                //一号机床
            }else if (handleChangeTool.location == "TWO")
            {
                //二号机床
            }
            else if (handleChangeTool.location == "THREE")
            {
                //三号机床
            }
            else if (handleChangeTool.location == "FOUR")
            {
                //四号机床
            }
            else if (handleChangeTool.location == "FIVE")
            {
                //五号机床

                //刀号
                s7.Write("DB2.2968", Convert.ToInt16(handleChangeTool.tno));

                //取放刀标识
                s7.Write("DB2.3096", Convert.ToInt16(handleChangeTool.handleFlag));
            }
            

   

 


            return responseData;
        }

        public async Task<ResponseECSData> StorgeOut(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                //读取刀具信息
                RequestBody<ToolData> deviceReq = new RequestBody<ToolData>();
                deviceReq.serverUrl = req.url;
                deviceReq.type = OpcUaActionTypeEnum.ToolNoData.ToString();
                deviceReq.deviceType = "Mazaka";
                deviceReq.toolNo = req.toolNo;
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                if (!responseOpcUaData.result || responseOpcUaData.toolsData == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ToolOut + "刀具手动出库==》获取刀具信息异常" + JsonConvert.SerializeObject(req),
                   EnumHelper.GetDescription(ActionTypeEnum.ToolOut));
                    responseData.msg = "获取刀具【" + req.toolNo + "】信息失败===>>" + Result.Message;
                    responseData.result = "false";
                    return responseData;
                }
                ToolData toolData = JsonConvert.DeserializeObject<ToolData>(responseOpcUaData.toolsData);
                //更新RFID信息
                RFIData rFIData = req.data;

                rFIData.length = toolData.lengthA + "";
                rFIData.name = toolData.name + "";
                rFIData.int0 = toolData.int0 + "";
                rFIData.diameter = toolData.diameter + "";
                rFIData.lifetime = toolData.lifetime + "";
                rFIData.lifenumber = toolData.lifenumber + "";
                rFIData.usetime = toolData.usetime + "";
                rFIData.usenumber = toolData.usenumber + "";
                rFIData.int1 = toolData.int1 + "";
                rFIData.wearcompZ = toolData.wearcompZ + "";
                rFIData.maxwearZ = toolData.maxwearZ + "";
                rFIData.angle = toolData.angle + "";
                rFIData.easycompX = toolData.easycompX + "";
                rFIData.easycompY = toolData.easycompY + "";
                rFIData.conscompZ = toolData.conscompZ + "";

                RequestData<RFIData> rfidReq = new RequestData<RFIData>();
                rfidReq.url = "10.161.30.248";
                rfidReq.port = "102";
                rfidReq.type = req.type;
                rfidReq.data = rFIData;
                Task<ResponseECSData> rfidResult = this.WriteRFID(rfidReq);
                if (rfidResult.Result.result != "true")
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ToolOut + "刀具出库==》写入RFID失败" + rfidResult.Result.msg + "=========" + JsonConvert.SerializeObject(req),
                   EnumHelper.GetDescription(ActionTypeEnum.ToolOut));
                    responseData.msg = "写入RFID失败===》" + rfidResult.Result.msg;
                    responseData.result = "false";
                    return responseData;
                }

                responseData.data = JsonConvert.SerializeObject(rfidReq);
                //更新机床刀具库
                RequestData<ToolData> toolOutReq = new RequestData<ToolData>();
                toolOutReq.url = req.url;
                toolOutReq.port = req.port;
                toolOutReq.toolNo = req.toolNo;
                toolOutReq.storgeFlag = req.storgeFlag;
                toolOutReq.type = req.type;

                Task<ResponseECSData> toolOutResult = this.updateToolInfo(toolOutReq);
                if (toolOutResult.Result.result != "true")
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ToolOut + "刀具出库==》更新机床刀具库失败：" + toolOutResult.Result.msg + "=====" + JsonConvert.SerializeObject(req),
                 EnumHelper.GetDescription(ActionTypeEnum.ToolOut));
                    responseData.msg = "更新机床刀具库失败===》" + toolOutResult.Result.msg;
                    responseData.result = "false";
                    return responseData;
                }
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.ToolOut + "刀具出库===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ToolOut));
                responseData.msg = "更新机床刀具库失败===》" + ex.Message;
                responseData.result = "false";
                return responseData;
            }

            responseData.result = "true";
            return responseData;
        }

        /// <summary>
        /// 手动处理机器人取放动作
        /// </summary> 
        public async Task<ResponseECSData> HandRobotAction(RequestData<LocationData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

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

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.msg = ActionTypeEnum.RobotAction + "设备已离线===>>" + req.url;
                    return responseData;
                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.RobotAction.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.msg = ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + actionInfo.Ip;
                    responseData.result = "false";
                    return responseData;
                }
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询条件
                List<CcsActionAddress> CcsActionAddressChecks = new List<CcsActionAddress>();

                CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_PLC.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足==地址：" + actionAddress.Address + "目标值：" + operateResult + "期望值：" + actionAddress.Value,
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足==地址：" + actionAddress.Address + "目标值：" + operateResult + "期望值：" + actionAddress.Value;
                            return responseData;
                        }
                    }
                }

                //为装载站三色灯特殊判断
                if (threeDengDict.ContainsKey(req.data.location))
                {
                    //取
                    string location = threeDengDict[req.data.location];
                    string getResult = s7.ReadInt16(location).Content.ToString();
                    //判断装载站是否允许取料
                    if (getResult != "9")
                    {
                        //判断装载站是否有料
                        if (getResult != "1" && getResult != "3")
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,非有托盘状态" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,非有托盘状态";
                            s7.ConnectClose();
                            return responseData;
                        }
                        else
                        {

                            string postLocation = threeDengPostDict[req.data.location];
                            string postResult = s7.ReadInt16(postLocation).Content.ToString();
                            if (postResult == "8")
                            {
                                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,等待允许取料中" + JsonConvert.SerializeObject(req),
                                                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                                responseData.result = "false";
                                responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,等待允许取料中";
                                s7.ConnectClose();
                                return responseData;
                            }
                            //先请求取料
                            s7.Write(postLocation, Convert.ToInt16("8"));

                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,已请求取料" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】,已请求取料";
                            s7.ConnectClose();
                            return responseData;
                        }
                    }
                    else if (getResult == "9")
                    {
                        //判断是否存在请求取料
                        string postLocation = threeDengPostDict[req.data.location];
                        string postResult = s7.ReadInt16(location).Content.ToString();
                        if (postResult == "9")
                        {
                            //消除请求
                            s7.Write(postLocation, Convert.ToInt16("0"));
                        }

                    }
                }
                else if (threeDengDict.ContainsKey(req.data.destLocation))
                {
                    //放
                    string destLocation = threeDengDict[req.data.destLocation];
                    string getResult = s7.ReadInt16(destLocation).Content.ToString();
                    //判断装载站是否允许放料
                    if (getResult != "16")
                    {
                        //判断装载站是否有料
                        if (getResult != "0" && getResult != "2")
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】,非无托盘状态" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】,非无托盘状态";
                            s7.ConnectClose();
                            return responseData;
                        }
                        else
                        {
                            string postLocation = threeDengPostDict[req.data.destLocation];
                            string postResult = s7.ReadInt16(postLocation).Content.ToString();
                            if (postResult == "16")
                            {
                                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "放条件不满足【" + getResult + "】,等待允许放料中" + JsonConvert.SerializeObject(req),
                                                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                                responseData.result = "false";
                                responseData.msg = "异常===>>" + "点位" + req.data.location + "放条件不满足【" + getResult + "】,等待允许放料中";
                                s7.ConnectClose();
                                return responseData;
                            }
                            //先请求放料
                            s7.Write(postLocation, Convert.ToInt16("16"));

                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】，已请求放料" + JsonConvert.SerializeObject(req),
                                                        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + getResult + "】，已请求放料";
                            s7.ConnectClose();
                            return responseData;
                        }
                    }
                    else if (getResult == "16")
                    {
                        //判断是否存在请求取料
                        string postLocation = threeDengPostDict[req.data.destLocation];
                        string postResult = s7.ReadInt16(postLocation).Content.ToString();
                        if (postResult == "16")
                        {
                            //消除请求
                            s7.Write(postLocation, Convert.ToInt16("0"));
                        }
                    }
                }

                //判断取放地址是否满足条件
                if (pointDict.ContainsKey(req.data.location))
                {
                    string location = pointDict[req.data.location]; //取
                    if (location != null)
                    {
                        string getResult = s7.ReadInt16(location).Content.ToString();
                        if (getResult != "9" && getResult != "8")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.location + "取条件不满足【" + getResult + "】";
                            return responseData;
                        }
                    }
                }

                if (pointDict.ContainsKey(req.data.destLocation))
                {
                    string destLocation = pointDict[req.data.destLocation]; //放
                    if (destLocation != null)
                    {
                        string putResult = s7.ReadInt16(destLocation).Content.ToString();
                        if (putResult != "16")
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + putResult + "】" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            responseData.msg = "异常===>>" + "点位" + req.data.destLocation + "放条件不满足【" + putResult + "】";
                            return responseData;
                        }
                    }
                }

                string log = "任务【" + req.taskNodeId + "】写入:";
                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString(); 

                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                                log = log + "地址:" + actionAddress.Address + "【" + dataValue + "】";
                            }
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));

                            log = log + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                        }

                        //同步更新数据库状态
                        //CcsTagValue tagValueQuery = new CcsTagValue();
                        //tagValueQuery.Ip = req.url;
                        //tagValueQuery.Address = actionAddress.Address;
                        //CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault(); 
                        //if(tagValue != null)
                        //{
                        //    tagValue.TagValue = actionAddress.Value;
                        //    await _ccsTagValueService.Update(tagValue);
                        //}  
                    }
                }
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "===>>" + log
                  , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                Thread.Sleep(SLEEP_TIME);
                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                bool checkFlag = true;
                string returnMsg = "";
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //取参数传参值
                        string dataValue = getProperties(req.data, actionAddress.Description);
                        //读取写入结果
                        string readWriteResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (dataValue != readWriteResult)
                        {
                            returnMsg = "地址位:" + actionAddress.Address + "写入值：" + dataValue + "读出值：" + readWriteResult;
                            checkFlag = false;
                            break;
                        }

                    }

                }
                //不通过不写执行
                if (!checkFlag)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "写入失败,plc没有写入相应的值" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.msg = "写入异常===>>" + returnMsg;
                    return responseData;
                }

                //二次写入地址列表
                string log2 = "任务【" + req.taskNodeId + "】二次写入:";
                List<CcsActionAddress> CcsActionAddressWriteSeconds = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSeconds)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                            }
                        }
                        else
                        {
                            log2 = log2 + "地址:" + actionAddress.Address + "【" + actionAddress.Value + "】";
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "二次写入===>>" + log2
                  , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                s7.ConnectClose();

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

        public async Task<ResponseECSData> CancelCCS(RequestData<LocationData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskNodeId);
            TaskCallback taskCallback = new TaskCallback(req.taskNodeId);

            List<TaskCallback> taskCallbacks = await _taskCallbackService.GetList(taskCallback);

            if (taskCallbacks.Count == 1)
            {
                TaskCallback taskCallback1 = taskCallbacks[0];
                taskCallback1.State = false;
                await _taskCallbackService.Update(taskCallback1);
                responseData.msg = req.taskNodeId + ":取消任务成功";
            }
            else if(taskCallbacks.Count == 0)
            {
                responseData.result = "false";
                responseData.msg = req.taskNodeId + ":不存在当前任务";
                   
            }
                
            return responseData;
        }
    }
}