bpa
/
BPASmartClient
2
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
终端一体化运控平台
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
1507 Revize
7 Větve
118 MiB
 
 
 
Větev: HK研究所反应釜三屏显示
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „HK研究所反应釜三屏显示“
${ noResults }
BPASmartClient/DosingSystem/ViewModel/RecipeControlViewModel.cs

1052 řádky
83 KiB
Surový Trvalý odkaz Blame Historie 

  1. using BPA.Communication;

  2. using BPA.Helper;

  3. using BPASmartClient.CustomResource.Pages.Model;

  4. using BPASmartClient.CustomResource.UserControls;

  5. using BPASmartClient.CustomResource.UserControls.MessageShow;

  6. using BPASmartClient.Model;

  7. using System;

  8. using System.Collections.Concurrent;

  9. using System.Collections.Generic;

  10. using System.Collections.ObjectModel;

  11. using System.Diagnostics;

  12. using System.Linq;

  13. using System.Threading;

  14. using System.Threading.Tasks;

  15. 

  16. namespace BPASmartClient.DosingSystem.ViewModel

  17. {

  18.     public class RecipeControlViewModel : NotifyBase

  19.     {

  20.         //int ComCount = 0;//配料完成计数

  21.       //  static ConcurrentQueue<string> RecipeNames = new ConcurrentQueue<string>();

  22.       //  static ObservableCollection<StockStatusModel> StockStatus = new ObservableCollection<StockStatusModel>();

  23.         public RecipeControlViewModel()

  24.         {

  25.             //StartCommand = new BPARelayCommand<object>(RecipeIssued);

  26.             //// ChangeRecipeStateCommand = new BPARelayCommand<object>(ChangeRecipeState);

  27.             //CancelRecipeCommand = new BPARelayCommand<object>(CancelRecipe);

  28.             //RecipeRun();

  29.             //RecipeStatusInquire();

  30. 

  31.             StartCommand = new BPARelayCommand<object>(new Action<object>((o) => {

  32.                 if (o != null && o is string recipeName)

  33.                 {

  34.                     ActionManage.GetInstance.Send("配方下发", recipeName);

  35.                 }

  36.             }));

  37.             CancelRecipeCommand = new BPARelayCommand<object>(new Action<object>((ob) => {

  38.                 if (ob != null && ob is RecipeModel recipe)

  39.                 {

  40.                     ActionManage.GetInstance.Send("取消配方", recipe.RecipeName);

  41.                 }

  42. 

  43.             }));

  44.         }

  45. 

  46.         //private async void CancelRecipe(object o)

  47.         //{

  48.         //    if (o != null && o is RecipeModel recipe)

  49.         //    {

  50.         //        var res = MessageNotify.GetInstance.ShowDialog($"是否取消配方 【{recipe.RecipeName}】制作", DialogType.Warning);

  51.         //        if (res)

  52.         //        {

  53.         //            int index = Recipes.ToList().FindIndex(p => p.RecipeName == recipe.RecipeName);

  54.         //            if (index >= 0 && index < Recipes.Count)

  55.         //            {

  56.         //                await Task.Factory.StartNew(new Action(() =>

  57.         //                {

  58.         //                    Recipes.ElementAt(index).IsEnable = true;

  59.         //                    Json<LocalRecipe>.Data.Recipes.ElementAt(index).IsEnable = true;

  60.         //                    Recipes.ElementAt(index).Are.Set();

  61.         //                    App.Current.Dispatcher.Invoke(new Action(() => { recipeProcesses.Clear(); }));

  62.         //                    SiemensDevice.GetInstance.MySiemens.Write("M10.5", true);

  63.         //                    MessageNotify.GetInstance.ShowRunLog($"M10.5:true");

  64.         //                    Thread.Sleep(1000);

  65.         //                    SiemensDevice.GetInstance.MySiemens.Write("M10.5", false);

  66.         //                    MessageNotify.GetInstance.ShowRunLog($"M10.5:false");

  67.         //                    NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, App.MainWindow, "提示", $"配方 [{recipe.RecipeName}] 取消成功");

  68. 

  69.         //                    MessageNotify.GetInstance.ShowUserLog($"取消配方制作 {recipe.RecipeName}");

  70.         //                }));

  71.         //            }

  72.         //        }

  73.         //    }

  74.         //}

  75. 

  76.         /// <summary>

  77.         /// 配方下发

  78.         /// </summary>

  79.         //private void RecipeIssued(object o)

  80.         //{

  81.         //    if (o != null && o is string deviceName)

  82.         //    {

  83.         //        int index = Array.FindIndex(Recipes.ToArray(), p => p.RecipeName == deviceName);

  84.         //        if (index >= 0 && index < Recipes.Count)

  85.         //        {

  86.         //            for (int i = 0; i < Recipes.ElementAt(index).RawMaterials.Count; i++)

  87.         //            {

  88.         //                if (Recipes.ElementAt(index).RawMaterials.ElementAt(i).RawMaterialSource == 1)

  89.         //                {

  90.         //                    string ip = Recipes.ElementAt(index).RawMaterials.ElementAt(i).DeviceIp;

  91.         //                    var device = DeviceInquire.GetInstance.GetDevice(ip);

  92.         //                    if (ip == null && ip == "")

  93.         //                    {

  94.         //                        MessageNotify.GetInstance.ShowDialog($"原料 【{Recipes.ElementAt(index).RawMaterials.ElementAt(i).RawMaterialName}】配料系统无法配料,请人工配置此原料：原料{Recipes.ElementAt(index).RawMaterials.ElementAt(i).RawMaterialName},重量{Recipes.ElementAt(index).RawMaterials.ElementAt(i).RawMaterialWeight}", DialogType.Information);

  95.         //                        return;

  96.         //                    }

  97.         //                    if (!device.IsConnected)

  98.         //                    {

  99.         //                        MessageNotify.GetInstance.ShowDialog($"设备 【{device.DeviceName}】 未连接,不允许下发此配方", DialogType.Error);

  100.         //                        return;

  101.         //                    }

  102.         //                }

  103. 

  104.         //            }

  105.         //            Recipes.ElementAt(index).IsEnable = false;

  106.         //            Json<LocalRecipe>.Data.Recipes.ElementAt(index).IsEnable = false;

  107.         //        }

  108.         //        MessageNotify.GetInstance.ShowUserLog($"下发工单 {Recipes.ElementAt(index).RecipeName}");

  109.         //        RecipeNames.Enqueue(deviceName);

  110.         //        //var t = RecipeNames.GetHashCode();

  111.         //        var res = Recipes.FirstOrDefault(p => p.RecipeName == deviceName);

  112.         //        UserTreeWait.Add(new RecipeModel { RecipStatus = "等待制作", SerialNum = UserTreeWait.Count + 1, RecipeName = deviceName, RawMaterials = res.RawMaterials });

  113.         //    }

  114.         //    NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, App.MainWindow, "提示", $"配方下发成功!");

  115.         //}

  116. 

  117.         /// <summary>

  118.         /// 配方业务执行

  119.         /// </summary>

  120.         //private void RecipeRun()

  121.         //{

  122.         //    TaskManage.GetInstance.StartLong(new Action(() =>

  123.         //    {

  124.         //        if (RecipeNames.Count > 0)

  125.         //        {

  126.         //            int index = Array.FindIndex(Recipes.ToArray(), p => p.RecipeName == RecipeNames.ElementAt(0));

  127.         //            if (index >= 0 && index < Recipes.Count)

  128.         //            {

  129.         //                Recipes.ElementAt(index).Are.Reset();

  130.         //                Recipes.ElementAt(index).IsEnable = false;

  131.         //                StockStatus.Clear();

  132.         //                App.Current.Dispatcher.Invoke(new Action(() =>

  133.         //                {

  134.         //                    recipeProcesses.Clear();

  135.         //                    if (UserTreeWait.Count > 0) UserTreeWait.RemoveAt(0);

  136.         //                }));

  137.         //                CurrentRecipeName = Recipes.ElementAt(index).RecipeName;

  138. 

  139.         //                #region 配方下发到PLC操作相关

  140.         //                //配方数据写入到输送机

  141.         //                var res = Json<LocalRecipe>.Data.Recipes.FirstOrDefault(p => p.RecipeName == CurrentRecipeName);

  142.         //                List<int> BarrelNum = new List<int>();

  143.         //                ConcurrentDictionary<string, int[]> values = new();

  144.         //                if (res != null)

  145.         //                {

  146.         //                    var tInfo = res.RawMaterials.GroupBy(p => p.Loc);//获取桶号信息

  147.         //                    if (tInfo != null)

  148.         //                    {

  149.         //                        for (int i = 0; i < tInfo.Count(); i++)

  150.         //                        {

  151.         //                            int data = 0;

  152.         //                            for (int m = 0; m < tInfo.ElementAt(i).Count(); m++)

  153.         //                            {

  154.         //                                var TempName = tInfo.ElementAt(i).ElementAt(m).RawMaterialName;

  155.         //                                var tempDevice = DeviceInquire.GetInstance.devices.FirstOrDefault(p => p.DeviceName == TempName);

  156.         //                                if (tempDevice != null)

  157.         //                                {

  158.         //                                    /*data = data.SetBitValue((byte)tempDevice.DeviceNum, true);*/

  159.         //                                    if (tempDevice.DeviceNum > 0)

  160.         //                                    {

  161.         //                                        //    //int a = data.SetBitValue((byte)tInfo.ElementAt(i).ElementAt(m).Loc, true);

  162.         //                                        //    //byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  163.         //                                        //    //int item = test1.ToInt();

  164.         //                                        //    int item = data.SetBitValue((byte)tInfo.ElementAt(i).ElementAt(m).Loc, true).ToBytes(BPA.Helper.DataFormat.BADC).ToInt();

  165.         //                                        //    int item1 = SiemensDevice.GetInstance.MySiemens.Read<int>($"DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4}").Content;

  166.         //                                        ////prop1:

  167.         //                                        //    var RE = SiemensDevice.GetInstance.MySiemens.Write($"DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4}", item + item1);

  168.         //                                        //    //var values = SiemensDevice.GetInstance.MySiemens.Read<int>($"DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4}");

  169.         //                                        //    //if ((values != null && values.ToString() != (item + item1).ToString()) || values == null)

  170.         //                                        //    //    goto prop1;

  171.         //                                        //    if (RE.IsSuccess)

  172.         //                                        //        MessageNotify.GetInstance.ShowRunLog($"下发配方DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4} :{(byte)tInfo.ElementAt(i).ElementAt(m).Loc}-{item + item1}-{(item + item1).ToBinString()}");

  173.         //                                        //    else

  174.         //                                        //        MessageNotify.GetInstance.ShowRunLog($"下发配方DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4} 失败");

  175. 

  176. 

  177. 

  178.         //                                        int item = data.SetBitValue((byte)tInfo.ElementAt(i).ElementAt(m).Loc, true).ToBytes(BPA.Helper.DataFormat.BADC).ToInt();

  179.         //                                        string tempAdd = $"DB4.DBD{2 + (tempDevice.DeviceNum - 1) * 4}";

  180.         //                                        if (!values.ContainsKey(tempAdd)) values.TryAdd(tempAdd, new int[2] { 0, 0 });

  181.         //                                        values[tempAdd][0] = values[tempAdd][0] + item;

  182.         //                                        values[tempAdd][1] = tInfo.ElementAt(i).ElementAt(m).Loc;

  183.         //                                    }

  184.         //                                }

  185.         //                                if (tInfo.ElementAt(i).ElementAt(m).Loc > 0)

  186.         //                                {

  187.         //                                    if (!BarrelNum.Contains(tInfo.ElementAt(i).ElementAt(m).Loc))

  188.         //                                    {

  189.         //                                        BarrelNum.Add(tInfo.ElementAt(i).ElementAt(m).Loc);

  190.         //                                    }

  191.         //                                }

  192.         //                            }

  193.         //                        }

  194.         //                    }

  195.         //                }

  196. 

  197.         //                values?.ToList().ForEach(x =>

  198.         //                {

  199.         //                    SiemensDevice.GetInstance.MySiemens.Write(x.Key, x.Value[0]).OnSuccess(() =>

  200.         //                    {

  201.         //                        MessageNotify.GetInstance.ShowRunLog($"下发配方-{x.Key} :桶数：[{x.Value[1]}]-{x.Value[0].ToBinString()}");

  202.         //                    }).OnFail(s =>

  203.         //                    {

  204.         //                        MessageNotify.GetInstance.ShowRunLog($"下发配方-{x.Key} 失败");

  205.         //                    });

  206.         //                });

  207. 

  208. 

  209.         //                SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD198", BarrelNum.Count);//配方使用桶数写入

  210. 

  211.         //                SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX0.1", true);//配方执行启动

  212.         //                Stopwatch sw = new Stopwatch();

  213.         //                var recipe = Recipes.ElementAt(index);

  214.         //                ObservableCollection<RawMaterialModel> RawMater = new ObservableCollection<RawMaterialModel>();

  215.         //                foreach (var item in recipe.RawMaterials)

  216.         //                {

  217.         //                    RawMater.Add(new RawMaterialModel()

  218.         //                    {

  219.         //                        RawMaterialName = item.RawMaterialName,

  220.         //                        DeviceIp = item.DeviceIp,

  221.         //                        DownLimtFeedback = item.DownLimtFeedback,

  222.         //                        Loc = item.Loc,

  223.         //                        RawMaterialId = item.RawMaterialId,

  224.         //                        RawMaterialSource = item.RawMaterialSource,

  225.         //                        RawMaterialType = item.RawMaterialType,

  226.         //                        RawMaterialWeight = item.RawMaterialWeight,

  227.         //                        RecipeStatus = item.RecipeStatus,

  228.         //                        SelectIndex = item.SelectIndex,

  229.         //                        Status = item.Status,

  230.         //                        UpLimtFeedback = item.UpLimtFeedback,

  231.         //                        UpLimtWeightFeedback = item.UpLimtWeightFeedback,

  232.         //                        WeightFeedback = item.WeightFeedback,

  233.         //                    });

  234.         //                }

  235.         //                App.Current.Dispatcher.Invoke(() =>

  236.         //                {

  237.         //                    recipeProcesses.Add(new RecipeModel()

  238.         //                    {

  239.         //                        RawMaterials = RawMater,

  240.         //                        IsEnable = recipe.IsEnable,

  241.         //                        RecipeName = recipe.RecipeName,

  242.         //                        SerialNum = recipe.SerialNum,

  243.         //                        RecipCode = recipe.RecipCode,

  244.         //                    });

  245.         //                });

  246.         //                sw.Restart();

  247.         //                while (true)

  248.         //                {

  249.         //                    if (sw.ElapsedMilliseconds >= 3000 && !GlobalDevice.PlcData.ResComplete)

  250.         //                    {

  251.         //                        MessageNotify.GetInstance.ShowRunLog("获取配方下发反馈超时");

  252.         //                        break;

  253.         //                    }

  254.         //                    if (GlobalDevice.PlcData.ResComplete)

  255.         //                    {

  256.         //                        SiemensDevice.GetInstance.MySiemens.Write("DB3.DBX0.1", false);

  257.         //                        break;

  258.         //                    }

  259.         //                    Thread.Sleep(100);

  260.         //                }

  261.         //                #endregion

  262. 

  263.         //                Recipes.ElementAt(index).Are.WaitOne();//阻塞，直到当前配方完成

  264.         //                RecipeNames.TryDequeue(out string deviceName);

  265.         //                var recipeComple = Recipes.ElementAt(index);

  266.         //                ObservableCollection<RawMaterialModel> RawMaterComple = new ObservableCollection<RawMaterialModel>();

  267.         //                foreach (var item in recipeComple.RawMaterials)

  268.         //                {

  269.         //                    RawMaterComple.Add(new RawMaterialModel()

  270.         //                    {

  271.         //                        RawMaterialName = item.RawMaterialName,

  272.         //                        DeviceIp = item.DeviceIp,

  273.         //                        DownLimtFeedback = item.DownLimtFeedback,

  274.         //                        Loc = item.Loc,

  275.         //                        RawMaterialId = item.RawMaterialId,

  276.         //                        RawMaterialSource = item.RawMaterialSource,

  277.         //                        RawMaterialType = item.RawMaterialType,

  278.         //                        RawMaterialWeight = item.RawMaterialWeight,

  279.         //                        RecipeStatus = item.RecipeStatus,

  280.         //                        SelectIndex = item.SelectIndex,

  281.         //                        Status = item.Status,

  282.         //                        UpLimtFeedback = item.UpLimtFeedback,

  283.         //                        UpLimtWeightFeedback = item.UpLimtWeightFeedback,

  284.         //                        WeightFeedback = item.WeightFeedback,

  285.         //                    });

  286.         //                }

  287.         //                App.Current.Dispatcher.Invoke(() =>

  288.         //                {

  289.         //                    UserTreeCompelete.Add(new RecipeModel()

  290.         //                    {

  291.         //                        RawMaterials = RawMaterComple,

  292.         //                        IsEnable = recipeComple.IsEnable,

  293.         //                        RecipeName = recipeComple.RecipeName,

  294.         //                        SerialNum = UserTreeCompelete.Count + 1,

  295.         //                        RecipCode = recipeComple.RecipCode,

  296.         //                        RecipStatus = "制作完成"

  297.         //                    });

  298.         //                });

  299.         //                App.Current.Dispatcher.Invoke(new Action(() =>

  300.         //                {

  301.         //                    recipeProcesses.Clear();

  302.         //                    CurrentRecipeName = string.Empty;

  303.         //                }));//完成后清空当前配方

  304.         //            }

  305.         //        }

  306.         //        Thread.Sleep(100);

  307.         //    }), "启动配方下发", true);

  308.         //}

  309. 

  310. 

  311.         /// <summary>

  312.         /// 配方执行状态监听

  313.         /// </summary>

  314.         //private void RecipeStatusInquire()

  315.         //{

  316.         //    TaskManage.GetInstance.StartLong(new Action(() =>

  317.         //    {

  318.         //        #region v1.0

  319.         //        //for (int i = 0; i < Recipes.Count; i++)

  320.         //        //{

  321.         //        //    for (int m = 0; m < Recipes.ElementAt(i).RawMaterials.Count; m++)

  322.         //        //    {

  323.         //        //        var RunStatus = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(m).DeviceIp).deviceStatus.RunStatus;

  324.         //        //        //设备状态显示

  325.         //        //        if (Recipes.ElementAt(i).RecipeName == CurrentRecipeName)

  326.         //        //        {

  327.         //        //            string tempRawMaterialName = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(m).DeviceIp).DeviceName;

  328.         //        //            int recIndex = recipeProcesses.ToList().FindIndex(p => p.RecipeName == CurrentRecipeName);

  329.         //        //            if (recIndex >= 0 && recIndex < recipeProcesses.Count)

  330.         //        //            {

  331.         //        //                int index = recipeProcesses.ElementAt(recIndex).RawMaterials.ToList().FindIndex(p => p.RawMaterialName == tempRawMaterialName);

  332.         //        //                if (index >= 0 && index < recipeProcesses.ElementAt(recIndex).RawMaterials.Count)

  333.         //        //                {

  334.         //        //                    //测试使用

  335.         //        //                    recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(index).RecipeStatus = RunStatus;

  336.         //        //                }

  337.         //        //                for (int j = 0; j < GlobalDevice.PlcData.IsAllowIngredients.Length; j++)

  338.         //        //                {

  339.         //        //                    if (GlobalDevice.PlcData.IsAllowIngredients[j])

  340.         //        //                    {

  341.         //        //                        int barrel = j + 1;//桶号

  342.         //        //                        int cnt = GlobalDevice.PlcData.LocationFeedback[j];//允许配料的位置 0~6

  343.         //        //                        if (RTrig.GetInstance("a").Start(GlobalDevice.PlcData.IsAllowIngredients[j]))

  344.         //        //                        {

  345.         //        //                            MessageNotify.GetInstance.ShowRunLog($"桶号：{barrel}，位置：{cnt}，允许配料");

  346.         //        //                        }

  347.         //        //                        int Location1 = 0;

  348.         //        //                        int Location2 = 0;

  349.         //        //                        if (cnt == -1)

  350.         //        //                        {

  351.         //        //                            MessageNotify.GetInstance.ShowRunLog("错误");

  352.         //        //                            return;

  353.         //        //                        }

  354.         //        //                        else

  355.         //        //                        {

  356.         //        //                            if (cnt >= 1 && cnt <= 6)

  357.         //        //                            {

  358. 

  359.         //        //                                //int a1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt * 2 - 1);

  360.         //        //                                //int b1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt * 2);

  361.         //        //                                //if (a1 >= 0)

  362.         //        //                                //{

  363.         //        //                                //    Location1 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(a1).DeviceName && p.Loc == barrel);

  364.         //        //                                //}

  365.         //        //                                //if (b1 >= 0)

  366.         //        //                                //{

  367.         //        //                                //    Location2 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(b1).DeviceName && p.Loc == barrel);

  368.         //        //                                //}

  369. 

  370.         //        //                                int a1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt);

  371.         //        //                                //int b1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt * 2);

  372.         //        //                                if (a1 >= 0)

  373.         //        //                                {

  374.         //        //                                    Location1 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(a1).DeviceName && p.Loc == barrel);

  375.         //        //                                }

  376.         //        //                                //if (b1 >= 0)

  377.         //        //                                //{

  378.         //        //                                //    Location2 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(b1).DeviceName && p.Loc == barrel);

  379.         //        //                                //}

  380.         //        //                                Location2 = Location1;

  381.         //        //                            }

  382. 

  383. 

  384.         //        //                        }

  385.         //        //                        if (Location1 >= 0)

  386.         //        //                        {

  387.         //        //                            string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  388.         //        //                            int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  389.         //        //                            int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  390.         //        //                            if (DeviceNum > 0)

  391.         //        //                            {

  392.         //        //                                float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialWeight;

  393.         //        //                                //测试

  394.         //        //                                int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => (p.RawMaterialName == RawName));

  395.         //        //                                if (loc >= 0 && RawName != null && weight >= 0)

  396.         //        //                                {

  397.         //        //                                    int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  398.         //        //                                    int materialCount = recipeProcesses.ElementAt(recIndex).RawMaterials.Where(p => p.RawMaterialName == RawName).Count();

  399.         //        //                                    if (St_index < 0 || (StockStatus.Count < materialCount && St_index > 0))

  400.         //        //                                    {

  401.         //        //                                        StockStatus.Add(new StockStatusModel()

  402.         //        //                                        {

  403.         //        //                                            MaterialName = RawName,

  404.         //        //                                            IssueWeight = weight,

  405.         //        //                                            IssueStatus = 0,

  406.         //        //                                        });

  407.         //        //                                    }

  408.         //        //                                    St_index = Array.FindIndex(StockStatus.ToArray(), p => (p.MaterialName == RawName && p.IssueStatus == 0));

  409. 

  410.         //        //                                    int St_index1 = Array.FindIndex(StockStatus.ToArray(), p => (p.MaterialName == RawName && p.IssueStatus == 1));

  411.         //        //                                    if (St_index >= 0)

  412.         //        //                                    {

  413.         //        //                                        if ((recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0))// 

  414.         //        //                                        {

  415.         //        //                                            StockStatus.ElementAt(St_index).IssueStatus = 1;

  416.         //        //                                            DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  417.         //        //                                            MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  418.         //        //                                        }

  419.         //        //                                        //if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  420.         //        //                                        //{

  421.         //        //                                        //    //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  422.         //        //                                        //    StockStatus.ElementAt(St_index).IssueStatus = 2;

  423.         //        //                                        //    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  424.         //        //                                        //    int a = 0.SetBitValue((byte)(DeviceNum), true);

  425.         //        //                                        //    byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  426.         //        //                                        //    int item = test1.ToInt();

  427.         //        //                                        //    SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  428.         //        //                                        //    //MessageNotify.GetInstance.ShowRunLog($"{res}");

  429.         //        //                                        //    MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  430.         //        //                                        //    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  431.         //        //                                        //}

  432. 

  433.         //        //                                        //测试

  434.         //        //                                        if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index1).IssueStatus == 1)

  435.         //        //                                        {

  436.         //        //                                            //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  437.         //        //                                            StockStatus.ElementAt(St_index1).IssueStatus = 2;

  438.         //        //                                            DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  439.         //        //                                            int a = 0.SetBitValue((byte)(DeviceNum), true);

  440.         //        //                                            byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  441.         //        //                                            int item = test1.ToInt();

  442.         //        //                                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  443.         //        //                                            //MessageNotify.GetInstance.ShowRunLog($"{res}");

  444.         //        //                                            MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  445.         //        //                                            MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  446.         //        //                                        }

  447.         //        //                                    }

  448.         //        //                                }

  449.         //        //                            }

  450.         //        //                        }

  451. 

  452.         //        //                        //调试

  453.         //        //                        //if (Location1 >= 0)

  454.         //        //                        //{

  455.         //        //                        //    string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  456.         //        //                        //    int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  457.         //        //                        //    int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  458.         //        //                        //    if (DeviceNum > 0)

  459.         //        //                        //    {

  460.         //        //                        //        float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialWeight;

  461.         //        //                        //        //测试

  462.         //        //                        //       // int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => (p.RawMaterialName == RawName));

  463.         //        //                        //        if (Location1 >= 0 && RawName != null && weight >= 0)

  464.         //        //                        //        {

  465.         //        //                        //            int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  466.         //        //                        //            int materialCount = recipeProcesses.ElementAt(recIndex).RawMaterials.Where(p => p.RawMaterialName == RawName).Count();

  467.         //        //                        //            if (St_index < 0 || (StockStatus.Count < materialCount && St_index > 0))

  468.         //        //                        //            {

  469.         //        //                        //                StockStatus.Add(new StockStatusModel()

  470.         //        //                        //                {

  471.         //        //                        //                    MaterialName = RawName,

  472.         //        //                        //                    IssueWeight = weight,

  473.         //        //                        //                    IssueStatus = 0,

  474.         //        //                        //                });

  475.         //        //                        //            }

  476.         //        //                        //            St_index = Array.FindIndex(StockStatus.ToArray(), p => (p.MaterialName == RawName && p.IssueStatus == 0));

  477. 

  478.         //        //                        //            int St_index1 = Array.FindIndex(StockStatus.ToArray(), p => (p.MaterialName == RawName && p.IssueStatus == 1));

  479.         //        //                        //            if (St_index >= 0)

  480.         //        //                        //            {

  481.         //        //                        //                if ((recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(Location1).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0))// 

  482.         //        //                        //                {

  483.         //        //                        //                    StockStatus.ElementAt(St_index).IssueStatus = 1;

  484.         //        //                        //                    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).DeviceIp).Start(weight);

  485.         //        //                        //                    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).DeviceIp},开始出料");

  486.         //        //                        //                }

  487.         //        //                        //                //if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  488.         //        //                        //                //{

  489.         //        //                        //                //    //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  490.         //        //                        //                //    StockStatus.ElementAt(St_index).IssueStatus = 2;

  491.         //        //                        //                //    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  492.         //        //                        //                //    int a = 0.SetBitValue((byte)(DeviceNum), true);

  493.         //        //                        //                //    byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  494.         //        //                        //                //    int item = test1.ToInt();

  495.         //        //                        //                //    SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  496.         //        //                        //                //    //MessageNotify.GetInstance.ShowRunLog($"{res}");

  497.         //        //                        //                //    MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  498.         //        //                        //                //    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  499.         //        //                        //                //}

  500. 

  501.         //        //                        //                //测试

  502.         //        //                        //                if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(Location1).RecipeStatus == 3 && StockStatus.ElementAt(St_index1).IssueStatus == 1)

  503.         //        //                        //                {

  504.         //        //                        //                    //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  505.         //        //                        //                    StockStatus.ElementAt(St_index1).IssueStatus = 2;

  506.         //        //                        //                    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).DeviceIp).StatusReset();

  507.         //        //                        //                    int a = 0.SetBitValue((byte)(DeviceNum), true);

  508.         //        //                        //                    byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  509.         //        //                        //                    int item = test1.ToInt();

  510.         //        //                        //                    SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  511.         //        //                        //                    //MessageNotify.GetInstance.ShowRunLog($"{res}");

  512.         //        //                        //                    MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  513.         //        //                        //                    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).DeviceIp},出料完成，状态复位");

  514.         //        //                        //                }

  515.         //        //                        //            }

  516.         //        //                        //        }

  517.         //        //                        //    }

  518.         //        //                        //}

  519.         //        //                        if (Location1 >= 0)

  520.         //        //                        {

  521. 

  522.         //        //                            string RawName111 = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  523.         //        //                            int St_index111 = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName111);

  524.         //        //                            if (Location2 >= 0 && ((Location1 >= 0 && StockStatus.ElementAt(St_index111).IssueStatus == 2)))

  525.         //        //                            {

  526.         //        //                                string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location2).RawMaterialName;

  527.         //        //                                int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  528.         //        //                                int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  529.         //        //                                if (DeviceNum > 0)

  530.         //        //                                {

  531.         //        //                                    float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location2).RawMaterialWeight;

  532.         //        //                                    int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == RawName);

  533.         //        //                                    if (loc >= 0 && RawName != null && weight >= 0)

  534.         //        //                                    {

  535.         //        //                                        int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  536.         //        //                                        if (St_index < 0)

  537.         //        //                                        {

  538.         //        //                                            StockStatus.Add(new StockStatusModel()

  539.         //        //                                            {

  540.         //        //                                                MaterialName = RawName,

  541.         //        //                                                IssueWeight = weight,

  542.         //        //                                                IssueStatus = 0,

  543.         //        //                                            });

  544.         //        //                                        }

  545.         //        //                                        St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  546.         //        //                                        if (St_index >= 0)

  547.         //        //                                        {

  548.         //        //                                            if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0)

  549.         //        //                                            {

  550.         //        //                                                StockStatus.ElementAt(St_index).IssueStatus = 1;

  551.         //        //                                                DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  552.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  553.         //        //                                            }

  554.         //        //                                            if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  555.         //        //                                            {

  556.         //        //                                                //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  557.         //        //                                                StockStatus.ElementAt(St_index).IssueStatus = 2;

  558.         //        //                                                DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  559.         //        //                                                int a = 0.SetBitValue((byte)(DeviceNum), true);

  560.         //        //                                                byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  561.         //        //                                                int item = test1.ToInt();

  562.         //        //                                                SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  563.         //        //                                                //MessageNotify.GetInstance.ShowRunLog($"{res}");

  564.         //        //                                                //MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  565.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item}");

  566.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  567.         //        //                                            }

  568.         //        //                                        }

  569.         //        //                                    }

  570.         //        //                                }

  571.         //        //                            }

  572.         //        //                        }

  573.         //        //                        else

  574.         //        //                        {

  575.         //        //                            if (Location2 >= 0)

  576.         //        //                            {

  577.         //        //                                string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location2).RawMaterialName;

  578.         //        //                                int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  579.         //        //                                int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  580.         //        //                                if (DeviceNum >= 0)

  581.         //        //                                {

  582.         //        //                                    float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location2).RawMaterialWeight;

  583.         //        //                                    int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == RawName);

  584.         //        //                                    if (cnt > 0 && loc >= 0 && RawName != null && weight >= 0)

  585.         //        //                                    {

  586.         //        //                                        int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  587.         //        //                                        if (St_index < 0)

  588.         //        //                                        {

  589.         //        //                                            StockStatus.Add(new StockStatusModel()

  590.         //        //                                            {

  591.         //        //                                                MaterialName = RawName,

  592.         //        //                                                IssueWeight = weight,

  593.         //        //                                                IssueStatus = 0,

  594.         //        //                                            });

  595.         //        //                                        }

  596.         //        //                                        St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  597.         //        //                                        if (St_index >= 0)

  598.         //        //                                        {

  599.         //        //                                            if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0)

  600.         //        //                                            {

  601.         //        //                                                StockStatus.ElementAt(St_index).IssueStatus = 1;

  602.         //        //                                                DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  603.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  604.         //        //                                            }

  605.         //        //                                            if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  606.         //        //                                            {

  607.         //        //                                                //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  608.         //        //                                                StockStatus.ElementAt(St_index).IssueStatus = 2;

  609.         //        //                                                DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  610.         //        //                                                int a = 0.SetBitValue((byte)(DeviceNum), true);

  611.         //        //                                                byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  612.         //        //                                                int item = test1.ToInt();

  613.         //        //                                                SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  614.         //        //                                                recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).UpLimtWeightFeedback = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).deviceStatus.NowWeightFeedback;

  615.         //        //                                                //MessageNotify.GetInstance.ShowRunLog($"{res}");

  616.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");

  617.         //        //                                                MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  618.         //        //                                            }

  619.         //        //                                        }

  620.         //        //                                    }

  621.         //        //                                }

  622.         //        //                            }

  623.         //        //                        }

  624.         //        //                    }

  625.         //        //                    //508配料项目代码

  626.         //        //                    //if (GlobalDevice.PlcData.IsAllowIngredients[j])

  627.         //        //                    //{

  628.         //        //                    //    int barrel = j + 1;//桶号

  629.         //        //                    //    int cnt = GlobalDevice.PlcData.LocationFeedback[j];//允许配料的位置 1~10

  630.         //        //                    //    if (RTrig.GetInstance("a").Start(GlobalDevice.PlcData.IsAllowIngredients[j]))

  631.         //        //                    //    {

  632.         //        //                    //        MessageNotify.GetInstance.ShowRunLog($"桶号：{barrel}，位置：{cnt}，允许配料");

  633.         //        //                    //    }

  634.         //        //                    //    int Location1 = 0;

  635.         //        //                    //    if (cnt == -1)

  636.         //        //                    //    {

  637.         //        //                    //        MessageNotify.GetInstance.ShowRunLog("没有读取到配料的位置");

  638.         //        //                    //        return;

  639.         //        //                    //    }

  640.         //        //                    //    else

  641.         //        //                    //    {

  642.         //        //                    //        int a1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt);

  643.         //        //                    //        Location1 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(a1).DeviceName && p.Loc == barrel);

  644.         //        //                    //    }

  645.         //        //                    //    if (Location1 >= 0)

  646.         //        //                    //    {

  647.         //        //                    //        string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  648.         //        //                    //        int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  649.         //        //                    //        int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  650.         //        //                    //        if (DeviceNum > 0)

  651.         //        //                    //        {

  652.         //        //                    //            float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialWeight;

  653.         //        //                    //            int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == RawName);

  654.         //        //                    //            if (loc >= 0 && RawName != null && weight >= 0)

  655.         //        //                    //            {

  656.         //        //                    //                int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  657.         //        //                    //                if (St_index < 0)

  658.         //        //                    //                {

  659.         //        //                    //                    StockStatus.Add(new StockStatusModel()

  660.         //        //                    //                    {

  661.         //        //                    //                        MaterialName = RawName,

  662.         //        //                    //                        IssueWeight = weight,

  663.         //        //                    //                        IssueStatus = 0,

  664.         //        //                    //                    });

  665.         //        //                    //                }

  666.         //        //                    //                St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  667.         //        //                    //                if (St_index >= 0)

  668.         //        //                    //                {

  669.         //        //                    //                    if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0)

  670.         //        //                    //                    {

  671.         //        //                    //                        StockStatus.ElementAt(St_index).IssueStatus = 1;

  672.         //        //                    //                        DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  673.         //        //                    //                        MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  674.         //        //                    //                    }

  675.         //        //                    //                    if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  676.         //        //                    //                    {

  677.         //        //                    //                        //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  678.         //        //                    //                        StockStatus.ElementAt(St_index).IssueStatus = 2;

  679.         //        //                    //                        DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  680.         //        //                    //                        /*int a = 0.SetBitValue((byte)(DeviceNum), true);

  681.         //        //                    //                        byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.ABCD);

  682.         //        //                    //                        int item = test1.ToInt();*/

  683.         //        //                    //                        if (DeviceNum >= 1 && DeviceNum <= 8) 

  684.         //        //                    //                        {

  685.         //        //                    //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX130." + (DeviceNum - 1), true);

  686.         //        //                    //                        }else if (DeviceNum >= 9 && DeviceNum <= 16)

  687.         //        //                    //                        {

  688.         //        //                    //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX131." + (DeviceNum - 9), true);

  689.         //        //                    //                        }

  690.         //        //                    //                        else if (DeviceNum >=17 && DeviceNum <= 24)

  691.         //        //                    //                        {

  692.         //        //                    //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX132." + (DeviceNum - 17), true);

  693.         //        //                    //                        }else if (DeviceNum >= 25 && DeviceNum <= 32)

  694.         //        //                    //                        {

  695.         //        //                    //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX133." + (DeviceNum - 25), true);

  696.         //        //                    //                        }

  697.         //        //                    //                        MessageNotify.GetInstance.ShowRunLog($"料仓：{DeviceNum}，配料完成");

  698.         //        //                    //                        /*string res = SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item, 2);

  699.         //        //                    //                        MessageNotify.GetInstance.ShowRunLog($"{res}");

  700.         //        //                    //                        MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");*/

  701.         //        //                    //                        MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  702.         //        //                    //                    }

  703.         //        //                    //                }

  704.         //        //                    //            }

  705.         //        //                    //        }

  706.         //        //                    //    }

  707.         //        //                    //}

  708.         //        //                }

  709.         //        //                int Finish_Count = StockStatus.Where(s => s.IssueStatus == 2).Count();

  710.         //        //                int Finish = Recipes.ElementAt(i).RawMaterials.Where(p => p.RecipeStatus == 3).Count();

  711.         //        //                if (StockStatus.Count >= Recipes.ElementAt(i).RawMaterials.Count && Finish == Recipes.ElementAt(i).RawMaterials.Count) //配方配料完成 Finish_Count >= Recipes.ElementAt(i).RawMaterials.Count

  712.         //        //                {

  713.         //        //                    StockStatus.Clear();

  714.         //        //                    MessageNotify.GetInstance.ShowUserLog($"配方:{recipeProcesses.ElementAt(recIndex).RecipeName},配料完成");

  715.         //        //                    foreach (var item in recipeProcesses.ElementAt(recIndex).RawMaterials)

  716.         //        //                    {

  717.         //        //                        MessageNotify.GetInstance.ShowUserLog($"原料:{item.RawMaterialName},桶号：{item.Loc}，设定配料重量{item.RawMaterialWeight}g,实际配料重量{item.UpLimtWeightFeedback}g");

  718.         //        //                    }

  719.         //        //                    SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX202.0", true);//配料完成

  720.         //        //                    MessageNotify.GetInstance.ShowRunLog($"配方:{CurrentRecipeName},配料完成");

  721.         //        //                    int recipIndex = Array.FindIndex(Recipes.ToArray(), p => p.RecipeName == CurrentRecipeName);

  722.         //        //                    App.Current.Dispatcher.Invoke(new Action(() => { recipeProcesses.Clear(); }));

  723.         //        //                    Recipes.ElementAt(recipIndex).IsEnable = true;

  724.         //        //                    Json<LocalRecipe>.Data.Recipes.ElementAt(recipIndex).IsEnable = true;

  725.         //        //                    Recipes.ElementAt(recipIndex).Are.Set();

  726.         //        //                    Thread.Sleep(100);

  727.         //        //                }

  728.         //        //            }

  729.         //        //        }

  730.         //        //    }

  731.         //        //}

  732.         //        #endregion

  733. 

  734.         //        #region 正式版

  735.         //        for (int i = 0; i < Recipes.Count; i++)

  736.         //        {

  737.         //            for (int m = 0; m < Recipes.ElementAt(i).RawMaterials.Count; m++)

  738.         //            {

  739.         //                var RunStatus = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(m).DeviceIp).deviceStatus.RunStatus;

  740.         //                //设备状态显示

  741.         //                if (Recipes.ElementAt(i).RecipeName == CurrentRecipeName)

  742.         //                {

  743.         //                    string tempRawMaterialName = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(m).DeviceIp).DeviceName;

  744.         //                    int recIndex = recipeProcesses.ToList().FindIndex(p => p.RecipeName == CurrentRecipeName);

  745.         //                    if (recIndex >= 0 && recIndex < recipeProcesses.Count)

  746.         //                    {

  747.         //                        int index = recipeProcesses.ElementAt(recIndex).RawMaterials.ToList().FindIndex(p => p.RawMaterialName == tempRawMaterialName);

  748. 

  749.         //                        if (index >= 0 && index < recipeProcesses.ElementAt(recIndex).RawMaterials.Count)

  750.         //                        {

  751.         //                            //测试使用

  752.         //                            recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(index).RecipeStatus = RunStatus;

  753.         //                        }

  754.         //                        for (int j = 0; j < GlobalDevice.PlcData.IsAllowIngredients.Length; j++)

  755.         //                        {

  756.         //                            if (GlobalDevice.PlcData.IsAllowIngredients[j])

  757.         //                            {

  758.         //                                int barrel = j + 1;//桶号

  759.         //                                int cnt = GlobalDevice.PlcData.LocationFeedback[j];//允许配料的位置 1~6

  760.         //                                if (RTrig.GetInstance($"a{j}").Start(GlobalDevice.PlcData.IsAllowIngredients[j]))

  761.         //                                {

  762.         //                                    MessageNotify.GetInstance.ShowRunLog($"桶号：{barrel}，位置：{cnt}，允许配料");

  763.         //                                }

  764.         //                                int Location1 = 0;

  765.         //                                int Location2 = 0;

  766.         //                                if (cnt == -1)

  767.         //                                {

  768.         //                                    MessageNotify.GetInstance.ShowRunLog("错误");

  769.         //                                    return;

  770.         //                                }

  771.         //                                else

  772.         //                                {

  773.         //                                    if (cnt >= 1 && cnt <= 6)

  774.         //                                    {

  775.         //                                        int a1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt);

  776.         //                                        if (a1 >= 0)

  777.         //                                        {

  778.         //                                            Location1 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(a1).DeviceName && p.Loc == barrel);

  779.         //                                        }

  780. 

  781.         //                                    }

  782.         //                                }

  783.         //                                if (Location1 >= 0)

  784.         //                                {

  785.         //                                    string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  786.         //                                    int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  787.         //                                    int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  788.         //                                    if (DeviceNum > 0)

  789.         //                                    {

  790.         //                                        float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialWeight;

  791. 

  792.         //                                        int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => (p.RawMaterialName == RawName));

  793.         //                                        if (loc >= 0 && RawName != null && weight >= 0)

  794.         //                                        {

  795.         //                                            int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  796. 

  797.         //                                            if (St_index < 0) //|| (StockStatus.Count < materialCount && St_index > 0)

  798.         //                                            {

  799.         //                                                StockStatus.Add(new StockStatusModel()

  800.         //                                                {

  801.         //                                                    MaterialName = RawName,

  802.         //                                                    IssueWeight = weight,

  803.         //                                                    IssueStatus = 0,

  804.         //                                                });

  805.         //                                            }

  806.         //                                            St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);//&& p.IssueStatus == 0)

  807.         //                                            if (St_index >= 0)

  808.         //                                            {

  809. 

  810.         //                                                if (RTrig.GetInstance($"ac{j}-{St_index}").Start(GlobalDevice.PlcData.IsAllowIngredients[j]))

  811.         //                                                {

  812.         //                                                    MessageNotify.GetInstance.ShowRunLog($"{St_index}-{j}--》允许配料");

  813.         //                                                    if (StockStatus.ElementAt(St_index).IssueStatus == 2)

  814.         //                                                    {

  815.         //                                                        StockStatus.ElementAt(St_index).IssueStatus = 0;

  816.         //                                                        MessageNotify.GetInstance.ShowRunLog($"{St_index}-复位");

  817.         //                                                    }

  818.         //                                                }

  819.         //                                                var rrr = DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).deviceStatus.RunStatus;

  820.         //                                                if ((recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0))// 

  821.         //                                                {

  822. 

  823.         //                                                    StockStatus.ElementAt(St_index).IssueStatus = 1;

  824.         //                                                    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  825.         //                                                    var res = recipeProcesses.ElementAt(recIndex).RawMaterials.FirstOrDefault(p => p.Status != Status.正在配料 && p.Status != Status.配料完成 && p.RawMaterialName == tempRawMaterialName && p.Loc == j + 1);

  826.         //                                                    if (res != null)

  827.         //                                                        res.Status = Status.正在配料;

  828. 

  829.         //                                                    MessageNotify.GetInstance.ShowRunLog($"设备执行状态：{rrr}");

  830.         //                                                    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  831.         //                                                }

  832.         //                                                if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  833.         //                                                {

  834.         //                                                    //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  835. 

  836.         //                                                    ComCount++;

  837.         //                                                    StockStatus.ElementAt(St_index).IssueStatus = 2;

  838.         //                                                    DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  839.         //                                                    //int a = 0.SetBitValue((byte)(DeviceNum), true);

  840.         //                                                    //byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.BADC);

  841.         //                                                    //int item = test1.ToInt();

  842.         //                                                    //prop1:

  843.         //                                                    // SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item);

  844.         //                                                    SiemensDevice.GetInstance.MySiemens.Write($"DB4.DBX130.{DeviceNum - 1}", true);

  845.         //                                                    Task.Run(() =>

  846.         //                                                    {

  847.         //                                                        int cout = DeviceNum - 1;

  848.         //                                                        while (!SiemensDevice.GetInstance.MySiemens.Read<bool>($"DB3.DBX148.{cout}").Content)  //DB3.DBX148.0-31   148.0-148.5代表6个料仓位置

  849.         //                                                        {

  850.         //                                                            SiemensDevice.GetInstance.MySiemens.Write($"DB4.DBX130.{cout}", true);

  851.         //                                                            Thread.Sleep(200);

  852.         //                                                        }

  853.         //                                                        while (SiemensDevice.GetInstance.MySiemens.Read<bool>($"DB3.DBX148.{cout}").Content)

  854.         //                                                        {

  855.         //                                                            SiemensDevice.GetInstance.MySiemens.Write($"DB4.DBX130.{cout}", false);

  856.         //                                                        }

  857.         //                                                        MessageNotify.GetInstance.ShowRunLog($"{cout}号气缸复位信号写入成功！");

  858.         //                                                    });

  859.         //                                                    var res = recipeProcesses.ElementAt(recIndex).RawMaterials.FirstOrDefault(p => p.Status != Status.配料完成 && p.RawMaterialName == tempRawMaterialName && p.Loc == j + 1);

  860.         //                                                    if (res != null)

  861.         //                                                        res.Status = Status.配料完成;

  862. 

  863. 

  864.         //                                                    MessageNotify.GetInstance.ShowRunLog($"设备完成执行状态：{rrr}");

  865.         //                                                    MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  866. 

  867.         //                                                }

  868. 

  869. 

  870.         //                                            }

  871.         //                                        }

  872.         //                                    }

  873.         //                                }

  874.         //                            }

  875.         //                            //508配料项目代码

  876.         //                            //if (GlobalDevice.PlcData.IsAllowIngredients[j])

  877.         //                            //{

  878.         //                            //    int barrel = j + 1;//桶号

  879.         //                            //    int cnt = GlobalDevice.PlcData.LocationFeedback[j];//允许配料的位置 1~10

  880.         //                            //    if (RTrig.GetInstance("a").Start(GlobalDevice.PlcData.IsAllowIngredients[j]))

  881.         //                            //    {

  882.         //                            //        MessageNotify.GetInstance.ShowRunLog($"桶号：{barrel}，位置：{cnt}，允许配料");

  883.         //                            //    }

  884.         //                            //    int Location1 = 0;

  885.         //                            //    if (cnt == -1)

  886.         //                            //    {

  887.         //                            //        MessageNotify.GetInstance.ShowRunLog("没有读取到配料的位置");

  888.         //                            //        return;

  889.         //                            //    }

  890.         //                            //    else

  891.         //                            //    {

  892.         //                            //        int a1 = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceNum == cnt);

  893.         //                            //        Location1 = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == DeviceInquire.GetInstance.devices.ElementAt(a1).DeviceName && p.Loc == barrel);

  894.         //                            //    }

  895.         //                            //    if (Location1 >= 0)

  896.         //                            //    {

  897.         //                            //        string RawName = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialName;

  898.         //                            //        int abc = Array.FindIndex(DeviceInquire.GetInstance.devices.ToArray(), p => p.DeviceName == RawName);

  899.         //                            //        int DeviceNum = DeviceInquire.GetInstance.devices.ElementAt(abc).DeviceNum;

  900.         //                            //        if (DeviceNum > 0)

  901.         //                            //        {

  902.         //                            //            float weight = Recipes.ElementAt(i).RawMaterials.ElementAt(Location1).RawMaterialWeight;

  903.         //                            //            int loc = Array.FindIndex(Recipes.ElementAt(i).RawMaterials.ToArray(), p => p.RawMaterialName == RawName);

  904.         //                            //            if (loc >= 0 && RawName != null && weight >= 0)

  905.         //                            //            {

  906.         //                            //                int St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  907.         //                            //                if (St_index < 0)

  908.         //                            //                {

  909.         //                            //                    StockStatus.Add(new StockStatusModel()

  910.         //                            //                    {

  911.         //                            //                        MaterialName = RawName,

  912.         //                            //                        IssueWeight = weight,

  913.         //                            //                        IssueStatus = 0,

  914.         //                            //                    });

  915.         //                            //                }

  916.         //                            //                St_index = Array.FindIndex(StockStatus.ToArray(), p => p.MaterialName == RawName);

  917.         //                            //                if (St_index >= 0)

  918.         //                            //                {

  919.         //                            //                    if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 1 && StockStatus.ElementAt(St_index).IssueStatus == 0)

  920.         //                            //                    {

  921.         //                            //                        StockStatus.ElementAt(St_index).IssueStatus = 1;

  922.         //                            //                        DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).Start(weight);

  923.         //                            //                        MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},开始出料");

  924.         //                            //                    }

  925.         //                            //                    if (recipeProcesses.ElementAt(recIndex).RawMaterials.ElementAt(loc).RecipeStatus == 3 && StockStatus.ElementAt(St_index).IssueStatus == 1)

  926.         //                            //                    {

  927.         //                            //                        //GlobalDevice.PlcData.IsAllowIngredients[j] = false;//测试使用

  928.         //                            //                        StockStatus.ElementAt(St_index).IssueStatus = 2;

  929.         //                            //                        DeviceInquire.GetInstance.GetDevice(Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp).StatusReset();

  930.         //                            //                        /*int a = 0.SetBitValue((byte)(DeviceNum), true);

  931.         //                            //                        byte[] test1 = a.ToBytes(BPA.Helper.DataFormat.ABCD);

  932.         //                            //                        int item = test1.ToInt();*/

  933.         //                            //                        if (DeviceNum >= 1 && DeviceNum <= 8) 

  934.         //                            //                        {

  935.         //                            //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX130." + (DeviceNum - 1), true);

  936.         //                            //                        }else if (DeviceNum >= 9 && DeviceNum <= 16)

  937.         //                            //                        {

  938.         //                            //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX131." + (DeviceNum - 9), true);

  939.         //                            //                        }

  940.         //                            //                        else if (DeviceNum >=17 && DeviceNum <= 24)

  941.         //                            //                        {

  942.         //                            //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX132." + (DeviceNum - 17), true);

  943.         //                            //                        }else if (DeviceNum >= 25 && DeviceNum <= 32)

  944.         //                            //                        {

  945.         //                            //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX133." + (DeviceNum - 25), true);

  946.         //                            //                        }

  947.         //                            //                        MessageNotify.GetInstance.ShowRunLog($"料仓：{DeviceNum}，配料完成");

  948.         //                            //                        /*string res = SiemensDevice.GetInstance.MySiemens.Write("DB4.DBD130", item, 2);

  949.         //                            //                        MessageNotify.GetInstance.ShowRunLog($"{res}");

  950.         //                            //                        MessageNotify.GetInstance.ShowRunLog($"DB4.DBD130:{item.ToBinString()}");*/

  951.         //                            //                        MessageNotify.GetInstance.ShowRunLog($"柔性味魔方{Recipes.ElementAt(i).RawMaterials.ElementAt(loc).DeviceIp},出料完成，状态复位");

  952.         //                            //                    }

  953.         //                            //                }

  954.         //                            //            }

  955.         //                            //        }

  956.         //                            //    }

  957.         //                            //}

  958.         //                        }

  959. 

  960.         //                        if (ComCount >= Recipes.ElementAt(i).RawMaterials.Count) //配方配料完成 StockStatus.Count >= Recipes.ElementAt(i).RawMaterials.Count &&

  961.         //                        {

  962.         //                            int cc = recipeProcesses.ElementAt(recIndex).RawMaterials.OrderBy(p => p.RawMaterialName).Count();

  963.         //                            for (int k = 0; k < 32; k++)

  964.         //                            {

  965.         //                                for (int l = 0; l < cc; l++)

  966.         //                                {

  967.         //                                    RTrig.GetInstance($"ac{k}-{l}").Start(false);

  968.         //                                }

  969.         //                            }

  970.         //                            ComCount = 0;

  971. 

  972.         //                            StockStatus.Clear();

  973.         //                            MessageNotify.GetInstance.ShowUserLog($"配方:{recipeProcesses.ElementAt(recIndex).RecipeName},配料完成");

  974.         //                            foreach (var item in recipeProcesses.ElementAt(recIndex).RawMaterials)

  975.         //                            {

  976.         //                                MessageNotify.GetInstance.ShowUserLog($"原料:{item.RawMaterialName},桶号：{item.Loc}，设定配料重量{item.RawMaterialWeight}g,实际配料重量{item.UpLimtWeightFeedback}g");

  977.         //                            }

  978.         //                            SiemensDevice.GetInstance.MySiemens.Write("DB4.DBX202.0", true);//配料完成

  979.         //                            MessageNotify.GetInstance.ShowRunLog($"配方:{CurrentRecipeName},配料完成");

  980.         //                            int recipIndex = Array.FindIndex(Recipes.ToArray(), p => p.RecipeName == CurrentRecipeName);

  981.         //                            App.Current.Dispatcher.Invoke(new Action(() => { recipeProcesses.Clear(); }));

  982.         //                            Recipes.ElementAt(recipIndex).IsEnable = true;

  983.         //                            Json<LocalRecipe>.Data.Recipes.ElementAt(recipIndex).IsEnable = true;

  984.         //                            Recipes.ElementAt(recipIndex).Are.Set();

  985.         //                            Thread.Sleep(100);

  986.         //                        }

  987.         //                    }

  988.         //                }

  989.         //            }

  990.         //        }

  991.         //        #endregion

  992. 

  993.         //        Thread.Sleep(100);

  994.         //    }), "RecipeControlViewModelStatusInquire", true);

  995.         //}

  996. 

  997.         public BPARelayCommand<object> StartCommand { get; set; }

  998. 

  999.         //public BPARelayCommand<object> ChangeRecipeStateCommand { get; set; }

  1000. 

  1001.         public BPARelayCommand<object> CancelRecipeCommand { get; set; }

  1002. 

  1003.         public static ObservableCollection<RecipeModel> Recipes { get; set; } =ExcuteControl.GetInstance.Recipes;

  1004. 

  1005.       //  public static string CurrentRecipeName { get { return _RecipeName; } set { _RecipeName = value; OnStaticPropertyChanged(); } }

  1006.        // private static string _RecipeName;

  1007. 

  1008.         /// <summary>

  1009.         /// 当前正在制作的配方

  1010.         /// </summary>

  1011.         public static ObservableCollection<RecipeModel> recipeProcesses { get; set; } = ExcuteControl.GetInstance.recipeProcesses;

  1012. 

  1013.         /// <summary>

  1014.         /// 等待制作的配方

  1015.         /// </summary>

  1016.         //public static ObservableCollection<RecipeModel> UserTreeWait { get; set; } = new ObservableCollection<RecipeModel>();

  1017. 

  1018.         /// <summary>

  1019.         /// 已完成的配方

  1020.         /// </summary>

  1021.         //public static ObservableCollection<RecipeModel> UserTreeCompelete { get; set; } = new ObservableCollection<RecipeModel>();

  1022. 

  1023. 

  1024.         //private void ChangeRecipeState(object o)

  1025.         //{

  1026.         //    if (o == null) return;

  1027.         //    if (o is string id)

  1028.         //    {

  1029.         //        var Recipe = recipeProcesses.FirstOrDefault(p => p.RecipeName == CurrentRecipeName);

  1030.         //        if (Recipe != null)

  1031.         //        {

  1032.         //            var res = Recipe.RawMaterials.FirstOrDefault(p => p.RawMaterialId == id);

  1033.         //            //var res1=Recipe.RawMaterials.Where(p => p.RawMaterialId == id);

  1034.         //            if (res != null)

  1035.         //            {

  1036.         //                if (res.RecipeStatus == 3)

  1037.         //                {

  1038.         //                    res.RecipeStatus = 1;

  1039.         //                }

  1040.         //                else

  1041.         //                {

  1042.         //                    res.RecipeStatus = 3;

  1043.         //                }

  1044.         //            }

  1045.         //        }

  1046.         //    }

  1047.         //}

  1048.     }

  1049. 

  1050. 

  1051. }