using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Windows.Forms;
using ICSharpCode.Core;
using System.Data;
using Mesnac.Action.ChemicalWeighing.Entity;
using System.Threading;
using System.Configuration;
using Mesnac.Action.ChemicalWeighing.Technical.PmtRecipe.entity;

namespace Mesnac.Action.ChemicalWeighing.ChemicalWeighingPlc
{
    /// <summary>
    /// 计划列表下传PLC辅助类
    /// </summary>
    public class PlcPlanHelper
    {
        #region 事件定义

        public static object sender = null;
        public static event EventHandler OnUpdatePlanStateFromPlc;
        public static event EventHandler AutoDownloadPlan;
        public static event EventHandler OnAutoAddPlan;
        public static event EventHandler OnChangePlan;

        #region 冠合修改
        public static event EventHandler GHAutoDownloadPlan;
        #endregion

        #endregion

        #region 字段定义

        private static string originalMixPlcPlanTableName = String.Empty;
        private static string originalMillPlcPlanTableName = String.Empty;

        #endregion

        #region 冠合计划自动下传
        public static bool GHDownloadPlanData()
        {
            try
            {
                //查询PLC状态，确认是否可以下发计划
                if (!(BasePlcHelper.Instance.GH_PC_ConfirmOnline.NowValue.ToInt() == 1 && BasePlcHelper.Instance.GH_PC_ConfirmRemote.NowValue.ToInt() == 1 && BasePlcHelper.Instance.GH_PC_ConfirmReady.NowValue.ToInt() == 1 && BasePlcHelper.Instance.GH_PC_ConfirmRun.NowValue.ToInt() == 0))
                {
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug("{生产计划-自动计划下传}  下位机信号未准备好...");
                }
                else
                {
                    //扫描计划表中的最先执行的计划
                    List<Product.PptPlan.entity.Base_PlanInfo> base_PlanListInfos =  Product.PptPlan.GhPlanHelper.GetPlanEntityListByNum(1);
                    if (base_PlanListInfos != null && base_PlanListInfos.Count > 0)
                    {
                       if(base_PlanListInfos[0].run_Type == 1)  //0-自动运行；1-手动运行,手动方式需要操作人点击“执行”按钮方可下达计划执行
                        {
                            return false;
                        }
                        else
                        {
                            //写入配方数据
                            //通过配方ID关联配方数据
                            if (WriteRecipeInfoToPLC(base_PlanListInfos[0]))    //配方下发成功
                            {
                                //更新计划界面
                                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug("{生产计划-自动计划下传}  自动计划下传成功...");
                            }
                            else    //配方下发失败
                            {
                                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("{生产计划-自动计划下传}  自动计划下传失败...");
                            }
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        #endregion
        public static bool WriteRecipeInfoToPLC(Product.PptPlan.entity.Base_PlanInfo base_PlanInfo)
        {
            try
            {
                Base_RecipeInfo info = Technical.PmtRecipe.RecipeHelper.GetRecipeById(base_PlanInfo.recipe_Id);
                var plan_Id = Convert.ToInt32(base_PlanInfo.plan_Id);

                object[] recipeidArray = Mesnac.Basic.DataProcessor.ToSiemensPLCDataArray(plan_Id);

                //计划编号
                bool resultPlanNoPlc = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_PlanNo, recipeidArray);
                //配方编号
                bool resultFromPlc = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_RecipeCode, new object[] {int.Parse(base_PlanInfo.recipe_Id) });
                //配方名称,测试暂用配方编号代替
                bool writeResult = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_RecipeName, new object[] { int.Parse(base_PlanInfo.recipe_Id) });
                //设定车数
                var writeResult1 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_SetCarNumber, new object[] { base_PlanInfo.car_Amount });
                //格数
                var writeResult2 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_SetGeNumber, new object[] { base_PlanInfo.grid_Amount });

                //层数
                var writeResult3 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_SetLineNumber, new object[] { base_PlanInfo.line_Amount });

                //通过配方编号获取物料信息、参数信息
                List<Base_RecipeMaterial> recipeMaterials = Technical.PmtRecipe.RecipeHelper.GetRecipeMaterialInfoByRecipeId(info.recipeId);

                //罐1
                //VCC加料
                //Base_RecipeMaterial recipeMaterial = recipeMaterials.Where(x => x.materialName.Contains("VCC")).FirstOrDefault();
                Base_RecipeMaterial recipeMaterial = recipeMaterials[0];
                decimal vccJl = recipeMaterial.materialWeight;
                var writeResult9 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_VCCJl, (float)vccJl);

                ////GFA加料
                //Base_RecipeMaterial recipeMaterial2 = recipeMaterials.Where(x => x.materialName.Contains("GFA")).FirstOrDefault();
                Base_RecipeMaterial recipeMaterial2 = recipeMaterials[1];
                decimal gfajl = recipeMaterial2.materialWeight;
                var writeResult10 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_GFAJl, (float)gfajl);

                ////树脂加料
                //Base_RecipeMaterial recipeMaterial3 = recipeMaterials.Where(x => x.materialName.Contains("树脂")).FirstOrDefault();
                Base_RecipeMaterial recipeMaterial3 = recipeMaterials[2];
                decimal szjl = recipeMaterial3.materialWeight;
                var writeResult11 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_SZJl, (float)szjl);

                //罐A2次加料
                Base_RecipeMaterial recipeMaterial4 = recipeMaterials[3];
                decimal vcc2th = recipeMaterial4.materialWeight;
                var writeResult20 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_VCC_2th, (float)vcc2th);

                //罐B2次加料
                Base_RecipeMaterial recipeMaterial5 = recipeMaterials[4];
                decimal gfa2th = recipeMaterial5.materialWeight;
                var writeResult21 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_GFA_2th, (float)gfa2th);


                //通过配方编号获取工艺参数信息
                List<Base_RecipeCratParam> recipeCratParams = Technical.PmtRecipe.RecipeHelper.GerCratParamListByRecipeAndMaterial(info.recipeId, string.Empty);

                //混料速度1
                Base_RecipeCratParam base_RecipeCratParam1 = recipeCratParams.Where(x => x.paramName.Contains("混料速度1")).FirstOrDefault();
                int hlsd1 = int.Parse(base_RecipeCratParam1.paramValue);
                var writeResult4 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Hlsd1, new object[] { hlsd1 });

                //混料速度2
                Base_RecipeCratParam base_RecipeCratParam2 = recipeCratParams.Where(x => x.paramName.Contains("混料速度2")).FirstOrDefault();
                int hlsd2 = int.Parse(base_RecipeCratParam2.paramValue);
                var writeResult5 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Hlsd2, new object[] { hlsd2 });

                //混料速度3
                Base_RecipeCratParam base_RecipeCratParam3 = recipeCratParams.Where(x => x.paramName.Contains("混料速度3")).FirstOrDefault();
                int hlsd3 = int.Parse(base_RecipeCratParam3.paramValue);
                var writeResult6 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Hlsd3, new object[] { hlsd3 });

                //进料时间
                Base_RecipeCratParam base_RecipeCratParam4 = recipeCratParams.Where(x => x.paramName.Contains("进料时间")).FirstOrDefault();
                int jlsj = int.Parse(base_RecipeCratParam4.paramValue);
                var writeResult7 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Jlsj, new object[] { jlsj });

                //混料时间
                Base_RecipeCratParam base_RecipeCratParam5 = recipeCratParams.Where(x => x.paramName.Contains("混料时间")).FirstOrDefault();
                int hlsj = int.Parse(base_RecipeCratParam5.paramValue);
                var writeResult8 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Hlsj, new object[] { hlsj });

                //VCC加料误差
                Base_RecipeCratParam base_RecipeCratParam6 = recipeCratParams.Where(x => x.paramName.Contains("罐A加料误差")).FirstOrDefault();
                decimal vccjlwc = decimal.Parse(base_RecipeCratParam6.paramValue);
                var writeResult12 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_VCCJlWc, (float)vccjlwc );

                //GFA加料误差
                Base_RecipeCratParam base_RecipeCratParam7 = recipeCratParams.Where(x => x.paramName.Contains("罐B加料误差")).FirstOrDefault();
                decimal gfajlwc = decimal.Parse(base_RecipeCratParam7.paramValue);
                var writeResult13 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_GFAJlWc, (float)gfajlwc);

                //树脂加料误差
                Base_RecipeCratParam base_RecipeCratParam8 = recipeCratParams.Where(x => x.paramName.Contains("树脂加料误差")).FirstOrDefault();
                decimal szjlwc = decimal.Parse(base_RecipeCratParam8.paramValue);
                var writeResult14 = BasePlcHelper.Instance.PlcWriteFloatByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_SZJlWc, (float)szjlwc);

                //配方下传完成
                var writeResult15 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_RpFinished, new object[] { true });
                //计划下传成功后需要修改计划状态为执行中
                base_PlanInfo.plan_State = 1;
                base_PlanInfo.plan_beginTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

                Product.PptPlan.PlanHelper.UpdateBasePlanStateInfo(base_PlanInfo);
                
                if (GHAutoDownloadPlan != null)
                {
                    GHAutoDownloadPlan(sender, System.EventArgs.Empty);
                }
                
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        #region 下传计划列表至PLC

        /// <summary>
        /// 下传计划列表至PLC
        /// </summary>
        /// <param name="msgList">输出消息列表</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool DownloadPlanData(List<string> msgList)
        {
            bool result = true;
            List<Entity.RT_Plan> list = null;
            //if (Global.PublicVar.Instance.ChemicalWeighingPlcOnlineFlag)    //|| Global.PublicVar.Instance.IsLocalTest)
            if (true)
            {
                if (result)
                {
                    if (list == null)
                    {
                        list = Product.PptPlan.PlanHelper.GetUnExePlanEntityList(1);
                    }
                    result = DownloadPlanDataToChe(list, msgList);
                }
            }

            return result;
        }

        /// <summary>
        /// 下传计划列表至PLC(自动)
        /// </summary>
        /// <param name="msgList">输出消息列表</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool AutoDownloadPlanData(List<string> msgList)
        {
            bool result = true;
            List<Entity.RT_Plan> list = null;

            #region 读取应答信号

            if (!(BasePlcHelper.Instance.ChemicalWeighing_PLC_LoadingStatus.NowValue.ToInt() == 1 && BasePlcHelper.Instance.ChemicalWeighing_PC_LoadingStatus.NowValue.ToInt() == 0))
            {
                return false;
            }

            #endregion

            if (result)
            {
                if (list == null)
                {
                    list = Product.PptPlan.PlanHelper.GetUnExePlanEntityList(1);
                }
                result = DownloadPlanDataToChe(list, msgList);
            }

            return result;
        }

        #region 下传计划列表至小料PLC

        /// <summary>
        /// 下传计划列表至小料PLC
        /// </summary>
        /// <param name="list">计划列表</param>
        /// <param name="msgList">输出的消息列表</param>
        /// <returns>成功返回true，失败返回flase</returns>
        public static bool DownloadPlanDataToChe(List<Entity.RT_Plan> list, List<string> msgList)
        {
            try
            {
                #region 定义变量

                //int cnt = 0;            //循环计数
                string msg = String.Empty;
                List<Int16> writeDataList = new List<Int16>();
                PropertyInfo[] ps = typeof(RT_Plan).GetProperties();
                PropertyInfo[] psMaterial = typeof(Pmt_weigh).GetProperties();
                List<Pmt_weigh> listMaterial = new List<Pmt_weigh>();   //计划对应的配方对应的物料列表
                Pmt_recipe currentPmtRecipe = new Pmt_recipe(); //当前配方
                RT_Plan nextRTPlan = null;  //下一条计划
                Pmt_recipe nextPmtRecipe = null; //当前配方
                bool planDownFlag = false;

                if (msgList == null)
                {
                    msgList = new List<string>();
                }

                #endregion

                #region 验证处理-配置

                if (list == null || list.Count == 0)
                {
                    msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg40"));          //小料-计划信息下传PLC失败：无可下传计划!
                    msgList.Add(msg);
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    return false;
                }

                List<PlcWriter> writerList = PlcSchemaHelper.Instance.GetPlcWriter("PlanRecipeData");   //配方头数据
                if (writerList == null || writerList.Count == 0)
                {
                    msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg10"));          //小料-计划信息下传PLC失败：在PlcSchema.xml中没有RT_Plan配置节!
                    msgList.Add(msg);
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    return false;
                }

                List<PlcWriter> writerList1 = PlcSchemaHelper.Instance.GetMaterialPlcWriter("PlanMaterialData");   //物料数据
                if (writerList == null || writerList.Count == 0)
                {
                    msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg10"));          //小料-计划信息下传PLC失败：在PlcSchema.xml中没有RT_Plan配置节!
                    msgList.Add(msg);
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    return false;
                }

                writerList = writerList.Concat(writerList1).ToList();

                #endregion

                #region 验证处理-数据

                if (list == null || list.Count == 0)
                {
                    msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg15"));          //小料-计划信息下传PLC失败：当班计划列表为空!
                    msgList.Add(msg);
                    return false;
                }
                else
                {
                    #region 根据配方recipeID获取物料信息

                    string recipeID = list[0].Recipe_ID;
                    listMaterial = Product.PptPlan.PlanHelper.GetPmt_weighList(recipeID);
                    if(listMaterial != null)
                    {
                        Global.PublicVar.Instance.currentListPmt_weigh = listMaterial;
                    }

                    #endregion

                    #region 根据配方recipeID获取配方信息

                    currentPmtRecipe = Technical.PmtRecipe.RecipeHelper.GetRecipeEntityByGUID(recipeID);

                    #endregion

                    #region 获取下一配方信息

                    nextRTPlan = Product.PptPlan.PlanHelper.GetNextPlan((int)list[0].Plan_Serial);
                    if(nextRTPlan != null){
                        nextPmtRecipe = Technical.PmtRecipe.RecipeHelper.GetRecipeEntityByGUID(nextRTPlan.Recipe_ID);
                    }
                    
                    #endregion
                }

                #endregion

                #region 业务处理

                foreach (PlcWriter writer in writerList)
                {
                    writeDataList.Clear();

                    #region 验证处理

                    if (writer.EquipRunName != "Recipe_Data_Download_BaseInf" && writer.EquipRunName != "Hopper_Recipe_Detail_Inf")
                    {
                        continue;
                    }

                    #endregion

                    #region 获取PLC品牌名称，处理西门子与其他PLC差异

                    string equipBrand = Mesnac.Equips.Factory.Instance.GetEquipBrandByRunName(writer.EquipRunName);
                    writer.EquipBrand = equipBrand;

                    #endregion

                    #region 整理数据

                    if (writer.EquipRunName == "Recipe_Data_Download_BaseInf")
                    {
                        Entity.RT_Plan entity = null;

                        for (int i = 0; i < writer.ThisCount; i++)
                        {
                            if (list != null && i < list.Count)
                            {
                                entity = list[i];
                                DateTime timeNow = DateTime.Now;
                                foreach (PlcWriteItem item in writer.SchemaList)
                                {
                                    item.ClearData();
                                    item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                    foreach (PropertyInfo pi in ps)
                                    {
                                        if (item.DataFieldName == pi.Name)
                                        {
                                            item.SetValue = pi.GetValue(entity, null);
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Year")
                                        {
                                            item.SetValue = timeNow.Year;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Month")
                                        {
                                            item.SetValue = timeNow.Month;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Date")
                                        {
                                            item.SetValue = timeNow.Day;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Hour")
                                        {
                                            item.SetValue = timeNow.Hour;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Minute")
                                        {
                                            item.SetValue = timeNow.Minute;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_H_Second")
                                        {
                                            item.SetValue = timeNow.Second;
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_MachineCode")
                                        {
                                            item.SetValue = "01";
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_TotalSetWeight")
                                        {
                                            if (currentPmtRecipe != null && currentPmtRecipe.Total_Weight != null)
                                            {
                                                item.SetValue = Convert.ToInt32(currentPmtRecipe.Total_Weight * 1000);
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_TotalErrorWeight")
                                        {
                                            if (currentPmtRecipe != null && currentPmtRecipe.Total_Error != null)
                                            {
                                                item.SetValue = Convert.ToInt32(currentPmtRecipe.Total_Error * 1000);
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_1LOT")
                                        {
                                            if (currentPmtRecipe != null && currentPmtRecipe.GroupBags != null)
                                            {
                                                item.SetValue = (Int32)currentPmtRecipe.GroupBags;
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_NextPlanCode")
                                        {
                                            if (nextPmtRecipe != null && nextPmtRecipe.Recipe_Name != null)
                                            {
                                                item.SetValue = nextPmtRecipe.Recipe_Name;
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_NextTotalSetWeight")
                                        {
                                            if (nextPmtRecipe != null && nextPmtRecipe.Total_Weight != null)
                                            {
                                                item.SetValue = Convert.ToInt32(nextPmtRecipe.Total_Weight * 1000);
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_NextPlanNum")
                                        {
                                            if (nextRTPlan != null && nextRTPlan.Plan_Num != null)
                                            {
                                                item.SetValue = Convert.ToInt32(nextRTPlan.Plan_Num);
                                            }
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_SeparateNum")
                                        {
                                            if (entity != null && entity.Plan_Num != null)
                                            {
                                                item.SetValue = entity.Plan_Num;            //后期会有配置项进行设置
                                            }
                                            break;
                                        }
                                    }
                                    writeDataList.AddRange(item.WriteData());
                                }
                            }
                            else
                            {
                                foreach (PlcWriteItem item in writer.SchemaList)
                                {
                                    item.ClearData();
                                    item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                    writeDataList.AddRange(item.WriteData());
                                }
                            }

                        }
                    }

                    if (writer.EquipRunName == "Hopper_Recipe_Detail_Inf")
                    {
                        Pmt_weigh entity = null;

                        for (int i = 0; i < writer.ThisCount; i++)
                        {
                            if (listMaterial != null && i < listMaterial.Count)
                            {
                                entity = listMaterial[i];
                                DateTime timeNow = DateTime.Now;
                                foreach (PlcWriteItem item in writer.SchemaList)
                                {
                                    item.ClearData();
                                    item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                    foreach (PropertyInfo pi in psMaterial)
                                    {
                                        if (item.DataFieldName == pi.Name)
                                        {
                                            item.SetValue = pi.GetValue(entity, null);
                                            if (item.DataFieldName == "Set_Weight" || item.DataFieldName == "Set_Error")
                                            {
                                                object temd = item.SetValue;
                                                item.SetValue = Convert.ToDouble(temd) * 1000;
                                            }
                                            else if (item.DataFieldName == "Weight_Id")
                                            {
                                                object temd = item.SetValue;
                                                item.SetValue = Convert.ToInt32(temd) - 1;
                                            } 
                                            break;
                                        }
                                        else if (item.EquipRunName == "DownLoad_BinNo")
                                        {
                                            Pmt_Bin pmtBin = Product.PptPlan.PlanHelper.GetPmt_Bin(entity.Material_ID);
                                            if (pmtBin != null && pmtBin.Bin_Serial != null)
                                            {
                                                item.SetValue = pmtBin.Bin_Serial;
                                            }
                                            else
                                            {
                                                item.SetValue = 100;    //对应手动秤功能
                                            }
                                            break;
                                        }
                                    }
                                    writeDataList.AddRange(item.WriteData());
                                }
                            }
                            else
                            {
                                foreach (PlcWriteItem item in writer.SchemaList)
                                {
                                    item.ClearData();
                                    item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                    writeDataList.AddRange(item.WriteData());
                                }
                            }

                        }
                    }

                    #endregion

                    #region 下传数据

                    object[] buff = new object[writeDataList.Count];
                    Array.Copy(writeDataList.ToArray(), buff, buff.Length);

                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]开始下传计划信息...", writer.EquipRunName));
                    if (!BasePlcHelper.Instance.PlcWriteByRunName(writer.EquipRunName, buff))
                    {
                        msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg50"));          //小料-计划信息下传PLC[{0}]失败...
                        msg = String.Format(msg, writer.EquipRunName);
                        msgList.Add(msg);
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                        return false;
                    }
                    else
                    {
                        planDownFlag = true;
                    }
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]计划信息下传完毕...", writer.EquipRunName));

                    #endregion
                   
                }

                #endregion

                #region 交互逻辑

                if (planDownFlag)
                {
                    
                    #region 下传请求信号

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_LoadingStatus, new object[] { 1 });
                    if (!result)
                    {
                        msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg20"));     //小料-计划信息下传PLC：向PLC下传请求信号失败!
                        msgList.Add(msg);
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                        return false;
                    }

                    #endregion

                    #region 数据下传完成后，将该条计划的状态更改为已下传

                    Product.PptPlan.PlanHelper.UpdatePlanState(list[0].Plan_Id, 4);
                    planDownFlag = false;

                    #endregion

                    if (AutoDownloadPlan != null)
                    {
                        AutoDownloadPlan(sender, System.EventArgs.Empty);
                    }
                }

                #endregion

                return true;
            }
            catch (Exception ex)
            {
                msgList.Add(ex.Message);
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(ex.Message, ex);
                return false;
            }
            finally
            {
                #region 交互逻辑

                if (Global.PublicVar.Instance.PlcDownloadMode == 1)
                {
                    //#region 清除请求信号

                    //bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.Mix_SysAction_ExchPlanInfoRep_Req, new object[] { 0 });
                    //if (!result)
                    //{
                    //    BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.Mix_SysAction_ExchPlanInfoRep_Req, new object[] { 0 });
                    //}

                    //#endregion
                }

                #endregion
            }
        }

        #endregion

        #endregion



        #region 获取PLC计划列表中某条计划中允许修改的最小车数

        /// <summary>
        /// 获取上辅机PLC计划列表中某条计划中允许修改的最小车数
        /// </summary>
        /// <param name="planID">要获取的允许最小车数的计划号</param>
        /// <returns>返回对应计划号的最小车数</returns>
        //public static int GetMixMinPlanNumFromPlc(string planID)
        //{
        //    DataTable dt = BasePlcHelper.Instance.Mix_PlanState_PlcPlanList.LastValue.ToObject() as DataTable;
        //    if (dt != null && dt.Rows.Count > 0)
        //    {
        //        foreach(DataRow dr in dt.Rows)
        //        {
        //            if (Mesnac.Basic.DataProcessor.RowValue(dr, "PlanID", String.Empty) == planID)
        //            {
        //                return Mesnac.Basic.DataProcessor.RowValue(dr, "NumModifyMin", 0);
        //            }
        //        }
        //        return 0;
        //    }
        //    else
        //    {
        //        return 0;
        //    }
        //}

        #endregion

        #region 获取PLC计划列表中某条计划的计划数

        /// <summary>
        /// 获取PLC计划列表中某条计划的计划数
        /// </summary>
        /// <param name="planID">计划编号</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns>返回对应计划号的计划数</returns>
        //public static int GetMixPlanNumFromPlc(string planID, int defaultValue)
        //{
        //    DataTable dt = BasePlcHelper.Instance.Mix_PlanState_PlcPlanList.LastValue.ToObject() as DataTable;
        //    if (dt != null && dt.Rows.Count > 0)
        //    {
        //        foreach (DataRow dr in dt.Rows)
        //        {
        //            if (Mesnac.Basic.DataProcessor.RowValue(dr, "PlanID", String.Empty) == planID)
        //            {
        //                return Mesnac.Basic.DataProcessor.RowValue(dr, "PlanNum", defaultValue);
        //            }
        //        }
        //        return defaultValue;
        //    }
        //    else
        //    {
        //        return defaultValue;
        //    }
        //}

        #endregion

        #region 把PLC的计划状态更新至数据库

        /// <summary>
        /// 把PLC的计划状态更新至数据库
        /// </summary>
        public static void UpdatePlanStateFromPlc()
        {
            try
            {
                bool flag = false;

                #region 小料同步计划状态和完成数

                if (BasePlcHelper.Instance.ChemicalWeighing_PLC_Plan_Status_ShakeHand.NowValue.ToInt() == 1 && BasePlcHelper.Instance.ChemicalWeighing_PLC_Plan_Status_FeedBack.NowValue.ToInt() == 0)
                {
                    int planSerial = BasePlcHelper.Instance.ChemicalWeighing_Plan_Serial.NowValue.ToInt();      //计划序号
                    int planState = BasePlcHelper.Instance.ChemicalWeighing_Plan_Status.NowValue.ToInt();       //计划状态
                    int planNum = BasePlcHelper.Instance.ChemicalWeighing_Plan_Number.NowValue.ToInt();         //计划数量
                    int planRestNum = BasePlcHelper.Instance.ChemicalWeighing_Remain_Number.NowValue.ToInt();   //剩余数量
                    int planComNum = planNum - planRestNum;                                                     //完成数量

                    if (planState == (int)Entity.PlanState.Received)
                    {
                        Product.PptPlan.PlanHelper.UpdatePlanInfo(planSerial, planState, planNum, planComNum);
                    }
                    else if (planState == (int)Entity.PlanState.Completed)
                    {
                        Product.PptPlan.PlanHelper.UpdatePlanInfo(planSerial, planState, planNum, planComNum,DateTime.Now.ToString());
                    }
                    else
                    {
                        return;
                    }
                    
                    flag = true;

                    //PlanListReDown();20211205三元现场注释掉

                    #region 此处需要将RT_Plan中计划写入到LR_Plan中，同时向LR_Recipe中存储信息

                    RT_Plan rtPlan = Product.PptPlan.PlanHelper.GetPlanDataEntity(planSerial);
                    if (rtPlan != null)
                    {
                        LR_plan lrPlan = new LR_plan();
                        Product.PptPlan.PlanHelper.EntityToEntity(rtPlan, lrPlan);
                        if (Product.PptPlan.PlanHelper.LRPlanExists(lrPlan.Plan_Id))
                        {
                            //更新
                            if (planState == (int)Entity.PlanState.Received)
                            {
                                Product.PptPlan.PlanHelper.LRUpdatePlanInfo(lrPlan.Plan_Id, planState, planNum, planComNum);
                            }
                            else if (planState == (int)Entity.PlanState.Completed)
                            {
                                Product.PptPlan.PlanHelper.LRUpdatePlanInfo(lrPlan.Plan_Id, planState, planNum, planComNum, DateTime.Now.ToString());

                                #region 执行删除计划操作

                                Product.PptPlan.PlanHelper.DeletePlan(rtPlan.Plan_Id);

                                #endregion
                            }
                        }
                        else
                        {
                            //添加(LR_plan)
                            Product.PptPlan.PlanHelper.LRAddPlan(lrPlan);

                            //添加(LR_recipe)
                            LR_recipe lrRecipe = new LR_recipe();
                            lrRecipe.Plan_id = rtPlan.Plan_Id;
                            lrRecipe.Equip_Code = rtPlan.Equip_Code;

                            string recipeID = rtPlan.Recipe_ID;
                            List<Pmt_weigh> listPmtWeigh = Product.PptPlan.PlanHelper.GetPmt_weighList(recipeID);
                            foreach (Pmt_weigh tempPW in listPmtWeigh)
                            {
                                lrRecipe.Weight_ID = tempPW.Weight_Id - 1;
                                lrRecipe.Set_Weight = (float)tempPW.Set_Weight;
                                lrRecipe.Set_Error = (float)tempPW.Set_Error;
                                lrRecipe.CPK_Error = (decimal)0;

                                Base_MaterialInfo pmtMaterial = Product.PptPlan.PlanHelper.GetPmt_material(tempPW.Material_ID);
                                if (pmtMaterial != null)
                                {
                                    lrRecipe.Material_Code = pmtMaterial.materialId;
                                    lrRecipe.Material_Name = pmtMaterial.materialName;
                                    lrRecipe.Batch_number = pmtMaterial.putTime.ToString();
                                    lrRecipe.remark = null;
                                    Product.PptPlan.PlanHelper.AddLR_recipe(lrRecipe);
                                }
                            }
                        }
                    }

                    #endregion
                }   
                
                #endregion

                #region 触发事件

                if (flag)
                {
                    #region 下传请求信号

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PLC_Plan_Status_FeedBack, new object[] { 1 });
                    if (!result)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg30"));     //小料-计划信息下传PLC：向PLC下传计划状态请求信号失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    #endregion


                    #region 判断等待计划数和正在运行的计划数。如果两个都是0，清空RT_Plan表。

                    int waitPlanCount = Product.PptPlan.PlanHelper.GetUnExePlanNum();
                    int runningPlanCount = Product.PptPlan.PlanHelper.GetRunningPlanNum();
                    int downPlanCount = Product.PptPlan.PlanHelper.GetDownPlanNum();
                    if (waitPlanCount == 0 && runningPlanCount == 0 && downPlanCount == 0)
                    {
                        Product.PptPlan.PlanHelper.ClearRT_Plan();
                    }

                    #endregion

                    if (OnUpdatePlanStateFromPlc != null)
                    {
                        OnUpdatePlanStateFromPlc(sender, System.EventArgs.Empty);
                    }
                }

                #endregion
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("把PLC的计划状态更新至数据库异常：" + ex.Message, ex);
            }
            finally
            {
                Global.PublicVar.Instance.LocalPlanIsRefresh = false;
            }
        }

        #endregion

        #region 处理HMI的配方添加计划请求

        /// <summary>
        /// 处理HMI的配方添加计划请求
        /// </summary>
        public static void AutoAddPlan()
        {
            try
            {
                bool flag = false;

                #region 读取并处理HMI的配方添加计划请求（添加计划）

                if (BasePlcHelper.Instance.ChemicalWeighing_HMI_Confirm_Recipe_ShakeHand.NowValue.ToInt() == 1 && (BasePlcHelper.Instance.ChemicalWeighing_HMI_Confirm_Recipe_FeedBack.NowValue.ToInt() <= 0 || BasePlcHelper.Instance.ChemicalWeighing_HMI_Confirm_Recipe_FeedBack.NowValue.ToInt() == 65535))
                {
                    #region 从PLC中获取要添加的计划信息

                    String sysMachine = BasePlcHelper.Instance.ChemicalWeighing_Sys_Machine1.NowValue.ToString();        //机台号
                    String recipeName = BasePlcHelper.Instance.ChemicalWeighing_Plan_Code1.NowValue.ToString();          //配方名称
                    int hmiPlanNum = BasePlcHelper.Instance.ChemicalWeighing_HMI_Plan_Num.NowValue.ToInt();              //设定数量

                    if (String.IsNullOrEmpty(sysMachine))
                    {
                        sysMachine = "01";
                    }

                    #endregion

                    #region 补全计划信息

                    DateTime planDate = DateTime.Now;                                   //当前计划日期
                    int shiftId = Technical.TechnicalHelper.GetCurrentShiftime();       //当前班次号

                    Base_RecipeInfo pmtRecipe = Technical.PmtRecipe.RecipeHelper.GetRecipeByName(recipeName);
                    string recipeId = null;
                    if (pmtRecipe != null && pmtRecipe.recipeId != null)
                    {
                        recipeId = pmtRecipe.recipeId;
                    }
                    else
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_6"));     //HMI添加计划请求：没有找到相关配方的信息!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);

                        #region 下传反馈失败的信号

                        bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_HMI_Confirm_Recipe_FeedBack, new object[] { 3 });
                        if (!result)
                        {
                            string msg1 = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_7"));     //HMI添加计划请求：没有找到相关配方的信息时，写反馈信号失败!
                            ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg1);
                        }

                        #endregion

                        return;
                    }

                    #endregion

                    #region 执行添加计划操作

                    string planID = Product.PptPlan.PlanHelper.AddPlan(sysMachine, planDate, shiftId, recipeId, hmiPlanNum);
                    flag = true;

                    #region 将等待计划数写入PLC

                    //WaitPlanNumToPLC();

                    #endregion

                    #endregion

                    #region 触发事件

                    if (OnAutoAddPlan != null)
                    {
                        OnAutoAddPlan(sender, System.EventArgs.Empty);
                    }

                    #endregion

                    #region 记录日志

                    string logContent = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_1"));          //计划编号：{0}，HMI请求添加完毕!
                    logContent = String.Format(logContent, planID);
                    //base.DBLog(logContent); cfm20210729暂时注释

                    #endregion
                    
                }

                #endregion

                #region HMI添加计划请求交互，并向PLC写入计划列表数据

                if (flag)
                {
                    #region 下传请求信号

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_HMI_Confirm_Recipe_FeedBack, new object[] { 1 });
                    if (!result)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_2"));     //HMI添加计划请求成功后：向PLC下传反馈信号失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    #endregion

                    #region 向PLC写入计划列表数据

                    #region 定义变量

                    List<Int16> writeDataList = new List<Int16>();
                    PropertyInfo[] ps = typeof(RT_Plan).GetProperties();
                    List<RT_Plan> rtPlanList = Product.PptPlan.PlanHelper.GetPlanEntityListByNum(5);

                    #endregion

                    #region 验证处理-配置

                    if (rtPlanList == null || rtPlanList.Count == 0)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_3"));     //HMI添加计划请求成功后：计划列表获取失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    List<PlcWriter> writerList = PlcSchemaHelper.Instance.GetPlcWriter("PlanListData");   //计划列表数据
                    if (writerList == null || writerList.Count == 0)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_4"));     //HMI添加计划请求成功后：计划列表写入数据结构获取失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    #endregion

                    #region 业务处理

                    foreach (PlcWriter writer in writerList)
                    {
                        writeDataList.Clear();

                        #region 验证处理

                        if (writer.EquipRunName != "PlanList_Info")
                        {
                            continue;
                        }

                        #endregion

                        #region 获取PLC品牌名称，处理西门子与其他PLC差异

                        string equipBrand = Mesnac.Equips.Factory.Instance.GetEquipBrandByRunName(writer.EquipRunName);
                        writer.EquipBrand = equipBrand;

                        #endregion

                        #region 整理数据

                        if (writer.EquipRunName == "PlanList_Info")
                        {
                            Entity.RT_Plan entity = null;

                            for (int i = 0; i < writer.ThisCount; i++)
                            {
                                if (rtPlanList != null && i < rtPlanList.Count)
                                {
                                    entity = rtPlanList[i];
                                    DateTime timeNow = DateTime.Now;
                                    foreach (PlcWriteItem item in writer.SchemaList)
                                    {
                                        item.ClearData();
                                        item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                        foreach (PropertyInfo pi in ps)
                                        {
                                            if (item.DataFieldName == pi.Name)
                                            {
                                                item.SetValue = pi.GetValue(entity, null);
                                                break;
                                            }
                                            else if (item.EquipRunName == "DownLoad_MachineCode")
                                            {
                                                item.SetValue = "01";
                                                break;
                                            }
                                        }
                                        writeDataList.AddRange(item.WriteData());
                                    }
                                }
                            }
                        }

                        if (writeDataList.Count < 200)
                        {
                            int fillNum = 200 - writeDataList.Count;
                            for (int i = 0; i < fillNum; i++)
                            {
                                writeDataList.AddRange(new short[] { 0 });
                            }
                        }

                        #endregion

                        #region 下传数据

                        object[] buff = new object[writeDataList.Count];
                        Array.Copy(writeDataList.ToArray(), buff, buff.Length);

                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]开始下传计划信息...", writer.EquipRunName));
                        if (!BasePlcHelper.Instance.PlcWriteByRunName(writer.EquipRunName, buff))
                        {
                            string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_5"));     //HMI添加计划请求成功后：计划列表写入PLC失败!
                            ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                        }
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]计划列表信息下传完毕...", writer.EquipRunName));

                        #endregion

                    }

                    #endregion

                    #endregion
                }

                #endregion
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("把PLC的计划状态更新至数据库异常：" + ex.Message, ex);
            }
            finally
            {
                Global.PublicVar.Instance.LocalPlanIsRefresh = false;
            }
        }

        #endregion

        #region 处理HMI的修改计划请求

        /// <summary>
        /// 处理HMI的修改计划请求
        /// </summary>
        public static void ChangePlan()
        {
            try
            {
                bool flag = false;

                #region 读取并处理HMI的配方添加计划请求（添加计划）

                if (BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_ShakeHand.NowValue.ToInt() == 1 && (BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_FeedBack.NowValue.ToInt() <= 0 || BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_FeedBack.NowValue.ToInt() == 65535))
                {
                    #region 从PLC中获取要添加的计划信息

                    int planCommand = BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_Command.NowValue.ToInt();       //命令
                    String sysMachine = BasePlcHelper.Instance.ChemicalWeighing_Sys_Machine2.NowValue.ToString();                       //机台号 
                    int[] planIdData;
                    BasePlcHelper.Instance.PlcRead(BasePlcHelper.Instance.ChemicalWeighing_HMIChange_PlanId, out planIdData);
                    string planId = Mesnac.Basic.DataProcessor.ToString1(planIdData);                                                   //计划
                    int ChangePlanNum = BasePlcHelper.Instance.ChemicalWeighing_HMIChange_PlanNum.NowValue.ToInt();                     //设定数量

                    if (String.IsNullOrEmpty(sysMachine))
                    {
                        sysMachine = "01";
                    }

                    #endregion

                    #region 验证(PLC中读取过来的planid对应的数据库中的计划必须是存在的)

                    RT_Plan currentRT_Plan = Product.PptPlan.PlanHelper.GetPlanDataEntity(planId);

                    if (currentRT_Plan == null)
                    {
                        ChangePlanErrorReturn();
                        return;
                    }

                    #endregion

                    #region 判断命令（0默认 1刷新 2上移 3下移 4修改车数 5删除计划）并执行操作

                    if (planCommand == 1)
                    {
                        //刷新事件，将最新的计划列表重写入PLC。

                    }
                    else if (planCommand == 2)
                    {
                        #region 获取交换位置对象并判断是否可以上移（条件：在该条计划前，是否有一条未运行中的计划）并执行上移

                        int swagPlanSerial = (int)currentRT_Plan.Plan_Serial - 1;
                        RT_Plan swagRtPLan = Product.PptPlan.PlanHelper.GetPlanBySerialUp(swagPlanSerial);
                        if (swagRtPLan == null)
                        {
                            ChangePlanErrorReturn();
                            return;
                        }
                        else
                        {
                            currentRT_Plan.Plan_Serial = currentRT_Plan.Plan_Serial - 1;
                            swagRtPLan.Plan_Serial = swagRtPLan.Plan_Serial + 1;
                            Product.PptPlan.PlanHelper.UpdatePlanSerial(currentRT_Plan);
                            Product.PptPlan.PlanHelper.UpdatePlanSerial(swagRtPLan);

                            #region 重新下传计划列表

                            flag = PlanListReDown();

                            #endregion
                        }
                        
                        #endregion
                    }
                    else if (planCommand == 3)
                    {
                        #region 获取交换位置对象并判断是否可以下移（条件：在该条计划后，是否有一条未运行中的计划）并执行下移

                        int swagPlanSerial = (int)currentRT_Plan.Plan_Serial + 1;
                        RT_Plan swagRtPLan = Product.PptPlan.PlanHelper.GetPlanBySerialDown(swagPlanSerial);
                        if (swagRtPLan == null)
                        {
                            ChangePlanErrorReturn();
                            return;
                        }
                        else
                        {
                            currentRT_Plan.Plan_Serial = currentRT_Plan.Plan_Serial + 1;
                            swagRtPLan.Plan_Serial = swagRtPLan.Plan_Serial - 1;
                            Product.PptPlan.PlanHelper.UpdatePlanSerial(currentRT_Plan);
                            Product.PptPlan.PlanHelper.UpdatePlanSerial(swagRtPLan);

                            #region 重新下传计划列表

                            flag = PlanListReDown();

                            #endregion
                        }

                        #endregion
                    }
                    else if (planCommand == 4)
                    {
                        #region 执行修改计划操作

                        Product.PptPlan.PlanHelper.UpdatePlanNum(planId, ChangePlanNum);

                        #endregion

                        #region 重新下传计划列表

                        flag = PlanListReDown();

                        #endregion
                    }
                    else if (planCommand == 5)
                    {
                        #region 获取计划号对应的序号

                        int delSerial = (int)currentRT_Plan.Plan_Serial;

                        #endregion

                        #region 执行删除计划操作

                        Product.PptPlan.PlanHelper.DeletePlan(planId);

                        #endregion

                        #region 整理修改后续计划的序号（-1）

                        List<RT_Plan> mRtPlan = Product.PptPlan.PlanHelper.GetPlanListAfterPlanSerial(delSerial);
                        if (mRtPlan != null && mRtPlan.Count > 0)
                        {
                            foreach (RT_Plan tempRT in mRtPlan)
                            {
                                tempRT.Plan_Serial = tempRT.Plan_Serial - 1;
                                Product.PptPlan.PlanHelper.UpdatePlanSerial(tempRT);
                            }
                        }

                        #endregion

                        #region 将等待计划数写入PLC

                        //WaitPlanNumToPLC();

                        #endregion

                        #region 重新下传计划列表

                        flag = PlanListReDown();

                        #endregion
                    }
                    else
                    {
                        //默认

                    }

                    #endregion 

                    #region 触发事件

                    if (OnChangePlan != null)
                    {
                        OnChangePlan(sender, System.EventArgs.Empty);
                    }

                    #endregion
                }

                #endregion

                #region HMI修改计划请求交互

                if (flag)
                {
                    #region 下传请求信号

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_FeedBack, new object[] { 1 });
                    if (!result)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ChangePlan_logContent_1"));     //HMI修改计划请求成功后：向PLC下传反馈信号失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    #endregion
                }

                #endregion
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("从HMI修改计划异常：" + ex.Message, ex);
            }
        }

        #endregion

        #region 修改计划出现异常反馈到PLC
        public static void ChangePlanErrorReturn()
        {
            bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_HMI_Request_Recipe_Change_FeedBack, new object[] { 3 });
            if (!result)
            {
                string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ChangePlan_logContent_2"));     //HMI修改计划请求成功后：向PLC下传异常反馈信号失败!
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
            }
        }
        #endregion

        #region 执行完修改计划操作后重新向PLC写入计划列表数据
        public static bool PlanListReDown()
        {
            #region 定义变量

            bool reFlag = false;
            List<Int16> writeDataList = new List<Int16>();
            PropertyInfo[] ps = typeof(RT_Plan).GetProperties();
            List<RT_Plan> rtPlanList = Product.PptPlan.PlanHelper.GetPlanEntityListByNum(5);

            #endregion

            #region 验证处理-配置

            if (rtPlanList == null || rtPlanList.Count == 0)
            {
                string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_3"));     //HMI添加计划请求成功后：计划列表获取失败!
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
            }

            List<PlcWriter> writerList = PlcSchemaHelper.Instance.GetPlcWriter("PlanListData");   //计划列表数据
            if (writerList == null || writerList.Count == 0)
            {
                string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_4"));     //HMI添加计划请求成功后：计划列表写入数据结构获取失败!
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
            }

            #endregion

            #region 业务处理

            foreach (PlcWriter writer in writerList)
            {
                writeDataList.Clear();

                #region 验证处理

                if (writer.EquipRunName != "PlanList_Info")
                {
                    continue;
                }

                #endregion

                #region 获取PLC品牌名称，处理西门子与其他PLC差异

                string equipBrand = Mesnac.Equips.Factory.Instance.GetEquipBrandByRunName(writer.EquipRunName);
                writer.EquipBrand = equipBrand;

                #endregion

                #region 整理数据

                if (writer.EquipRunName == "PlanList_Info")
                {
                    Entity.RT_Plan entity = null;

                    for (int i = 0; i < writer.ThisCount; i++)
                    {
                        if (rtPlanList != null && i < rtPlanList.Count)
                        {
                            entity = rtPlanList[i];
                            DateTime timeNow = DateTime.Now;
                            foreach (PlcWriteItem item in writer.SchemaList)
                            {
                                item.ClearData();
                                item.EquipBrand = equipBrand;               //设置PLC设备品牌
                                foreach (PropertyInfo pi in ps)
                                {
                                    if (item.DataFieldName == pi.Name)
                                    {
                                        item.SetValue = pi.GetValue(entity, null);
                                        break;
                                    }
                                    else if (item.EquipRunName == "DownLoad_MachineCode")
                                    {
                                        item.SetValue = "01";
                                        break;
                                    }
                                }
                                writeDataList.AddRange(item.WriteData());
                            }
                        }
                    }
                }

                if (writeDataList.Count < 200)
                {
                    int fillNum = 200 - writeDataList.Count;
                    for (int i = 0; i < fillNum; i++)
                    {
                        writeDataList.AddRange(new short[] { 0 });
                    }
                }

                #endregion

                #region 下传数据

                object[] buff = new object[writeDataList.Count];
                Array.Copy(writeDataList.ToArray(), buff, buff.Length);

                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]开始下传计划信息...", writer.EquipRunName));
                if (!BasePlcHelper.Instance.PlcWriteByRunName(writer.EquipRunName, buff))
                {
                    string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_5"));     //HMI添加计划请求成功后：计划列表写入PLC失败!
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                }
                else
                {
                    reFlag = true;
                }
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]计划列表信息下传完毕...", writer.EquipRunName));

                #endregion

            }

            #endregion

            return reFlag;
        }
        #endregion

        #region 待计划数写入PLC

        public static void WaitPlanNumToPLC()
        {
            try
            {
                int waitPlanNum = Product.PptPlan.PlanHelper.GetUnExePlanNum();

                #region 向PLC写入等待计划数

                object[] tempob = new object[1] { 0 };
                tempob[0] = waitPlanNum;
                bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Scheduled_Num, tempob);
                if (!result)
                {
                    string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_AutoAddPlan_logContent_8"));     //向PLC写入等待计划数失败!
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                }

                #endregion
                
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("把等待计划数写入PLC异常：" + ex.Message, ex);
            }
        }

        #endregion
            
        #region 终止计划

        /// <summary>
        /// 终止计划方法
        /// </summary>
        /// <param name="planSerial">要终止的计划序号</param>
        /// <param name="planCommand">终止命令</param>
        /// <param name="planNum">要终止的计划数</param>
        /// <param name="unFinishedNum">要终止的计划剩余数</param>
        /// <param name="isShowMsg">是否方法内显示消息窗口</param>
        /// <param name="msgList">输出的消息列表</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool ExecStop(int planSerial, int planCommand, int planNum, int unFinishedNum, bool isShowMsg, List<string> msgList)
        {
            try
            {
                #region 1 定义变量

                List<Int16> writeDataList = new List<Int16>();

                #endregion

                #region 2 验证处理-配置

                List<PlcWriter> writerList = PlcSchemaHelper.Instance.GetPlcWriter("PlanModifyData");
                if (writerList == null || writerList.Count == 0)
                {
                    string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecStop_logContent_1"));     //终止计划数据结构获取失败!
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    return false;
                }

                #endregion

                #region 3 业务处理

                foreach (PlcWriter writer in writerList)
                {
                    writeDataList.Clear();

                    #region 验证处理

                    if (writer.EquipRunName != "Plan_To_Plc")
                    {
                        continue;
                    }

                    #endregion

                    #region 获取PLC品牌名称，处理西门子与其他PLC差异

                    string equipBrand = Mesnac.Equips.Factory.Instance.GetEquipBrandByRunName(writer.EquipRunName);
                    writer.EquipBrand = equipBrand;

                    #endregion

                    #region 整理数据

                    if (writer.EquipRunName == "Plan_To_Plc")
                    {
                        for (int i = 0; i < writer.ThisCount; i++)
                        {
                            foreach (PlcWriteItem item in writer.SchemaList)
                            {
                                item.ClearData();
                                item.EquipBrand = equipBrand;
                                if (item.EquipRunName == "DownLoad_PlanSerial")
                                {
                                    item.SetValue = planSerial;
                                }
                                else if (item.EquipRunName == "DownLoad_PlanCommand")
                                {
                                    item.SetValue = planCommand;
                                }
                                else if (item.EquipRunName == "DownLoad_PlanNum")
                                {
                                    item.SetValue = planNum;
                                }
                                else if (item.EquipRunName == "DownLoad_RealNum")
                                {
                                    item.SetValue = unFinishedNum;
                                }
                                writeDataList.AddRange(item.WriteData());
                            }
                        }
                    }

                    #endregion

                    #region 下传数据

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_ShakeHand, new object[] { 1 });
                    if (!result)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecStop_logContent_3"));     //向PLC下传终止计划命令失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                        return false;
                    }
                    else
                    {
                        object[] buff = new object[writeDataList.Count];
                        Array.Copy(writeDataList.ToArray(), buff, buff.Length);
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]开始下传终止计划信息...", writer.EquipRunName));
                        if (!BasePlcHelper.Instance.PlcWriteByRunName(writer.EquipRunName, buff))
                        {
                            string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecStop_logContent_2"));     //终止计划写入PLC失败!
                            ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                            return false;
                        }
                        else
                        {
                            bool result1 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_ShakeHand, new object[] { 2 });
                            if (!result1)
                            {
                                string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecStop_logContent_4"));     //向PLC下传终止计划命令及数据成功后，反馈失败!
                                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                                return false;
                            }
                            else
                            {
                                int readCount = 0;
                                while (readCount < 5)
                                {
                                    if (BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_FeedBack.NowValue.ToInt() == 1)
                                    {
                                        BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_ShakeHand, new object[] { 0 });
                                        BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_FeedBack, new object[] { 0 });
                                        break;
                                    }
                                    readCount++;
                                    Thread.Sleep(200);
                                }

                            }
                        }
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]计划列表信息下传完毕...", writer.EquipRunName));
                    }
                    #endregion
                }

                #endregion

                #region 4 关闭进度提示

                Sys.FrmNotify.Instance.Value = 100;
                Sys.FrmNotify.Instance.Destory();

                #endregion

                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(ex.Message);
                msgList.Add(ex.Message);
                return false;
            }
            finally
            {
                Sys.FrmNotify.Instance.Destory();
            }
        }

        #endregion

        #region 修改计划数

        /// <summary>
        /// 修改计划数方法
        /// </summary>
        /// <param name="planID">要终止的计划编号</param>
        /// <param name="newPlanNum">新的计划数</param>
        /// <param name="isShowMsg">是否方法内显示消息窗口</param>
        /// <param name="msgList">输出的消息列表</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool ExecModifyPlanNum(int planSerial, int planCommand, int newPlanNum, int unFinishedNum, bool isShowMsg, List<string> msgList)
        {
            try
            {
                #region 1 定义变量

                List<Int16> writeDataList = new List<Int16>();

                #endregion

                #region 2 验证处理-配置

                List<PlcWriter> writerList = PlcSchemaHelper.Instance.GetPlcWriter("PlanModifyData");
                if (writerList == null || writerList.Count == 0)
                {
                    string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecModify_logContent_1"));     //上位机修改计划数：数据结构获取失败!
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    return false;
                }

                #endregion

                #region 3 业务处理

                foreach (PlcWriter writer in writerList)
                {
                    writeDataList.Clear();

                    #region 验证处理

                    if (writer.EquipRunName != "Plan_To_Plc")
                    {
                        continue;
                    }

                    #endregion

                    #region 获取PLC品牌名称，处理西门子与其他PLC差异

                    string equipBrand = Mesnac.Equips.Factory.Instance.GetEquipBrandByRunName(writer.EquipRunName);
                    writer.EquipBrand = equipBrand;

                    #endregion

                    #region 整理数据

                    if (writer.EquipRunName == "Plan_To_Plc")
                    {
                        for (int i = 0; i < writer.ThisCount; i++)
                        {
                            foreach (PlcWriteItem item in writer.SchemaList)
                            {
                                item.ClearData();
                                item.EquipBrand = equipBrand;
                                if (item.EquipRunName == "DownLoad_PlanSerial")
                                {
                                    item.SetValue = planSerial;
                                }
                                else if (item.EquipRunName == "DownLoad_PlanCommand")
                                {
                                    item.SetValue = planCommand;
                                }
                                else if (item.EquipRunName == "DownLoad_PlanNum")
                                {
                                    item.SetValue = newPlanNum;
                                }
                                else if (item.EquipRunName == "DownLoad_RealNum")
                                {
                                    item.SetValue = unFinishedNum;
                                }
                                writeDataList.AddRange(item.WriteData());
                            }
                        }
                    }

                    #endregion

                    #region 下传数据

                    object[] buff = new object[writeDataList.Count];
                    Array.Copy(writeDataList.ToArray(), buff, buff.Length);
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]开始下传终止计划信息...", writer.EquipRunName));
                    if (!BasePlcHelper.Instance.PlcWriteByRunName(writer.EquipRunName, buff))
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecModify_logContent_3"));     //上位机修改计划数：写入PLC失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                        return false;
                    }
                    else
                    {
                        bool result1 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_ShakeHand, new object[] { 2 });
                        if (!result1)
                        {
                            string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_Product_PptPlan_ExecModify_logContent_4"));     //上位机修改计划数：向PLC下传修改计划数成功后，反馈失败!
                            ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                            return false;
                        }
                        else
                        {
                            int readCount = 0;
                            while (readCount < 5)
                            {
                                if (BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_FeedBack.NowValue.ToInt() == 1)
                                {
                                    BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_ShakeHand, new object[] { 0 });
                                    BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Plan_Status_Com_FeedBack, new object[] { 0 });
                                    break;
                                }
                                readCount++;
                                Thread.Sleep(200);
                            }

                        }
                    }
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Debug(String.Format("[{0}]计划列表信息下传完毕...", writer.EquipRunName));

                    #endregion
                }

                #endregion

                #region 5 关闭进度提示

                Sys.FrmNotify.Instance.Value = 100;
                Sys.FrmNotify.Instance.Destory();

                #endregion

                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(ex.Message);
                msgList.Add(ex.Message);
                return false;
            }
            finally
            {
                Sys.FrmNotify.Instance.Destory();
            }
        }

        #endregion

        #region 条码命令处理下传

        /// <summary>
        /// 条码命令处理下传方法
        /// </summary>
        /// <param name="codeStr">通过Socket取到的扫码枪条码字符串</param>
        /// <returns>成功返回true，失败返回false</returns>
        public static bool ScanCodeDown(string codeStr)
        {
            try
            {
                #region 1 条码处理：取出查找物料等相关信息的字符串。

                //string useStr = codeStr.Substring(Global.PublicVar.Instance.ScanCodeStrStart, Global.PublicVar.Instance.ScanCodeStrEnd);
                string useStr = codeStr;
                if (useStr == null || useStr == string.Empty || useStr == "")
                {
                    bool resultHopper_No1 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Hopper_No_103, new object[] { 0 });
                    bool resultScanCommand1 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_ScanCommand, new object[] { 0 });
                    if (!resultHopper_No1 || !resultScanCommand1)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_ScanCodeDown_Error1"));     //没有获取到条码中的有效信息。
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }
                    return false;
                }

                #endregion

                #region 2 根据从条码中取出的物料名称获取物料代码

                string meterialId = Product.PptPlan.PlanHelper.GetPmt_materialID(useStr);
                if (meterialId == null || meterialId == string.Empty || meterialId == "")
                {
                    bool resultHopper_No2 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Hopper_No_103, new object[] { 0 });
                    bool resultScanCommand2 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_ScanCommand, new object[] { 0 });
                    if (!resultHopper_No2 || !resultScanCommand2)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_ScanCodeDown_Error2"));     //没有找到对应的物料代码。
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }
                    return false;
                }

                #endregion

                #region 3 根据物料代码获取对应的料仓号

                int binSerial = Product.PptPlan.PlanHelper.GetPmt_BinSerial(meterialId);
                if (binSerial == 0)
                {
                    bool resultHopper_No3 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Hopper_No_103, new object[] { 0 });
                    bool resultScanCommand3 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_ScanCommand, new object[] { 0 });
                    if (!resultHopper_No3 || !resultScanCommand3)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_ScanCodeDown_Error3"));     //没有找到对应的料仓号。
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }
                    return false;
                }

                #endregion

                #region 4 下传料仓号和命令（失败反馈）

                bool resultHopper_No4 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Hopper_No_103, new object[] { binSerial });
                bool resultScanCommand4 = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_ScanCommand, new object[] { 1 });
                bool resultFromPlc = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_Open_door_Command_ShakeHand, new object[] { 2 });

                if (!resultHopper_No4 || !resultScanCommand4 || !resultFromPlc)
                {
                    string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_ScanCodeDown_Error4"));     //料仓号获取成功，下传时失败。
                    ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                }

                #endregion

                #region 将扫码信息写入数据库报表

                LR_BarcodeLog lR_BarcodeLog = new LR_BarcodeLog();
                lR_BarcodeLog.Equip_Code = ConfigurationManager.AppSettings["EquipCode"];
                lR_BarcodeLog.Scan_Time = DateTime.Now.ToString();
                lR_BarcodeLog.Scan_Bar = useStr;
                lR_BarcodeLog.Material = Product.PptPlan.PlanHelper.GetPmt_material(meterialId).materialName;
                lR_BarcodeLog.Bin = binSerial;
                lR_BarcodeLog.Scan_State = 1;
                Report.ReportHelper.InsertLR_BarcodeLog(lR_BarcodeLog);

                #endregion

                return true;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(ex.Message);
                return false;
            }
            finally
            {
                Sys.FrmNotify.Instance.Destory();
            }
        }

        #endregion

        #region 更新物料名称

        /// <summary>
        /// 更新物料名称
        /// </summary>
        public static void UpdateMaterialNameToPlc()
        {
            try
            {
                bool flag = false;

                #region 更新物料名称及物料代码

                if (BasePlcHelper.Instance.ChemicalWeighing_PLC_LoadingConfig.NowValue.ToInt() == 1 && BasePlcHelper.Instance.ChemicalWeighing_PC_LoadingConfig.NowValue.ToInt() == 0)
                {

                    #region 下传物料名称

                    List<Pmt_Bin> pmt_Bins = Product.PptPlan.PlanHelper.GetAllPmt_Bin();

                    for (int i = 1; i <= 20; i++)
                    {
                        bool findFlag = false;
                        DataKeyValue ChemicalWeighing_MaterName = new DataKeyValue("MaterName_Bin" + Mesnac.Basic.DataProcessor.FillZero(i.ToString(), 2));
                        DataKeyValue ChemicalWeighing_MaterCode = new DataKeyValue("MaterCode_Bin" + Mesnac.Basic.DataProcessor.FillZero(i.ToString(), 2));
                        if (pmt_Bins != null && pmt_Bins.Count > 0)
                        {
                            for (int j = 0; j < pmt_Bins.Count; j++)
                            {
                                Base_MaterialInfo pmt_Material = Product.PptPlan.PlanHelper.GetPmt_material(pmt_Bins[j].Material_ID);
                                string binStr = null;
                                if (pmt_Bins[j] != null && pmt_Bins[j].Bin_Serial != null && pmt_Material != null && pmt_Material.materialName != null)
                                {
                                    binStr = Mesnac.Basic.DataProcessor.FillZero(pmt_Bins[j].Bin_Serial.ToString(), 2);
                                    if (ChemicalWeighing_MaterName.EquipRunName.Contains(binStr))
                                    {
                                        object[] oblist = Mesnac.Basic.DataProcessor.ToPLCDataArray(pmt_Material.materialName);
                                        object[] oblistCode = Mesnac.Basic.DataProcessor.ToPLCDataArray(pmt_Material.materialId);
                                        BasePlcHelper.Instance.PlcWriteByDataKey(ChemicalWeighing_MaterName, FullObj(oblist));
                                        BasePlcHelper.Instance.PlcWriteByDataKey(ChemicalWeighing_MaterCode, FullObj(oblistCode));
                                        findFlag = true;
                                        break;
                                    }
                                }
                            }

                            if (findFlag == false)
                            {
                                object[] oblist = new object[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                                object[] oblistCode = new object[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                                BasePlcHelper.Instance.PlcWriteByDataKey(ChemicalWeighing_MaterName, oblist);
                                BasePlcHelper.Instance.PlcWriteByDataKey(ChemicalWeighing_MaterCode, oblistCode);
                            }
                        }
                    }
                    flag = true;

                    #endregion
                }

                #endregion

                #region 触发事件

                if (flag)
                {
                    #region 下传请求信号

                    bool result = BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_LoadingConfig, new object[] { 1 });
                    if (!result)
                    {
                        string msg = StringParser.Parse(ResourceService.GetString("Mesnac_Action_ChemicalWeighing_ChemicalWeighingPlc_PlcPlanHelper_Mix_msg60"));     //小料物料名称向PLC下传反馈信号失败!
                        ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error(msg);
                    }

                    #endregion
                }

                #endregion
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<PlcPlanHelper>.Error("把PLC的计划状态更新至数据库异常：" + ex.Message, ex);
            }
            finally
            {
                Global.PublicVar.Instance.LocalPlanIsRefresh = false;
            }
        }

        #endregion

        #region 修改PCOnlin心跳信号

        public static void HeartBeatChange()
        {
            if (BasePlcHelper.Instance.ChemicalWeighing_PLC_Online_Flag.NowValue.ToInt() != 0)
            {
                if (BasePlcHelper.Instance.ChemicalWeighing_PC_Online.NowValue.ToInt() == 1)
                {
                    BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Online, new object[] { 0 });
                }
                else
                {
                    BasePlcHelper.Instance.PlcWriteByDataKey(BasePlcHelper.Instance.ChemicalWeighing_PC_Online, new object[] { 1 });
                }
            }
        }

        #endregion


        #region 自动修改班次

        public static void shiftIDAutoChange()
        {
            Global.PublicVar.Instance.globalShiftID = Product.ProductHelper.shiftIDAtuoRefresh();
        }

        #endregion

        public static object[] FullObj(object[] ob)
        {
            object[] reOb = ob;

            if (reOb.Count() < 20)
            {
                for (int z = reOb.Count(); z < 20; z++)
                {
                    object[] tempo = new object[1] { 0 };
                    reOb = reOb.Concat(tempo).ToArray();
                }
            }

            return reOb;
        }



    }
}