#region    [自定义类-VS][20250623083459471][AutoThread]
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using GZ.Modular.Redis;
using GZ.DB.Entity.OIDATABASE;
using GZ.DB.IRepository.OIDATABASE;
using GZ.DB.Repository.OIDATABASE;
using static System.Windows.Forms.VisualStyles.VisualStyleElement;
using System.Windows.Interop;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.TextBox;
using System.Security.Cryptography;
using System.Windows.Markup;
using static GZ.Projects.AuxAllWCS.EasyPLC;
using static System.Runtime.CompilerServices.RuntimeHelpers;
using ServiceStack.Configuration;
using ServiceStack;
using Spectre.Console;
using System.Net.WebSockets;
using System.Net;
using System.Threading;
using System.IO;

namespace GZ.Projects.AuxAllWCS
{
    public partial class AutoThread
    {

        private static AutoThread _instance;

        // 私有构造函数防止外部实例化
        private AutoThread() { }

        public static AutoThread Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new AutoThread();
                }
                return _instance;
            }
        }

        // 线程安全的委托缓存
        private static readonly ConcurrentDictionary<string, Delegate> _methodCache = new ConcurrentDictionary<string, Delegate>();

        // 方法执行器
        public static object InvokeMethod(object instance, string methodName, params object[] args)
        {
            var cacheKey = $"{instance.GetType().FullName}_{methodName}";

            if (!_methodCache.TryGetValue(cacheKey, out var methodDelegate))
            {
                // 获取方法信息
                var methodInfo = instance.GetType().GetMethod(
                    methodName,
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

                if (methodInfo == null)
                    throw new MissingMethodException($"Method {methodName} not found");

                // 创建委托并缓存
                methodDelegate = Delegate.CreateDelegate(
                    GetDelegateType(methodInfo),
                    instance,
                    methodInfo);

                _methodCache.TryAdd(cacheKey, methodDelegate);
            }

            // 执行委托
            //if (methodName != "TaskEverythingRun")
            //    return null;
            return methodDelegate.DynamicInvoke(args);
        }

        // 根据方法签名生成对应的委托类型
        private static Type GetDelegateType(MethodInfo methodInfo)
        {
            var parameterTypes = methodInfo.GetParameters()
                .Select(p => p.ParameterType)
                .ToList();

            if (methodInfo.ReturnType == typeof(void))
            {
                return System.Linq.Expressions.Expression.GetActionType(parameterTypes.ToArray());
            }
            else
            {
                parameterTypes.Add(methodInfo.ReturnType);
                return System.Linq.Expressions.Expression.GetFuncType(parameterTypes.ToArray());
            }
        }

        /// <summary>
        /// 配置初始化。
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="action"></param>
        public void ThreadSettingInit(Tag tag, Action action)
        {
            Console.WriteLine("初始化配置 线程 run " + tag.Global.SettingsOver);
            if (tag.Global.SettingsOver == 0)
            {
                action?.Invoke();
                tag.Global.SettingsOver = 1;
            }
            else if (Settings.deviceInfos.Count == 0)
            {
                tag.Global.SettingsOver = 0;
            }
            else tag.Global.SettingsOver++;
            if (tag.Global.SettingsOver > 999)
            {
                tag.Global.SettingsOver = 1;
                Console.Clear();
            }
        }

        public string WriteLine(string value = "")
        {




            // 在这里拦截处理输出
            string intercepted = $"[拦截到的输出] {value}";
            return intercepted;
        }

        /// <summary>
        /// 捷顺1 信号处理
        /// </summary>
        /// <param name="tag"></param>
        public void ThreadJS1(Tag tag)
        {
            Console.WriteLine($"ThreadJS1 捷顺1 信号处理 =================> ");
            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 2 && x.deviceName == "Js捷顺1");

            if (VERX != null)
            {
                if (tag.Js1.D1212_LAST == 0 && TcpServer.GetBitdata(tag.Js1.D1212, 2) == 1)
                {
                    var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                    {
                        requestType = 4,
                        endBit = VERX.location[0]
                    }));
                    LogHelper.Info($"{VERX.location[0]}申请mes任务结果{str}");
                    var strr = JsonConvert.DeserializeObject<Messss>(str);
                    if (strr != null && strr.success && strr.data?.state == 0)
                    {
                        //tag.Js1.D1212_LAST = 1;
                        RedisHelper.Add($"Js捷顺1.D1202_LAST", "1", out string msg);
                    }
                }
                if (tag.Js1.D1212_LAST == 1 && TcpServer.GetBitdata(tag.Js1.D1212, 2) == 0)
                {
                    //tag.Js1.D1212_LAST = 0; 
                    RedisHelper.Add($"Js捷顺1.D1202_LAST", "0", out string msg);
                }

                if (tag.Js1.D1213_LAST == 0 && TcpServer.GetBitdata(tag.Js1.D1212, 3) == 1)
                {
                    var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                    {
                        requestType = 4,
                        endBit = VERX.location[1]
                    }));
                    LogHelper.Info($"{VERX.location[1]}申请mes任务结果{str}");
                    var strr = JsonConvert.DeserializeObject<Messss>(str);
                    if (strr != null && strr.success && strr.data?.state == 0)
                    {
                        //tag.Js1.D1213_LAST = 1;
                        RedisHelper.Add($"Js捷顺1.D1203_LAST", "1", out string msg);
                    }
                }
                if (tag.Js1.D1213_LAST == 1 && TcpServer.GetBitdata(tag.Js1.D1212, 3) == 0)
                {
                    //tag.Js1.D1213_LAST = 0;
                    RedisHelper.Add($"Js捷顺1.D1203_LAST", "0", out string msg);
                }
            }
        }
        /// <summary>
        /// 捷顺2 信号处理
        /// </summary>
        /// <param name="tag"></param>
        public void ThreadJS2(Tag tag)
        {
            Console.WriteLine($"ThreadJS2 捷顺2 信号处理 =================> ");
            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 2 && x.deviceName == "Js捷顺2");

            if (VERX != null)
            {
                if (tag.Js2.D1212_LAST == 0 && TcpServer.GetBitdata(tag.Js2.D1212, 2) == 1)
                {
                    var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                    {
                        requestType = 4,
                        endBit = VERX.location[0]
                    }));
                    LogHelper.Info($"{VERX.location[0]}申请mes任务结果{str}");
                    var strr = JsonConvert.DeserializeObject<Messss>(str);
                    if (strr != null && strr.success && strr.data?.state == 0)
                    {
                        RedisHelper.Add($"Js捷顺2.D1202_LAST", "1", out string msg);
                    }
                }
                if (tag.Js2.D1212_LAST == 1 && TcpServer.GetBitdata(tag.Js2.D1212, 2) == 0)
                {
                    //tag.Js2.D1212_LAST = 0;

                    RedisHelper.Add($"Js捷顺2.D1202_LAST", "0", out string msg);
                }
                if (tag.Js2.D1213_LAST == 0 && TcpServer.GetBitdata(tag.Js2.D1212, 3) == 1)
                {
                    var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                    {
                        requestType = 4,
                        endBit = VERX.location[1]
                    }));
                    LogHelper.Info($"{VERX.location[1]}申请mes任务结果{str}");

                    var strr = JsonConvert.DeserializeObject<Messss>(str);
                    if (strr != null && strr.success && strr.data?.state == 0)
                    {
                        RedisHelper.Add($"Js捷顺2.D1203_LAST", "1", out string msg);
                    }
                }
                if (tag.Js2.D1213_LAST == 1 && TcpServer.GetBitdata(tag.Js2.D1213, 2) == 0)
                {
                    //tag.Js2.D1213_LAST = 0;

                    RedisHelper.Add($"Js捷顺2.D1203_LAST", "0", out string msg);
                }
            }
        }
        /// <summary>
        /// 维希尔1 左
        /// </summary>
        /// <param name="tag"></param>
        public void Threadwxr1L(Tag tag)
        {
            Console.WriteLine($"Threadwxr1L 维希尔1 左 =================> ");
            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 1 && x.deviceName.Contains("1"));

            if (VERX != null)
            {
                if (tag.wxr1.R44)
                    LogHelper.Info($"{VERX.deviceName} R44>{tag.wxr1.R44} R44LAST>{tag.wxr1.R44_LAST} R10>{tag.wxr1.R10}");
                if (tag.wxr1.R44 && !tag.wxr1.R44_LAST && tag.wxr1.R10)
                {
                    if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[0], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                    {
                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                        {
                            requestType = 1,
                            cntrCode = traycode,
                            startBit = VERX.location[0],
                            endBit = ""
                        }));
                        LogHelper.Info($"{VERX.location[0]}申请mes任务结果{str}");
                        var strr = JsonConvert.DeserializeObject<Messss>(str);
                        if (strr != null && strr.success && strr.data?.state == 0)
                        {
                            //tag.wxr1.R44_LAST = true;
                            RedisHelper.Add($"维希尔抓臂1.R44_LAST", "true", out string msg);
                        }
                    }
                    else
                    {
                        TcpServer.TcpServerSend(VERX.deviceNo[0], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E"));
                    }
                }
                else
                {
                    //TaskRepository ts = new TaskRepository();
                    if (tag.wxr1.R10_LAST) //托盘放置信号。。
                    {
                        if (tag.wxr1.R10)
                        {
                            //tag.wxr1.R10_LAST = false;
                            RedisHelper.Add($"维希尔抓臂1.R10_LAST", "false", out string msg);
                        }
                        else
                        if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[0], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                        {
                            //上报校验。
                            LogHelper.Info($"{VERX.deviceNo[0]} 上报校验>{traycode}");

                            ///var str = Settings.apiHelper.Post(Settings.MESbaseUrl + "mom-basic/dataTransmission/json/service/202", requestJson);
                            var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/202", JsonConvert.SerializeObject(new
                            {
                                sceneType = 1,
                                cntrCode = traycode,
                            }));
                            if (str.Contains("true"))
                            {
                                //Conn.默认Redis.SetValue("维希尔抓臂1.R10", "true", "维希尔抓臂1Queue");
                                tag.wxr1.R10 = true;
                                //tag.wxr1.R44_LAST = false;
                                RedisHelper.Add($"维希尔抓臂1.R44_LAST", "false", out string msg);
                            }
                            else
                            {
                                //报警。
                            }
                        }
                        else { TcpServer.TcpServerSend(VERX.deviceNo[0], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E")); }
                    }
                }
            }
        }

        /// <summary>
        /// 维希尔1 右
        /// </summary>
        /// <param name="tag"></param>
        public void Threadwxr1R(Tag tag)
        {
            Console.WriteLine($"Threadwxr1R 维希尔1 右 =================> ");
            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 1 && x.deviceName.Contains("1"));

            if (VERX != null)
            {
                if (tag.wxr1.R46)
                    LogHelper.Info($"{VERX.deviceName} R44>{tag.wxr1.R46} R44LAST>{tag.wxr1.R46_LAST} R10>{tag.wxr1.R11}");
                if (tag.wxr1.R46 && !tag.wxr1.R46_LAST && tag.wxr1.R11)
                {
                    if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[1], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                    {
                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                        {
                            requestType = 1,
                            cntrCode = traycode,
                            startBit = VERX.location[1],
                            endBit = ""
                        }));
                        LogHelper.Info($"{VERX.location[1]}申请mes任务结果{str}");
                        var strr = JsonConvert.DeserializeObject<Messss>(str);
                        if (strr != null && strr.success && strr.data?.state == 0)
                        {
                            //tag.wxr1.R46_LAST = true;
                            RedisHelper.Add($"维希尔抓臂1.R46_LAST", "true", out string msg);
                        }
                    }
                    else
                    {
                        TcpServer.TcpServerSend(VERX.deviceNo[1], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E"));
                    }
                }
                else
                {
                    if (tag.wxr1.R11_LAST) //托盘放置信号。。
                    {
                        if (tag.wxr1.R11)
                        {
                            //tag.wxr1.R11_LAST = false;
                            RedisHelper.Add($"维希尔抓臂1.R11_LAST", "false", out string msg);
                        }
                        else
                        if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[1], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                        {
                            //上报校验。
                            LogHelper.Info($"{VERX.deviceNo[1]} 上报校验>{traycode}");
                            ///var str = Settings.apiHelper.Post(Settings.MESbaseUrl + "mom-basic/dataTransmission/json/service/202", requestJson);
                            var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/202", JsonConvert.SerializeObject(new
                            {
                                sceneType = 1,
                                cntrCode = traycode,
                            }));
                            if (str.Contains("true"))
                            {
                                //Conn.默认Redis.SetValue("维希尔抓臂1.R10", "true", "维希尔抓臂1Queue");
                                tag.wxr1.R11 = true;
                                //tag.wxr1.R46_LAST = false;
                                RedisHelper.Add($"维希尔抓臂1.R46_LAST", "false", out string msg);
                            }
                            else
                            {
                                //报警。
                            }
                        }
                        else { TcpServer.TcpServerSend(VERX.deviceNo[1], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E")); }
                    }
                }
            }
        }

        /// <summary>
        /// 维希尔2 左
        /// </summary>
        /// <param name="tag"></param>
        public void Threadwxr2L(Tag tag)
        {
            Console.WriteLine($"Threadwxr2L 维希尔2 左 =================> ");
            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 1 && x.deviceName.Contains("2"));

            if (VERX != null)
            {
                if (tag.wxr2.R44)
                    LogHelper.Info($"{VERX.deviceName} R44>{tag.wxr2.R44} R44LAST>{tag.wxr2.R44_LAST} R10>{tag.wxr2.R10}");
                if (tag.wxr2.R44 && !tag.wxr2.R44_LAST && tag.wxr2.R10)
                {
                    if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[0], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                    {
                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                        {
                            requestType = 1,
                            cntrCode = traycode,
                            startBit = VERX.location[0],
                            endBit = ""
                        }));
                        LogHelper.Info($"{VERX.location[0]}申请mes任务结果{str}");
                        var strr = JsonConvert.DeserializeObject<Messss>(str);
                        if (strr != null && strr.success && strr.data?.state == 0)
                        {
                            //tag.wxr2.R44_LAST = true;
                            RedisHelper.Add($"维希尔抓臂2.R44_LAST", "true", out string msg);
                        }
                    }
                    else
                    {
                        TcpServer.TcpServerSend(VERX.deviceNo[0], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E"));
                    }
                }
                else
                {
                    if (tag.wxr2.R10_LAST) //托盘放置信号。。
                    {
                        if (tag.wxr2.R10)
                        {
                            //tag.wxr2.R10_LAST = false;
                            RedisHelper.Add($"维希尔抓臂2.R10_LAST", "false", out string msg);
                        }
                        else
                        if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[0], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                        {
                            //上报校验。
                            LogHelper.Info($"{VERX.deviceNo[0]} 上报校验>{traycode}");
                            ///var str = Settings.apiHelper.Post(Settings.MESbaseUrl + "mom-basic/dataTransmission/json/service/202", requestJson);
                            var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/202", JsonConvert.SerializeObject(new
                            {
                                sceneType = 1,
                                cntrCode = traycode,
                            }));
                            if (str.Contains("true"))
                            {
                                //Conn.默认Redis.SetValue("维希尔抓臂1.R10", "true", "维希尔抓臂1Queue");
                                tag.wxr2.R10 = true;
                                //tag.wxr2.R44_LAST = false;
                                RedisHelper.Add($"维希尔抓臂2.R44_LAST", "false", out string msg);
                            }
                            else
                            {
                                //报警。
                            }
                        }
                        else { TcpServer.TcpServerSend(VERX.deviceNo[0], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E")); }
                    }
                }
            }
        }

        /// <summary>
        /// 维希尔2 右
        /// </summary>
        /// <param name="tag"></param>
        public void Threadwxr2R(Tag tag)
        {
            Console.WriteLine($"Threadwxr2R 维希尔2 右 =================> ");

            var VERX = Settings.deviceInfos?.Find(x => x.deviceType == 1 && x.deviceName.Contains("2"));

            if (VERX != null)
            {
                if (tag.wxr2.R46)
                    LogHelper.Info($"{VERX.deviceName} R44>{tag.wxr2.R46} R44LAST>{tag.wxr2.R46_LAST} R10>{tag.wxr2.R11}");
                if (tag.wxr2.R46 && !tag.wxr2.R46_LAST && tag.wxr2.R11)
                {
                    if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[1], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                    {
                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                        {
                            requestType = 1,
                            cntrCode = traycode,
                            startBit = VERX.location[1],
                            endBit = ""
                        }));
                        LogHelper.Info($"{VERX.location[1]}申请mes任务结果{str}");
                        var strr = JsonConvert.DeserializeObject<Messss>(str);
                        if (strr != null && strr.success && strr.data?.state == 0)
                        {
                            //tag.wxr2.R46_LAST = true;
                            RedisHelper.Add($"维希尔抓臂2.R46_LAST", "true", out string msg);
                        }
                    }
                    else
                    {
                        TcpServer.TcpServerSend(VERX.deviceNo[2], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E"));
                    }
                }
                else
                {
                    //LogHelper.Info($"Threadwxr2R 托盘放置信号1。。  -{tag.wxr2.R11_LAST}");
                    if (tag.wxr2.R11_LAST) //托盘放置信号。。
                    {
                        //LogHelper.Info($"Threadwxr2R 托盘放置信号1。。  -{tag.wxr2.R11}");
                        if (tag.wxr2.R11)
                        {
                            //tag.wxr2.R11_LAST = false;
                            RedisHelper.Add($"维希尔抓臂2.R11_LAST", "false", out string msg);
                        }
                        else
                        if (TcpServer.TrayIps.TryGetValue(VERX.deviceNo[1], out string traycode) && !string.IsNullOrEmpty(traycode.Trim()))
                        {
                            LogHelper.Info($"{VERX.deviceNo[1]} 上报校验>{traycode}");
                            //上报校验。
                            ///var str = Settings.apiHelper.Post(Settings.MESbaseUrl + "mom-basic/dataTransmission/json/service/202", requestJson);
                            var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/202", JsonConvert.SerializeObject(new
                            {
                                sceneType = 1,
                                cntrCode = traycode,
                            }));
                            if (str.Contains("true"))
                            {
                                //Conn.默认Redis.SetValue("维希尔抓臂1.R10", "true", "维希尔抓臂1Queue");
                                tag.wxr2.R11 = true;
                                //tag.wxr2.R46_LAST = false;
                                RedisHelper.Add($"维希尔抓臂2.R46_LAST", "false", out string msg);
                            }
                            else
                            {
                                //报警。
                            }
                        }
                        else
                        {
                            LogHelper.Info($"Threadwxr2R。。  -发送扫码");
                            TcpServer.TcpServerSend(VERX.deviceNo[1], GZ.Device.PLC.PlcHelper.Hex2Bin("544F4E"));
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine($"Threadwxr2R 维希尔2 右  设备未找到。 =================> ");
            }
        }

        public void ThreadTaskRun(Tag tag, Func<TaskEntity, bool> action)
        {
            Console.WriteLine($"ThreadTaskRun 任务下发 =================> ");
            LogHelper.Info("ThreadTaskRun 任务下发");

            ITaskRepository taskservice = new TaskRepository();
            try
            {
                LogHelper.Info("任务下发  AGV 任务 进入");
                #region AGV任务下发。

                var tklist = taskservice.FindList(x => x.S_B_STATE == "未执行" && x.S_WORK_MODE == "AGV");
                if (tklist.Any())
                    foreach (var tk in tklist.GroupBy(item =>
                    {
                        var ticks = item.T_CREATE.Ticks;
                        return new DateTime(ticks - ticks % (10 * TimeSpan.TicksPerMinute));
                    }).OrderBy(x => x.Key))
                    {
                        var ts = tk.OrderByDescending(x => x.N_PRIORITY).ToList();
                        foreach (var t in ts)
                        {
                            var b = false;
                            b = action?.Invoke(t) ?? false; //new ViewModel().RunTask(t);

                            if (b)
                            {
                                t.S_B_STATE = "已推送";
                                taskservice.Update(t);
                            }
                        }
                        break;
                    }
                //foreach (var tk in tklist.GroupBy(item =>
                //{
                //    var ticks = item.T_CREATE.Ticks;
                //    return new DateTime(ticks - ticks % (10 * TimeSpan.TicksPerMinute));
                //}).OrderBy(x => x.Key))
                //if (tklist.Any())
                //{

                #endregion
            }
            catch (Exception ex)
            {
                LogHelper.Info(ex.Message + ex.StackTrace);
            }
            try
            {
                #region Rgv

                LogHelper.Info($"查看RGV 电量：【{tag.RGV.R当前电量}】 充电状态：【{tag.RGV.R充电状态}】 故障代码：【{tag.RGV.RgvrunError}】 手动1自动2【{tag.RGV.R手动1自动2}】");

                if (tag.RGV.R手动1自动2 == 1)
                {
                    LogHelper.Info($"RGV 手动模式，不用管。");
                    return;
                }
                if (tag.RGV.taskend == 125)
                {
                    LogHelper.Info($"RGV 有125命令未执行。");
                    System.Threading.Thread.Sleep(3000);
                    return;
                }
                LogHelper.Info($"任务下发 Rgv 任务 进入 Rgv信息 W1状态{tag.RGV.w1status} ReadTask1No>{tag.RGV.ReadTask1No} bit1taskOver>{tag.RGV.bit1taskOver} W2状态{tag.RGV.w2status} ReadTask2No>{tag.RGV.ReadTask2No} bit2taskOver>{tag.RGV.bit2taskOver}");
                TaskEntity task1 = null;
                TaskEntity task2 = null;
                var task1Isrun = false;
                if (tag.RGV.ReadTask1No > 0 && tag.RGV.bit1taskOver != 1)
                {
                    var taskno = tag.RGV.ReadTask1No;
                    string tno = "TN" + (DateTime.Now.ToString("yy")) + ((taskno.ToString()).PadLeft(8, '0'));
                    task1 = taskservice.FindEntity(x => x.S_TASK_NO == tno);
                    if (task1 != null && task1.S_B_STATE != "完成")
                        task1Isrun = true;
                    //if (tag.RGV.bit1taskOver_LAST == 1)
                    //    RedisHelper.Add($"RGV.bit1taskOver_LAST", "0", out string msg);
                }
                var task2Isrun = false;
                if (tag.RGV.ReadTask2No > 0 && tag.RGV.bit2taskOver != 1)
                {
                    var taskno = tag.RGV.ReadTask2No;
                    string tno = "TN" + (DateTime.Now.ToString("yy")) + ((taskno.ToString()).PadLeft(8, '0'));
                    task2 = taskservice.FindEntity(x => x.S_TASK_NO == tno);
                    if (task2 != null && task2.S_B_STATE != "完成")
                        task2Isrun = true;
                    //if (tag.RGV.bit2taskOver_LAST == 1)
                    //    RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                }
                if (task1Isrun || task2Isrun)
                {
                    string mes = "";
                    if (task1Isrun)
                        mes += tag.RGV.ReadTask1No + "执行中...";
                    if (task2Isrun)
                        mes += tag.RGV.ReadTask2No + "执行中...";
                    LogHelper.Info($"{mes} 不能下发新任务。");
                    System.Threading.Thread.Sleep(3000);
                    return;
                }

                var thisOver = 0;
                LogHelper.Info($"查看RGV 1工位任务》");
                if (tag.RGV.ReadTask1No > 0 && tag.RGV.bit1taskOver == 1)
                {
                    var taskno = tag.RGV.ReadTask1No;
                    LogHelper.Info($"RGV 1工位任务{tag.RGV.ReadTask1No}");
                    string tno = "TN" + (DateTime.Now.ToString("yy")) + ((taskno.ToString()).PadLeft(8, '0'));
                    task1 = taskservice.FindEntity(x => x.S_TASK_NO == tno);

                    LogHelper.Info($"RGV 1工位任务{task1?.S_TASK_NO}.bit1taskOver_LAST：{tag.RGV.bit1taskOver_LAST}");
                    if (tag.RGV.bit1taskOver_LAST == 0 && task1 != null)
                    {
                        if (task1.S_B_STATE != "完成")
                        {
                            thisOver = 1;
                            if (task1.S_B_STATE == "取货完成")
                            {
                                task1.S_B_STATE = "完成";
                                tag.RGV.ReadTask1No = 0;
                            }
                            else
                            {
                                task1.S_B_STATE = "取货完成";
                            }
                            //tag.RGV.bit1taskOver = 0;
                            LogHelper.Info($"RGV 1工位任务{task1.S_TASK_NO} 状态切换为{task1.S_B_STATE}");
                            //tag.RGV.bit1taskOver_LAST = 1;
                            RedisHelper.Add($"RGV.bit1taskOver_LAST", "1", out string msg);
                            LogHelper.Info($"RGV 1工位任务写处理");
                            taskservice.Update(task1);
                            LogHelper.Info($"RGV 1工位任务更新。");
                        }
                        else
                        {
                            LogHelper.Info("RGV1工位任务已经完成。");
                        }
                    }
                }
                else if (tag.RGV.ReadTask1No == 0)
                {
                    LogHelper.Info($"RGV 1工位没有任务》");
                }

                LogHelper.Info($"查看RGV 2工位任务》");
                if (tag.RGV.ReadTask2No > 0 && tag.RGV.bit2taskOver == 1)
                {
                    var taskno = tag.RGV.ReadTask2No;
                    LogHelper.Info($"RGV 2工位任务{tag.RGV.ReadTask2No}");
                    string tno = "TN" + (DateTime.Now.ToString("yy")) + ((taskno.ToString()).PadLeft(8, '0'));
                    task2 = taskservice.FindEntity(x => x.S_TASK_NO == tno);

                    LogHelper.Info($"RGV2工位任务{task2?.S_TASK_NO}.bit2taskOver_LAST：{tag.RGV.bit2taskOver_LAST}");
                    if (tag.RGV.bit2taskOver_LAST == 0 && task2 != null)
                    {
                        if (task2.S_B_STATE != "完成")
                        {
                            thisOver = 2;
                            if (task2.S_B_STATE == "取货完成")
                            {
                                task2.S_B_STATE = "完成";
                                tag.RGV.ReadTask2No = 0;
                            }
                            else
                            {
                                task2.S_B_STATE = "取货完成";
                            }
                            //tag.RGV.bit2taskOver = 0;
                            LogHelper.Info($"RGV 2工位任务{task2.S_TASK_NO} 状态切换为{task2.S_B_STATE}");
                            RedisHelper.Add($"RGV.bit2taskOver_LAST", "1", out string msg);
                            LogHelper.Info($"RGV 2工位任务写处理");
                            taskservice.Update(task2);
                            LogHelper.Info($"RGV 2工位任务更新。");
                        }
                        else
                        {
                            LogHelper.Info("RGV2工位任务已经完成。");
                        }
                    }
                }
                else if (tag.RGV.ReadTask2No == 0)
                {
                    LogHelper.Info($"RGV 2工位没有任务》");
                }

                //if (thisOver > 0)
                //{
                //    var v2 = RedisHelper.Get<WriteGroupEntity>("RGVQueue", out string rev);
                //    if (v2 != null)
                //    {
                //        LogHelper.Info($"RGVQueue 读到结果-{JsonConvert.SerializeObject(v2)}  \n 下发前进行清除。");
                //        var b = RedisHelper.Remove("RGVQueue", out rev);
                //    }
                //}

                ///1 有货  就2 取。  1 没货 就2 卸货， 都有货  就1卸货。 都没货 就1卸
                var tklist = taskservice.FindList(x => x.S_B_STATE == "未执行" && x.S_WORK_MODE == "RGV").OrderBy(x => x.T_CREATE).ToList();
                if (task1 != null && task1.S_B_STATE != "完成") //1有任务
                {
                    if (task2 != null && task2.S_B_STATE != "完成")// 1 有任务  2 有任务。 
                    {
                        LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 也有任务{task2.S_TASK_NO}。 开始工位1 卸货。");
                        tag.RGV.workMod = 1;
                        tag.RGV.taskmod = 2;
                        tag.RGV.taskno1 = Convert.ToUInt32(task1.S_TASK_NO.Substring(4));
                        tag.RGV.task1do = Convert.ToUInt16(task1.S_END_LOC);
                        //RedisHelper.Add($"RGV.bit1taskOver_LAST", "0", out string msg);
                        //tag.RGV.taskend = 125;
                        //Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue");

                        if (tag.RGV.bit1taskOver == 1)
                            tag.RGV.bit1taskOver = 0;
                        LogHelper.Info($"{task1.S_TASK_NO}> end 写 125");
                        Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);

                        LogHelper.Info($"{task1.S_TASK_NO}> bit1taskOver_LAST 写 0");
                        RedisHelper.Add($"RGV.bit1taskOver_LAST", "0", out string msg);
                    }
                    else //1有任务  2 没任务。  
                    {

                        LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 没任务。 找同侧取货任务。");

                        var leftSide = new List<string> { "1023", "1020" };
                        var RightSide = new List<string> { "1002", "1008", "1010", "1016" };
                        bool creT2 = false;

                        // 2号 优先给 1020  1008  1016
                        var t2 = tklist.OrderBy(x => x.T_CREATE).ToList().Find(x => x.S_START_LOC == "1020" || x.S_START_LOC == "1008" || x.S_START_LOC == "1016");
                        if (t2 != null)
                        {
                            LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 没任务。 找1020  1008  1016取货任务{t2.S_TASK_NO}。");
                            tag.RGV.workMod = 2;
                            LogHelper.Info($"{t2.S_TASK_NO}> workMod 2 《2工位》");
                            tag.RGV.taskmod = 1;
                            LogHelper.Info($"{t2.S_TASK_NO}> taskmod 1 《取货》");
                            tag.RGV.taskno2 = Convert.ToUInt32(t2.S_TASK_NO.Substring(4));
                            tag.RGV.task2do = Convert.ToUInt16(t2.S_START_LOC);

                            if (tag.RGV.bit2taskOver == 1)
                                tag.RGV.bit2taskOver = 0;
                            LogHelper.Info($"{t2.S_TASK_NO}> end 写 125");
                            Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);

                            LogHelper.Info($"{t2.S_TASK_NO}> bit2taskOver_LAST 写 0");
                            RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                            t2.S_B_STATE = "已推送";
                            taskservice.Update(t2);
                        }
                        ////2 如果有同侧取货任务。就取。没有
                        //else if (leftSide.Contains(task1.S_START_LOC))
                        //{
                        //    leftSide.Remove(task1.S_START_LOC);
                        //    var lsde = leftSide.FirstOrDefault();
                        //    t2 = tklist.Find(x => x.S_START_LOC == lsde && x.S_END_LOC != "1017");
                        //    if (t2 != null) //同侧取货任务。
                        //    {
                        //        LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 没任务。 找同侧取货任务{t2.S_TASK_NO}。");
                        //        tag.RGV.workMod = 2;
                        //        tag.RGV.taskmod = 1;
                        //        tag.RGV.taskno2 = Convert.ToUInt32(t2.S_TASK_NO.Substring(4));
                        //        tag.RGV.task2do = Convert.ToUInt16(t2.S_START_LOC);
                        //        t2.S_B_STATE = "已推送";
                        //        taskservice.Update(t2);
                        //        creT2 = true;
                        //        System.Threading.Thread.Sleep(750);
                        //        LogHelper.Info($"{t2.S_TASK_NO}> bit2taskOver_LAST 写 0");
                        //        RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                        //        LogHelper.Info($"{t2.S_TASK_NO}> end 写 125");
                        //        Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                        //    }
                        //}
                        //else if (RightSide.Contains(task1.S_START_LOC))
                        //{
                        //    RightSide.Remove(task1.S_START_LOC);
                        //    t2 = tklist.Find(x => RightSide.Contains(x.S_START_LOC) && x.S_END_LOC != "1017");
                        //    if (t2 != null) //同侧取货任务。
                        //    {
                        //        LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 没任务。 找同侧 1002,1010 取货任务{t2.S_TASK_NO}。");
                        //        tag.RGV.workMod = 2;
                        //        tag.RGV.taskmod = 1;
                        //        tag.RGV.taskno2 = Convert.ToUInt32(t2.S_TASK_NO.Substring(4));
                        //        tag.RGV.task2do = Convert.ToUInt16(t2.S_START_LOC);
                        //        t2.S_B_STATE = "已推送";
                        //        taskservice.Update(t2);
                        //        creT2 = true;
                        //        System.Threading.Thread.Sleep(750);
                        //        LogHelper.Info($"{t2.S_TASK_NO}> bit2taskOver_LAST 写 125");
                        //        RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                        //        LogHelper.Info($"{t2.S_TASK_NO}> end 写 125");
                        //        Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                        //    }
                        //}
                        else //1 直接卸货。 
                        //if (!creT2)
                        {
                            LogHelper.Info($"查看RGV1 有任务{task1.S_TASK_NO},工位2 没任务。 没有同侧取货任务 1工位卸货。");
                            tag.RGV.workMod = 1;
                            LogHelper.Info($"{task1.S_TASK_NO}> workMod 1 《1工位》");
                            tag.RGV.taskmod = 2;
                            LogHelper.Info($"{task1.S_TASK_NO}> taskmod 2 《卸货》");
                            tag.RGV.taskno1 = Convert.ToUInt32(task1.S_TASK_NO.Substring(4));
                            tag.RGV.task1do = Convert.ToUInt16(task1.S_END_LOC);

                            if (tag.RGV.bit1taskOver == 1)
                                tag.RGV.bit1taskOver = 0;
                            LogHelper.Info($"{task1.S_TASK_NO}> taskend 写 0");
                            Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                            LogHelper.Info($"{task1.S_TASK_NO}> bit1taskOver_LAST 写 0");
                            RedisHelper.Add($"RGV.bit1taskOver_LAST", "0", out string msg);
                        }
                    }
                }
                else
                {
                    if (task2 != null && task2.S_B_STATE != "完成")// 1 没任务  2 有任务。 
                    {
                        LogHelper.Info($"查看RGV 1工位没任务,工位2 有任务{task2.S_TASK_NO}。工位2卸货。。");
                        //2 卸货。
                        tag.RGV.workMod = 2;
                        LogHelper.Info($"{task2.S_TASK_NO}> workMod 2 《2工位》");
                        tag.RGV.taskmod = 2;
                        LogHelper.Info($"{task2.S_TASK_NO}> taskmod 2 《卸货》");
                        tag.RGV.taskno2 = Convert.ToUInt32(task2.S_TASK_NO.Substring(4));
                        tag.RGV.task2do = Convert.ToUInt16(task2.S_END_LOC);

                        if (tag.RGV.bit2taskOver == 1)
                            tag.RGV.bit2taskOver = 0;
                        //tag.RGV.taskend = 125;
                        LogHelper.Info($"{task2.S_TASK_NO}> taskend 写125");
                        Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                        LogHelper.Info($"{task2.S_TASK_NO}> bit2taskOver_LAST 写 0");
                        RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                    }
                    else if (tklist.Any()) //1mei 任务  2 没任务。
                    {
                        LogHelper.Info($"查看RGV 1工位没任务,工位2 也没任务。优先1工位终点1017任务。。");
                        //、下 1017任务 给1号工位。
                        //var lss = tklist.Take(2).ToList();
                        var e1017first = tklist.Find(x => x.S_START_LOC == "1002" || x.S_START_LOC == "1010" || x.S_START_LOC == "1023");
                        //if (e1017first != null)
                        //{
                        //    e1017first = tklist.FirstOrDefault();
                        //}
                        if (e1017first != null)
                        {
                            LogHelper.Info($"查看RGV没任务， 给工位1筛选任务。 1002  1010  1023取货任务{e1017first.S_TASK_NO}。");
                            tag.RGV.workMod = 1;
                            LogHelper.Info($"{e1017first.S_TASK_NO}> workMod 1 《1工位》");
                            tag.RGV.taskmod = 1;
                            LogHelper.Info($"{e1017first.S_TASK_NO}> taskmod 1 《取货》");
                            uint tno = Convert.ToUInt32(e1017first.S_TASK_NO.Substring(4));
                            LogHelper.Info($"{e1017first.S_TASK_NO}> 转换后任务号{tno} 开始写入。");
                            tag.RGV.taskno1 = tno;
                            LogHelper.Info($"{e1017first.S_TASK_NO}>开始写入 task1do>>{e1017first.S_START_LOC}。");
                            tag.RGV.task1do = Convert.ToUInt16(e1017first.S_START_LOC);
                            //tag.RGV.taskend=125
                            if (tag.RGV.bit1taskOver == 1)
                                tag.RGV.bit1taskOver = 0;
                            LogHelper.Info($"{e1017first.S_TASK_NO}> taskend 写125");
                            Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                            LogHelper.Info($"{e1017first.S_TASK_NO}> bit1taskOver_LAST 写0");
                            RedisHelper.Add($"RGV.bit1taskOver_LAST", "0", out string msg);
                            LogHelper.Info($"{e1017first.S_TASK_NO}> 更新任务。");
                            e1017first.S_B_STATE = "已推送";
                            taskservice.Update(e1017first);
                        }
                        else
                        {
                            var t2 = tklist.OrderBy(x => x.T_CREATE).ToList().Find(x => x.S_START_LOC == "1020" || x.S_START_LOC == "1008" || x.S_START_LOC == "1016");
                            if (tklist != null)
                            {
                                LogHelper.Info($"查看RGV没任务 给工位2筛选任务。 找1020  1008  1016取货任务{t2.S_TASK_NO}。");
                                tag.RGV.workMod = 2;
                                LogHelper.Info($"{t2.S_TASK_NO}> workMod 2 《2工位》");
                                tag.RGV.taskmod = 1;
                                LogHelper.Info($"{t2.S_TASK_NO}> taskmod 1 《取货》");
                                tag.RGV.taskno2 = Convert.ToUInt32(t2.S_TASK_NO.Substring(4));
                                LogHelper.Info($"{t2.S_TASK_NO}> taskno2  {Convert.ToUInt32(t2.S_TASK_NO.Substring(4))}《任务号》");
                                tag.RGV.task2do = Convert.ToUInt16(t2.S_START_LOC);
                                if (tag.RGV.bit2taskOver == 1)
                                    tag.RGV.bit2taskOver = 0;
                                LogHelper.Info($"{t2.S_TASK_NO}> end 写 125");
                                Conn.默认Redis.SetValue("RGV.taskend", "125", "RGVQueue", false);
                                LogHelper.Info($"{t2.S_TASK_NO}> bit2taskOver_LAST 写 0");
                                RedisHelper.Add($"RGV.bit2taskOver_LAST", "0", out string msg);
                                t2.S_B_STATE = "已推送";
                                taskservice.Update(t2);
                            }
                        }
                    }
                }
                LogHelper.Info($"rgv 处理完成。taskend 125");
                #endregion
            }
            catch (Exception ex)
            {
                LogHelper.Info(ex.Message + ex.StackTrace);
            }
        }


        public void ThreadGrats(Tag tag, Action<HaiKangOrderInfo> continueTask)
        {
            LogHelper.Info($"ThreadGrats 光栅处理 =================> ");

            var taskCOdes = new List<string> { "Sarrive", "Srelease", "Earrive", "Erelease" };
            TaskActRepository taskActRepository = new TaskActRepository();
            TaskRepository taskRepository = new TaskRepository();
            var requires = taskActRepository.FindList(x => taskCOdes.Contains(x.S_ACTION_CODE) && x.N_CREATEMETHOD == 0).OrderBy(x => x.T_CREATE);
            foreach (var item in requires)
            {
                LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE}光栅处理 =================> ");
                var tin = taskCOdes.IndexOf(item.S_ACTION_CODE);
                if (tin == -1)
                {
                    item.N_CREATEMETHOD = -1;
                    taskActRepository.Update(item);
                    continue;
                }
                var task = taskRepository.FindEntity(x => x.S_TASK_NO == item.S_TASK_NO);
                if (task == null)
                {
                    item.N_CREATEMETHOD = -1;
                    taskActRepository.Update(item);
                    continue;
                }
                string loc = "";
                if (tin < 2)
                {
                    loc = item.S_START_LOC;
                }
                else
                {
                    loc = item.S_END_LOC;
                }
                if (loc == null) continue; else loc = loc.Trim();
                bool goin = tin % 2 == 0;
                bool continuuuuu = false;
                var dev = Settings.deviceInfos.Find(x => x.location.Contains(loc));
                if (dev != null)
                {
                    LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 光栅处理 =================> ");
                    var V = dev.location.ToList().FindIndex(x => x == loc) == 0;
                    //车走了  开光栅
                    if (!goin)
                    {
                        if (dev.deviceType == 1)
                        {
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 开启光栅处理 =================> ");
                            LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。" + string.Format("{0}{1}{2}", dev.deviceName + "." + (V ? "R02" : "R04"), "true", dev.deviceName + "Queue"));
                            Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "R02" : "R04"), "true", dev.deviceName + "Queue", false);
                        }
                        else if (dev.deviceType == 2)
                        {
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 开启光栅处理 =================> ");
                            LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。" + string.Format("{0}{1}{2}", dev.deviceName + "." + (V ? "D1222" : "D1223"), "1", dev.deviceName + "Queue"));

                            Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "D1220" : "D1221"), "0", dev.deviceName + "Queue");
                            Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "D1222" : "D1223"), "1", dev.deviceName + "Queue");
                        }
                        LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 开启光栅处理完成 =================> ");

                        item.N_CREATEMETHOD = 1;
                        taskActRepository.Update(item);
                    }
                    //车要进入交互。
                    else
                    {
                        if (dev.deviceType == 1)
                        {
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 关闭光栅处理 =================> ");
                            var tf = Conn.默认Redis.GetValue(dev.deviceName + "." + (V ? "R50" : "R52"));//读关闭状态
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 光栅关闭信号{tf}");
                            if (tf?.ToLower() == "true")
                            {
                                LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。 已经关闭！");
                                continuuuuu = true;
                            }
                            else
                            {
                                LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。" + string.Format("{0}{1}{2}", dev.deviceName + "." + (V ? "R01" : "R03"), "true", dev.deviceName + "Queue"));
                                Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "R01" : "R03"), "true", dev.deviceName + "Queue", false);
                            }
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 关闭光栅处理完成 =================> ");
                        }
                        else if (dev.deviceType == 2)
                        {
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 关闭光栅处理 =================> ");
                            var tf = Conn.默认Redis.GetValue(dev.deviceName + ".D1202");
                            int numm = int.Parse(string.IsNullOrEmpty(tf) ? "0" : tf);
                            int close = TcpServer.GetBitdata(numm, (V ? 0 : 1));
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 光栅关闭信号{close}");
                            if (close == 1)
                            {
                                LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。 已经关闭！");
                                continuuuuu = true;
                            }
                            else
                            {
                                LogHelper.Info($"{dev.deviceName}{(V ? "左" : "右")} 光栅{(goin ? "关闭" : "开启")} 申请。" + string.Format("{0}{1}{2}", dev.deviceName + "." + (V ? "D1220" : "D1221"), "1", dev.deviceName + "Queue"));
                                Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "D1222" : "D1223"), "0", dev.deviceName + "Queue");
                                Conn.默认Redis.SetValue(dev.deviceName + "." + (V ? "D1220" : "D1221"), "1", dev.deviceName + "Queue");

                                string d12201 = RedisHelper.Get<string>(dev.deviceName + "." + (V ? "D1220" : "D1221"), out string msg);
                                LogHelper.Info($"ThreadGrats 写{(dev.deviceName + "." + (V ? "D1220" : "D1221"))}为 1 ， 后读{d12201}");
                            }
                            LogHelper.Info($"ThreadGrats {item.S_TASK_NO} >{item.S_ACTION_CODE} 设备是{dev.deviceName} 关闭光栅处理完成 =================> ");
                        }
                    }

                }
                if (continuuuuu)
                {
                    LogHelper.Info($"{item.S_TASK_NO}{item.S_ACTION_CODE} 车辆发送继续任务！");
                    continueTask?.Invoke(new HaiKangOrderInfo
                    {
                        reqCode = item.S_ID.Replace("-", ""),
                        taskCode = item.S_TASK_NO
                    });
                    item.N_CREATEMETHOD = 1;
                    taskActRepository.Update(item);
                }
            }
            System.Threading.Thread.Sleep(3000);
            LogHelper.Info($"ThreadGrats deviceType2光栅写入位重置 =================> ");
            //重置信号
            foreach (var dev in Settings.deviceInfos.FindAll(x => x.deviceType == 2))
            {
                var tf = Conn.默认Redis.GetValue(dev.deviceName + ".D1202");
                int numm = int.Parse(string.IsNullOrEmpty(tf) ? "0" : tf);
                //int int0 = TcpServer.GetBitdata(numm, 0);
                //int int1 = TcpServer.GetBitdata(numm, 1);

                if (TcpServer.GetBitdata(numm, 0) == 0)
                {
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1220", "0", dev.deviceName + "Queue", false);
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1222", "0", dev.deviceName + "Queue", false);
                }
                if (TcpServer.GetBitdata(numm, 1) == 0)
                {
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1221", "0", dev.deviceName + "Queue", false);
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1223", "0", dev.deviceName + "Queue", false);
                }
                if (TcpServer.GetBitdata(numm, 2) == 0)
                {
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1224", "0", dev.deviceName + "Queue", false);
                }
                if (TcpServer.GetBitdata(numm, 3) == 0)
                {
                    Conn.默认Redis.SetValue(dev.deviceName + ".D1225", "0", dev.deviceName + "Queue", false);
                }
            }
            LogHelper.Info($"ThreadGrats deviceType2光栅写入位重置完成。 =================> ");
        }
        /// <summary>
        /// 1020  1023空框下线
        /// </summary>
        /// <param name="tag"></param>
        public void ThreadEdown(Tag tag)
        {
            Console.WriteLine($"ThreadEdown 20 23 = 空下检测 =================> ");
            TaskRepository taskRepository = new TaskRepository();
            foreach (var Bssx in new string[] { "1020", "1023" })
            {
                var RtaskState = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState"), typeof(System.UInt16));
                var RtaskState_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState_LAST"), typeof(System.UInt16));
                var R托盘码 = (System.String)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.R托盘码"), typeof(System.String));
                Console.WriteLine($"{Bssx} 空下检测：任务申请：{RtaskState}- 是否已处理：{RtaskState_LAST}- 托盘码：{R托盘码}  ");
                if (RtaskState == 3 && RtaskState_LAST == 0)
                {
                    var task = taskRepository.FindEntity(x => x.S_START_LOC == Bssx && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                    string msg = "";
                    if (task != null)
                    {
                        Console.WriteLine($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        LogHelper.Info($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        continue;
                    }
                    try
                    {
                        var listtep = new List<string>();
                        if (Bssx == "1020")
                        {
                            if (tag.SF下料位.RArrive1003 == 1)
                            {
                                listtep = new List<string> { "1012", "1004" };
                            }
                            else
                            {
                                listtep = new List<string> { "1004", "1012" };
                            }
                        }
                        else
                        {
                            if (tag.SF下料位.RArrive1005 == 1)
                            {
                                listtep = new List<string> { "1014", "1006" };
                            }
                            else
                            {
                                listtep = new List<string> { "1006", "1014" };
                            }
                        }

                        foreach (var item in listtep)//(Bssx == "1020" ? new string[] { "1004", "1012" } : new string[] { "1006", "1014" }))
                        {
                            var R5 = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲"), typeof(System.UInt16));
                            var R5空闲_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲_LAST"), typeof(System.UInt16));
                            if (R5 == 5 && R5空闲_LAST == 0 && task == null)
                            {
                                task = taskRepository.FindEntity(x => x.S_END_LOC == item && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                                msg = "";
                                if (task != null)
                                {
                                    Console.WriteLine($" {item}有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                                    LogHelper.Info($" {item}有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                                    continue;
                                }

                                var b = TaskProcess.CreateTask("", Bssx, item, "空上RGV", 5, new List<string> { R托盘码 }, "RGV");
                                if (b)
                                {
                                    LogHelper.Debug($"输送线RGV空托任务 from:{Bssx}>to {item}开始创建成功");
                                    RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "1", out msg);
                                    //Conn.默认Redis.SetValue($"S{Bssx}Read.RtaskState_LAST", "1", $"S{Bssx}ReadQueue");
                                    RedisHelper.Add($"S{item}Read.R5空闲_LAST", "1", out msg);
                                    //Conn.默认Redis.SetValue($"S{item}Read.R5空闲_LAST", "1", $"S{item}ReadQueue");
                                    break;
                                }
                            }
                            else if (R5 != 5 && R5空闲_LAST == 1)
                            {
                                RedisHelper.Add($"S{item}Read.R5空闲_LAST", "0", out msg);
                                //Conn.默认Redis.SetValue($"S{item}Read.R5空闲_LAST", "0", $"S{item}ReadQueue");
                            }
                        }
                        System.Threading.Thread.Sleep(1000);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex.Message, ex);
                        Console.WriteLine(ex.Message + ex.StackTrace);
                    }
                }
                else if (RtaskState != 3 && RtaskState_LAST == 1)
                {
                    RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "0", out string msg);
                    //Conn.默认Redis.SetValue($"S{Bssx}Read.RtaskState_LAST", "0", $"S{Bssx}ReadQueue");
                }
                System.Threading.Thread.Sleep(2000);
            }

            foreach (var item in new string[] { "1004", "1012", "1006", "1014", "1026", "1017" })
            {
                var R5 = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲"), typeof(System.UInt16));
                var R5空闲_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲_LAST"), typeof(System.UInt16));
                if (R5 != 5 && R5空闲_LAST == 1)
                {
                    RedisHelper.Add($"S{item}Read.R5空闲_LAST", "0", out string msg);
                    //Conn.默认Redis.SetValue($"S{item}Read.R5空闲_LAST", "0", $"S{item}ReadQueue");
                }
            }
        }

        public void ThreadDdown(Tag tag)
        {
            Console.WriteLine($"ThreadDdown 08 10 ==================> 1026");
            TaskRepository taskRepository = new TaskRepository();
            foreach (var Bssx in new string[] { "1008", "1016" })
            {
                var RtaskState = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState"), typeof(System.UInt16));
                var RtaskState_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState_LAST"), typeof(System.UInt16));
                var R托盘码 = (System.String)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.R托盘码"), typeof(System.String));
                Console.WriteLine($"{Bssx} 满下检测：任务申请：{RtaskState}- 是否已处理：{RtaskState_LAST}- 托盘码：{R托盘码}");
                if (RtaskState == 3 && RtaskState_LAST == 0)
                {
                    var task = taskRepository.FindEntity(x => x.S_START_LOC == Bssx && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                    string msg = "";
                    if (task != null)
                    {
                        Console.WriteLine($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        LogHelper.Info($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        continue;
                    }

                    var item = "1026";
                    var R5 = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲"), typeof(System.UInt16));
                    var R5空闲_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲_LAST"), typeof(System.UInt16));
                    if (R5 == 5 && R5空闲_LAST == 0)
                    {
                        task = taskRepository.FindEntity(x => x.S_END_LOC == item && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                        msg = "";
                        if (task != null)
                        {
                            Console.WriteLine($"{item} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                            LogHelper.Info($"{item} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                            continue;
                        }
                        var b = TaskProcess.CreateTask("", Bssx, item, "满转1026", 5, new List<string> { R托盘码 }, "RGV");
                        if (b)
                        {
                            RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "1", out msg);
                            RedisHelper.Add($"S{item}Read.R5空闲_LAST", "1", out string msg2);
                            //Conn.默认Redis.SetValue($"S{Bssx}Read.RtaskState_LAST", "1", $"S{Bssx}ReadQueue");
                            //Conn.默认Redis.SetValue($"S{item}Read.R5空闲_LAST", "1", $"S{item}ReadQueue");
                            break;
                        }
                    }
                    else if (R5 != 5 && R5空闲_LAST == 1)
                    {
                        RedisHelper.Add($"S{item}Read.R5空闲_LAST", "0", out string msg2);
                    }
                }
                else if (RtaskState != 3 && RtaskState_LAST == 1)
                {
                    RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "0", out string msg);
                    //Conn.默认Redis.SetValue($"S{Bssx}Read.RtaskState_LAST", "0", $"S{Bssx}ReadQueue");
                }
                System.Threading.Thread.Sleep(2000);
            }
        }

        public void Thread0210Down(Tag tag)
        {
            Console.WriteLine($"Thread0210Down ==================>");
            TaskRepository taskRepository = new TaskRepository();
            foreach (var Bssx in new string[] { "1002", "1010" })
            {
                var RtaskState = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState"), typeof(System.UInt16));
                var RtaskState_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.RtaskState_LAST"), typeof(System.UInt16));
                var R托盘码 = (System.String)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{Bssx}Read.R托盘码"), typeof(System.String));
                Console.WriteLine($"{Bssx} 满下检测：任务申请：{RtaskState}- 是否已处理：{RtaskState_LAST}- 托盘码：{R托盘码}");
                if (RtaskState == 3 && RtaskState_LAST == 0)
                {
                    var task = taskRepository.FindEntity(x => x.S_START_LOC == Bssx && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                    string msg = "";
                    if (task != null)
                    {
                        Console.WriteLine($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        LogHelper.Info($"{Bssx} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                        continue;
                    }
                    var item = "1017";
                    var R5 = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲"), typeof(System.UInt16));
                    var R5空闲_LAST = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"S{item}Read.R5空闲_LAST"), typeof(System.UInt16));
                    if (R5 == 5 && R5空闲_LAST == 0)
                    {
                        task = taskRepository.FindEntity(x => x.S_END_LOC == item && x.S_B_STATE != "完成" && x.S_B_STATE != "取消");
                        msg = "";
                        if (task != null)
                        {
                            Console.WriteLine($"{item} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                            LogHelper.Info($"{item} 有正在 [{task.S_B_STATE}] 中的{task.S_TASK_NO}任务");
                            continue;
                        }
                        var b = TaskProcess.CreateTask("", Bssx, item, "满转1017", 5, new List<string> { R托盘码 }, "RGV");
                        if (b)
                        {
                            RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "1", out msg);
                            RedisHelper.Add($"S{item}Read.R5空闲_LAST", "1", out string msg1);
                            //Conn.默认Redis.SetValue($"S{Bssx}Read.RtaskState_LAST", "1", $"S{Bssx}ReadQueue");
                            //Conn.默认Redis.SetValue($"S{item}Read.R5空闲_LAST", "1", $"S{item}ReadQueue");
                            break;
                        }
                    }
                    else if (R5 != 5 && R5空闲_LAST == 1)
                    {
                        RedisHelper.Add($"S{item}Read.R5空闲_LAST", "0", out string msg1);
                    }
                }
                else if (RtaskState != 3 && RtaskState_LAST == 1)
                {
                    RedisHelper.Add($"S{Bssx}Read.RtaskState_LAST", "0", out string msg);
                }
                System.Threading.Thread.Sleep(2000);
            }
        }


        public void Thread下料位检测(Tag tag)
        {
            Console.WriteLine($"Thread下料位检测    =====>");
            foreach (var ssx in new string[] { "1003", "1005", "1011", "1013" })
            {
                var RArrive = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"FNK1003051113.RArrive{ssx}"), typeof(System.UInt16));
                //var RArriveLast = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"FNK1003051113.RArrive{ssx}_LAST"), typeof(System.UInt16));
                var wArriveOver = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"FNK1003051113.wArrive{ssx}Over"), typeof(System.UInt16));
                var rReleaseOver = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"FNK1003051113.rRelease{ssx}Over"), typeof(System.UInt16));
                var WRelease = (System.UInt16)System.Convert.ChangeType(Conn.默认Redis.GetValue($"FNK1003051113.WRelease{ssx}"), typeof(System.UInt16));
                var RtrayCode = (System.String)System.Convert.ChangeType(Conn.默认Redis.GetValue($"SSX1003051113.R{ssx}Barcode"), typeof(System.String));
                var rdisTcode = RedisHelper.Get<string>($"Arrive{ssx}BarcodeLast", out string msg);
                // 写了空框到位的托盘号记录， 如果下次信号来了，托盘号不一致就写，一致就不写，防止因特殊原因被清除重新触发，导致发送重复的问题。
                LogHelper.Info($@" 托盘号：{RtrayCode} redis托盘号：{rdisTcode} 空到位 RArrive{ssx}>{RArrive} 机械手收到控到位.wArrive{ssx}Over>{wArriveOver} 送出完成.rRelease{ssx}Over>{rReleaseOver}  放货完成.WRelease{ssx}>{WRelease}");
                if (RArrive == 1 && WRelease == 0 /*&& RArriveLast == 0*/ && !string.IsNullOrEmpty(RtrayCode) && RtrayCode != rdisTcode)
                {
                    switch (ssx)
                    {
                        case "1003":
                            {
                                LogHelper.Info($"ssx == 1003 && tag.SF下料位.WRelease1003:{tag.SF下料位.WRelease1003}  写f1 2210=1，Arrive{ssx}BarcodeLast={RtrayCode}");
                                tag.FNK1.D2210 = 1;
                            }
                            break;
                        case "1005":
                            {
                                LogHelper.Info($"ssx == 1005 && tag.SF下料位.WRelease1005:{tag.SF下料位.WRelease1005}  写f1 2215=1，Arrive{ssx}BarcodeLast={RtrayCode}");
                                tag.FNK1.D2215 = 1;
                            }
                            break;
                        case "1011":
                            {
                                LogHelper.Info($"ssx == 1011 && tag.SF下料位.WRelease1011:{tag.SF下料位.WRelease1011}  写f2 2210=1，Arrive{ssx}BarcodeLast={RtrayCode}");
                                tag.FNK2.D2210 = 1;
                            }
                            break;
                        case "1013":
                            {
                                LogHelper.Info($"ssx == 1013 && tag.SF下料位.WRelease1013:{tag.SF下料位.WRelease1013}  写f2 2215=1，Arrive{ssx}BarcodeLast={RtrayCode}");
                                tag.FNK2.D2215 = 1;
                            }
                            break;
                    }
                    RedisHelper.Add($"Arrive{ssx}BarcodeLast", RtrayCode, out msg);
                }
                else if (RArrive == 0)
                {
                    //if (RArriveLast == 1)
                    //{
                    //    LogHelper.Info($"重置 FNK1003051113.RArrive{ssx}_LAST=0");
                    //    RedisHelper.Add($"FNK1003051113.RArrive{ssx}_LAST", "0", out string msg);
                    //}
                    if (wArriveOver == 1)
                    {
                        LogHelper.Info($"重置 FNK1003051113.wArrive{ssx}Over=0");
                        Conn.默认Redis.SetValue($"FNK1003051113.wArrive{ssx}Over", "0", $"FNK1003051113Queue");
                    }
                    //Conn.默认Redis.SetValue($"FNK1003051113.RArrive{ssx}_LAST", "0", $"FNK1003051113Queue");
                }

                if (WRelease == 1 && rReleaseOver == 1)
                {
                    switch (ssx)
                    {
                        case "1003":
                            {
                                LogHelper.Info($"读{ssx} WRelease=1&& rReleaseOver=1  读FNK1.D2213{tag.FNK1.D2213}=1? 并写0");
                                tag.FNK1.D2213 = 0;
                            }
                            break;
                        case "1005":
                            {
                                LogHelper.Info($"读{ssx} WRelease=1&& rReleaseOver=1  读FNK1.D2218{tag.FNK1.D2218}=1? 并写0");
                                tag.FNK1.D2218 = 0;
                            }
                            break;
                        case "1011":
                            {
                                LogHelper.Info($"读{ssx} WRelease=1&& rReleaseOver=1  读FNK2.D2213{tag.FNK1.D2213}=1? 并写0");
                                tag.FNK2.D2213 = 0;
                            }
                            break;
                        case "1013":
                            {
                                LogHelper.Info($"读{ssx} WRelease=1&& rReleaseOver=1  读FNK2.D2218{tag.FNK2.D2218}=1?  并写0");
                                tag.FNK2.D2218 = 0;
                            }
                            break;
                    }
                    LogHelper.Info($"读{ssx} WRelease=1&& rReleaseOver=1  WRelease 写0");
                    Conn.默认Redis.SetValue($"FNK1003051113.WRelease{ssx}", "0", $"FNK1003051113Queue");
                }

            }
        }

        public void ThreadFNK1Over(Tag tag)
        {
            Console.WriteLine($"ThreadFNK1Over    =====>");
            LogHelper.Info($" FN1 D2217>{tag.FNK1.D2217} D2217LAST>{tag.FNK1.D2217_LAST} D2215>{tag.FNK1.D2215} D2216>{tag.FNK1.D2216} D2218>{tag.FNK1.D2218}");
            //LogHelper.Info($" FN1 .D2217=1,2217_LAST=0 写 2215=0，D2217_LAST=1，WRelease1005=1 RArrive1005_LAST=0");
            if (tag.FNK1.D2217 == 1 && tag.FNK1.D2217_LAST == 0)
            {
                //tag.FNK1.D2215 = 0;
                tag.FNK1.D2218 = 1;
                //tag.FNK1.D2212_LAST = 1;
                RedisHelper.Add($"p发那科1下线.D2217_LAST", "1", out string msg);

                tag.SF下料位.WRelease1005 = 1;
                tag.SF下料位.WSafe0305 = 1;
                System.Threading.Thread.Sleep(1000);
                //RedisHelper.Add($"FNK1003051113.RArrive1005_LAST", "0", out msg);
                RedisHelper.Add($"Arrive1005BarcodeLast", "0", out msg);
                LogHelper.Info($" FN1 .D2217=1,2217_LAST=0 写 2218=1，D2217_LAST=1，WRelease1005=1 Arrive1005BarcodeLast=0");
            }
            else if (tag.FNK1.D2217 == 0 && tag.FNK1.D2217_LAST == 1)
            {
                //tag.FNK1.D2217_LAST = 0;
                RedisHelper.Add($"p发那科1下线.D2217_LAST", "0", out string msg);
                LogHelper.Info($" p发那科1下线.D2217_LAST=0");
            }
            if (tag.FNK1.D2216 == 1)
            {
                tag.FNK1.D2215 = 0;
                tag.SF下料位.wArrive1005Over = 1;
                LogHelper.Info($" p发那科1下线 读D2216=1  写D2215 =0， 写机械手收到1005 =1");
            }

            LogHelper.Info($" FN1 D2212>{tag.FNK1.D2212} D2212LAST>{tag.FNK1.D2212_LAST} D2210>{tag.FNK1.D2210} D2211>{tag.FNK1.D2211} D2213>{tag.FNK1.D2213}");
            if (tag.FNK1.D2212 == 1 && tag.FNK1.D2212_LAST == 0)
            {
                tag.FNK1.D2213 = 1;
                //tag.FNK1.D2210 = 0;
                //tag.FNK1.D2217_LAST = 1;
                RedisHelper.Add($"p发那科1下线.D2212_LAST", "1", out string msg);
                tag.SF下料位.WRelease1003 = 1;
                tag.SF下料位.WSafe0305 = 1;
                System.Threading.Thread.Sleep(1000);
                //RedisHelper.Add($"FNK1003051113.RArrive1003_LAST", "0", out msg);
                RedisHelper.Add($"Arrive1003BarcodeLast", "0", out msg);
                LogHelper.Info($" FN1 .D2212=1,2212_LAST=0 写 D2213=1，D2212_LAST=1，WRelease1003=1 Arrive1003BarcodeLast=0");
            }
            //else if (tag.FNK1.D2211 == 1)
            //    tag.FNK1.D2210 = 0;
            else if (tag.FNK1.D2212 == 0 && tag.FNK1.D2212_LAST == 1)
            {
                //tag.FNK1.D2212_LAST = 0;
                RedisHelper.Add($"p发那科1下线.D2212_LAST", "0", out string msg);
                LogHelper.Info($" p发那科1下线.D2212_LAST=0");
            }

            if (tag.FNK1.D2211 == 1)
            {
                tag.FNK1.D2210 = 0;
                tag.SF下料位.wArrive1003Over = 1;
                LogHelper.Info($" p发那科1下线 读D2211=1  写D2210 =0 写机械手收到空到1003=1");
            }
        }

        public void ThreadFNK2Over(Tag tag)
        {
            Console.WriteLine($"ThreadFNK2Over    =====>");
            LogHelper.Info($" FN2 D2217>{tag.FNK2.D2217} D2217LAST>{tag.FNK2.D2217_LAST} D2215>{tag.FNK2.D2215} D2216>{tag.FNK2.D2216} D2218>{tag.FNK2.D2218}");
            if (tag.FNK2.D2217 == 1 && tag.FNK2.D2217_LAST == 0)
            {
                //tag.FNK2.D2215 = 0;
                tag.FNK2.D2218 = 1;
                //tag.FNK2.D2212_LAST = 1;
                RedisHelper.Add($"p发那科2下线.D2217_LAST", "1", out string msg);

                tag.SF下料位.WRelease1013 = 1;
                tag.SF下料位.WSafe1113 = 1;
                System.Threading.Thread.Sleep(1000);
                //RedisHelper.Add($"FNK1003051113.RArrive1013_LAST", "0", out msg);
                RedisHelper.Add($"Arrive1013BarcodeLast", "0", out msg);
                LogHelper.Info($" FN2 .D2217=1,2217_LAST=0 写 2218=1，D2217_LAST=1，WRelease1013=1 Arrive1013BarcodeLast=0");
            }
            else if (tag.FNK2.D2217 == 0 && tag.FNK2.D2217_LAST == 1)
            {
                //tag.FNK2.D2217_LAST = 0;
                RedisHelper.Add($"p发那科2下线.D2217_LAST", "0", out string msg);

                LogHelper.Info($" p发那科2下线.D2217_LAST=0");
            }
            if (tag.FNK2.D2216 == 1)
            {
                tag.FNK2.D2215 = 0;
                tag.SF下料位.wArrive1013Over = 1;
                LogHelper.Info($" p发那科2下线 读D2216=1  写D2215 =0 写机械手收到空到1013=1");
            }

            LogHelper.Info($" FN2 D2212>{tag.FNK2.D2212} D2212LAST>{tag.FNK2.D2212_LAST} D2210>{tag.FNK2.D2210} D2211>{tag.FNK2.D2211} D2213>{tag.FNK2.D2213}");
            if (tag.FNK2.D2212 == 1 && tag.FNK2.D2212_LAST == 0)
            {
                //tag.FNK2.D2210 = 0;
                tag.FNK2.D2213 = 1;
                //tag.FNK2.D2217_LAST = 1;
                RedisHelper.Add($"p发那科2下线.D2212_LAST", "1", out string msg);

                tag.SF下料位.WRelease1011 = 1;
                tag.SF下料位.WSafe1113 = 1;
                System.Threading.Thread.Sleep(1000);
                //RedisHelper.Add($"FNK1003051113.RArrive1011_LAST", "0", out msg);
                RedisHelper.Add($"Arrive1011BarcodeLast", "0", out msg);
                LogHelper.Info($" FN2 .D2212=1,2212_LAST=0 写 2213=1，D2212_LAST=1，WRelease1011=1 Arrive1011BarcodeLast=0");
            }
            else if (tag.FNK2.D2212 == 0 && tag.FNK2.D2212_LAST == 1)
            {
                //tag.FNK2.D2212_LAST = 0;
                RedisHelper.Add($"p发那科2下线.D2212_LAST", "0", out string msg);
                LogHelper.Info($" p发那科2下线.D2212_LAST=0");
            }
            if (tag.FNK2.D2211 == 1)
            {
                tag.FNK2.D2210 = 0;
                tag.SF下料位.wArrive1011Over = 1;
                LogHelper.Info($" p发那科2下线 读D2211=1  写D2210 =0 写机械手收到空到1011 wArrive1011Over=1");
            }
        }


        public void Thread1019Down(Tag tag)
        {
            Console.WriteLine($"1019任务状态：   =====>");
            Console.WriteLine($"1019任务状态：{tag.SA1019.RtaskState}- barcode:{tag.SA1019.R托盘码}- 空闲{tag.SA1019.R5空闲}");
        }
        public void Thread1025Up(Tag tag)
        {
            Console.WriteLine($"SA1025 任务状态：   =====>");
            Console.WriteLine($"SA1025 任务状态：{tag.SA1025.RtaskState}- 空闲{tag.SA1025.R5空闲}");
        }
        public void Thread1022Up(Tag tag)
        {
            Console.WriteLine($"SA1022    =====>");
            Console.WriteLine($"SA1022 任务状态：{tag.SA1022.RtaskState}- 空闲{tag.SA1022.R5空闲}");
        }
        public void Thread1030Down(Tag tag)
        {
            Console.WriteLine($"SA1030 任务状态：   =====>");
            Console.WriteLine($"SA1030 任务状态：{tag.SA1030.RtaskState}- 空闲{tag.SA1030.R5空闲}-->对应终点2001>空闲5：{tag.SA2001.R5空闲}");
        }
        public void Thread2030Down(Tag tag)
        {

            Console.WriteLine($"SA2030 任务状态：   =====>");
            Console.WriteLine($"SA2030 任务状态：{tag.SA2030.RtaskState}- 空闲{tag.SA2030.R5空闲} - barcode:{tag.SA2030.R托盘码}");



        }

        public void ResolveMesTask()
        {
            TaskRepository taskservice = new TaskRepository();
            var tasks = taskservice.FindList(x => (x.S_B_STATE == "MES" || x.S_B_STATE == "People") && x.N_PRIORITY == -88);
            var VERXs = Settings.deviceInfos?.FindAll(x => x.deviceType == 2);
            //if (VERXs.Any())
            foreach (var task in tasks)
            {
                LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} ");
                if (task.S_TYPE?.Trim() == "100")
                {
                    LogHelper.Info($"MES任务 S_TYPE 100->{task.S_TYPE} ");
                }
                var sx = VERXs?.Find(x => x.location.Contains(task.S_END_LOC));
                LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} {(sx == null ? "非" : "是")}总装机器人任务");
                if (sx == null)
                {
                    LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 直接生成对应任务");
                    //直接生成对应任务。
                    var res = TaskProcess.CreateTask(task.S_TASK_NO, task.S_START_LOC, task.S_END_LOC, task.S_TYPE, 6, task.S_CNTRS?.Split(',').ToList() ?? new List<string>());

                    LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 直接生成对应任务 结果：{res}");
                    if (res)
                    {
                        LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 修改标识");
                        //task.N_PRIORITY = 0;
                        taskservice.dbcontext.Set<TaskEntity>().Attach(task);
                        taskservice.dbcontext.Entry(task).Property(x => x.N_PRIORITY).CurrentValue = 0;
                        taskservice.dbcontext.Entry(task).Property(x => x.N_PRIORITY).IsModified = true;
                        taskservice.dbcontext.SaveChanges();
                    }
                }
                else
                {
                    var sindex = sx.location.ToList().IndexOf(task.S_END_LOC);
                    LocRepository locRepository = new LocRepository();
                    //生成跳跃任务。  -- 托盘货位表。 
                    var t1s = taskservice.FindList(x => x.S_SRC_NO == task.S_TASK_NO);

                    LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 查找是否有已生成任务：{t1s != null}");
                    if (t1s.Any())
                    {
                        var t1 = t1s.OrderBy(x => x.T_CREATE).LastOrDefault();
                        if (t1.S_END_LOC == task.S_END_LOC)
                        {
                            task.N_PRIORITY = 0;
                            task.S_B_STATE = "MES_完成";
                            taskservice.Update(task);
                            continue;
                        }
                        if (t1.S_B_STATE == "完成")
                        {
                            //1.终点是否有托盘。 依据是终点的任务是 作为终点，还是起点。
                            //var ec = taskservice.FindList(x => (x.S_START_LOC == task.S_START_LOC || x.S_END_LOC == task.S_END_LOC) /*&& DateTime.Now.Subtract(x.T_CREATE).TotalHours < 5*/).OrderByDescending(x => x.T_CREATE).FirstOrDefault();//($"select top 1 * from TN_TASK WHERE S_START_LOC='{task.S_END_LOC}' OR S_END_LOC='{task.S_END_LOC}' ORDER BY T_CREATE DESC");
                            //var ec = taskservice.FindList(x => x.S_START_LOC == task.S_START_LOC && x.S_END_LOC == task.S_START_LOC, new Common.Data.Pagination
                            //                        {
                            //                            page = 1,
                            //                            sidx = "T_CREATE",
                            //                            sord = "desc",
                            //                            rows = 1
                            //                        }).FirstOrDefault();
                            //TaskEntity ec = null;
                            //var dev = Conn.默认Redis.GetValue(sx.deviceName + "." + (sindex == 0 ? "D1224" : "D1225"));
                            //if (dev?.Trim() == "1")
                            //    ec = taskservice.FindList(x => x.S_END_LOC == task.S_END_LOC && x.S_B_STATE == "完成", new Common.Data.Pagination
                            //    {
                            //        page = 1,
                            //        sidx = "T_CREATE",
                            //        sord = "desc",
                            //        rows = 1
                            //    }).FirstOrDefault();
                            bool canReq = true;
                            var tf = Conn.默认Redis.GetValue(sx.deviceName + ".D1202");
                            var V = sx.location.ToList().FindIndex(x => x == task.S_END_LOC) == 0;
                            var tf2 = int.Parse(string.IsNullOrEmpty(tf) ? "0" : tf);
                            canReq = TcpServer.GetBitdata(tf2, (V ? 2 : 3)) == 1;
                            //if (canReq)
                            //    ec = taskservice.FindList(x => x.S_END_LOC == task.S_END_LOC && x.S_B_STATE == "完成", new Common.Data.Pagination
                            //    {
                            //        page = 1,
                            //        sidx = "T_CREATE",
                            //        sord = "desc",
                            //        rows = 1
                            //    }).FirstOrDefault();
                            if (t1.S_START_LOC == task.S_START_LOC && canReq)//!= task.S_END_LOC)
                            {
                                //第二段。
                                LocEntity endLoc = null;
                                var di = sx;
                                if (di != null)
                                {
                                    //foreach (var ssloc in di.deviceNo)
                                    {
                                        var ssloc = di.deviceNo[1];
                                        var endloc = locRepository.FindEntity(x => x.S_LOC_CODE == ssloc);
                                        if (endloc != null && endloc.N_CURRENT_NUM == 0 && endloc.S_LOCK_STATE.Trim() == "无")
                                        {
                                            endLoc = endloc;
                                            //break;
                                        }
                                    }
                                    if (endLoc != null)
                                    {
                                        var res = TaskProcess.CreateTask(task.S_TASK_NO, task.S_END_LOC, endLoc.S_LOC_CODE, task.S_TYPE + "下空", 7, "NONE".Split(',').ToList());
                                        if (res)
                                        {
                                            task.N_PRIORITY = 0; taskservice.Update(task);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                if (t1.S_START_LOC != task.S_START_LOC)
                                {
                                    t1 = taskservice.FindEntity(x => x.S_SRC_NO == task.S_TASK_NO && x.S_START_LOC == task.S_START_LOC && x.S_B_STATE == "完成");
                                }
                                var res = TaskProcess.CreateTask(task.S_TASK_NO, t1.S_END_LOC, task.S_END_LOC, task.S_TYPE + "补满", 6, task.S_CNTRS.Split(',').ToList());
                                if (res)
                                {
                                    task.N_PRIORITY = 0; taskservice.Update(task);
                                }
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 筛选生成第一段 任务。");
                        //生成第一段。
                        LocEntity endLoc = null;
                        var di = sx;
                        if (di != null)
                        {
                            //foreach (var ssloc in di.deviceNo)
                            {
                                var ssloc = di.deviceNo[0];
                                var endloc = locRepository.FindEntity(x => x.S_LOC_CODE == ssloc);
                                if (endloc != null && endloc.N_CURRENT_NUM == 0 && endloc.S_LOCK_STATE.Trim() == "无")
                                {
                                    endLoc = endloc;
                                    //break;
                                }
                            }
                            if (endLoc != null)
                            {
                                LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 创建第一段 任务。");
                                var res = TaskProcess.CreateTask(task.S_TASK_NO, task.S_START_LOC, endLoc.S_LOC_CODE, task.S_TYPE + "满转", 8, task.S_CNTRS.Split(',').ToList());

                                LogHelper.Info($"解释MES任务 ->{task.S_TASK_NO} 创建第一段 任务。结果：{res}");
                                if (res)
                                {
                                    task.N_PRIORITY = 0; taskservice.Update(task);
                                }
                            }
                        }
                    }

                }
            }
        }


        public HkReturnResult OperateHKTaskStatus(HaiKangOrderInfo model)
        {
            // 查询任务：根据任务号
            //var wcsTask = WCSHelper.GetTask(model.taskCode);
            ITaskRepository MainMissionService = new TaskRepository();
            var wcsTask = MainMissionService.FindEntity(x => model.taskCode == x.S_TASK_NO);
            if (wcsTask != null)
            {
                if (!string.IsNullOrWhiteSpace(model.method))
                {
                    ILocRepository locrep = new LocRepository();
                    var startloc = locrep.FindEntity(x => x.S_LOC_CODE == wcsTask.S_START_LOC);
                    var endLoc = locrep.FindEntity(x => x.S_LOC_CODE == wcsTask.S_END_LOC);

                    List<string> cntrs = wcsTask.S_CNTRS.Split(',').ToList();
                    bool bobe = false;
                    //model.method = model.method?.ToLower();
                    switch (model.method)
                    {
                        case "start":
                            LogHelper.Info($"海康车任务状态变更为执行，任务号为：{model.taskCode}", "agv杭叉交互日志");
                            if (wcsTask.S_B_STATE.Trim() == "已推送")
                            {
                                wcsTask.S_B_STATE = "执行中";
                                wcsTask.T_START_TIME = DateTime.Now;
                                MainMissionService.Update(wcsTask);
                                bobe = true;
                            }
                            break;
                        case "outBin":
                        case "outbin":
                            model.method = model.method?.ToLower();
                            LogHelper.Info($"海康车任务状态变更为取货完成，任务号为：{model.taskCode}", "agv杭叉交互日志");
                            wcsTask.S_B_STATE = "取货完成";

                            startloc.N_CURRENT_NUM = 0;
                            startloc.S_LOCK_STATE = "无";
                            startloc.T_MODIFY = DateTime.Now;
                            //ILocContainerRepository locContainerRepository = new LocContainerRepository();
                            ////var cnr = locContainerRepository.FindList(x => cntrs.Contains(x.S_CNTR_CODE.Trim()) && x.S_LOC_CODE == wcsTask.S_START_LOC);
                            //locContainerRepository.Delete(x => cntrs.Contains(x.S_CNTR_CODE.Trim()) && x.S_LOC_CODE == wcsTask.S_START_LOC);
                            MainMissionService.Update(wcsTask);
                            locrep.Update(startloc);

                            bobe = true;
                            var device = Settings.deviceInfos.Find(x => x.location.Contains(wcsTask.S_START_LOC));
                            if (device != null)
                            {
                                if (device.deviceType == 1)
                                {
                                    if (device.deviceName.Contains("维希尔抓臂"))
                                    {  //卸货进行清空，触发扫码
                                        var inde = device.location.ToList().FindIndex(x => x == wcsTask.S_START_LOC) == 0;
                                        string V = inde ? "R05" : "R06";
                                        Conn.默认Redis.SetValue(device.deviceName + "." + V, "true", device.deviceName + "Queue", false);

                                        TcpServer.TrayIps.Remove(device.deviceNo[inde ? 0 : 1]);
                                    }
                                }
                                else if (device.deviceType == 2)
                                {
                                    //Task.Run(() =>
                                    //{
                                    //    var inde = device.location.ToList().FindIndex(x => x == wcsTask.S_START_LOC) == 0;
                                    //    string V = inde ? "D1224" : "D1225";
                                    //    Conn.默认Redis.SetValue(device.deviceName + "." + V, "0", device.deviceName + "Queue");
                                    //});
                                }
                            }
                            //LocationHelper.UnLockLoc(wcsTask.S_START_LOC);
                            break;
                        case "end":
                            LogHelper.Info($"海康车任务状态变更为完成，任务号为：{model.taskCode}", "agv杭叉交互日志");
                            wcsTask.S_B_STATE = "完成";
                            wcsTask.T_END_TIME = DateTime.Now;

                            bobe = true;
                            //ILocContainerRepository locContainerRepository2 = new LocContainerRepository();
                            //List<LocContainerEntity> llls = new List<LocContainerEntity>();
                            //foreach (var c in cntrs)
                            //{
                            //    var action = new LocContainerEntity()
                            //    {
                            //        S_ID = Guid.NewGuid().ToString(),
                            //        S_STATE = "编辑",
                            //        T_CREATE = DateTime.Now,
                            //        T_MODIFY = DateTime.Now,

                            //        S_LOC_CODE = endLoc.S_LOC_CODE,
                            //        S_CNTR_CODE = c,
                            //        S_TYPE = "",
                            //    };
                            //    llls.Add(action);
                            //}

                            endLoc.S_LOCK_STATE = "无";
                            endLoc.N_CURRENT_NUM = 1;
                            endLoc.T_MODIFY = DateTime.Now;
                            MainMissionService.Update(wcsTask);
                            if (Settings.deviceInfos.Find(x => x.deviceType == 2 && (/*x.location.Contains(wcsTask.S_END_LOC)||*/x.deviceNo.Contains(wcsTask.S_END_LOC))) != null)
                                locrep.Update(endLoc);
                            //locContainerRepository2.Insert(llls);

                            var device2 = Settings.deviceInfos.Find(x => x.location.Contains(wcsTask.S_END_LOC));
                            if (device2 != null)
                            {
                                if (device2.deviceType == 1)
                                {
                                    if (device2.deviceName.Contains("维希尔抓臂"))
                                    {
                                        //string V = device2.location.ToList().FindIndex(x => x == wcsTask.S_START_LOC) == 0 ? "R10" : "R11";
                                        //Conn.默认Redis.SetValue(device2.deviceName + "." + V, "true", device2.deviceName + "Queue");
                                        //卸货再写托盘取走。 然后触发扫码进行校验。 
                                        var inde = device2.location.ToList().FindIndex(x => x == wcsTask.S_END_LOC) == 0;
                                        //string V = inde ? "R05" : "R06";
                                        //Conn.默认Redis.SetValue(device2.deviceName + "." + V, "true", device2.deviceName + "Queue");
                                        string V2 = inde ? "R10_LAST" : "R11_LAST";
                                        //Conn.默认Redis.SetValue(device2.deviceName + "." + V2, "true", device2.deviceName + "Queue");

                                        GZ.Modular.Redis.RedisHelper.Add(device2.deviceName + "." + V2, "true", out string msg1);
                                        TcpServer.TrayIps.Remove(device2.deviceNo[inde ? 0 : 1]);
                                    }
                                }
                                else if (device2.deviceType == 2)
                                {
                                    if (device2.deviceName.Contains("Js捷顺"))
                                    {
                                        Task.Run(() =>
                                        {
                                            var inde = device2.location.ToList().FindIndex(x => x == wcsTask.S_END_LOC) == 0;
                                            string V = inde ? "D1224" : "D1225";
                                            Conn.默认Redis.SetValue(device2.deviceName + "." + V, "1", device2.deviceName + "Queue");
                                        });

                                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/202", JsonConvert.SerializeObject(new
                                        {
                                            sceneType = 3,
                                            cntrCode = cntrs.FirstOrDefault()
                                        }));
                                        //if (device2.deviceName.Contains("1"))
                                        //{
                                        //    if (inde) tag.Js1.D1224 = 1;
                                        //    else tag.Js1.D1225 = 1;
                                        //}else
                                        //{
                                        //    if (inde) tag.Js2.D1224 = 1;
                                        //    else tag.Js2.D1225 = 1;
                                        //}
                                    }
                                    var ssloc = device2.deviceNo[1];
                                    var endloc = locrep.FindEntity(x => x.S_LOC_CODE == ssloc);
                                    LogHelper.Info($"捷顺卸货后， 查看缓存位 {ssloc}-{endloc?.N_CURRENT_NUM}>0? 则申请mes搬走。");
                                    if (endloc != null && endloc.N_CURRENT_NUM == 1)
                                    {
                                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", JsonConvert.SerializeObject(new
                                        {
                                            requestType = 3,
                                            startBit = ssloc
                                        }));
                                        LogHelper.Info($"{ssloc}申请mes任务结果{str}");
                                    }
                                }
                            }

                            //LocationMethod.JudgeLocation(wcsTask);
                            break;
                        case "cancel":
                            LogHelper.Info($"海康车任务状态变更为取消，任务号为：{model.taskCode}", "agv杭叉交互日志");
                            wcsTask.S_B_STATE = "取消";
                            //startloc.S_LOCK_STATE = "无";
                            //endLoc.S_LOCK_STATE = "无";
                            MainMissionService.Update(wcsTask);
                            TaskActRepository taskActRepository = new TaskActRepository();
                            var tare = taskActRepository.FindList(x => x.S_TASK_NO == wcsTask.S_TASK_NO);
                            if (tare.Any())
                            {
                                if (tare.Find(x => x.S_ACTION_CODE == "outbin") == null)
                                {
                                    startloc.S_LOCK_STATE = "无";
                                    endLoc.S_LOCK_STATE = "无";
                                    locrep.Update(startloc);
                                    locrep.Update(endLoc);
                                }
                                else if (tare.Find(x => x.S_ACTION_CODE == "end") == null)
                                {
                                    endLoc.S_LOCK_STATE = "无";
                                    locrep.Update(endLoc);
                                }
                            }

                            //locrep.Update(startloc);
                            //locrep.Update(endLoc);
                            //TaskProcess.OperateStatus(wcsTask, 7);
                            //WCSHelper.Fail(wcsTask);
                            break;
                        case "apply":
                            // 判断该任务的接驳位是否有其他入库或出库任务，如果有，则在等位等待，如果没有，则入
                            //TaskisOk(wcsTask);
                            break;
                    }

                    if (!string.IsNullOrEmpty(wcsTask.S_SRC_NO))
                    {
                        var mestask = MainMissionService.FindEntity(x => x.S_TASK_NO == wcsTask.S_SRC_NO);
                        if (mestask != null && bobe)
                        {
                            if (model.method != "end")
                            {
                                if (mestask.S_START_LOC == wcsTask.S_START_LOC && mestask.S_B_STATE == "MES")
                                    Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/201", JsonConvert.SerializeObject(new
                                    {
                                        reqCode = wcsTask.S_SRC_NO,
                                        model.method
                                    }));
                            }
                            else
                            {
                                if (mestask.S_END_LOC != wcsTask.S_END_LOC)
                                {
                                    LogHelper.Info($"{wcsTask.S_SRC_NO}-{wcsTask.S_TASK_NO} 一阶段完成，重置进行二阶段。");
                                    mestask.N_PRIORITY = -88;
                                    MainMissionService.Update(mestask);
                                }
                                else if (mestask.S_B_STATE == "MES")
                                {
                                    var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/201", JsonConvert.SerializeObject(new
                                    {
                                        reqCode = wcsTask.S_SRC_NO,
                                        model.method
                                    }));
                                }
                            }

                        }
                        else if (mestask != null && model.method == "cancel")
                        {
                            if (mestask.S_B_STATE == "MES")
                                Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/201", JsonConvert.SerializeObject(new
                                {
                                    reqCode = wcsTask.S_SRC_NO,
                                    model.method
                                }));
                            LogHelper.Info($"{wcsTask.S_SRC_NO}-{wcsTask.S_TASK_NO} 一阶段取消，重置点，线程处理。");
                            mestask.N_PRIORITY = -1;
                            mestask.S_B_STATE = "MES_取消";
                            MainMissionService.Update(mestask);
                        }
                    }
                    TaskProcess.AddActionRecord(model.taskCode, model.method, model.eqpCode, model.data, wcsTask.S_START_LOC, wcsTask.S_END_LOC);
                    //调用第三方接口（如果有）TaskProcess.ReportStatus
                }
                else
                {
                    // 暂时设定为0
                    wcsTask.S_B_STATE = "上报状态空";
                    //安全请求等
                    //TaskProcess.OperateReq(model.taskCode, wcsTask.N_B_STATE, model.eqpCode, model.data);
                }
            }
            else
            {
                LogHelper.Info($"当前任务号任务不存在{model.taskCode} agv杭叉交互日志");
                return new HkReturnResult { reqCode = model.reqCode, code = 1, message = "这不是我们的任务。" };
            }
            return new HkReturnResult { reqCode = model.reqCode, code = 0 };
        }

        public void TaskEverythingRun()
        {
            var host = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
            foreach (var ip in host.AddressList)
            {
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    Console.WriteLine($"ip= {ip.ToString()}");
                    new HttpServer(ip.ToString()).HttpServerRun();
                    new TcpServer(ip.ToString());
                    var server = new EnhancedWebSocketServer($"http://{ip.ToString()}:8809/").StartAsync();
                    //var client = new WebSocketClient($"http://{ip.ToString()}:8809/").ConnectAsync();
                    break;
                }
            }
        }










    }


    public class HttpServer
    {
        System.Net.HttpListener HttpSvcHost = null;

        public static string _listenerPrefix = "";
        public HttpServer(string ip)
        {
            _listenerPrefix = $"http://{ip}:8808/";
        }
        public void HttpServerRun()
        {
            HttpSvcHost = new System.Net.HttpListener();
            HttpSvcHost.AuthenticationSchemes = System.Net.AuthenticationSchemes.Anonymous;
            HttpSvcHost.Prefixes.Add(_listenerPrefix);
            HttpSvcHost.Start();
            HttpSvcHost.BeginGetContext(HttpSvcListenerCallback, null);
        }


        private async void HttpSvcListenerCallback(IAsyncResult ar)
        {
            System.Net.HttpListenerContext context = null;
            var data = DateTime.Now;
            string apth = "";
            try
            {
                HttpSvcHost.BeginGetContext(HttpSvcListenerCallback, null);
                context = HttpSvcHost.EndGetContext(ar);
                System.Net.HttpListenerRequest request = context.Request;
                System.Net.HttpListenerResponse response = context.Response;

                using (var reader = new System.IO.StreamReader(request.InputStream, System.Text.Encoding.UTF8))
                {
                    string requestJson = reader.ReadToEnd();
                    System.Net.HttpStatusCode statusCode = 0;
                    apth = request.Url.AbsolutePath;
                    string respstr = HttpSvcListenerCallback_he(request.HttpMethod, request.Url.AbsolutePath, requestJson, out statusCode);
                    string logContent = "";
                    logContent += $"\r\n[{request.HttpMethod}]{request.Url.AbsolutePath}";
                    logContent += $"\r\n[request]{requestJson}";
                    logContent += $"\r\n[response]{respstr}";
                    _ = Task.Run(() =>
                    {
                        Conn.默认日志?.Info(logContent);
                    });
                    byte[] bytstr = Encoding.UTF8.GetBytes(respstr);
                    response.StatusCode = (int)statusCode;
                    response.SendChunked = false;
                    response.ContentLength64 = bytstr.Length;
                    //response.OutputStream.Write(bytstr, 0, bytstr.Length);
                    if (request.Url.AbsolutePath.ToLower().Contains(".js"))
                        response.ContentType = "application/javascript";
                    else if (request.Url.AbsolutePath.ToLower().Contains(".svg"))
                        response.ContentType = "image/svg+xml";
                    // 异步写入响应
                    await response.OutputStream.WriteAsync(bytstr, 0, bytstr.Length);
                }
            }
            catch (Exception ex)
            {
                _ = Task.Run(() =>
                {
                    Conn.默认日志.Error(ex.ToString());
                });
            }
            finally
            {
                context?.Response.Close();
                Console.WriteLine(apth + "<<>>" + DateTime.Now.Subtract(data).TotalMilliseconds);
            }
        }
        private System.String HttpSvcListenerCallback_he(System.String method, System.String path, System.String requestJson, out System.Net.HttpStatusCode statusCode)
        {
            try
            {
                switch (method)
                {
                    case "POST":
                        {
                            switch (path)
                            {
                                case "/agv/agvCallbackService/agvCallback":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;

                                        LogHelper.Info("ExecuteState Request-haikang：" + requestJson);
                                        var model = JsonConvert.DeserializeObject<HaiKangOrderInfo>(requestJson);
                                        AutoThread.Instance.OperateHKTaskStatus(model);
                                        return JsonConvert.SerializeObject(new HkReturnResult { reqCode = model.reqCode });
                                    }
                                case "/api/Wcs/CreateTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;

                                        LogHelper.Info("/api/Wcs/CreateTask：" + requestJson);
                                        var model = JsonConvert.DeserializeObject<ToWMSMES.CreateTask>(requestJson);
                                        var res = ToWMSMES.CreateTask.CreatemesTask(model);
                                        return JsonConvert.SerializeObject(res);
                                    }
                                case "/api/Wcs/TestRequestTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        LogHelper.Info("/api/Wcs/TestRequestTask：" + requestJson);
                                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/200", requestJson);
                                        return str;
                                    }
                                case "/api/Wcs/updateStatus":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        LogHelper.Info("/api/Wcs/updateStatus：" + requestJson);
                                        var str = Settings.apiHelper.Post(Settings.WMSbaseUrl + "mom-basic/dataTransmission/json/service/201", requestJson);
                                        return str;
                                    }
                                case "/api/Wcs/toMes":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;

                                        LogHelper.Info("/api/Wcs/toMes：" + requestJson);
                                        var str = Settings.apiHelper.Post(Settings.MESbaseUrl + "mom-basic/dataTransmission/json/service/202", requestJson);
                                        return str;
                                    }
                                case "/api/Wcs/CreatePointTask":
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;

                                        LogHelper.Info("/api/Wcs/CreatepointTask：" + requestJson);
                                        var model = JsonConvert.DeserializeObject<ToWMSMES.CreateTask>(requestJson);
                                        var res = ToWMSMES.CreateTask.CreatePointTask(model);
                                        return JsonConvert.SerializeObject(res);
                                    }
                            }
                            break;
                        }
                    case "GET":
                        {
                            switch (path)
                            {
                                case var _ when System.Text.RegularExpressions.Regex.IsMatch(path, @"\.(html|ico|js|css)(\?.*)?$", System.Text.RegularExpressions.RegexOptions.IgnoreCase):
                                    {
                                        statusCode = System.Net.HttpStatusCode.OK;
                                        // 复制到case 上
                                        //var _ when System.Text.RegularExpressions.Regex.IsMatch(path, @"\.(html|ico|js|css)(\?.*)?$", System.Text.RegularExpressions.RegexOptions.IgnoreCase)
                                        var filePath = /*Directory.GetCurrentDirectory() + "\\Static" + "\\" + path.Substring(1);*/System.IO.Path.Combine(Directory.GetCurrentDirectory() + "\\Static", path.Substring(1));
                                        return File.ReadAllText(filePath);
                                    }
                            }
                            break;
                        }
                }
                statusCode = System.Net.HttpStatusCode.NotFound;
                return "";
            }
            catch (Exception ex)
            {
                Conn.默认日志.Error(ex.ToString());
                statusCode = System.Net.HttpStatusCode.InternalServerError;
                return "";
            }
        }
    }

    class EnhancedWebSocketServer
    {
        private HttpListener _listener;
        private readonly string _listenerPrefix;
        private readonly ConcurrentDictionary<Guid, WebSocket> _connections = new ConcurrentDictionary<Guid, WebSocket>();
        private CancellationTokenSource _cts = new CancellationTokenSource();

        public EnhancedWebSocketServer(string url)
        {
            _listenerPrefix = url;
        }

        public async Task StartAsync()
        {
            try
            {
                _listener = new HttpListener();
                _listener.Prefixes.Add(_listenerPrefix);
                _listener.Start();
                Console.WriteLine($"WebSocket服务器已启动，监听 {_listenerPrefix}");
                while (!_cts.IsCancellationRequested)
                {
                    HttpListenerContext context = await _listener.GetContextAsync();
                    if (context.Request.IsWebSocketRequest)
                    {
                        var wsContext = await context.AcceptWebSocketAsync(null);
                        var connectionId = Guid.NewGuid();
                        _connections[connectionId] = wsContext.WebSocket;
                        _ = HandleConnectionAsync(connectionId, wsContext.WebSocket, _cts.Token);
                    }
                    else
                    {
                        context.Response.StatusCode = 400;
                        context.Response.Close();
                    }
                }
            }
            catch (Exception ex) when (ex is HttpListenerException || ex is ObjectDisposedException)
            {
                // 服务器停止时的正常异常
                Console.WriteLine("服务器正在停止...");
            }
        }

        private async Task HandleConnectionAsync(Guid connectionId, WebSocket webSocket, CancellationToken ct)
        {
            var buffer = new byte[1024 * 4];
            try
            {
                while (webSocket.State == WebSocketState.Open && !ct.IsCancellationRequested)
                {
                    var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), ct);

                    if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "客户端关闭连接", ct);
                        break;
                    }

                    string message = System.Text.Encoding.UTF8.GetString(buffer, 0, result.Count);
                    Console.WriteLine($"连接 {connectionId} 收到消息: {message}");

                    // 广播消息给所有客户端
                    await BroadcastMessageAsync($"客户端 {connectionId} 说: {message}");
                }
            }
            catch (WebSocketException ex)
            {
                Console.WriteLine($"连接 {connectionId} 错误: {ex.WebSocketErrorCode} - {ex.Message}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"处理连接 {connectionId} 时出错: {ex.Message}");
            }
            finally
            {
                _connections.TryRemove(connectionId, out _);
                webSocket?.Dispose();
                Console.WriteLine($"{DateTime.Now.ToString("HH:mm:ss.fff")} 连接 {connectionId} 已关闭");
            }
        }

        public async Task BroadcastMessageAsync(string message)
        {
            var buffer = System.Text.Encoding.UTF8.GetBytes(message);
            foreach (var connection in _connections)
            {
                if (connection.Value.State == WebSocketState.Open)
                {
                    try
                    {
                        await connection.Value.SendAsync(
                            new ArraySegment<byte>(buffer),
                            WebSocketMessageType.Text,
                            true,
                            CancellationToken.None);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"广播消息到连接 {connection.Key} 失败: {ex.Message}");
                    }
                }
            }
        }

        public async Task StopAsync()
        {
            _cts.Cancel();

            // 关闭所有连接
            foreach (var connection in _connections)
            {
                try
                {
                    if (connection.Value.State == WebSocketState.Open)
                    {
                        await connection.Value.CloseAsync(
                            WebSocketCloseStatus.NormalClosure,
                            "服务器关闭",
                            CancellationToken.None);
                    }
                    connection.Value.Dispose();
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"关闭连接 {connection.Key} 时出错: {ex.Message}");
                }
            }

            _listener?.Stop();
            _listener?.Close();
            Console.WriteLine("WebSocket服务器已停止");
        }

    }

    internal class WebSocketClient
    {
        private ClientWebSocket _webSocket = new ClientWebSocket();
        private readonly Uri _serverUri;

        public WebSocketClient(string serverUrl)
        {
            _serverUri = new Uri(serverUrl);
        }

        public async Task ConnectAsync()
        {
            try
            {
                await _webSocket.ConnectAsync(_serverUri, CancellationToken.None);
                Console.WriteLine("已连接到WebSocket服务器");

                // 启动接收消息任务
                _ = ReceiveMessagesAsync();

                // 发送测试消息
                await SendMessageAsync("Hello, Server!");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"连接失败: {ex.Message}");
            }
        }

        private async Task ReceiveMessagesAsync()
        {
            var buffer = new byte[1024];
            try
            {
                while (_webSocket.State == WebSocketState.Open)
                {
                    var result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
                    if (result.MessageType == WebSocketMessageType.Close)
                    {
                        await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
                        Console.WriteLine("服务器关闭了连接");
                        break;
                    }

                    string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                    Console.WriteLine($"收到服务器消息: {message}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"接收消息时出错: {ex.Message}");
            }
        }

        public async Task SendMessageAsync(string message)
        {
            if (_webSocket.State != WebSocketState.Open)
            {
                Console.WriteLine("WebSocket未连接，无法发送消息");
                return;
            }

            byte[] buffer = Encoding.UTF8.GetBytes(message);
            await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
        }

        public async Task DisconnectAsync()
        {
            if (_webSocket.State == WebSocketState.Open)
            {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "客户端关闭连接", CancellationToken.None);
            }
            _webSocket.Dispose();
            Console.WriteLine("已断开WebSocket连接");
        }
    }


    class Messss
    {
        public bool success { get; set; }
        public Ddata data { get; set; }
        public object extra { get; set; }
    }

    public class Ddata
    {
        public string reqCode { get; set; }
        public int state { get; set; }
        public string error { get; set; }
    }
}

#endregion [自定义类-VS][20250623083459471][AutoThread]