bpa
/
BPASmartClient
2
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
终端一体化运控平台
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
410 Commitit
7 Branchit
118 MiB
 
 
 
Puu: 5551a63aaf
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '5551a63aaf'
${ noResults }
BPASmartClient/FryPot_DosingSystem/Control/DosingLogicControl.cs

1188 rivejä
56 KiB
Raaka Blame Historia 

  1. using BPASmartClient.AGV;

  2. using BPASmartClient.AGV.Enums;

  3. using BPASmartClient.AGV.Feedback;

  4. using BPASmartClient.CustomResource.Pages.Model;

  5. using BPASmartClient.Helper;

  6. using BPASmartClient.HubHelper;

  7. using FryPot_DosingSystem.Model;

  8. using FryPot_DosingSystem.ViewModel;

  9. using Newtonsoft.Json;

  10. using System;

  11. using System.Collections.Concurrent;

  12. using System.Collections.Generic;

  13. using System.Collections.ObjectModel;

  14. using System.Linq;

  15. using System.Text;

  16. using System.Threading;

  17. using System.Threading.Tasks;

  18. using System.Windows.Media;

  19. using System.Windows;

  20. 

  21. namespace FryPot_DosingSystem.Control

  22. {

  23.     internal class DosingLogicControl

  24.     {

  25.         public static DosingLogicControl _instance;

  26.         public static DosingLogicControl GetInstance => _instance ??= new DosingLogicControl();

  27.         public ConcurrentDictionary<string, object> PlcReadData = new ConcurrentDictionary<string, object>();

  28.         /// <summary>

  29.         /// 配方队列

  30.         /// </summary>

  31.         public ConcurrentQueue<NewRecipeModel> RecipeQuene = new ConcurrentQueue<NewRecipeModel>();

  32.         /// <summary>

  33.         /// 进料原料队列

  34.         /// </summary>

  35.         public ConcurrentQueue<MaterialInfo> InputMaterialQuene = new ConcurrentQueue<MaterialInfo>();

  36.         /// <summary>

  37.         /// 出料原料队列

  38.         /// </summary>

  39.         public ConcurrentQueue<MaterialInfo> OutputMaterialQuene = new ConcurrentQueue<MaterialInfo>();

  40.         /// <summary>

  41.         /// 全局变量对象声明

  42.         /// </summary>

  43.         GlobalVariable globalVar;

  44.         /// <summary>

  45.         /// 线体状态对象声明

  46.         /// </summary>

  47.         HardWareStatusViewModel hardWareStatusModel;

  48. 

  49.         #region 上位机内部变量

  50.         //int lineAlarm = 0;//线体故障信号 1：无故障 -1：故障 

  51.         int FryPotAlarm = 0;//炒锅滚筒故障信号 1：无故障 -1：故障

  52.         int ReicpeNum = 0;//记录接收到的配方数

  53.         #endregion

  54.         #region agv临时变量

  55.         bool agvArriveUpLoad = false;//agv是否到达线体装料位置

  56.         bool agvArriveUnLoad = false;//agv是否到达炒锅送料位置

  57.         bool agvFryPotEmptyRollerArrive = false;//agv是否拿到炒锅空桶

  58.         string robotJobId = String.Empty;//当前上游系统任务号，全局唯一

  59.         //List<string> robotJobIds = new List<string>();//存储当前上游系统任务号，全局唯一

  60.         bool loadInteractive = false;// fasle:不需要上料交互 true:需要上料交互

  61.         #endregion

  62.         public DosingLogicControl()

  63.         {

  64.             globalVar = new GlobalVariable();

  65.             hardWareStatusModel = HardWareStatusViewModel.GetInstance;

  66.             ActionManage.GetInstance.Register(new Action<object>(RecipeDataParse), "RecipeSetDown");

  67.             ActionManage.GetInstance.Register(new Action(() => { RecipeQuene.Clear(); InputMaterialQuene.Clear(); OutputMaterialQuene.Clear(); }), "ClearRecipes");

  68.             ActionManage.GetInstance.Register(new Action(() => { globalVar.PlcInite = 1; }), "StartPlcInite");

  69.             ActionManage.GetInstance.Register(new Action(() => { globalVar.PlcInite = 0; }), "EndPlcInite");

  70.             ActionManage.GetInstance.Register(new Action(() => { globalVar.ExitMainTask = true; }), "FryPotDosingMainTaskExit");

  71.             HubHelper.GetInstance.Report = new Action<object>(AgvTaskUpReportDataAnalysis);

  72.             HubHelper.GetInstance.Upstreamrequest = new Action<object>(AgvFeedBackUpReportDataAnalysis);

  73.             ResetProgram();

  74.             ReadPlcData();

  75.             IniteTask();

  76.         }

  77. 

  78.         /// <summary>

  79.         /// AGV上下料上报数据解析

  80.         /// </summary>

  81.         /// <param name="obj"></param>

  82.         private void AgvFeedBackUpReportDataAnalysis(object obj)

  83.         {

  84.             if (obj != null && obj is byte[] datas)

  85.             {

  86.                 string strData = Encoding.UTF8.GetString(datas);

  87.                 object objData = JsonConvert.DeserializeObject(strData);

  88.                 if (objData != null && objData is Upstreamrequest upDownReportData)

  89.                 {

  90.                     //if (upDownReportData.body != null && upDownReportData.body is UpstreamrequestBody body)

  91.                     //{

  92.                     //    if (body.robotJobId == robotJobId && body.command == "LOAD")//同一任务号且处于上料阶段

  93.                     //    {

  94.                     //        agvArriveUpLoad = true;//AGV到达上料位置

  95.                     //    }

  96.                     //    if (body.robotJobId == robotJobId && body.command == "UNLOAD")//同一任务号且处于下料阶段

  97.                     //    {

  98.                     //        agvArriveUnLoad = true;//AGV到达下料位置

  99.                     //    }

  100. 

  101.                     //}

  102.                 }

  103.             }

  104.         }

  105. 

  106.         /// <summary>

  107.         /// AGV搬运任务上报数据解析

  108.         /// </summary>

  109.         /// <param name="obj"></param>

  110.         private void AgvTaskUpReportDataAnalysis(object obj)

  111.         {

  112.             if (obj != null && obj is byte[] datas)

  113.             {

  114.                 string strData = Encoding.UTF8.GetString(datas);

  115.                 object objData = JsonConvert.DeserializeObject(strData);

  116.                 if (objData != null && objData is AGVToUpSystem agvUpReportData)

  117.                 {

  118.                     //if (agvUpReportData.body != null && agvUpReportData.body is AGVToUpSystemBody body)

  119.                     //{

  120.                     //    if (body.state == "ROLLER_LOAD_FINISH" && body.jobData.startPointCode == "")//上料完成以及到达指定上料点位

  121.                     //    {

  122.                     //        agvFryPotEmptyRollerArrive = true;

  123.                     //    }

  124.                     //}

  125.                 }

  126.             }

  127.         }

  128. 

  129.         /// <summary>

  130.         /// 主任务重启

  131.         /// </summary>

  132.         private void ResetProgram()

  133.         {

  134.             ThreadManage.GetInstance().StartLong(new Action(() =>

  135.             {

  136.                 if (RTrig.GetInstance("ResetProgram").Start(globalVar.PlcInite == 1))//判断是否初始化 一初始化就重启主任务

  137.                 {

  138.                     MessageLog.GetInstance.ShowRunLog("主任务正在重启");

  139.                     ThreadManage.GetInstance().StopTask("MainTask", new Action(() =>

  140.                     {

  141.                         ThreadManage.GetInstance().StopTask("MainViewReadPlcData", new Action(() =>

  142.                         {

  143.                             globalVar = null;

  144.                             globalVar = new GlobalVariable();

  145.                             ReicpeNum = 0;

  146.                             ActionManage.GetInstance.CancelRegister("RecipeSetDown");

  147.                             ActionManage.GetInstance.Register(new Action<object>(RecipeDataParse), "RecipeSetDown");

  148.                             ActionManage.GetInstance.Send("ClearRecipes");

  149.                             ReadPlcData();

  150.                             IniteTask();

  151.                             MessageLog.GetInstance.ShowRunLog("主任务重启完成");

  152.                         }));

  153.                     }));

  154.                 }

  155. 

  156.                 Thread.Sleep(10);

  157.             }), "ResetProgram");

  158.         }

  159.         /// <summary>

  160.         /// 实时获取plc数据

  161.         /// </summary>

  162.         public void ReadPlcData()

  163.         {

  164.             ThreadManage.GetInstance().StartLong(new Action(() =>

  165.             {

  166.                 GetAddressData("D2001", new Action<ushort[]>((data) =>

  167.                 {

  168.                     globalVar.rollerLineOne.StationOne = data[0];

  169.                     globalVar.rollerLineOne.StationTwo = data[1];

  170.                     globalVar.rollerLineOne.StationThree = data[2];

  171.                     globalVar.rollerLineOne.StationFour = data[3];

  172.                     globalVar.rollerLineOne.StationFive = data[4];

  173.                     globalVar.rollerLineOne.StationSix = data[5];

  174.                     globalVar.rollerLineOne.StationSeven = data[6];

  175.                     globalVar.rollerLineOne.StationEight = data[7];

  176.                 }));

  177.                 GetAddressData("D2011", new Action<ushort[]>((data) =>

  178.                 {

  179.                     globalVar.rollerLineTwo.StationOne = data[0];

  180.                     globalVar.rollerLineTwo.StationTwo = data[1];

  181.                     globalVar.rollerLineTwo.StationThree = data[2];

  182.                     globalVar.rollerLineTwo.StationFour = data[3];

  183.                     globalVar.rollerLineTwo.StationFive = data[4];

  184.                     globalVar.rollerLineTwo.StationSix = data[5];

  185.                     globalVar.rollerLineTwo.StationSeven = data[6];

  186.                     globalVar.rollerLineTwo.StationEight = data[7];

  187.                 }));

  188.                 GetAddressData("D2021", new Action<ushort[]>((data) =>

  189.                 {

  190.                     globalVar.rollerLineThree.StationOne = data[0];

  191.                     globalVar.rollerLineThree.StationTwo = data[1];

  192.                     globalVar.rollerLineThree.StationThree = data[2];

  193.                     globalVar.rollerLineThree.StationFour = data[3];

  194.                     globalVar.rollerLineThree.StationFive = data[4];

  195.                     globalVar.rollerLineThree.StationSix = data[5];

  196.                     globalVar.rollerLineThree.StationSeven = data[6];

  197.                     globalVar.rollerLineThree.StationEight = data[7];

  198.                 }));

  199.                 GetAddressData("D2031", new Action<ushort[]>((data) =>

  200.                 {

  201.                     globalVar.rollerLineOne.OutMaterialingSingle = data[3];

  202.                     globalVar.rollerLineTwo.OutMaterialingSingle = data[4];

  203.                     globalVar.rollerLineThree.OutMaterialingSingle = data[5];

  204.                     globalVar.rollerLineOne.OutMaterialingTroubleSingle = data[6];

  205.                     globalVar.rollerLineTwo.OutMaterialingTroubleSingle = data[7];

  206.                     globalVar.rollerLineThree.OutMaterialingTroubleSingle = data[8];

  207.                 }));

  208.                 GetAddressData("D2040", new Action<ushort[]>((data) =>

  209.                 {

  210.                     globalVar.fryPotOne.InputMaterialRollerRunningSingle = data[0];

  211.                     globalVar.fryPotTwo.InputMaterialRollerRunningSingle = data[1];

  212.                     globalVar.fryPotThree.InputMaterialRollerRunningSingle = data[2];

  213.                     globalVar.fryPotFour.InputMaterialRollerRunningSingle = data[3];

  214.                     globalVar.fryPotFive.InputMaterialRollerRunningSingle = data[4];

  215.                 }));

  216.                 GetAddressData("D2045", new Action<ushort[]>((data) =>

  217.                 {

  218.                     globalVar.fryPotOne.InputMaterialArrivedSingle = data[0];

  219.                     globalVar.fryPotTwo.InputMaterialArrivedSingle = data[1];

  220.                     globalVar.fryPotThree.InputMaterialArrivedSingle = data[2];

  221.                     globalVar.fryPotFour.InputMaterialArrivedSingle = data[3];

  222.                     globalVar.fryPotFive.InputMaterialArrivedSingle = data[4];

  223.                 }));

  224.                 GetAddressData("D2050", new Action<ushort[]>((data) =>

  225.                 {

  226.                     globalVar.fryPotOne.EmptyBarrelArrivedSingle = data[0];

  227.                     globalVar.fryPotTwo.EmptyBarrelArrivedSingle = data[1];

  228.                     globalVar.fryPotThree.EmptyBarrelArrivedSingle = data[2];

  229.                     globalVar.fryPotFour.EmptyBarrelArrivedSingle = data[3];

  230.                     globalVar.fryPotFive.EmptyBarrelArrivedSingle = data[4];

  231.                 }));

  232.                 GetAddressData("D2065", new Action<ushort[]>((data) =>

  233.                 {

  234.                     globalVar.fryPotOne.EmptyBarrelRollerRunningSingle = data[0];

  235.                     globalVar.fryPotTwo.EmptyBarrelRollerRunningSingle = data[1];

  236.                     globalVar.fryPotThree.EmptyBarrelRollerRunningSingle = data[2];

  237.                     globalVar.fryPotFour.EmptyBarrelRollerRunningSingle = data[3];

  238.                     globalVar.fryPotFive.EmptyBarrelRollerRunningSingle = data[4];

  239.                 }));

  240.                 GetAddressData("D2070", new Action<ushort[]>((data) =>

  241.                 {

  242.                     globalVar.fryPotOne.RollerTroubleSingle = data[0];

  243.                     globalVar.fryPotTwo.RollerTroubleSingle = data[1];

  244.                     globalVar.fryPotThree.RollerTroubleSingle = data[2];

  245.                     globalVar.fryPotFour.RollerTroubleSingle = data[3];

  246.                     globalVar.fryPotFive.RollerTroubleSingle = data[4];

  247.                 }));

  248.                 GetAddressData("D2078", new Action<ushort[]>(data =>

  249.                 {

  250.                     globalVar.rollerLineOne.RecipeCompleteSingle = data[0];

  251.                     globalVar.rollerLineTwo.RecipeCompleteSingle = data[1];

  252.                     globalVar.rollerLineThree.RecipeCompleteSingle = data[2];

  253.                 }));

  254.                 GetAddressData("D2075", new Action<ushort[]>(data =>

  255.                 {

  256. 

  257.                     globalVar.CleadBarrelEnterSingle = data[0];

  258.                 }));

  259.                 GetAddressData("D2077", new Action<ushort[]>(data =>

  260.                 {

  261. 

  262.                     globalVar.CleadBarrelExitSingle = data[0];

  263.                 }));

  264.                 //globalVar.rollerLineOne.OutMaterialingSingle = 0;

  265.                 //globalVar.rollerLineOne.StationOne = 401;

  266.                 //globalVar.rollerLineOne.StationTwo = 402;

  267.                 //globalVar.rollerLineOne.OutMaterialingTroubleSingle = 1;

  268.                 RollerLineStatusDisplay();

  269.                 Thread.Sleep(10);

  270.             }), "MainViewReadPlcData");

  271. 

  272.         }

  273.         /// <summary>

  274.         /// 滚筒线运行状态显示

  275.         /// </summary>

  276.         private void RollerLineStatusDisplay()

  277.         {

  278.             hardWareStatusModel.RollerOneModel.LocOneRollerSerial = globalVar.rollerLineOne.StationOne;

  279.             hardWareStatusModel.RollerOneModel.LocTwoRollerSerial = globalVar.rollerLineOne.StationTwo;

  280.             hardWareStatusModel.RollerOneModel.LocThreeRollerSerial = globalVar.rollerLineOne.StationThree;

  281.             hardWareStatusModel.RollerOneModel.LocFourRollerSerial = globalVar.rollerLineOne.StationFour;

  282.             hardWareStatusModel.RollerOneModel.LocFiveRollerSerial = globalVar.rollerLineOne.StationFive;

  283.             hardWareStatusModel.RollerOneModel.LocSixRollerSerial = globalVar.rollerLineOne.StationSix;

  284.             hardWareStatusModel.RollerOneModel.LocSevenRollerSerial = globalVar.rollerLineOne.StationSeven;

  285.             hardWareStatusModel.RollerOneModel.LocEightRollerSerial = globalVar.rollerLineOne.StationEight;

  286.             if (globalVar.rollerLineOne.OutMaterialingTroubleSingle == 0)

  287.             {

  288. 

  289.                 hardWareStatusModel.RollerOneModel.RollerAlarmState = Color.FromRgb(130, 232, 139);//无故障

  290.             }

  291.             else

  292.             {

  293. 

  294.                 hardWareStatusModel.RollerOneModel.RollerAlarmState = Color.FromRgb(255, 51, 153);//有故障

  295.             }

  296.             if (globalVar.rollerLineOne.OutMaterialingSingle == 1)//运行中

  297.             {

  298. 

  299.                 hardWareStatusModel.RollerOneModel.RollerRunState = Color.FromRgb(130, 232, 139);//运行中

  300.             }

  301.             else

  302.             {

  303. 

  304.                 hardWareStatusModel.RollerOneModel.RollerRunState = Color.FromRgb(84, 84, 84);//未运行

  305.             }

  306.             hardWareStatusModel.RollerTwoModel.LocOneRollerSerial = globalVar.rollerLineTwo.StationOne;

  307.             hardWareStatusModel.RollerTwoModel.LocTwoRollerSerial = globalVar.rollerLineTwo.StationTwo;

  308.             hardWareStatusModel.RollerTwoModel.LocThreeRollerSerial = globalVar.rollerLineTwo.StationThree;

  309.             hardWareStatusModel.RollerTwoModel.LocFourRollerSerial = globalVar.rollerLineTwo.StationFour;

  310.             hardWareStatusModel.RollerTwoModel.LocFiveRollerSerial = globalVar.rollerLineTwo.StationFive;

  311.             hardWareStatusModel.RollerTwoModel.LocSixRollerSerial = globalVar.rollerLineTwo.StationSix;

  312.             hardWareStatusModel.RollerTwoModel.LocSevenRollerSerial = globalVar.rollerLineTwo.StationSeven;

  313.             hardWareStatusModel.RollerTwoModel.LocEightRollerSerial = globalVar.rollerLineTwo.StationEight;

  314.             if (globalVar.rollerLineTwo.OutMaterialingTroubleSingle == 0)

  315.             {

  316.                 hardWareStatusModel.RollerTwoModel.RollerAlarmState = Color.FromRgb(130, 232, 139);//无故障

  317.             }

  318.             else

  319.             {

  320. 

  321.                 hardWareStatusModel.RollerTwoModel.RollerAlarmState = Color.FromRgb(255, 51, 153);//有故障

  322.             }

  323.             if (globalVar.rollerLineTwo.OutMaterialingSingle == 1)//运行中

  324.             {

  325. 

  326.                 hardWareStatusModel.RollerTwoModel.RollerRunState = Color.FromRgb(130, 232, 139);//运行中

  327. 

  328.             }

  329.             else

  330.             {

  331.                 hardWareStatusModel.RollerTwoModel.RollerRunState = Color.FromRgb(84, 84, 84);//未运行

  332.             }

  333.             hardWareStatusModel.RollerThreeModel.LocOneRollerSerial = globalVar.rollerLineThree.StationOne;

  334.             hardWareStatusModel.RollerThreeModel.LocTwoRollerSerial = globalVar.rollerLineThree.StationTwo;

  335.             hardWareStatusModel.RollerThreeModel.LocThreeRollerSerial = globalVar.rollerLineThree.StationThree;

  336.             hardWareStatusModel.RollerThreeModel.LocFourRollerSerial = globalVar.rollerLineThree.StationFour;

  337.             hardWareStatusModel.RollerThreeModel.LocFiveRollerSerial = globalVar.rollerLineThree.StationFive;

  338.             hardWareStatusModel.RollerThreeModel.LocSixRollerSerial = globalVar.rollerLineThree.StationSix;

  339.             hardWareStatusModel.RollerThreeModel.LocSevenRollerSerial = globalVar.rollerLineThree.StationSeven;

  340.             hardWareStatusModel.RollerThreeModel.LocEightRollerSerial = globalVar.rollerLineThree.StationEight;

  341.             if (globalVar.rollerLineThree.OutMaterialingTroubleSingle == 0)

  342.             {

  343.                 hardWareStatusModel.RollerThreeModel.RollerAlarmState = Color.FromRgb(130, 232, 139);//无故障

  344.             }

  345.             else

  346.             {

  347.                 hardWareStatusModel.RollerThreeModel.RollerAlarmState = Color.FromRgb(255, 51, 153);//有故障

  348.             }

  349.             if (globalVar.rollerLineThree.OutMaterialingSingle == 1)//运行中

  350.             {

  351.                 hardWareStatusModel.RollerThreeModel.RollerRunState = Color.FromRgb(130, 232, 139);//运行中

  352.             }

  353.             else

  354.             {

  355.                 hardWareStatusModel.RollerThreeModel.RollerRunState = Color.FromRgb(84, 84, 84);//未运行

  356.             }

  357.             //滚筒线4

  358. 

  359.         }

  360.         /// <summary>

  361.         /// 返回指定地址指定长度的数据

  362.         /// </summary>

  363.         /// <param name="address"></param>

  364.         /// <returns></returns>

  365.         public void GetAddressData(string address, Action<ushort[]> action)

  366.         {

  367.             PlcReadData = DeviceOperate.GetInstance.GetAllData();

  368.             if (PlcReadData.ContainsKey(address))

  369.             {

  370.                 action((ushort[])(PlcReadData[address]));

  371.             }

  372.         }

  373.         /// <summary>

  374.         /// 写Plc数据

  375.         /// </summary>

  376.         /// <param name="address"></param>

  377.         /// <param name="Value"></param>

  378.         public void WritePlcData(string address, ushort Value)

  379.         {

  380.             DeviceOperate.GetInstance.WritePlcData(address, Value);

  381.         }

  382.         /// <summary>

  383.         /// 初始化任务

  384.         /// </summary>

  385.         public void IniteTask()

  386.         {

  387.             ThreadManage.GetInstance().StartLong(new Action(() =>

  388.             {

  389.                 MainTask();

  390.             }), "MainTask");

  391.         }

  392.         /// <summary>

  393.         /// 配方数据接收

  394.         /// </summary>

  395.         public void RecipeDataParse(object obj)

  396.         {

  397.             Task.Run(new Action(() =>

  398.             {

  399.                 if (obj != null && obj is NewRecipeModel recipe)

  400.                 {

  401.                     RecipeQuene.Enqueue(recipe);

  402.                     ReicpeNum++;

  403.                     MessageLog.GetInstance.ShowRunLog($"接收到第{ReicpeNum}个配方");

  404.                 }

  405. 

  406.             }));

  407. 

  408. 

  409. 

  410.         }

  411.         /// <summary>

  412.         /// 开启主任务

  413.         /// </summary>

  414.         public void MainTask()

  415.         {

  416.             RecipeDataToPlc();

  417.             AgvLoadRoller();

  418.             FryPotInputMaterial();

  419.             FryPotOutputMaterial();

  420.         }

  421.         /// <summary>

  422.         /// 数据下发PLC

  423.         /// </summary>

  424.         public void RecipeDataToPlc()

  425.         {

  426.             if (RecipeQuene.Count > 0 && OutputMaterialQuene.Count == 0 && InputMaterialQuene.Count == 0)//后续添加其它限制条件

  427.             {

  428.                 //NewRecipeModel newRecipe = new NewRecipeModel();

  429.                 MaterialType material = new MaterialType();

  430.                 if (RecipeQuene.TryDequeue(out NewRecipeModel result))

  431.                 {

  432.                     MessageLog.GetInstance.ShowRunLog($"开始制作【{result.RecipeName}】 配方");

  433.                     //for (int k = 0; k < result.materialCollection.Count-1; k++)

  434.                     //{

  435.                     //    for (int j = 0; j < result.materialCollection.Count-1-k; j++)

  436.                     //    {

  437.                     //        if (result.materialCollection[j].MaterialLoc > result.materialCollection[j + 1].MaterialLoc)

  438.                     //        {

  439.                     //            material = result.materialCollection[j];

  440.                     //            result.materialCollection[j] = result.materialCollection[j + 1];

  441.                     //            result.materialCollection[j + 1] = material;

  442.                     //        }

  443.                     //    }

  444.                     //}

  445.                     for (int i = 0; i < result.materialCollection.Count; i++) //遍历单个配方中所有物料

  446.                     {

  447.                         //将配方中原料加入新的队列

  448.                         InputMaterialQuene.Enqueue(new MaterialInfo()

  449.                         {

  450.                             materialType = result.materialCollection[i],

  451.                             materialId = result.RecipeId

  452.                         });

  453.                         ushort n = result.materialCollection[i].MaterialLoc;

  454.                         switch (n / 100)

  455.                         {

  456.                             case 1:

  457.                             case 4: RollerOneDataWrite(i, result.materialCollection[i].MaterialLoc, result.materialCollection[i].MaterialWeight); break;//1号滚筒线桶号以及重量数据下发

  458.                             case 2:

  459.                             case 5: RollerTwoDataWrite(i, result.materialCollection[i].MaterialLoc, result.materialCollection[i].MaterialWeight); break;//2号滚筒线桶号以及重量数据下发

  460.                             case 3: RollerThreeDataWrite(i, result.materialCollection[i].MaterialLoc, result.materialCollection[i].MaterialWeight); break;//3号滚筒线桶号以及重量数据下发

  461.                         }

  462.                     }

  463.                     switch (result.materialCollection[0].MaterialLoc / 100)

  464.                     {

  465.                         case 1:

  466.                             DeviceOperate.GetInstance.WritePlcData("D1009", (ushort)result.materialCollection.Count); break;//发送1号滚筒线工序数据

  467.                         case 2:

  468.                             DeviceOperate.GetInstance.WritePlcData("D1026", (ushort)result.materialCollection.Count); break;//发送2号滚筒线工序数据

  469.                         case 3:

  470.                             DeviceOperate.GetInstance.WritePlcData("D1043", (ushort)result.materialCollection.Count); break;//发送3号滚筒线工序数据

  471.                     }

  472.                 }

  473.             }

  474. 

  475.         }

  476.         /// <summary>

  477.         /// AGV到配方对应线体装桶以及出料到炒锅

  478.         /// </summary>

  479.         public void AgvLoadRoller()

  480.         {

  481.             //lineAlarm = 0;

  482.             if (InputMaterialQuene.Count > 0)

  483.             {

  484.                 switch (InputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  485.                 {

  486.                     case 1:

  487.                     case 4: AgvToLineOneLoadRoller(); AgvFromLineOneToFryPot(); break;//AGV到1号线体装桶

  488.                     case 2:

  489.                     case 5: AgvToLineTwoLoadRoller(); AgvFromLineTwoToFryPot(); break;//AGV到2号线体装桶

  490.                     case 3: AgvToLineThreeLoadRoller(); AgvFromLineThreeToFryPot(); break;//AGV到3号线体装桶

  491.                 }

  492.             }

  493. 

  494.         }

  495.         /// <summary>

  496.         /// AGV从炒锅送料位置到倒料过程处理

  497.         /// </summary>

  498.         public void FryPotInputMaterial()

  499.         {

  500.             if (OutputMaterialQuene.Count > 0 && !globalVar.InOrOutputLock)

  501.             {

  502. 

  503.                 while (!agvArriveUnLoad)//等待agv到达炒锅位置

  504.                 {

  505.                     Thread.Sleep(5);

  506.                     if (globalVar.ExitMainTask)

  507.                         return;

  508.                 }

  509.                 AgvArriveFryPotSingleSetDown();

  510.                 FryPotRollerTroubleCheck();

  511.                 if (FryPotAlarm == 1)//炒锅滚筒无故障

  512.                 {

  513.                     //炒锅滚筒进料运行到位处理

  514.                     FryPotInputMaterialRollerOperate();

  515.                     globalVar.InOrOutputLock = true;

  516.                 }

  517. 

  518.             }

  519. 

  520.         }

  521.         /// <summary>

  522.         /// 炒锅出桶

  523.         /// </summary>

  524.         public void FryPotOutputMaterial()

  525.         {

  526.             if (OutputMaterialQuene.Count > 0 && globalVar.InOrOutputLock)

  527.             {

  528.                 AgvFromFryPotToClean();//上游下发搬运任务给AGV

  529.                 while (!agvArriveUpLoad)//等待agv到达炒锅位置

  530.                 {

  531.                     Thread.Sleep(5);

  532.                     if (globalVar.ExitMainTask)

  533.                         return;

  534.                 }

  535.                 agvArriveUpLoad = false;

  536.                 AgvArriveFryPotOutEmptyRollerSingleSetDown();//暂时考虑agv送完料后原地等待，不加条件，直接发送到位信号

  537.                 FryPotRollerTroubleCheck();

  538.                 if (FryPotAlarm == 1)//无故障

  539.                 {

  540.                     FryPotOutEmpetyRollerOperate();

  541.                     if (OutputMaterialQuene.TryDequeue(out MaterialInfo materialInfo))//空桶出桶后，出料原料队列移除对应原料

  542.                     {

  543.                         while (!agvFryPotEmptyRollerArrive)//等待AGV拿到出桶空桶

  544.                         {

  545.                             Thread.Sleep(5);

  546.                             if (globalVar.ExitMainTask)

  547.                                 return;

  548.                         }

  549.                         //AGV拿到空桶,让AGV运桶到指定位置，同时可以让下一个AGV从线体装料运到炒锅

  550.                         globalVar.AllowAgvToLineLoadRoller = true;

  551.                         globalVar.InOrOutputLock = false;

  552.                     }

  553.                 }

  554. 

  555.             }

  556.         }

  557.         /// <summary>

  558.         /// 炒锅滚筒进料运行到位处理

  559.         /// </summary>

  560.         public void FryPotInputMaterialRollerOperate()

  561.         {

  562.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  563.             {

  564.                 case 1:

  565.                     while (globalVar.fryPotOne.InputMaterialArrivedSingle == 0)

  566.                     {

  567.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  568.                             return;

  569.                     }

  570.                     MessageLog.GetInstance.ShowRunLog($"炒锅【1】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}已到进料位置，准备倒料"); break;

  571.                 case 2:

  572.                     while (globalVar.fryPotTwo.InputMaterialArrivedSingle == 0)

  573.                     {

  574.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  575.                             return;

  576.                     }

  577.                     MessageLog.GetInstance.ShowRunLog($"炒锅【2】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}已到进料位置，准备倒料"); break;

  578.                 case 3:

  579.                     while (globalVar.fryPotThree.InputMaterialArrivedSingle == 0)

  580.                     {

  581.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  582.                             return;

  583.                     }

  584.                     MessageLog.GetInstance.ShowRunLog($"炒锅【3】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}已到进料位置，准备倒料"); break;

  585.                 case 4:

  586.                     while (globalVar.fryPotFour.InputMaterialArrivedSingle == 0)

  587.                     {

  588.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  589.                             return;

  590.                     }

  591.                     MessageLog.GetInstance.ShowRunLog($"炒锅【4】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}已到进料位置，准备倒料"); break;

  592.                 case 5:

  593.                     while (globalVar.fryPotFive.InputMaterialArrivedSingle == 0)

  594.                     {

  595.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  596.                             return;

  597.                     }

  598.                     MessageLog.GetInstance.ShowRunLog($"炒锅【5】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}已到进料位置，准备倒料"); break;

  599.             }

  600. 

  601.         }

  602.         /// <summary>

  603.         /// 炒锅滚筒空桶出桶处理

  604.         /// </summary>

  605.         public void FryPotOutEmpetyRollerOperate()

  606.         {

  607.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  608.             {

  609.                 case 1:

  610.                     while (globalVar.fryPotOne.EmptyBarrelArrivedSingle == 0)

  611.                     {

  612.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  613.                             return;

  614.                     }

  615.                     MessageLog.GetInstance.ShowRunLog($"炒锅【1】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}空桶到达出桶位置,正在出桶"); break;

  616.                 case 2:

  617.                     while (globalVar.fryPotTwo.EmptyBarrelArrivedSingle == 0)

  618.                     {

  619.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  620.                             return;

  621.                     }

  622.                     MessageLog.GetInstance.ShowRunLog($"炒锅【2】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}空桶到达出桶位置,正在出桶"); break;

  623.                 case 3:

  624.                     while (globalVar.fryPotThree.EmptyBarrelArrivedSingle == 0)

  625.                     {

  626.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  627.                             return;

  628.                     }

  629.                     MessageLog.GetInstance.ShowRunLog($"炒锅【3】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}空桶到达出桶位置,正在出桶"); break;

  630.                 case 4:

  631.                     while (globalVar.fryPotFour.EmptyBarrelArrivedSingle == 0)

  632.                     {

  633.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  634.                             return;

  635.                     }

  636.                     MessageLog.GetInstance.ShowRunLog($"炒锅【4】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}空桶到达出桶位置,正在出桶"); break;

  637.                 case 5:

  638.                     while (globalVar.fryPotFive.EmptyBarrelArrivedSingle == 0)

  639.                     {

  640.                         Thread.Sleep(5); if (globalVar.ExitMainTask)

  641.                             return;

  642.                     }

  643.                     MessageLog.GetInstance.ShowRunLog($"炒锅【5】原料：{OutputMaterialQuene.ElementAt(0).materialType.MaterialName}空桶到达出桶位置,正在出桶"); break;

  644. 

  645.             }

  646.         }

  647.         /// <summary>

  648.         /// 发送agv送料就位信号至PLC（线体到炒锅）

  649.         /// </summary>

  650.         public void AgvArriveFryPotSingleSetDown()

  651.         {

  652.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  653.             {

  654.                 case 1: DeviceOperate.GetInstance.WritePlcData("D1055", 1); break;//agv到炒锅1送料就位信号

  655.                 case 2: DeviceOperate.GetInstance.WritePlcData("D1056", 1); break;//agv到炒锅2送料就位信号

  656.                 case 3: DeviceOperate.GetInstance.WritePlcData("D1057", 1); break;//agv到炒锅3送料就位信号

  657.                 case 4: DeviceOperate.GetInstance.WritePlcData("D1058", 1); break;//agv到炒锅4送料就位信号

  658.                 case 5: DeviceOperate.GetInstance.WritePlcData("D1059", 1); break;//agv到炒锅5送料就位信号

  659.             }

  660.         }

  661.         /// <summary>

  662.         /// 发送agv回桶就位信号至PLC

  663.         /// </summary>

  664.         public void AgvArriveFryPotOutEmptyRollerSingleSetDown()

  665.         {

  666.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  667.             {

  668.                 case 1: DeviceOperate.GetInstance.WritePlcData("D1060", 1); break;//agv到炒锅1送料就位信号

  669.                 case 2: DeviceOperate.GetInstance.WritePlcData("D1061", 1); break;//agv到炒锅2送料就位信号

  670.                 case 3: DeviceOperate.GetInstance.WritePlcData("D1062", 1); break;//agv到炒锅3送料就位信号

  671.                 case 4: DeviceOperate.GetInstance.WritePlcData("D1063", 1); break;//agv到炒锅4送料就位信号

  672.                 case 5: DeviceOperate.GetInstance.WritePlcData("D1064", 1); break;//agv到炒锅5送料就位信号

  673.             }

  674.         }

  675.         /// <summary>

  676.         /// AGV离开炒锅运送空桶任务

  677.         /// </summary>

  678.         public void AgvFromFryPotToClean()

  679.         {

  680.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  681.             {

  682.                 case 1:

  683.                 erp: string id = Guid.NewGuid().ToString("N");//上游唯一ID

  684.                     if (id == robotJobId)

  685.                     {

  686.                         goto erp;

  687.                     }

  688.                     string info = AGVHelper.GetInstance.AgvLeaveFryPotOne(id);

  689.                     robotJobId = id;

  690.                     FryCarryTaskErrorCodeAnalysis(info, 1); break;

  691.                 case 2:

  692.                 erp1: string id1 = Guid.NewGuid().ToString("N");//上游唯一ID

  693.                     if (id1 == robotJobId)

  694.                     {

  695.                         goto erp1;

  696.                     }

  697.                     string info1 = AGVHelper.GetInstance.AgvLeaveFryPotTwo(id1);

  698.                     robotJobId = id1;

  699.                     FryCarryTaskErrorCodeAnalysis(info1, 2); break;

  700.                 case 3:

  701.                 erp2: string id2 = Guid.NewGuid().ToString("N");//上游唯一ID

  702.                     if (id2 == robotJobId)

  703.                     {

  704.                         goto erp2;

  705.                     }

  706.                     string info2 = AGVHelper.GetInstance.AgvLeaveFryPotThree(id2);

  707.                     robotJobId = id2;

  708.                     FryCarryTaskErrorCodeAnalysis(info2, 3); break;

  709.                 case 4:

  710.                 erp3: string id3 = Guid.NewGuid().ToString("N");//上游唯一ID

  711.                     if (id3 == robotJobId)

  712.                     {

  713.                         goto erp3;

  714.                     }

  715.                     string info3 = AGVHelper.GetInstance.AgvLeaveFryPotFour(id3);

  716.                     robotJobId = id3;

  717.                     FryCarryTaskErrorCodeAnalysis(info3, 4); break;

  718.                 case 5:

  719.                 erp4: string id4 = Guid.NewGuid().ToString("N");//上游唯一ID

  720.                     if (id4 == robotJobId)

  721.                     {

  722.                         goto erp4;

  723.                     }

  724.                     string info4 = AGVHelper.GetInstance.AgvLeaveFryPotFive(id4);

  725.                     robotJobId = id4;

  726.                     FryCarryTaskErrorCodeAnalysis(info4, 5); break;

  727.             }

  728.         }

  729.         /// <summary>

  730.         /// 处理agv从线体1到送料到炒锅的条件

  731.         /// </summary>

  732.         /// <param name="lineAlarm"></param>

  733.         public void AgvFromLineOneToFryPot()

  734.         {

  735.         erp: if (globalVar.rollerLineOne.OutMaterialingTroubleSingle == 0)//无故障

  736.             {

  737.                 while (!agvArriveUpLoad)//等待AGV到线体装料位置

  738.                 {

  739.                     Thread.Sleep(5);

  740.                     if (globalVar.ExitMainTask)

  741.                         return;

  742.                 }

  743.                 agvArriveUpLoad = false;

  744.                 AgvArriveLineSingelSetDown();

  745.                 if (InputMaterialQuene.TryDequeue(out MaterialInfo materialInfo))

  746.                 {

  747.                     while (!(globalVar.rollerLineOne.StationEight == materialInfo.materialType.MaterialLoc))//等待线体工号位8存放对应原料桶号

  748.                     {

  749.                         Thread.Sleep(5);

  750.                         if (globalVar.ExitMainTask)

  751.                             return;

  752.                     }

  753.                     OutputMaterialQuene.Enqueue(materialInfo);

  754.                     //原料到位，agv到位，agv自行运料到炒锅

  755.                 }

  756. 

  757.             }

  758.             else//有故障

  759.             {

  760.                 while (globalVar.rollerLineOne.OutMaterialingTroubleSingle == 1)

  761.                 {

  762.                     Thread.Sleep(50);

  763.                     if (globalVar.ExitMainTask)

  764.                         return;

  765.                 }

  766.                 MessageLog.GetInstance.ShowRunLog("线体【1】滚筒故障解除，继续运行");

  767.                 //lineAlarm = 1;

  768.                 goto erp;

  769.             }

  770.         }

  771.         /// <summary>

  772.         /// 处理agv从线体2到送料到炒锅的条件

  773.         /// </summary>

  774.         /// <param name="lineAlarm"></param>

  775.         public void AgvFromLineTwoToFryPot()

  776.         {

  777.         erp: if (globalVar.rollerLineTwo.OutMaterialingTroubleSingle == 0)//无故障

  778.             {

  779.                 while (!agvArriveUpLoad)//等待AGV到线体装料位置

  780.                 {

  781.                     Thread.Sleep(5);

  782.                     if (globalVar.ExitMainTask)

  783.                         return;

  784.                 }

  785.                 agvArriveUpLoad = false;

  786.                 AgvArriveLineSingelSetDown();

  787.                 if (InputMaterialQuene.TryDequeue(out MaterialInfo materialInfo))

  788.                 {

  789.                     while (!(globalVar.rollerLineTwo.StationEight == materialInfo.materialType.MaterialLoc))//等待线体工号位8存放对应原料桶号

  790.                     {

  791.                         Thread.Sleep(5);

  792.                         if (globalVar.ExitMainTask)

  793.                             return;

  794.                     }

  795.                     OutputMaterialQuene.Enqueue(materialInfo);

  796.                     //原料到位，agv到位，agv运料到炒锅

  797.                 }

  798. 

  799.             }

  800.             else//有故障

  801.             {

  802.                 while (globalVar.rollerLineTwo.OutMaterialingTroubleSingle == 1)

  803.                 {

  804.                     Thread.Sleep(50);

  805.                     if (globalVar.ExitMainTask)

  806.                         return;

  807.                 }

  808.                 MessageLog.GetInstance.ShowRunLog("线体【2】滚筒故障解除，继续运行");

  809.                 // lineAlarm = 1;

  810.                 goto erp;

  811.             }

  812.         }

  813.         /// <summary>

  814.         /// 处理agv从线体3到送料到炒锅的条件

  815.         /// </summary>

  816.         /// <param name="lineAlarm"></param>

  817.         public void AgvFromLineThreeToFryPot()

  818.         {

  819.         erp: if (globalVar.rollerLineThree.OutMaterialingTroubleSingle == 0)//无故障

  820.             {

  821.                 while (!agvArriveUpLoad)//等待AGV到线体装料位置

  822.                 {

  823.                     Thread.Sleep(5);

  824.                     if (globalVar.ExitMainTask)

  825.                         return;

  826.                 }

  827.                 agvArriveUpLoad = false;

  828.                 AgvArriveLineSingelSetDown();

  829.                 if (InputMaterialQuene.TryDequeue(out MaterialInfo materialInfo))

  830.                 {

  831.                     while (!(globalVar.rollerLineThree.StationEight == materialInfo.materialType.MaterialLoc))//等待线体工号位8存放对应原料桶号

  832.                     {

  833.                         Thread.Sleep(5);

  834.                         if (globalVar.ExitMainTask)

  835.                             return;

  836.                     }

  837.                     OutputMaterialQuene.Enqueue(materialInfo);

  838.                     //原料到位，agv到位，agv运料到炒锅

  839.                 }

  840. 

  841.             }

  842.             else //有故障

  843.             {

  844.                 while (globalVar.rollerLineThree.OutMaterialingTroubleSingle == 1)

  845.                 {

  846.                     Thread.Sleep(50);

  847.                     if (globalVar.ExitMainTask)

  848.                         return;

  849.                 }

  850.                 MessageLog.GetInstance.ShowRunLog("线体【3】滚筒故障解除，继续运行");

  851.                 // lineAlarm = 1;

  852.                 goto erp;

  853.             }

  854.         }

  855.         /// <summary>

  856.         /// 线体搬运任务错误码分析

  857.         /// </summary>

  858.         /// <param name="errorCode"></param>

  859.         /// <param name="num"></param>

  860.         public void LineCarryTaskErrorCodeAnalysis(string errorCode, int num)

  861.         {

  862.             if (errorCode == "SUCCESS")

  863.             {

  864.                 MessageLog.GetInstance.ShowRunLog($"AGV去{num}号线体");

  865.                 globalVar.AllowAgvToLineLoadRoller = false;

  866.             }

  867.             else if (errorCode == "Analysis Error")

  868.             {

  869.                 MessageLog.GetInstance.ShowRunLog($"提示：AGV去{num}号线体接口调用失败，请检查");

  870.             }

  871.             else

  872.             {

  873.                 MessageLog.GetInstance.ShowRunLog($"提示：AGV去{num}号线体失败，错误码:{errorCode}");

  874.             }

  875.         }

  876.         /// <summary>

  877.         /// 炒锅搬运任务错误码分析

  878.         /// </summary>

  879.         /// <param name="errorCode"></param>

  880.         /// <param name="num"></param>

  881.         public void FryCarryTaskErrorCodeAnalysis(string errorCode, int num)

  882.         {

  883.             if (errorCode == "SUCCESS")

  884.             {

  885.                 MessageLog.GetInstance.ShowRunLog($"AGV离开{num}号炒锅");

  886.             }

  887.             else if (errorCode == "Analysis Error")

  888.             {

  889.                 MessageLog.GetInstance.ShowRunLog($"提示：AGV离开{num}号炒锅接口调用失败，请检查");

  890.             }

  891.             else

  892.             {

  893.                 MessageLog.GetInstance.ShowRunLog($"提示：AGV离开{num}号炒锅失败，错误码:{errorCode}");

  894.             }

  895.         }

  896. 

  897.         public void AgvToLineOneLoadRoller()

  898.         {

  899.             if (globalVar.rollerLineOne.OutMaterialingTroubleSingle == 0)//输送线无故障

  900.             {

  901.                 if (InputMaterialQuene.Count > 0)

  902.                 {

  903.                     while (!globalVar.AllowAgvToLineLoadRoller || globalVar.rollerLineOne.OutMaterialingSingle == 0)

  904.                     {

  905.                         Thread.Sleep(5);

  906.                         if (globalVar.ExitMainTask)

  907.                             return;

  908.                     }

  909.                 e: string id = Guid.NewGuid().ToString("N");

  910.                     if (id == robotJobId)

  911.                         goto e;

  912.                     string info = AGVHelper.GetInstance.AgvToLineOneLoadRoller(id);

  913.                     robotJobId = id;

  914.                     Thread.Sleep(500);

  915.                     LineCarryTaskErrorCodeAnalysis(info, 1);

  916.                 }

  917.             }

  918.             else

  919.             {

  920.                 MessageLog.GetInstance.ShowRunLog("警告：滚筒输送线体【1】故障！！！");

  921.                 //  lineAlarm = -1;

  922.             }

  923.             // lineAlarm = 1;

  924.         }

  925.         public void AgvToLineTwoLoadRoller()

  926.         {

  927.             if (globalVar.rollerLineTwo.OutMaterialingTroubleSingle == 0)//输送线无故障

  928.             {

  929.                 if (InputMaterialQuene.Count > 0)

  930.                 {

  931.                     while (!globalVar.AllowAgvToLineLoadRoller || globalVar.rollerLineOne.OutMaterialingSingle == 0) //后续考虑是否用while

  932.                     {

  933.                         Thread.Sleep(5);

  934.                         if (globalVar.ExitMainTask)

  935.                             return;

  936.                     }

  937.                 p: string id = Guid.NewGuid().ToString();

  938.                     if (id == robotJobId)

  939.                         goto p;

  940.                     string info = AGVHelper.GetInstance.AgvToLineTwoLoadRoller(id);

  941.                     robotJobId = id;

  942.                     Thread.Sleep(500);

  943.                     LineCarryTaskErrorCodeAnalysis(info, 2);

  944.                 }

  945. 

  946.             }

  947.             else

  948.             {

  949.                 MessageLog.GetInstance.ShowRunLog("警告：滚筒输送线体【2】故障！！！");

  950.                 //lineAlarm = -1;

  951.             }

  952.             // lineAlarm = 1;

  953.         }

  954.         public void AgvToLineThreeLoadRoller()

  955.         {

  956.             if (globalVar.rollerLineThree.OutMaterialingTroubleSingle == 0)//输送线无故障

  957.             {

  958.                 if (InputMaterialQuene.Count > 0)

  959.                 {

  960.                     while (!globalVar.AllowAgvToLineLoadRoller || globalVar.rollerLineOne.OutMaterialingSingle == 0) //后续考虑是否用while

  961.                     {

  962.                         Thread.Sleep(5);

  963.                         if (globalVar.ExitMainTask)

  964.                             return;

  965.                     }

  966.                 g: string id = Guid.NewGuid().ToString();

  967.                     if (id == robotJobId)

  968.                         goto g;

  969.                     string info = AGVHelper.GetInstance.AgvToLineThreeLoadRoller(id);

  970.                     robotJobId = id;

  971.                     Thread.Sleep(500);

  972.                     LineCarryTaskErrorCodeAnalysis(info, 3);

  973.                 }

  974. 

  975.             }

  976.             else

  977.             {

  978.                 MessageLog.GetInstance.ShowRunLog("警告：滚筒输送线体【3】故障！！！");

  979.                 // lineAlarm = -1;

  980.             }

  981.             // lineAlarm = 1;

  982.         }

  983.         /// <summary>

  984.         /// 1号线体数据下发

  985.         /// </summary>

  986.         /// <param name="count"></param>

  987.         /// <param name="materialLoc"></param>

  988.         /// <param name="materialWeight"></param>

  989.         public void RollerOneDataWrite(int count, ushort materialLoc, ushort materialWeight)

  990.         {

  991.             switch (count)

  992.             {

  993.                 case 0:

  994.                     DeviceOperate.GetInstance.WritePlcData("D1001", materialLoc);//桶1位置

  995.                     DeviceOperate.GetInstance.WritePlcData("D1010", materialWeight);//桶2重量

  996.                     break;

  997.                 case 1:

  998.                     DeviceOperate.GetInstance.WritePlcData("D1002", materialLoc);//桶2位置

  999.                     DeviceOperate.GetInstance.WritePlcData("D1011", materialWeight);//桶2重量

  1000.                     break;

  1001.                 case 2:

  1002.                     DeviceOperate.GetInstance.WritePlcData("D1003", materialLoc);//桶3位置

  1003.                     DeviceOperate.GetInstance.WritePlcData("D1012", materialWeight);//桶3重量

  1004.                     break;

  1005.                 case 3:

  1006.                     DeviceOperate.GetInstance.WritePlcData("D1004", materialLoc);//桶4位置

  1007.                     DeviceOperate.GetInstance.WritePlcData("D1013", materialWeight);//桶4重量

  1008.                     break;

  1009.                 case 4:

  1010.                     DeviceOperate.GetInstance.WritePlcData("D1005", materialLoc);//桶5位置

  1011.                     DeviceOperate.GetInstance.WritePlcData("D1014", materialWeight);//桶5重量

  1012.                     break;

  1013.                 case 5:

  1014.                     DeviceOperate.GetInstance.WritePlcData("D1006", materialLoc);//桶6位置

  1015.                     DeviceOperate.GetInstance.WritePlcData("D1015", materialWeight);//桶6重量

  1016.                     break;

  1017.                 case 6:

  1018.                     DeviceOperate.GetInstance.WritePlcData("D1007", materialLoc);//桶7位置

  1019.                     DeviceOperate.GetInstance.WritePlcData("D1016", materialWeight);//桶7重量

  1020.                     break;

  1021.                 case 7:

  1022.                     DeviceOperate.GetInstance.WritePlcData("D1008", materialLoc);//桶8位置

  1023.                     DeviceOperate.GetInstance.WritePlcData("D1017", materialWeight);//桶8重量

  1024.                     break;

  1025. 

  1026.             }

  1027.         }

  1028.         /// <summary>

  1029.         /// 2号线体数据下发

  1030.         /// </summary>

  1031.         /// <param name="count"></param>

  1032.         /// <param name="materialLoc"></param>

  1033.         /// <param name="materialWeight"></param>

  1034.         public void RollerTwoDataWrite(int count, ushort materialLoc, ushort materialWeight)

  1035.         {

  1036.             switch (count)

  1037.             {

  1038.                 case 0:

  1039.                     DeviceOperate.GetInstance.WritePlcData("D1018", materialLoc);//桶1位置

  1040.                     DeviceOperate.GetInstance.WritePlcData("D1027", materialWeight);//桶2重量

  1041.                     break;

  1042.                 case 1:

  1043.                     DeviceOperate.GetInstance.WritePlcData("D1019", materialLoc);//桶2位置

  1044.                     DeviceOperate.GetInstance.WritePlcData("D1028", materialWeight);//桶2重量

  1045.                     break;

  1046.                 case 2:

  1047.                     DeviceOperate.GetInstance.WritePlcData("D1020", materialLoc);//桶3位置

  1048.                     DeviceOperate.GetInstance.WritePlcData("D1029", materialWeight);//桶3重量

  1049.                     break;

  1050.                 case 3:

  1051.                     DeviceOperate.GetInstance.WritePlcData("D1021", materialLoc);//桶4位置

  1052.                     DeviceOperate.GetInstance.WritePlcData("D1030", materialWeight);//桶4重量

  1053.                     break;

  1054.                 case 4:

  1055.                     DeviceOperate.GetInstance.WritePlcData("D1022", materialLoc);//桶5位置

  1056.                     DeviceOperate.GetInstance.WritePlcData("D1031", materialWeight);//桶5重量

  1057.                     break;

  1058.                 case 5:

  1059.                     DeviceOperate.GetInstance.WritePlcData("D1023", materialLoc);//桶6位置

  1060.                     DeviceOperate.GetInstance.WritePlcData("D1032", materialWeight);//桶6重量

  1061.                     break;

  1062.                 case 6:

  1063.                     DeviceOperate.GetInstance.WritePlcData("D1024", materialLoc);//桶7位置

  1064.                     DeviceOperate.GetInstance.WritePlcData("D1033", materialWeight);//桶7重量

  1065.                     break;

  1066.                 case 7:

  1067.                     DeviceOperate.GetInstance.WritePlcData("D1025", materialLoc);//桶8位置

  1068.                     DeviceOperate.GetInstance.WritePlcData("D1034", materialWeight);//桶8重量

  1069.                     break;

  1070. 

  1071.             }

  1072.         }

  1073.         /// <summary>

  1074.         /// 3号线体数据下发

  1075.         /// </summary>

  1076.         /// <param name="count"></param>

  1077.         /// <param name="materialLoc"></param>

  1078.         /// <param name="materialWeight"></param>

  1079.         public void RollerThreeDataWrite(int count, ushort materialLoc, ushort materialWeight)

  1080.         {

  1081.             switch (count)

  1082.             {

  1083.                 case 0:

  1084.                     DeviceOperate.GetInstance.WritePlcData("D1035", materialLoc);//桶1位置

  1085.                     DeviceOperate.GetInstance.WritePlcData("D1044", materialWeight);//桶2重量

  1086.                     break;

  1087.                 case 1:

  1088.                     DeviceOperate.GetInstance.WritePlcData("D1036", materialLoc);//桶2位置

  1089.                     DeviceOperate.GetInstance.WritePlcData("D1045", materialWeight);//桶2重量

  1090.                     break;

  1091.                 case 2:

  1092.                     DeviceOperate.GetInstance.WritePlcData("D1037", materialLoc);//桶3位置

  1093.                     DeviceOperate.GetInstance.WritePlcData("D1046", materialWeight);//桶3重量

  1094.                     break;

  1095.                 case 3:

  1096.                     DeviceOperate.GetInstance.WritePlcData("D1038", materialLoc);//桶4位置

  1097.                     DeviceOperate.GetInstance.WritePlcData("D1047", materialWeight);//桶4重量

  1098.                     break;

  1099.                 case 4:

  1100.                     DeviceOperate.GetInstance.WritePlcData("D1039", materialLoc);//桶5位置

  1101.                     DeviceOperate.GetInstance.WritePlcData("D1048", materialWeight);//桶5重量

  1102.                     break;

  1103.                 case 5:

  1104.                     DeviceOperate.GetInstance.WritePlcData("D1040", materialLoc);//桶6位置

  1105.                     DeviceOperate.GetInstance.WritePlcData("D1049", materialWeight);//桶6重量

  1106.                     break;

  1107.                 case 6:

  1108.                     DeviceOperate.GetInstance.WritePlcData("D1041", materialLoc);//桶7位置

  1109.                     DeviceOperate.GetInstance.WritePlcData("D1050", materialWeight);//桶7重量

  1110.                     break;

  1111.                 case 7:

  1112.                     DeviceOperate.GetInstance.WritePlcData("D1042", materialLoc);//桶8位置

  1113.                     DeviceOperate.GetInstance.WritePlcData("D1051", materialWeight);//桶8重量

  1114.                     break;

  1115. 

  1116.             }

  1117. 

  1118.         }

  1119.         /// <summary>

  1120.         /// AGV进料就位信号下发至PLC

  1121.         /// </summary>

  1122.         public void AgvArriveLineSingelSetDown()

  1123.         {

  1124.             switch (InputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  1125.             {

  1126.                 case 1:

  1127.                 case 4: DeviceOperate.GetInstance.WritePlcData("D1052", 1); break;//AGV进料就位信号1

  1128.                 case 2:

  1129.                 case 5: DeviceOperate.GetInstance.WritePlcData("D1053", 1); break;//AGV进料就位信号2

  1130.                 case 3: DeviceOperate.GetInstance.WritePlcData("D1054", 1); break;//AGV进料就位信号3

  1131.             }

  1132. 

  1133.         }

  1134.         /// <summary>

  1135.         /// 炒锅滚筒信号检测

  1136.         /// </summary>

  1137.         public void FryPotRollerTroubleCheck()

  1138.         {

  1139.             FryPotAlarm = 0;

  1140.             switch (OutputMaterialQuene.ElementAt(0).materialType.MaterialLoc / 100)

  1141.             {

  1142.                 case 1:

  1143.                     if (globalVar.fryPotOne.RollerTroubleSingle == 1) { FryPotAlarm = -1; MessageLog.GetInstance.ShowRunLog("警告：炒锅【1】输送滚筒发生故障"); } else { FryPotAlarm = 1; } while (globalVar.fryPotOne.RollerTroubleSingle == 1)

  1144.                     {

  1145.                         Thread.Sleep(50); if (globalVar.ExitMainTask)

  1146.                             return;

  1147.                     }

  1148.                     MessageLog.GetInstance.ShowRunLog("炒锅【1】输送滚筒故障解除，继续运行");

  1149.                     FryPotAlarm = 1; break;

  1150.                 case 2:

  1151.                     if (globalVar.fryPotTwo.RollerTroubleSingle == 1) { FryPotAlarm = -1; MessageLog.GetInstance.ShowRunLog("警告：炒锅【2】输送滚筒发生故障"); } else { FryPotAlarm = 1; } while (globalVar.fryPotTwo.RollerTroubleSingle == 1)

  1152.                     {

  1153.                         Thread.Sleep(50); if (globalVar.ExitMainTask)

  1154.                             return;

  1155.                     }

  1156.                     MessageLog.GetInstance.ShowRunLog("炒锅【2】输送滚筒故障解除，继续运行");

  1157.                     FryPotAlarm = 1; break;

  1158.                 case 3:

  1159.                     if (globalVar.fryPotThree.RollerTroubleSingle == 1) { FryPotAlarm = -1; MessageLog.GetInstance.ShowRunLog("警告：炒锅【3】输送滚筒发生故障"); } else { FryPotAlarm = 1; } while (globalVar.fryPotThree.RollerTroubleSingle == 1)

  1160.                     {

  1161.                         Thread.Sleep(50); if (globalVar.ExitMainTask)

  1162.                             return;

  1163.                     }

  1164.                     MessageLog.GetInstance.ShowRunLog("炒锅【3】输送滚筒故障解除，继续运行");

  1165.                     FryPotAlarm = 1; break;

  1166.                 case 4:

  1167.                     if (globalVar.fryPotFour.RollerTroubleSingle == 1) { FryPotAlarm = -1; MessageLog.GetInstance.ShowRunLog("警告：炒锅【4】输送滚筒发生故障"); } else { FryPotAlarm = 1; } while (globalVar.fryPotFour.RollerTroubleSingle == 1)

  1168.                     {

  1169.                         Thread.Sleep(50); if (globalVar.ExitMainTask)

  1170.                             return;

  1171.                     }

  1172.                     MessageLog.GetInstance.ShowRunLog("炒锅【4】输送滚筒故障解除，继续运行");

  1173.                     FryPotAlarm = 1; break;

  1174.                 case 5:

  1175.                     if (globalVar.fryPotFive.RollerTroubleSingle == 1) { FryPotAlarm = -1; MessageLog.GetInstance.ShowRunLog("警告：炒锅【5】输送滚筒发生故障"); } else { FryPotAlarm = 1; } while (globalVar.fryPotFive.RollerTroubleSingle == 1)

  1176.                     {

  1177.                         Thread.Sleep(50); if (globalVar.ExitMainTask)

  1178.                             return;

  1179.                     }

  1180.                     MessageLog.GetInstance.ShowRunLog("炒锅【5】输送滚筒故障解除，继续运行");

  1181.                     FryPotAlarm = 1; break;

  1182. 

  1183.             }

  1184.         }

  1185. 

  1186.     }

  1187. }