CPL
/
banboshi_V1
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
12 Commits
2 Branches
886 MiB
 
 
 
 
 
Tree: 0b61e83da6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0b61e83da6'
${ noResults }
banboshi_V1/halftoneproject-master/Code/FrmMain.cs

3720 lines
200 KiB
Raw Blame History 

  1. using Advantech.Motion;

  2. using HalconDotNet;

  3. using Microsoft.VisualBasic;

  4. using Models;

  5. using Newtonsoft.Json;

  6. using Newtonsoft.Json.Linq;

  7. using OpenCvSharp;

  8. using ProductionControl.Device;

  9. using ProductionControl.UI;

  10. using ProductionControl.Utils;

  11. using SqlSugar;

  12. using System;

  13. using System.Collections;

  14. using System.Collections.Generic;

  15. using System.ComponentModel;

  16. using System.Data;

  17. using System.Diagnostics;

  18. using System.Drawing;

  19. using System.Drawing.Imaging;

  20. using System.IO;

  21. using System.Linq;

  22. using System.Security.Cryptography;

  23. using System.Text;

  24. using System.Threading;

  25. using System.Threading.Tasks;

  26. using System.Web.Routing;

  27. using System.Windows.Forms;

  28. using static ProductionControl.Device.AxisDev;

  29. using static ProductionControl.Device.DefectLib;

  30. using static ProductionControl.Device.SizeLib;

  31. 

  32. namespace ProductionControl

  33. {

  34.     public partial class FrmMain : Form

  35.     {

  36.         WebService webService = new WebService();

  37. 

  38.         private List<string> productCodeList = new List<string>();

  39.         private DevContainer devContainer = new DevContainer();

  40.         private Service.ProductService svcProduct = new Service.ProductService();

  41.         private Service.OrderService svcOrder = new Service.OrderService();

  42.         private bool bExitApp = false;

  43.         //禁用蜂鸣器，门磁

  44.         private bool disableBuzzer, disableDoorSensor;

  45. 

  46.         //线宽,张力，厚度，PT

  47.         private List<double> lstTension = new List<double>();

  48.         private List<double> lstHeight = new List<double>();

  49.         private List<double> lstLineWidth = new List<double>();

  50.         private List<double> lstPT = new List<double>();

  51. 

  52.         private Queue<scannerGBmpLoc> scannerGBmpQueue = new Queue<scannerGBmpLoc>();

  53.         private Queue<scannerCBmpLoc> scannerCBmpQueue = new Queue<scannerCBmpLoc>();

  54.         //private int scannerCBmpIndex = 0;//scannerCBmpQueue中使用当前项的计数器

  55.         private int compBmpIndex = 0;//比对777图的索引

  56.         private int defectBmpNum = 0;

  57.         private int defectBmpNumResult = 0;

  58.         /// <summary>

  59.         /// 比对失败的图片

  60.         /// </summary>

  61.         private List<Bitmap> lstCompareFailZoomImage = new List<Bitmap>();

  62. 

  63.         private object myLock=new object();

  64.         private WarningEnum warningLevel;//警告等级

  65.         private CurrentPTEnum currentPT;//当前点位

  66.         private CurrentStateEnum currentState;//当前状态 

  67.         /// <summary>

  68.         /// 当前流程ID，暂停/继续时使用

  69.         /// </summary>

  70.         private int currProcessIndex = -1;

  71.         private Models.Product currProductModel = null;//当前产品

  72. 

  73.         private bool autoMakeTagRuning = false;

  74.         private bool isProductRevise = false;

  75. 

  76.         //产品-厚度base校正点位索引

  77.         private int ProductPT_HeightBaseNum = 0; 

  78.          

  79.         private Stopwatch stopWatch = new Stopwatch();

  80.         private Order order = new Order();

  81.         //--333输出变量供后面多个777使用

  82.         public HObject contoursAffineTrans1_Out;

  83. 

  84.         private System.Timers.Timer timer = new System.Timers.Timer();

  85.         private class scannerGBmpLoc

  86.         {

  87.             public scannerGBmpLoc(Mat mat, double xmm, double ymm)

  88.             {

  89.                 bmp = mat;

  90.                 Xmm = xmm;

  91.                 Ymm = ymm;

  92.             }

  93.             public Mat bmp { get; private set; }

  94.             public double Xmm { get; private set; }

  95.             public double Ymm { get; private set; }

  96.         }

  97.         private class scannerCBmpLoc

  98.         {

  99.             public scannerCBmpLoc(string path, double posX, double posY)

  100.             {

  101.                 Path = path;

  102.                 PosX=posX;

  103.                 PosY=posY;

  104.             }

  105.             public scannerCBmpLoc(Bitmap bmp, double posX, double posY)

  106.             {

  107.                 BMP = bmp;

  108.                 PosX = posX;

  109.                 PosY = posY;

  110.             }

  111.             public Bitmap BMP { get; private set; }

  112.             public string Path { get; private set; }

  113.             public double PosX { get; private set; }

  114.             public double PosY { get; private set; }

  115.         }

  116.         public FrmMain()

  117.         {

  118.             InitializeComponent();

  119.             this.dgvProcess.AutoGenerateColumns = false;

  120.             this.tsbtnCloseDev.Visible = false;

  121.             this.tsslLoginInfo.Text = $"操作员：{Config.loginUser.Code}({Config.loginUser.Name})";

  122.             this.tsslLoginTime.Text = $" 登录时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm")}";

  123. 

  124.             //显示行号与列宽度自动调整

  125.             dgvProcess.RowHeadersVisible = true;

  126.             dgvProcess.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders;

  127.             dgvProcess.RowPostPaint += (sender, e) =>

  128.             {

  129.                 Utils.Util.showRowNum_onDataGrid_RowPostPaint(this.dgvProcess, sender, e);

  130.             };

  131.             checkCustomerVer(); 

  132.         }

  133.         private void checkCustomerVer()

  134.         {

  135.             //if(Config.CustomerVer=="A")

  136.             //    this.tsMenuOrderProduct.Visible = false;

  137.         }

  138.         private void FrmMian_Load(object sender, EventArgs e)

  139.         { 

  140.             if (Config.loginUser.RoleInfo.Code!="admin") 

  141.                 checkRoleRight();

  142.             loadProductCodeList();

  143. 

  144.             this.statusStrip1.LayoutStyle = System.Windows.Forms.ToolStripLayoutStyle.HorizontalStackWithOverflow;

  145.             this.tsslLoginTime.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;

  146.             this.tsslLoginInfo.Alignment = System.Windows.Forms.ToolStripItemAlignment.Right;

  147.             this.tsAxisState.Text = "";

  148. 

  149.             // 

  150.             webService.LogEvent = (warning, msg) =>

  151.             {

  152.                 AddTextEvent("HTTP服务", msg, warning);

  153.                 webService.LogEvent = null;

  154.             };

  155.             webService.start();

  156. 

  157.             //读取硬盘剩余空间

  158.             Config.CheckDisk();

  159.         }

  160.         private void loadProductCodeList()

  161.         {

  162.             try

  163.             {

  164.                 productCodeList = svcProduct.GetList().Select(m => m.Code).OrderBy(m=>m).ToList(); 

  165.             }

  166.             catch(Exception ex)

  167.             {

  168.                 AddTextEvent("启动", "加载产品料号失败:" + ex.Message,WarningEnum.High);

  169.             }

  170.         }

  171.         private void checkRoleRight()

  172.         {

  173.             this.流程管理ToolStripMenuItem.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Step") != null);

  174.             this.产品管理ToolStripMenuItem.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Product") != null);

  175.             this.设备调试ToolStripMenuItem.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Debug") != null);

  176. 

  177.             //this.tsMenuOrderQuery.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Order") != null);

  178.             //this.tsMenuStatistics.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Statistics") != null);

  179. 

  180.             this.角色管理ToolStripMenuItem.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "Role") != null);

  181.             this.用户管理ToolStripMenuItem.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "User") != null);

  182. 

  183.             this.tsbtnProductRevise.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "HeightBase") != null);

  184.             this.tsMenuSysSetting.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "SysSetting") != null);

  185.             this.tsMenuCmdSetting.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "CmdSetting") != null);

  186.             this.tsMenuPTSetting.Enabled = (Config.loginUser.RoleInfo.RightList.FirstOrDefault(m => m.Code == "PTSetting") != null); 

  187.         }

  188.         private void txtProductName_KeyPress(object sender, KeyPressEventArgs e)

  189.         {

  190.             //if (e.KeyChar == '\r' && devContainer.state && currentState == CurrentStateEnum.ScanBarcode)// && currentPT== CurrentPTEnum.UpPT )

  191.             //{

  192.             //    runStep();

  193.             //}

  194.         }

  195.         /// <summary>

  196.         /// 删除修复台重复sn图片

  197.         /// </summary>

  198.         private void DeleteRepairImage(string sn)

  199.         {

  200.             List<string> imagePath = new List<string>

  201.             {

  202.                 Config.Defect_SavePath,

  203.                 Config.Defect_Small_SavePath,

  204.                 Config.Defect_Compress_SavePath,

  205.                 Config.SizeBmp_Zoom_Image_SavePath,

  206.                 Config.SizeBmp_SavePath,

  207.                 Config.SizeBmp_Compare_SavePath

  208.             };

  209.             //删除文件

  210.             //Task.Factory.StartNew(() =>

  211.             //{

  212.                 for (int i = 0; i < imagePath.Count; i++)

  213.                 {

  214.                     string dirPath = Util.createSubDir(imagePath[i],

  215.                                                             new List<string> { DateTime.Now.ToString("yyyyMMdd"), sn });

  216.                     if (!Directory.Exists(dirPath))

  217.                     {

  218.                         return;

  219.                     }

  220.                     string[] array = Directory.GetFiles(dirPath);

  221.                     foreach (string text in array)

  222.                     {

  223.                         try

  224.                         {

  225.                             API.OutputDebugString("清除文件：" + text + "...");

  226.                             File.Delete(text);

  227.                         }

  228.                         catch (Exception ex)

  229.                         {

  230.                             API.OutputDebugString("Ex1:" + ex.Message);

  231.                         }

  232.                     }

  233.                 }             

  234. 

  235.             //});

  236.         }

  237. 

  238.         //后台线程运行

  239.         /// <summary>

  240.         /// 中断工序运行

  241.         /// </summary>

  242.         /// <returns></returns>

  243.         private bool isBreakProcessRun()

  244.         {

  245.             return warningLevel != WarningEnum.Normal || currentState != CurrentStateEnum.运行中;

  246.         }

  247.         private void runStep()

  248.         { 

  249.             compBmpIndex = defectBmpNum = defectBmpNumResult = 0; 

  250.             AddTextEvent("启动", "等待扫码枪扫码...");

  251.             if (devContainer.devCodeScanner != null)

  252.             {

  253.                 devContainer.devCodeScanner.stop();

  254.                 devContainer.devCodeScanner = null;

  255.             }

  256.             devContainer.devCodeScanner = new CodeScannerDev();

  257.             if (!devContainer.devCodeScanner.start())

  258.             {

  259.                 AddTextEvent("扫码枪", "扫码枪初始化失败！");

  260.                 return;

  261.             }

  262.             //2023-12-06 无输入料号防呆

  263.             if(string.IsNullOrEmpty(this.txtProductCode.Text))

  264.             {

  265.                 AddTextEvent("料号", "未选择料号！");

  266.                 return;

  267.             }

  268.             //2023-10-20 不使用扫码枪事件处理

  269.             //devContainer.devCodeScanner.ScanerEvent = (code) =>

  270.             string code = this.txtProductCode.Text;

  271.             {

  272.                 if (!devContainer.state || currentState != CurrentStateEnum.等待扫码 || string.IsNullOrWhiteSpace(code))

  273.                     return;

  274. 

  275.                 //

  276.                 scannerGBmpQueue.Clear();

  277.                 scannerCBmpQueue.Clear();

  278.                 lstCompareFailZoomImage.Clear();

  279.                 contoursAffineTrans1_Out = null;

  280.                 Thread threadtest = new System.Threading.Thread(() =>

  281.                 {

  282.                     int errStep = 0;

  283.                     try

  284.                     {

  285.                         var model = svcProduct.GetModelNav(code);

  286.                         if (model != null && model.StepInfo.ProcessList.Count > 0)

  287.                         {

  288.                             errStep = 1;

  289.                             //根据产品设置动态加载外观检测模型文件

  290.                             string onnxFile;

  291.                             if (!string.IsNullOrWhiteSpace(model.DefectModelFile))

  292.                                 onnxFile = $"{Application.StartupPath}\\onnxFiles\\{model.DefectModelFile}";

  293.                             else

  294.                                 onnxFile = $"{Application.StartupPath}\\onnxFiles\\default.onnx";

  295.                             devContainer.libDefect.loadModelFile(onnxFile);

  296. 

  297.                             //

  298.                             errStep = 2;

  299.                             string sn = "";

  300.                             AutoResetEvent waitEvent = new AutoResetEvent(false);

  301.                             this.Invoke(new System.Action(() =>

  302.                             {

  303.                                 FrmInput frm = new FrmInput(null, "请输入网版编码:");

  304.                                 if (frm.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(frm.inputData))

  305.                                     sn = frm.inputData;

  306.                                 waitEvent.Set();

  307.                             }));

  308.                             errStep = 3;

  309.                             waitEvent.WaitOne();

  310.                             if (string.IsNullOrWhiteSpace(sn))

  311.                             {

  312.                                 AddTextEvent("扫码枪", $"料号{code}未输入网版编码，流程中止!");

  313.                                 return;

  314.                             }

  315.                             AddTextEvent("扫码枪", $"料号：{code}，网版编码：{sn}");

  316.                             //是否闪退需观察

  317.                             errStep = 4;

  318.                             devContainer.devCodeScanner.stop();

  319.                             devContainer.devCodeScanner = null;

  320.                             errStep = 5;

  321.                             //删除重复sn用于修复台的图片

  322.                             AddTextEvent("扫码枪", $"删除{sn}重复用于修复台的图片...");

  323.                             DeleteRepairImage(sn);

  324. 

  325.                             //判断SN数量是否达到批次上限

  326.                             //创建表达式

  327.                             if (!string.IsNullOrWhiteSpace(model.BatchId) && model.TargetCount > 0)

  328.                             {

  329.                                 var exp1 = Expressionable.Create<Order>()

  330.                                     .And(m => m.ProductId == model.Id)

  331.                                     .And(m => m.BatchId == model.BatchId)

  332.                                     .And(m => m.SN != sn)

  333.                                     .ToExpression();//注意 这一句 不能少

  334.                                 errStep = 6;

  335.                                 if (svcOrder.Count(exp1) >= model.TargetCount)

  336.                                 {

  337.                                     AddTextEvent("扫码枪", $"当前产品本批次检测数已达目标数量，请更换检测批次号!");

  338.                                     return;

  339.                                 }

  340. 

  341.                                 errStep = 7;

  342.                             }

  343.                             //

  344. 

  345.                             this.Invoke(new System.Action(() =>

  346.                             {

  347.                                 this.txtProductSN.Text = sn;

  348.                             }));

  349. 

  350.                             //  

  351.                             model.HeightBaseDec = "";

  352.                             currentState = CurrentStateEnum.运行中;

  353.                             currentPT = CurrentPTEnum.Moving;

  354.                             currProductModel = model;

  355.                             AddTextEvent("扫码枪", $"{model.Name} {model.Spec} [{model.Code}]");

  356.                             this.Invoke(new System.Action(() =>

  357.                             {

  358.                                 this.txtProductCode.Text = model.Code;

  359.                                 this.txtProductName.Text = model.Name;

  360.                                 this.dgvProcess.DataSource = new BindingSource(model.StepInfo.ProcessList, null);

  361.                                 devContainer.libFor.clear();

  362.                                 devContainer.libIF.clear();

  363.                                 tsbtnSizeTag.Enabled = tsbtnSizeImage.Enabled = tsbtnDefectImage.Enabled = true;

  364.                             }));

  365.                             errStep = 8;

  366.                             //   

  367.                             ProductPT_HeightBaseNum = 0;

  368.                             this.setButtonEnabled(this.tsbtnPause, true);

  369.                             this.setButtonEnabled(this.tsbtnStopNow, true);

  370.                             order = new Order();

  371.                             order.Qualified = true;//默认合格，中间有一项指标不合格则改为false

  372.                             order.ProductId = currProductModel.Id;

  373.                             order.StepId = (int)currProductModel.StepId;

  374.                             order.SN = sn;

  375.                             order.BatchId = currProductModel.BatchId;

  376.                             errStep = 9;

  377.                             int nextStepId = 0;

  378.                             do

  379.                             {

  380.                                 nextStepId = nextProcess(model, nextStepId);

  381.                             } while (nextStepId >= 0 && !isBreakProcessRun());

  382.                             errStep = 10;

  383.                         }

  384.                         else

  385.                             AddTextEvent("扫码枪", model != null ? $"料号{code}不存在!" : $"产品({model.Name})未配置检测流程!");

  386.                     }

  387.                     catch (Exception ex)

  388.                     {

  389.                         //AddTextEvent("扫码后", $"errcode({errStep}):" + ex.Message);//会有空对象引用，但不知哪里报的

  390.                         //warning(WarningEnum.High);

  391.                     }

  392.             });

  393.                 threadtest.IsBackground = true;

  394.                 threadtest.Start();

  395. 

  396.             };

  397.         }

  398.         

  399.         //model.Type=1 系统校正

  400.         /// <summary>

  401.         /// 

  402.         /// </summary>

  403.         /// <param name="model"></param>

  404.         /// <param name="stepIndex">0-n</param>

  405.         /// <returns>大于等于0正常工序； -1:结束 -2：异常</returns>

  406.         private int nextProcess(Models.Product model, int stepIndex)

  407.         {

  408.             try

  409.             {

  410.                 //记录当前index

  411.                 this.currProcessIndex = stepIndex;

  412.                 this.Invoke(new System.Action(() =>

  413.                 {

  414.                     try

  415.                     {

  416.                         this.dgvProcess.Rows[stepIndex].Selected = true;

  417.                         dgvProcess.CurrentCell = dgvProcess.Rows[stepIndex].Cells[1];

  418.                     }

  419.                     catch { }

  420.                 }));

  421.                 lock (myLock)

  422.                 {

  423.                     if (isBreakProcessRun())

  424.                         return stepIndex;

  425.                 }

  426.                 //开始计时

  427.                 if(!isProductRevise && model.StepInfo.StartTimeIndex>0 && model.StepInfo.StartTimeIndex==stepIndex+1)

  428.                     stopWatch.Restart();

  429. 

  430.                 var processList = isProductRevise ? model.ReviseStepInfo.ProcessList : model.StepInfo.ProcessList;

  431.                 var processInfo = processList[stepIndex];

  432.                 string processName = processInfo.ProcessName;  

  433.                 //AddTextEvent($"{stepIndex + 1}-{processName}", $"工序开始...");

  434.                 string jsonParams = null;//配方

  435. 

  436.                 if (model.ProductProcessList != null && model.ProductProcessList.Count > 0)//使用产品配方

  437.                 {

  438.                     ProductProcess productProcessParams = model.ProductProcessList.First(m => m.ProcessCode == processInfo.ProcessCode);

  439.                     if (productProcessParams != null)

  440.                     {

  441.                         jsonParams = productProcessParams.ProcessParams;

  442.                         AddTextEvent($"{stepIndex + 1}-{processName}", $"使用产品专用配方:{jsonParams}");

  443.                     }

  444.                 }

  445.                 if (jsonParams == null)//使用流程默认配方

  446.                 {

  447.                     jsonParams = processInfo.ProcessParams;

  448.                     if (jsonParams == null)  throw new Exception("配方为null!!");

  449.                     AddTextEvent($"{stepIndex + 1}-{processName}", $"使用流程默认配方:{jsonParams}");

  450.                 }

  451. 

  452.                 //

  453.                 JObject processParam = JObject.Parse(jsonParams);

  454.                 if (!processParam.ContainsKey("Disable") || !processParam.Value<bool>("Disable"))

  455.                 {

  456.                     AutoResetEvent endEvent;

  457.                     uint sleepPre = processParam.Value<uint>("SleepPre");

  458.                     uint sleepLater = processParam.Value<uint>("SleepLater");

  459.                     if (sleepPre > 0)

  460.                         Thread.Sleep((int)sleepPre);

  461.                     double limitThresholdVal, lowerThresholdVal; //张力，厚度，Size,Defect

  462. 

  463.                     //======Switch 工序类型

  464.                     bool asynRun;

  465.                     string gbxBmpPath = "";

  466. 

  467.                     Models.Attachment attachmentFile;

  468.                     int liStatocStepIndex = stepIndex;

  469.                     switch (processInfo.ProcessCode)

  470.                     {

  471.                         case "IOCard":

  472.                             #region

  473.                             var direction = (IODirectionEnum)processParam.Value<int>("Direction");

  474.                             if (direction == IODirectionEnum.输入 || direction == IODirectionEnum.输入输出)

  475.                             {

  476.                                 uint IN_Waiting_Timeout = processParam.Value<uint>("IN_Waiting_Timeout");

  477.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"等待I/O输入信号{(IN_Waiting_Timeout > 0 ? $"(超时时长: {IN_Waiting_Timeout})" : "...")}");

  478.                                 string[] inValue = processParam.Value<JArray>("IN_OP_SHOW").ToObject<List<string>>().ToArray();

  479.                                 uint inWaitingTime = 0;

  480.                                 while (true)

  481.                                 {

  482.                                     if (isBreakProcessRun())

  483.                                         return stepIndex; 

  484. 

  485.                                     if (Util.compareIOInput(inValue, devContainer.devIOCard.DIData))

  486.                                         break;

  487. 

  488.                                     Thread.Sleep(10);

  489.                                     inWaitingTime += 10;

  490.                                     if (IN_Waiting_Timeout>0 && inWaitingTime >= IN_Waiting_Timeout)

  491.                                     {

  492.                                         AddTextEvent($"{stepIndex + 1}-{processName}", $"输入等待超时告警!", WarningEnum.High);

  493.                                         warning(WarningEnum.Low);//暂停  

  494.                                         return stepIndex;

  495.                                     }

  496.                                 }

  497.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"I/O输入信号对比完成！");

  498.                             }

  499. 

  500.                             if (direction == IODirectionEnum.输出 || direction == IODirectionEnum.输入输出)

  501.                                 devContainer.io_output($"{stepIndex + 1}-{processName}", processParam);

  502.                             #endregion

  503.                             break;

  504.                         case "Tension":

  505.                             #region

  506.                             //limitThresholdVal = processParam.Value<double>("LimitThresholdVal");

  507.                             //lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");

  508.                             //double tensionValue = 0;

  509.                             //int timeoutTension = 0;

  510.                             //do

  511.                             //{

  512.                             //    tensionValue = devContainer.devTension.getValue();

  513.                             //    setDgvContentCol(liStatocStepIndex, $"张力值:{tensionValue}");

  514.                             //    Thread.Sleep(10);

  515.                             //    timeoutTension += 10;

  516.                             //    if (tensionValue <= 0 && timeoutTension >= 600)//3秒超时

  517.                             //    {

  518.                             //        AddTextEvent($"{stepIndex + 1}-{processName}", $"张力测量失败，确认设备是否正常!", WarningEnum.High);

  519.                             //        warning(WarningEnum.Low);//暂停 

  520.                             //        devContainer.io_output(CMDName.张力读取结束输出);

  521.                             //        currProcessIndex--;

  522.                             //        return stepIndex;

  523.                             //    }

  524.                             //} while (tensionValue <= 0);

  525.                             //devContainer.io_output(CMDName.张力读取结束输出);

  526. 

  527.                             //lstTension.Add(tensionValue);

  528.                             //updateTensionValue(model.TensionBaseValue+model.TensionUpFloatValue,model.TensionBaseValue-model.TensionDownFloatValue);

  529.                             //if (limitThresholdVal > 0 && tensionValue >= limitThresholdVal)

  530.                             //{

  531.                             //    AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{tensionValue}，达到上限阀值:{limitThresholdVal}，进行下料...", WarningEnum.Low);

  532.                             //    currProcessIndex = stepIndex + 1;

  533.                             //    warning(WarningEnum.Low);//暂停

  534.                             //    return stepIndex;

  535.                             //}

  536.                             //else if (lowerThresholdVal > 0 && tensionValue < lowerThresholdVal)

  537.                             //{

  538.                             //    AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{tensionValue}，达到下限阀值:{lowerThresholdVal}，进行下料...", WarningEnum.Low);

  539.                             //    currProcessIndex = stepIndex + 1; 

  540.                             //    warning(WarningEnum.Low);//暂停 

  541.                             //    return stepIndex;

  542.                             //}

  543.                             //AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{tensionValue}");

  544.                             #endregion

  545.                             break;

  546.                         case "Height":

  547.                             #region

  548.                             if (Config.SkipHeight)

  549.                             {

  550.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");

  551.                                 setDgvContentCol(liStatocStepIndex, $"设备禁用，忽略此步骤!");

  552.                                 break;

  553.                             }

  554.                             while (!devContainer.devAxis.isReady())//因启用轴异步功能,使用前需等待

  555.                             {

  556.                                 Thread.Sleep(100);

  557.                                 if (isBreakProcessRun())

  558.                                 {

  559.                                     //currProcessIndex = stepIndex;//本工序没执行，step不变

  560.                                     return stepIndex;

  561.                                 }

  562.                             }

  563. 

  564.                             limitThresholdVal = processParam.Value<double>("LimitThresholdVal");

  565.                             lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");

  566.                             bool IsRevise = processParam.Value<bool>("IsRevise");

  567.                             double relBaseValue = processParam.Value<double>("RelBaseValue"); //配方中相对偏移值

  568.                             var heightValue = devContainer.devHeight.getHeight();

  569.                             heightValue = Math.Round(heightValue, 2);//保留2位小数

  570.                             File.AppendAllText(Application.StartupPath + "\\厚度测量记录.txt", heightValue+"\r\n");//TEMP

  571.                             if (!IsRevise && heightValue < 0)

  572.                             { 

  573.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue}，异常数据，终止任务！", WarningEnum.Low);

  574.                                 warning(WarningEnum.Low);//暂停

  575.                                 return stepIndex;

  576.                             }

  577.                             //厚度Base校正

  578.                             if (isProductRevise)

  579.                             {

  580.                                 setDgvContentCol(liStatocStepIndex, $"厚度值:{heightValue}");

  581.                                 model.HeightBaseDec += heightValue + ";";

  582.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue}");

  583.                             }

  584.                             else if (IsRevise)

  585.                             {

  586.                                 var reviseHeight = heightValue + relBaseValue;

  587.                                 model.HeightBaseDec += reviseHeight + ";";

  588.                                 setDgvContentCol(liStatocStepIndex, $"base值:{reviseHeight} = 厚度值:{heightValue}+偏移值:{relBaseValue}");

  589.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"base值:{reviseHeight} = 厚度值:{heightValue}+偏移值:{relBaseValue}，校正索引队列:{model.HeightBaseDec}");

  590.                             }

  591.                             else

  592.                             {

  593.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue}，base值:{model.HeightBaseDec}，偏移值:{relBaseValue}，当前base索引:{ProductPT_HeightBaseNum}");

  594.                                 double heightDev = 0;

  595.                                 var heightDev_BaseList=model.HeightBaseDec.Split(new char[] {';',','});

  596.                                 if (heightDev_BaseList.Count() > ProductPT_HeightBaseNum && heightDev_BaseList[ProductPT_HeightBaseNum].Trim() != "")

  597.                                     heightDev = Convert.ToDouble(heightDev_BaseList[ProductPT_HeightBaseNum].Trim());

  598.                                 ProductPT_HeightBaseNum++;

  599. 

  600.                                 double heightValue2 =Math.Abs(heightDev - heightValue ) + relBaseValue;

  601.                                 heightValue2 = Math.Round(heightValue2, 2);

  602.                                 setDgvContentCol(liStatocStepIndex, $"厚度值:{heightValue2}");

  603.                                 lstHeight.Add(heightValue2);

  604.                                 updateHeightValue(model.HeightBaseValue + model.HeightUpFloatValue, model.HeightBaseValue - model.HeightDownFloatValue);

  605.                                 if (limitThresholdVal > 0 && heightValue2 >= limitThresholdVal)

  606.                                 {

  607.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue2}，达到上限阀值:{limitThresholdVal}，进行下料...", WarningEnum.Low);

  608.                                     currProcessIndex = stepIndex + 1;

  609.                                     warning(WarningEnum.Low);//终止 

  610.                                     return stepIndex;

  611.                                 }

  612.                                 else if (lowerThresholdVal > 0 && heightValue2 < lowerThresholdVal)

  613.                                 {

  614.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"读取数据:{heightValue2}，达到下限阀值:{lowerThresholdVal}，进行下料...", WarningEnum.Low);

  615.                                     currProcessIndex = stepIndex + 1; 

  616.                                     warning(WarningEnum.Low);//终止 

  617.                                     return stepIndex;

  618.                                 }

  619. 

  620.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"厚度值:{heightValue2} (Base值:{heightDev} - 读取数据:{heightValue} + 偏移值:{relBaseValue})");

  621.                             }

  622.                             #endregion

  623.                             break;

  624.                         case "Axis":

  625.                             #region  多轴后遗留问题：暂停后再启动不知哪几个轴已执行

  626.                             JObject processParamTmp = new JObject();

  627.                             //兼容旧版单轴

  628.                             if (!processParam.ContainsKey("0") && !processParam.ContainsKey("1") && !processParam.ContainsKey("2") && !processParam.ContainsKey("3"))

  629.                             { 

  630.                                 processParam.Add("Enable", true);

  631.                                 processParamTmp.Add(processParam.Value<int>("AxisIndex").ToString(), processParam);

  632.                                 processParam = processParamTmp;

  633.                             }

  634.                             //- 

  635.                             foreach (var processParamSub in processParam.Properties())

  636.                             { 

  637.                                 processParam = processParamSub.Value as JObject;

  638.                                 AddTextEvent($"{stepIndex + 1}-{processName}", processParam.ToString());

  639.                                 if (!processParam.ContainsKey("Disable") || !processParam.Value<bool>("Disable"))

  640.                                 {

  641.                                     //asynRun = processParam.Value<bool>("AsynRun");//异步

  642.                                     int AxisIndex = processParam.Value<int>("AxisIndex");

  643.                                     int DeviceType = processParam.Value<int>("DeviceType");

  644. 

  645.                                     double VelLow = processParam.Value<double>("VelLow");

  646.                                     double VelHigh = processParam.Value<double>("VelHigh");

  647.                                     double Acc = processParam.Value<double>("Acc");

  648.                                     double Dec = processParam.Value<double>("Dec");

  649. 

  650.                                     AxMoveMode MoveMode = (AxMoveMode)processParam.Value<int>("MoveMode");//绝对位置

  651.                                     double PPUValue = processParam.Value<double>("Value");

  652. 

  653.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"轴{AxisIndex}准备({(MoveMode == AxMoveMode.绝对位置 ? "绝对" : "相对")})运动至{PPUValue}(当前轴状态:{((AxisState)devContainer.devAxis.AxState[AxisIndex]).ToString()})...");

  654. 

  655.                                     //移动Axis前等待厚度传感器收回

  656.                                     if (!Config.SkipHeight)

  657.                                     {

  658.                                         while (devContainer.devHeight.getHeight() < (double)Math.Abs(Config.HeightDev_SafeValue))

  659.                                         {

  660.                                             if (isBreakProcessRun())

  661.                                                 return stepIndex;

  662.                                             Thread.Sleep(10);

  663.                                         }

  664.                                     }

  665.                                     while (!devContainer.devAxis.isReady(AxisIndex))

  666.                                     {

  667.                                         Thread.Sleep(100);

  668.                                         if (isBreakProcessRun())

  669.                                             return stepIndex;

  670.                                     }

  671.                                     devContainer.devAxis.setAxisVelParam(VelLow, VelHigh, Acc, Dec, AxisIndex);

  672.                                     if (!devContainer.devAxis.move_ptp(AxisIndex, PPUValue, MoveMode))

  673.                                     {

  674.                                         AddTextEvent($"{stepIndex + 1}-{processName}", $"轴{AxisIndex}运动失败！", WarningEnum.Low);

  675.                                         warning(WarningEnum.Low);//终止

  676.                                         return stepIndex;

  677.                                     }

  678. 

  679.                                     //多轴运行自动使用异步，全部执行后强制等待各轴完成 asynRun属性已无用

  680.                                     //AddTextEvent($"{stepIndex + 1}-{processName}", $"等待轴{AxisIndex}运行完成...");

  681.                                     //while (!asynRun && !devContainer.devAxis.isReady(AxisIndex))

  682.                                     //{

  683.                                     //    Thread.Sleep(100);

  684.                                     //    if (isBreakProcessRun())

  685.                                     //    {

  686.                                     //        currProcessIndex = stepIndex + 1;

  687.                                     //        return stepIndex;

  688.                                     //    }

  689.                                     //}

  690.                                     //if (devContainer.devAxis.isReady(AxisIndex))

  691.                                     //    AddTextEvent($"{stepIndex + 1}-{processName}", $"轴{AxisIndex}运行完成,当前命令位置:{devContainer.devAxis.getCmdPos_mm(AxisIndex)},反馈位置:{devContainer.devAxis.getActualPos_mm(AxisIndex)}");

  692.                                 }

  693.                             }

  694.                             //多轴同时运行后强制等待各轴完成

  695.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

  696.                             while (!devContainer.devAxis.isReady())

  697.                             {

  698.                                 Thread.Sleep(100);

  699.                                 if (isBreakProcessRun())

  700.                                 {

  701.                                     currProcessIndex = stepIndex + 1;

  702.                                     return stepIndex;

  703.                                 }

  704.                             }

  705.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"轴组运行完成。");

  706.                             #endregion

  707.                             break;

  708.                         case "AxisTag":

  709.                             #region

  710.                             //asynRun = processParam.Value<bool>("AsynRun");//异步

  711.                             string axisSizeTag= processParam.Value<string>("SizeTag");

  712.                             int useIndex = processParam.Value<int>("UseIndex");//消费posePT中的索引

  713.                             AxMoveMode TagMoveMode = (AxMoveMode)processParam.Value<int>("MoveMode");//绝对位置

  714.                             var AxisIndexList = processParam.Value<JArray>("AxisIndexList").ToObject<List<int>>();

  715. 

  716.                             double TagVelLow = processParam.Value<double>("VelLow");

  717.                             double TagVelHigh = processParam.Value<double>("VelHigh");

  718.                             double TagAcc = processParam.Value<double>("Acc");

  719.                             double TagDec = processParam.Value<double>("Dec");

  720.                             var sizeTagObj = order.SizeTagDataList.LastOrDefault(m => m.SizeTag == axisSizeTag);//用最新的last

  721.                             if (sizeTagObj == null)

  722.                             {

  723.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"偏移校正轴工序找不到数据提供者Tag:{axisSizeTag}！", WarningEnum.High);

  724.                                 warning(WarningEnum.High);

  725.                                 return stepIndex;

  726.                             } 

  727.                             string[] posePT= sizeTagObj.posePT.Split(',');

  728.                             if(posePT.Length < useIndex+ AxisIndexList.Count)

  729.                             {

  730.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"Tag:{axisSizeTag}对应消费索引:{useIndex},Axis数量:{AxisIndexList.Count} 超出postPT:{sizeTagObj.posePT} 范围!", WarningEnum.High);

  731.                                 warning(WarningEnum.High);

  732.                                 return stepIndex;

  733.                             }

  734. 

  735.                             double[] TagPPUValue = new double[AxisIndexList.Count];

  736.                             for (int i = 0; i < AxisIndexList.Count; i++)

  737.                                 TagPPUValue[i] = double.Parse(posePT[useIndex + i]);

  738.                             string axisTagMsg = $"消费Tag:{axisSizeTag},索引:{useIndex}, 轴:{string.Join(",", AxisIndexList.ToList())},数据:{(TagMoveMode== AxMoveMode.绝对位置 ? "绝对" : "相对")}({string.Join(",", TagPPUValue.ToList())})";

  739.                             AddTextEvent($"{stepIndex + 1}-{processName}", axisTagMsg);

  740.                             setDgvContentCol(liStatocStepIndex, axisTagMsg);

  741. 

  742.                             //移动Axis前等待厚度传感器收回

  743.                             if (!Config.SkipHeight)

  744.                             {

  745.                                 while (devContainer.devHeight.getHeight() < (double)Math.Abs(Config.HeightDev_SafeValue))

  746.                                 {

  747.                                     if (isBreakProcessRun())

  748.                                         return stepIndex; //如果是相对位置，这里返回会有问题

  749.                                     Thread.Sleep(10);

  750.                                 }

  751.                             }

  752.                             for (int i = 0; i < AxisIndexList.Count && i < TagPPUValue.Length; i++)

  753.                             {

  754.                                 while (!devContainer.devAxis.isReady(AxisIndexList[i]))

  755.                                 {

  756.                                     Thread.Sleep(100);

  757.                                     if (isBreakProcessRun())

  758.                                         return stepIndex;

  759.                                 }

  760.                                 devContainer.devAxis.setAxisVelParam(TagVelLow, TagVelHigh, TagAcc, TagDec, AxisIndexList[i]);

  761.                                 if (!devContainer.devAxis.move_ptp(AxisIndexList[i], TagPPUValue[i], TagMoveMode))

  762.                                 {

  763.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}运动失败！", WarningEnum.Low);

  764.                                     warning(WarningEnum.Low);//终止

  765.                                     return stepIndex;//如果是相对位置，这里返回会有问题

  766.                                 }

  767. 

  768.                                 //AddTextEvent($"{stepIndex + 1}-{processName}", $"等待轴{AxisIndexList[i]}运行完成...");

  769.                                 //while (!asynRun && !devContainer.devAxis.isReady(AxisIndexList[i]))

  770.                                 //{

  771.                                 //    Thread.Sleep(100);

  772.                                 //    if (isBreakProcessRun())

  773.                                 //    {

  774.                                 //        currProcessIndex = stepIndex + 1;

  775.                                 //        return stepIndex;//如果是相对位置，这里返回会有问题

  776.                                 //    }

  777.                                 //}

  778.                                 //if (devContainer.devAxis.isReady(AxisIndexList[i]))

  779.                                 //    AddTextEvent($"{stepIndex + 1}-{processName}", $"轴{AxisIndexList[i]}运行完成,当前命令位置:{devContainer.devAxis.getCmdPos_mm(AxisIndexList[i])},反馈位置:{devContainer.devAxis.getActualPos_mm(AxisIndexList[i])}");

  780.                             }

  781.                             if (sizeTagObj.ConsumeStepIndex == null) sizeTagObj.ConsumeStepIndex = "";

  782.                             sizeTagObj.ConsumeStepIndex += $"{stepIndex + 1}-{useIndex}, ";//消费工序ID

  783. 

  784.                             //多轴同时运行后强制等待各轴完成

  785.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"等待轴组运行完成...");

  786.                             while (!devContainer.devAxis.isReady())

  787.                             {

  788.                                 Thread.Sleep(100);

  789.                                 if (isBreakProcessRun())

  790.                                 {

  791.                                     currProcessIndex = stepIndex + 1;

  792.                                     return stepIndex;

  793.                                 }

  794.                             }

  795.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"轴组运行完成。");

  796.                             #endregion

  797.                             break;

  798.                         case "Light":

  799.                             #region 

  800.                             if (Config.SkipLight)

  801.                             {

  802.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");

  803.                                 setDgvContentCol(liStatocStepIndex, $"设备禁用，忽略此步骤!");

  804.                                 break;

  805.                             }

  806.                             int ChannelIndex = processParam.Value<int>("ChannelIndex"); //通道

  807.                             int DigitalValue = processParam.Value<int>("DigitalValue"); //亮度

  808.                             int nowDiaitalValue = devContainer.devLight.getDigitalValue(ChannelIndex);

  809.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"通道{ChannelIndex}当前值:{nowDiaitalValue},准备更新值:{DigitalValue}...");

  810.                             devContainer.devLight.setDigitalValue(ChannelIndex, DigitalValue);

  811.                             nowDiaitalValue = devContainer.devLight.getDigitalValue(ChannelIndex);

  812.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"通道{ChannelIndex}更新后当前值:{nowDiaitalValue}。");

  813.                             #endregion

  814.                             break;

  815.                         case "Scanner_GENTL":

  816.                             #region

  817.                             if (Config.SkipScannerGL)

  818.                             {

  819.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");

  820.                                 setDgvContentCol(liStatocStepIndex, $"设备禁用，忽略此步骤!");

  821.                                 break;

  822.                             }

  823.                             while (!devContainer.devAxis.isReady())//因启用轴异步功能,使用前需等待

  824.                             {

  825.                                 Thread.Sleep(100);

  826.                                 if (isBreakProcessRun())

  827.                                 {

  828.                                     //currProcessIndex = stepIndex;//本工序没执行，step不变

  829.                                     return stepIndex;

  830.                                 }

  831.                             }

  832. 

  833.                             AIEngineLibEnum AIEngineLib = AIEngineLibEnum.缺陷库;

  834.                             if(processParam.ContainsKey("AIEngineLib"))

  835.                                 AIEngineLib=(AIEngineLibEnum)processParam.Value<int>("AIEngineLib");

  836.                             float ExposureTime = processParam.Value<float>("ExposureTime"); //曝光

  837.                             float Gain = processParam.Value<float>("Gain"); //增益

  838.                             float ResultingFrameRate = processParam.Value<float>("ResultingFrameRate"); //帧率

  839. 

  840.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");

  841.                             devContainer.devScannerGentl.setParam(ExposureTime, Gain, ResultingFrameRate);

  842. 

  843.                             endEvent = new AutoResetEvent(false);

  844.                             devContainer.devScannerGentl.ScanEvent = (num, bmpout) =>

  845.                             {

  846.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片完成。");

  847.                                 //----缺陷队列

  848.                                 //bool cloneUse = false;

  849.                                 if (AIEngineLib == AIEngineLibEnum.缺陷库 || AIEngineLib == AIEngineLibEnum.缺陷与测量库)

  850.                                 {

  851.                                     //cloneUse = true;

  852.                                     var mat = OpenCvSharp.Extensions.BitmapConverter.ToMat(bmpout);

  853.                                     scannerGBmpQueue.Enqueue(new scannerGBmpLoc(mat,

  854.                                         devContainer.devAxis.getActualPos_mm(1),

  855.                                         devContainer.devAxis.getActualPos_mm(2)));//Dequeue 

  856.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"缺陷图像队列数量: {scannerGBmpQueue.Count}");

  857.                                 }

  858.                                 if (AIEngineLib == AIEngineLibEnum.测量库 || AIEngineLib == AIEngineLibEnum.缺陷与测量库)

  859.                                 {

  860.                                     //v1.2.2. 修改传图

  861.                                     //scannerCBmpQueue.Enqueue(new scannerCBmpLoc(

  862.                                     //    cloneUse?(Bitmap)bmpout.Clone(): bmpout,

  863.                                     //    devContainer.devAxis.getActualPos_mm(1),

  864.                                     //    devContainer.devAxis.getActualPos_mm(2)));//Dequeue

  865.                                     scannerCBmpQueue.Enqueue(new scannerCBmpLoc(

  866.                                          (Bitmap)bmpout.Clone(),

  867.                                         devContainer.devAxis.getActualPos_mm(1),

  868.                                         devContainer.devAxis.getActualPos_mm(2)));//Dequeue

  869.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，X:{devContainer.devAxis.getActualPos_mm(1)},y:{devContainer.devAxis.getActualPos_mm(2)},数量: {scannerCBmpQueue.Count}");

  870.                                 }

  871.                                 endEvent.Set();//线程返回

  872.                             };

  873.                             //AddTextEvent($"{stepIndex + 1}-{processName}", $"软触发拍照...");

  874.                             if (!devContainer.devScannerGentl.scan(1))//软触发拍照

  875.                             {

  876.                                 devContainer.devScannerGentl.ScanEvent = null;

  877.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片失败！", WarningEnum.Low);

  878.                                 warning(WarningEnum.Low);//终止

  879.                                 return stepIndex;

  880.                             } 

  881.                             if (!endEvent.WaitOne(10000))

  882.                             {

  883.                                 devContainer.devScannerGentl.ScanEvent = null;

  884.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片超时！", WarningEnum.Low);

  885.                                 warning(WarningEnum.Low);//终止

  886.                                 return stepIndex;

  887.                             } 

  888.                             devContainer.devScannerGentl.ScanEvent = null;

  889.                             #endregion

  890.                             break;

  891.                         case "Scanner_CC":

  892.                             #region

  893.                             if (Config.SkipScannerCC)

  894.                             {

  895.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");

  896.                                 setDgvContentCol(liStatocStepIndex, $"设备禁用，忽略此步骤!");

  897.                                 break;

  898.                             }

  899.                             while (!devContainer.devAxis.isReady())//因启用轴异步功能,使用前需等待

  900.                             {

  901.                                 Thread.Sleep(100);

  902.                                 if (isBreakProcessRun())

  903.                                 {

  904.                                     //currProcessIndex = stepIndex;//本工序没执行，step不变

  905.                                     return stepIndex;

  906.                                 }

  907.                             }

  908. 

  909.                             float ExposureTimeCC = processParam.Value<float>("ExposureTime"); //曝光

  910.                             float GainCC = processParam.Value<float>("Gain"); //增益

  911.                             float ResultingFrameRateCC = processParam.Value<float>("ResultingFrameRate"); //帧率

  912. 

  913.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"相机开始采集照片...");

  914.                             devContainer.devScannerCC.setParam(ExposureTimeCC, GainCC, ResultingFrameRateCC);

  915. 

  916.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"相机参数设置完成。");

  917.                             AutoResetEvent endEventCC = new AutoResetEvent(false);

  918.                             //devContainer.devScannerCC.ScanEvent = (num, bmp2) =>

  919.                             //{

  920.                             //    AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片完成.");

  921.                             //    scannerCBmpQueue.Enqueue(bmp2);//Dequeue

  922.                             //    endEventCC.Set();//线程返回

  923.                             //};

  924.                             devContainer.devScannerCC.ScanEventPath += new System.Action<int, string>((num, path2) =>

  925.                             {

  926.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片完成.");

  927.                                 scannerCBmpQueue.Enqueue(new scannerCBmpLoc(path2, 

  928.                                     devContainer.devAxis.getActualPos_mm(0),

  929.                                     devContainer.devAxis.getActualPos_mm(2)));//Dequeue

  930.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"添加尺寸图像队列，X:{ devContainer.devAxis.getActualPos_mm(0)},y: { devContainer.devAxis.getActualPos_mm(2)},数量: { scannerCBmpQueue.Count}");

  931.                                 endEventCC.Set();//线程返回

  932.                             });

  933.                             if (!devContainer.devScannerCC.scan(1))//软触发拍照

  934.                             {

  935.                                 devContainer.devScannerCC.ScanEventPath = null;

  936.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片失败！", WarningEnum.Low);

  937.                                 warning(WarningEnum.Low);//终止

  938.                                 return stepIndex;

  939.                             }

  940. 

  941.                             if (!endEventCC.WaitOne(10000))

  942.                             {

  943.                                 devContainer.devScannerCC.ScanEventPath = null;

  944.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"相机采集照片超时！", WarningEnum.Low);

  945.                                 warning(WarningEnum.Low);//终止

  946.                                 return stepIndex;

  947.                             }

  948.                             devContainer.devScannerCC.ScanEventPath = null;

  949.                             #endregion

  950.                             break;

  951.                         case "SmallAxis":

  952.                             #region 

  953.                             if (Config.SkipSmallAxis)

  954.                             {

  955.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"设备禁用，忽略此步骤！");

  956.                                 setDgvContentCol(liStatocStepIndex, $"设备禁用，忽略此步骤!");

  957.                                 break;

  958.                             }

  959.                             int CmdPos = processParam.Value<int>("CmdPos"); //命令脉冲

  960.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"开始由起始位置{devContainer.devSmallAxis.getCurrPPU()}运动到{CmdPos}...");

  961.                             devContainer.devSmallAxis.gotoPos(CmdPos, true);

  962.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"运动完成，当前位置:{devContainer.devSmallAxis.getCurrPPU()}");

  963.                             #endregion

  964.                             break;

  965.                         case "Size":

  966.                             #region

  967.                             asynRun = processParam.Value<bool>("AsynRun");//异步

  968.                             limitThresholdVal = processParam.Value<double>("LimitThresholdVal");

  969.                             lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");

  970.                             int sizeIndex = processParam.Value<int>("Index");

  971.                             string sizeTag = processParam.ContainsKey("SizeTag") ? processParam.Value<string>("SizeTag") : "";

  972. 

  973. 

  974.                             //2023-10-27

  975.                             bool useMap = false;

  976.                             List<double> getPosList = new List<double>();

  977.                             try

  978.                             {

  979.                                 useMap = processParam.Value<bool>("UseMapPoints");

  980.                                 if (useMap) { 

  981.                                     var list = model.GetPointList.Split(',');

  982.                                     List<double> dList = new List<double>();

  983.                                     if (list.Length < 28)

  984.                                     {

  985.                                         for (int i = 0; i < 28; i++)

  986.                                         {

  987.                                             dList.Add(0);

  988.                                         }

  989.                                     }

  990.                                     else

  991.                                     {

  992.                                         for (int i = 0; i < list.Length; i++)

  993.                                         {

  994.                                             dList.Add(double.Parse(list[i]));

  995.                                         }

  996.                                     }

  997.                                     getPosList = dList;

  998.                                 }

  999.                                 else

  1000.                                 {

  1001.                                     for (int i = 0; i < 28; i++)

  1002.                                         getPosList.Add(0);

  1003.                                 }

  1004.                                 //getPosList = processParam.Value<JArray>("GetPointList").ToObject<List<double>>();

  1005.                             }

  1006.                             catch

  1007.                             {

  1008.                                 for (int i = 0; i < 28; i++)

  1009.                                     getPosList.Add(0);

  1010.                             }

  1011. 

  1012. 

  1013.                             double[] getPosArray = getPosList.ToArray();

  1014.                             if (scannerCBmpQueue.Count < 1)

  1015.                             {

  1016.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"尺寸检测异常，无源图像!!", WarningEnum.Low);

  1017.                                 warning(WarningEnum.Low);//暂停

  1018.                                 return stepIndex;

  1019.                             }

  1020.                             var bmpCBmpQueue = scannerCBmpQueue.Dequeue();

  1021.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"开始尺寸检测，index:{sizeIndex},posX:{bmpCBmpQueue.PosX},posY:{bmpCBmpQueue.PosY},图像队列数量: {scannerCBmpQueue.Count}...");

  1022. 

  1023.                             attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);

  1024.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"尺寸检测，index:{sizeIndex},{model.AttachmentList.Count}|{(attachmentFile == null ? "null": attachmentFile.NameTimestamp+ attachmentFile.ExtendName)}");

  1025.                             if (attachmentFile != null)

  1026.                             {

  1027.                                 gbxBmpPath = Application.StartupPath + $"\\Attachment\\product\\{attachmentFile.NameTimestamp}";

  1028.                                 if (!File.Exists(gbxBmpPath+ attachmentFile.ExtendName)) gbxBmpPath = "";

  1029.                             }

  1030.                             if ((sizeIndex == 333 || sizeIndex == 777) && gbxBmpPath == "")

  1031.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"尺寸检测，index:{sizeIndex},图纸不存在！", WarningEnum.Low);

  1032.                             //2023-10-27

  1033.                             //if ((sizeIndex == 3333)&&(getPosList != null) && (getPosList.Count() != 28))

  1034.                             //    AddTextEvent($"{stepIndex + 1}-{processName}", $"尺寸检测，index:{sizeIndex},图纸读点不存在！", WarningEnum.Low);

  1035.                             if (useMap&&(sizeIndex == 3333) && (getPosArray != null) && (getPosArray.Count() == 28) && (getPosArray[0] != 0))

  1036.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"开始图纸读点，index:{sizeIndex},PT1:{getPosArray[0]},PT2:{getPosArray[2]},PT3:{getPosArray[4]},PT4:{getPosArray[6]},PT5:{getPosArray[8]}," +

  1037.                                     $"线宽1:[{getPosArray[10]},{getPosArray[11]}],线宽2:[{getPosArray[12]},{getPosArray[13]}],线宽3:[{getPosArray[14]},{getPosArray[15]}]," +

  1038.                                     $"线宽4:[{getPosArray[16]},{getPosArray[17]}],线宽5:[{getPosArray[18]},{getPosArray[19]}],线宽6:[{getPosArray[20]},{getPosArray[21]}]," +

  1039.                                     $"线宽7:[{getPosArray[22]},{getPosArray[23]}],线宽8:[{getPosArray[24]},{getPosArray[25]}],线宽9:[{getPosArray[26]},{getPosArray[27]}]");

  1040.                             //需要偏移校正，index=0时不能异步 //10,20,30...　

  1041.                             endEvent = new AutoResetEvent(false);

  1042.                             devContainer.libSize.add(new SizeTask()

  1043.                             {

  1044.                                 stepIndex = stepIndex,

  1045.                                 processName = processName,

  1046.                                 sizeTag = sizeTag,

  1047.                                 engineName = processParam.Value<string>("EngineName"),

  1048.                                 bmp = bmpCBmpQueue.BMP == null ? bmpCBmpQueue.BMP : (Bitmap)bmpCBmpQueue.BMP.Clone(),//bmp/file_path二选一，优先bmp

  1049.                                 file_path = bmpCBmpQueue.Path,

  1050.                                 drawingPagePath = gbxBmpPath,

  1051.                                 posX= bmpCBmpQueue.PosX,

  1052.                                 posY= bmpCBmpQueue.PosY,

  1053.                                 //2023-10-27

  1054.                                 PTandLinePos = getPosArray,

  1055.                                 index = sizeIndex,// scannerCBmpIndex++,

  1056.                                 ContoursAffineTrans1_Out=this.contoursAffineTrans1_Out,//只有777时才使用最近333输出的结果 

  1057.                                 finishEvent = (res) =>

  1058.                                 {

  1059.                                     try

  1060.                                     {

  1061.                                         //比对

  1062.                                         if (res.index == 777)//比对

  1063.                                         {

  1064.                                             if (res.isSucceed)

  1065.                                             {

  1066.                                                 setDgvContentCol(liStatocStepIndex, $"index:{res.index}-{compBmpIndex}，posX:{res.posX},posY:{res.posY},图像比对:{(res.CompResult ? "通过" : "未通过")} ");

  1067.                                                 AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"图像比对，index:{res.index}-{compBmpIndex},posX:{res.posX},posY:{res.posY}，结果:{(res.CompResult ? "通过" : "未通过")}");

  1068.                                                 // 

  1069.                                                 if (order.CompareResult < 2)

  1070.                                                     order.CompareResult = res.CompResult ? 1 : 2;

  1071.                                                 updateCompareResult(res.CompResult);//更新比对看板 

  1072.                                                 if (!res.CompResult)

  1073.                                                 {

  1074.                                                     AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"图像比对，未通过结果:{JsonConvert.SerializeObject(res.defectInfor2RestorationDesk)}");

  1075.                                                     //转为图纸上坐标位置

  1076.                                                     if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)

  1077.                                                     {

  1078.                                                         //AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"转换到图纸后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");

  1079.                                                         if (order.DefectInfoList == null)

  1080.                                                             order.DefectInfoList = new List<DefectInfo>();

  1081.                                                         foreach (var item in res.defectInfor2RestorationDeskPage)

  1082.                                                             order.DefectInfoList.Add(new DefectInfo()

  1083.                                                             {

  1084.                                                                 Type = 1,

  1085.                                                                 Code = item[3],

  1086.                                                                 X = double.Parse(item[1]),

  1087.                                                                 Y = double.Parse(item[2]),

  1088.                                                                 ZXD = double.Parse(item[4]),

  1089.                                                                 ModifyUserCode = Config.loginUser.Code,

  1090.                                                                 CreateUserCode = Config.loginUser.Code,

  1091.                                                             });

  1092.                                                     }

  1093. 

  1094.                                                     //比对失败的图片 -- 用于修复台调用

  1095.                                                     Bitmap bmpCompareFailZoomImage = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.Zoom_Image_mat);

  1096.                                                     lstCompareFailZoomImage.Add(bmpCompareFailZoomImage);

  1097.                                                     if (Config.SizeBmp_Zoom_Image_SavePath != "" && Directory.Exists(Config.SizeBmp_Zoom_Image_SavePath))

  1098.                                                     {

  1099.                                                         string path = Util.createSubDir(Config.SizeBmp_Zoom_Image_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1100.                                                         //path += $"Size_SN{order.SN}_I{res.index}_X{res.Defects_X}_Y{res.Defects_Y}_C0_{ model.StepInfo.Name}";

  1101.                                                         path += $"Size_SN{order.SN}_I{compBmpIndex}_X{res.posX}_Y{res.posY}_C0_{ model.StepInfo.Name}";

  1102.                                                         bmpCompareFailZoomImage.Save(path + ".bmp", ImageFormat.Bmp);

  1103.                                                         if (res.defectInfor2RestorationDesk != null && res.defectInfor2RestorationDesk.Count > 0)

  1104.                                                             File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));

  1105.                                                     }

  1106.                                                     //保存原图

  1107.                                                     if (Config.SizeBmp_Compare_SavePath != "" && Directory.Exists(Config.SizeBmp_Compare_SavePath))

  1108.                                                     {

  1109.                                                         string path = Util.createSubDir(Config.SizeBmp_Compare_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1110.                                                         path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{ model.StepInfo.Name}.bmp";

  1111.                                                         AddTextEvent($"{res.stepIndex + 1}-{processName}", $"未通过图片保存:{path}");

  1112.                                                         if (res.bmp != null)

  1113.                                                             res.bmp.Save(path, ImageFormat.Bmp);

  1114.                                                         else

  1115.                                                             API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 

  1116.                                                     }

  1117.                                                 }

  1118.                                             }

  1119.                                             else

  1120.                                             {

  1121.                                                 //2023-12-29 加入比对失败当作NG处理

  1122.                                                 order.CompareResult =  2;

  1123.                                                 updateCompareResult(false);//更新比对看板 

  1124. 

  1125.                                                 //warning(WarningEnum.Low);//暂停

  1126.                                                 setDgvContentCol(liStatocStepIndex, $"index:{res.index}，图像比对失败！");

  1127.                                                 AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"图像比对失败，index:{res.index}-{compBmpIndex}.", WarningEnum.Low);

  1128.                                             }

  1129.                                             compBmpIndex++;

  1130.                                         }

  1131.                                         //MARK

  1132.                                         else if (res.index == 111 || res.index == 222 || res.index == 333 || res.index == 444)

  1133.                                         { 

  1134.                                             AddTextEvent($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index}，结果记录...");

  1135.                                             if (res.index == 333) this.contoursAffineTrans1_Out = res.ContoursAffineTrans1_Out;//不管成功失败都替换

  1136.                                             if (res.isSucceed)

  1137.                                             {

  1138.                                                 Thread.Sleep(100);

  1139.                                                 AddTextEvent($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index}; 当前值：{string.Join(",", res.MarkPointList)}");

  1140.                                                 JArray markDatas;

  1141.                                                 if (string.IsNullOrWhiteSpace(order.MarkData))

  1142.                                                     markDatas = new JArray() { 0, 0, 0, 0, 0, 0, 0, 0 };

  1143.                                                 else

  1144.                                                     markDatas = JArray.Parse(order.MarkData);

  1145.                                                 for (int i = 0; i < res.MarkPointList.Count(); i++)

  1146.                                                     if (res.MarkPointList[i] != 0)

  1147.                                                         markDatas[i] = res.MarkPointList[i];

  1148.                                                 order.MarkData = markDatas.ToString();

  1149.                                                 setDgvContentCol(liStatocStepIndex, $"index:{res.index}，Mark点:{order.MarkData} ");

  1150.                                                 AddTextEvent($"{res.stepIndex + 1}-{processName}", $"Mark点 Index={res.index};合并后：{order.MarkData}");

  1151.                                             }

  1152.                                             else

  1153.                                             {

  1154.                                                 //warning(WarningEnum.Low);//暂停

  1155.                                                 setDgvContentCol(liStatocStepIndex, $"index:{res.index}，Mark点计算失败！");

  1156.                                                 AddTextEvent($"{res.stepIndex + 1}-{processName}", $"Mark点计算失败，index:{res.index}.", WarningEnum.Low);

  1157.                                                 //2023-10-20 make暂停

  1158.                                                 if (Config.OpenMarkErrorStop)

  1159.                                                     warning(WarningEnum.Low);//暂停

  1160.                                             }

  1161. 

  1162.                                             //保存

  1163.                                             if (Config.SizeBmp_SavePath != "" && Directory.Exists(Config.SizeBmp_SavePath))

  1164.                                             {

  1165.                                                 string path = Util.createSubDir(Config.SizeBmp_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1166.                                                 path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{ model.StepInfo.Name}.bmp";

  1167.                                                 if (res.bmp != null)

  1168.                                                     res.bmp.Save(path, ImageFormat.Bmp);

  1169.                                                 else

  1170.                                                     API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 

  1171.                                             }

  1172.                                         }

  1173.                                         else

  1174.                                         { 

  1175.                                             int roundIndex = res.index % 10;

  1176.                                             if (res.isSucceed)

  1177.                                             {

  1178.                                                 string tagOutData = "";

  1179.                                                 if (res.index == 3333 && !string.IsNullOrWhiteSpace(res.sizeTag))

  1180.                                                 {

  1181.                                                     tagOutData = $"Tag:{res.sizeTag},posePT:[{string.Join(",", res.posePT)}]";

  1182.                                                     if (res.posePT.Length < 2 || res.posePT.Length % 2 != 0)

  1183.                                                     {

  1184.                                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测输出Tag对应posePT非法: {tagOutData}", WarningEnum.High);

  1185.                                                         warning(WarningEnum.High);//急停

  1186.                                                         return;

  1187.                                                     }

  1188.                                                     //2023-10-27

  1189.                                                     AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"Tag对应posePT: {tagOutData}", WarningEnum.Normal);

  1190. 

  1191.                                                     if (order.SizeTagDataList == null)

  1192.                                                         order.SizeTagDataList = new List<SizeTagData>();

  1193.                                                     order.SizeTagDataList.Add(new SizeTagData()

  1194.                                                     {

  1195.                                                         SizeTag = res.sizeTag,

  1196.                                                         CreateStepIndex = res.stepIndex + 1,

  1197.                                                         posePT= string.Join(",", res.posePT)// 回转 Array.ConvertAll(sNums , double.Parse);

  1198.                                                     });

  1199. 

  1200.                                                 }

  1201. 

  1202.                                                 setDgvContentCol(liStatocStepIndex, $"index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData}");

  1203.                                                 AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测完成 index:{res.index}，PT1:{res.PT1}，PT2:{res.PT2}，Shanxian:{res.Shanxian}，Circle_Xmm:{res.Circle_Xmm}，Circle_Ymm:{res.Circle_Ymm}，offsetX:{res.offsetX}，offsetY:{res.offsetY}, {tagOutData} ");

  1204.                                                 //测量

  1205.                                                 //------TEST

  1206.                                                 if (res.index>20 && res.index<30)

  1207.                                                 {

  1208.                                                     lock (lstPT)

  1209.                                                     {

  1210.                                                         lstPT.Add(Math.Round(res.PT1 + Config.PT_Offset, 4)); 

  1211.                                                         updatePTValueTest(model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue);

  1212.                                                     }

  1213.                                                 }

  1214.                                                 //------

  1215.                                                 if (roundIndex > 0)//1-9测量

  1216.                                                 {

  1217.                                                     if (res.index < 10)//11-13 (PT: 7-9 => 21-29（PT1）) 不用管，李工处理

  1218.                                                     {

  1219.                                                         //if (roundIndex >= 7)

  1220.                                                         //{

  1221.                                                         //    lock (lstPT)

  1222.                                                         //    {

  1223.                                                         //        lstPT.Add(Math.Round(res.PT1, 4));

  1224.                                                         //        lstPT.Add(res.index == 8 ? 0 : Math.Round(res.PT2, 4));

  1225.                                                         //        updatePTValue(model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue);

  1226.                                                         //    }

  1227.                                                         //}

  1228. 

  1229.                                                         lock (lstLineWidth)

  1230.                                                         {

  1231.                                                             lstLineWidth.Add(res.Shanxian > 0 ? Math.Round(res.Shanxian + Config.LineWidth_Offset, 2) : 0);

  1232.                                                             updateLineWidthValue(model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue);

  1233.                                                         }

  1234.                                                     }

  1235.                                                 }

  1236.                                                 //校正偏移 10,20,30...:偏移

  1237.                                                 else

  1238.                                                 {

  1239.                                                     AxMoveMode axSizeMode = AxMoveMode.绝对位置;

  1240.                                                     double xPos = 0;

  1241.                                                     double yPos = 0;

  1242.                                                     //绝对偏移 

  1243.                                                     if (res.offsetX != 0 || res.offsetY != 0)

  1244.                                                     {

  1245.                                                         xPos += res.offsetX;

  1246.                                                         yPos += res.offsetY;

  1247.                                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"offsetX/Y绝对校正, 0轴:{xPos}mm, 2轴:{yPos}mm");

  1248.                                                     }

  1249.                                                     else if (res.Circle_Xmm != 0 || res.Circle_Ymm != 0)//相对偏移校正

  1250.                                                     {

  1251.                                                         axSizeMode = AxMoveMode.相对位置;

  1252.                                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"原点相对校正, 0轴:{res.Circle_Xmm}mm, 2轴:{res.Circle_Ymm}mm");

  1253.                                                         if (res.Circle_Xmm != 0) xPos = res.Circle_Xmm;

  1254.                                                         if (res.Circle_Ymm != 0) yPos = res.Circle_Ymm;

  1255.                                                     }

  1256.                                                     //当前工序直接移动                                                   

  1257.                                                     if (xPos != 0 || yPos != 0)

  1258.                                                     {

  1259.                                                         devContainer.devAxis.setAxisVelParam(0.1, 1, 1, 1, 0);

  1260.                                                         devContainer.devAxis.setAxisVelParam(0.1, 1, 1, 1, 2);

  1261.                                                         if (xPos != 0) devContainer.devAxis.move_ptp(0, xPos, axSizeMode);

  1262.                                                         if (yPos != 0) devContainer.devAxis.move_ptp(2, yPos, axSizeMode);

  1263.                                                         while (!devContainer.devAxis.isReady(0) || !devContainer.devAxis.isReady(2))

  1264.                                                         {

  1265.                                                             Thread.Sleep(100);

  1266.                                                             if (isBreakProcessRun())

  1267.                                                                 break;

  1268.                                                         }

  1269.                                                     }

  1270.                                                 }

  1271.                                                  

  1272.                                                 //保存

  1273.                                                 //string sizeFileName = Config.Size_SavePath + "\\" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff");

  1274.                                                 //API.CopyFile(res.file_path, defectFileName + ".bmp", false);//更快

  1275.                                                 //File.WriteAllText(defectFileName + ".json", JsonConvert.SerializeObject(res.informationList));

  1276.                                             }

  1277.                                             //失败

  1278.                                             else

  1279.                                             {

  1280.                                                 //------TEST

  1281.                                                 if (res.index > 20 && res.index < 30)

  1282.                                                 {

  1283.                                                     lock (lstPT)

  1284.                                                     {

  1285.                                                         lstPT.Add(0);

  1286.                                                         updatePTValueTest(model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue);

  1287.                                                     }

  1288.                                                 }

  1289.                                                 //------

  1290. 

  1291.                                                 if (roundIndex > 0)

  1292.                                                 {

  1293.                                                     //if (roundIndex >= 7)

  1294.                                                     //{

  1295.                                                     //    lock (lstPT)

  1296.                                                     //    {

  1297.                                                     //        lstPT.Add(0);

  1298.                                                     //        lstPT.Add(0);

  1299.                                                     //        updatePTValue(model.PTBaseValue + model.PTUpFloatValue, model.PTBaseValue - model.PTDownFloatValue);

  1300.                                                     //    }

  1301.                                                     //}

  1302.                                                 

  1303.                                                     lock (lstLineWidth)

  1304.                                                     {

  1305.                                                         lstLineWidth.Add(0);

  1306.                                                         updateLineWidthValue(model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue);

  1307.                                                     }

  1308.                                                 }

  1309.                                                 setDgvContentCol(liStatocStepIndex, $"失败:{res.resultInfo}");

  1310.                                                 AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测失败index:{res.index}:{res.resultInfo}");

  1311.                                                 //warning(WarningEnum.Low);//暂停  这里不能暂停，stepIndex和scannerBmpQueue队列也不对了

  1312.                                             }

  1313.                                              

  1314.                                             //保存

  1315.                                             if (Config.SizeBmp_SavePath != "" && Directory.Exists(Config.SizeBmp_SavePath))

  1316.                                             {

  1317.                                                 string path = Util.createSubDir(Config.SizeBmp_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1318.                                                 path += $"Size_SN{order.SN}_I{res.index}_X{res.posX}_Y{res.posY}_{ model.StepInfo.Name}.bmp";

  1319.                                                 if (res.bmp != null)

  1320.                                                     res.bmp.Save(path, ImageFormat.Bmp);

  1321.                                                 else

  1322.                                                     API.CopyFile(res.file_path, path, false);//比.NET(File.Copy)更快 

  1323.                                             }

  1324.                                         }

  1325.                                     }

  1326.                                     catch(Exception ex)

  1327.                                     {

  1328.                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"尺寸检测回调处理异常 index:{res.index}，ex={ex.Message}");

  1329.                                     }

  1330. 

  1331.                                     //

  1332.                                     //if (!asynRun)//是否异步执行endEvent.Set()都没问题

  1333.                                     endEvent.Set();//roundIndex＝０成功或失败线程返回

  1334.                                     //---

  1335.                                     if (res.bmp != null)

  1336.                                     {

  1337.                                         res.bmp.Dispose();

  1338.                                         res.bmp = null;

  1339.                                     }

  1340.                                     else

  1341.                                     {

  1342.                                         API.DeleteFile(res.file_path);

  1343.                                     }

  1344.                                 }

  1345.                             });

  1346. 

  1347.                             //需等上面异步回调中的相对偏移校正完成再继续

  1348.                             if (!asynRun || sizeIndex % 10==0)

  1349.                             {

  1350.                                 if (!endEvent.WaitOne(60000))

  1351.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"{sizeIndex}等待超时，忽略继续！", WarningEnum.Low);

  1352.                             }

  1353.                             #endregion

  1354.                             break;

  1355.                         case "Defect":

  1356.                             #region

  1357.                             limitThresholdVal = processParam.Value<double>("LimitThresholdVal");

  1358.                             lowerThresholdVal = processParam.Value<double>("LowerThresholdVal");

  1359.                             if (scannerGBmpQueue.Count < 1)

  1360.                             {

  1361.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"缺陷检测异常，无源图像!!", WarningEnum.Low);

  1362.                                 warning(WarningEnum.Low);//终止

  1363.                                 return stepIndex;

  1364.                             }

  1365.                             var bmpLoc = scannerGBmpQueue.Dequeue();

  1366.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"开始缺陷检测，源图索引:{defectBmpNum},图像队列数量: {scannerGBmpQueue.Count}...");

  1367.                             string[] aarCut_size = processParam.Value<string>("CutSize").Split(',');

  1368.                             string[] aarResize = processParam.Value<string>("Resize").Split(',');

  1369.                             //图纸

  1370.                             attachmentFile = model.AttachmentList.FirstOrDefault(x => x.Type == 0);

  1371.                             if (attachmentFile != null)

  1372.                             {

  1373.                                 gbxBmpPath = Application.StartupPath + $"\\Attachment\\product\\{attachmentFile.NameTimestamp}";

  1374.                                 if (!File.Exists(gbxBmpPath + attachmentFile.ExtendName)) gbxBmpPath = "";

  1375.                             }

  1376.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"图纸路径:{gbxBmpPath}");

  1377.                             devContainer.libDefect.add(new DefectTask()

  1378.                             {

  1379.                                 stepIndex= stepIndex,

  1380.                                 processName= processName,

  1381.                                 drawingPagePath= gbxBmpPath,

  1382.                                 index = defectBmpNum++,

  1383.                                 bmp = bmpLoc.bmp,

  1384.                                 Xmm = bmpLoc.Xmm,

  1385.                                 Ymm = bmpLoc.Ymm,

  1386.                                 cut_size = new System.Drawing.Size(Convert.ToInt32(aarCut_size[0]), Convert.ToInt32(aarCut_size[1])),

  1387.                                 resize = new System.Drawing.Size(Convert.ToInt32(aarResize[0]), Convert.ToInt32(aarResize[1])),

  1388.                                 thresholds = processParam.Value<float>("Thresholds"),

  1389.                                 thresholdsClass = processParam.Value<string>("ThresholdsClass"),

  1390.                                 recAreaThreshold= getProductAreaThreshol(model), //qxName,面积; qxName,面积; qxName,面积;

  1391.                                 finishEvent = (res) =>

  1392.                                 {

  1393.                                     if (res.isSucceed)

  1394.                                     {

  1395.                                         setDgvContentCol(liStatocStepIndex, $"源图索引:{res.index}，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}");

  1396.                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测完成(源图索引:{res.index})，缺陷数:{res.defectCount}，处理时间(ms):{string.Join("->", res.stopwatch.Select(i => i.ToString()).ToArray())}");

  1397.                                         string path;

  1398.                                         if (res.defectCount > 0)

  1399.                                         { 

  1400.                                             //UI显示小图 (含统计缺陷类型数量)

  1401.                                             showDefectSmallBmps(res.bmps_tag, res.bmps_cut, res.Xmm, res.Ymm, res.informationList);

  1402.                                             if (res.defectInfor2RestorationDeskPage != null && res.defectInfor2RestorationDeskPage.Count > 0)

  1403.                                             {

  1404.                                                 AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"转换后坐标数据：{JsonConvert.SerializeObject(res.defectInfor2RestorationDeskPage)}");

  1405.                                                 if (order.DefectInfoList == null) 

  1406.                                                     order.DefectInfoList = new List<DefectInfo>();

  1407.                                                 foreach (var item in res.defectInfor2RestorationDeskPage) 

  1408.                                                     order.DefectInfoList.Add(new DefectInfo()

  1409.                                                     {

  1410.                                                         Type = 0,

  1411.                                                         Code = item[3],

  1412.                                                         X = double.Parse(item[1]),

  1413.                                                         Y = double.Parse(item[2]),

  1414.                                                         ZXD = double.Parse(item[4]),

  1415.                                                         ModifyUserCode = Config.loginUser.Code,

  1416.                                                         CreateUserCode = Config.loginUser.Code,

  1417.                                                     });

  1418.                                             }

  1419.                                             //保存原始大图

  1420.                                             if (Config.Defect_SavePath != "" && Directory.Exists(Config.Defect_SavePath))

  1421.                                             {

  1422.                                                 path = Util.createSubDir(Config.Defect_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1423.                                                 path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{ model.StepInfo.Name}";

  1424.                                                 //API.CopyFile(res.file_path, defectFileName + ".bmp", false);//比.NET(File.Copy)更快

  1425.                                                 //res.bmp.SaveImage(path + ".bmp");//opencv保存格式与BMP不同

  1426.                                                 OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);

  1427.                                                 File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.informationList));

  1428.                                             }

  1429. 

  1430.                                             //保存小图

  1431.                                             if (Config.Defect_Small_SavePath != "" && Directory.Exists(Config.Defect_Small_SavePath))

  1432.                                             {

  1433.                                                 path = Util.createSubDir(Config.Defect_Small_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1434.                                                 path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_{ model.StepInfo.Name}";

  1435.                                                 for (int i = 0; i < res.bmps_tag.Count(); i++)

  1436.                                                     res.bmps_tag[i].Save(path + $"_i{i}.bmp", ImageFormat.Bmp);

  1437.                                             }

  1438. 

  1439.                                             //保存原始小图

  1440.                                             if (Config.Defect_SrcSmall_SavePath != "" && Directory.Exists(Config.Defect_SrcSmall_SavePath))

  1441.                                             {

  1442.                                                 for (int i = 0; i < res.defectInfor2RestorationDesk.Count(); i++)

  1443.                                                 {

  1444.                                                     int indext = int.Parse(res.defectInfor2RestorationDesk[i][0]);

  1445.                                                     double thres = double.Parse(res.defectInfor2RestorationDesk[i][4]);

  1446.                                                     if (thres >= Config.Defect_SrcSmall_Thres)

  1447.                                                     {

  1448.                                                         path = Util.createSubDir(Config.Defect_SrcSmall_SavePath,

  1449.                                                         new List<string> { order.CreateTime.ToString("yyyyMMdd"),

  1450.                                                         order.SN,

  1451.                                                         order.ProductInfo.MainGrid == 1?"主栅":order.ProductInfo.ClassesId == 7?"rj":"pi",

  1452.                                                         res.defectInfor2RestorationDesk[i][3]});

  1453.                                                         path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_{model.StepInfo.Name}";

  1454.                                                         res.bmps_cut[indext].ImWrite(path + $"_i{i}.bmp");

  1455.                                                     }

  1456.                                                 }

  1457.                                                     

  1458.                                             }

  1459. 

  1460.                                             //保存压缩大图 -- 用于修复台调用

  1461.                                             if (Config.Defect_Compress_SavePath != "" && Directory.Exists(Config.Defect_Compress_SavePath))

  1462.                                             {

  1463.                                                 path = Util.createSubDir(Config.Defect_Compress_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1464.                                                 path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{ model.StepInfo.Name}";

  1465.                                                 //res.bmpCompress.SaveImage(path + ".bmp");//opencv保存格式与BMP不同

  1466.                                                 OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmpCompress).Save(path + ".bmp", ImageFormat.Bmp);

  1467.                                                 File.WriteAllText(path + ".json", JsonConvert.SerializeObject(res.defectInfor2RestorationDesk));

  1468.                                             }

  1469.                                         }

  1470.                                         else//没有缺陷

  1471.                                         { 

  1472.                                             if (Config.SaveAllDefectImg && Config.Defect_SavePath != "" && Directory.Exists(Config.Defect_SavePath))

  1473.                                             {

  1474.                                                 path = Util.createSubDir(Config.Defect_SavePath, new List<string> { order.CreateTime.ToString("yyyyMMdd"), order.SN });

  1475.                                                 path += $"Defect_SN{order.SN}_I{res.index}_X{res.Xmm}_Y{res.Ymm}_C{res.defectCount}_{ model.StepInfo.Name}";

  1476.                                                 //API.CopyFile(res.file_path, defectFileName + ".bmp", false);//比.NET(File.Copy)更快

  1477.                                                 //res.bmp.SaveImage(path + ".bmp");//opencv保存格式与BMP不同

  1478.                                                 OpenCvSharp.Extensions.BitmapConverter.ToBitmap(res.bmp).Save(path + ".bmp", ImageFormat.Bmp);

  1479. 

  1480.                                             }

  1481.                                         }

  1482.                                     }

  1483.                                     else

  1484.                                     {

  1485.                                         setDgvContentCol(liStatocStepIndex, $"失败:{res.resultInfo}");

  1486.                                         AddTextEvent($"{res.stepIndex + 1}-{res.processName}", $"缺陷检测失败:{res.resultInfo}");

  1487.                                         //warning(WarningEnum.Low);//暂停 这里不能暂停，stepIndex和scannerBmpQueue队列也不对了

  1488.                                     }

  1489.                                     defectBmpNumResult++;

  1490.                                     foreach (var item in res.bmps_cut)

  1491.                                         item.Dispose();

  1492.                                     res.bmp.Dispose(); 

  1493.                                     res.bmp = null;

  1494.                                     res.bmps_tag = null;

  1495.                                     if (res.bmpCompress != null)

  1496.                                     {

  1497.                                         res.bmpCompress.Dispose();

  1498.                                         res.bmpCompress = null;

  1499.                                     }

  1500.                                     System.GC.Collect();

  1501.                                 }

  1502.                             });

  1503.                             #endregion

  1504.                             break;

  1505.                         case "For":

  1506.                             #region

  1507.                             long UniqueId = processParam.Value<long>("UniqueId");

  1508.                             int GotoStepIndex = processParam.Value<int>("GotoStepIndex");//1-n

  1509.                             int LimitNum = processParam.Value<int>("LimitNum");//1-n

  1510.                             bool Reset = processParam.Value<bool>("Reset");

  1511.                             if (GotoStepIndex - 1 == stepIndex)

  1512.                             {

  1513.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"For死循环！！！");

  1514.                                 warning(WarningEnum.High);

  1515.                                 return stepIndex;

  1516.                             }

  1517.                             if (!devContainer.libFor.dicData.ContainsKey(UniqueId))

  1518.                                 devContainer.libFor.dicData.Add(UniqueId, 0);

  1519.                             //

  1520.                             int Num = devContainer.libFor.dicData[UniqueId];

  1521.                             Num++;

  1522.                             if (Num <= LimitNum)

  1523.                             {

  1524.                                 if (Num == LimitNum)

  1525.                                 {

  1526.                                     setDgvContentCol(liStatocStepIndex, $"第[{Num}/{LimitNum}]次，循环完成");

  1527.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次，循环完成。");

  1528.                                 }

  1529.                                 else

  1530.                                 {

  1531.                                     setDgvContentCol(liStatocStepIndex, $"第[{Num}/{LimitNum}]次");

  1532.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"第[{Num}/{LimitNum}]次跳转到步骤[{GotoStepIndex}]...");

  1533.                                     stepIndex = GotoStepIndex - 2;

  1534.                                 }

  1535.                                 devContainer.libFor.dicData[UniqueId] = Num;

  1536.                             }

  1537.                             else

  1538.                             { 

  1539.                                 setDgvContentCol(liStatocStepIndex, $"已失效不执行");

  1540.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"本循环已失效不执行！");

  1541.                             }

  1542. 

  1543.                             //达到limit重置0

  1544.                             if (devContainer.libFor.dicData[UniqueId] >= LimitNum && Reset)

  1545.                             {

  1546.                                 devContainer.libFor.dicData[UniqueId] = 0;

  1547.                                 setDgvContentCol(liStatocStepIndex, $"第[0/{LimitNum}]次");

  1548.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"计数器已重置。");

  1549.                             }

  1550.                             #endregion

  1551.                             break;

  1552.                         case "If":

  1553.                             #region

  1554.                             long UniqueId_if = processParam.Value<long>("UniqueId");

  1555.                             int GotoStepIndex_if = processParam.Value<int>("GotoStepIndex");//1-n

  1556.                             int LimitNum_if = processParam.Value<int>("LimitNum");//1-n

  1557.                             bool Reset_if = processParam.Value<bool>("Reset");

  1558.                             if (GotoStepIndex_if - 1 == stepIndex)

  1559.                             {

  1560.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"If死循环，不可自我跳转！！！");

  1561.                                 warning(WarningEnum.High);

  1562.                                 return stepIndex;

  1563.                             }

  1564.                             //

  1565.                             if (!devContainer.libIF.dicData.ContainsKey(UniqueId_if))

  1566.                                 devContainer.libIF.dicData.Add(UniqueId_if, 0);

  1567.                             //

  1568.                             int Num_if = devContainer.libIF.dicData[UniqueId_if];

  1569.                             Num_if++;

  1570.                             if (Num_if <= LimitNum_if)

  1571.                             {

  1572.                                 if (Num_if == LimitNum_if)

  1573.                                 {

  1574.                                     setDgvContentCol(liStatocStepIndex, $"第[{Num_if}/{LimitNum_if}]次，跳转至[{GotoStepIndex_if}]");

  1575.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"计数器[{Num_if}/{LimitNum_if}]，跳转至步骤[{GotoStepIndex_if}]...");

  1576.                                     stepIndex = GotoStepIndex_if - 2;

  1577.                                 }

  1578.                                 else

  1579.                                 {

  1580.                                     setDgvContentCol(liStatocStepIndex, $"第[{Num_if}/{LimitNum_if}]次，不跳转");

  1581.                                     AddTextEvent($"{stepIndex + 1}-{processName}", $"计数器[{Num_if}/{LimitNum_if}]，不跳转。");

  1582.                                 }

  1583.                                 //

  1584.                                 devContainer.libIF.dicData[UniqueId_if] = Num_if;

  1585.                             }

  1586.                             else

  1587.                             {

  1588.                                 setDgvContentCol(liStatocStepIndex, $"已失效不执行");

  1589.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"本IF已失效不执行。");

  1590.                             }

  1591. 

  1592.                             //达到limit重置0

  1593.                             if (devContainer.libIF.dicData[UniqueId_if] >= LimitNum_if && Reset_if)

  1594.                             {

  1595.                                 devContainer.libIF.dicData[UniqueId_if] = 0;

  1596.                                 setDgvContentCol(liStatocStepIndex, $"第[0/{LimitNum_if}]次"); 

  1597.                                 AddTextEvent($"{stepIndex + 1}-{processName}", $"计数器已重置。");

  1598.                             }

  1599.                             #endregion

  1600.                             break;

  1601.                         default:

  1602.                             AddTextEvent($"{stepIndex + 1}-{processName}", $"未知工序：{processInfo.ProcessCode}");

  1603.                             warning(WarningEnum.High);

  1604.                             return stepIndex;

  1605.                     }

  1606.                     if (sleepLater > 0) Thread.Sleep((int)sleepLater);

  1607.                 } 

  1608. 

  1609.                 //============结束，判断是否自动下料 

  1610.                 if (stepIndex == processList.Count - 1)

  1611.                 {

  1612.                     //厚度校正 直接更新并保存

  1613.                     if (isProductRevise)

  1614.                     {

  1615.                         isProductRevise = false;

  1616.                         if (MessageBox.Show($"厚度校正完成，是否保存？\r\nBase值：{model.HeightBaseDec}", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

  1617.                         {

  1618.                             //保存  //更新指定列

  1619.                             if (svcProduct.Update(it => new Product() { HeightBaseDec = model.HeightBaseDec }, it => it.Id == model.Id))

  1620.                                 AddTextEvent($"产品校正", $"保存成功。");

  1621.                             else

  1622.                                 AddTextEvent($"产品校正", $"保存失败！！");

  1623.                         }

  1624.                         //下料 

  1625.                         currentState = CurrentStateEnum.自动流程结束;

  1626.                         gotoDownPT();

  1627.                     }

  1628.                     else//生产

  1629.                     {

  1630.                         //等待缺陷图显示完成

  1631.                         while (defectBmpNum != defectBmpNumResult)

  1632.                             Thread.Sleep(100);

  1633. 

  1634.                         //判断是否合格 

  1635.                         DefectCodeEnum defectCode;

  1636.                         string defectNames = "";

  1637.                         if (model.QualifiedCriterionList!= null && model.QualifiedCriterionList.Count >0) 

  1638.                         {

  1639.                             int itemDefectCount;

  1640.                             foreach (var item in model.QualifiedCriterionList)

  1641.                             {

  1642.                                 defectCode = EnumUtil.Convert2Enum<DefectCodeEnum>(item.DefectCode);

  1643.                                 itemDefectCount = getDefectCountFromCode(order, defectCode);

  1644.                                 if (item.MaxDefectCount>-1 && itemDefectCount > item.MaxDefectCount)

  1645.                                 {

  1646.                                     order.Qualified = false;

  1647.                                     defectNames += $"{((DefectNameEnum)(int)defectCode).ToString()}({itemDefectCount}),"; 

  1648.                                 }

  1649.                             }

  1650.                         }

  1651. 

  1652.                         stopWatch.Stop();

  1653.                         long timeLen = stopWatch.ElapsedMilliseconds / 1000;

  1654.                         this.BeginInvoke(new System.Action(() =>

  1655.                         {

  1656.                             lblTimeLen.Visible = true;

  1657.                             lblTimeLen.Text = $"检测时长: {timeLen} 秒";

  1658.                             if (defectNames != "")

  1659.                             {

  1660.                                 lblDefectResult.Text = "未通过";

  1661.                                 lblDefectResultCount.Text = defectNames.Substring(0, defectNames.Length - 1);

  1662.                                 this.toolTip1.SetToolTip(lblDefectResultCount, lblDefectResultCount.Text);

  1663.                                 lblDefectResult.ForeColor = lblDefectResultCount.ForeColor = Color.Red;

  1664.                             }

  1665.                         }));  

  1666.                         order.TimeLen = timeLen;

  1667.                         order.DefectCount = (int)this.gboxDefectList.Tag;

  1668.                         order.Succeed = true;

  1669.                         order.ModifyUserCode = order.CreateUserCode = Config.loginUser.Code;

  1670. 

  1671.                         order.Abnormalities = "";//无异常

  1672.                         order.RepairCode = "";//无修复人员

  1673.                         //如SN检测已存在，先删除

  1674.                         var oldSNOrder= svcOrder.GetFirst(m=> m.SN==order.SN);

  1675.                         if(oldSNOrder!=null)

  1676.                         {

  1677.                             AddTextEvent("删除记录", $"删除上一重复SN检测记录:SN={oldSNOrder.SN}, Date={oldSNOrder.CreateTime}");

  1678.                             svcOrder.DelNav(oldSNOrder);

  1679.                         }

  1680.                         if (!svcOrder.InsertNav(order))//导航插入

  1681.                             AddTextEvent("保存失败", $"保存生产记录失败！");

  1682.                         //更新本批次检测数量

  1683.                         if (!string.IsNullOrWhiteSpace(model.BatchId))

  1684.                         {

  1685.                             var expOrder = Expressionable.Create<Order>()

  1686.                                 .And(m => m.ProductId == model.Id)

  1687.                                 .And(m => m.BatchId == model.BatchId)

  1688.                                 .ToExpression();//注意 这一句 不能少

  1689.                             currProductModel.CompleteCount = svcOrder.Count(expOrder);

  1690.                         }

  1691.                         //以主键为条件更新CompleteCount单列值 

  1692.                         svcProduct.Update(it => new Product() { CompleteCount = currProductModel.CompleteCount }, it => it.Id == currProductModel.Id);

  1693. 

  1694.                         if (Config.MakeTag && order.DefectCount > 0)//要打标 and 有缺陷图

  1695.                         {

  1696.                             AddTextEvent("完成", $"工序结束，用时 {order.TimeLen} 秒；缺陷 {order.DefectCount} 张.");

  1697.                                 //+(Config.MakeTag ?  "开始自动打标...":"手动打标..."));

  1698.                             currentPT = CurrentPTEnum.MakeTag;

  1699.                             currentState = CurrentStateEnum.打标中;

  1700.                             setButtonEnabled(tsbtnGoDownPT, true);

  1701.                             setButtonEnabled(tsbtnReset, true);

  1702.                             setButtonEnabled(btnMakeTags, true);

  1703.                             //if (!Config.MakeTag)//自动打标

  1704.                             {

  1705.                                 this.Invoke(new System.Action(() =>

  1706.                                 {

  1707.                                     btnMakeTag_Click(null, null);

  1708.                                 })); 

  1709.                             }

  1710.                         }

  1711.                         else//下料

  1712.                         {

  1713.                             AddTextEvent("完成", $"用时 {order.TimeLen} 秒，进行下料...");

  1714.                             currentState = CurrentStateEnum.自动流程结束; 

  1715.                             gotoDownPT();

  1716.                         }

  1717.                     }

  1718. 

  1719.                     currProcessIndex = -1;

  1720.                     return -1;

  1721.                 }

  1722.                 else //继续

  1723.                 {

  1724.                     return ++stepIndex;

  1725.                     //return nextProcess(model, ++stepIndex);

  1726.                 }

  1727.             }

  1728.             catch (Exception ex)

  1729.             {

  1730.                 AddTextEvent("工序", $"[{stepIndex+1}] Err:" + ex.Message+"\n"+ex.StackTrace);

  1731.                 warning(WarningEnum.Low);

  1732.                 return -2;

  1733.             }

  1734.         }

  1735.         private Dictionary<string, float> getProductAreaThreshol(Product m)

  1736.         {

  1737.             Dictionary<string, float> dic = new Dictionary<string, float>();

  1738.             foreach(var item in m.QualifiedCriterionList)

  1739.                 dic.Add(item.DefectCode, (float)(item.Size * 25.4 * 25.4 / m.HoleCount / m.HoleCount) );//网目 => mm^2

  1740. 

  1741.             //全缺陷项

  1742.             var lstDefect = Utils.EnumUtil.GetArrayList<DefectCodeEnum>();

  1743.             foreach (DictionaryEntry item in lstDefect)

  1744.             {

  1745.                 string code = item.Value.ToString();

  1746.                 if (!dic.ContainsKey(code))

  1747.                     dic.Add(code, 0); 

  1748.             }

  1749. 

  1750.             return dic;

  1751.         }

  1752.         private void setDgvContentCol(int rowIndex, string info)

  1753.         {

  1754.             int row = rowIndex;//why -1 ???

  1755.             this.Invoke(new System.Action(() =>

  1756.             {

  1757.                 this.dgvProcess.Rows[row].Cells["colValue"].Value = info;

  1758.             }));

  1759.         }

  1760.         /// <summary>

  1761.         /// 报警,只响应low,high

  1762.         /// </summary>

  1763.         private void warning(WarningEnum level, bool buzzer = true)

  1764.         {

  1765.             if (level == WarningEnum.Normal)

  1766.                 return;

  1767. 

  1768.             lock(myLock)

  1769.                 warningLevel = level;

  1770.             if (level == WarningEnum.Low)//暂停

  1771.             {

  1772.                 currentState = CurrentStateEnum.暂停;

  1773.                 pauseCommand(buzzer);

  1774.             }

  1775.             else if (level == WarningEnum.High)//急停

  1776.             {

  1777.                 currentState = CurrentStateEnum.急停;

  1778.                 devContainer.devAxis.stopNow();

  1779. 

  1780.                 stopNowCommand();

  1781.             }

  1782. 

  1783.             //启用报警消除按钮

  1784.             this.Invoke(new System.Action(() =>

  1785.             {

  1786.                 tsbtnWarning.Enabled = true;

  1787.             }));

  1788.         }  

  1789.         private void updateTensionValue(double upperLimit,double lowerLimit)

  1790.         {

  1791.             int count = lstTension.Count();

  1792.             if (count < 1) return;

  1793.             switch (count)

  1794.             {

  1795.                 case 1:

  1796.                     order.Tension1 = lstTension[count - 1]; 

  1797.                     AddTextEvent("张力值", $"张力1:{order.Tension1}");

  1798.                     break;

  1799.                 case 2:

  1800.                     order.Tension2 = lstTension[count - 1];

  1801.                     AddTextEvent("张力值", $"张力2:{order.Tension2}");

  1802.                     break;

  1803.                 case 3:

  1804.                     order.Tension3 = lstTension[count - 1];

  1805.                     AddTextEvent("张力值", $"张力3:{order.Tension3}");

  1806.                     break;

  1807.                 case 4:

  1808.                     order.Tension4 = lstTension[count - 1];

  1809.                     AddTextEvent("张力值", $"张力4:{order.Tension4}");

  1810.                     break;

  1811.                 case 5:

  1812.                     order.Tension5 = lstTension[count - 1];

  1813.                     AddTextEvent("张力值", $"张力5:{order.Tension5}");

  1814.                     break;

  1815.             }

  1816. 

  1817.             double value = Math.Round(lstTension.Average(), 2);

  1818.             double valueMax = lstTension.Max();

  1819.             double valueMin = lstTension.Min();

  1820.             if (order != null) order.TensionValue = value;

  1821.             Color color = (upperLimit+ lowerLimit>0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;

  1822.             Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;

  1823.             Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

  1824.             this.BeginInvoke(new System.Action(() =>

  1825.             { 

  1826.                 this.lblTension.Text = Math.Round(value, 2).ToString(); 

  1827.                 this.lblTension.ForeColor = color;

  1828. 

  1829.                 this.lblTensionMax.Text = Math.Round(valueMax, 2).ToString();

  1830.                 this.lblTensionMax.ForeColor = colorMax;

  1831. 

  1832.                 this.lblTensionMin.Text = Math.Round(valueMin, 2).ToString();

  1833.                 this.lblTensionMin.ForeColor = colorMin;

  1834.             }));

  1835.             //不合格

  1836.             if (color == Color.Red) order.Qualified = false;

  1837.         }

  1838.         private void updateHeightValue(double upperLimit, double lowerLimit)

  1839.         {

  1840.             int count = lstHeight.Count();

  1841.             if (count < 1) return;

  1842.             AddTextEvent("厚度", string.Join(",", lstHeight));

  1843.             switch (count)

  1844.             {

  1845.                 case 1:

  1846.                     order.Height1 = lstHeight[count - 1];

  1847.                     AddTextEvent("厚度值", $"厚度1:{order.Height1}");

  1848.                     break;

  1849.                 case 2:

  1850.                     order.Height2 = lstHeight[count - 1];

  1851.                     AddTextEvent("厚度值", $"厚度2:{order.Height2}");

  1852.                     break;

  1853.                 case 3:

  1854.                     order.Height3 = lstHeight[count - 1];

  1855.                     AddTextEvent("厚度值", $"厚度3:{order.Height3}");

  1856.                     break;

  1857.                 case 4:

  1858.                     order.Height4 = lstHeight[count - 1];

  1859.                     AddTextEvent("厚度值", $"厚度4:{order.Height4}");

  1860.                     break;

  1861.                 case 5:

  1862.                     order.Height5 = lstHeight[count - 1];

  1863.                     AddTextEvent("厚度值", $"厚度5:{order.Height5}");

  1864.                     break;

  1865.             }

  1866. 

  1867.             double value = Math.Round(lstHeight.Average(), 2);

  1868.             double valueMax = lstHeight.Max();

  1869.             double valueMin = lstHeight.Min();

  1870.             if (order != null) order.HeightValue = value;

  1871.             Color color = (upperLimit + lowerLimit > 0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;

  1872.             Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;

  1873.             Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

  1874.             this.Invoke(new System.Action(() =>

  1875.             {

  1876.                 this.lblHeight.Text = Math.Round(value, 2).ToString();

  1877.                 this.lblHeight.ForeColor = color;

  1878. 

  1879.                 this.lblHeightMax.Text = Math.Round(valueMax, 2).ToString();

  1880.                 this.lblHeightMax.ForeColor = colorMax;

  1881. 

  1882.                 this.lblHeightMin.Text = Math.Round(valueMin, 2).ToString();

  1883.                 this.lblHeightMin.ForeColor = colorMin;

  1884.             }));

  1885.             //不合格

  1886.             if (color == Color.Red) order.Qualified = false;

  1887.         }

  1888.         private void updateLineWidthValue(double upperLimit, double lowerLimit)

  1889.         {

  1890.             int count = lstLineWidth.Count();

  1891.             if (count < 1) return; 

  1892.             switch (count)

  1893.             {

  1894.                 case 1:

  1895.                     order.LineWidth1 = lstLineWidth[count - 1];

  1896.                     AddTextEvent("线宽值", $"线宽1:{order.LineWidth1}");

  1897.                     break;

  1898.                 case 2:

  1899.                     order.LineWidth2 = lstLineWidth[count - 1];

  1900.                     AddTextEvent("线宽值", $"线宽2:{order.LineWidth2}");

  1901.                     break;

  1902.                 case 3:

  1903.                     order.LineWidth3 = lstLineWidth[count - 1];

  1904.                     AddTextEvent("线宽值", $"线宽3:{order.LineWidth3}");

  1905.                     break;

  1906.                 case 4:

  1907.                     order.LineWidth4 = lstLineWidth[count - 1];

  1908.                     AddTextEvent("线宽值", $"线宽4:{order.LineWidth4}");

  1909.                     break;

  1910.                 case 5:

  1911.                     order.LineWidth5 = lstLineWidth[count - 1];

  1912.                     AddTextEvent("线宽值", $"线宽5:{order.LineWidth5}");

  1913.                     break;

  1914.                 case 6:

  1915.                     order.LineWidth6 = lstLineWidth[count - 1];

  1916.                     AddTextEvent("线宽值", $"线宽6:{order.LineWidth6}");

  1917.                     break;

  1918.                 case 7:

  1919.                     order.LineWidth7 = lstLineWidth[count - 1];

  1920.                     AddTextEvent("线宽值", $"线宽7:{order.LineWidth7}");

  1921.                     break;

  1922.                 case 8:

  1923.                     order.LineWidth8 = lstLineWidth[count - 1];

  1924.                     AddTextEvent("线宽值", $"线宽8:{order.LineWidth8}");

  1925.                     break;

  1926.                 case 9:

  1927.                     order.LineWidth9 = lstLineWidth[count - 1];

  1928.                     AddTextEvent("线宽值", $"线宽9:{order.LineWidth9}");

  1929.                     break;

  1930.             }

  1931.             List<double> lstValidValue = new List<double>(); 

  1932.             for (int i = 0; i < count; i++)

  1933.             {

  1934.                 if (lstLineWidth[i] > 0) 

  1935.                     lstValidValue.Add(lstLineWidth[i]); 

  1936.             }

  1937.             if (lstValidValue.Count < 1) return;//WLQ 前面失败时会向lstLineWidth.add(0)

  1938. 

  1939.             double value = Math.Round(lstValidValue.Average(), 2); 

  1940.             double valueMax = lstValidValue.Max();

  1941.             double valueMin = lstValidValue.Min();

  1942.             if (order != null) order.LineWidthValue = value;

  1943.             Color color = (upperLimit + lowerLimit > 0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;

  1944.             Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;

  1945.             Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

  1946.             this.Invoke(new System.Action(() =>

  1947.             {

  1948.                 this.lblLineWidth.Text = Math.Round(value, 2).ToString();

  1949.                 this.lblLineWidth.ForeColor = color;

  1950. 

  1951.                 this.lblLineWidthMax.Text = Math.Round(valueMax, 2).ToString();

  1952.                 this.lblLineWidthMax.ForeColor = colorMax;

  1953. 

  1954.                 this.lblLineWidthMin.Text = Math.Round(valueMin, 2).ToString();

  1955.                 this.lblLineWidthMin.ForeColor = colorMin;

  1956.             }));

  1957.             //不合格

  1958.             if (color == Color.Red) order.Qualified = false;

  1959.         }

  1960.         private void updatePTValue(double upperLimit, double lowerLimit)

  1961.         {

  1962.             //每次加2个：PT1,PT2 

  1963.             int count = lstPT.Count();

  1964.             if (count < 1) return; 

  1965.             switch (count)

  1966.             {

  1967.                 case 2:

  1968.                     order.PT1 = lstPT[count - 2];

  1969.                     order.PT2 = lstPT[count - 1];

  1970.                     AddTextEvent("PT值",$"PT1:{order.PT1},PT2:{order.PT2}");

  1971.                     break;

  1972.                 case 4:

  1973.                     order.PT3 = lstPT[count - 2];

  1974.                     order.PT4 = lstPT[count - 1];

  1975.                     AddTextEvent("PT值", $"PT3:{order.PT3},PT4:{order.PT4}");

  1976.                     break;

  1977.                 case 6:

  1978.                     order.PT5 = lstPT[count - 2];

  1979.                     order.PT6 = lstPT[count - 1];

  1980.                     AddTextEvent("PT值", $"PT5:{order.PT5},PT6:{order.PT6}");

  1981.                     break; 

  1982.             }

  1983. 

  1984.             List<double> lstValidValue = new List<double>();

  1985.             for (int i = 0; i < count; i++)

  1986.             {

  1987.                 if (lstPT[i] > 0)

  1988.                     lstValidValue.Add(lstPT[i]);

  1989.             }

  1990.             double value = Math.Round(lstValidValue.Average(), 4);

  1991.             double valueMax = lstValidValue.Max();

  1992.             double valueMin = lstValidValue.Min();

  1993.             if (order != null) order.PTValue = value;

  1994.             Color color = (upperLimit + lowerLimit > 0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;

  1995.             Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;

  1996.             Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

  1997.             this.Invoke(new System.Action(() =>

  1998.             {

  1999.                 this.lblPT.Text = value.ToString();

  2000.                 this.lblPT.ForeColor = color;

  2001. 

  2002.                 this.lblPTMax.Text = Math.Round(valueMax, 4).ToString();

  2003.                 this.lblPTMax.ForeColor = colorMax;

  2004. 

  2005.                 this.lblPTMin.Text = Math.Round(valueMin, 4).ToString();

  2006.                 this.lblPTMin.ForeColor = colorMin;

  2007.             }));

  2008.             //不合格

  2009.             if (color == Color.Red) order.Qualified = false;

  2010.         }

  2011.         private void updatePTValueTest(double upperLimit, double lowerLimit)

  2012.         {

  2013.             //每次加2个：PT1,PT2 

  2014.             int count = lstPT.Count();

  2015.             if (count < 1) return;

  2016.             switch (count)

  2017.             {

  2018.                 case 1:

  2019.                     order.PT1 = lstPT[count - 1];

  2020.                     AddTextEvent("PT1", $"PT1:{order.PT1}");

  2021.                     break;

  2022.                 case 2:

  2023.                     order.PT2 = lstPT[count - 1];

  2024.                     AddTextEvent("PT2", $"PT2:{order.PT2}");

  2025.                     break;

  2026.                 case 3:

  2027.                     order.PT3 = lstPT[count - 1];

  2028.                     order.PT4 = 0;

  2029.                     AddTextEvent("PT3", $"PT3:{order.PT3}");

  2030.                     break;

  2031.                 case 4:

  2032.                     order.PT5 = lstPT[count - 1];

  2033.                     AddTextEvent("PT4", $"PT4:{order.PT5}");

  2034.                     break;

  2035.                 case 5:

  2036.                     order.PT6 = lstPT[count - 1];

  2037.                     AddTextEvent("PT5", $"PT5:{order.PT6}");

  2038.                     break;

  2039.             }

  2040. 

  2041.             List<double> lstValidValue = new List<double>();

  2042.             for (int i = 0; i < count; i++)

  2043.             {

  2044.                 if (lstPT[i] > 0)

  2045.                     lstValidValue.Add(lstPT[i]);

  2046.             }

  2047.             double value = Math.Round(lstValidValue.Average(), 4);

  2048.             double valueMax = lstValidValue.Max();

  2049.             double valueMin = lstValidValue.Min();

  2050.             if (order != null) order.PTValue = value;

  2051.             Color color = (upperLimit + lowerLimit > 0 && (value > upperLimit || value < lowerLimit)) ? Color.Red : Color.White;

  2052.             Color colorMax = (upperLimit + lowerLimit > 0 && (valueMax > upperLimit || valueMax < lowerLimit)) ? Color.Red : Color.White;

  2053.             Color colorMin = (upperLimit + lowerLimit > 0 && (valueMin > upperLimit || valueMin < lowerLimit)) ? Color.Red : Color.White;

  2054.             this.Invoke(new System.Action(() =>

  2055.             {

  2056.                 this.lblPT.Text = value.ToString();

  2057.                 this.lblPT.ForeColor = color;

  2058. 

  2059.                 this.lblPTMax.Text = Math.Round(valueMax, 4).ToString();

  2060.                 this.lblPTMax.ForeColor = colorMax;

  2061. 

  2062.                 this.lblPTMin.Text = Math.Round(valueMin, 4).ToString();

  2063.                 this.lblPTMin.ForeColor = colorMin;

  2064.             }));

  2065.             //不合格

  2066.             if (color == Color.Red) order.Qualified = false;

  2067.         }

  2068.         private void updateCompareResult(bool compareResult)

  2069.         {

  2070.             this.Invoke(new System.Action(() =>

  2071.             { 

  2072.                 this.lblCompareResult.Text = (order.CompareResult==1 ? "通过" : "未通过");

  2073.                 if (!compareResult)

  2074.                 {

  2075.                     this.lblCompareResultCount.Text = (Convert.ToInt16(lblCompareResultCount.Text) + 1).ToString();

  2076.                     this.lblCompareResult.ForeColor = lblCompareResultCount.ForeColor=Color.Red;

  2077.                     //不合格

  2078.                     order.Qualified = false;

  2079.                 }

  2080.             }));

  2081.         }

  2082.         private void resetUIValue()

  2083.         {

  2084.             this.Invoke(new System.Action(() =>

  2085.             {

  2086.                 //保持产品名称和料号

  2087.                 //txtProductName.Text = txtProductCode.Text = txtProductSN.Text = "";

  2088.                 txtProductSN.Text = "";

  2089. 

  2090.                 lstHeight.Clear();

  2091.                 lstLineWidth.Clear();

  2092.                 lstTension.Clear();

  2093.                 lstPT.Clear();

  2094.                 this.lblTension.Text = this.lblHeight.Text = this.lblLineWidth.Text = "0.00";

  2095.                 this.lblPT.Text = this.lblPTMax.Text= this.lblPTMin.Text="0.0000";

  2096.                 this.lblCompareResult.Text =this.lblDefectResult.Text = "无";

  2097. 

  2098.                 this.lblTensionMax.Text = this.lblHeightMax.Text = this.lblLineWidthMax.Text

  2099.                     = this.lblTensionMin.Text = this.lblHeightMin.Text = this.lblLineWidthMin.Text = "0.00";

  2100. 

  2101.                 this.lblCompareResultCount.Text = "0";

  2102.                 this.lblDefectResultCount.Text = "无"; 

  2103.                 this.toolTip1.SetToolTip(lblDefectResultCount, lblDefectResultCount.Text);

  2104.                 //

  2105.                 this.lblTension.ForeColor = this.lblHeight.ForeColor = this.lblLineWidth.ForeColor = this.lblPT.ForeColor = this.lblCompareResult.ForeColor= this.lblDefectResult.ForeColor=Color.White; 

  2106.                 this.lblTensionMax.ForeColor = this.lblHeightMax.ForeColor = this.lblLineWidthMax.ForeColor = this.lblPTMax.ForeColor 

  2107.                     = this.lblTensionMin.ForeColor = this.lblHeightMin.ForeColor = this.lblLineWidthMin.ForeColor = this.lblPTMin.ForeColor = Color.White;

  2108.                 this.lblCompareResultCount.ForeColor = this.lblDefectResultCount.ForeColor=Color.White;

  2109. 

  2110.                 this.dgvProcess.DataSource = null;

  2111.                 this.lstLog.Items.Clear();

  2112.                 this.clearDefectBmps();

  2113. 

  2114.                 this.picScanner1.Image = this.picScanner2.Image = null;

  2115.                 picScanner1.Refresh();

  2116.                 picScanner2.Refresh();

  2117. 

  2118.                 this.btnMakeTags.Enabled = false;

  2119.             }));

  2120.         }

  2121.         //info:  [{"1":[["92.7542","80.85799","99.54083","86.05363","dk","0.52"]]},

  2122.         private void showDefectSmallBmps(Bitmap[] bmps, Mat[] bmps_cut, double Xmm, double Ymm, List<Dictionary<int, List<string>[]>> info)

  2123.         {

  2124.             this.Invoke(new System.Action(() =>

  2125.             {

  2126.                 int imgWidth = this.pnlBmpList.ClientSize.Width - 50;

  2127.                 int imgHeight = (int)((bmps[0].Height * 1.0f / bmps[0].Width) * imgWidth + 0.5);

  2128.                 int splitWidth = 20;

  2129.                 int pnlWidth = this.pnlBmpList.ClientSize.Width;

  2130.                 int index = (int)this.gboxDefectList.Tag; 

  2131.                 for (int x = 0; x < info.Count(); x++)

  2132.                 {

  2133.                     foreach (var item in info[x]) //单个info[x] = {"1":[["92.7542","80.85799","99.54083","86.05363","dk","0.52"]]}

  2134.                     {

  2135.                         //统计缺陷类型

  2136.                         countDefectClass(item.Value);//[["92.7542","80.85799","99.54083","86.05363","dk","0.52"]]

  2137. 

  2138.                         //

  2139.                         PictureBox picbox = new PictureBox();

  2140.                         picbox.Width =   imgWidth;

  2141.                         picbox.Height =  imgHeight;

  2142.                         CheckBox checkBox = new CheckBox();

  2143.                         picbox.Image = (Bitmap)bmps[x].Clone();

  2144.                         picbox.Name = "imgDefect_" + index;

  2145.                         picbox.Tag = item.Key + "," + Xmm + "," + Ymm;

  2146. 

  2147.                         checkBox.Tag = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(bmps_cut[item.Key]); //Mat转Bitmap ;//原始小图

  2148.                         checkBox.Name = "chkDefect_" + index;

  2149.                         checkBox.Text = $"第{index + 1}张";

  2150.                         checkBox.CheckedChanged += new System.EventHandler(this.CheckBox_CheckedChanged);

  2151.                         if (Config.MakeTag)//自动打标

  2152.                         {

  2153.                             checkBox.Checked = true;

  2154.                             checkBox.Enabled = false;

  2155.                         }

  2156.                         picbox.Click += new EventHandler(defectBmpBox_Click); 

  2157.                         picbox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;

  2158.                         picbox.BorderStyle = BorderStyle.FixedSingle;

  2159.                         picbox.Margin = new Padding((pnlWidth - picbox.Width) / 2, splitWidth,0, 0);

  2160.                         checkBox.Margin = new Padding((pnlWidth - checkBox.Width) / 2 + splitWidth,

  2161.                             0, 0, 0);

  2162.                          

  2163.                         //

  2164.                         //if (this.pnlBmpList.Controls.Count > 0)

  2165.                         //{

  2166.                         //    if ((this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Right + imgWidth + splitWidth) > this.pnlBmpList.Width)

  2167.                         //        picbox.Location = new System.Drawing.Point(splitWidth, this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Bottom + splitWidth);

  2168.                         //    else

  2169.                         //        picbox.Location = new System.Drawing.Point(this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Right + splitWidth, this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Location.Y);

  2170.                         //}

  2171.                         //else

  2172.                         //{

  2173.                         //    picbox.Location = new System.Drawing.Point(splitWidth, 0);

  2174.                         //}

  2175.                         //checkBox.Location = new System.Drawing.Point(picbox.Location.X + 5, picbox.Location.Y + 5);

  2176.                         //checkBox.ForeColor = Color.Black; 

  2177.                         this.pnlBmpList.Controls.Add(picbox);

  2178.                         this.pnlBmpList.Controls.Add(checkBox);

  2179.                         break;

  2180.                     }

  2181.                      

  2182.                     //

  2183.                     index++;

  2184.                 };

  2185.                 this.gboxDefectList.Tag = index;

  2186.                 this.gboxDefectList.Text = $"缺陷图像:{index} 张";

  2187.                 if (Config.MakeTag) {

  2188.                     lblDefectAddTag.Text = $"待打标数:{index}";

  2189.                     lblDefectAddTag.Tag = index;

  2190.                 }

  2191.                 pnlBmpList.VerticalScroll.Value = pnlBmpList.VerticalScroll.Maximum;

  2192.             }));

  2193.         }

  2194.         //统计缺陷类型  [["92.7542","80.85799","99.54083","86.05363","dk","0.52"]]

  2195.         private void countDefectClass(List<string>[] list)

  2196.         {

  2197.             string className;

  2198.             for(int i=0; i<list.Length; i++)

  2199.             {

  2200.                 className = list[i][4];

  2201.                 switch (className)

  2202.                 {

  2203.                     case "dk":

  2204.                         order.DKCount++;

  2205.                         break;

  2206.                     case "zw":

  2207.                         order.ZWCount++;

  2208.                         break;

  2209.                     case "gsyc":

  2210.                         order.GSYCCount++;

  2211.                         break;

  2212.                     case "xws":

  2213.                         order.XWSCount++;

  2214.                         break;

  2215.                     case "qk":

  2216.                         order.QKCount++;

  2217.                         break;

  2218.                     case "zk":

  2219.                         order.ZKCount++;

  2220.                         break;

  2221.                     case "pp":

  2222.                         order.PPCount++;

  2223.                         break;

  2224.                     case "hs":

  2225.                         order.HSCount++;

  2226.                         break;

  2227.                     case "yx":

  2228.                         order.YXCount++;

  2229.                         break;

  2230.                     case "xb":

  2231.                         order.XBCount++;

  2232.                         break;

  2233.                     case "sx":

  2234.                         order.SXCount++;

  2235.                         break;

  2236.                 }

  2237.             }

  2238.         }

  2239.         private int getDefectCountFromCode(Order order, DefectCodeEnum defectCodeEnum)

  2240.         {

  2241.             switch (defectCodeEnum)

  2242.             {

  2243.                 case DefectCodeEnum.dk:

  2244.                     return order.DKCount;

  2245.                 case DefectCodeEnum.zw:

  2246.                     return order.ZWCount;

  2247.                 case DefectCodeEnum.gsyc:

  2248.                     return order.GSYCCount;

  2249.                 case DefectCodeEnum.xws:

  2250.                     return order.XWSCount;

  2251.                 case DefectCodeEnum.qk:

  2252.                     return order.QKCount;

  2253.                 case DefectCodeEnum.zk:

  2254.                     return order.ZKCount;

  2255.                 case DefectCodeEnum.pp:

  2256.                     return order.PPCount;

  2257.                 case DefectCodeEnum.hs:

  2258.                     return order.HSCount;

  2259.                 case DefectCodeEnum.yx:

  2260.                     return order.YXCount; 

  2261.                 case DefectCodeEnum.xb:

  2262.                     return order.XBCount;

  2263.                 case DefectCodeEnum.gsdl:

  2264.                     return order.SXCount;

  2265.                 default:

  2266.                     return 0;

  2267.             }

  2268.         }

  2269.         private void CheckBox_CheckedChanged(object sender, EventArgs e)

  2270.         {

  2271.             CheckBox ck = (CheckBox)sender;

  2272.             int cout = Convert.ToInt32(this.lblDefectAddTag.Tag);

  2273.             if (ck.Checked)

  2274.                 cout++;

  2275.             else

  2276.                 cout--;

  2277. 

  2278.             lblDefectAddTag.Text = $"待打标数:{cout}";

  2279.             lblDefectAddTag.Tag = cout;

  2280.         }

  2281. 

  2282.         private void defectBmpBox_Click(object sender, EventArgs e)

  2283.         {

  2284.             // if(autoMakeTagRuning) //自动打标中不可打开人工达标窗 

  2285.             PictureBox picbox = sender as PictureBox; 

  2286.             if (!devContainer.state || defectBmpNum != defectBmpNumResult || autoMakeTagRuning || currentState != CurrentStateEnum.自动流程结束)//检测中

  2287.             {

  2288.                 //只查看

  2289.                 FrmPhoto frm = new FrmPhoto(this.pnlBmpList.Controls, Convert.ToInt32(picbox.Name.Split(new char[] { '_' })[1]));

  2290.                 frm.ShowDialog(this);

  2291.             }

  2292.             else//完成

  2293.             {

  2294.                 FrmPhotoTag frm = new FrmPhotoTag(this.pnlBmpList.Controls, Convert.ToInt32(picbox.Name.Split(new char[] { '_' })[1])

  2295.                     ,(defectBmpNum == defectBmpNumResult ? this.devContainer : null));

  2296.                 frm.ShowDialog(this);

  2297. 

  2298.                 //

  2299.                 if (devContainer.state && !Config.SkipScannerCC)

  2300.                 {

  2301.                     devContainer.devScannerCC.setMode(false);

  2302.                     devContainer.devScannerCC.setPreviewWin(this.picScanner1.Handle);

  2303.                 }

  2304.             }

  2305.             

  2306.         }

  2307.         private void clearDefectBmps()

  2308.         {

  2309.             this.pnlBmpList.Controls.Clear();

  2310.             this.gboxDefectList.Text = $"缺陷图像";

  2311.             this.gboxDefectList.Tag = 0;

  2312. 

  2313.             this.lblDefectAddTag.Text = "";

  2314.             this.lblDefectAddTag.Tag = 0;

  2315.         } 

  2316.         public delegate void AddTextDelegate(string tag, string msg, WarningEnum level);

  2317.         /// <summary>

  2318.         /// 异步输出日志

  2319.         /// </summary>

  2320.         /// <param name="tag">模板标识</param>

  2321.         /// <param name="msg">内容</param>

  2322.         /// <param name="type"></param>

  2323.         private void AddTextEvent(string tag, string msg, WarningEnum level = WarningEnum.Normal)

  2324.         {

  2325.             try

  2326.             {

  2327.                 if (InvokeRequired)

  2328.                 {

  2329.                     Invoke(new AddTextDelegate(AddTextEvent), new object[]

  2330.                     {

  2331.                         tag,

  2332.                         msg,

  2333.                         level

  2334.                     });

  2335.                 }

  2336.                 else

  2337.                 {

  2338.                     if (tag != null && tag != "")

  2339.                         tag = $" - [{tag}]";

  2340. 

  2341.                     var now = DateTime.Now;

  2342.                     msg = now.ToString("HH:mm:ss fff") + tag + " - " + msg;

  2343.                     //cont = MyHelper.subString(cont, 300);

  2344. 

  2345.                     //写日志，warn和error日志直接写

  2346.                     writeLog(now, level, msg);

  2347. 

  2348.                     //

  2349.                     //if (type > 0)

  2350.                     //    cont = $"<color=\"{(type == 1 ? "Yellow" : "Red")}\">{cont}</color>";

  2351. 

  2352.                     msg = (level == WarningEnum.Normal ? "B" : level == WarningEnum.Low ? "Y" : "R") + msg;

  2353.                     this.Invoke(new System.Action(() =>

  2354.                     {

  2355.                         if (this.lstLog.Items.Count > 1000)

  2356.                             this.lstLog.Items.Clear();

  2357.                         lstLog.Items.Insert(0, msg);

  2358.                     }));

  2359.                     //日志滚动 

  2360.                     //lstLog.SelectedIndex = lstLog.Items.Count - 1; 

  2361.                 }

  2362.             }

  2363.             catch (Exception ex)

  2364.             {

  2365.                 //MessageBox.Show("AddTextEvent ex=(" + ex.Message + ")", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);

  2366.             }

  2367.         }

  2368.         private void lstLog_DrawItem(object sender, DrawItemEventArgs e)

  2369.         {

  2370.             e.DrawBackground();

  2371.             if (e.Index < 0) return;

  2372. 

  2373.             try

  2374.             {

  2375.                 string str = lstLog.Items[e.Index].ToString();

  2376.                 e.Graphics.DrawString(str.Substring(1), e.Font,

  2377.                     new SolidBrush(str[0] == 'R' ? Color.Red : (str[0] == 'Y' ? Color.Orange : Color.Black)),

  2378.                     e.Bounds);

  2379.             }

  2380.             catch 

  2381.             {

  2382.                 ;

  2383.             }

  2384.         }

  2385.         private void writeLog(DateTime now, WarningEnum level, string text)

  2386.         {

  2387.             string directory = Config.LogPath + "\\" + DateTime.Now.ToString("yyyyMM") + "\\";

  2388.             //if (type == 0) directory = Application.StartupPath + "\\Log\\Info\\";

  2389.             //else if (type == 1) directory = Application.StartupPath + "\\Log\\Warn\\";

  2390.             //else directory = Application.StartupPath + "\\Log\\Error\\";

  2391. 

  2392.             if (!System.IO.Directory.Exists(directory))

  2393.                 System.IO.Directory.CreateDirectory(directory);

  2394. 

  2395.             File.AppendAllText(directory + now.ToString("yyyyMMdd") + ".log", text + "\r\n");

  2396.         }

  2397. 

  2398.         private void FrmMian_FormClosing(object sender, FormClosingEventArgs e)

  2399.         {

  2400.             if (devContainer.state)

  2401.             {

  2402.                 MessageBox.Show("请先停止生产后才能关闭程序！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  2403.                 e.Cancel = true;

  2404.                 return;

  2405.             }

  2406. 

  2407.             if (!bExitApp && MessageBox.Show($"确认退出？", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes)

  2408.             {

  2409.                 e.Cancel = true;

  2410.                 return;

  2411.             }

  2412.         }

  2413.         private void FrmMian_FormClosed(object sender, FormClosedEventArgs e)

  2414.         {

  2415.             webService.stop();

  2416.             Application.Exit();

  2417.             System.GC.Collect();

  2418.             System.Environment.Exit(0);

  2419.         }

  2420.         private void tsbtnOpenDev_Click(object sender, EventArgs e)

  2421.         {

  2422.             //FrmGetPosByPic frr = new FrmGetPosByPic(new SizeLibProp());

  2423.             //frr.ShowDialog();

  2424. 

  2425.             Config.LoadAllConfig();

  2426.             //设置程序最小/大线程池

  2427.             // Get the current settings. 

  2428.             int minWorker, minIOC;

  2429.             ThreadPool.GetMinThreads(out minWorker, out minIOC);

  2430.             ThreadPool.SetMinThreads(25, minIOC);

  2431.             //ThreadPool.SetMaxThreads(256, 256);

  2432. 

  2433.             this.tsbtnProductRevise.Enabled = false;

  2434.             this.tsbtnOpenDev.Enabled = false; 

  2435.             //scannerCBmpIndex = 0;

  2436. 

  2437.             isProductRevise = false;

  2438.             this.resetUIValue();  

  2439.             currProcessIndex = -1;

  2440.             currentState = CurrentStateEnum.等待复位;

  2441.             warningLevel = WarningEnum.Normal;

  2442.             currentPT = CurrentPTEnum.InitPT;

  2443.             this.tsbtnWarning.Enabled=this.tsbtnGoDownPT.Enabled=this.tsbtnStart.Enabled=this.tsbtnStopNow.Enabled=this.tsbtnPause.Enabled=this.tsbtnReset.Enabled=false;

  2444.             //后台线程回调事件

  2445.             devContainer.StateChange = (state, msg) =>

  2446.             { 

  2447.                 if (state)

  2448.                 {

  2449.                     //全局中断

  2450.                     devContainer.devIOCard.INEvent = globalBreakEvent;

  2451.                     devContainer.OutDebugEvent = (tag, debugInfo) =>

  2452.                     {

  2453.                         AddTextEvent(tag, debugInfo);

  2454.                     };

  2455.                     //

  2456.                     AddTextEvent("设备启动", "请先进行复位操作！");

  2457.                     this.Invoke(new System.Action(() =>

  2458.                     {

  2459.                         this.tsbtnReset.Enabled = true;

  2460.                         tsbtnWarning.Enabled = this.tsbtnStart.Enabled = this.tsbtnGoDownPT.Enabled

  2461.                             = this.tsbtnPause.Enabled = this.tsbtnStopNow.Enabled = false;

  2462. 

  2463.                         this.tsbtnOpenDev.Enabled = true;

  2464.                         this.tsbtnOpenDev.Visible = false;

  2465.                         this.tsbtnCloseDev.Visible = true;

  2466.                     }));

  2467. 

  2468.                     timer.Elapsed += Timer_Elapsed;

  2469.                     timer.Interval = 500;

  2470.                     timer.Start();

  2471.                 }

  2472.                 else

  2473.                 {

  2474.                     AddTextEvent("设备启动", $"启动失败，{msg}", WarningEnum.High);

  2475.                     this.Invoke(new System.Action(() =>

  2476.                     {

  2477.                         this.tsbtnOpenDev.Enabled = true;

  2478.                         this.tsbtnOpenDev.Visible = true;

  2479.                         this.tsbtnCloseDev.Visible = false;

  2480.                     }));

  2481.                 }

  2482. 

  2483.             };

  2484.             devContainer.WarningEvent = (level, msg) =>

  2485.             {

  2486.                 AddTextEvent("设备事件", msg, level);

  2487.                 if (level == WarningEnum.High)

  2488.                     warning(level,true);

  2489.             }; 

  2490.             devContainer.start(this.picScanner1.Handle, this.picScanner2.Handle);

  2491.         }

  2492. 

  2493.         private void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)

  2494.         {

  2495.             this.Invoke(new System.Action(() =>

  2496.             {

  2497.                 this.tsAxisState.Text = $"[命令位:{devContainer.devAxis.CmdPos[0]} 反馈位:{devContainer.devAxis.ActualPos[0]}] | " +

  2498.                     $"[命令位:{devContainer.devAxis.CmdPos[1]} 反馈位:{devContainer.devAxis.ActualPos[1]}] | " +

  2499.                     $"[命令位:{devContainer.devAxis.CmdPos[2]} 反馈位:{devContainer.devAxis.ActualPos[2]}] | " +

  2500.                     $"[命令位:{devContainer.devAxis.CmdPos[3]} 反馈位:{devContainer.devAxis.ActualPos[3]}]";

  2501.             }));

  2502.         }

  2503. 

  2504.         private void tsbtnCloseDev_Click(object sender, EventArgs e)

  2505.         {

  2506.             AddTextEvent("设备停止", $"设备停止..."); 

  2507.             this.tsbtnProductRevise.Enabled = false;

  2508.             this.tsbtnOpenDev.Visible = true;

  2509.             this.tsbtnCloseDev.Visible = false;

  2510.             this.btnMakeTags.Enabled = false;

  2511.             this.lblTimeLen.Visible = false;

  2512. 

  2513.             this.tsbtnReset.Enabled = tsbtnWarning.Enabled = this.tsbtnStart.Enabled = this.tsbtnGoDownPT.Enabled

  2514.                 = this.tsbtnPause.Enabled = this.tsbtnStopNow.Enabled = false;

  2515. 

  2516.             this.tsbtnSizeTag.Enabled = tsbtnSizeImage.Enabled = tsbtnDefectImage.Enabled = false;

  2517.             if (devContainer.state)

  2518.             {

  2519.                 devContainer.devIOCard.reset();

  2520.                 devContainer.io_output(CMDName.IO默认输出);

  2521.             }

  2522.             timer.Stop();

  2523.             devContainer.stop();

  2524.         }

  2525.         /// <summary>

  2526.         /// 全局中断

  2527.         /// </summary>

  2528.         private void globalBreakEvent(int portIndex, byte data)

  2529.         {

  2530.             if (compareIOInput(CMDName.启动按钮) && this.tsbtnStart.Enabled)

  2531.                 startCommand();

  2532.             else if (compareIOInput(CMDName.暂停按钮) && this.tsbtnPause.Enabled)

  2533.                 warning(WarningEnum.Low, false);

  2534.             else if (compareIOInput(CMDName.复位按钮) && this.tsbtnReset.Enabled) 

  2535.                 resetCommand(); 

  2536.             else if (compareIOInput(CMDName.张力读取) && currentPT == CurrentPTEnum.Moving)

  2537.                 readTension();

  2538.             else if (!this.disableBuzzer && compareIOInput(CMDName.门磁告警输入))

  2539.                 warning(WarningEnum.Low, true);

  2540.             else if (!this.disableBuzzer && compareIOInput(CMDName.喷墨告警输入))

  2541.                 warning(WarningEnum.Low, true);

  2542.         }

  2543.         private bool compareIOInput(CMDName key)

  2544.         {

  2545.             JObject joJson = Config.CMDProcess[key];

  2546.             IODirectionEnum direction = (IODirectionEnum)joJson.Value<int>("Direction");

  2547.             if (direction == IODirectionEnum.输入 || direction == IODirectionEnum.输入输出)

  2548.             { 

  2549.                 return Util.compareIOInput(

  2550.                     joJson.Value<JArray>("IN_OP_SHOW").ToObject<List<string>>().ToArray(), 

  2551.                     devContainer.devIOCard.DIData); 

  2552.             }

  2553.             return false;

  2554.         }

  2555.         private void readTension()

  2556.         {

  2557.             if (Config.SkipTension)

  2558.             {

  2559.                 AddTextEvent("张力读取", $"张力设备禁用，忽略此步骤!");

  2560.                 return;

  2561.             }

  2562.             devContainer.io_output(CMDName.张力读取);

  2563.             double tensionValue = devContainer.devTension.getValue() + Config.Tension_Offset;//加入张力偏差

  2564.             tensionValue=Math.Round(tensionValue, 2);//保留2位小数

  2565.             AddTextEvent("张力读取", $"张力值:{tensionValue}"); 

  2566.             devContainer.io_output(CMDName.张力读取,false,true,500); 

  2567.             lstTension.Add(tensionValue); 

  2568.             updateTensionValue(currProductModel.TensionBaseValue + currProductModel.TensionUpFloatValue, currProductModel.TensionBaseValue - currProductModel.TensionDownFloatValue); 

  2569.         }

  2570.         /// <summary>

  2571.         /// 启动

  2572.         /// </summary>

  2573.         private void startCommand()

  2574.         {

  2575.             this.setButtonEnabled(this.tsbtnProductRevise, false);

  2576.             //2023-10-23 运行前清除过期图片文件

  2577.             Config.DelectPictureFile();

  2578.             if (!devContainer.state || warningLevel != WarningEnum.Normal || currentState != CurrentStateEnum.等待启动)

  2579.                 return;

  2580.             if (currentPT == CurrentPTEnum.MakeTag)

  2581.             {

  2582.                 AddTextEvent("启动", "打标未结束，非可启动状态！", warningLevel);

  2583.                 return;

  2584.             }

  2585. 

  2586.             if (!devContainer.devAxis.isReady())

  2587.             {

  2588.                 AddTextEvent("启动", "轴状态异常，不可启动！", warningLevel);

  2589.                 return;

  2590.             }

  2591.             if (!devContainer.devAxis.IsReset)

  2592.             {

  2593.                 AddTextEvent("启动", "轴需先进行复位操作！", WarningEnum.High);

  2594.                 return;

  2595.             }

  2596. 

  2597.             devContainer.io_output(CMDName.启动按钮);

  2598.             devContainer.io_output(CMDName.绿灯输出);

  2599.             devContainer.io_output(CMDName.暂停按钮, false, true, 0);

  2600.             devContainer.io_output(CMDName.红灯输出, false, true, 0);

  2601.             devContainer.io_output(CMDName.黄灯输出, false, true, 0);

  2602. 

  2603.             //暂停-》继续

  2604.             if (currProcessIndex >= 0 && currentPT == CurrentPTEnum.Moving && currentState == CurrentStateEnum.等待启动)

  2605.             {

  2606.                 AddTextEvent("启动", $"暂停 -> 继续 当前工序索引：{currProcessIndex + 1}");

  2607.                 threadProcess = new System.Threading.Thread(() =>

  2608.                 {

  2609.                     int nextStepId = currProcessIndex;

  2610.                     do

  2611.                     {

  2612.                         currentState = CurrentStateEnum.运行中;

  2613.                         nextStepId = nextProcess(currProductModel, nextStepId);

  2614.                     } while (nextStepId >= 0 && !isBreakProcessRun());

  2615.                     //nextProcess(currProductModel, currProcessIndex);

  2616.                 });

  2617.                 threadProcess.IsBackground = true;

  2618.                 threadProcess.Start();

  2619.                 this.setButtonEnabled(this.tsbtnPause, true);

  2620.                 this.setButtonEnabled(this.tsbtnStopNow, true);

  2621.             }

  2622.             else//开始/重新开始

  2623.             {

  2624.                 //校正从复位-》运行，不会新启动

  2625.                 isProductRevise = false;

  2626.                 resetUIValue();

  2627.                 AddTextEvent("启动", "移动至上料位...");

  2628.                 gotoUpPT();

  2629. 

  2630.                 this.Invoke(new System.Action(() =>

  2631.                 {

  2632.                     //新开始

  2633.                     lblTimeLen.Visible = false;

  2634.                     runStep();

  2635.                 }));

  2636.                 this.setButtonEnabled(this.tsbtnPause, false);

  2637.                 this.setButtonEnabled(this.tsbtnStopNow, false);

  2638.             }

  2639. 

  2640.             this.setButtonEnabled(this.tsbtnStart, false);

  2641.             this.setButtonEnabled(this.tsbtnReset, false);

  2642.             this.setButtonEnabled(this.tsbtnGoDownPT, false);

  2643.         }

  2644.         /// <summary>

  2645.         /// 暂停

  2646.         /// </summary>

  2647.         /// <param name="buzzer">是否响蜂鸣</param>

  2648.         private void pauseCommand(bool buzzer = false)

  2649.         { 

  2650.             devContainer.io_output(CMDName.暂停按钮);

  2651.             if (buzzer)

  2652.             {

  2653.                 devContainer.io_output(CMDName.红灯输出);

  2654.                 devContainer.io_output(CMDName.蜂鸣器输出);

  2655.             }

  2656.             else 

  2657.                 devContainer.io_output(CMDName.黄灯输出);

  2658.             devContainer.io_output(CMDName.启动按钮, false, true, 0);

  2659.             devContainer.io_output(CMDName.绿灯输出, false, true, 0);

  2660. 

  2661.             this.setButtonEnabled(this.tsbtnWarning, true);

  2662.             this.setButtonEnabled(this.tsbtnGoDownPT, false);

  2663.             this.setButtonEnabled(this.tsbtnStart, false);

  2664.             this.setButtonEnabled(this.tsbtnPause, false);

  2665.             this.setButtonEnabled(this.tsbtnStopNow, false);

  2666.             this.setButtonEnabled(this.tsbtnReset, false); 

  2667.             AddTextEvent("暂停", $"当前工序索引：{currProcessIndex + 1}", WarningEnum.Low); 

  2668.         }

  2669.         /// <summary>

  2670.         /// 急停

  2671.         /// </summary> 

  2672.         private void stopNowCommand()

  2673.         {

  2674.             if (!devContainer.state)

  2675.             {

  2676.                 this.setButtonEnabled(this.tsbtnStopNow, false);

  2677.                 return;

  2678.             }

  2679. 

  2680.             devContainer.io_output(CMDName.Y轴复位输出, false, true, 0);

  2681.             devContainer.io_output(CMDName.红灯输出);

  2682.             if (!this.disableBuzzer) devContainer.io_output(CMDName.蜂鸣器输出);

  2683.             devContainer.io_output(CMDName.暂停按钮, false, true, 0);

  2684.             devContainer.io_output(CMDName.黄灯输出, false, true, 0);

  2685.             devContainer.io_output(CMDName.启动按钮, false, true, 0);

  2686.             devContainer.io_output(CMDName.绿灯输出, false, true, 0);

  2687. 

  2688.             this.setButtonEnabled(this.tsbtnWarning, true);

  2689.             this.setButtonEnabled(this.tsbtnGoDownPT, false);

  2690.             this.setButtonEnabled(this.tsbtnStart, false);

  2691.             this.setButtonEnabled(this.tsbtnPause, false);

  2692.             this.setButtonEnabled(this.tsbtnStopNow, false);

  2693.             this.setButtonEnabled(this.tsbtnReset, false);

  2694.             AddTextEvent("急停", $"当前工序索引：{currProcessIndex + 1}", WarningEnum.High);

  2695.         }

  2696.         private bool reseting = false;

  2697.         private void resetCommand()

  2698.         {

  2699.             currentState = CurrentStateEnum.等待复位;

  2700.             warningLevel = WarningEnum.Normal;

  2701.             currentPT = CurrentPTEnum.InitPT;

  2702.             this.Invoke(new System.Action(() =>

  2703.             {

  2704.                 lblTimeLen.Visible = false;

  2705.                 this.tsbtnWarning.Enabled = this.tsbtnGoDownPT.Enabled = this.tsbtnStart.Enabled = this.tsbtnStopNow.Enabled = this.tsbtnPause.Enabled = this.tsbtnReset.Enabled = false;

  2706.             }));

  2707. 

  2708.             try

  2709.             { 

  2710.                 if (devContainer.state && !reseting)

  2711.                 { 

  2712.                     reseting = true;

  2713.                     isProductRevise = false;

  2714.                     resetUIValue();

  2715.                     AddTextEvent("复位", $"设备复位中...");

  2716.                     currProcessIndex = -1;

  2717. 

  2718.                     this.setButtonEnabled(this.tsbtnReset, false);

  2719. 

  2720.                     // I/O reset后，输出默认状态 

  2721.                     AddTextEvent("复位", $"I/O复位中...");

  2722.                     if (!devContainer.devIOCard.reset())

  2723.                     {

  2724.                         AddTextEvent("复位", "I/O板卡复位失败！", WarningEnum.High);

  2725.                         return;

  2726.                     }

  2727.                     if (!devContainer.io_output(CMDName.IO默认输出))

  2728.                     {

  2729.                         //AddTextEvent("复位", "I/O板卡复位默认值失败！", WarningEnum.High);

  2730.                         //return;

  2731.                     }

  2732. 

  2733.                     //板卡复位输出灯 

  2734.                     devContainer.io_output(CMDName.复位按钮);

  2735.                     devContainer.io_output(CMDName.黄灯输出, true);

  2736. 

  2737.                     //4.5X

  2738.                     if(!Config.SkipSmallAxis)

  2739.                         devContainer.devSmallAxis.gotoPos((int)SmallAxCmdPos.倍率4_5X, false);

  2740. 

  2741.                     //移动Axis前等待厚度传感器收回

  2742.                     AddTextEvent("复位", $"检测厚度传感器安全值...");

  2743.                     if (!Config.SkipHeight)

  2744.                     {

  2745.                         while (devContainer.devHeight.getHeight() < (double)Math.Abs(Config.HeightDev_SafeValue))

  2746.                         {

  2747.                             if (!devContainer.state || currentState != CurrentStateEnum.等待复位)

  2748.                                 return;

  2749.                             Thread.Sleep(100);

  2750.                             Application.DoEvents();

  2751.                         }

  2752.                     }

  2753. 

  2754.                     //goto ORG

  2755.                     AddTextEvent("复位", $"轴正在回原点...");

  2756.                     devContainer.devAxis.closeJogMode();

  2757.                     devContainer.devAxis.resetAxisState(-1);//reset state 

  2758.                     //AddTextEvent("复位", $"重置轴状态...");

  2759.                     for (int i = 0; i < Config.Axis_HomeMode.Length; i++)

  2760.                     {

  2761.                         //到起始位速度使用回HOME速度

  2762.                         devContainer.devAxis.setAxisVelParam((double)Config.Axis_HomeVelLow[i], (double)Config.Axis_HomeVelHigh[i],

  2763.                                  (double)Config.Axis_HomeAcc[i], (double)Config.Axis_HomeDec[i], i);

  2764.                         if (i != 2)

  2765.                         { 

  2766.                             //devContainer.devAxis.setAxisVelParam(40000,200000,5000000, 5000000,i,true);

  2767.                             devContainer.devAxis.home(i, (uint)Config.Axis_HomeMode[i], (uint)Config.Axis_HomeDir[i]);

  2768.                         }

  2769.                         else//Y轴 I/O控制回HOME

  2770.                         {

  2771.                             devContainer.io_output(CMDName.Y轴复位输出);

  2772.                         }

  2773.                     }

  2774.                     AddTextEvent("复位", $"等待轴状态完成...");

  2775.                     while (!devContainer.devAxis.isReady())

  2776.                     {

  2777.                         if (!devContainer.state || currentState != CurrentStateEnum.等待复位)

  2778.                         {

  2779.                             AddTextEvent("复位", $"当前状态："+ ((CurrentStateEnum)currentState).ToString());

  2780.                             return;

  2781.                         }

  2782.                         //AddTextEvent("复位", $"轴0状态:"+ ((AxisState)devContainer.devAxis.AxState[0]).ToString());

  2783.                         //AddTextEvent("复位", $"轴1状态:" + ((AxisState)devContainer.devAxis.AxState[1]).ToString());

  2784.                         //AddTextEvent("复位", $"轴2状态:" + ((AxisState)devContainer.devAxis.AxState[2]).ToString());

  2785.                         //AddTextEvent("复位", $"轴3状态:" + ((AxisState)devContainer.devAxis.AxState[3]).ToString());

  2786. 

  2787.                         Thread.Sleep(1000);

  2788.                         Application.DoEvents();

  2789.                     }

  2790.                     //判断Y轴回原点完成I/O信号

  2791.                     AddTextEvent("复位", $"等待Y轴回HOME完成...");

  2792.                     while (!this.compareIOInput(CMDName.Y轴复位完成输入))

  2793.                     {

  2794.                         Thread.Sleep(100);

  2795.                         Application.DoEvents();

  2796.                     } 

  2797.                     AddTextEvent("复位", $"Y轴回HOME已完成.");

  2798.                     devContainer.io_output(CMDName.Y轴复位输出, false, true, 0);

  2799.                     AddTextEvent("复位", $"重置Y轴反馈位置与命令位置.");

  2800.                     devContainer.devAxis.resetCmdPosition(2);

  2801.                     devContainer.devAxis.resetActualPosition(2);

  2802. 

  2803.                     //

  2804.                     if (devContainer.devAxis.isError())

  2805.                         throw new Exception("轴回原点失败！");

  2806. 

  2807.                     if (Config.OpenAxisXCalibration)

  2808.                     {

  2809.                         //2023-11-29 加入X1X2回原之后启动补偿

  2810.                         devContainer.io_output(CMDName.X1轴复位输出, false, true, 300);

  2811.                         devContainer.io_output(CMDName.X2轴复位输出, false, true, 300);

  2812.                     }

  2813. 

  2814.                     // 

  2815.                     //goto InitPT  

  2816.                     //AddTextEvent("复位", $"轴回原点完成，回到初始位...");

  2817.                     JArray arrPT = Config.joPTSetting.Value<JArray>("initPT");

  2818.                     for (int i = 0; i < arrPT.Count; i++)

  2819.                     {

  2820.                         if (!devContainer.state || currentState != CurrentStateEnum.等待复位)

  2821.                             return;

  2822. 

  2823.                         AddTextEvent($"复位", $"轴{i}准备运动至初始位:{(double)arrPT[i]}(当前轴状态:{((AxisState)devContainer.devAxis.AxState[i]).ToString()})...");

  2824.                         devContainer.devAxis.move_ptp(i, (double)arrPT[i], AxMoveMode.绝对位置);

  2825.                     } 

  2826.                     while (!devContainer.devAxis.isReady())

  2827.                     {

  2828.                         if (!devContainer.state || warningLevel != WarningEnum.Normal)

  2829.                             return;

  2830.                         Thread.Sleep(100);

  2831.                     }

  2832.                     if (devContainer.devAxis.isError())

  2833.                         throw new Exception("轴移动至初始位失败！");

  2834.                      

  2835.                     //

  2836.                     this.setButtonEnabled(this.tsbtnReset, true);

  2837.                     this.setButtonEnabled(this.tsbtnStart, true);

  2838.                     this.setButtonEnabled(this.tsbtnStopNow, true);

  2839.                     this.setButtonEnabled(this.tsbtnPause, false);

  2840.                     this.setButtonEnabled(this.tsbtnGoDownPT, false);

  2841.                     this.setButtonEnabled(this.tsbtnWarning, false);

  2842.                      

  2843.                     devContainer.io_output(CMDName.复位按钮, false, true, 0);//熄灭

  2844.                     devContainer.io_output(CMDName.黄灯输出);//长亮

  2845.                     currentPT = CurrentPTEnum.InitPT;

  2846.                     currentState = CurrentStateEnum.等待启动;

  2847.                     AddTextEvent("复位", $"复位完成。");

  2848.                     this.setButtonEnabled(this.tsbtnProductRevise, true);

  2849.                 }

  2850.                 else

  2851.                 {

  2852.                     AddTextEvent("复位", "非可复位状态，请先停止后再复位！", WarningEnum.High);

  2853.                 }

  2854.             }

  2855.             catch (Exception ex)

  2856.             {

  2857.                 AddTextEvent("复位", "复位失败 Err:" + ex.Message, WarningEnum.High);

  2858.                 warning(WarningEnum.High, true);

  2859.             }

  2860.             finally

  2861.             {

  2862.                 reseting = false;

  2863.             }

  2864.         }

  2865.         /// <summary>

  2866.         /// 上料

  2867.         /// </summary>

  2868.         private void gotoUpPT()

  2869.         {

  2870.             try

  2871.             {

  2872.                 JArray arrPT = Config.joPTSetting.Value<JArray>("upPT");

  2873.                 for (int i = 0; i < arrPT.Count; i++)

  2874.                 {

  2875.                     if (!devContainer.state || warningLevel != WarningEnum.Normal)

  2876.                         return;

  2877. 

  2878.                     AddTextEvent($"上料", $"轴{i}准备运动至上料位:{(double)arrPT[i]}(当前轴状态:{((AxisState)devContainer.devAxis.AxState[i]).ToString()})...");

  2879.                     devContainer.devAxis.move_ptp(i, (double)arrPT[i], AxMoveMode.绝对位置);

  2880.                 } 

  2881.                 while (!devContainer.devAxis.isReady())

  2882.                 {

  2883.                     if (!devContainer.state || warningLevel != WarningEnum.Normal)

  2884.                         return;

  2885.                     Thread.Sleep(100);

  2886.                 }

  2887.                 if (devContainer.devAxis.isError())

  2888.                     throw new Exception("轴移动至上料位失败！");

  2889. 

  2890.                 //

  2891.                 currentPT = CurrentPTEnum.UpPT;

  2892.                 currentState = CurrentStateEnum.等待扫码;

  2893.                 AddTextEvent($"上料", "到达上料位！");

  2894.             }

  2895.             catch (Exception ex)

  2896.             {

  2897.                 AddTextEvent("上料", "上料初始失败 Err:" + ex.Message, WarningEnum.High);

  2898.                 warning(WarningEnum.High);

  2899.             }

  2900.         } 

  2901.         /// <summary>

  2902.         /// 下料

  2903.         /// </summary>

  2904.         private void gotoDownPT()

  2905.         {

  2906.             try

  2907.             {

  2908.                 if (currentState != CurrentStateEnum.打标中 && currentState != CurrentStateEnum.等待启动 && currentState != CurrentStateEnum.自动流程结束)

  2909.                 {

  2910.                     AddTextEvent($"下料", $"非可下料状态:{currentState.ToString()}");

  2911.                     return;

  2912.                 }

  2913. 

  2914.                 currentState = CurrentStateEnum.下料中;

  2915.                 isProductRevise = false;

  2916. 

  2917.                 JArray arrPT = Config.joPTSetting.Value<JArray>("downPT");

  2918.                 for (int i = 0; i < arrPT.Count; i++)

  2919.                 {

  2920.                     if (!devContainer.state || warningLevel != WarningEnum.Normal || currentState != CurrentStateEnum.下料中)

  2921.                         return;

  2922. 

  2923.                     AddTextEvent($"下料", $"轴{i}准备运动至下料位:{(double)arrPT[i]}(当前轴状态:{((AxisState)devContainer.devAxis.AxState[i]).ToString()})...");

  2924.                     devContainer.devAxis.move_ptp(i, (double)arrPT[i], AxMoveMode.绝对位置);

  2925.                 }

  2926. 

  2927.                 while (!devContainer.devAxis.isReady())

  2928.                 {

  2929.                     if (!devContainer.state || warningLevel != WarningEnum.Normal || currentState != CurrentStateEnum.下料中)

  2930.                         return;

  2931.                     Thread.Sleep(100);

  2932.                 }

  2933.                 if (devContainer.devAxis.isError())

  2934.                     throw new Exception("轴移动至下料位失败！");

  2935. 

  2936.                 //

  2937.                 currentPT = CurrentPTEnum.DownPT;

  2938.                 currentState = CurrentStateEnum.等待启动;

  2939.                 devContainer.io_output(CMDName.下料完成输出);

  2940.                 setButtonEnabled(tsbtnStart, true);

  2941.                 AddTextEvent($"下料", "下料完成！");

  2942.             }

  2943.             catch (Exception ex)

  2944.             {

  2945.                 AddTextEvent("下料", "下料失败 Err:" + ex.Message, WarningEnum.High);

  2946.                 warning(WarningEnum.High);

  2947.             }

  2948.         }

  2949.         private void setButtonEnabled(ToolStripButton button, bool Enabled)

  2950.         {

  2951.             this.Invoke(new System.Action(() =>

  2952.             {

  2953.                 button.Enabled = Enabled;

  2954.             }));

  2955.         }

  2956.         private void setButtonEnabled(ToolStripMenuItem button, bool Enabled)

  2957.         {

  2958.             this.Invoke(new System.Action(() =>

  2959.             {

  2960.                 button.Enabled = Enabled;

  2961.             }));

  2962.         }

  2963.         private void setButtonEnabled(Control button, bool Enabled)

  2964.         {

  2965.             this.Invoke(new System.Action(() =>

  2966.             {

  2967.                 button.Enabled = Enabled;

  2968.             }));

  2969.         }

  2970. 

  2971.         private void FrmMian_Shown(object sender, EventArgs e)

  2972.         {

  2973.         }

  2974. 

  2975.         private void FrmMian_Resize(object sender, EventArgs e)

  2976.         {

  2977. 

  2978.         }

  2979. 

  2980.         private void 流程管理ToolStripMenuItem_Click(object sender, EventArgs e)

  2981.         {

  2982.             if (devContainer.state)

  2983.             {

  2984.                 MessageBox.Show("请先停止生产，再进行流程修改！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  2985.                 return;

  2986.             }

  2987. 

  2988.             FrmStepList frm = new FrmStepList();

  2989.             frm.ShowDialog();

  2990.         }

  2991. 

  2992.         private void 产品管理ToolStripMenuItem_Click(object sender, EventArgs e)

  2993.         {

  2994.             if (devContainer.state)

  2995.             {

  2996.                 MessageBox.Show("请先停止生产，再进行产品修改！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  2997.                 return;

  2998.             }

  2999. 

  3000.             FrmProductList frm = new FrmProductList();

  3001.             frm.ShowDialog();

  3002.             loadProductCodeList();

  3003.         }

  3004.         private void tsbtnProductRevise_Click(object sender, EventArgs e)

  3005.         {

  3006.             if (!devContainer.state)

  3007.             { 

  3008.                 MessageBox.Show("请先启动设备！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);

  3009.                 return;

  3010.             } 

  3011.             if (currentPT != CurrentPTEnum.InitPT || currentState != CurrentStateEnum.等待启动)

  3012.             {

  3013.                 MessageBox.Show("请先复位设备！", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);

  3014.                 return;

  3015.             }

  3016.              

  3017.             FrmProductList frm = new FrmProductList(true);

  3018.             if (frm.ShowDialog() == DialogResult.Yes && frm.Product != null)//执行校正

  3019.             {

  3020.                 AddTextEvent("校正", "开始执行产品base厚度校正...");

  3021. 

  3022.                 isProductRevise = true;

  3023.                 currProductModel = frm.Product;

  3024.                 currProductModel.HeightBaseDec = "";

  3025.                 this.txtProductCode.Text = currProductModel.Code;

  3026.                 this.txtProductName.Text = currProductModel.Name;

  3027.                 this.txtProductSN.Text = "";

  3028.                 this.dgvProcess.DataSource = new BindingSource(currProductModel.ReviseStepInfo.ProcessList, null);

  3029.                 devContainer.libFor.clear();

  3030.                 devContainer.libIF.clear();

  3031. 

  3032.                 //    

  3033.                 this.setButtonEnabled(this.tsbtnStart, false); 

  3034.                 this.setButtonEnabled(this.tsbtnPause, true);

  3035.                 this.setButtonEnabled(this.tsbtnStopNow, true);

  3036.                 threadProcess = new System.Threading.Thread(() =>

  3037.                 {

  3038.                     int nextStepId = 0;

  3039.                     do

  3040.                     {

  3041.                         currentState = CurrentStateEnum.运行中;

  3042.                         nextStepId = nextProcess(currProductModel, nextStepId);

  3043.                     } while (nextStepId >= 0 && !isBreakProcessRun());

  3044.                 });

  3045.                 threadProcess.IsBackground = true;

  3046.                 threadProcess.Start();

  3047.             }

  3048.         }

  3049.         private void 设备调试ToolStripMenuItem_Click(object sender, EventArgs e)

  3050.         {

  3051.             if (devContainer.state)

  3052.             {

  3053.                 MessageBox.Show("请先停止生产，再进行设备调试！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  3054.                 return;

  3055.             }

  3056. 

  3057.             FrmDebug3 frm = new FrmDebug3();

  3058.             frm.ShowDialog();

  3059.         }

  3060. 

  3061.         private void 角色管理ToolStripMenuItem_Click(object sender, EventArgs e)

  3062.         {

  3063.             FrmRoleRight frm = new FrmRoleRight();

  3064.             frm.ShowDialog(this);

  3065.         }

  3066. 

  3067.         private void 用户管理ToolStripMenuItem_Click(object sender, EventArgs e)

  3068.         {

  3069.             FrmUserList frm = new FrmUserList();

  3070.             frm.ShowDialog(this);

  3071.         }

  3072. 

  3073.         private void 退出ToolStripMenuItem_Click(object sender, EventArgs e)

  3074.         {

  3075.             Application.Exit();

  3076.             System.GC.Collect();

  3077.             System.Environment.Exit(0);

  3078.         }

  3079. 

  3080.         private void 注销ToolStripMenuItem_Click(object sender, EventArgs e)

  3081.         {

  3082.             if (devContainer.state)

  3083.             {

  3084.                 MessageBox.Show("请先停止生产再退出！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  3085.                 return;

  3086.             }

  3087. 

  3088.             if (MessageBox.Show($"确认退出？", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)

  3089.             {

  3090.                 this.bExitApp = true;

  3091.                 Process.Start(Application.StartupPath + "\\ProductionControl.exe");

  3092.                 this.Close();

  3093.             }

  3094.         }

  3095. 

  3096.         private void splitContainer1_Panel1_Resize(object sender, EventArgs e)

  3097.         { 

  3098.             int allWidth = this.splitContainer1.Panel1.Width;

  3099.             this.gpbProductInfo.Width = this.flpnlResultData.Width = this.gpbProcessList.Width = this.gpbLog.Width = allWidth;

  3100. 

  3101.             //

  3102.             this.txtProductName.Width = this.txtProductCode.Width = this.gpbProductInfo.Width - this.txtProductName.Left - 8;

  3103.             this.txtProductSN.Width = this.txtBatchId.Width = (this.txtProductName.Width- lblBatchId.Width)/2;

  3104.             this.lblBatchId.Left = this.txtProductSN.Right ;

  3105.             this.txtBatchId.Left = this.lblBatchId.Right;

  3106. 

  3107. 

  3108.             //

  3109.             int spliceWidth = 5;

  3110.             kanban1.Width = kanban2.Width = kanban3.Width = kanban4.Width = kanban5.Width = kanban6.Width = (flpnlResultData.Width-20) / 6;

  3111. 

  3112.             //2023-10-17 更新log和步骤列表显示

  3113.             this.gpbProcessList.Height = this.splitContainer1.Panel1.Height - this.gpbProcessList.Top - this.gpbLog.Height;

  3114.             this.gpbLog.Top = this.splitContainer1.Panel1.Height - this.gpbLog.Height;

  3115.         }

  3116. 

  3117. 

  3118.         private void 关于ToolStripMenuItem_Click(object sender, EventArgs e)

  3119.         {

  3120.             AboutBox1 aboutBox1 = new AboutBox1();

  3121.             aboutBox1.Show();

  3122.         }

  3123. 

  3124. 

  3125.         private void 系统设置ToolStripMenuItem_Click(object sender, EventArgs e)

  3126.         {

  3127.             FrmSysSetting frmSetting = new FrmSysSetting();

  3128.             frmSetting.ShowDialog();

  3129.         }

  3130. 

  3131. 

  3132. 

  3133.         private void dgvProcess_DataBindingComplete(object sender, DataGridViewBindingCompleteEventArgs e)

  3134.         {

  3135.             //string processCode;

  3136.             //for (int i = 0; i < this.dgvProcess.Rows.Count; i++)

  3137.             //{

  3138.             //processCode = dgvProcess.Rows[i].Cells[0].Value.ToString();

  3139.             //dgvProcess.Rows[i].Cells[1].Value = Config.dicDevType[processCode];

  3140.             //}

  3141.         }

  3142. 

  3143.         private void tsbtnWarning_Click(object sender, EventArgs e)

  3144.         {

  3145.             //if (warningLevel == WarningEnum.Normal)

  3146.             //{

  3147.             //    tsbtnWarning.Enabled = false;

  3148.             //    return;

  3149.             //}

  3150. 

  3151.             //重置AXIS状态

  3152.             devContainer.devAxis.resetAxisState();

  3153.             if (!devContainer.devAxis.isReady())

  3154.             {

  3155.                 AddTextEvent("解除报警", "轴状态未恢复，解除报警失败！", warningLevel);

  3156.                 return;

  3157.             }

  3158.             if (devContainer.devAxis.isError())

  3159.             {

  3160.                 AddTextEvent("解除报警", "轴IO状态异常，解除报警失败！", warningLevel);

  3161.                 return;

  3162.             }

  3163.             if (!this.disableDoorSensor && compareIOInput(CMDName.门磁告警输入))

  3164.             {

  3165.                 AddTextEvent("解除报警", "门磁告警未清除 ，解除报警失败！", warningLevel);

  3166.                 return;

  3167.             }

  3168.             if (!this.disableDoorSensor && compareIOInput(CMDName.喷墨告警输入))

  3169.             {

  3170.                 AddTextEvent("解除报警", "喷墨告警输入未清除 ，解除报警失败！", warningLevel);

  3171.                 return;

  3172.             }

  3173.             //关闭蜂鸣器

  3174.             devContainer.io_output(CMDName.蜂鸣器输出, false, true, 0); 

  3175.             devContainer.io_output(CMDName.红灯输出, false, true, 0);

  3176.             devContainer.io_output(CMDName.复位按钮, false, true, 0);

  3177.             if (warningLevel == WarningEnum.High)

  3178.             {

  3179.                 AddTextEvent("解除报警", "急停告警已解除，但必需进行复位操作！", warningLevel);

  3180.                 currentState = CurrentStateEnum.等待复位;

  3181.                 this.tsbtnReset.Enabled = true;

  3182.                 tsbtnWarning.Enabled = this.tsbtnStart.Enabled = this.tsbtnGoDownPT.Enabled

  3183.                     = this.tsbtnPause.Enabled = this.tsbtnStopNow.Enabled = this.btnMakeTags.Enabled= false;

  3184.             }

  3185.             else

  3186.             { 

  3187.                 devContainer.io_output(CMDName.黄灯输出);

  3188.                 AddTextEvent("解除报警", "告警已解除，请继续选择下一步操作！", warningLevel);

  3189.                 if (currentPT == CurrentPTEnum.MakeTag)

  3190.                     currentState = CurrentStateEnum.打标中;

  3191.                 else

  3192.                     currentState = CurrentStateEnum.等待启动;

  3193. 

  3194.                 tsbtnWarning.Enabled = false;

  3195.                 this.tsbtnStart.Enabled = this.tsbtnGoDownPT.Enabled = true;

  3196.                 this.tsbtnReset.Enabled = this.tsbtnPause.Enabled = this.tsbtnStopNow.Enabled = true;

  3197.             }

  3198.             warningLevel = WarningEnum.Normal; 

  3199.         }

  3200.         private void tsbtnGoDownPT_Click(object sender, EventArgs e)

  3201.         {

  3202.             if (!devContainer.state || warningLevel!= WarningEnum.Normal)

  3203.                 return; 

  3204.             if (!devContainer.devAxis.isReady())

  3205.             {

  3206.                 AddTextEvent("下料失败", "轴状态异常！", WarningEnum.Low);

  3207.                 return;

  3208.             }

  3209. 

  3210.             gotoDownPT();

  3211.         }

  3212.         //急停

  3213.         private void tsbtnStopNow_Click(object sender, EventArgs e)

  3214.         { 

  3215.             this.warning(WarningEnum.High);

  3216.         }

  3217.         private Thread threadProcess;

  3218. 

  3219.         private void tsbtnStart_Click(object sender, EventArgs e)

  3220.         {

  3221.             this.startCommand();

  3222.         }

  3223. 

  3224.         private void tsbtnPause_Click(object sender, EventArgs e)

  3225.         {

  3226.             warning(WarningEnum.Low,false); 

  3227.         }

  3228.         //复位

  3229.         private void tsbtnReset_Click(object sender, EventArgs e)

  3230.         { 

  3231.             this.resetCommand();

  3232.         }

  3233. 

  3234.         private void tsbtnGButSetting_Click(object sender, EventArgs e)

  3235.         {

  3236.             if (devContainer.state)

  3237.             {

  3238.                 MessageBox.Show("请先停止生产，再进行设置！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  3239.                 return;

  3240.             }

  3241. 

  3242.             FrmCMDProcess from = new FrmCMDProcess();

  3243.             from.ShowDialog();

  3244.         }

  3245. 

  3246.         private void tsbtnPTSetting_Click(object sender, EventArgs e)

  3247.         {

  3248.             if (devContainer.state)

  3249.             {

  3250.                 MessageBox.Show("请先停止生产，再进行设置！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  3251.                 return;

  3252.             }

  3253. 

  3254.             FrmPTSetting from = new FrmPTSetting();

  3255.             from.ShowDialog();

  3256.         }

  3257. 

  3258.         private void tsMenuModifyPW_Click(object sender, EventArgs e)

  3259.         {

  3260.             FrmModifyPW frm = new FrmModifyPW();

  3261.             frm.ShowDialog();

  3262.         }

  3263. 

  3264.         //分拆面板平均分配

  3265.         private void splitContainer1_ClientSizeChanged(object sender, EventArgs e)

  3266.         {

  3267.             if (this.WindowState == FormWindowState.Minimized)

  3268.                 return;

  3269. 

  3270.             SplitContainer sc = (SplitContainer)sender;

  3271.             sc.SplitterDistance = sc.Width / 7*3;

  3272.         }

  3273.         private void splitContainer3_ClientSizeChanged(object sender, EventArgs e)

  3274.         {

  3275.             if (this.WindowState == FormWindowState.Minimized)

  3276.                 return;

  3277. 

  3278.             SplitContainer sc = (SplitContainer)sender;

  3279.             sc.SplitterDistance = sc.Height / 2;

  3280.         }

  3281.         private void Menu查询统计_Click(object sender, EventArgs e)

  3282.         { 

  3283.             FrmWeb frm = new FrmWeb("查询统计", $"reportRecordSN?CustomerVer={Config.CustomerVer}");

  3284.             frm.Show();

  3285.         }

  3286. 

  3287.         private void tsMenuOrder_Click(object sender, EventArgs e)

  3288.         {

  3289.             //FrmOrderList frm = new FrmOrderList();

  3290.             string subject = (sender as ToolStripMenuItem).Text;

  3291.             FrmWeb frm = new FrmWeb(subject, $"reportRecordSN?CustomerVer={Config.CustomerVer}");

  3292.             frm.Show();

  3293.         }

  3294.         private void tsMenuOrderProduct_Click(object sender, EventArgs e)

  3295.         {

  3296.             string subject = (sender as ToolStripMenuItem).Text;

  3297.             FrmWeb frm = new FrmWeb(subject, $"reportRecordProduct?CustomerVer={Config.CustomerVer}");

  3298.             frm.Show();

  3299.         }

  3300.         private void tsMenuStatistics_Click(object sender, EventArgs e)

  3301.         {

  3302.             string subject = (sender as ToolStripMenuItem).Text;

  3303.             FrmWeb frm = new FrmWeb(subject, $"bigscreen/index.html", "http://127.0.0.1:18082/static/");

  3304.             frm.Show();

  3305.         }

  3306.         private void toolStripButton1_Click(object sender, EventArgs e)

  3307.         {

  3308.             //Bitmap[] bmps = new Bitmap[2];

  3309.             //bmps[0] = new Bitmap(@"f:\1.bmp");

  3310.             //bmps[1] = new Bitmap(@"f:\111.bmp");

  3311.             //List<Dictionary<int, List<string>[]>> list = new List<Dictionary<int, List<string>[]>>();

  3312.             //Dictionary<int, List<string>[]> dir = new Dictionary<int, List<string>[]>();

  3313.             //List<string>[] vs = new List<string>[1];

  3314.             //vs[0] = new List<string>();

  3315.             //dir.Add(0, vs);

  3316.             //list.Add(dir);

  3317.             //showDefectSmallBmps(bmps, list);

  3318.             var bmp = Bitmap.FromFile("f:\\1.jpg");

  3319.             int pnlWidth = this.pnlBmpList.ClientSize.Width;

  3320.             for (int i = 0; i < 5; i++)

  3321.             {

  3322.                 int x = i;

  3323.                 this.Invoke(new System.Action(() =>

  3324.                 {

  3325.                     int imgWidth = 224;

  3326.                     int imgHeight = 200;

  3327.                     int splitWidth = 10;

  3328.                     int index = Convert.ToInt32(this.gboxDefectList.Tag); 

  3329. 

  3330.                     PictureBox picbox = new PictureBox();

  3331.                     picbox.Width = imgWidth;

  3332.                     picbox.Height = imgHeight;

  3333.                     CheckBox checkBox = new CheckBox();

  3334.                     picbox.Image = bmp;

  3335.                     picbox.Name = "imgDefect_" + index;

  3336.                     picbox.Tag ="1,2,3";

  3337.                     checkBox.Name = "chkDefect_" + index;

  3338.                     checkBox.Text = $"第{index + 1}张";

  3339.                     checkBox.CheckedChanged += new System.EventHandler(this.CheckBox_CheckedChanged);

  3340. 

  3341.                     picbox.Click += new EventHandler(defectBmpBox_Click); 

  3342.                     picbox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom;

  3343.                     picbox.BorderStyle = BorderStyle.FixedSingle;

  3344.                     picbox.Margin = new Padding((pnlWidth - picbox.Width) / 2, splitWidth, 0, 0);

  3345.                     checkBox.Margin = new Padding((pnlWidth - checkBox.Width) / 2+ splitWidth, 0, 0, 0);

  3346.                     //

  3347.                     //if (this.pnlBmpList.Controls.Count > 0)

  3348.                     //    {

  3349.                     //        if ((this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Right + imgWidth + splitWidth) > this.pnlBmpList.Width)

  3350.                     //            picbox.Location = new System.Drawing.Point(splitWidth, this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Bottom + splitWidth);

  3351.                     //        else

  3352.                     //            picbox.Location = new System.Drawing.Point(this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Right + splitWidth, this.pnlBmpList.Controls[this.pnlBmpList.Controls.Count - 1].Location.Y);

  3353.                     //    }

  3354.                     //    else

  3355.                     //    {

  3356.                     //        picbox.Location = new System.Drawing.Point(splitWidth, 0);

  3357.                     //    }

  3358.                     //    checkBox.Location = new System.Drawing.Point(picbox.Location.X + 5, picbox.Location.Y + 5);

  3359.                     //    checkBox.ForeColor = Color.Black; 

  3360.                     //}

  3361.                     this.pnlBmpList.Controls.Add(picbox);

  3362.                     this.pnlBmpList.Controls.Add(checkBox);

  3363. 

  3364.                     //

  3365.                     index++; 

  3366.                     this.gboxDefectList.Tag = index;

  3367.                     this.gboxDefectList.Text = $"缺陷图像:{index} 张";

  3368.                     pnlBmpList.VerticalScroll.Value = pnlBmpList.VerticalScroll.Maximum;

  3369.                 }));

  3370.             }

  3371.         }

  3372.  

  3373. 

  3374.         private void chkBuzzer_CheckedChanged(object sender, EventArgs e)

  3375.         {

  3376.             this.disableBuzzer = chkBuzzer.Checked;

  3377.             if (devContainer.state && this.disableBuzzer)

  3378.                 devContainer.io_output(CMDName.蜂鸣器输出, false, true, 0);

  3379.         }

  3380. 

  3381.         private void chkDoorSensor_CheckedChanged(object sender, EventArgs e)

  3382.         {

  3383.             this.disableDoorSensor = chkDoorSensor.Checked;

  3384.         }

  3385. 

  3386.         private void tsbtnLight_Click(object sender, EventArgs e)

  3387.         {

  3388.             if (devContainer.state)

  3389.             {

  3390.                 if(tsbtnLight.Text.Trim()== "开灯")

  3391.                 {

  3392.                     if(devContainer.io_output(CMDName.日光灯输出))

  3393.                         tsbtnLight.Text = "  关灯  ";

  3394.                 }

  3395.                 else

  3396.                 {

  3397.                     if (devContainer.io_output(CMDName.日光灯输出, false, true, 0)) 

  3398.                         tsbtnLight.Text = "  开灯  ";

  3399.                 }

  3400.             }

  3401.         }

  3402. 

  3403.         private void btnMakeTag_Click(object sender, EventArgs e)

  3404.         {

  3405.             if(currentPT != CurrentPTEnum.MakeTag)

  3406.             {

  3407.                 AddTextEvent("打标失败", "非可打标状态！");

  3408.                 return;

  3409.             }

  3410.             btnMakeTags.Enabled = false;

  3411.             autoMakeTagRuning = true;

  3412.             Thread threadtest = new System.Threading.Thread(() =>

  3413.             {

  3414.                 try

  3415.                 {

  3416.                     if (!devContainer.state)

  3417.                     {

  3418.                         AddTextEvent("打标", "设备已停机！");

  3419.                         return;

  3420.                     }

  3421.                     if ((int)this.lblDefectAddTag.Tag < 1)

  3422.                     {

  3423.                         AddTextEvent("打标", "打标队列为空！");

  3424.                         return;

  3425.                     }

  3426. 

  3427.                     int tagIndex;

  3428.                     double Xmm, Ymm;

  3429.                     Bitmap currBmp;

  3430.                     string[] tags;

  3431.                     for (int i = 0; i < this.pnlBmpList.Controls.Count; i += 2)

  3432.                     {

  3433.                         CheckBox cb = this.pnlBmpList.Controls[i + 1] as CheckBox;

  3434.                         if (cb.Checked)

  3435.                         {

  3436.                             PictureBox picBox = this.pnlBmpList.Controls[i] as PictureBox;

  3437.                             tags = picBox.Tag.ToString().Split(',');

  3438.                             tagIndex = Convert.ToInt32(tags[0]);

  3439.                             Xmm = Convert.ToDouble(tags[1]);

  3440.                             Ymm = Convert.ToDouble(tags[2]);

  3441.                             currBmp = (Bitmap)picBox.Image;

  3442. 

  3443.                             //打标

  3444.                             AddTextEvent("打标", $"第{i / 2 + 1}/{this.pnlBmpList.Controls.Count / 2}张 [索引:{tagIndex}, X:{Xmm}mm, Y:{Ymm}mm]");

  3445.                             var list = devContainer.libDefect.makeTag(tagIndex, Xmm, Ymm, currBmp.Width, currBmp.Height);

  3446.                             devContainer.devAxis.move_ptp(1, list[0], AxMoveMode.绝对位置);

  3447.                             devContainer.devAxis.move_ptp(2, list[1], AxMoveMode.绝对位置);

  3448.                             while (!devContainer.devAxis.isReady(1) || !devContainer.devAxis.isReady(2))

  3449.                             {

  3450.                                 Application.DoEvents();

  3451.                                 Thread.Sleep(100);

  3452.                                 if (!devContainer.state)

  3453.                                     throw new Exception("设备停止，打标中止！");

  3454.                             }

  3455.                             //

  3456.                             if (!devContainer.io_output(CMDName.喷墨输出, false, true, 500))

  3457.                                 throw new Exception("请确认[喷墨输出]指令设置是否正确！");

  3458. 

  3459.                             this.Invoke(new System.Action(() =>

  3460.                             {

  3461.                                 cb.Checked = false;

  3462.                             })); 

  3463.                         }

  3464.                     }

  3465. 

  3466.                     //自动下料

  3467.                     AddTextEvent("打标完成", $"批量打标完成，进行下料...");

  3468.                     currentState = CurrentStateEnum.自动流程结束;

  3469.                     gotoDownPT();

  3470.                 }

  3471.                 catch (Exception ex)

  3472.                 {

  3473.                     AddTextEvent("打标失败", ex.Message, WarningEnum.High);

  3474.                     warning(WarningEnum.Low, true);

  3475.                 }

  3476.                 finally { autoMakeTagRuning=false; }

  3477.             });

  3478.             threadtest.IsBackground = true;

  3479.             threadtest.Start();

  3480.         }

  3481. 

  3482.         private void btnInputCode_Click(object sender, EventArgs e)

  3483.         {

  3484.             txtProductCode_DoubleClick(null, null);

  3485.         }

  3486.         private void txtProductName_DoubleClick(object sender, EventArgs e)

  3487.         {

  3488.             txtProductCode_DoubleClick(null, null);

  3489.         }

  3490.         private void txtProductCode_DoubleClick(object sender, EventArgs e)

  3491.         {

  3492.             //不需要等待扫码才能选择

  3493.             //if (currentState != CurrentStateEnum.等待扫码) return;

  3494. 

  3495.             FrmInput frm = new FrmInput(productCodeList, "请选择产品料号:");

  3496.             if (frm.ShowDialog() != DialogResult.OK && string.IsNullOrWhiteSpace(frm.inputData))

  3497.                 return;

  3498.             //显示料号

  3499.             //this.txtProductCode.Text = frm.inputData;

  3500.             var model = svcProduct.GetModelNav(frm.inputData);

  3501.             if (model != null && model.StepInfo.ProcessList.Count > 0)

  3502.             {

  3503.                 this.txtProductCode.Text = model.Code;

  3504.                 this.txtProductName.Text = model.Name;

  3505.             }

  3506.             /*//屏蔽扫码枪事件

  3507.             Task.Factory.StartNew(() =>

  3508.             {

  3509.                 devContainer.devCodeScanner.ScanerEvent?.Invoke(frm.inputData);

  3510.             });

  3511.             */

  3512. 

  3513.             //string code = Interaction.InputBox("请输入产品编码", "输入框", "", -1, -1).Trim();

  3514.             //if(code  != "")

  3515.             //{

  3516.             //    Task.Factory.StartNew(() =>

  3517.             //    {

  3518.             //        devContainer.devCodeScanner.ScanerEvent?.Invoke(frm.inputData);

  3519.             //    });

  3520.             //}

  3521.         }

  3522. 

  3523.         private void txtProductSN_DoubleClick(object sender, EventArgs e)

  3524.         {

  3525.             //if (currentState != CurrentStateEnum.等待扫码 || this.txtProductCode.Text.Trim()=="") return;

  3526. 

  3527.             //string sn = Interaction.InputBox("请输入产品SN码", "输入框", "", -1, -1).Trim();

  3528.             //if (sn != "")

  3529.             //{

  3530.             //    this.txtProductSN.Text = sn;

  3531.             //    string code = this.txtProductCode.Text.Trim();

  3532.             //    Task.Factory.StartNew(() =>

  3533.             //    {

  3534.             //        devContainer.devCodeScanner.ScanerEvent?.Invoke(code);

  3535.             //    });

  3536.             //}

  3537.         } 

  3538.         private void 测试ToolStripMenuItem_Click(object sender, EventArgs e)

  3539.         {

  3540.             tsbtnDefectImage.Enabled = tsbtnSizeImage.Enabled=true;

  3541.             return;

  3542.             Form1 frm = new Form1();

  3543.             frm.Show();

  3544.             //tsbtnDefectImage_Click(null, null);

  3545.             return;

  3546.             try

  3547.             {

  3548.                 //string ls = "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,182.257722637742,182.257727282667,0,0";

  3549.                 //List<string> list = new List<string>(ls.Split(','));

  3550.                 //lstPT = list.Select<string, double>(q => Convert.ToDouble(q)).ToList();  

  3551.                 //updatePTValue(1,2);

  3552.                 //lstPT.Add(10);

  3553.                 //lstPT.Add(0);

  3554.                 //updatePTValue(1, 2);

  3555.                 //{

  3556.                 //    lstLineWidth.Add(res.Shanxian > 0 ? res.Shanxian : 0);

  3557.                 //    updateLineWidthValue(model.LineWidthBaseValue + model.LineWidthUpFloatValue, model.LineWidthBaseValue - model.LineWidthDownFloatValue);

  3558.                 //}

  3559.                 //return;

  3560. 

  3561.                 //loadProductCodeList();

  3562.                 //FrmInput frm = new FrmInput(null, "请选择产品编码:");

  3563.                 //if (frm.ShowDialog() != DialogResult.OK)

  3564.                 //    return;

  3565.                 //var model = svcProduct.GetModelNav(frm.inputData);

  3566.                 //if (model == null)

  3567.                 //    throw new Exception("没有此产品！");

  3568.                 //order.ProductId = model.Id;

  3569.                 //order.BatchId = model.BatchId;

  3570.                 //order.StepId = model.StepId==null? 0:(int)model.StepId;

  3571.                 //frm = new FrmInput(null, "请输入SN:");

  3572.                 //if (frm.ShowDialog() != DialogResult.OK)

  3573.                 //    return;

  3574.                 //order.SN = frm.inputData;

  3575. 

  3576.                 //frm = new FrmInput(null, "请输入主机台Mark点数据:", "[0,0,0,0,0,0,0,0]");

  3577.                 //if (frm.ShowDialog() != DialogResult.OK)

  3578.                 //    return;

  3579.                 //order.MarkData= frm.inputData;

  3580.                 //order.Tension1 = order.Tension2 = order.Tension3 = order.Tension4 = order.Tension5 = order.Tension5 + 3;

  3581.                 //order.PT1 = order.PT4 = order.PT5 = order.PT6 = order.PT6 + 1.33;

  3582.                 //order.LineWidth2 = order.LineWidth3 = order.LineWidth5 = order.LineWidth6 = +order.LineWidth6 + 1.22;

  3583. 

  3584.                 //order.HeightValue = order.Height1 = order.Height3 = order.Height4 = 55;

  3585.                 //order.DefectCount = order.DefectCount + 22;

  3586.                 //order.YXCount = order.PPCount = 33;

  3587.                 //order.TimeLen =  1000;

  3588.                 //order.Succeed = true;

  3589.                 //order.ModifyUserCode = order.CreateUserCode = Config.loginUser.Code;

  3590. 

  3591.                 //if (!svcOrder.Insert(order))

  3592.                 //    AddTextEvent("保存失败", $"保存生产记录失败！");

  3593.                 //MessageBox.Show("成功！");

  3594. 

  3595.                 //---------------

  3596.                 this.lstCompareFailZoomImage.Add((Bitmap)Bitmap.FromFile(@"f:\1.bmp"));

  3597.                 this.lstCompareFailZoomImage.Add((Bitmap)Bitmap.FromFile(@"f:\2.bmp"));

  3598.                 this.lstCompareFailZoomImage.Add((Bitmap)Bitmap.FromFile(@"f:\3.bmp"));

  3599.             }

  3600.             catch(Exception ex)

  3601.             {

  3602.                 MessageBox.Show(ex.Message);

  3603.             }

  3604.         }

  3605. 

  3606.         private void toolStripSeparator4_Click(object sender, EventArgs e)

  3607.         {

  3608. 

  3609.         }

  3610. 

  3611.         private void chkHttpLog_CheckedChanged(object sender, EventArgs e)

  3612.         {

  3613.             if (this.chkHttpLog.Checked)

  3614.             {

  3615.                 webService.LogEvent = (warning, msg) =>

  3616.                 {

  3617.                     AddTextEvent("HTTP服务", msg, warning);

  3618.                 };

  3619.             }

  3620.             else

  3621.                 webService.LogEvent = null;

  3622.         }

  3623.         //打开比对失败的图片

  3624.         private void lblCompareResult_Click(object sender, EventArgs e)

  3625.         {

  3626.             if (lstCompareFailZoomImage.Count < 1) return;

  3627.             FrmPhotoShow frm = new FrmPhotoShow(lstCompareFailZoomImage);

  3628.             frm.ShowDialog();

  3629.         }

  3630. 

  3631.         //过程变量查看

  3632.         private void tsbtnSizeTag_Click(object sender, EventArgs e)

  3633.         {

  3634.             if (order == null || order.SizeTagDataList == null || order.SizeTagDataList.Count<1)

  3635.                 return;

  3636. 

  3637.             FrmShowSizeTag frm = new FrmShowSizeTag(order);

  3638.             frm.Show();

  3639.         }

  3640. 

  3641.         //缺陷+比对与图纸查看

  3642.         private void tsbtnDefectImage_Click(object sender, EventArgs e)

  3643.         {

  3644.             //currProductModel = svcProduct.GetModelNav(53);

  3645.             //order = svcOrder.GetModelNav("20230814002"); 

  3646.             AddTextEvent("打开窗口", "1");

  3647.             if (currProductModel ==null || order == null || order.DefectInfoList == null || order.DefectInfoList.Count < 1)

  3648.                 return;

  3649.             AddTextEvent("打开窗口", "2");

  3650.             //图纸

  3651.             try

  3652.             {

  3653.                 string gbxBmpPath = "";

  3654.                 var attachmentFile = currProductModel.AttachmentList.FirstOrDefault(x => x.Type == 0);

  3655.                 if (attachmentFile != null)

  3656.                 {

  3657.                     gbxBmpPath = Application.StartupPath + $"\\Attachment\\product\\{attachmentFile.NameTimestamp}";

  3658.                     if (!File.Exists(gbxBmpPath + ".bmp")) gbxBmpPath = "";

  3659.                 }

  3660.                 AddTextEvent("打开窗口", "3");

  3661.                 if (string.IsNullOrEmpty(gbxBmpPath))

  3662.                 {

  3663.                     MessageBox.Show("图纸文件不存在！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);

  3664.                     return;

  3665.                 }

  3666.                 AddTextEvent("打开窗口", "4");

  3667.                 if (!File.Exists(gbxBmpPath + ".jpg"))//转背景后的图纸文件

  3668.                 {

  3669.                     AddTextEvent("打开窗口", "5");

  3670.                     //换背景JPG

  3671.                     Mat mat = Cv2.ImRead(gbxBmpPath + ".bmp");

  3672.                     Cv2.CvtColor(mat, mat, ColorConversionCodes.RGB2GRAY);//转灰度图

  3673.                     for (int i = 0; i < mat.Height; i++)

  3674.                     {

  3675.                         for (int j = 0; j < mat.Width; j++)

  3676.                         {

  3677.                             if (mat.At<byte>(i, j) == 255)//白色 

  3678.                                 mat.Set<byte>(i, j, 0);

  3679.                             else

  3680.                                 mat.Set<byte>(i, j, 255);

  3681.                         }

  3682.                     }

  3683.                     AddTextEvent("打开窗口", "6");

  3684.                     //灰转彩

  3685.                     //Cv2.CvtColor(mat, mat, ColorConversionCodes.GRAY2RGB);

  3686.                     //for (int i = 0; i < mat.Height; i++)

  3687.                     //{

  3688.                     //    for (int j = 0; j < mat.Width; j++)

  3689.                     //    {

  3690.                     //        if (mat.At<byte>(i, j) == 255)//白色 

  3691.                     //            mat.Set<byte>(i, j, 0); //黄色

  3692.                     //    }

  3693.                     //}  

  3694.                     OpenCvSharp.Extensions.BitmapConverter.ToBitmap(mat).Save(gbxBmpPath + ".jpg", ImageFormat.Jpeg);

  3695.                 }

  3696.                 AddTextEvent("打开窗口", "7");

  3697.                 //

  3698.                 ToolStripButton btn = sender as ToolStripButton;

  3699.                 AddTextEvent("打开窗口", btn.Tag.ToString());

  3700.                 FrmShowDefectImage frm = new FrmShowDefectImage(gbxBmpPath + ".jpg", order, string.IsNullOrEmpty(btn.Tag.ToString()) ? 0 : Convert.ToInt32(btn.Tag.ToString()));

  3701.                 frm.Show();

  3702.                 AddTextEvent("打开窗口", "9");

  3703.             }

  3704.             catch (Exception ex)

  3705.             {

  3706.                 MessageBox.Show(ex.Message, "异常", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);

  3707.             }

  3708.         }

  3709. 

  3710.         private void tsbtnLog_Click(object sender, EventArgs e)

  3711.         {

  3712.             if (string.IsNullOrWhiteSpace(Config.LogPath)) return;

  3713.             string lsPath = (Config.LogPath + "\\" + DateTime.Now.ToString("yyyyMM") + "\\").Replace("\\\\", "\\");

  3714.             if(!Directory.Exists(lsPath))

  3715.                 Directory.CreateDirectory(lsPath);

  3716.             System.Diagnostics.Process.Start("explorer.exe", lsPath);

  3717.         }

  3718.     }

  3719. }