YG-OPP-WCS-Client/WCS.Workflow/ConveyorPlc02.cs

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

namespace WCS.Workflow
{
    /// <summary>
    /// 输送线02PLC
    /// </summary>
    public class ConveyorPlc02: Base_Conv
    {
        #region 只读变量
        #region 电脑、液晶拆解线
        private readonly string Conv_2002 = "2002";
        private readonly string Conv_2004 = "2004";
        private readonly string Conv_2006 = "2006";
        private readonly string Conv_2008 = "2008";
        private readonly string Conv_2011 = "2011";
        private readonly string Conv_2012 = "2012";
        private readonly string Conv_2013 = "2013";
        private readonly string Conv_2014 = "2014";
        private readonly string Conv_2015 = "2015";
        private readonly string Conv_2016 = "2016";
        private readonly string Conv_2017 = "2017";
        private readonly string Conv_2018 = "2018";
        #endregion;

        #region 电视拆解线
        private readonly string Conv_2021 = "2021";
        private readonly string Conv_2022 = "2022";
        private readonly string Conv_2023 = "2023";
        private readonly string Conv_2024 = "2024";
        private readonly string Conv_2025 = "2025";
        private readonly string Conv_2026 = "2026";
        private readonly string Conv_2027 = "2027";
        private readonly string Conv_2028 = "2028";

        private readonly string Conv_2092 = "2092";
        private readonly string Conv_2094 = "2094";
        private readonly string Conv_2096 = "2096";
        private readonly string Conv_2098 = "2098";
        private readonly string Conv_2100 = "2100";
        #endregion;

        #region 洗衣机拆解线
        private readonly string Conv_2212 = "2212";
        private readonly string Conv_2214 = "2214";
        private readonly string Conv_2216 = "2216";
        private readonly string Conv_2218 = "2218";
        private readonly string Conv_2220 = "2220";

        private readonly string Conv_2174 = "2174";
        private readonly string Conv_2176 = "2176";

        private readonly string Conv_2131 = "2131";
        private readonly string Conv_2132 = "2132";
        private readonly string Conv_2133 = "2133";
        private readonly string Conv_2134 = "2134";
        private readonly string Conv_2138 = "2138";
        private readonly string Conv_2139 = "2139";
        private readonly string Conv_2140 = "2140";
        private readonly string Conv_2141 = "2141";
        private readonly string Conv_2142 = "2142";
        #endregion;

        #region 空调拆解线
        private readonly string Conv_2166 = "2166";
        private readonly string Conv_2168 = "2168";
        private readonly string Conv_2170 = "2170";
        private readonly string Conv_2172 = "2172";

        private readonly string Conv_2111 = "2111";
        private readonly string Conv_2112 = "2112";
        private readonly string Conv_2113 = "2113";
        private readonly string Conv_2114 = "2114";
        private readonly string Conv_2116 = "2116";
        private readonly string Conv_2120 = "2120";
        private readonly string Conv_2121 = "2121";
        private readonly string Conv_2122 = "2122";
        private readonly string Conv_2123 = "2123";
        private readonly string Conv_2124 = "2124";
        #endregion;

        #region 堆垛机出口输送线
        private readonly string Conv_2302 = "2302";
        private readonly string Conv_2306 = "2306";
        private readonly string Conv_2310 = "2310";
        private readonly string Conv_2314 = "2314";
        private readonly string Conv_2318 = "2318";
        private readonly string Conv_2322 = "2322";
        #endregion;

        #region 堆垛机一楼入库台
        private readonly string Conv_2380 = "2380";
        private readonly string Conv_2390 = "2390";
        #endregion;

        #region 堆垛机一楼出库台
        //异常口
        private readonly string Conv_2381 = "2381";
        private readonly string Conv_2391 = "2391";
        #endregion;

        #region 震动输送机
        private readonly string Conv_2065 = "2065";
        private readonly string Conv_2067 = "2067";
        private readonly string Conv_2069 = "2069";
        private readonly string Conv_2071 = "2071";
        private readonly string Conv_2073 = "2073";
        private readonly string Conv_2075 = "2075";
        #endregion;

        #region 称重输送线
        private readonly string Conv_Weigh_2235 = "2235";

        private readonly string Conv_Weigh_2336 = "2336";
        private readonly string Conv_Weigh_2036 = "2036";
        private readonly string Conv_Weigh_2034 = "2034";
        private readonly string Conv_Weigh_2056 = "2056";

        private readonly string Conv_Weigh_2344 = "2344";
        private readonly string Conv_Weigh_2157 = "2157";
        private readonly string Conv_Weigh_2155 = "2155";
        private readonly string Conv_Weigh_2181 = "2181";
        #endregion;

        #region 扫描输送线
        private readonly string Conv_2246 = "2246";
        private readonly string Conv_2235 = "2235";
        public readonly string Conv_2238 = "2238";
        private readonly string Conv_2359 = "2359";

        #endregion;

        #region 穿梭车
        private readonly string Rgv2019 = "rgv2019";
        private readonly string Rgv2029 = "rgv2029";
        private readonly string Rgv2044 = "rgv2044";
        private readonly string Rgv2062 = "rgv2062";
        private readonly string Rgv2081 = "rgv2081";

        private readonly string Rgv2201 = "rgv2201";
        private readonly string Rgv2189 = "rgv2189";
        private readonly string Rgv2163 = "rgv2163";
        private readonly string Rgv2143 = "rgv2143";
        private readonly string Rgv2125 = "rgv2125";
        #endregion;

        //打铁缓存位呼叫空托盘
        private readonly string Conv_2047 = "2047";
        private readonly string Conv_2436 = "2436";
        private readonly string Conv_2136 = "2136";
        private readonly string Conv_2137 = "2137";
        //异常口
        private readonly string Conv_2046 = "2046";
        //异常口
        private readonly string Conv_2437 = "2437";

        private readonly string Conv_2184 = "2184";
        private readonly string Conv_2151 = "2151";

        private readonly string ROUTE_INOUTTYPE_IN = "in";
        private readonly string ROUTE_INOUTTYPE_OUT = "out";

        private readonly string Conv_2360 = "2360";
        //发货口
        private readonly string Conv_2361 = "2361";

        private readonly string Conv_2365 = "2365";
        //发货口
        private readonly string Conv_2364 = "2364";

        private readonly string Conv_2051 = "2051";
        private readonly string Out_Area_D = "Out_Area_D";
        #endregion;

        #region 构造函数
        public ConveyorPlc02() : base()
        {
        }
        #endregion;

        #region 重载实现
        /// <summary>
        /// 调度PLC执行任务
        /// </summary>
        public override void Run()
        {
            //刷新任务数据
            WCSWorkflow.RefreshData();

            //一楼入库台申请(入库/搬运)
            Conv_FirstFloorExeTask();

            //二楼环线扫码执行任务
            Conv_ScanBarCodeExeTask();

            //二楼堆垛机出口任务执行
            SrmOutConvExeTask();

            //RGV超高退回报警超高，WCS确认清除
            ConvCancelTask();

            //出口任务完成
            ConveyorTaskFinish();

            //WCS写入输送线执行任务
            ConveyorWriteTaskExecute();

            //生产线空框呼叫
            ThreadHelper.TaskThread(ProLineCallEmptyOutTask);

            //生产线称重
            ThreadHelper.TaskThread(ProLineWeigh);

            //生产线物料入库请求
            ThreadHelper.TaskThread(ProLineInTaskRequest);

            //RGV对接的输送线自动执行的任务状态修改
            ThreadHelper.TaskThread(ConveyorTaskExecute);

            //生产线异常口申请，任务变更目标地址
            ThreadHelper.TaskThread(ExecConvRequest);
        }
        #endregion;

        #region 多线程调用
        private static int _proLineWeigh = 0;
        private void ProLineWeigh()
        {
            if (Interlocked.Exchange(ref _proLineWeigh, 1) == 0)
            {
                try
                {
                    int weight = 70000;//克
                    List<string> convNoSet = new List<string>();
                    convNoSet.Add(Conv_Weigh_2336);
                    convNoSet.Add(Conv_Weigh_2034);
                    convNoSet.Add(Conv_Weigh_2036);
                    convNoSet.Add(Conv_Weigh_2056);

                    convNoSet.Add(Conv_Weigh_2344);
                    convNoSet.Add(Conv_Weigh_2157);
                    convNoSet.Add(Conv_Weigh_2155);
                    convNoSet.Add(Conv_Weigh_2181);

                    foreach (var convNo in convNoSet)
                    {
                        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) continue;
                        if (equ_conv.DB521_Res04 <= 2000) continue;
                        if (equ_conv.DB521_Res04 < weight)
                        {
                            var msg = string.Format("输送机[{0}]处称重异常，当前重量[{1}]克，铁托盘预估重量[{2}]克以上。", convNo, equ_conv.DB521_Res04, weight);
                            LogMessageHelper.RecordLogMessage(msg);
                            continue;
                        }
                        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);
                }
            }
        }

        private static int _roLineInTaskRequest = 0;
        private void ProLineInTaskRequest()
        {
            if (Interlocked.Exchange(ref _roLineInTaskRequest, 1) == 0)
            {
                try
                {
                    List<string> convNoSet = new List<string>();
                    #region 生产线电视，电脑
                    convNoSet.Add(Conv_2092);
                    convNoSet.Add(Conv_2094);
                    convNoSet.Add(Conv_2096);
                    convNoSet.Add(Conv_2098);
                    convNoSet.Add(Conv_2100);

                    convNoSet.Add(Conv_2021);
                    convNoSet.Add(Conv_2022);
                    convNoSet.Add(Conv_2023);
                    convNoSet.Add(Conv_2024);
                    convNoSet.Add(Conv_2025);
                    convNoSet.Add(Conv_2026);
                    convNoSet.Add(Conv_2027);
                    convNoSet.Add(Conv_2028);

                    convNoSet.Add(Conv_2002);
                    convNoSet.Add(Conv_2004);
                    convNoSet.Add(Conv_2006);
                    convNoSet.Add(Conv_2008);

                    convNoSet.Add(Conv_2011);
                    convNoSet.Add(Conv_2012);
                    convNoSet.Add(Conv_2013);
                    convNoSet.Add(Conv_2014);
                    convNoSet.Add(Conv_2015);
                    convNoSet.Add(Conv_2016);
                    convNoSet.Add(Conv_2017);
                    convNoSet.Add(Conv_2018);

                    convNoSet.Add(Conv_2065);
                    convNoSet.Add(Conv_2067);
                    convNoSet.Add(Conv_2069);
                    convNoSet.Add(Conv_2071);
                    convNoSet.Add(Conv_2073);
                    convNoSet.Add(Conv_2075);
                    #endregion;

                    #region 空调，洗衣机
                    convNoSet.Add(Conv_2111);
                    convNoSet.Add(Conv_2112);
                    convNoSet.Add(Conv_2113);
                    convNoSet.Add(Conv_2114);
                    convNoSet.Add(Conv_2116);
                    convNoSet.Add(Conv_2120);
                    convNoSet.Add(Conv_2121);
                    convNoSet.Add(Conv_2122);
                    convNoSet.Add(Conv_2123);
                    convNoSet.Add(Conv_2124);

                    convNoSet.Add(Conv_2131);
                    convNoSet.Add(Conv_2132);
                    convNoSet.Add(Conv_2133);
                    convNoSet.Add(Conv_2134);
                    convNoSet.Add(Conv_2138);
                    convNoSet.Add(Conv_2139);
                    convNoSet.Add(Conv_2140);
                    convNoSet.Add(Conv_2141);
                    convNoSet.Add(Conv_2142);

                    convNoSet.Add(Conv_2166);
                    convNoSet.Add(Conv_2168);
                    convNoSet.Add(Conv_2170);
                    convNoSet.Add(Conv_2172);
                    convNoSet.Add(Conv_2174);
                    convNoSet.Add(Conv_2176);

                    convNoSet.Add(Conv_2212);
                    convNoSet.Add(Conv_2214);
                    convNoSet.Add(Conv_2216);
                    convNoSet.Add(Conv_2218);
                    convNoSet.Add(Conv_2220);

                    convNoSet.Add(Conv_2436);//打铁
                    convNoSet.Add(Conv_2137);//打铁
                    #endregion;

                    CreateInTaskByRequest(convNoSet);
                }
                catch (Exception ex)
                {
                    Log4netHelper.Logger_Error.ErrorFormat(ex.ToString());
                }
                finally
                {
                    Interlocked.Exchange(ref _roLineInTaskRequest, 0);
                }
            }
        }

        private static int _conveyorTaskExecute = 0;
        private void ConveyorTaskExecute()
        {
            if (Interlocked.Exchange(ref _conveyorTaskExecute, 1) == 0)
            {
                try
                {
                    //List<string> convSet = new List<string>() { "2033", "2061", "2041", "2038", "2088", "2246", "2188", "2208", "2160", "2154", "2159", "2153", "2151" };
                    foreach (var convNo in AppSettingsHelper.AppSettings.TaskStatusUpdateConNoList)
                    {
                        var task = Current.TaskSet.FirstOrDefault(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);
                }
            }
        }
        private static int _execConvRequest = 0;
        private void ExecConvRequest()
        {
            if (Interlocked.Exchange(ref _execConvRequest, 1) == 0)
            {
                try
                {
                    ExecConvRequest(Conv_2046);

                    ExecConvRequest(Conv_2437);
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _execConvRequest, 0);
                }
            }
        }
        private static int _proLineCallEmptyOutTask = 0;
        private void ProLineCallEmptyOutTask()
        {
            if (Interlocked.Exchange(ref _proLineCallEmptyOutTask, 1) == 0)
            {
                try
                {
                    WCSWorkflow.RefreshData();
                    List<string> OutPos = new List<string>();

                    //电视面板、面板塑料、PS、含汞背光灯
                    OutPos.Add(Conv_2092);
                    OutPos.Add(Conv_2094);
                    OutPos.Add(Conv_2096);
                    OutPos.Add(Conv_2098);
                    OutPos.Add(Conv_2100);

                    //电路板、面板塑料(纸)、LED灯、扬声器
                    OutPos.Add(Conv_2021);
                    OutPos.Add(Conv_2022);
                    OutPos.Add(Conv_2023);
                    OutPos.Add(Conv_2024);
                    OutPos.Add(Conv_2025);
                    OutPos.Add(Conv_2026);
                    OutPos.Add(Conv_2027);
                    OutPos.Add(Conv_2028);

                    //电线电缆、电子枪、防静电线、螺丝
                    OutPos.Add(Conv_2011);
                    OutPos.Add(Conv_2012);
                    OutPos.Add(Conv_2013);
                    OutPos.Add(Conv_2014);
                    OutPos.Add(Conv_2015);
                    OutPos.Add(Conv_2016);
                    OutPos.Add(Conv_2017);
                    OutPos.Add(Conv_2018);

                    //屏玻璃
                    OutPos.Add(Conv_2002);
                    OutPos.Add(Conv_2006);

                    //锥玻璃
                    OutPos.Add(Conv_2004);
                    OutPos.Add(Conv_2008);

                    //震动输送机
                    //CallEmptyOutTask(Conv_2065);
                    //CallEmptyOutTask(Conv_2067);
                    //CallEmptyOutTask(Conv_2069);
                    //CallEmptyOutTask(Conv_2071);
                    //CallEmptyOutTask(Conv_2073);
                    //CallEmptyOutTask(Conv_2075);

                    //打铁缓存位呼叫空托盘
                    Conv_RequestCarry(Conv_2047, Conv_2436);
                    Conv_RequestCarry(Conv_2136, Conv_2137);

                    //打铁缓存位呼叫空托盘
                    OutPos.Add(Conv_2047);
                    OutPos.Add(Conv_2136);

                    //空调产物入库位置呼叫空箱
                    OutPos.Add(Conv_2111);
                    OutPos.Add(Conv_2112);
                    OutPos.Add(Conv_2113);
                    OutPos.Add(Conv_2114);
                    OutPos.Add(Conv_2116);
                    //OutPos.Add(Conv_2120);
                    OutPos.Add(Conv_2121);
                    OutPos.Add(Conv_2122);
                    OutPos.Add(Conv_2123);
                    OutPos.Add(Conv_2124);

                    //洗衣机产物入库位置呼叫空箱
                    OutPos.Add(Conv_2131);
                    OutPos.Add(Conv_2132);
                    OutPos.Add(Conv_2133);
                    OutPos.Add(Conv_2134);
                    //OutPos.Add(Conv_2138);
                    OutPos.Add(Conv_2139);
                    OutPos.Add(Conv_2140);
                    OutPos.Add(Conv_2141);
                    OutPos.Add(Conv_2142);

                    //震动输送机
                    //CallEmptyOutTask(Conv_2166);
                    //CallEmptyOutTask(Conv_2168);
                    //CallEmptyOutTask(Conv_2170);
                    //CallEmptyOutTask(Conv_2172);
                    //CallEmptyOutTask(Conv_2174);
                    //CallEmptyOutTask(Conv_2176);

                    ////二楼产物
                    OutPos.Add(Conv_2212);
                    OutPos.Add(Conv_2214);
                    OutPos.Add(Conv_2216);
                    OutPos.Add(Conv_2218);
                    OutPos.Add(Conv_2220);

                    foreach (var convNo in OutPos)
                    {
                        if (Current.WCS_TASKTIMEPOINTSet.Any(v => v.F_NO == convNo)) continue;
                        CallEmptyOutTask(convNo);
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _proLineCallEmptyOutTask, 0);
                }
            }
        }
        #endregion;

        #region 模块调用
        private void Conv_FirstFloorExeTask()
        {
            Conv_NotScannExeTask(Conv_2380, string.Empty, true);

            Conv_NotScannExeTask(Conv_2390, string.Empty, true);
        }
        private void Conv_ScanBarCodeExeTask()
        {
            Conv_Scanning_2246(Conv_2246, Conv_2235);

            Conv_Scanning_2235(Conv_2235, Conv_2381, "0", 1);

            Conv_Scanning_2238(Conv_2238, Conv_2246);

            Conv_Scanning_2359(Conv_2359);
        }
        private void SrmOutConvExeTask()
        {
            SrmOutConvExeTask(PlcName, Conv_2302);
            SrmOutConvExeTask(PlcName, Conv_2306);
            SrmOutConvExeTask(PlcName, Conv_2310);
            SrmOutConvExeTask(PlcName, Conv_2314);
            SrmOutConvExeTask(PlcName, Conv_2318);
            SrmOutConvExeTask(PlcName, Conv_2322);
        }
        /// <summary>
        /// 入口输送线超高报警取消任务(震动输送机和2436超高变更目标地址到异常口)
        /// </summary>
        private void ConvCancelTask()
        {
            //震动输送机超高
            Conv_H_OutsideUpdateTaskEndAddress(Conv_Weigh_2056, Conv_2046);

            #region 电视，电脑
            List<string> list_rgv2019 = new List<string>() { Conv_2002, Conv_2004, Conv_2006, Conv_2008, Conv_2011, Conv_2012, Conv_2013, Conv_2014, Conv_2015, Conv_2016, Conv_2017, Conv_2018 };
            foreach (var item in list_rgv2019)
            {
                ConvSuperHighAlaramResetTask(Rgv2019, item);
            }
            List<string> list_rgv2029 = new List<string>() { Conv_2021, Conv_2022, Conv_2023, Conv_2024, Conv_2025, Conv_2026, Conv_2027, Conv_2028 };
            foreach (var item in list_rgv2029)
            {
                ConvSuperHighAlaramResetTask(Rgv2029, item);
            }
            List<string> list_rgv2044 = new List<string>() { Conv_2046, Conv_2436 };
            foreach (var item in list_rgv2044)
            {
                ConvSuperHighAlaramResetTask(Rgv2044, item);
            }
            List<string> list_rgv2062 = new List<string>() { Conv_2065, Conv_2067, Conv_2069, Conv_2071, Conv_2073, Conv_2075 };
            foreach (var item in list_rgv2062)
            {
                ConvSuperHighAlaramResetTask(Rgv2062, item);
            }
            List<string> list_rgv2081 = new List<string>() { Conv_2092, Conv_2094, Conv_2096, Conv_2098, Conv_2100 };
            foreach (var item in list_rgv2081)
            {
                ConvSuperHighAlaramResetTask(Rgv2081, item);
            }
            #endregion; 

            #region  空调，洗衣机
            List<string> list_rgv2125 = new List<string>() { Conv_2111, Conv_2112, Conv_2113, Conv_2114, Conv_2116, Conv_2120, Conv_2121, Conv_2122, Conv_2123, Conv_2124 };
            foreach (var item in list_rgv2125)
            {
                ConvSuperHighAlaramResetTask(Rgv2125, item);
            }
            List<string> list_rgv2143 = new List<string>() { Conv_2131, Conv_2132, Conv_2133, Conv_2134, Conv_2137, Conv_2138, Conv_2139, Conv_2140, Conv_2141, Conv_2142 };
            foreach (var item in list_rgv2143)
            {
                ConvSuperHighAlaramResetTask(Rgv2143, item);
            }
            List<string> list_rgv2163 = new List<string>() { Conv_2166, Conv_2168, Conv_2170, Conv_2174, Conv_2437 };
            foreach (var item in list_rgv2163)
            {
                ConvSuperHighAlaramResetTask(Rgv2163, item);
            }
            List<string> list_rgv2189 = new List<string>() { Conv_2174, Conv_2176 };
            foreach (var item in list_rgv2189)
            {
                ConvSuperHighAlaramResetTask(Rgv2189, item);
            }
            List<string> list_rgv2201 = new List<string>() { Conv_2212, Conv_2214, Conv_2216, Conv_2218, Conv_2220 };
            foreach (var item in list_rgv2201)
            {
                ConvSuperHighAlaramResetTask(Rgv2201, item);
            }
            #endregion;
        }
        private void ConveyorTaskFinish()
        {
            //成品测试出口
            ConveyorTaskFinish(PlcName,Conv_2238);

            ConveyorTaskFinish(PlcName,Conv_2246);

            #region 生产线输送线任务完成 A区
            ConveyorTaskFinish(PlcName, Conv_2092);
            ConveyorTaskFinish(PlcName, Conv_2094);
            ConveyorTaskFinish(PlcName, Conv_2096);
            ConveyorTaskFinish(PlcName, Conv_2098);
            ConveyorTaskFinish(PlcName, Conv_2100);

            ConveyorTaskFinish(PlcName, Conv_2021);
            ConveyorTaskFinish(PlcName, Conv_2022);
            ConveyorTaskFinish(PlcName, Conv_2023);
            ConveyorTaskFinish(PlcName, Conv_2024);
            ConveyorTaskFinish(PlcName, Conv_2025);
            ConveyorTaskFinish(PlcName, Conv_2026);
            ConveyorTaskFinish(PlcName, Conv_2027);
            ConveyorTaskFinish(PlcName, Conv_2028);

            ConveyorTaskFinish(PlcName, Conv_2011);
            ConveyorTaskFinish(PlcName, Conv_2012);
            ConveyorTaskFinish(PlcName, Conv_2013);
            ConveyorTaskFinish(PlcName, Conv_2014);
            ConveyorTaskFinish(PlcName, Conv_2015);
            ConveyorTaskFinish(PlcName, Conv_2016);
            ConveyorTaskFinish(PlcName, Conv_2017);
            ConveyorTaskFinish(PlcName, Conv_2018);

            ConveyorTaskFinish(PlcName, Conv_2002);
            ConveyorTaskFinish(PlcName, Conv_2004);
            ConveyorTaskFinish(PlcName, Conv_2006);
            ConveyorTaskFinish(PlcName, Conv_2008);

            ConveyorTaskFinish(PlcName, Conv_2065);
            ConveyorTaskFinish(PlcName, Conv_2067);
            ConveyorTaskFinish(PlcName, Conv_2069);
            ConveyorTaskFinish(PlcName, Conv_2071);
            ConveyorTaskFinish(PlcName, Conv_2073);
            ConveyorTaskFinish(PlcName, Conv_2075);
            //ConveyorTaskFinish(plcName, "2100");
            #endregion;

            #region 生产线输送线任务完成 B区
            ConveyorTaskFinish(PlcName, Conv_2212);
            ConveyorTaskFinish(PlcName, Conv_2214);
            ConveyorTaskFinish(PlcName, Conv_2216);
            ConveyorTaskFinish(PlcName, Conv_2218);
            ConveyorTaskFinish(PlcName, Conv_2220);

            ConveyorTaskFinish(PlcName, Conv_2166);
            ConveyorTaskFinish(PlcName, Conv_2168);
            ConveyorTaskFinish(PlcName, Conv_2170);
            ConveyorTaskFinish(PlcName, Conv_2172);
            ConveyorTaskFinish(PlcName, Conv_2174);
            ConveyorTaskFinish(PlcName, Conv_2176);

            ConveyorTaskFinish(PlcName, Conv_2111);
            ConveyorTaskFinish(PlcName, Conv_2112);
            ConveyorTaskFinish(PlcName, Conv_2113);
            ConveyorTaskFinish(PlcName, Conv_2114);
            ConveyorTaskFinish(PlcName, Conv_2116);
            ConveyorTaskFinish(PlcName, Conv_2120);
            ConveyorTaskFinish(PlcName, Conv_2121);
            ConveyorTaskFinish(PlcName, Conv_2122);
            ConveyorTaskFinish(PlcName, Conv_2123);
            ConveyorTaskFinish(PlcName, Conv_2124);

            ConveyorTaskFinish(PlcName, Conv_2131);
            ConveyorTaskFinish(PlcName, Conv_2132);
            ConveyorTaskFinish(PlcName, Conv_2133);
            ConveyorTaskFinish(PlcName, Conv_2134);
  

            ConveyorTaskFinish(PlcName, Conv_2137);
            ConveyorTaskFinish(PlcName, Conv_2138);
            ConveyorTaskFinish(PlcName, Conv_2139);
            ConveyorTaskFinish(PlcName, Conv_2140);
            ConveyorTaskFinish(PlcName, Conv_2141);
            ConveyorTaskFinish(PlcName, Conv_2142);
            ConveyorTaskFinish(PlcName, Conv_2436);
            #endregion;

            ConveyorTaskFinish(PlcName, Conv_2047);//打铁托盘缓存位完成
            ConveyorTaskFinish(PlcName, Conv_2136);//打铁托盘缓存位完成

            #region 发货口任务完成
            ThreadHelper.TaskThread(ConvTaskFinish);
            #endregion;

        }
        private void ConveyorWriteTaskExecute()
        {
            ConveyorWriteTaskExecute(Conv_2051);

            ConveyorWriteTaskExecute(Conv_Weigh_2056);

            ConveyorWriteTaskExecute(Conv_2184);

            ConveyorWriteTaskExecute(Conv_2151);
        }
        #endregion;

        #region 功能实现
        private void CreateInTaskByRequest(List<string> convNoSet)
        {
            WCSWorkflow.RefreshData();
            foreach (var convNo in convNoSet)
            {
                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) continue;
                if (!equ_conv.DB521_Res01) continue;

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_POSIDFROM == convNo);
                if (task == null || task.TASK_WKSTATUS >= 99)
                {
                    var param = new GetInTaskParam();
                    param.ContainerBarCode = string.Empty;
                    param.ContainerType = 1;
                    param.MatBarCode = string.Empty;
                    param.WareHouseId = Current.Pvchouseputong;
                    param.EquipmentNo = convNo;
                    if (convNo == Conv_2120 || convNo == Conv_2138)
                    {
                        param.EndPostion = Conv_2381;
                    }
                    else
                    {
                        param.EndPostion = srm;
                    }
                  
                    param.Memo2 = "2";
                    task = BaseWorkflow.GetInTask(param);
                }
                else if (task.TASK_WKSTATUS <= 1)
                {
                    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();
                }
                else if (convNo == Conv_2436 || convNo == Conv_2137)//打铁位置可以生成多个入库任务
                {
                    var tasks = Current.TaskSet.Where(v => v.TASK_POSIDFROM == convNo);
                    int count = 0;
                    bool iscreatetask = true;
                    foreach (var item in tasks)
                    {
                        count = SugarBase.DB.Queryable<WCS_TASK_DTL>().Count(v => v.PARENTID == item.TASK_NO);
                        if (count < 3)
                        {
                            iscreatetask = false;
                            break;
                        }
                    }
                    if (iscreatetask)
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = string.Empty;
                        param.ContainerType = 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        param.EquipmentNo = convNo;
                        param.EndPostion = srm;
                        param.Memo2 = "2";
                        task = BaseWorkflow.GetInTask(param);
                    }
                }
            }
        }
        /// <summary>
        /// 发货口任务完成
        /// </summary>
        private void ConvTaskFinish()
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyorTo = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_2359);
                var cs = conveyorTo.EquSignal_Conv;

                List<string> list = new List<string>();
                list.Add(Conv_2361);
                list.Add(Conv_2364);
                foreach (var convNo in list)
                {
                    var task = Current.TaskSet.FirstOrDefault(v => v.TASK_POSIDTO == convNo && v.TASK_POSIDNEXT == convNo);
                    if (task!=null && task.TASK_NO != cs.DB521_Tasknum)
                   {
                        string result = TryCachHelper.TryExecute((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();
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        private void CallEmptyOutTask(string posidTo)
        {
            if (!Current.TaskSet.Any(v => v.TASK_POSIDTO_SHORT == posidTo))
            {
                var conv = ConveyorHelper.GetConveyorSignal(PlcName, posidTo);
                if (conv.CvDB51_PH_Status) return;
                if (conv.DB521_Tasknum > 0) return;

                var param = new GetOutTaskParam();
                param.OutEndPostion = posidTo;
                if (posidTo == Conv_2047 || posidTo == Conv_2436 || posidTo == Conv_2136 || posidTo == Conv_2137)
                {
                    param.OutType = 2;
                }
                else
                {
                    param.OutType = 3;
                }

                param.WareHouseId = Current.Pvchouseputong;

                WCS_GetOutTask(param, posidTo);
            }
        }
        /// <summary>
        /// 输送线无扫码执行任务
        /// </summary>
        /// <param name="convNo">扫码输送线</param>
        /// <param name="exitNo">扫码异常退出口</param>
        /// <param name="endPosIsCurConv">目标地址是否当前输送线</param>
        private void Conv_NotScannExeTask(string convNo, string exitNo, 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.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));
                    //GetInTaskParam param = new GetInTaskParam();
                    //param.ContainerBarCode = txtBarCode.Text.Trim();
                    //param.ContainerType = 1;
                    //param.MatBarCode = string.Empty;
                    //param.WareHouseId = "producthouse";
                    //param.EquipmentNo = "2390";
                    //param.EndPostion = "2246";
                    //CreateInTask(param);
                }

                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
                    {
                        throw new Exception(string.Format("该函数不支持多个分支输送地址，请编写扩展接口。"));
                    }
                }
                WriteInfoToConveyor(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        /// <summary>
        /// 打铁位置申请搬运任务
        /// </summary>
        /// <param name="convNo"></param>
        /// <param name="endConvNo"></param>
        private void Conv_RequestCarry(string convNo,string endConvNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var startCs = conveyor.EquSignal_Conv;
                var endConveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == endConvNo);
                var endCs = endConveyor.EquSignal_Conv;

                if (!startCs.CvDB51_PH_Status) return;
                if (endCs.CvDB51_PH_Status) return;
                if (endCs.DB521_Tasknum > 0) return;

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_POSIDFROM == convNo);
                if (task == null)
                {
                    var param = new GetInTaskParam();
                    param.ContainerBarCode = string.Empty;
                    param.ContainerType = 1;
                    param.MatBarCode = string.Empty;
                    param.WareHouseId = Current.Pvchouseputong;
                    param.EquipmentNo = convNo;
                    param.EndPostion = endConvNo;
                    param.Memo2 = "2";

                    task = BaseWorkflow.GetInTask(param);
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        /// <summary>
        /// 输送线扫码执行
        /// </summary>
        /// <param name="convNo">扫码输送线</param>
        /// <param name="exitNo">扫码异常退出口(没有则传空值)</param>
        /// <param name="endPostion">目标位置(method.调用扩展函数;0.无效参数; 1.仓库;2.区域A;3.区域B 等)</param>
        /// <param name="assignType">分配类型：0.不分配;1.分配巷道;2.分配货位</param>
        private void Conv_Scanning_2246(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 (ConveyorHelper.ConvGoodsAlarms(convNo, cs)) return;

                if (cs.DB521_BCR_Noread)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));
                    //if (!string.IsNullOrWhiteSpace(exitNo))
                    //{
                    //    var convwrite = new WCSWriteToConveyorSignal();
                    //    convwrite.Plc = plc.Plc;
                    //    convwrite.DBName = plc.WriteDBName;
                    //    convwrite.ConveyorNo = convNo;
                    //    convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                    //    convwrite.Tasknum = 1;
                    //    convwrite.Goodscode = 0;
                    //    convwrite.Goodstype = 0;
                    //    convwrite.Goodssize = 0;
                    //    convwrite.Goodsstart = Convert.ToInt32(convNo);
                    //    convwrite.Goodsend = Convert.ToInt32(exitNo);
                    //    //创建任务失败,写入托盘退回
                    //    ConveyorHelper.WriteInfoToConveyor(cs, convwrite, true);
                    //}
                    return;
                }

                //var scann = plc.WCS_ScannSet.FirstOrDefault(v => v.SCANN_PLCNAME == plcName && v.SCANN_STATIONNO == convNo);
                //if (string.IsNullOrWhiteSpace(scann.SCANN_BARCODE))
                //{
                //    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                //}
                //string barcodestr = scann.SCANN_BARCODE.Replace("\r", "").Replace("\0", "").Trim();

                if (string.IsNullOrWhiteSpace(cs.BarCodeStr))
                {
                    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                }

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

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == cs.BarCodeStr);
                if (task == null)
                {
                    //if (!string.IsNullOrWhiteSpace(exitNo))
                    //{
                    //    var convwrite = new WCSWriteToConveyorSignal();
                    //    convwrite.Plc = plc.Plc;
                    //    convwrite.DBName = plc.WriteDBName;
                    //    convwrite.ConveyorNo = convNo;
                    //    convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                    //    convwrite.Tasknum = 1;
                    //    convwrite.Goodscode = 0;
                    //    convwrite.Goodstype = 0;
                    //    convwrite.Goodssize = 0;
                    //    convwrite.Goodsstart = Convert.ToInt32(convNo);
                    //    convwrite.Goodsend = Convert.ToInt32(exitNo);
                    //    //创建任务失败,写入托盘退回
                    //    ConveyorHelper.WriteInfoToConveyor(cs, convwrite, true);
                    //}
                    //return;
                    var param = new GetInTaskParam();
                    param.ContainerBarCode = cs.BarCodeStr;
                    param.ContainerType = 1;
                    param.MatBarCode = string.Empty;
                    param.WareHouseId = Current.Pvchouseputong;
                    param.EquipmentNo = convNo;
                    param.EndPostion = "srm";
                    //if (endPostion == "method")
                    //{
                    //    param.EndPostion = Current.WcsInterface.QuerySetExtendedParam(plcName, param);
                    //}
                    //else
                    //{
                    //    param.EndPostion = endPostion;
                    //}

                    task = BaseWorkflow.GetInTask(param);
                }
                else if (task.TASK_COMTYPE == (int)ComTypeEnum.搬运 && task.TASK_POSIDTO == convNo)
                {
                    Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]是搬运到该位置的铁箱，等待任务完成后触发生成新的任务。", task.TASK_NO));
                    return;
                }
                //任务已经执行
                if (task == null || task.TASK_POSIDCUR != convNo || task.TASK_ITEM5 == convNo) 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);

                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 (task.TASK_POSIDTO == "srm")
                {
                    converywrite.Goodsend = Convert.ToInt32(Conv_Weigh_2235);
                }
                //else if (task.TASK_POSIDTO == "2391" || task.TASK_POSIDTO == "2381")
                //{
                //    converywrite.Goodsend = 2235;
                //}
                else
                {
                    throw new Exception(string.Format("该函数不支持多个分支输送地址，请编写扩展接口。"));
                }

                WriteInfoToConveyor(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        /// <summary>
        /// 输送线扫码执行
        /// </summary>
        /// <param name="convNo">扫码输送线</param>
        /// <param name="exitNo">扫码异常退出口(没有则传空值)</param>
        private void Conv_Scanning_2238(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 (ConveyorHelper.ConvGoodsAlarms(convNo, cs)) return;

                if (cs.DB521_BCR_Noread)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));
                    //if (!string.IsNullOrWhiteSpace(exitNo))
                    //{
                    //    var convwrite = new WCSWriteToConveyorSignal();
                    //    convwrite.Plc = plc.Plc;
                    //    convwrite.DBName = plc.WriteDBName;
                    //    convwrite.ConveyorNo = convNo;
                    //    convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                    //    convwrite.Tasknum = 1;
                    //    convwrite.Goodscode = 0;
                    //    convwrite.Goodstype = 0;
                    //    convwrite.Goodssize = 0;
                    //    convwrite.Goodsstart = Convert.ToInt32(convNo);
                    //    convwrite.Goodsend = Convert.ToInt32(exitNo);
                    //    //创建任务失败,写入托盘退回
                    //    ConveyorHelper.WriteInfoToConveyor(cs, convwrite, true);
                    //}
                    return;
                }

                //var scann = plc.WCS_ScannSet.FirstOrDefault(v => v.SCANN_PLCNAME == plcName && v.SCANN_STATIONNO == convNo);
                //if (string.IsNullOrWhiteSpace(scann.SCANN_BARCODE))
                //{
                //    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                //}
                //string barcodestr = scann.SCANN_BARCODE.Replace("\r", "").Replace("\0", "").Trim();

                if (string.IsNullOrWhiteSpace(cs.BarCodeStr))
                {
                    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                }

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

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == cs.BarCodeStr);
                if (task == null)
                {
                    //throw new Exception(string.Format("输送线[{0}]条码[{1}]未查询到任务，请检查扫码是否正确。", convNo, cs.BarCodeStr));
                    //if (!string.IsNullOrWhiteSpace(exitNo))
                    //{
                    //    var convwrite = new WCSWriteToConveyorSignal();
                    //    convwrite.Plc = plc.Plc;
                    //    convwrite.DBName = plc.WriteDBName;
                    //    convwrite.ConveyorNo = convNo;
                    //    convwrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                    //    convwrite.Tasknum = 1;
                    //    convwrite.Goodscode = 0;
                    //    convwrite.Goodstype = 0;
                    //    convwrite.Goodssize = 0;
                    //    convwrite.Goodsstart = Convert.ToInt32(convNo);
                    //    convwrite.Goodsend = Convert.ToInt32(exitNo);
                    //    //创建任务失败,写入托盘退回
                    //    ConveyorHelper.WriteInfoToConveyor(cs, convwrite, true);
                    //}
                    //return;

                    var param = new GetInTaskParam();
                    param.ContainerBarCode = cs.BarCodeStr;
                    param.ContainerType = 1;
                    param.MatBarCode = string.Empty;
                    param.WareHouseId = Current.Pvchouseputong;
                    param.EquipmentNo = convNo;
                    param.EndPostion = "srm";
                    //if (endPostion == "method")
                    //{
                    //    param.EndPostion = Current.WcsInterface.QuerySetExtendedParam(plcName, param);
                    //}
                    //else
                    //{
                    //    param.EndPostion = endPostion;
                    //}

                    task = BaseWorkflow.GetInTask(param);
                }
                //任务已经执行
                if (task == null || task.TASK_POSIDCUR != convNo || task.TASK_ITEM5 == convNo) 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);

                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 (task.TASK_POSIDTO == "srm")
                {
                    converywrite.Goodsend = Convert.ToInt32(Conv_2246);
                }
                else
                {
                    throw new Exception(string.Format("该函数不支持多个分支输送地址，请编写扩展接口。"));
                }

                WriteInfoToConveyor(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        /// <summary>
        /// 输送线扫码执行
        /// </summary>
        /// <param name="convNo">扫码输送线</param>
        /// <param name="exitNo">扫码异常退出口(没有则传空值)</param>
        /// <param name="endPostion">目标位置(method.调用扩展函数;0.无效参数; 1.仓库;2.区域A;3.区域B 等)</param>
        /// <param name="assignType">分配类型：0.不分配;1.分配巷道;2.分配货位</param>
        private void Conv_Scanning_2235(string convNo, string exitNo, string endPostion, int assignType = 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.DB521_Request) return;
                //if (ConveyorHelper.ConvGoodsAlarms(convNo, cs)) return;
                WCS_TASK task = null;
                if (cs.DB521_BCR_Noread)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));
                    return;
                    if (!string.IsNullOrWhiteSpace(exitNo))
                    {
                        var taskExce = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_POSIDFROM == convNo && v.TASK_POSIDCUR == convNo && v.TASK_POSIDNEXT == convNo);
                        if (taskExce == null)
                        {
                            //创建异常任务
                            taskExce = new WCS_TASK();
                            taskExce.TASK_WMSNO = "无";
                            taskExce.TASK_COMTYPE = (int)ComTypeEnum.搬运;
                            taskExce.TASK_SYSTYPE = "WCS";
                            taskExce.TASK_POSIDFROM = convNo;//起点地址
                            taskExce.TASK_POSIDCUR = convNo;
                            taskExce.TASK_POSIDNEXT = convNo;
                            taskExce.TASK_POSIDMOVE = "";
                            taskExce.TASK_PRIORITY = 1;
                            taskExce.TASK_WKSTATUS = 0;
                            taskExce.TASK_WHID = "成品库";
                            taskExce.TASK_ADDUSERNO = "WMS";
                            taskExce.TASK_ADDDATETIME = DateTime.Now;
                            taskExce.TASK_EDITUSERNO = "WMS";
                            taskExce.TASK_EDITDATETIME = DateTime.Now;
                            taskExce.TASK_NOTES = "";
                            taskExce.TASK_RGVNO = "";
                            taskExce.TASK_SRMNO = "srm01";
                            taskExce.TASK_BOXBARCODE = string.Empty;
                            taskExce.TASK_POSIDTO = exitNo;
                            int id = SugarBase.DB.Insertable(taskExce).ExecuteReturnIdentity();
                            if (id <= 0)
                            {
                                throw new Exception(string.Format("扫码位置[{0}]扫码异常，添加WCS异常任务失败", convNo));
                            }
                            else
                            {
                                taskExce.TASK_NO = id;
                                task = taskExce;
                            }
                        }
                    }
                    else
                    {
                        return;
                    }
                }

                //var scann = plc.WCS_ScannSet.FirstOrDefault(v => v.SCANN_PLCNAME == plcName && v.SCANN_STATIONNO == convNo);
                //if (string.IsNullOrWhiteSpace(scann.SCANN_BARCODE))
                //{
                //    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                //}
                //string barcodestr = scann.SCANN_BARCODE.Replace("\r", "").Replace("\0", "").Trim();

                if (string.IsNullOrWhiteSpace(cs.BarCodeStr))
                {
                    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                }

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

                if (task == null) task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == cs.BarCodeStr);

                if (task == null)
                {
                    throw new Exception(string.Format("输送线[{0}]条码[{1}]查询不到任务信息，请检测扫码是否正确。", convNo, cs.BarCodeStr));
                    //var param = new GetInTaskParam();
                    //param.ContainerBarCode = cs.BarCodeStr;
                    //param.ContainerType = 1;
                    //param.MatBarCode = string.Empty;
                    //param.WareHouseId = Current.WareHouseId;
                    //param.EquipmentNo = convNo;
                    //if (endPostion == "method")
                    //{
                    //    param.EndPostion = Current.WcsInterface.QuerySetExtendedParam(plcName, param);
                    //}
                    //else
                    //{
                    //    param.EndPostion = endPostion;
                    //}

                    //if (assignType > 0 && param.EndPostion.Contains("srm")) param.Memo1 = assignType.ToString();
                    //task = BaseWorkflow.GetInTask(param);
                }
                else if (task.TASK_COMTYPE == (int)ComTypeEnum.搬运 && task.TASK_POSIDTO == convNo)
                {
                    Log4netHelper.Logger_Info.InfoFormat(string.Format("任务[{0}]是搬运到该位置的铁箱，等待任务完成后触发生成新的任务。", task.TASK_NO));
                    return;
                }
                //任务已经执行
                if (task.TASK_ITEM5 == convNo) return;

                //重量低于180000克报错。
                if (cs.DB521_Res04 < 80000)
                    throw new Exception(string.Format("输送线[{0}]称重[{1}]克错误。", convNo, cs.DB521_Res04));

                GetWeightParam param = new GetWeightParam();
                param.WMSTaskNum = task.TASK_WMSNO;
                param.Weight = cs.DB521_Res04;
                if (string.IsNullOrEmpty(task.TASK_ITEM3))
                {
                    if (BaseWorkflow.GetWeight(param) == false)
                    {
                        return;
                    }
                }
                else
                {
                    Log4netHelper.Logger_Info.Info(string.Format("任务[{0}]已称重[{1}]，不会重复进行记录该称重信息。", task.TASK_NO, task.TASK_ITEM3));
                }

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

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

                var routes = routeSet.Where(v => v.ROUTE_STARTPOS == convNo).ToList();

                //if (task.TASK_POSIDTO == "2391")
                //{
                //    converywrite.Goodsend = 2304;
                //    //修改堆垛机编号
                //    SugarBase.DB.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_COMTYPE = 4, TASK_SRMNO = "srm11", TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                //               .Where(it => it.TASK_NO == task.TASK_NO)
                //               .ExecuteCommand();
                //}
                //else if (task.TASK_POSIDTO == "2381")
                //{
                //    converywrite.Goodsend = 2324;
                //    SugarBase.DB.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_COMTYPE = 4, TASK_SRMNO = "srm06", TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                //              .Where(it => it.TASK_NO == task.TASK_NO)
                //              .ExecuteCommand();
                //}
                //else 
                if (routes.Count == 1)
                {
                    converywrite.Goodsend = Convert.ToInt32(routes[0].ROUTE_SONPOS);
                }
                else if (task.TASK_POSIDTO.Contains("srm") && assignType > 0)
                {
                    ConveyorHelper.AssignSrm(routeSet, converywrite, Convert.ToInt32(task.TASK_WMSNO));
                }
                else
                {
                    throw new Exception(string.Format("任务[{0}]该函数不支持多个分支输送地址，请编写扩展接口。", task.TASK_NO));
                }

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

        private void Conv_Scanning_2359(string convNo)
        {
            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.DB521_BCR_Noread)
                {
                    throw new Exception(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));
                }
                if (string.IsNullOrWhiteSpace(cs.BarCodeStr))
                {
                    throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                }
                if (cs.BarCodeStr.ToUpper().Contains("ERROR") || cs.BarCodeStr.ToUpper().Contains("N") || cs.BarCodeStr.Contains("?"))
                {
                    throw new Exception(string.Format("输送线[{0}]存在请求信号，但条码是：[{1}]存在报错，PLC应该报条码错误信号", convNo, cs.BarCodeStr));
                }

                var conv2360 = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_2360).EquSignal_Conv;
                var conv2361 = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_2361).EquSignal_Conv;

                bool isNotTask_2061 = false;
                if (conv2360.DB521_Tasknum > 0 && conv2360.DB521_Goodsend == Convert.ToInt32(Conv_2361))
                {
                    isNotTask_2061 = true;
                }
                if (conv2361.DB521_Tasknum > 0 && conv2361.DB521_Goodsend == Convert.ToInt32(Conv_2361))
                {
                    isNotTask_2061 = true;
                }
                var conv2364 = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_2364).EquSignal_Conv;
                var conv2365 = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == Conv_2365).EquSignal_Conv;
                bool isNotTask_2064 = false;
                if (conv2360.DB521_Tasknum > 0 && conv2360.DB521_Goodsend == Convert.ToInt32(Conv_2364))
                {
                    isNotTask_2064 = true;
                }
                if (conv2364.DB521_Tasknum > 0 && conv2364.DB521_Goodsend == Convert.ToInt32(Conv_2364))
                {
                    isNotTask_2064 = true;
                }
                if (conv2365.DB521_Tasknum > 0 && conv2365.DB521_Goodsend == Convert.ToInt32(Conv_2364))
                {
                    isNotTask_2064 = true;
                }

                string endaddress = string.Empty;
                if (isNotTask_2061 == false)
                {
                    endaddress = Conv_2361;
                }
                else if (isNotTask_2064 == false)
                {
                    endaddress = Conv_2364;
                }
                if (string.IsNullOrWhiteSpace(endaddress)) return;

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == cs.BarCodeStr);
                if (task.TASK_POSIDTO == Out_Area_D)
                {
                    string result = TryCachHelper.TryTranExecute((db) =>
                    {
                        db.Updateable<WCS_TASK>(it => new WCS_TASK()
                        {
                            TASK_POSIDTO = endaddress,
                            TASK_EDITUSERNO = "WCS",
                            TASK_EDITDATETIME = DateTime.Now
                        })
                          .Where(it => it.TASK_NO == task.TASK_NO).ExecuteCommand();

                        string msg = string.Format("任务[{0}]已到达发货出库口扫码位置[{1}]分配目标地址[{2}]成功。", task.TASK_NO, convNo, endaddress);
                        CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, endaddress, msg);
                    });
                    if (string.IsNullOrWhiteSpace(result))
                    {
                        task.TASK_POSIDTO = endaddress;
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]已到达发货出库口扫码位置[{1}]分配目标地址[{2}]失败。", task.TASK_NO, convNo, endaddress));
                    }
                }
                if (task.TASK_POSIDNEXT == task.TASK_POSIDTO) 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);
                converywrite.Goodsend = Convert.ToInt32(task.TASK_POSIDTO);

                WriteInfoToConveyor(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        private static string guid = string.Empty;
        private bool WCS_GetOutTask(GetOutTaskParam param, string posidTo)
        {
            bool result = false;
            WCS_TASK wcstask = null;
            try
            {
                if (string.IsNullOrWhiteSpace(guid)) guid = Guid.NewGuid().ToString();
                param.OutId = guid;

                var reply = Current.WmsInterface.I_WCS_GetOutTask(param);
                if (reply.ResType)
                {
                    if(string.IsNullOrWhiteSpace(reply.WareHouseName))
                    {
                        throw new Exception(string.Format("工位[{0}]申请出库任务仓库不能为空。", posidTo));
                    }
                    var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_WMSNO == reply.WMSTaskNum);
                    if (task == null)
                    {
                        //添加wcs任务
                        wcstask = new WCS_TASK();
                        wcstask.TASK_WMSNO = reply.WMSTaskNum;
                        wcstask.TASK_COMTYPE = reply.TaskType;
                        wcstask.TASK_SYSTYPE = "WMS";
                        wcstask.TASK_POSIDFROM = reply.OutWareCellNo;//起点地址
                        wcstask.TASK_POSIDCUR = reply.OutWareCellNo;
                        wcstask.TASK_POSIDNEXT = reply.OutWareCellNo;
                        wcstask.TASK_POSIDMOVE = "";
                        wcstask.TASK_PRIORITY = reply.Priority;
                        wcstask.TASK_WKSTATUS = 0;
                        wcstask.TASK_WHID = reply.WareHouseName;
                        wcstask.TASK_ADDUSERNO = "WMS";
                        wcstask.TASK_ADDDATETIME = DateTime.Now;
                        wcstask.TASK_EDITUSERNO = "WMS";
                        wcstask.TASK_EDITDATETIME = DateTime.Now;
                        wcstask.TASK_NOTES = "";
                        wcstask.TASK_RGVNO = "";
                        wcstask.TASK_BOXBARCODE = reply.ContainerBarCode;
                        wcstask.TASK_POSIDTO = posidTo;
                        //wcstask.TASK_PRIORITY = reply.Priority;
                        if (string.IsNullOrWhiteSpace(reply.TunnelNum))
                        {
                            //wcstask.TASK_SRMNO = reply.EndPostion;
                        }
                        else
                        {
                            wcstask.TASK_FromTunnelNum = reply.TunnelNum;
                            if (wcstask.TASK_FromTunnelNum.Length == 2)
                                wcstask.TASK_SRMNO = string.Format("srm{0}", wcstask.TASK_FromTunnelNum);
                            else
                                wcstask.TASK_SRMNO = string.Format("srm0{0}", wcstask.TASK_FromTunnelNum);

                        }
                        if (wcstask.TASK_COMTYPE == 2 && string.IsNullOrWhiteSpace(wcstask.TASK_SRMNO))
                        {
                            throw new Exception(string.Format("工位[{0}]申请出库任务中 堆垛机编号不能为空。", posidTo));
                        }
                        if (string.IsNullOrWhiteSpace(wcstask.TASK_BOXBARCODE))
                        {
                            throw new Exception(string.Format("工位[{0}]申请出库任务中 条码编号不能为空。", posidTo));
                        }
                        int id = SugarBase.DB.Insertable(wcstask).ExecuteReturnIdentity();
                        if (id <= 0)
                        {
                            throw new Exception(string.Format("WMS任务[{0}]添加WCS任务失败", reply.WMSTaskNum));
                        }
                        else
                        {
                            wcstask.TASK_NO = id;
                            guid = Guid.NewGuid().ToString();
                            result = true;
                        }
                    }
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(reply.Memo2))
                    {
                        var msg = string.Format("目标位置[{0}]获取出库任务失败,原因：[{1}]", posidTo, reply.ResMessage);
                        LogMessageHelper.RecordLogMessage(msg);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
            return result;
        }
        /// <summary>
        /// 超高重置任务
        /// </summary>
        /// <param name="rgvName"></param>
        /// <param name="convNo"></param>
        private void ConvSuperHighAlaramResetTask(string rgvName, string convNo)
        {
            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;
                var rgv = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == rgvName).WCS_EquipmentInfoSet[0].EquSignal_Rgv;

                if (cs.DB521_H_Outside)
                {
                    var task = Current.TaskSet.FirstOrDefault(v => v.TASK_NO == rgv.DB521_TaskID_1 && (v.TASK_WKSTATUS == 3 || v.TASK_WKSTATUS == 7) && (v.TASK_COMTYPE == 1 || v.TASK_COMTYPE == 4 || v.TASK_COMTYPE == 5));
                    if (task == null)
                    {
                        //throw new Exception(string.Format("输送线[{0}]超高报警，未查询到任务,取消任务失败。", convNo));
                    }
                    else
                    {
                        //调用sp完成任务
                        string result = TryCachHelper.TryTranExecute((db) =>
                        {
                            db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 1, TASK_POSIDCUR = convNo, TASK_POSIDNEXT = convNo, TASK_RGVNO = "", TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                                     .Where(it => it.TASK_NO == task.TASK_NO)
                                     .ExecuteCommand();

                            //添加明细
                            string msg = string.Format("输送线[{0}]上料到穿梭车[{1}]任务[{2}]外检故障,重置任务。", convNo, rgvName, task.TASK_NO);
                            CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, msg);
                            string alaram = string.Format("托盘[{0}]超高报警", task.TASK_BOXBARCODE);
                            BaseWorkflow.AddLedErrorMsg(db, convNo, alaram, task.TASK_NO);
                        });
                        if (!string.IsNullOrWhiteSpace(result))
                        {
                            throw new Exception(result);
                        }
                    }

                    if (rgv.DB521_Finish_1 == false)
                    {
                        if (!Current.TaskSet.Any(v => v.TASK_RGVNO == rgvName && v.TASK_WKSTATUS == 7))
                        {
                            //穿梭车不存在任务，写入取消任务信号，PLC根据该信号写入穿梭车完成信号
                            if (!plc.Plc.WriteBits((ushort)plc.WriteDBName, (ushort)((cs.EquDbInfo_ReadWrite.DBReadIndox + 17) * 8 + 6), true))
                            {
                                throw new Exception(string.Format("输送线[{0}]任务[{0}]写入超高重置任务失败！", convNo, rgv.DB521_TaskID_2));
                            }
                            else
                            {
                                Log4netHelper.Logger_Info.InfoFormat("输送线[{0}]任务[{0}]写入超高重置任务成功！", convNo, rgv.DB521_TaskID_2);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        private void Conv_H_OutsideUpdateTaskEndAddress(string convNo,string endConvNo)
        {
            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_H_Outside)
                {
                    var task = Current.TaskSet.FirstOrDefault(v => (v.TASK_WKSTATUS == 9) && v.TASK_POSIDCUR == convNo && v.TASK_COMTYPE == 1);
                    if (task == null)
                    {
                        //throw new Exception(string.Format("输送线[{0}]超高报警，未查询到任务,取消任务失败。", convNo));
                    }
                    else
                    {
                        //调用sp完成任务
                        string result = TryCachHelper.TryTranExecute((db) =>
                        {
                            db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 2, TASK_POSIDNEXT = convNo, TASK_POSIDTO = endConvNo, TASK_RGVNO = "", TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                              .Where(it => it.TASK_NO == task.TASK_NO)
                              .ExecuteCommand();

                            //添加明细
                            string msg = string.Format("输送线[{0}]任务[{1}]外检超高故障,变更任务目标地址为[{2}]。", convNo, task.TASK_NO, endConvNo);
                            CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, msg);
                            string alaram = string.Format("托盘[{0}]超高报警,排出到异常口[{1}]人工处理。", task.TASK_BOXBARCODE, endConvNo);
                            BaseWorkflow.AddLedErrorMsg(db, convNo, alaram, task.TASK_NO);
                        });
                        if (!string.IsNullOrWhiteSpace(result))
                        {
                            throw new Exception(result);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 堆垛机出口输送线任务执行(任务目标地址的下个地址只支持单一地址)
        /// </summary>
        private void SrmOutConvExeTask(string plcName, string convNo, bool endPosIsCurConv = false)
        {
            try
            {
                string conv_2381 = "2381";//危废仓库出口
                string conv_2391 = "2391";//空调和小家电出库口
                int conv_2324 = 2324;//危废仓库出口
                string srmno = string.Empty;
                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 && cs.DB523_Fault == false)
                {
                    var taskSet = Current.TaskSet.Where(v => v.TASK_POSIDNEXT == convNo).ToList();

                    var task = taskSet.SingleOrDefault(v => v.TASK_WKSTATUS == (int)WkStatus.堆垛机完成);
                    if (task != null)
                    {
                        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
                        {
                            if (task.TASK_POSIDTO == conv_2381)//危废仓库出口
                            {
                                converywrite.Goodsend = conv_2324;
                            }
                            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 (routes.Any(v => v.ROUTE_SONPOS == Conv_2246) && routes.Any(v => v.ROUTE_SONPOS == Conv_2238))
                                    {
                                        converywrite.Goodsend = Convert.ToInt32(Conv_2246);
                                    }
                                    else
                                    {
                                        throw new Exception(string.Format("输送线[{0}]任务[{1}]请求该函数不支持多个分支输送地址，请编写扩展函数。", convNo, task.TASK_NO));
                                    }
                                }
                            }

                            if (task.TASK_POSIDTO == conv_2381 || task.TASK_POSIDTO == conv_2391)//危废仓库出口、小家电和冰箱出口
                            {
                                srmno = task.TASK_POSIDTO == conv_2381 ? "srm06" : "srm11";
                                //修改目标堆垛机和任务类型
                                if (task.TASK_SRMNO != srmno)
                                {
                                    //调用sp完成任务
                                    string result = TryCachHelper.TryTranExecute((db) =>
                                    {
                                        db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_COMTYPE = 4, TASK_SRMNO = srmno, 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_POSIDNEXT, msg);
                                    });
                                    if (string.IsNullOrWhiteSpace(result))
                                    {
                                        throw new Exception(string.Format("任务[{0}]去危废仓库变更堆垛机编号和任务类型失败。", task.TASK_NO));
                                    }
                                }
                            }
                        }
                        WriteInfoToConveyor(cs, converywrite);
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void ExecConvRequest(string convNo)
        {
            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_Res01)
                {
                    var task = SugarBase.DB.Queryable<WCS_TASK>().First(v => v.TASK_NO == cs.DB521_Tasknum && v.TASK_POSIDCUR == convNo && v.TASK_POSIDTO == convNo);
                    if (task != null)
                    {
                        string result = TryCachHelper.TryTranExecute((db) =>
                        {
                            //修改任务的目标地址
                            db.Updateable<WCS_TASK>(it => new WCS_TASK() { TASK_WKSTATUS = 2, TASK_POSIDTO = srm, TASK_EDITUSERNO = "WCS", TASK_EDITDATETIME = DateTime.Now })
                              .Where(it => it.TASK_NO == task.TASK_NO)
                              .ExecuteCommand();
                            string msg = string.Format("任务[{0}]超高报警处理完成，变更目标地址为[{1}]", task.TASK_NO, srm);
                            CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, srm, msg);
                        });
                        if (!string.IsNullOrWhiteSpace(result))
                        {
                            LogMessageHelper.RecordLogMessage(string.Format("任务[{0}]超高，变更目标地址失败，原因：[{1}]", task.TASK_NO, result));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }
        #endregion;

        #region 重写
        public override int ConveyorWriteTaskExecuteToMoreAddress(string convNo, WCS_TASK task, List<WCS_EQUIPMENTROUTE> routes)
        {
            int nextaddress = 0;
            if (convNo == Conv_2184 || convNo == Conv_Weigh_2056)
            {
                if (task.TASK_POSIDTO == srm)
                {
                    nextaddress = Convert.ToInt32(routes.FirstOrDefault(v => v.ROUTE_INOUTTYPE == ROUTE_INOUTTYPE_IN).ROUTE_SONPOS);
                }
                else
                {
                    nextaddress = Convert.ToInt32(routes.FirstOrDefault(v => v.ROUTE_INOUTTYPE == ROUTE_INOUTTYPE_OUT).ROUTE_SONPOS);
                }
            }
            else
            {
                throw new Exception(string.Format("输送线[{0}]申请任务[{1}]分配下一个地址失败。", convNo, task.TASK_NO));
            }
            return nextaddress;
        }
        #endregion;
    }
}