YG-PVC-WCS/WCS.Workflow/ConvPlc02.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using WCS.Data;
using WCS.Data.Models;
using WCS.Data.Utils;
using WCS.PLC;

namespace WCS.Workflow
{
    public class ConvPlc02 : Base_Conv
    {
        #region 只读变量

        private readonly string Conv_1200 = "1200";
        private readonly string Conv_1204 = "1204";
        private readonly string Conv_1460 = "1460";
        private readonly string Conv_1099 = "1099";
        private readonly string Conv_1105 = "1105";

        private readonly string Conv_1102 = "1102";
        private readonly string Conv_1104 = "1104";

        private readonly string Conv_1035 = "1035";
        private readonly string Conv_1036 = "1036";

        private readonly string Conv_1051 = "1051";
        private readonly string Conv_1056 = "1056";
        private readonly string Conv_1172 = "1172";
        private readonly string Conv_1173 = "1173";
        private readonly string Conv_1178 = "1178";
        private readonly string Conv_1177 = "1177";

        private readonly string Conv_1044 = "1044";
        private readonly string Conv_1071 = "1071";
        private readonly string Conv_1072 = "1072";
        private readonly string Conv_1085 = "1085";
        private readonly string Conv_1070 = "1070";
        private readonly string Conv_1285 = "1285";
        private readonly string Conv_1286 = "1286";
        private readonly string Conv_1287 = "1287";

        private readonly string Conv_1179 = "1179";

        private readonly string Conv_1199 = "1199";
        private readonly string Conv_1196 = "1196";

        private readonly string Conv_1504 = "1504";
        private readonly string Conv_1107 = "1107";

        private readonly string Conv_1110 = "1110";
        private readonly string Conv_1109 = "1109";

        private readonly string Conv_1114 = "1114";
        private readonly string Conv_1115 = "1115";

        private readonly string Conv_1112 = "1112";
        private readonly string Conv_1518 = "1518";

        private readonly string Conv_1092 = "1092";
        private readonly string Conv_1094 = "1094";
        private readonly string Conv_1097 = "1097";
        private readonly string Conv_1098 = "1098";

        private readonly string Conv_1185 = "1185";
        private readonly string Conv_1221 = "1221";
        private readonly string Conv_1246 = "1246";
        private readonly string Conv_1233 = "1233";
        private readonly string Conv_1234 = "1234";
        private readonly string Conv_1251 = "1251";
        private readonly string Conv_1257 = "1257";
        private readonly string Conv_1252 = "1252";
        private readonly string Conv_1258 = "1258";
        private readonly string Conv_1261 = "1261";
        private readonly string Conv_1278 = "1278";
        private readonly string Conv_1283 = "1283";

        private readonly string Conv_1288 = "1288";
        private readonly string Conv_1293 = "1293";
        private readonly string Conv_1273 = "1273";
        private readonly string Conv_1260 = "1260";

        private readonly string Conv_1193 = "1193";
        private readonly string Conv_1182 = "1182";

        private readonly string Conv_1226 = "1226";
        private readonly string Conv_1231 = "1231";

        private readonly string Conv_1214 = "1214";

        #endregion 只读变量

        #region WMS 调用

        private static int _WMSRun = 0;

        private void WMSRun()
        {
            if (Interlocked.Exchange(ref _WMSRun, 1) == 0)
            {
                try
                {
                    ThreadHelper.TaskThread(Conv_Scanning_1185_WMS);
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _WMSRun, 0);
                }
            }
        }

        #endregion WMS 调用

        #region 重载实现

        /// <summary>
        /// 调度PLC执行任务
        /// </summary>
        public override void Run()
        {
            DateTime dt = DateTime.Now;
            //Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始WMSRun");
            WMSRun();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始Conv_ScanBarCodeExeTask");
            //扫码执行任务
            Conv_ScanBarCodeExeTask();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConveyorWriteTaskExecute");

            //执行称重任务
            Conv_GetWeight();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始称重");

            //输送线任务执行
            ConveyorWriteTaskExecute();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvCacheOutTask_1172");
            //1172缓存出库
            ThreadHelper.TaskThread(ConvCacheOutTask_1072);
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTask_6_7_1115");
            ConvWriteTask_6_7(Conv_1115, Conv_1112, Conv_1114);//7#
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTask_6_7_1110");
            ConvWriteTask_6_7(Conv_1110, Conv_1107, Conv_1109);//6#

            //电控无扫码执行任务
            //Conv_NoScanExeTask();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始SrmOutConvExeTask");
            //堆垛机出口任务执行
            SrmOutConvExeTask();
            //测试1117出口任务完成
            //ConvTaskFinish_1117();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1204");
            //输送机执行任务
            ConvWriteTaskExe_1204();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1460");
            //1460申请并且上传称重信息
            ConvWriteTaskExe_1460();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1044_1071");
            ConvWriteTaskExe_1044(Conv_1071);
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1044_1072");
            ConvWriteTaskExe_1044(Conv_1072);
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1071");
            ConvWriteTaskExe_1071();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvWriteTaskExe_1072");
            ConvWriteTaskExe_1072();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始BindingTray");
            BindingTray();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始CallEmptyOutTask");
            //码盘机托盘组出库
            ThreadHelper.TaskThread(CallEmptyOutTask);
            //写入尾箱信息
            WriteLastBoxInfo();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConveyorTaskExecute");
            //修改任务状态
            ThreadHelper.TaskThread(ConveyorTaskExecute);
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConvtaskFinish");
            //出口任务完成
            ConvTaskFinish();
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlc02开始ConveyorFinish_1199");
            //1199手动出库任务完成
            ThreadHelper.TaskThread(ConveyorFinish_1199);
            Log4netHelper.Logger_ProductLog.InfoFormat("ConvPlce02开始AgvRun");
            //Agv信号对接
            AgvRun();
            DateTime dt2 = DateTime.Now;
            if (dt.AddSeconds(2) <= dt2)
            {
                Log4netHelper.Logger_ProductLog.InfoFormat(string.Format("开始时间[{0}]结束时间[{1}]", dt.ToString("yyyy-MM-dd hh:mm:ss ffff"), dt2.ToString("yyyy-MM-dd hh:mm:ss ffff")));
            }
            Log4netHelper.Logger_ProductLog.InfoFormat("结束");
        }

        #region 模块调用

        /// <summary>
        /// 输送线无扫码执行任务
        /// </summary>
        /// <param name="convNo">扫码输送线</param>
        /// <param name="exitNo">扫码异常退出口</param>
        /// <param name="endPosIsCurConv">目标地址是否当前输送线</param>
        /// <param name="plcindex">PLC索引</param>
        private void Conv_NotScannExeTask(string convNo, string exitNo, bool endPosIsCurConv = false, int plcindex = 0)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (cs.DB523_Fault) return;
                if (!cs.DB521_Request) return;

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_POSIDFROM == convNo && v.TASK_POSIDCUR == convNo && v.TASK_POSIDNEXT == convNo && v.TASK_WKSTATUS <= 1);

                if (task == null)
                {
                    throw new Exception(string.Format("输送线[{0}]有请求未查询到任务信息", convNo));
                }

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.PlcInstanceSet[plcindex];//plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodscode = 0;
                converywrite.Goodstype = 0;
                converywrite.Goodssize = 0;
                converywrite.Goodsstart = Convert.ToInt32(convNo);
                converywrite.isClearPalletizingPos = true;
                if (endPosIsCurConv)
                {
                    converywrite.Goodsend = converywrite.Goodsstart;
                }
                else
                {
                    //if (task.TASK_POSIDTO == srm)
                    //{
                    //    ThreadHelper.TaskThread(BaseWorkflow.AssignSrm, task, 2000);
                    //    return;
                    //}

                    var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);

                    var routes = routeSet.Where(v => v.ROUTE_STARTPOS == convNo).ToList();
                    if (routes.Count == 1)
                    {
                        converywrite.Goodsend = Convert.ToInt32(routes[0].ROUTE_SONPOS);
                    }
                    else
                    {
                        converywrite.Goodsend = ConveyorWriteTaskExecuteToMoreAddress(convNo, task, routes);
                    }
                }
                WriteInfoToConv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private static int _callEmptyOutTask = 0;

        /// <summary>
        /// 码盘机托盘组出库
        /// </summary>
        private void CallEmptyOutTask()
        {
            if (Interlocked.Exchange(ref _callEmptyOutTask, 1) == 0)
            {
                try
                {
                    Thread.Sleep(10000);
                    if (!SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == Conv_1185))
                    {
                        var conv = ConveyorHelper.GetConveyorSignal(PlcName, Conv_1185);
                        if (conv.CvDB51_PH_Status) return;
                        if (conv.DB521_Tasknum > 0) return;
                        if (conv.DB521_Notask) return;
                        if (conv.DB521_BCR_Noread) return;
                        if (conv.DB521_Request) return;
                        if (conv.DB520_Confirm) return;

                        var param = new GetOutTaskParam()
                        {
                            OutId = Guid.NewGuid().ToString(),
                            OutEndPostion = Conv_1185,
                            OutType = 2,
                            WareHouseId = Current.Pvchouseputong
                        };
                        BaseWorkflow.GetOutTask(param);
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _callEmptyOutTask, 0);
                }
            }
        }

        /// <summary>
        /// 写入尾箱信息
        /// </summary>
        private void WriteLastBoxInfo()
        {
            string convPosFrom = "";
            try
            {
                var sysset = SugarBase.DB.Queryable<WCS_SYSSET>().First(v => v.SET_TYPE == "PalletizingPos" && v.SET_VALUE == "1");
                if (sysset == null) return;
                //var dt = Convert.ToDateTime(sysset.SET_EDITTIME);
                //if (dt.AddMinutes(20) > SugarBase.DB.GetDate()) return;
                convPosFrom = sysset.SET_ID;
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == sysset.SET_ID && v.TASK_COMTYPE == 4))
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]存在切单信号但写入尾箱信息失败，原因：工位[{1}]存在未完成的任务。", sysset.SET_ID, sysset.SET_ID));
                }

                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == sysset.SET_ID);
                var cs = conveyor.EquSignal_Conv;

                if (cs.DB521_Request)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：存在请求，需要先处理请求信号。", sysset.SET_ID));
                }
                if (cs.DB520_Confirm)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因: 520存在确认信号Confirm值，请先处理。", sysset.SET_ID));
                }
                if (!cs.CvDB51_PH_Status)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：没有光电信号。", sysset.SET_ID));
                }
                if (cs.DB521_Tasknum <= 0)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：没有任务号。", sysset.SET_ID));
                }
                if (cs.DB521_Goodsend != Convert.ToInt32(sysset.SET_ID))
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：该位置目标地址不等于当前输送线编号。", sysset.SET_ID));
                }
                if (cs.DB520_Res01)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：DB520_Res01存在信号，不需要重复写入。", sysset.SET_ID));
                }
                if (cs.DB521_Res02)
                {
                    throw new Exception(string.Format("机械手码垛位置[{0}]写入尾箱信息失败，原因：DB521_Res02存在信号，不需要重复写入。", sysset.SET_ID));
                }
                string date = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                string result = TryCachHelper.TryTranExecute((db) =>
                {
                    db.Updateable<WCS_SYSSET>(it => new WCS_SYSSET() { SET_VALUE = "0", SET_EDITTIME = date })
                                        .Where(it => it.SET_ID == sysset.SET_ID)
                                        .ExecuteCommand();

                    if (WCS_PLCItem.Plc.WriteBits((ushort)WCS_PLCItem.WriteDBName, (uint)((cs.EquDbInfo_ReadWrite.DBReadIndox + 17) * 8 + 6), true))
                    {
                        Log4netHelper.Logger_Info.InfoFormat(string.Format("机械手码垛位置[{0}]写入强制完成信号成功！", sysset.SET_ID));
                    }
                    else
                    {
                        throw new Exception(string.Format("机械手码垛位置[{0}]写入强制完成信号失败！", sysset.SET_ID));
                    }
                });
                if (!string.IsNullOrWhiteSpace(result)) throw new Exception(result);
            }
            catch (Exception ex)
            {
                BaseWorkflow.AddLedErrorMsg(convPosFrom, ex.Message, 0);
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void AgvRun()
        {
            //agv申请取货
            AgvRequestOnMat();
            //PLC允许取货
            ConvEnableOnMat();
            //agv取货完成
            AgvFinishOnMat();
            //PLC允许离开(取货完成)
            ConvEnableAgvLeave();

            //agv申请放货
            AgvRequestUpMat();
            //PLC允许放货
            ConvEnableUpMat();
            //agv放货完成
            AgvFinishUpMat();
            //PLC允许离开(放货完成)
            ConvEnableAgvLeave_OnMat();

            //Agv对接完成后输送线请求(6#)
            RequestByAgvConv(Conv_1107, Conv_1504);
            //Agv对接完成后输送线请求(7#)
            RequestByAgvConv(Conv_1112, Conv_1518);

            //Agv对接完成后输送线请求(4#,5#,18#)
            ConvRequestDeleteAgvSignal();
        }

        private void ConvWriteTask_6_7(string convNo, string agvPosNo, string scanningNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                converywrite.Goodstype = 1;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == cs.DB521_Tasknum && v.TASK_COMTYPE == 2);
                if (task == null)
                {
                    converywrite.Tasknum = Convert.ToInt32(convNo);
                    converywrite.Goodsend = Convert.ToInt32(scanningNo);
                    //检测是否存在出库任务
                    //if (CheckIsExistOutTask(convNo)) return;
                    //WriteInfoToConveyor(cs, converywrite, true);
                    WriteInfoToCv(cs, converywrite, true);
                }
                else
                {
                    //检测AGV对接工位是否为空
                    var agvconvNo = ConveyorHelper.GetConveyorSignal(PlcName, agvPosNo);
                    if (agvconvNo.DB521_Tasknum > 0 || agvconvNo.CvDB51_PH_Status || agvconvNo.DB521_Request)
                    {
                        return;
                    }
                    converywrite.Goodstype = task.TASK_BOXBARCODE.Substring(0, 2) == "SH" ? 1 : 2;
                    converywrite.Tasknum = task.TASK_NO;
                    //var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                    //var route = routeSet.FirstOrDefault(v => v.ROUTE_STARTPOS == convNo);
                    converywrite.Goodsend = Convert.ToInt32(agvPosNo);

                    WriteInfoToConv(cs, converywrite);
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void ConvTaskFinish()
        {
            ConveyorTaskFinish(PlcName, Conv_1185);
            ConveyorTaskFinish(PlcName, Conv_1285);
            ConveyorTaskFinish(PlcName, Conv_1286, true, true);
            ConveyorTaskFinish(PlcName, Conv_1287, true, true);
            ConveyorTaskFinish(PlcName, Conv_1288, true);
            ConveyorTaskFinish(PlcName, Conv_1293, true);

            //ConveyorTaskFinish(PlcName, Conv_1454);
            //ConveyorTaskFinish(PlcName, Conv_1199, false, true);
            //ConveyorTaskFinish(PlcName, "1198", false, true);
        }

        private static int _conveyorFinish_1199 = 0;

        /// <summary>
        /// 输送线任务完成
        /// </summary>
        public void ConveyorFinish_1199()
        {
            if (Interlocked.Exchange(ref _conveyorFinish_1199, 1) == 0)
            {
                try
                {
                    List<string> list = new List<string>();
                    list.Add("1196");
                    list.Add("1197");
                    list.Add("1198");
                    list.Add("1199");
                    var tasks = SugarBase.DB.Queryable<WCS_TASK>().Where(v => v.TASK_POSIDNEXT == Conv_1196 || v.TASK_POSIDNEXT == Conv_1199).ToList();
                    tasks = tasks.Where(v => list.Contains(v.TASK_POSIDCUR)).ToList();
                    foreach (var item in tasks)
                    {
                        bool isupdate = false;
                        int agvStatus = 0;
                        if (item.TASK_POSIDTO.Contains("Pvc_18"))
                        {
                            if (Current.SysSets.FirstOrDefault(v => v.SET_ID == "Agv_18#").SET_VALUE == "1")
                            {
                                isupdate = true;
                                agvStatus = 99;
                            }
                            else
                            {
                                int task_id = string.IsNullOrWhiteSpace(item.TASK_ITEM8) ? 0 : Convert.ToInt32(item.TASK_ITEM8);
                                var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_Id == task_id);
                                if (agvtask == null || (agvtask.Task_AgvStatus == 99 && agvtask.Task_WcsStatus == 4))
                                {
                                    isupdate = true;
                                    agvStatus = 0;
                                }
                            }
                        }
                        else
                        {
                            isupdate = true;
                            agvStatus = 99;
                        }

                        if (isupdate)
                        {
                            string result = TryCachHelper.TryTranExecute((db) =>
                            {
                                //修改任务的状态
                                db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                  .Where(it => it.TASK_NO == item.TASK_NO)
                                  .ExecuteCommand();

                                int task_id = string.IsNullOrWhiteSpace(item.TASK_ITEM8) ? 0 : Convert.ToInt32(item.TASK_ITEM8);
                                if (task_id > 0)
                                {
                                    if (agvStatus > 0)
                                    {
                                        //标识agv任务Wcs完成状态
                                        db.Updateable<Middle_AGVTask>(it => new Middle_AGVTask()
                                        {
                                            Task_WcsStatus = 99,
                                            Task_AgvStatus = 99,
                                            Task_UpdateUser = "wcs",
                                            Task_UpdateDate = DateTime.Now
                                        })
                                        .Where(it => it.Task_Id == task_id)
                                        .ExecuteCommand();
                                    }
                                    else
                                    {
                                        if (db.Queryable<Middle_AGVTask>().Any(v => v.Task_Id == task_id))
                                        {
                                            //标识agv任务Wcs完成状态
                                            db.Updateable<Middle_AGVTask>(it => new Middle_AGVTask()
                                            {
                                                Task_WcsStatus = 99,
                                                Task_UpdateUser = "wcs",
                                                Task_UpdateDate = DateTime.Now
                                            })
                                            .Where(it => it.Task_Id == task_id)
                                            .ExecuteCommand();
                                        }
                                    }
                                }
                            });
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _conveyorFinish_1199, 0);
                }
            }
        }

        private void ConveyorWriteTaskExecute()
        {
            ConveyorWriteTaskExecute(Conv_1179);
            ConveyorWriteTaskExecute(Conv_1098);
            ConveyorWriteTaskExecute(Conv_1105);

            ConveyorWriteTaskExecute(Conv_1092);//4#
            ConveyorWriteTaskExecute(Conv_1099);//5#
            ConveyorWriteTaskExecute(Conv_1504);//6#
            ConveyorWriteTaskExecute(Conv_1518);//7#

            ConveyorWriteTaskExecute(Conv_1221);
            ConveyorWriteTaskExecute(Conv_1246);

            Conv_NotScannExeTask(Conv_1288, string.Empty, true);
            Conv_NotScannExeTask(Conv_1293, string.Empty, true);
            Conv_NotScannExeTask(Conv_1285, string.Empty, true);
            Conv_NotScannExeTask(Conv_1286, string.Empty, true);
            ConveyorWriteTaskExecute(Conv_1273);

            ConveyorWriteTaskExe(Conv_1226);
            ConveyorWriteTaskExe(Conv_1231);
            ConveyorWriteTaskExe(Conv_1234);
            ConveyorWriteTaskExe(Conv_1251);
            ConveyorWriteTaskExe(Conv_1257);
            ConveyorWriteTaskExe(Conv_1252);
            ConveyorWriteTaskExe(Conv_1258);
            ConveyorWriteTaskExe(Conv_1261);
            ConveyorWriteTaskExe(Conv_1278);
            ConveyorWriteTaskExe(Conv_1283);
        }

        private void SrmOutConvExeTask()
        {
            SrmOutConvExeTask(PlcName, Conv_1051);
            SrmOutConvExeTask(PlcName, Conv_1056);
            SrmOutConvExeTask(PlcName, Conv_1172, true);
            SrmOutConvExeTask(PlcName, Conv_1173, true);
            SrmOutConvExeTask(PlcName, Conv_1036, true);
            SrmOutConvExeTask(PlcName, Conv_1035, true);
            SrmOutConvExeTask(PlcName, Conv_1178, true);
            SrmOutConvExeTask(PlcName, Conv_1177, false);
        }

        /// <summary>
        /// 扫码执行任务
        /// </summary>
        private void Conv_ScanBarCodeExeTask()
        {
            //4#入库申请
            Conv_Scanning(Conv_1094, Conv_1097);
            //5#入库申请
            Conv_Scanning_1102();
            //18#入库申请
            Conv_ScanningRequestIn(Conv_1200, Conv_1200);
            //6#入库申请
            Conv_ScanningRequestIn(Conv_1109, Conv_1110);
            //7#入库申请
            Conv_ScanningRequestIn(Conv_1114, Conv_1115);
            //拆盘机拆盘扫码请求
            Conv_Scanning_1185_WCS();
        }

        /// <summary>
        /// 称重任务执行
        /// </summary>
        private void Conv_GetWeight()
        {
            Conv_Scanning_1214(Conv_1214);
        }

        #endregion 模块调用

        #region 功能实现

        private static int _convCacheOutTask_1072 = 0;

        private void ConvCacheOutTask_1072()
        {
            if (Interlocked.Exchange(ref _convCacheOutTask_1072, 1) == 0)
            {
                try
                {
                    Thread.Sleep(60000);
                    int conv1072_num = Current.TaskSet.Count(v => v.TASK_POSIDTO == Conv_1072);
                    if (conv1072_num < 3)
                    {
                        var param = new GetOutTaskParam()
                        {
                            OutId = Guid.NewGuid().ToString(),
                            OutEndPostion = Conv_1072,
                            OutType = 2,
                            WareHouseId = Current.Pvchouseputong
                        };
                        BaseWorkflow.GetOutTask(param);
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _convCacheOutTask_1072, 0);
                }
            }
        }

        public void ConveyorWriteTaskExe_WMS(string convNo)
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.CvDB51_PH_Status) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Tasknum <= 0) return;

                if (equ_conv.DB521_Res04_1 == 5)//码垛正常完成
                {
                    string barcode = SugarBase.DB.Queryable<WCS_SYSSET>().First(v => v.SET_ID == convNo).SET_MEMO.Trim();
                    if (!Current.TaskSet.Any(v => v.TASK_BOXBARCODE == barcode))
                    {
                        int contype = equ_conv.DB520_Res02 ? 2 : 1;

                        var param = new GetInTaskParam();
                        param.ContainerBarCode = barcode;
                        param.ContainerType = contype;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        param.EquipmentNo = convNo;
                        param.EndPostion = srm;

                        ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        /// <summary>
        /// 码垛位托盘搬运任务完成和码垛完成请求
        /// </summary>
        /// <param name="convNo"></param>
        public void ConveyorWriteTaskExe(string convNo)
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.CvDB51_PH_Status) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Tasknum <= 0) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == equ_conv.DB521_Tasknum);

                if (equ_conv.DB521_Res04_1 == 1)//请求码垛
                {
                    bool isHaveSonTray = true;//是否有子托盘
                    //var palletizingCodeSet = SugarBase.DB.Queryable<WCS_PalletizingCode>().ToList();
                    //WCS_PalletizingCode palletizingCode = null;
                    if (task == null || task.TASK_COMTYPE == 1 || task.TASK_WKSTATUS >= 99)
                    {
                        throw new Exception(string.Format("输送线[{0}]请求码垛未查询到任务[{1}]，无法获取码垛清单信息", convNo, equ_conv.DB521_Tasknum));
                    }
                    else
                    {
                        if (string.IsNullOrWhiteSpace(task.PalletizingSonTraySize))
                        {
                            isHaveSonTray = false;
                        }
                        else
                        {
                            if (Convert.ToInt32(task.PalletizingSonTraySize) > 0)
                            {
                                isHaveSonTray = true;

                                if (task.SonTrayColorNo.GetValueOrDefault() <= 0 || task.SonTrayColorNo.GetValueOrDefault() > 3)
                                {
                                    throw new Exception(string.Format("输送线[{0}]任务[{1}]有子托盘但无子托盘颜色编号(1.蓝;2.白;3.绿)，不能码垛。", convNo, task.TASK_NO));
                                }
                            }
                            else
                            {
                                isHaveSonTray = false;
                            }
                        }
                    }
                    // if (palletizingCode == null) return;
                    if (task == null) return;
                    var convwrite = new WCSWriteToConveyorSignal()
                    {
                        Plc = WCS_PLCItem.Plc,
                        DBName = WCS_PLCItem.WriteDBName,
                        ConveyorNo = convNo,
                        WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox,
                        Tasknum = task.TASK_NO,
                        //Goodscode = palletizingCode.PalletizingBoxNo,
                        //Goodstype = palletizingCode.PalletizingNo,
                        //Goodssize = palletizingCode.PalletizingSonTrayNo,
                        Goodscode = string.IsNullOrWhiteSpace(task.PalletizingBoxSize) ? 0 : Convert.ToInt32(task.PalletizingBoxSize),
                        Goodstype = task.TASK_STACKINGTYPE,
                        Goodssize = string.IsNullOrWhiteSpace(task.PalletizingSonTraySize) ? 0 : Convert.ToInt32(task.PalletizingSonTraySize),
                        Goodsstart = Convert.ToInt32(convNo),
                        Goodsend = Convert.ToInt32(convNo),
                        Res02 = isHaveSonTray,
                        TrayColor_One = task.SonTrayColorNo.GetValueOrDefault() == 1 ? true : false,
                        TrayColor_Two = task.SonTrayColorNo.GetValueOrDefault() == 2 ? true : false,
                        TrayColor_Three = task.SonTrayColorNo.GetValueOrDefault() == 3 ? true : false,
                        Remark = convNo
                    };

                    WriteInfoToConv(equ_conv, convwrite);
                }
                if (equ_conv.DB521_Res04_1 == 5 || equ_conv.DB521_Res04_1 == 4)//码垛正常完成
                {
                    if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == convNo && (v.TASK_WKSTATUS == 99 || v.TASK_WKSTATUS == 109)))
                    {
                        throw new Exception(string.Format("工位[{0}]存在料箱未上报完成到WMS。", convNo));
                    }

                    var cv_1401 = ConveyorHelper.GetConveyorSignal("conveyor03", "1401");
                    var cv_1416 = ConveyorHelper.GetConveyorSignal("conveyor03", "1416");
                    //获取缠膜机是否屏蔽信号
                    var cv_1205 = ConveyorHelper.GetConveyorSignal("conveyor02", "1205");

                    if ((cv_1401.DB521_Request && cv_1401.DB521_Goodsend.ToString() == convNo) ||
                        (cv_1416.DB521_Request && cv_1416.DB521_Goodsend.ToString() == convNo))
                    {
                        throw new Exception(string.Format("码垛工位[{0}]9，不能生成入库任务。", convNo));
                    }

                    string barcode = SugarBase.DB.Queryable<WCS_SYSSET>().First(v => v.SET_ID == convNo).SET_MEMO.Trim();

                    var taskitem = SugarBase.DB.Queryable<WCS_TASK>().Single(v => v.TASK_BOXBARCODE == barcode && v.TASK_POSIDFROM == convNo && v.TASK_WKSTATUS <= 1);
                    if (taskitem == null)
                    {
                        Log4netHelper.Logger_Info.InfoFormat(string.Format("码垛位置[{0}]条码[{1}]获取到机械手传递的高度是否超过1.70[{2}]", convNo, barcode, equ_conv.DB521_Res01));

                        int contype = equ_conv.DB521_Res01 ? 2 : 1;
                        //检测到缠膜机禁用时获取排往18车间的任务
                        if(cv_1205.DB521_Overload && (convNo == "1252"  || convNo == "1258"))
                        {
                            var param = new GetExeTaskParam()
                            {
                                ContainerBarCode = barcode,
                                ContainerType = contype,
                                MatBarCode = string.Empty,
                                WareHouseId = Current.Pvchouseputong,
                                EquipmentNo = convNo,
                                EndPostion = "srm",
                                IsBan = true                             
                            };
                            task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsExeTask, param);
                        }
                        else
                        {
                            var param = new GetInTaskParam()
                            {
                                ContainerBarCode = barcode,
                                ContainerType = contype,
                                MatBarCode = string.Empty,
                                WareHouseId = Current.Pvchouseputong,
                                EquipmentNo = convNo,
                                EndPostion = "srm"
                            };
                            task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                        }                        
                    }
                    else
                    {
                        int goodsend = 0;
                        var routeSet = EquRouteHelper.QueryRoute(convNo, taskitem.TASK_POSIDTO);
                        var routes = routeSet.Where(v => v.ROUTE_STARTPOS == convNo).ToList();
                        if (routes.Count() == 0)
                        {
                            throw new Exception(string.Format("输送线[{0}]任务[{1}]查询路由失败。", convNo, taskitem.TASK_NO));
                        }
                        else
                        {
                            goodsend = Convert.ToInt32(routes.First().ROUTE_SONPOS);
                        }
                        if (goodsend == 0) return;
                        if (convNo == Conv_1234) goodsend = 1235;
                        else if (convNo == Conv_1261) goodsend = 1262;

                        var convwrite = new WCSWriteToConveyorSignal()
                        {
                            Plc = WCS_PLCItem.Plc,
                            DBName = WCS_PLCItem.WriteDBName,
                            ConveyorNo = convNo,
                            WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox,
                            Tasknum = taskitem.TASK_NO,
                            Goodsstart = Convert.ToInt32(convNo),
                            isClearPalletizingPos = true,
                            Goodsend = goodsend
                        };

                        WriteInfoToConv(equ_conv, convwrite);
                    }
                }
            }
            catch (Exception ex)
            {
                BaseWorkflow.AddLedErrorMsg(convNo, ex.Message, 0);
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        //private static int _proLineWeigh = 0;
        //private void ProLineWeigh()
        //{
        //    if (Interlocked.Exchange(ref _proLineWeigh, 1) == 0)
        //    {
        //        try
        //        {
        //            int weight = 10000;//克
        //            string convNo = "1460";
        //            var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo).EquSignal_Conv;
        //            //if (equ_conv.DB523_Fault) continue;
        //            if (!equ_conv.CvDB51_PH_Status) return;
        //            if (equ_conv.DB521_Res04 <= 2000) return;
        //            if (equ_conv.DB521_Res04 < weight)
        //            {
        //                var msg = string.Format("输送机[{0}]处称重异常，当前重量[{1}]克，托盘预估重量[{2}]克以上。", convNo, equ_conv.DB521_Res04, weight);
        //                LogMessageHelper.RecordLogMessage(msg);
        //                return;
        //            }
        //            var tasks = SugarBase.DB.Queryable<WCS_TASK>().Where(v => v.TASK_COMTYPE == (int)ComTypeEnum.托盘异常退回).ToList();
        //            var task = tasks.FirstOrDefault(v => v.TASK_POSIDCUR == convNo &&
        //                                                  string.IsNullOrWhiteSpace(v.TASK_ITEM3) &&
        //                                                 v.TASK_WKSTATUS < 99 && v.TASK_WKSTATUS != 7 && v.TASK_WKSTATUS != 4);

        //            if (task == null) return;

        //            var param = new GetWeightParam();
        //            param.WMSTaskNum = task.TASK_WMSNO;
        //            param.Weight = equ_conv.DB521_Res04;
        //            BaseWorkflow.GetWeight(param);
        //        }
        //        catch (Exception ex)
        //        {
        //            LogMessageHelper.RecordLogMessage(ex);
        //        }
        //        finally
        //        {
        //            Interlocked.Exchange(ref _proLineWeigh, 0);
        //        }
        //    }
        //}
        /// <summary>
        /// 涂布车间人工上料(18#,6#,7#)
        /// </summary>
        /// <param name="convNo"></param>
        /// <param name="exitNo"></param>
        private void Conv_ScanningRequestIn(string convNo, string exitNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB520_Confirm) return;

                if (convNo == Conv_1200 && cs.DB521_Goodstype == 0)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]外捡高度为零,WCS默认标识为1", convNo), true, LogLevelEnum.INFO.ToString());
                }

                WCS_TASK task = QueryTaskByBarcode(cs, convNo);

                //if (task == null)
                //{
                //    if (CheckIsExistOutTask(convNo, cs.BarCodeStr))
                //    {
                //        //查询异常任务
                //        task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_BOXBARCODE == cs.BarCodeStr && v.TASK_COMTYPE == 6);
                //    }
                //}

                if (task == null)
                {
                    if (WcsScanConvIsUsed(convNo))
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = cs.BarCodeStr;
                        param.ContainerType = cs.DB521_Goodstype > 0 ? cs.DB521_Goodstype : 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        param.EquipmentNo = convNo;
                        param.EndPostion = srm;
                        //param.Memo3 = "1";//需要传递熟化类型，温度，时长
                        param.Memo2 = exitNo;

                        task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }
                }
                if (task == null) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodstype = 1;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                //判断任务是否已经执行
                if (task.TASK_WKSTATUS >= 2) return;

                if (task.TASK_COMTYPE == (int)ComTypeEnum.托盘异常退回)
                {
                    converywrite.Notask = true;
                    converywrite.Goodsend = Convert.ToInt32(exitNo);
                }
                else
                {
                    var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                    var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == convNo);
                    converywrite.Goodsend = Convert.ToInt32(route.ROUTE_SONPOS);
                }
                //检测存在出库任务
                //if (CheckIsExistOutTask(convNo, cs.BarCodeStr)) return;
                if (convNo == Conv_1200)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]任务[{1}]条码[{2}]外检高度[{3}](零值默认为1)。", convNo, task.TASK_NO, cs.BarCodeStr, cs.DB521_Goodstype), true, LogLevelEnum.INFO.ToString());
                }
                WriteInfoToCv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// Agv对接输送线请求删除与Agv对接信号
        /// </summary>
        public void ConvRequestDeleteAgvSignal()
        {
            try
            {
                var list = new Dictionary<string, string>();
                list.Add("1097", "1094");//4#
                list.Add("1104", "1102");//5#
                list.Add("1199", "");

                foreach (var item in list)
                {
                    try
                    {
                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Key);
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (!cs.DB521_Request) continue;
                        //if (cs.CvDB51_PH_Status == false) continue;
                        //if (cs.DB521_Tasknum == 0) continue;

                        #region 检测AGV任务是否已经完成

                        if (cs.DB521_Tasknum > 10000)
                        {
                            var task = Current.TaskSet.FirstOrDefault(v => v.TASK_NO == cs.DB521_Tasknum);
                            if (task != null && (!string.IsNullOrWhiteSpace(task.TASK_ITEM8)))
                            {
                                var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().Single(v => v.Task_Id == Convert.ToInt32(task.TASK_ITEM8));
                                if (agvtask != null &&
                                   (agvtask.Task_WcsStatus != 4 && agvtask.Task_WcsStatus != 99 && agvtask.Task_WcsStatus != 106))
                                {
                                    throw new Exception(string.Format("输送线[{0}]收到清除AGV对接信号请求，任务[{1}]与AGV对接未完成，不能清除信号。", item.Key, cs.DB521_Tasknum));
                                }
                            }
                        }

                        #endregion 检测AGV任务是否已经完成

                        var convwrite = new WCSWriteToConveyorSignal();
                        convwrite.Plc = WCS_PLCItem.Plc;
                        convwrite.DBName = WCS_PLCItem.WriteDBName;
                        convwrite.ConveyorNo = item.Key;
                        convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        if (item.Key == Conv_1199)
                        {
                            convwrite.TaskDelete = true;
                        }
                        else
                        {
                            convwrite.Tasknum = Convert.ToInt32(item.Key);
                            convwrite.Goodsstart = Convert.ToInt32(item.Key);
                            convwrite.Goodsend = Convert.ToInt32(item.Value);
                            if (cs.DB521_Goodstype == 2 || cs.CvDB51_PH_Status)
                            {
                                //检测是否存在出库任务
                                if (CheckIsExistOutTask(item.Key)) return;
                            }
                        }

                        WriteInfoToConv(cs, convwrite, true);
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 检测是否存在出库任务
        /// </summary>
        private bool CheckIsExistOutTask(string convNo, string barcode = "")
        {
            bool result = false;
            if (convNo == Conv_1112)//7#AGV对接工位
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1518 || v.TASK_POSIDNEXT == Conv_1115 || v.TASK_POSIDNEXT == Conv_1112) && v.TASK_POSIDCUR != Conv_1115))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }
            else if (convNo == Conv_1107)//6#AGV对接工位
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1504 || v.TASK_POSIDNEXT == Conv_1110 || v.TASK_POSIDNEXT == Conv_1107) && v.TASK_POSIDCUR != Conv_1110))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }
            else if (convNo == Conv_1114)//7#扫描位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1518 || v.TASK_POSIDNEXT == Conv_1115 || v.TASK_POSIDNEXT == Conv_1112) && (v.TASK_POSIDCUR != Conv_1112)))
                {
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE == barcode)) return false;
                    //生成退回异常任务
                    string msg = string.Format("输送线[{0}]条码[{1}]无法入库,单通道存在出库任务。", convNo, barcode);
                    LogMessageHelper.RecordLogMessage(msg);

                    string errormsg = TryCachHelper.TryTranExecute((db) =>
                    {
                        BaseWorkflow.AddLedErrorMsg(db, Conv_1114, msg, 0);
                        //wms任务异常需要生成退回托盘任务
                        var wcstask = new WCS_TASK();
                        wcstask.TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss");
                        wcstask.TASK_COMTYPE = (int)ComTypeEnum.托盘异常退回;
                        wcstask.TASK_SYSTYPE = "WCS";
                        wcstask.TASK_POSIDFROM = Conv_1114;//起点地址
                        wcstask.TASK_POSIDCUR = Conv_1114;
                        wcstask.TASK_POSIDNEXT = Conv_1114;
                        wcstask.TASK_POSIDMOVE = "";
                        wcstask.TASK_PRIORITY = 1;
                        wcstask.TASK_WKSTATUS = 1;
                        wcstask.TASK_WHID = "PVC原膜立库";
                        wcstask.TASK_ADDUSERNO = "WCS";
                        wcstask.TASK_ADDDATETIME = DateTime.Now;
                        wcstask.TASK_EDITUSERNO = "WCS";
                        wcstask.TASK_EDITDATETIME = DateTime.Now;
                        wcstask.TASK_NOTES = "";
                        wcstask.TASK_RGVNO = "";
                        wcstask.TASK_BOXBARCODE = barcode;
                        wcstask.TASK_POSIDTO = Conv_1115;
                        //wcstask.TASK_NOTES = errormsg;

                        int id = SugarBase.DB.Insertable(wcstask).ExecuteReturnIdentity();
                        if (id <= 0)
                        {
                            throw new Exception(string.Format("条码[{0}]添加WCS任务失败", barcode));
                        }
                        else
                        {
                            wcstask.TASK_NO = id;
                        }

                        CommonData.AddWCS_TASK_DTL(db, wcstask.TASK_NO, wcstask.TASK_NO, wcstask.TASK_POSIDCUR, wcstask.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(errormsg))
                    {
                        throw new Exception(errormsg);
                    }
                    result = true;
                }
            }
            else if (convNo == Conv_1109)//6#扫描位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1504 || v.TASK_POSIDNEXT == Conv_1110 || v.TASK_POSIDNEXT == Conv_1107) && (v.TASK_POSIDCUR != Conv_1107)))
                {
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE == barcode)) return false;
                    //生成退回异常任务
                    string msg = string.Format("输送线[{0}]条码[{1}]无法入库,单通道存在出库任务。", convNo, barcode);
                    LogMessageHelper.RecordLogMessage(msg);

                    string errormsg = TryCachHelper.TryTranExecute((db) =>
                    {
                        BaseWorkflow.AddLedErrorMsg(db, convNo, msg, 0);
                        //wms任务异常需要生成退回托盘任务
                        var wcstask = new WCS_TASK();
                        wcstask.TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss");
                        wcstask.TASK_COMTYPE = (int)ComTypeEnum.托盘异常退回;
                        wcstask.TASK_SYSTYPE = "WCS";
                        wcstask.TASK_POSIDFROM = convNo;//起点地址
                        wcstask.TASK_POSIDCUR = convNo;
                        wcstask.TASK_POSIDNEXT = convNo;
                        wcstask.TASK_POSIDMOVE = "";
                        wcstask.TASK_PRIORITY = 1;
                        wcstask.TASK_WKSTATUS = 1;
                        wcstask.TASK_WHID = "PVC原膜立库";
                        wcstask.TASK_ADDUSERNO = "WCS";
                        wcstask.TASK_ADDDATETIME = DateTime.Now;
                        wcstask.TASK_EDITUSERNO = "WCS";
                        wcstask.TASK_EDITDATETIME = DateTime.Now;
                        wcstask.TASK_NOTES = "";
                        wcstask.TASK_RGVNO = "";
                        wcstask.TASK_BOXBARCODE = barcode;
                        wcstask.TASK_POSIDTO = Conv_1110;
                        //wcstask.TASK_NOTES = errormsg;

                        int id = SugarBase.DB.Insertable(wcstask).ExecuteReturnIdentity();
                        if (id <= 0)
                        {
                            throw new Exception(string.Format("条码[{0}]添加WCS任务失败", barcode));
                        }
                        else
                        {
                            wcstask.TASK_NO = id;
                        }

                        CommonData.AddWCS_TASK_DTL(db, wcstask.TASK_NO, wcstask.TASK_NO, wcstask.TASK_POSIDCUR, wcstask.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(errormsg))
                    {
                        throw new Exception(errormsg);
                    }
                    result = true;
                }
            }
            else if (convNo == Conv_1115)//7#人工上料位置
            {
                var tasks_1115 = SugarBase.DB.Queryable<WCS_TASK>().Where(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1518 || v.TASK_POSIDNEXT == Conv_1115 || v.TASK_POSIDNEXT == Conv_1112) && v.TASK_POSIDCUR != Conv_1112).ToList();
                if (tasks_1115.Any(v => (v.TASK_POSIDCUR == Conv_1112 && v.TASK_BOXBARCODE.Contains("SH")) == false))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }
            else if (convNo == Conv_1110)//6#人工上料位置
            {
                var tasks_1110 = SugarBase.DB.Queryable<WCS_TASK>().Where(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1504 || v.TASK_POSIDNEXT == Conv_1110 || v.TASK_POSIDNEXT == Conv_1107) &&
                                                          (v.TASK_POSIDCUR != Conv_1109)).ToList();
                if (tasks_1110.Any(v => (v.TASK_POSIDCUR == Conv_1107 && v.TASK_BOXBARCODE.Contains("SH")) == false))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }
            else if (convNo == Conv_1102)//5#扫描位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1099 || v.TASK_POSIDNEXT == Conv_1105) && v.TASK_POSIDCUR != Conv_1105))
                {
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE == barcode)) return false;
                    //生成退回异常任务
                    string msg = string.Format("输送线[{0}]条码[{1}]无法入库,单通道存在出库任务。", convNo, barcode);
                    LogMessageHelper.RecordLogMessage(msg);

                    string errormsg = TryCachHelper.TryTranExecute((db) =>
                    {
                        BaseWorkflow.AddLedErrorMsg(db, convNo, msg, 0);
                        //wms任务异常需要生成退回托盘任务
                        var wcstask = new WCS_TASK();
                        wcstask.TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss");
                        wcstask.TASK_COMTYPE = (int)ComTypeEnum.托盘异常退回;
                        wcstask.TASK_SYSTYPE = "WCS";
                        wcstask.TASK_POSIDFROM = convNo;//起点地址
                        wcstask.TASK_POSIDCUR = convNo;
                        wcstask.TASK_POSIDNEXT = convNo;
                        wcstask.TASK_POSIDMOVE = "";
                        wcstask.TASK_PRIORITY = 1;
                        wcstask.TASK_WKSTATUS = 1;
                        wcstask.TASK_WHID = "PVC原膜立库";
                        wcstask.TASK_ADDUSERNO = "WCS";
                        wcstask.TASK_ADDDATETIME = DateTime.Now;
                        wcstask.TASK_EDITUSERNO = "WCS";
                        wcstask.TASK_EDITDATETIME = DateTime.Now;
                        wcstask.TASK_NOTES = "";
                        wcstask.TASK_RGVNO = "";
                        wcstask.TASK_BOXBARCODE = barcode;
                        wcstask.TASK_POSIDTO = Conv_1104;
                        //wcstask.TASK_NOTES = errormsg;

                        int id = SugarBase.DB.Insertable(wcstask).ExecuteReturnIdentity();
                        if (id <= 0)
                        {
                            throw new Exception(string.Format("条码[{0}]添加WCS任务失败", barcode));
                        }
                        else
                        {
                            wcstask.TASK_NO = id;
                        }

                        CommonData.AddWCS_TASK_DTL(db, wcstask.TASK_NO, wcstask.TASK_NO, wcstask.TASK_POSIDCUR, wcstask.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(errormsg))
                    {
                        throw new Exception(errormsg);
                    }
                    result = true;
                }
            }
            else if (convNo == Conv_1094)//4#扫描位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1092 || v.TASK_POSIDNEXT == Conv_1098) && v.TASK_POSIDCUR != Conv_1098))
                {
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE == barcode)) return false;
                    //生成退回异常任务
                    string msg = string.Format("输送线[{0}]条码[{1}]无法入库,单通道存在出库任务。", convNo, barcode);
                    LogMessageHelper.RecordLogMessage(msg);

                    string errormsg = TryCachHelper.TryTranExecute((db) =>
                    {
                        BaseWorkflow.AddLedErrorMsg(db, convNo, msg, 0);
                        //wms任务异常需要生成退回托盘任务
                        var wcstask = new WCS_TASK();
                        wcstask.TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss");
                        wcstask.TASK_COMTYPE = (int)ComTypeEnum.托盘异常退回;
                        wcstask.TASK_SYSTYPE = "WCS";
                        wcstask.TASK_POSIDFROM = convNo;//起点地址
                        wcstask.TASK_POSIDCUR = convNo;
                        wcstask.TASK_POSIDNEXT = convNo;
                        wcstask.TASK_POSIDMOVE = "";
                        wcstask.TASK_PRIORITY = 1;
                        wcstask.TASK_WKSTATUS = 1;
                        wcstask.TASK_WHID = "PVC原膜立库";
                        wcstask.TASK_ADDUSERNO = "WCS";
                        wcstask.TASK_ADDDATETIME = DateTime.Now;
                        wcstask.TASK_EDITUSERNO = "WCS";
                        wcstask.TASK_EDITDATETIME = DateTime.Now;
                        wcstask.TASK_NOTES = "";
                        wcstask.TASK_RGVNO = "";
                        wcstask.TASK_BOXBARCODE = barcode;
                        wcstask.TASK_POSIDTO = Conv_1097;
                        //wcstask.TASK_NOTES = errormsg;

                        int id = SugarBase.DB.Insertable(wcstask).ExecuteReturnIdentity();
                        if (id <= 0)
                        {
                            throw new Exception(string.Format("条码[{0}]添加WCS任务失败", barcode));
                        }
                        else
                        {
                            wcstask.TASK_NO = id;
                        }

                        CommonData.AddWCS_TASK_DTL(db, wcstask.TASK_NO, wcstask.TASK_NO, wcstask.TASK_POSIDCUR, wcstask.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(errormsg))
                    {
                        throw new Exception(errormsg);
                    }
                    result = true;
                }
            }
            else if (convNo == Conv_1097)//5#AGV对接位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1092 || v.TASK_POSIDNEXT == Conv_1098 || v.TASK_POSIDNEXT == Conv_1097) && v.TASK_POSIDCUR != Conv_1098 && v.TASK_POSIDCUR != Conv_1097))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }
            else if (convNo == Conv_1104)//5#AGV对接位置
            {
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && (v.TASK_POSIDNEXT == Conv_1099 || v.TASK_POSIDNEXT == Conv_1105 || v.TASK_POSIDNEXT == Conv_1104) && v.TASK_POSIDCUR != Conv_1105 && v.TASK_POSIDCUR != Conv_1104))
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]请求,存在出库任务,交通管制无法入库，请等待。", convNo));
                    result = true;
                }
            }

            return result;
        }

        /// <summary>
        /// Agv对接输送线请求(6#,7#)
        /// </summary>
        private void RequestByAgvConv(string convNo, string endConPosNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (cs.DB523_Fault) return;
                if (!cs.DB521_Request) return;
                if (cs.DB521_Tasknum == 0) return;

                #region 检测AGV任务是否已经完成

                if (cs.DB521_Tasknum > 10000)
                {
                    var task = Current.TaskSet.FirstOrDefault(v => v.TASK_NO == cs.DB521_Tasknum);
                    if (task != null && (!string.IsNullOrWhiteSpace(task.TASK_ITEM8)))
                    {
                        var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().Single(v => v.Task_Id == Convert.ToInt32(task.TASK_ITEM8));
                        if (agvtask != null &&
                           (agvtask.Task_WcsStatus != 4 && agvtask.Task_WcsStatus != 99 && agvtask.Task_WcsStatus != 106))
                        {
                            throw new Exception(string.Format("输送线[{0}]收到清除AGV对接信号请求，任务[{1}]与AGV对接未完成，不能清除信号。", convNo, cs.DB521_Tasknum));
                        }
                    }
                }

                #endregion 检测AGV任务是否已经完成

                bool isMatureTray = false;//是否是熟化架
                string barcode = string.Empty;

                QueryInBarcode(cs.DB521_Tasknum, ref isMatureTray, ref barcode);

                var convwrite = new WCSWriteToConveyorSignal();
                convwrite.Plc = WCS_PLCItem.Plc;
                convwrite.DBName = WCS_PLCItem.WriteDBName;
                convwrite.ConveyorNo = convNo;
                convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                if (isMatureTray)
                {
                    //convwrite.TaskDelete = true;
                    WriteInfoToConv(cs, convwrite, true);
                }
                else
                {
                    var taskitem = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_BOXBARCODE == barcode && v.TASK_COMTYPE == 1);
                    if (taskitem == null)
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = barcode;
                        param.ContainerType = 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_BreakTrayNo == barcode && v.Task_Type == 2);//退料任务
                        if (agvtask != null)
                        {
                            param.EquipmentNo = agvtask.Task_PosidFrom;
                            param.Memo3 = agvtask.Task_BreakBarCode_1;
                            param.Memo4 = agvtask.Task_BreakBarCode_2;
                        }
                        else
                        {
                            param.EquipmentNo = convNo;
                        }
                        param.EndPostion = srm;
                        taskitem = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }

                    if (taskitem != null && taskitem.TASK_COMTYPE == 1)
                    {
                        if (taskitem.TASK_POSIDNEXT == endConPosNo) return;
                        //检测存在出库任务
                        //if (CheckIsExistOutTask(convNo)) return;

                        convwrite.Tasknum = taskitem.TASK_NO;
                        convwrite.Goodsstart = Convert.ToInt32(convNo);
                        convwrite.Goodsend = Convert.ToInt32(endConPosNo);
                        //WriteInfoToConv(cs, convwrite);
                        WriteInfoToCv(cs, convwrite);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private static void QueryInBarcode(int tasknum, ref bool isMatureTray, ref string barcode)
        {
            var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == tasknum);
            if (task == null)
            {
                var task_dis = SugarBase.DB.Queryable<WCS_TASK_DIS>().First(v => v.TASK_NO == tasknum);
                if (task_dis != null)
                {
                    isMatureTray = task_dis.TASK_BOXBARCODE.Substring(0, 2) == "SH" ? true : false;
                    barcode = task_dis.TASK_BOXBARCODE;
                }
            }
            else
            {
                if (task.TASK_COMTYPE == 2)
                {
                    //完成任务
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                    .Where(it => it.TASK_NO == task.TASK_NO)
                                    .ExecuteCommand();
                        //添加修改明细
                        string msg = string.Format("任务[{0}]完成", task.TASK_NO);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(result);
                    }
                }

                isMatureTray = task.TASK_BOXBARCODE.Substring(0, 2) == "SH" ? true : false;
                barcode = task.TASK_BOXBARCODE;
            }
        }

        /// <summary>
        /// Agv申请取货
        /// </summary>
        public void AgvRequestOnMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 4).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 3) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidFrom);
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (cs.CvDB51_PH_Status == false) continue;
                        if (cs.DB521_Tasknum == 0) continue;
                        if (cs.DB520_Res02) continue;//已写入申请取货

                        var convwrite = new WCSWriteToConveyorSignal();
                        convwrite.Plc = WCS_PLCItem.Plc;
                        convwrite.DBName = WCS_PLCItem.WriteDBName;
                        convwrite.ConveyorNo = item.Task_PosidFrom.Trim();
                        convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        convwrite.Res02 = true;

                        if (convwrite.Plc.WriteBits((ushort)convwrite.DBName, (uint)((convwrite.WriteStartAddress + 17) * 8 + 7), true))
                        {
                            Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]写入申请取货信号到输送线[{1}]成功！", convwrite.Tasknum, convwrite.ConveyorNo));
                        }
                        else
                        {
                            throw new Exception(string.Format("agv任务[{0}]写入申请取货信号到输送线[{1}]失败！", item.Task_Id, convwrite.ConveyorNo));
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 输送线PLC允许取货
        /// </summary>
        public void ConvEnableOnMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 4).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 3) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidFrom);
                        if (conveyor == null) continue;
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (cs.CvDB51_PH_Status == false) continue;
                        if (cs.DB521_Tasknum == 0) continue;

                        if (cs.DB521_L_Outside)
                        {
                            int task_no = string.IsNullOrWhiteSpace(item.Task_Remark) ? 0 : Convert.ToInt32(item.Task_Remark);
                            if (task_no == cs.DB521_Tasknum || task_no == 0)
                            {
                                //允许取货
                                SugarBase.DB.Updateable<Middle_AGVTask>(it => new Middle_AGVTask() { Task_WcsStatus = 3, Task_UpdateUser = "wcs", Task_UpdateDate = DateTime.Now })
                                         .Where(it => it.Task_Id == item.Task_Id)
                                         .ExecuteCommand();
                            }
                            else
                            {
                                string msg = string.Format("输送线WCS任务号[{0}]是上一个任务，AGV任务WCS任务号[{1}]是下一个任务，请等待上一个回库。", cs.DB521_Tasknum, task_no);
                                throw new Exception(msg);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// Agv完成取货
        /// </summary>
        public void AgvFinishOnMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 5 && (v.Task_WcsStatus == 4 || v.Task_WcsStatus == 3) && (v.Task_Type == 1 || v.Task_Type == 3)).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 4) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidFrom.Trim());
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (cs.DB520_Res03 == 1) continue;//已写入取货完成

                        var convwrite = new WCSWriteToConveyorSignal();
                        convwrite.Plc = WCS_PLCItem.Plc;
                        convwrite.DBName = WCS_PLCItem.WriteDBName;
                        convwrite.ConveyorNo = item.Task_PosidFrom.Trim();
                        convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        convwrite.Res03 = 1;

                        if (convwrite.Plc.WriteSignal((ushort)convwrite.DBName, (ushort)((convwrite.WriteStartAddress + 18)), 2, true))
                        {
                            Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]写入取货完成信号到输送线[{1}]成功！", convwrite.Tasknum, convwrite.ConveyorNo));
                        }
                        else
                        {
                            throw new Exception(string.Format("agv任务[{0}]写入取货完成信号到输送线[{1}]失败！", item.Task_Id, convwrite.ConveyorNo));
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// //输送线PLC允许Agv离开(取货完成)
        /// </summary>
        public void ConvEnableAgvLeave()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 5 && (v.Task_Type == 1 || v.Task_Type == 3)).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 4) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidFrom.Trim());
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;

                        if (cs.DB521_R_Outside)
                        {
                            //允许AGV离开
                            SugarBase.DB.Updateable<Middle_AGVTask>(it => new Middle_AGVTask() { Task_WcsStatus = 4, Task_UpdateUser = "wcs", Task_UpdateDate = DateTime.Now })
                                     .Where(it => it.Task_Id == item.Task_Id)
                                     .ExecuteCommand();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// Agv申请放货
        /// </summary>
        public void AgvRequestUpMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 2).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 2) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidTo);
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (cs.DB520_RollerTurn) continue;//已写入申请放货

                        var convwrite = new WCSWriteToConveyorSignal();
                        convwrite.Plc = WCS_PLCItem.Plc;
                        convwrite.DBName = WCS_PLCItem.WriteDBName;
                        convwrite.ConveyorNo = item.Task_PosidFrom.Trim();
                        convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        convwrite.UpMatRequest = true;

                        if (convwrite.Plc.WriteBits((ushort)convwrite.DBName, (uint)((convwrite.WriteStartAddress + 17) * 8 + 5), true))
                        {
                            Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]写入申请放货信号到输送线[{1}]成功！", convwrite.Tasknum, convwrite.ConveyorNo));
                        }
                        else
                        {
                            throw new Exception(string.Format("agv任务[{0}]写入申请放货信号到输送线[{1}]失败！", item.Task_Id, convwrite.ConveyorNo));
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 输送线PLC允许放货
        /// </summary>
        public void ConvEnableUpMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 2).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 2) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidTo.Trim());
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;

                        bool isEnableUpMat = false;
                        if (item.Task_WorkshopNo == "18")
                        {
                            if (cs.DB521_Res03)
                            {
                                isEnableUpMat = true;
                            }
                        }
                        else
                        {
                            if (cs.DB521_Goodstype == 0 && cs.CvDB51_PH_Status == false && cs.DB521_Tasknum <= 0 && cs.DB521_F_Outside)//判断旋转台没有托盘和熟化架
                            {
                                isEnableUpMat = true;
                            }
                            else if (cs.DB521_Goodstype == 2 && cs.CvDB51_PH_Status && cs.DB521_F_Outside)//判断旋转台有原膜托盘
                            {
                                isEnableUpMat = true;
                            }
                        }

                        if (isEnableUpMat)
                        {
                            //允许放货
                            SugarBase.DB.Updateable<Middle_AGVTask>(it => new Middle_AGVTask() { Task_WcsStatus = 2, Task_UpdateUser = "wcs", Task_UpdateDate = DateTime.Now })
                                     .Where(it => it.Task_Id == item.Task_Id)
                                     .ExecuteCommand();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// Agv完成放货
        /// </summary>
        public void AgvFinishUpMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 3).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 4) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidTo.Trim());
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;
                        if (cs.DB520_Res01) continue;//已写入放货完成

                        var convwrite = new WCSWriteToConveyorSignal();
                        convwrite.Plc = WCS_PLCItem.Plc;
                        convwrite.DBName = WCS_PLCItem.WriteDBName;
                        convwrite.ConveyorNo = item.Task_PosidFrom.Trim();
                        convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        convwrite.Res01 = true;

                        if (convwrite.Plc.WriteBits((ushort)convwrite.DBName, (uint)((convwrite.WriteStartAddress + 17) * 8 + 6), true))
                        {
                            Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]写入放货完成信号到输送线[{1}]成功！", convwrite.Tasknum, convwrite.ConveyorNo));
                        }
                        else
                        {
                            throw new Exception(string.Format("agv任务[{0}]写入放货完成信号到输送线[{1}]失败！", item.Task_Id, convwrite.ConveyorNo));
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// //输送线PLC允许Agv离开(放货完成)
        /// </summary>
        public void ConvEnableAgvLeave_OnMat()
        {
            try
            {
                var agvtasks = SugarBase.DB.Queryable<Middle_AGVTask>().Where(v => v.Task_AgvStatus == 3).ToList();
                agvtasks = agvtasks.Where(v => Current.SysSets.Any(t => t.SET_ID == v.Task_Workshop && t.SET_VALUE == "0")).ToList();
                foreach (var item in agvtasks)
                {
                    try
                    {
                        if (item.Task_WcsStatus == 4) continue;
                        if (item.Task_WcsStatus == 106) continue;

                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item.Task_PosidTo.Trim());
                        var cs = conveyor.EquSignal_Conv;

                        if (cs.DB523_Fault) continue;

                        bool isEnableUpMat = false;
                        if (item.Task_WorkshopNo == "18")
                        {
                            if (cs.DB521_Res04 != 0)
                            {
                                isEnableUpMat = true;
                            }
                        }
                        else
                        {
                            if (cs.DB521_B_Outside)
                            {
                                isEnableUpMat = true;
                            }
                        }

                        if (isEnableUpMat)
                        {
                            //允许AGV离开
                            SugarBase.DB.Updateable<Middle_AGVTask>(it => new Middle_AGVTask() { Task_WcsStatus = 4, Task_UpdateUser = "wcs", Task_UpdateDate = DateTime.Now })
                                     .Where(it => it.Task_Id == item.Task_Id)
                                     .ExecuteCommand();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogMessageHelper.RecordLogMessage(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        public override int ConveyorWriteTaskExecuteToMoreAddress(string convNo, WCS_TASK task, List<WCS_EQUIPMENTROUTE> routes)
        {
            int result = 0;
            if (convNo == Conv_1105)
            {
                result = Convert.ToInt32(Conv_1099);
            }
            else if (convNo == Conv_1179)
            {
                if (convNo == Conv_1252 || convNo == Conv_1226 || convNo == Conv_1231 ||
                    convNo == Conv_1234 || convNo == Conv_1251 || convNo == Conv_1257 ||
                    convNo == Conv_1258 || convNo == Conv_1261 || convNo == Conv_1278 ||
                    convNo == Conv_1283 || convNo == Conv_1288 || convNo == Conv_1293)
                {
                    //去机械码垛位置，指定到1182
                    result = Convert.ToInt32(Conv_1182);
                }
                else
                {
                    result = Convert.ToInt32(Conv_1193);
                }
            }
            else
            {
                result = base.ConveyorWriteTaskExecuteToMoreAddress(convNo, task, routes);
            }
            return result;
        }

        public override void SetConvwrite(WCSWriteToConveyorSignal convwrite, WCS_TASK task)
        {
            if (convwrite.ConveyorNo == Conv_1099 || convwrite.ConveyorNo == Conv_1504 ||
                convwrite.ConveyorNo == Conv_1518 || convwrite.ConveyorNo == Conv_1092 || convwrite.ConveyorNo == Conv_1105 || convwrite.ConveyorNo == Conv_1098)
            {
                convwrite.Goodstype = task.TASK_BOXBARCODE.Substring(0, 2) == "SH" ? 1 : 2;
                if (convwrite.ConveyorNo == Conv_1518)//7#
                {
                    if (task.TASK_COMTYPE != 2)
                    {
                        throw new Exception(string.Format("输送线[{0}]有请求信号，但任务[{1}]不是出库任务。", convwrite.ConveyorNo, task.TASK_NO));
                    }
                    //检测是否存在原膜托盘任务
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE.Substring(0, 3) == "TPC" && (v.TASK_POSIDNEXT == Conv_1112 || v.TASK_POSIDNEXT == Conv_1115)))
                    {
                        convwrite.Goodsend = Convert.ToInt32(Conv_1115);//避障位
                    }
                    else
                    {
                        //检测1112输送线是否存在任务或光电信息
                        if (Current.TaskSet.Any(v => v.TASK_POSIDFROM == Conv_1112 && v.TASK_POSIDCUR == Conv_1112))
                        {
                            convwrite.Goodsend = Convert.ToInt32(Conv_1115);//避障位
                        }
                        else
                        {
                            var cv = ConveyorHelper.GetConveyorSignal(PlcName, Conv_1112);
                            if (cv.CvDB51_PH_Status && cv.DB521_Request || cv.DB521_Goodsend.ToString() == Conv_1518)
                            {
                                convwrite.Goodsend = Convert.ToInt32(Conv_1115);//避障位
                            }
                            else
                            {
                                convwrite.Goodsend = Convert.ToInt32(Conv_1112);
                            }

                            //if (cv.DB521_Tasknum > 0 || cv.CvDB51_PH_Status || cv.DB521_Request || cv.DB521_Goodstype == 2)
                            //{
                            //    convwrite.Goodsend = Convert.ToInt32(Conv_1115);
                            //}
                            //else
                            //{
                            //    convwrite.Goodsend = Convert.ToInt32(Conv_1112);
                            //}
                        }
                    }
                }
                else if (convwrite.ConveyorNo == Conv_1504)//6#
                {
                    if (task.TASK_COMTYPE != 2)
                    {
                        throw new Exception(string.Format("输送线[{0}]有请求信号，但任务[{1}]不是出库任务。", convwrite.ConveyorNo, task.TASK_NO));
                    }
                    //检测是否存在原膜托盘任务
                    if (Current.TaskSet.Any(v => v.TASK_BOXBARCODE.StartsWith("TPC") && v.TASK_BOXBARCODE.Substring(0, 3) == "TPC" && (v.TASK_POSIDNEXT == Conv_1107 || v.TASK_POSIDNEXT == Conv_1110)))
                    {
                        convwrite.Goodsend = Convert.ToInt32(Conv_1110);//避障位
                    }
                    else
                    {
                        //检测1112输送线是否存在任务或光电信息
                        if (Current.TaskSet.Any(v => v.TASK_POSIDFROM == Conv_1107 && v.TASK_POSIDCUR == Conv_1107))
                        {
                            convwrite.Goodsend = Convert.ToInt32(Conv_1110);//避障位
                        }
                        else
                        {
                            var cv = ConveyorHelper.GetConveyorSignal(PlcName, Conv_1107);
                            if (cv.CvDB51_PH_Status && cv.DB521_Request || cv.DB521_Goodsend.ToString() == Conv_1518)
                            {
                                convwrite.Goodsend = Convert.ToInt32(Conv_1110);//避障位
                            }
                            else
                            {
                                convwrite.Goodsend = Convert.ToInt32(Conv_1107);
                            }

                            //if (cv.DB521_Tasknum > 0 || cv.CvDB51_PH_Status || cv.DB521_Request || cv.DB521_Goodstype == 2)
                            //{
                            //    convwrite.Goodsend = Convert.ToInt32(Conv_1115);
                            //}
                            //else
                            //{
                            //    convwrite.Goodsend = Convert.ToInt32(Conv_1112);
                            //}
                        }
                    }
                }
                else if (convwrite.ConveyorNo == Conv_1105)//5#避障位
                {
                    var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_PosidTo == Conv_1104 && v.Task_WcsStatus > 0 && v.Task_Type != 2);
                    if (agvtask != null)
                        throw new Exception(string.Format("5#避障位不能出库，存在AGV入库任务[{0}]", agvtask.Task_Id));
                }
                else if (convwrite.ConveyorNo == Conv_1098)//4#避障位
                {
                    var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_PosidTo == Conv_1097 && v.Task_WcsStatus > 0 && v.Task_Type != 2);
                    if (agvtask != null)
                        throw new Exception(string.Format("4#避障位不能出库，存在AGV入库任务[{0}]", agvtask.Task_Id));
                }
                else if (convwrite.ConveyorNo == Conv_1099)//5#穿梭车下料点
                {
                    if (task.TASK_COMTYPE != 2)
                    {
                        throw new Exception(string.Format("输送线[{0}]有请求信号，但任务[{1}]不是出库任务。", convwrite.ConveyorNo, task.TASK_NO));
                    }
                }
                else if (convwrite.ConveyorNo == Conv_1092)//4#穿梭车下料点
                {
                    if (task.TASK_COMTYPE != 2)
                    {
                        throw new Exception(string.Format("输送线[{0}]有请求信号，但任务[{1}]不是出库任务。", convwrite.ConveyorNo, task.TASK_NO));
                    }
                }
            }
        }

        //public void ConveyorWriteTaskExecute(string convNo, string nextNo, bool endPosIsCurConv = false)
        //{
        //    try
        //    {
        //        var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo).EquSignal_Conv;
        //        if (equ_conv.DB523_Fault) return;
        //        if (!equ_conv.CvDB51_PH_Status) return;
        //        if (!equ_conv.DB521_Request) return;
        //        if (equ_conv.DB521_Tasknum <= 0) return;

        //        var task = Current.TaskSet.FirstOrDefault(v => v.TASK_NO == equ_conv.DB521_Tasknum);
        //        if (task.TASK_POSIDNEXT != convNo) return;
        //        if (task.TASK_WKSTATUS == 7 || task.TASK_WKSTATUS == 3 || task.TASK_WKSTATUS == 4) return;

        //        if (equ_conv.DB521_H_Outside)
        //        {
        //            if (task.TASK_POSIDTO == srm) return;
        //        }

        //        var convwrite = new WCSWriteToConveyorSignal();
        //        convwrite.Plc = WCS_PLCItem.Plc;
        //        convwrite.DBName = WCS_PLCItem.WriteDBName;
        //        convwrite.ConveyorNo = convNo;
        //        convwrite.WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox;
        //        convwrite.Tasknum = task.TASK_NO;
        //        convwrite.Goodscode = 0;//待定
        //        convwrite.Goodstype = 0;
        //        convwrite.Goodssize = 0;//待定
        //        convwrite.Goodsstart = Convert.ToInt32(convNo);
        //        if (endPosIsCurConv)
        //        {
        //            convwrite.Goodsend = convwrite.Goodsstart;
        //        }
        //        else
        //        {
        //            convwrite.Goodsend = Convert.ToInt32(nextNo);
        //        }
        //        WriteInfoToConveyor(equ_conv, convwrite);
        //    }
        //    catch (Exception ex)
        //    {
        //        LogMessageHelper.RecordLogMessage(ex);
        //    }
        //}
        private void ConvWriteTaskExe_1071()
        {
            try
            {
                var convitem = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1071).EquSignal_Conv;

                if (convitem.DB521_Tasknum <= 0) return;
                if (!convitem.DB521_Request) return;
                //if (!convitem.CvDB51_PH_Status) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == convitem.DB521_Tasknum);
                if (string.IsNullOrWhiteSpace(task.TASK_ITEM1)) return;
                if (string.IsNullOrWhiteSpace(task.TASK_ITEM5)) return;//检查是否绑定了第一个原膜卷
                string endAddress = string.Empty;
                if (Current.TaskSet.Any(v => v.TASK_ITEM1 == task.TASK_ITEM1 && v.TASK_NO != task.TASK_NO && v.TASK_POSIDNEXT != Conv_1070 && (v.TASK_SRMNO == "srm01" || v.TASK_SRMNO == "srm06")))
                {
                    //到1072
                    endAddress = Conv_1072;
                }
                else
                {
                    endAddress = Conv_1085;
                }
                if (task.TASK_POSIDNEXT == endAddress) return;

                var convwrite = new WCSWriteToConveyorSignal();
                convwrite.Plc = WCS_PLCItem.Plc;
                convwrite.DBName = WCS_PLCItem.WriteDBName;
                convwrite.ConveyorNo = Conv_1071;
                convwrite.WriteStartAddress = convitem.EquDbInfo_ReadWrite.DBReadIndox;
                convwrite.Tasknum = task.TASK_NO;
                convwrite.Goodscode = 0;//待定
                convwrite.Goodstype = 0;
                convwrite.Goodssize = 0;//待定
                convwrite.Goodsstart = Convert.ToInt32(Conv_1071);
                convwrite.Goodsend = Convert.ToInt32(endAddress);

                WriteInfoToConv(convitem, convwrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void ConvWriteTaskExe_1072()
        {
            ConveyorWriteTaskExecute(Conv_1072);
        }

        private static int _palletizingConvRequest = 0;

        /// <summary>
        /// 机器人码垛输送线托盘需求
        /// </summary>
        private void Conv_Scanning_1185_WMS()
        {
            if (Interlocked.Exchange(ref _palletizingConvRequest, 1) == 0) 
            {
                try
                {
                    Thread.Sleep(3000);
                    var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                    var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1185);
                    var cs = conveyor.EquSignal_Conv;

                    if (!cs.DB521_Request) return;
                    if (cs.DB520_Confirm) return;
                    if (cs.BarCodeStr.ToUpper().Contains("ERROR") ||
                        cs.BarCodeStr.ToUpper().Contains("N") ||
                        cs.BarCodeStr.Contains("?"))
                    {
                        throw new Exception(string.Format("输送线[{0}]存在请求信号，但条码是：[{1}]存在报错，PLC应该报条码错误信号", Conv_1185, cs.BarCodeStr));
                    }
                    //条码未读出
                    if (cs.DB521_Res01) return;

                    List<string> list = new List<string>() { Conv_1251, Conv_1261, Conv_1226, Conv_1234, Conv_1257, Conv_1252, Conv_1231, Conv_1258, Conv_1278, Conv_1283, Conv_1288, Conv_1293 };

                    foreach (var item in list)
                    {
                        if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_BOXBARCODE == cs.BarCodeStr)) break;

                        var conv = ConveyorHelper.GetConveyorSignal(PlcName, item);
                        if (conv.CvDB51_PH_Status) continue;
                        if (conv.DB521_Tasknum > 0 && item != Conv_1288 && item != Conv_1293) continue;
                        if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == item && (v.TASK_COMTYPE == 2 || v.TASK_POSIDFROM == Conv_1185))) continue;

                        if (item == Conv_1288 || item == Conv_1293)
                        {
                            if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == item)) continue;
                            //if (!conv.DB521_Request) return;

                            var sysset = SugarBase.DB.Queryable<WCS_SYSSET>().First(v => v.SET_ID == item);
                            if (!string.IsNullOrWhiteSpace(sysset.SET_MEMO))
                            {
                                LogMessageHelper.RecordLogMessage(string.Format("字母托盘码盘位置[{0}]电控无光电无任务号,但是配置项中存在托盘信息[{1}]", item, sysset.SET_MEMO));
                                continue;
                            }
                            //创建搬运任务
                            var task = new WCS_TASK()
                            {
                                TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss"),
                                TASK_COMTYPE = (int)ComTypeEnum.搬运,
                                TASK_SYSTYPE = "WCS",
                                TASK_POSIDFROM = Conv_1185,//起点地址
                                TASK_POSIDCUR = Conv_1185,
                                TASK_POSIDNEXT = Conv_1185,
                                TASK_POSIDMOVE = "",
                                TASK_PRIORITY = 1,
                                TASK_WKSTATUS = 1,
                                TASK_WHID = "PVC普通立库",
                                TASK_ADDUSERNO = "WCS",
                                TASK_ADDDATETIME = DateTime.Now,
                                TASK_EDITUSERNO = "WCS",
                                TASK_EDITDATETIME = DateTime.Now,
                                TASK_NOTES = "",
                                TASK_RGVNO = "",
                                TASK_BOXBARCODE = cs.BarCodeStr,
                                TASK_POSIDTO = item
                            };
                            int id = SugarBase.DB.Insertable(task).ExecuteReturnIdentity();
                            if (id <= 0)
                            {
                                throw new Exception(string.Format("添加WCS搬运任务失败"));
                            }
                            else
                            {
                                break;
                            }
                        }
                        else
                        {
                            var param = new GetOutTaskParam()
                            {
                                OutId = Guid.NewGuid().ToString(),
                                OutEndPostion = item,
                                OutType = 2,
                                WareHouseId = Current.Pvchouseputong,
                                Memo2 = cs.BarCodeStr
                            };

                            SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_PosidTo == Conv_1104 && v.Task_WcsStatus > 0 && v.Task_Type != 2);
                            //查看是否存在搬运任务起始地址1288或1293，目的地机械手码垛工位
                            var task_move = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_COMTYPE == 4 && (v.TASK_POSIDCUR == Conv_1288 || v.TASK_POSIDCUR == Conv_1293) && v.TASK_POSIDTO == item);
                            if (task_move == null)
                            {
                                //调用WMS接口生成出库任务
                                if (BaseWorkflow.WCS_GetOutTask(param)) break;
                            }
                            //调用WMS接口生成出库任务
                            //if (BaseWorkflow.WCS_GetOutTask(param)) break;
                        }
                        Thread.Sleep(2000);
                    }

                    if (!SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_BOXBARCODE == cs.BarCodeStr))
                    {
                        var taskitem = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_POSIDFROM == Conv_1185 && v.TASK_WKSTATUS <= 1 && v.TASK_COMTYPE == 4 && (v.TASK_POSIDTO == Conv_1285 || v.TASK_POSIDTO == Conv_1286));
                        if (taskitem != null)
                        {
                            SugarBase.DB.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_BOXBARCODE = cs.BarCodeStr, TASK_EDITUSERNO = "wcs", TASK_EDITDATETIME = DateTime.Now })
                                     .Where(it => it.TASK_NO == taskitem.TASK_NO)
                                     .ExecuteCommand();
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _palletizingConvRequest, 0);
                }
            }
        }

        private void Conv_Scanning_1185_WCS()
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1185);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB520_Confirm) return;

                WCS_TASK task = null;
                if (cs.DB521_Res01)//未扫码到条码
                {
                    task = SugarBase.DB.Queryable<WCS_TASK>().Single(v => v.TASK_POSIDFROM == Conv_1185 && v.TASK_POSIDCUR == Conv_1185);
                    if (task == null)
                    {
                        string errormsg = TryCachHelper.TryTranExecute((db) =>
                        {
                            //创建异常任务
                            task = new WCS_TASK();
                            task.TASK_WMSNO = "wcs_" + DateTime.Now.ToString("yyyyMMddhhmmss");
                            task.TASK_COMTYPE = (int)ComTypeEnum.托盘异常退回;
                            task.TASK_SYSTYPE = "WCS";
                            task.TASK_POSIDFROM = Conv_1185;//起点地址
                            task.TASK_POSIDCUR = Conv_1185;
                            task.TASK_POSIDNEXT = Conv_1185;
                            task.TASK_POSIDMOVE = "";
                            task.TASK_PRIORITY = 1;
                            task.TASK_WKSTATUS = 1;
                            task.TASK_WHID = "PVC普通立库";
                            task.TASK_ADDUSERNO = "WCS";
                            task.TASK_ADDDATETIME = DateTime.Now;
                            task.TASK_EDITUSERNO = "WCS";
                            task.TASK_EDITDATETIME = DateTime.Now;
                            task.TASK_NOTES = "";
                            task.TASK_RGVNO = "";
                            task.TASK_BOXBARCODE = "扫码异常";
                            task.TASK_POSIDTO = Conv_1199;

                            int id = SugarBase.DB.Insertable(task).ExecuteReturnIdentity();
                            if (id <= 0)
                            {
                                throw new Exception(string.Format("条码[扫码异常]添加WCS任务失败"));
                            }
                            else
                            {
                                task.TASK_NO = id;
                            }
                            string msg = string.Format("拆盘机位置[{0}]扫码未识别", Conv_1185);
                            CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                        });

                        if (!string.IsNullOrWhiteSpace(errormsg))
                        {
                            throw new Exception(errormsg);
                        }
                    }
                }
                else
                {
                    task = SugarBase.DB.Queryable<WCS_TASK>().Single(v => v.TASK_BOXBARCODE == cs.BarCodeStr);
                }

                if (task == null || task.TASK_WKSTATUS > 1) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = Conv_1185;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(Conv_1185);
                //var routeSet = EquRouteHelper.QueryRoute(Conv_1185, task.TASK_POSIDTO);
                //var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == Conv_1185);
                //if (task.TASK_COMTYPE == 6)
                //{
                //    converywrite.Goodsend = Convert.ToInt32(Conv_1193);
                //}
                //else
                //{
                converywrite.Goodsend = Convert.ToInt32(Conv_1182);
                //}

                WriteInfoToConv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void Conv_Scanning_1102()
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1102);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB520_Confirm) return;

                var task = QueryTaskByBarcode(cs, Conv_1102);

                if (task == null)
                {
                    if (WcsScanConvIsUsed(Conv_1102))
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = cs.BarCodeStr;
                        param.ContainerType = 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().First(v => v.Task_BreakTrayNo == cs.BarCodeStr && v.Task_Type == 2);//退料任务
                        if (agvtask != null)
                        {
                            param.EquipmentNo = agvtask.Task_PosidFrom;
                            param.Memo3 = agvtask.Task_BreakBarCode_1;
                            param.Memo4 = agvtask.Task_BreakBarCode_2;
                        }
                        else
                        {
                            param.EquipmentNo = Conv_1102;
                        }
                        param.EndPostion = srm;
                        param.Memo2 = Conv_1104;
                        task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }
                }
                else if (task.TASK_COMTYPE == 2 && task.TASK_POSIDNEXT == Conv_1104 && task.TASK_WKSTATUS < 99)
                {
                    //完成任务
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                    .Where(it => it.TASK_NO == task.TASK_NO)
                                    .ExecuteCommand();
                        //添加修改明细
                        string msg = string.Format("任务[{0}]完成", task.TASK_NO);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(result);
                    }
                }
                if (task == null || (task.TASK_COMTYPE != 1 && task.TASK_COMTYPE != 6)) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = Conv_1102;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                //判断任务是否已经执行
                if (task.TASK_WKSTATUS == 2 || task.TASK_WKSTATUS == 99 || task.TASK_WKSTATUS == 109 || task.TASK_WKSTATUS == 106) return;
                converywrite.Tasknum = task.TASK_NO;
                //converywrite.Goodstype = task.TASK_BOXBARCODE.Substring(0,2)== "SH" ? 1 : 2;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(Conv_1102);

                if (task.TASK_COMTYPE == (int)ComTypeEnum.托盘异常退回)
                {
                    converywrite.Notask = true;
                    converywrite.Goodsend = Convert.ToInt32(Conv_1104);
                }
                else
                {
                    //bool isany = SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && v.TASK_POSIDTO == Conv_1104 && (v.TASK_POSIDNEXT == Conv_1099 || v.TASK_POSIDNEXT == Conv_1104 || v.TASK_POSIDNEXT == Conv_1105));
                    //if (isany)
                    //{
                    //    //二楼有托盘出库，入库托盘送到中转位置1105
                    //    converywrite.Goodsend = Convert.ToInt32(Conv_1105);
                    //}
                    //else
                    //{
                    //    //二楼没有出库托盘,入库目标地址位1099;
                    //    var routeSet = EquRouteHelper.QueryRoute(Conv_1102, task.TASK_POSIDTO);
                    //    var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == Conv_1102);
                    //    converywrite.Goodsend = Convert.ToInt32(route.ROUTE_SONPOS);
                    //}

                    var routeSet = EquRouteHelper.QueryRoute(Conv_1102, task.TASK_POSIDTO);
                    var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == Conv_1102);
                    converywrite.Goodsend = Convert.ToInt32(route.ROUTE_SONPOS);
                }
                //检测存在出库任务
                //if (CheckIsExistOutTask(Conv_1102, cs.BarCodeStr)) return;
                //WriteInfoToConv(cs, converywrite);
                WriteInfoToCv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void Conv_Scanning(string convNo, string ExceptionNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB520_Confirm) return;

                var task = QueryTaskByBarcode(cs, convNo);

                if (task == null)
                {
                    if (WcsScanConvIsUsed(convNo))
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = cs.BarCodeStr;
                        param.ContainerType = 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        var agvtask = SugarBase.DB.Queryable<Middle_AGVTask>().Single(v => v.Task_BreakTrayNo == cs.BarCodeStr && v.Task_Type == 2);//退料任务
                        if (agvtask != null)
                        {
                            param.EquipmentNo = agvtask.Task_PosidFrom;
                            param.Memo3 = agvtask.Task_BreakBarCode_1;
                            param.Memo4 = agvtask.Task_BreakBarCode_2;
                        }
                        else
                        {
                            param.EquipmentNo = convNo;
                        }
                        param.EndPostion = srm;
                        param.Memo2 = ExceptionNo;
                        task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }
                }
                else if (task.TASK_COMTYPE == 2 && task.TASK_POSIDNEXT == ExceptionNo && task.TASK_WKSTATUS < 99)
                {
                    //完成任务
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                    .Where(it => it.TASK_NO == task.TASK_NO)
                                    .ExecuteCommand();
                        //添加修改明细
                        string msg = string.Format("任务[{0}]完成", task.TASK_NO);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(result);
                    }
                }
                if (task == null || (task.TASK_COMTYPE != 1 && task.TASK_COMTYPE != 6)) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                //判断任务是否已经执行
                if (task.TASK_WKSTATUS == 2 || task.TASK_WKSTATUS == 99 || task.TASK_WKSTATUS == 109 || task.TASK_WKSTATUS == 106) return;

                converywrite.Tasknum = task.TASK_NO;
                //converywrite.Goodstype = task.TASK_BOXBARCODE.Substring(0,2)== "SH" ? 1 : 2;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                if (task.TASK_COMTYPE == (int)ComTypeEnum.托盘异常退回)
                {
                    converywrite.Notask = true;
                    converywrite.Goodsend = Convert.ToInt32(ExceptionNo);
                }
                else
                {
                    //bool isany = SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && v.TASK_POSIDTO == Conv_1104 && (v.TASK_POSIDNEXT == Conv_1099 || v.TASK_POSIDNEXT == Conv_1104 || v.TASK_POSIDNEXT == Conv_1105));
                    //if (isany)
                    //{
                    //    //二楼有托盘出库，入库托盘送到中转位置1105
                    //    converywrite.Goodsend = Convert.ToInt32(Conv_1105);
                    //}
                    //else
                    //{
                    //    //二楼没有出库托盘,入库目标地址位1099;
                    //    var routeSet = EquRouteHelper.QueryRoute(Conv_1102, task.TASK_POSIDTO);
                    //    var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == Conv_1102);
                    //    converywrite.Goodsend = Convert.ToInt32(route.ROUTE_SONPOS);
                    //}

                    //var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                    //var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == convNo);
                    converywrite.Goodsend = Convert.ToInt32(Conv_1092);
                }
                //检测存在出库任务
                //if (CheckIsExistOutTask(convNo, cs.BarCodeStr)) return;
                //WriteInfoToConv(cs, converywrite);
                WriteInfoToCv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void Conv_Scanning_1214(string convNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                //获取PLC的信号序列
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var weight = conveyor.EquSignal_Conv;
                if (weight.DB521_Tasknum <= 0) return;
                //判断光电是否是当前光电
                if (!weight.CvDB51_PH_Status) return;
                if (weight.DB521_Res04_1==0) return;

                //找到设备任务号对应的任务信息
                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == weight.DB521_Tasknum);
                if (task.TASK_POSIDCUR != Conv_1214) return;

                if (task.TASK_GrossWeight >0) return;
                //调用上传WMS的接口上传称重信息
                var param = new GetWeightParam()
                {
                    WMSTaskNum = task.TASK_WMSNO.ToString(),
                    Weight = weight.DB521_Res04_1
                };
                BaseWorkflow.ProInGetWeight(param);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 二坐标写入抓取原膜卷组盘任务
        /// </summary>
        private void ConvWriteTaskExe_1044(string convNo)
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1044).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Res04 != 1) return;//二坐标机械手完成信号

                var convitem = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo).EquSignal_Conv;

                if (convitem.DB521_Tasknum <= 0) return;
                //if (!convitem.CvDB51_PH_Status) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == convitem.DB521_Tasknum);
                if (task == null || task.TASK_POSIDNEXT != convNo) return;
                if (convNo == Conv_1071)
                {
                    if (!string.IsNullOrWhiteSpace(task.TASK_ITEM5)) return;
                }
                else if (convNo == Conv_1072)
                {
                    if (!string.IsNullOrWhiteSpace(task.TASK_ITEM6)) return;
                }

                string first = string.IsNullOrWhiteSpace(task.TASK_ITEM5) ? string.Empty : task.TASK_ITEM5.Trim();
                string second = string.IsNullOrWhiteSpace(task.TASK_ITEM6) ? string.Empty : task.TASK_ITEM6.Trim();

                var conv1035 = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1035).EquSignal_Conv;
                var conv1036 = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1036).EquSignal_Conv;

                var taskitem_1035 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == conv1035.DB521_Tasknum);
                var taskitem_1036 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == conv1036.DB521_Tasknum);
                string startAddress = string.Empty;
                string endAddress = string.Empty;
                int task_no = 0;
                if (string.IsNullOrWhiteSpace(first))
                {
                    //写入二坐标目标地址1071任务
                    //1035对应6#堆垛机
                    if (taskitem_1035 != null)
                    {
                        //如果是单卷膜进行抓取
                        var task_IsSingleVolume_1035 = SugarBase.DB.Queryable<WCS_TASK>().Count(v => v.TASK_ITEM1 == taskitem_1035.TASK_ITEM1 && (v.TASK_SRMNO == "srm01" || v.TASK_SRMNO == "srm06"));
                        //如果在同一巷道进行抓取
                        var task_SameSrm_1035 = SugarBase.DB.Queryable<WCS_TASK>().Count(v => v.TASK_ITEM1 == taskitem_1035.TASK_ITEM1 && v.TASK_SRMNO == "srm06");
                        if (task_IsSingleVolume_1035 < 2 || task_SameSrm_1035 == 2)
                        {
                            startAddress = "1035";
                            task_no = taskitem_1035.TASK_NO;
                        }
                        else
                        {
                            //判断在1#堆垛机否有未执行的任务
                            var task_IncompleteWork_1035 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_ITEM1 == taskitem_1035.TASK_ITEM1 && v.TASK_WKSTATUS <= 1 && v.TASK_SRMNO == "srm01");
                            if (task_IncompleteWork_1035 != null)
                            {
                                //如果存在则判断堆垛机是否执行任务
                                var task_IsWorking_1035 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_POSIDNEXT == "1036" && v.TASK_SRMNO == "srm01");
                                if (task_IsWorking_1035 == null)
                                {
                                    startAddress = "1035";
                                    task_no = taskitem_1035.TASK_NO;
                                }
                            }
                            else
                            {
                                startAddress = "1035";
                                task_no = taskitem_1035.TASK_NO;
                            }
                        }
                        //endAddress = "1071";
                    }

                    if (string.IsNullOrWhiteSpace(startAddress) && task_no == 0)
                    {
                        //1036对应1#堆垛机
                        if (taskitem_1036 != null)
                        {
                            //如果是单卷膜进行抓取
                            var task_IsSingleVolume_1036 = SugarBase.DB.Queryable<WCS_TASK>().Count(v => v.TASK_ITEM1 == taskitem_1036.TASK_ITEM1 && (v.TASK_SRMNO == "srm01" || v.TASK_SRMNO == "srm06"));
                            //如果在同一巷道进行抓取
                            var task_SameSrm_1036 = SugarBase.DB.Queryable<WCS_TASK>().Count(v => v.TASK_ITEM1 == taskitem_1036.TASK_ITEM1 && v.TASK_SRMNO == "srm01");
                            if (task_IsSingleVolume_1036 < 2 || task_SameSrm_1036 == 2)
                            {
                                startAddress = "1036";
                                task_no = taskitem_1036.TASK_NO;
                            }
                            else
                            {
                                //判断在6#堆垛机否有未执行的任务
                                var task_IncompleteWork_1036 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_ITEM1 == taskitem_1036.TASK_ITEM1 && v.TASK_WKSTATUS <= 1 && v.TASK_SRMNO == "srm06");
                                if (task_IncompleteWork_1036 != null)
                                {
                                    //如果存在则判断堆垛机是否执行任务
                                    var task_IsWorking_1036 = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_POSIDNEXT == "1035" && v.TASK_SRMNO == "srm06");
                                    if (task_IsWorking_1036 == null)
                                    {
                                        startAddress = "1036";
                                        task_no = taskitem_1036.TASK_NO;
                                    }
                                }
                                else
                                {
                                    startAddress = "1036";
                                    task_no = taskitem_1036.TASK_NO;
                                }
                            }
                        }
                    }

                    if (string.IsNullOrWhiteSpace(startAddress) || task_no == 0) return;
                }
                else if (string.IsNullOrWhiteSpace(second))
                {
                    //写入二坐标目标地址1072任务
                    if (taskitem_1035 != null && taskitem_1035.TASK_ITEM1 == task.TASK_ITEM1)
                    {
                        startAddress = "1035";
                        task_no = taskitem_1035.TASK_NO;
                        //endAddress = "1071";
                    }
                    else if (taskitem_1036 != null && taskitem_1036.TASK_ITEM1 == task.TASK_ITEM1)
                    {
                        startAddress = "1036";
                        task_no = taskitem_1036.TASK_NO;
                        //endAddress = "1071";
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
                if (taskitem_1036 != null && taskitem_1036.TASK_POSIDNEXT == Conv_1070) return;
                if (taskitem_1035 != null && taskitem_1035.TASK_POSIDNEXT == Conv_1070) return;

                var convwrite = new WCSWriteToConveyorSignal();
                convwrite.Plc = WCS_PLCItem.Plc;
                convwrite.DBName = WCS_PLCItem.WriteDBName;
                convwrite.ConveyorNo = Conv_1044;
                convwrite.WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox;
                convwrite.Tasknum = task_no;
                convwrite.Goodscode = 0;//待定
                convwrite.Goodstype = 0;
                convwrite.Goodssize = 0;//待定
                convwrite.Goodsstart = Convert.ToInt32(startAddress);
                convwrite.Goodsend = Convert.ToInt32(Conv_1070);
                if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDNEXT == Conv_1070 && v.TASK_WKSTATUS < 99))
                {
                    throw new Exception(string.Format("二坐标[{0}]存在未完成的任务，任务[{1}]未能下发给二坐标。", Conv_1044, task_no));
                }

                WriteInfoToConveyor(equ_conv, convwrite);
                //WriteInfoToConv(equ_conv, convwrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 卷绑定托盘
        /// </summary>
        private void BindingTray()
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1044).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Res04 != 1) return;
                if (equ_conv.DB521_Goodscode <= 0) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == equ_conv.DB521_Goodscode && v.TASK_WKSTATUS < 99);
                if (task == null) return;
                var convitem_1071 = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1071).EquSignal_Conv;
                //if (task.TASK_POSIDNEXT == Conv_1071)
                //{
                var task1071 = SugarBase.DB.Queryable<WCS_TASK>().Single(v => v.TASK_NO == convitem_1071.DB521_Tasknum);
                if (task1071 != null && string.IsNullOrWhiteSpace(task1071.TASK_ITEM5))
                {
                    //卷绑定托盘任务，完成任务
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        //卷绑定托盘任务
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_POSIDTO = task.TASK_POSIDTO, TASK_ITEM1 = task.TASK_ITEM1, TASK_ITEM5 = task.TASK_BOXBARCODE, TASK_ITEM8 = task.TASK_ITEM8, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                      .Where(it => it.TASK_NO == task1071.TASK_NO)
                      .ExecuteCommand();

                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                .Where(it => it.TASK_NO == task.TASK_NO)
                                .ExecuteCommand();
                        //添加修改明细
                        string msg = string.Format("任务[{0}]完成", task.TASK_NO);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                    });
                    if (!string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(result);
                    }
                }
                //}
                var convitem_1072 = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1072).EquSignal_Conv;
                //if (task.TASK_POSIDNEXT == Conv_1072)
                //{
                var task1072 = SugarBase.DB.Queryable<WCS_TASK>().Single(v => v.TASK_NO == convitem_1072.DB521_Tasknum);
                if (task1072 != null && string.IsNullOrWhiteSpace(task1072.TASK_ITEM6))
                {
                    //卷绑定托盘任务，完成任务
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        //卷绑定托盘任务
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_ITEM6 = task.TASK_BOXBARCODE, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                      .Where(it => it.TASK_NO == task1072.TASK_NO)
                      .ExecuteCommand();

                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 99, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                .Where(it => it.TASK_NO == task.TASK_NO)
                                .ExecuteCommand();
                        //添加修改明细
                        string msg = string.Format("任务[{0}]完成", task.TASK_NO);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                    });
                }
                //}
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        public virtual void ConvWriteTaskExe_1204()
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1204).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.CvDB51_PH_Status) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Tasknum <= 0) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == equ_conv.DB521_Tasknum);
                if (task.TASK_POSIDNEXT != Conv_1204) return;
                if (task.TASK_WKSTATUS != 9) return;

                var convwrite = new WCSWriteToConveyorSignal();
                convwrite.Plc = WCS_PLCItem.Plc;
                convwrite.DBName = WCS_PLCItem.WriteDBName;
                convwrite.ConveyorNo = Conv_1204;
                convwrite.WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox;
                convwrite.Tasknum = task.TASK_NO;
                convwrite.Goodscode = 0;//待定
                convwrite.Goodstype = 0;
                convwrite.Goodssize = 0;//待定
                convwrite.Goodsstart = Convert.ToInt32(Conv_1204);
                //string item2 = string.IsNullOrWhiteSpace(task.TASK_ITEM2) ? string.Empty : task.TASK_ITEM2.Trim();
                convwrite.UpMatRequest = task.TASK_IsWrapFilm;

                var routeSet = EquRouteHelper.QueryRoute(Conv_1204, task.TASK_POSIDTO);

                var routes = routeSet.Where(v => v.ROUTE_STARTPOS == Conv_1204).ToList();
                if (routes.Count == 1)
                {
                    convwrite.Goodsend = Convert.ToInt32(routes[0].ROUTE_SONPOS);
                }
                else
                {
                    convwrite.Goodsend = ConveyorWriteTaskExecuteToMoreAddress(Conv_1204, task, routes);
                }

                WriteInfoToConv(equ_conv, convwrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        public virtual void ConvWriteTaskExe_1460()
        {
            try
            {
                var equ_conv = WCS_PLCItem.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_1460).EquSignal_Conv;
                if (equ_conv.DB523_Fault) return;
                if (!equ_conv.CvDB51_PH_Status) return;
                if (!equ_conv.DB521_Request) return;
                if (equ_conv.DB521_Tasknum <= 0) return;

                var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == equ_conv.DB521_Tasknum);
                if (task.TASK_POSIDNEXT != Conv_1460) return;
                if (task.TASK_POSIDNEXT == "14600") return;
                //if (task.TASK_WKSTATUS != 2) return;

                var convwrite = new WCSWriteToConveyorSignal();
                convwrite.Plc = WCS_PLCItem.Plc;
                convwrite.DBName = WCS_PLCItem.WriteDBName;
                convwrite.ConveyorNo = Conv_1460;
                convwrite.WriteStartAddress = equ_conv.EquDbInfo_ReadWrite.DBReadIndox;
                convwrite.Tasknum = task.TASK_NO;
                convwrite.Goodscode = 0;//待定
                convwrite.Goodstype = 0;
                convwrite.Goodssize = 0;//待定
                convwrite.Goodsstart = Convert.ToInt32(Conv_1460);
                convwrite.Goodsend = 14600;

                WriteInfoToConv(equ_conv, convwrite, false);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 堆垛机出口输送线任务执行(任务目标地址的下个地址只支持单一地址)
        /// </summary>
        private void SrmOutConvExeTask(string plcName, string convNo, bool endPosIsCurConv = false)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == plcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB523_Fault) return;
                var taskSet = Current.TaskSet.Where(v => v.TASK_POSIDNEXT == convNo).ToList();
                var task = taskSet.SingleOrDefault(v => v.TASK_WKSTATUS == (int)WkStatus.堆垛机完成);
                if (task == null)
                {
                    throw new Exception(string.Format("堆垛机出口输送线[{0}]存在请求信号，但没查询到任务信息。", convNo));
                }

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodscode = 0;
                converywrite.Goodstype = 0;
                converywrite.Goodssize = 0;
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                if (endPosIsCurConv)
                {
                    converywrite.Goodsend = converywrite.Goodsstart;
                }
                else
                {
                    var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                    var routes = routeSet.Where(v => v.ROUTE_STARTPOS == convNo).ToList();
                    if (routes.Count == 1)
                    {
                        converywrite.Goodsend = Convert.ToInt32(routes[0].ROUTE_SONPOS);
                    }
                    else
                    {
                        if (convNo == Conv_1056 || convNo == Conv_1051)
                        {
                            if (task.TASK_POSIDTO != "1072")
                            {
                                converywrite.Goodsend = 1085;
                            }
                        }
                        else
                        {
                            throw new Exception(string.Format("输送线[{0}]任务[{1}]请求该函数不支持多个分支输送地址，请编写扩展函数。", convNo, task.TASK_NO));
                        }

                        //if (convNo == Conv_1056 || convNo== Conv_1051)
                        //{
                        //    string taryType = string.IsNullOrWhiteSpace(task.TASK_ITEM2) ? string.Empty : task.TASK_ITEM2.Trim();
                        //    string isEmpty = string.IsNullOrWhiteSpace(task.TASK_ITEM3) ? string.Empty : task.TASK_ITEM3.Trim();
                        //    if (taryType == "1" && isEmpty == "1")
                        //    {
                        //        converywrite.Goodsend = 1071;
                        //    }
                        //    else
                        //    {
                        //        converywrite.Goodsend = 1085;
                        //    }
                        //}
                        //else
                        //{
                        //throw new Exception(string.Format("输送线[{0}]任务[{1}]请求该函数不支持多个分支输送地址，请编写扩展函数。", convNo, task.TASK_NO));
                        //}
                    }
                }
                WriteInfoToConv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private static int _conveyorTaskExecute = 0;

        private void ConveyorTaskExecute()
        {
            if (Interlocked.Exchange(ref _conveyorTaskExecute, 1) == 0)
            {
                try
                {
                    foreach (var convNo in AppSettingsHelper.AppSettings.TaskStatusUpdateConNoList)
                    {
                        var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_POSIDCUR == convNo &&
                                                                        (v.TASK_WKSTATUS == (int)WkStatus.RGV完成 ||
                                                                        v.TASK_WKSTATUS == (int)WkStatus.RGV下料执行));
                        if (task == null) continue;
                        if (convNo == task.TASK_ITEM4) continue;

                        task.TASK_WKSTATUS = (int)WkStatus.输送机执行;
                        task.TASK_EDITUSERNO = "wcs";
                        task.TASK_POSIDNEXT = task.TASK_POSIDCUR;
                        task.TASK_EDITDATETIME = DateTime.Now;
                        SugarBase.DB.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _conveyorTaskExecute, 0);
                }
            }
        }

        #endregion 功能实现

        #endregion 重载实现
    }
}