添加 MX-PD-盘古项目文件

将 MX-PD-盘古 - new 目录下的所有文件添加到主仓库
2026-05-18 11:43:09 +08:00
parent 03632a379d
commit e31d3560bb
739 changed files with 99783 additions and 0 deletions
--- a/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationActivity.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationActivity.cs
@@ -0,0 +1,91 @@
+using MainShell.Common;
+using MainShell.DeviceMaintance.Model;
+using MainShell.EventArgsFolder;
+using MainShell.Parameter;
+using MainShell.ParaSetting.Model;
+using MaxwellFramework.Core.Attributes;
+using MW.WorkFlow;
+using MwFramework.ManagerService;
+using Stylet;
+using StyletIoC;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MainShell.Process
+{
+    [Singleton]
+    public class NeedleZCalibrationActivity : ActivityAbstractBase
+    {
+        private readonly NeedleZCalibrationService _needleZCalibrationService;
+
+       
+        public NeedleZCalibrationActivity(NeedleZCalibrationService needleZCalibrationService) : base("NeedleZCalibrationActivity")
+        {
+            _needleZCalibrationService = needleZCalibrationService ?? throw new ArgumentNullException(nameof(needleZCalibrationService));
+        }
+
+        protected override async Task<ActivityResult> OnExecuteAsync(WorkflowContext context, ActivityControl activityControl)
+        {
+            NeedleZCalibrationWorkflowData workflowData = GetWorkflowData(context);
+            IParamList paramList = workflowData.GetParameterList();
+            NeedleCalibrationSetting needleCalibrationSetting = paramList?.GetParameter<NeedleCalibrationSetting>();
+            EquipmentParaSysSetting equipmentParaSysSetting = paramList?.GetParameter<EquipmentParaSysSetting>();
+
+            try
+            {
+                NeedleZCalibrationExecutionContext executionContext = _needleZCalibrationService.CreateExecutionContext(
+                    needleCalibrationSetting,
+                    equipmentParaSysSetting,
+                    workflowData.TouchCount,
+                    workflowData.AutoRaiseZ1);
+                IReadOnlyList<double> results = await _needleZCalibrationService.ExecuteCalibrationAsync(
+                    executionContext,
+                    activityControl,
+                    workflowData.CancellationToken,
+                    result => PublishResult(workflowData, result));
+                WriteResults(context, results);
+                return ActivityResult.Success;
+            }
+            catch (InvalidOperationException ex)
+            {
+                return Fail(context, MessageKey.ProcessStepFailedWithReason, new object[] { Name, ex.Message });
+            }
+        }
+
+        private static void PublishResult(NeedleZCalibrationWorkflowData workflowData, double result)
+        {
+            workflowData.EventAggregator?.PublishOnUIThread(new NeedleZCalibrationResultEventArgs(result));
+        }
+
+        private static void WriteResults(WorkflowContext context, IReadOnlyList<double> results)
+        {
+            if (context == null || results == null || results.Count == 0)
+            {
+                return;
+            }
+
+            context.SetData(WorkflowContextKeys.NeedleZCalibrationResults, results);
+            context.SetData(WorkflowContextKeys.NeedleZCalibrationLastResult, results.Last());
+            context.SetData(WorkflowContextKeys.NeedleZCalibrationAverageResult, results.Average());
+        }
+
+        private static NeedleZCalibrationWorkflowData GetWorkflowData(WorkflowContext context)
+        {
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            NeedleZCalibrationWorkflowData workflowData = null;
+            if (!context.TryGetData(WorkflowContextKeys.NeedleZCalibrationWorkflowData, out workflowData) || workflowData == null)
+            {
+                throw new InvalidOperationException("δ<>ṩ<EFBFBD><E1B9A9>ͷZ<CDB7>Ե<EFBFBD><D4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݡ<EFBFBD>");
+            }
+
+            return workflowData;
+        }
+
+    }
+}
--- a/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationService.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationService.cs
@@ -0,0 +1,213 @@
+using MainShell.Common;
+using MainShell.DeviceMaintance.Model;
+using MainShell.Hardware;
+using MainShell.Motion;
+using MainShell.Parameter;
+using MainShell.ParaSetting.Model;
+using MaxwellFramework.Core.Attributes;
+using MaxwellFramework.Core.Interfaces;
+using MW.WorkFlow;
+using MwFramework.ManagerService;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MainShell.Process
+{
+    [Singleton]
+    public class NeedleZCalibrationService
+    {
+        private const double Precision = 0.001;
+
+        private readonly HardwareManager _hardwareManager;
+        private readonly SafeAxisMotion _safeAxisMotion;
+        private readonly IParamList _paramList;
+        private readonly IDeviceIoMonitorService _deviceIoMonitorService;
+
+        public NeedleZCalibrationService(HardwareManager hardwareManager, SafeAxisMotion safeAxisMotion, IParameterManager parameterManager, IDeviceIoMonitorService deviceIoMonitorService)
+        {
+            _hardwareManager = hardwareManager ?? throw new ArgumentNullException(nameof(hardwareManager));
+            _safeAxisMotion = safeAxisMotion ?? throw new ArgumentNullException(nameof(safeAxisMotion));
+            _paramList = parameterManager as IParamList;
+            _deviceIoMonitorService = deviceIoMonitorService ?? throw new ArgumentNullException(nameof(deviceIoMonitorService));
+        }
+
+        public NeedleZCalibrationExecutionContext GetExecutionContext(int? inputTouchCount, bool? inputAutoRaiseZ1)
+        {
+            NeedleCalibrationSetting needleCalibrationSetting = _paramList?.GetParameter<NeedleCalibrationSetting>();
+            EquipmentParaSysSetting equipmentParaSysSetting = _paramList?.GetParameter<EquipmentParaSysSetting>();
+            return CreateExecutionContext(needleCalibrationSetting, equipmentParaSysSetting, inputTouchCount, inputAutoRaiseZ1);
+        }
+
+        public NeedleZCalibrationExecutionContext CreateExecutionContext(NeedleCalibrationSetting needleCalibrationSetting, EquipmentParaSysSetting equipmentParaSysSetting, int? inputTouchCount, bool? inputAutoRaiseZ1)
+        {
+            ValidateCalibrationSetting(needleCalibrationSetting);
+
+            NeedleZCalibrationItem item = needleCalibrationSetting.NeedleZCalibrationItem;
+            ValidateCalibrationItem(item);
+
+            int touchCount = Math.Max(1, inputTouchCount ?? item.NeedleTouchCount);
+            bool autoRaiseZ1 = inputAutoRaiseZ1 ?? true;
+            double safeHeight = ResolveSafeHeight(equipmentParaSysSetting);
+
+            return new NeedleZCalibrationExecutionContext(needleCalibrationSetting, item, touchCount, autoRaiseZ1, safeHeight);
+        }
+
+        public async Task<double> ExecuteSingleTouchAsync(bool autoRaiseZ1, CancellationToken cancellationToken)
+        {
+            return await ExecuteSingleTouchAsync(autoRaiseZ1, cancellationToken, null);
+        }
+
+        public async Task<double> ExecuteSingleTouchAsync(bool autoRaiseZ1, CancellationToken cancellationToken, Action<double> onResult)
+        {
+            NeedleZCalibrationExecutionContext executionContext = GetExecutionContext(1, autoRaiseZ1);
+            IReadOnlyList<double> results = await ExecuteCalibrationAsync(executionContext, null, cancellationToken, onResult);
+            if (results == null || results.Count == 0)
+            {
+                throw new InvalidOperationException("<22><><EFBFBD>ζԵ<CEB6>δ<EFBFBD><CEB4><EFBFBD>ؽ<EFBFBD><D8BD><EFBFBD><EFBFBD><EFBFBD>");
+            }
+
+            return results[0];
+        }
+
+        public async Task<IReadOnlyList<double>> ExecuteCalibrationAsync(NeedleZCalibrationExecutionContext executionContext, ActivityControl activityControl, CancellationToken cancellationToken, Action<double> onResult)
+        {
+            if (executionContext == null)
+            {
+                throw new ArgumentNullException(nameof(executionContext));
+            }
+
+            List<double> results = new List<double>();
+            for (int i = 0; i < executionContext.TouchCount; i++)
+            {
+                await CheckControlAsync(activityControl, cancellationToken);
+                double result = await ExecuteSingleCalibrationAsync(executionContext, activityControl, cancellationToken);
+                results.Add(result);
+                onResult?.Invoke(result);
+            }
+
+            if (executionContext.AutoRaiseZ1)
+            {
+                await CheckControlAsync(activityControl, cancellationToken);
+                _safeAxisMotion.MoveAbs(_hardwareManager.Axis_Z1, executionContext.Item.Z1StartPosition, cancellationToken);
+            }
+
+            return results;
+        }
+
+        private async Task<double> ExecuteSingleCalibrationAsync(NeedleZCalibrationExecutionContext executionContext, ActivityControl activityControl, CancellationToken cancellationToken)
+        {
+            bool foundSignal = false;
+            double start = executionContext.Item.Z1StartPosition;
+            double end = start - executionContext.Item.Z1DropMaxPosition;
+
+            await CheckControlAsync(activityControl, cancellationToken);
+            _safeAxisMotion.MoveAbs(_hardwareManager.Axis_Z1, start, cancellationToken);
+
+            while (Math.Abs(end - start) > Precision)
+            {
+                await CheckControlAsync(activityControl, cancellationToken);
+                double mid = (start + end) / 2.0;
+                if (mid < executionContext.SafeHeight)
+                {
+                    throw new InvalidOperationException(string.Format("Ŀ<><C4BF>λ<EFBFBD><CEBB>[{0}]<5D><><EFBFBD><EFBFBD>Z1<5A>Ե<EFBFBD><D4B5><EFBFBD>ȫ<EFBFBD>߶<EFBFBD>[{1}]<5D><><EFBFBD>˶<EFBFBD><CBB6><EFBFBD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB>", mid, executionContext.SafeHeight));
+                }
+
+                _safeAxisMotion.MoveAbs(_hardwareManager.Axis_Z1, mid, cancellationToken);
+                if (IsToolSetterTriggered())
+                {
+                    end = mid;
+                    foundSignal = true;
+                }
+                else
+                {
+                    start = mid;
+                }
+            }
+
+            if (!foundSignal)
+            {
+                throw new InvalidOperationException("<22>ڷ<EFBFBD>Χ<EFBFBD><CEA7>δ<EFBFBD>ҵ<EFBFBD><D2B5>Ե<EFBFBD><D4B5>źţ<C5BA><C5A3>Ե<EFBFBD>ʧ<EFBFBD>ܡ<EFBFBD>\r\n<><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ե<EFBFBD><D4B5><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>в<EFBFBD><D0B2>ź<EFBFBD>״̬<D7B4><CCAC>");
+            }
+
+            return _hardwareManager.Axis_Z1.State != null ? _hardwareManager.Axis_Z1.State.ActualPos : _hardwareManager.Axis_Z1.GetPositionImmediate();
+        }
+
+        private static async Task CheckControlAsync(ActivityControl activityControl, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (activityControl == null)
+            {
+                return;
+            }
+
+            activityControl.CancellationToken.ThrowIfCancellationRequested();
+            await activityControl.CheckPauseAsync();
+            cancellationToken.ThrowIfCancellationRequested();
+            activityControl.CancellationToken.ThrowIfCancellationRequested();
+        }
+
+        private bool IsToolSetterTriggered()
+        {
+            return _deviceIoMonitorService.IsPointOn(DeviceIoNames.Stage.ToolSetterSignal);
+        }
+        private static void ValidateCalibrationSetting(NeedleCalibrationSetting needleCalibrationSetting)
+        {
+            if (needleCalibrationSetting == null || needleCalibrationSetting.NeedleZCalibrationItem == null)
+            {
+                throw new InvalidOperationException("δ<><CEB4>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>ͷ<EFBFBD>Ե<EFBFBD><D4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
+            }
+        }
+
+        private static void ValidateCalibrationItem(NeedleZCalibrationItem item)
+        {
+            if (item == null)
+            {
+                throw new ArgumentNullException(nameof(item));
+            }
+
+            if (item.Z1Speed <= 0)
+            {
+                throw new InvalidOperationException("Z1<5A>ٶȱ<D9B6><C8B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30>");
+            }
+
+            if (item.Z1DropMaxPosition <= 0)
+            {
+                throw new InvalidOperationException("Z1<5A>½<EFBFBD><C2BD><EFBFBD><EFBFBD><EFBFBD>λ<EFBFBD>ñ<EFBFBD><C3B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<EFBFBD><30>");
+            }
+        }
+
+        private static double ResolveSafeHeight(EquipmentParaSysSetting equipmentParaSysSetting)
+        {
+            if (equipmentParaSysSetting == null || equipmentParaSysSetting.SafeParaSysItem == null)
+            {
+                return 0;
+            }
+
+            return equipmentParaSysSetting.SafeParaSysItem.NeedleCalibSafeHeight;
+        }
+    }
+
+    public class NeedleZCalibrationExecutionContext
+    {
+        public NeedleZCalibrationExecutionContext(NeedleCalibrationSetting needleCalibrationSetting, NeedleZCalibrationItem item, int touchCount, bool autoRaiseZ1, double safeHeight)
+        {
+            NeedleCalibrationSetting = needleCalibrationSetting ?? throw new ArgumentNullException(nameof(needleCalibrationSetting));
+            Item = item ?? throw new ArgumentNullException(nameof(item));
+            TouchCount = touchCount;
+            AutoRaiseZ1 = autoRaiseZ1;
+            SafeHeight = safeHeight;
+        }
+
+        public NeedleCalibrationSetting NeedleCalibrationSetting { get; private set; }
+
+        public NeedleZCalibrationItem Item { get; private set; }
+
+        public int TouchCount { get; private set; }
+
+        public bool AutoRaiseZ1 { get; private set; }
+
+        public double SafeHeight { get; private set; }
+    }
+}
--- a/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationWorkflowData.cs
+++ b/new/PanGu.DieBonderApp/MainShell/Process/Calibration/NeedleZCalibrationWorkflowData.cs
@@ -0,0 +1,56 @@
+using MainShell.DeviceMaintance.Model;
+using MainShell.Hardware;
+using MainShell.Motion;
+using MainShell.Parameter;
+using MaxwellFramework.Core.Interfaces;
+using MwFramework.ManagerService;
+using Stylet;
+using System;
+using System.Threading;
+
+namespace MainShell.Process
+{
+    public class NeedleZCalibrationWorkflowData
+    {
+        public NeedleZCalibrationWorkflowData(string workflowName, int touchCount, bool autoRaiseZ1, CancellationToken cancellationToken, IEventAggregator eventAggregator, HardwareManager hardwareManager, SafeAxisMotion safeAxisMotion, IParameterManager parameterManager, IDeviceIoMonitorService deviceIoMonitorService)
+        {
+            if (string.IsNullOrWhiteSpace(workflowName))
+            {
+                throw new ArgumentException("workflowName");
+            }
+
+            WorkflowName = workflowName;
+            TouchCount = touchCount;
+            AutoRaiseZ1 = autoRaiseZ1;
+            CancellationToken = cancellationToken;
+            EventAggregator = eventAggregator;
+            HardwareManager = hardwareManager ?? throw new ArgumentNullException(nameof(hardwareManager));
+            SafeAxisMotion = safeAxisMotion ?? throw new ArgumentNullException(nameof(safeAxisMotion));
+            ParameterManager = parameterManager ?? throw new ArgumentNullException(nameof(parameterManager));
+            DeviceIoMonitorService = deviceIoMonitorService ?? throw new ArgumentNullException(nameof(deviceIoMonitorService));
+        }
+
+        public string WorkflowName { get; private set; }
+
+        public int TouchCount { get; private set; }
+
+        public bool AutoRaiseZ1 { get; private set; }
+
+        public CancellationToken CancellationToken { get; private set; }
+
+        public IEventAggregator EventAggregator { get; private set; }
+
+        public HardwareManager HardwareManager { get; private set; }
+
+        public SafeAxisMotion SafeAxisMotion { get; private set; }
+
+        public IParameterManager ParameterManager { get; private set; }
+
+        public IDeviceIoMonitorService DeviceIoMonitorService { get; private set; }
+
+        public IParamList GetParameterList()
+        {
+            return ParameterManager as IParamList;
+        }
+    }
+}