736 lines
33 KiB
C#
736 lines
33 KiB
C#
using Aurora;
|
|
using Aurora.Api;
|
|
using Aurora.Api.Devices;
|
|
using Aurora.Api.Manager;
|
|
using Aurora.View;
|
|
using AuroraACS;
|
|
using AuroraCellTracker;
|
|
using AuroraIO;
|
|
using AuroraLaser;
|
|
using AuroraLaser.Trumpf;
|
|
using AuroraLaserScanner;
|
|
using AuroraLBAD;
|
|
using AuroraLight;
|
|
using AuroraOCT;
|
|
using AuroraPLC;
|
|
using CoreUnit.Control.UserControl.Canvas;
|
|
using CoreUnit.Scanner.UserControl.ScannerCanvas;
|
|
using DB;
|
|
using DB.Recipe;
|
|
using Hermes;
|
|
using Hermes.Functional;
|
|
using Hermes.Functional.Option;
|
|
using ILSOS_PrismaticScanner.Device;
|
|
using ILSOS_PrismaticScanner.Models;
|
|
using Matrox.MatroxImagingLibrary;
|
|
using MilCommon;
|
|
using MilUI;
|
|
using OpenCvSharp;
|
|
using OpenCvSharp.Dnn;
|
|
using OpenCvSharp.WpfExtensions;
|
|
using System;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Configuration;
|
|
using System.Data;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.IO.Pipes;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.InteropServices.ComTypes;
|
|
using System.Runtime.Remoting.Contexts;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Forms.VisualStyles;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Xml.Linq;
|
|
using VisionCommon;
|
|
using WeldingCommon;
|
|
using WeldingCommon.Alarm;
|
|
using WeldingCommon.Data;
|
|
using WeldingCommon.Devices;
|
|
using WeldingCommon.Devices.ACS;
|
|
using WeldingCommon.Models;
|
|
using WeldingCommon.Sequences;
|
|
using WeldingCommon.Sequences.Main;
|
|
using WeldingCommon.Settings;
|
|
using WeldingCommon.Utils;
|
|
using WeldingCommon.Views;
|
|
using WeldingCommon.Vision.WeldingObjectGenerator;
|
|
using static Aurora.Api.SequenceBuilder;
|
|
using static AuroraIO.AJINEXTEK.AjinIO.IOModuleInfo;
|
|
using static AuroraIO.Vendor.PAIX.PAIXIO;
|
|
using static ILSOS_PrismaticScanner.Device.PLCControllerPrismaticScanner;
|
|
using static WeldingCommon.Devices.PLCController;
|
|
using static WeldingCommon.Sequences.Main.SeqExecutePlcBitInterface_InitParam;
|
|
|
|
namespace ILSOS_PrismaticScanner.Sequences
|
|
{
|
|
/// <summary>
|
|
/// Auto run sequence for prismatic scanner type
|
|
/// </summary>
|
|
public class SeqAutoRunPrismaticScanner
|
|
{
|
|
static readonly Logger Log = new Logger("SeqAutoRunPrismaticScanner");
|
|
|
|
const string SEQ_ENTER = "SEQ_ENTER";
|
|
const string SEQ_CHECK_INIT_CONDITION = "Check Init Condition";
|
|
const string SEQ_SET_BEFORE_UPLOAD = "Set Before Upload";
|
|
const string SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ = "Set Sequence Param (UploadWeldingList Seq)";
|
|
const string SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ = "Process (UploadWeldingList Seq)";
|
|
const string SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ = "Get Sequence Result (UploadWeldingList Seq)";
|
|
const string SEQ_CHECK_AFTER_UPLOAD = "Check After Upload";
|
|
const string SEQ_COMPLETE = "SEQ_COMPLETE";
|
|
const string SEQ_START_WELDING = "Start All Welding";
|
|
const string SEQ_DO_COMPONENT_WELDING = "Do Component Welding";
|
|
const string SEQ_ACS_MOTION_SET = "Set ACS Motion Parameter";
|
|
const string SEQ_ACS_MOTION_START = "ACS Motion Start";
|
|
const string SEQ_CHECK_MOTION_END = "Check ACS Motion Complete";
|
|
|
|
#region 260408 NDY nodes added
|
|
const string SEQ_STANDBY_MOTION = "Move Stage To Origin";
|
|
const string SEQ_STANDBY_SCANNER = "Encoder Reset";
|
|
#endregion
|
|
|
|
const int timeoutSeconds = 10;
|
|
static class ContextKey
|
|
{
|
|
public const string KEY_SEQUENCE_RESULT = "KEY_SEQUENCE_RESULT_SeqAutoRunPrismaticScanner";
|
|
public const string KEY_SEQUENCE_START_TIME = "KEY_SEQUENCE_START_TIME_SeqAutoRunPrismaticScanner";
|
|
}
|
|
|
|
// 기존
|
|
private SeqTeachingRun_InitParam _InitParam;
|
|
// 변경
|
|
//private SeqAutoRunPrismaticScanner_InitParam _InitParam;
|
|
private static Scanner _Scanner;
|
|
private IScannerACS _ACS;
|
|
private static ACSMotor _AxisX, _AxisZ;
|
|
private SystemParameter _SystemParameter;
|
|
private ScannerCanvasUserCtrl _ScannerCanvasUserCtrl;
|
|
private static SequenceSetting _SequenceSetting;
|
|
private eListNo _WeldingScannerListNo;
|
|
private List<IDrawObject> _SelectedObjectList;
|
|
private List<IDrawObject> _TargetObjects;
|
|
private static DateTime _SequenceCompleteTime;
|
|
private static TimeSpan _MeasurementSpanTime;
|
|
private static TimeSpan _ScannerSaveLogTime;
|
|
private static DateTime _partialWeldingStartTime;
|
|
private int _PageNum;
|
|
private double lastX, lastY;
|
|
private double _LastX, _LastY;
|
|
|
|
public SequenceBuilder Builder()
|
|
{
|
|
var sb = new SequenceBuilder(1000, true);
|
|
|
|
sb.AddAction(SEQ_ENTER, Sequence_Enter);
|
|
sb.AddAction(SEQ_CHECK_INIT_CONDITION, CheckInitCondition);
|
|
#region 26.04.08 NDY nodes added
|
|
sb.AddAction(SEQ_STANDBY_MOTION, SetStandbyMotion);
|
|
sb.AddAction(SEQ_STANDBY_SCANNER, SetStandbyScanner);
|
|
#endregion
|
|
sb.AddAction(SEQ_SET_BEFORE_UPLOAD, SetBeforeUpload);
|
|
sb.AddAction(SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ, SetUploadWeldingList_SeqParams);
|
|
sb.AddSubsequence(SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ, CommonSequenceManager.GetSeqBuilder_SeqUploadWeldingList());
|
|
sb.AddAction(SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ, GetUploadWeldingList_SeqResult);
|
|
sb.AddDecision(SEQ_CHECK_AFTER_UPLOAD, CheckAfterUpload);
|
|
sb.AddAction(SEQ_DO_COMPONENT_WELDING, DoComponentWelding);
|
|
sb.AddAction(SEQ_ACS_MOTION_SET, SetMotion);
|
|
sb.AddAction(SEQ_ACS_MOTION_START, StartMotion);
|
|
sb.AddAction(SEQ_CHECK_MOTION_END, EndWelding);
|
|
sb.AddAction(SEQ_COMPLETE, Complete);
|
|
|
|
sb.Flows(sb.Init
|
|
> sb[SEQ_ENTER]
|
|
> sb[SEQ_CHECK_INIT_CONDITION]
|
|
> sb[SEQ_STANDBY_MOTION]
|
|
> sb[SEQ_STANDBY_SCANNER]
|
|
> sb[SEQ_SET_BEFORE_UPLOAD]
|
|
> sb[SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ]
|
|
> sb[SEQ_DO_ID_UPLOAD_WELDING_LIST_SEQ]
|
|
> sb[SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ]
|
|
> sb[SEQ_CHECK_AFTER_UPLOAD]
|
|
> sb[SEQ_DO_COMPONENT_WELDING]
|
|
> sb[SEQ_ACS_MOTION_SET]
|
|
> sb[SEQ_ACS_MOTION_START]
|
|
> sb[SEQ_CHECK_MOTION_END]
|
|
> sb[SEQ_COMPLETE]
|
|
> sb.Final);
|
|
|
|
sb.Flows(sb[SEQ_CHECK_AFTER_UPLOAD]
|
|
> sb[SEQ_SET_BEFORE_UPLOAD]);
|
|
|
|
sb.OnStopped(OnStopped);
|
|
sb.OnForceError(OnForceError);
|
|
|
|
//sb.Draw("SeqAutoRunPrismaticScanner.pdf");
|
|
return sb;
|
|
}
|
|
|
|
// ==================== SEQ_ENTER ====================
|
|
private SequenceActionResult Sequence_Enter(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Log.I("===== [SEQ_ENTER] Sequence entry =====");
|
|
Log.I("SeqTeachingRun Start");
|
|
|
|
_InitParam = param.Param as SeqTeachingRun_InitParam;
|
|
_SystemParameter = context.Settings[CommonSettingIds.SystemParameter] as SystemParameter;
|
|
_SequenceSetting = context.Settings[CommonSettingIds.Sequence] as SequenceSetting;
|
|
|
|
_Scanner = context.Devices[DeviceIds.Scanner] as Scanner;
|
|
if (_Scanner == null) { Log.E("[SEQ_ENTER] Scanner is NULL"); MessageUtil.ShowErrorToast("Scanner not Ready", Log); return null; }
|
|
|
|
_ACS = context.Devices[DeviceIds.ACS] as ScannerACS;
|
|
if (_ACS == null) { Log.E("[SEQ_ENTER] ACS is NULL"); MessageUtil.ShowErrorToast("ACS not Ready", Log); return null; }
|
|
|
|
_AxisX = context.Devices[CommonDeviceIds.AxisX2] as ACSMotor;
|
|
if (_AxisX == null) { Log.E("[SEQ_ENTER] AxisX2 is NULL"); MessageUtil.ShowErrorToast("AxisX not Ready", Log); return null; }
|
|
|
|
_AxisZ = context.Devices[CommonDeviceIds.AxisZ] as ACSMotor;
|
|
if (_AxisZ == null) { Log.E("[SEQ_ENTER] AxisZ is NULL"); MessageUtil.ShowErrorToast("AxisZ not Ready", Log); return null; }
|
|
|
|
if (!CheckDeviceReady(context))
|
|
{
|
|
AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_DeviceNotReady);
|
|
Log.E("[SEQ_ENTER] Device not ready -> exit");
|
|
return null;
|
|
}
|
|
|
|
Log.I("[SEQ_ENTER] Complete -> CheckInitCondition");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private bool CheckDeviceReady(SequenceContext context)
|
|
{
|
|
List<string> deviceListToCheck = new List<string>() { DeviceIds.ACS, CommonDeviceIds.Scanner, CommonDeviceIds.AxisX2, CommonDeviceIds.AxisZ };
|
|
bool isAllDeviceActivated = true;
|
|
foreach (string item in deviceListToCheck)
|
|
{
|
|
bool activated = context.Devices[item].IsActivated;
|
|
Log.D($"[CheckDeviceReady] {item} -> IsActivated={activated}");
|
|
if (!activated) isAllDeviceActivated = false;
|
|
}
|
|
return isAllDeviceActivated;
|
|
}
|
|
|
|
// ==================== SEQ_CHECK_INIT_CONDITION ====================
|
|
private SequenceActionResult CheckInitCondition(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
bool hasAlarm = AlarmManager.HasAlarmLevelHigh();
|
|
Log.D($"[CheckInitCondition] HasAlarmLevelHigh={hasAlarm}");
|
|
if (hasAlarm)
|
|
{
|
|
Log.E("[CheckInitCondition] High alarm exists -> exit");
|
|
MessageUtil.ShowWarningToast("Clear Heavy Alarms For Welding!");
|
|
return null;
|
|
}
|
|
|
|
_ScannerSaveLogTime = TimeSpan.Zero;
|
|
_PageNum = 2;
|
|
var startTime = DateTime.Now;
|
|
context.PutValue(ContextKey.KEY_SEQUENCE_START_TIME, startTime);
|
|
|
|
Log.I($"[CheckInitCondition] Initial _PageNum={_PageNum}, StartTime={startTime:HH:mm:ss.fff}");
|
|
Log.D("ComponentTeachingRun Sequence CheckInitCondition");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_STANDBY_MOTION ====================
|
|
#region 26.04.08 NDY
|
|
private SequenceActionResult SetStandbyMotion(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
if (_AxisX == null)
|
|
{
|
|
Log.W("[MoveStageToOrigin] AxisX2 null - skip");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
Log.I("[MoveStageToOrigin] Stage X -> 310 move start");
|
|
|
|
// 26.04.17 NDY - start from 310
|
|
_AxisX.SetTargetPos(310, TargetPosType.ABS);
|
|
_AxisX.SetMoveVelocityImm(AuroraACS.Speed.M);
|
|
_AxisX.AccelerationImm(AuroraACS.Speed.M);
|
|
_AxisX.DecelerationImm(AuroraACS.Speed.M);
|
|
_AxisX.JerkImm(AuroraACS.Speed.M);
|
|
_AxisX.Move();
|
|
Log.D("[MoveStageToOrigin] AxisX.Move() called (target=310)");
|
|
|
|
// Laser FocusPosition Move 22.8 <- Z axis material position
|
|
_AxisZ.SetTargetPos(22.8, TargetPosType.ABS);
|
|
_AxisZ.SetMoveVelocityImm(AuroraACS.Speed.M);
|
|
_AxisZ.AccelerationImm(AuroraACS.Speed.M);
|
|
_AxisZ.DecelerationImm(AuroraACS.Speed.M);
|
|
_AxisZ.JerkImm(AuroraACS.Speed.M);
|
|
_AxisZ.Move();
|
|
Log.D("[MoveStageToOrigin] AxisZ.Move() called (target=22.8mm)");
|
|
|
|
//var res = context.RetryUntilSuccess(
|
|
// () => _AxisX.IsReachedTargetPosition(0) && _AxisZ.IsReachedTargetPosition(0),
|
|
// 30 * 1000, 20, true);
|
|
//var res = context.RetryUntilSuccess(
|
|
// () => _AxisX.IsReachedTargetPosition(0),
|
|
// 30 * 1000, 20, true);
|
|
var res = context.RetryUntilSuccess(
|
|
() => _AxisX.IsReachedTargetPosition(310),
|
|
30 * 1000, 20, true);
|
|
|
|
if (res == E2.TIMEOUT) { Log.E("[MoveStageToOrigin] TIMEOUT"); return null; }
|
|
else if (res == E2.CANCELLED) { Log.E("[MoveStageToOrigin] CANCELLED"); return null; }
|
|
|
|
Log.I("[MoveStageToOrigin] Stage X = 310 reached");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_STANDBY_SCANNER ====================
|
|
private SequenceActionResult SetStandbyScanner(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
var mainPage = CommonHelper.GetMainPage();
|
|
_ScannerCanvasUserCtrl = mainPage.ScannerCanvasCtrlTeaching;
|
|
_WeldingScannerListNo = eListNo.LIST1;
|
|
// _SelectedObjectList = FindObjects(); // removed duplicate 260417
|
|
_Scanner.SelectCorrectionTable(2);
|
|
Log.D("[EncoderReset] SelectCorrectionTable(2) done");
|
|
|
|
if (!_Scanner.Config.UseMarkingOnTheFly)
|
|
{
|
|
Log.W("[EncoderReset] MOTF disabled - skip");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
Log.I("[EncoderReset] Start");
|
|
_Scanner.SetStartList(_WeldingScannerListNo);
|
|
Log.D($"[EncoderReset] SetStartList({_WeldingScannerListNo}) done");
|
|
|
|
_Scanner.SetFlyX(_Scanner.Config.MarkingOnTheFlyEncoderResolutionX);
|
|
Log.I($"[EncoderReset] SetFlyX: {_Scanner.Config.MarkingOnTheFlyEncoderResolutionX}");
|
|
|
|
//_Scanner.WaitForEncoderX(_Scanner.Config.MarkingStartEncoderPositionX);
|
|
//Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.MarkingStartEncoderPositionX}");
|
|
|
|
// 26.04.17 NDY - encoder reset at Stage X = 310
|
|
_Scanner.StoreEncoder(0);
|
|
_Scanner.SaveAndRestartTimer();
|
|
|
|
Log.I("[EncoderReset] Complete - Stage(310) = Scanner Encoder(0) synchronized");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
private List<IDrawObject> FindObjects()
|
|
{
|
|
if (_InitParam.IsUseExternalObjects)
|
|
return _InitParam.ExternalObjects;
|
|
else if (_InitParam.IsObjectSelectAll)
|
|
return _ScannerCanvasUserCtrl.Model.ActiveLayer.Objects;
|
|
else
|
|
return _ScannerCanvasUserCtrl.Canvas.Model.SelectedObjects;
|
|
}
|
|
#endregion
|
|
|
|
// ==================== SEQ_SET_BEFORE_UPLOAD ====================
|
|
private SequenceActionResult SetBeforeUpload(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Log.I($"===== [SetBeforeUpload] Entry PageNum={_PageNum} =====");
|
|
|
|
var mainPage = CommonHelper.GetMainPage();
|
|
_ScannerCanvasUserCtrl = mainPage.ScannerCanvasCtrlTeaching;
|
|
|
|
int layerIdx = _PageNum - 1;
|
|
Log.D($"[SetBeforeUpload] LayerIndex={layerIdx}, TotalLayers={_ScannerCanvasUserCtrl.Model.Layers.Count()}");
|
|
|
|
_SelectedObjectList = _ScannerCanvasUserCtrl.Model.Layers[_PageNum - 1].Objects;
|
|
Log.D($"[SetBeforeUpload] PageNum={_PageNum} ObjectCount={_SelectedObjectList?.Count ?? 0}");
|
|
|
|
_LastX = lastX;
|
|
_LastY = lastY;
|
|
Log.D($"[SetBeforeUpload] Prev LastX={_LastX:F4}, LastY={_LastY:F4}");
|
|
|
|
// ScannerConfig dump
|
|
Log.I("---- [SetBeforeUpload] ScannerConfig values ----");
|
|
Log.I($" MarkingStartX_1 = {_Scanner.Config.MarkingStartX_1} (forward start)");
|
|
Log.I($" MarkingStartX_2 = {_Scanner.Config.MarkingStartX_2} (reverse start)");
|
|
Log.I($" XDiff_Page1and2 = {_Scanner.Config.XDiff_Page1and2} (360, Page1/2 boundary)");
|
|
Log.I($" XDiff_Page3and4 = {_Scanner.Config.XDiff_Page3and4} (590, Page3/4 boundary)");
|
|
Log.I($" EncoderResolutionX = {_Scanner.Config.MarkingOnTheFlyEncoderResolutionX}");
|
|
Log.I("------------------------------------------------");
|
|
|
|
if (_PageNum == 2 || _PageNum == 4)
|
|
{
|
|
if (_PageNum == 2)
|
|
{
|
|
// 기존 코드 유지 (if _PageNum==0 -> if _PageNum==2 수정)
|
|
Log.I($"[SetBeforeUpload] PageNum=2 -> WaitForEncoderX({_Scanner.Config.MarkingStartX_1:F4})");
|
|
Log.D($" MarkingStartX_1={_Scanner.Config.MarkingStartX_1} / XDiff_Page1and2={_Scanner.Config.XDiff_Page1and2}");
|
|
_Scanner.WaitForEncoderX(_Scanner.Config.MarkingStartX_1);
|
|
Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.MarkingStartX_1}");
|
|
|
|
// 26.04.17 NDY - if need 360 boundary, replace with below
|
|
//_Scanner.WaitForEncoderX(_Scanner.Config.XDiff_Page1and2);
|
|
//Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.XDiff_Page1and2}");
|
|
}
|
|
else // PageNum == 4
|
|
{
|
|
// 기존 코드 유지
|
|
Log.I($"[SetBeforeUpload] PageNum=4 -> WaitForEncoderX({_Scanner.Config.MarkingStartX_2:F4})");
|
|
Log.D($" MarkingStartX_2={_Scanner.Config.MarkingStartX_2} / XDiff_Page3and4={_Scanner.Config.XDiff_Page3and4}");
|
|
_Scanner.WaitForEncoderX(_Scanner.Config.MarkingStartX_2);
|
|
Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.MarkingStartX_2}");
|
|
|
|
// 26.04.17 NDY - if need 590 boundary, replace with below
|
|
//_Scanner.WaitForEncoderX(_Scanner.Config.XDiff_Page3and4);
|
|
//Log.I($"[EncoderReset] WaitForEncoderX: {_Scanner.Config.XDiff_Page3and4}");
|
|
}
|
|
|
|
int lineCount = 0;
|
|
foreach (IDrawObject obj in _SelectedObjectList)
|
|
{
|
|
if (obj is Line)
|
|
{
|
|
lastX = obj.PF2.X;
|
|
lastY = obj.PF2.Y;
|
|
lineCount++;
|
|
}
|
|
}
|
|
Log.D($"[SetBeforeUpload] Line objects={lineCount}, lastX={lastX:F4}, lastY={lastY:F4}");
|
|
}
|
|
else
|
|
{
|
|
Log.D($"[SetBeforeUpload] PageNum={_PageNum} -> WaitForEncoderX skip");
|
|
}
|
|
|
|
Log.I($"[SetBeforeUpload] Complete -> SetUploadWeldingList_SeqParams (PageNum={_PageNum})");
|
|
Log.D($"[SetBeforeUpload] Set Before UploadWeldingList");
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_SET_PARAMS_UPLOAD_WELDING_LIST_SEQ ====================
|
|
private SequenceActionResult SetUploadWeldingList_SeqParams(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Status.SetWorkingPosition(eWorkingPosition.UPLOADING_WELD_LIST);
|
|
|
|
bool _isUseInitParam = _InitParam == null ? false : true;
|
|
|
|
SeqUploadWeldingList_InitParam seqParams = new SeqUploadWeldingList_InitParam()
|
|
{
|
|
NeedSetLaserTiming = _isUseInitParam ? _InitParam.NeedSetLaserTiming : true,
|
|
IncludeListStartEnd = false,
|
|
CellMeasureCenterOffsetX = _SystemParameter.CellPosMeasureCenterOffsetX + (_isUseInitParam ? _InitParam.CellCenterOffsetX : 0),
|
|
CellMeasureCenterOffsetY = _SystemParameter.CellPosMeasureCenterOffsetY + (_isUseInitParam ? _InitParam.CellCenterOffsetY : 0),
|
|
SelectedDrawObjectList = _SelectedObjectList,
|
|
WeldingScannerListNo = _WeldingScannerListNo,
|
|
PageNum = _PageNum,
|
|
LastX = _LastX,
|
|
LastY = _LastY
|
|
};
|
|
|
|
Log.D($"[ComponentTeachingRun] Set UploadWeldingList Seq Param");
|
|
return SequenceAction.Ok(seqParams);
|
|
}
|
|
|
|
// ==================== SEQ_GET_RESULT_UPLOAD_WELDING_LIST_SEQ ====================
|
|
private SequenceActionResult GetUploadWeldingList_SeqResult(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Log.D($"[ComponentTeachingRun] Get UploadWeldingList Seq Param");
|
|
|
|
var resultOutParam = param.Param as SeqUploadWeldingList_OutParam;
|
|
if (resultOutParam.Success == false)
|
|
{
|
|
Log.E($"[ComponentTeachingRun] Failed UploadWeldingList Sequence");
|
|
return null;
|
|
}
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_CHECK_AFTER_UPLOAD ====================
|
|
private string CheckAfterUpload(SequenceContext context, string id, ICollection<string> branches, SequenceActionResult param)
|
|
{
|
|
_PageNum += 1;
|
|
if (_PageNum == 5) _PageNum = 1;
|
|
Log.I($"[CheckAfterUpload] PageNum after increment={_PageNum}");
|
|
|
|
if (_PageNum == 2)
|
|
{
|
|
Log.I("[CheckAfterUpload] PageNum==2 -> branch to DoComponentWelding");
|
|
return SEQ_DO_COMPONENT_WELDING;
|
|
}
|
|
else
|
|
{
|
|
Log.I($"[CheckAfterUpload] PageNum={_PageNum} -> branch to SetBeforeUpload (loop)");
|
|
return SEQ_SET_BEFORE_UPLOAD;
|
|
}
|
|
}
|
|
|
|
// ==================== SEQ_DO_COMPONENT_WELDING ====================
|
|
private SequenceActionResult DoComponentWelding(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
// Close list buffer before execute - subsequence has no SetStartList/SetEndList
|
|
//Log.I($"[DoComponentWelding] ListSpace (before SetEndList)={_Scanner.GetListSpace()}");
|
|
//_Scanner.SetEndList();
|
|
Log.I($"[DoComponentWelding] ListSpace (after SetEndList)={_Scanner.GetListSpace()}");
|
|
|
|
Log.I("ExecuteList Start");
|
|
Log.I($"Welding List Space : {_Scanner.GetListSpace()}");
|
|
DateTime weldingTime = DateTime.Now;
|
|
_Scanner.ExecuteList(_WeldingScannerListNo);
|
|
Log.I($"[DoComponentWelding] ExecuteList called at {weldingTime:HH:mm:ss.fff}");
|
|
|
|
// 26.04.06 NDY - ACS Stage X move (simultaneous with scanner list)
|
|
// MOTF: Stage X encoder triggers WaitForEncoderX -> galvano marking
|
|
// _ACS?.MOTFStart();
|
|
|
|
// 26.04.06 NDY - ACS completion wait
|
|
// while (!_ACS.CheckMOTFComp()) { Thread.Sleep(10); }
|
|
|
|
if (_Scanner.Config.UseRecordSignal)
|
|
{
|
|
DateTime startTime = DateTime.Now;
|
|
_Scanner.StackRecord();
|
|
_ScannerSaveLogTime += DateTime.Now.Subtract(startTime);
|
|
}
|
|
|
|
SaveScannerRecordFileForamt();
|
|
Log.D($"[ComponentTeachingRun] SaveScannerRecordFileForamt Time : {_ScannerSaveLogTime.TotalMilliseconds}");
|
|
|
|
var PartialTactTime = DateTime.Now.Subtract(_partialWeldingStartTime);
|
|
Log.D($"[TactTime] Complete Partial Component Weld : {PartialTactTime.TotalMilliseconds}");
|
|
|
|
_ScannerCanvasUserCtrl.TimeLabelUpdate(_MeasurementSpanTime.TotalMilliseconds, PartialTactTime.TotalMilliseconds);
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_ACS_MOTION_SET ====================
|
|
private SequenceActionResult SetMotion(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
var _scannerConfig = _Scanner.Config;
|
|
|
|
Log.I("[SetMotion] Forward param setting start");
|
|
Log.I($"[SetMotion] PosX={_scannerConfig.MarkingStartX_1}, NegX={_scannerConfig.MarkingStartX_2}, Vel={_scannerConfig.MOTFStageSpeed}");
|
|
|
|
// iMOTFComplete reset
|
|
_ACS.ResetMOTFComp();
|
|
Log.I("[SetMotion] ResetMOTFComp done");
|
|
|
|
// Forward direction param setting (310 -> 640)
|
|
bool result = _ACS.SetMOTFParams(
|
|
posX: _scannerConfig.MarkingStartX_1,
|
|
negX: _scannerConfig.MarkingStartX_2,
|
|
velocity: _scannerConfig.MOTFStageSpeed,
|
|
acc: 5000,
|
|
interval: 100
|
|
);
|
|
if (!result) { Log.E("[SetMotion] SetMOTFParams failed"); return null; }
|
|
Log.I("[SetMotion] SetMOTFParams done");
|
|
|
|
// 26.04.17 NDY - below line overwrites with MarkSpeed/0/0, commented out
|
|
// _ACS.SetMOTFParams(_scannerConfig.MarkingStartX_1, _scannerConfig.MarkingStartX_2, _scannerConfig.MarkSpeed, 0, 0);
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_ACS_MOTION_START ====================
|
|
private SequenceActionResult StartMotion(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
#region old code (commented out)
|
|
//_ACS.MOTFStart();
|
|
//var res = context.Wait(1000, 100);
|
|
//if (res == E2.TIMEOUT) {;}
|
|
//else if (res == E2.CANCELLED) { Log.E("[MOTF] Motion CANCELLED"); return null; }
|
|
//res = context.RetryUntilSuccess(() => _ACS.CheckMOTFComp(), 1000 * 20, 100, true);
|
|
//if (res == E2.TIMEOUT) { Log.E("[MOTF] Motion TIMEOUT"); return null; }
|
|
//else if (res == E2.CANCELLED) { Log.E("[MOTF] Motion CANCELLED"); return null; }
|
|
//return SequenceAction.Ok();
|
|
#endregion
|
|
|
|
var config = _Scanner.Config;
|
|
|
|
// ── Forward execution (310 -> 640, params already set in SetMotion) ──
|
|
Log.I("[StartMotion] Forward MOTFStart called");
|
|
_ACS.MOTFStart();
|
|
|
|
int waitMs = (int)((50.0 / config.MOTFStageSpeed) * 1000) + 200;
|
|
Log.I($"[StartMotion] Forward 50mm wait {waitMs}ms");
|
|
var res = context.Wait(waitMs, 10);
|
|
if (res == E2.CANCELLED) { Log.E("[StartMotion] Forward 50mm wait CANCELLED"); return null; }
|
|
|
|
Log.I("[StartMotion] Forward CheckMOTFComp wait start");
|
|
res = context.RetryUntilSuccess(() => _ACS.CheckMOTFComp(), 1000 * 30, 100, true);
|
|
if (res == E2.TIMEOUT) { Log.E("[StartMotion] Forward TIMEOUT"); return null; }
|
|
else if (res == E2.CANCELLED) { Log.E("[StartMotion] Forward CANCELLED"); return null; }
|
|
Log.I("[StartMotion] Forward complete");
|
|
|
|
// ── Reverse setting (640 -> 310) after forward complete ──
|
|
Log.I("[StartMotion] Reverse param setting start");
|
|
_ACS.ResetMOTFComp();
|
|
Log.I("[StartMotion] Reverse ResetMOTFComp done");
|
|
|
|
bool result = _ACS.SetMOTFParams(
|
|
posX: config.MarkingStartX_2, // 640 start
|
|
negX: config.MarkingStartX_1, // 310 end
|
|
velocity: config.MOTFStageSpeed,
|
|
acc: 5000,
|
|
interval: 100
|
|
);
|
|
if (!result) { Log.E("[StartMotion] Reverse SetMOTFParams failed"); return null; }
|
|
Log.I($"[StartMotion] Reverse SetMOTFParams done | PosX={config.MarkingStartX_2}, NegX={config.MarkingStartX_1}");
|
|
|
|
// ── Reverse execution ──
|
|
Log.I("[StartMotion] Reverse MOTFStart called");
|
|
_ACS.MOTFStart();
|
|
|
|
Log.I($"[StartMotion] Reverse 50mm wait {waitMs}ms");
|
|
res = context.Wait(waitMs, 10);
|
|
if (res == E2.CANCELLED) { Log.E("[StartMotion] Reverse 50mm wait CANCELLED"); return null; }
|
|
|
|
Log.I("[StartMotion] Reverse CheckMOTFComp wait start");
|
|
res = context.RetryUntilSuccess(() => _ACS.CheckMOTFComp(), 1000 * 30, 100, true);
|
|
if (res == E2.TIMEOUT) { Log.E("[StartMotion] Reverse TIMEOUT"); return null; }
|
|
else if (res == E2.CANCELLED) { Log.E("[StartMotion] Reverse CANCELLED"); return null; }
|
|
Log.I("[StartMotion] Reverse complete -> EndWelding");
|
|
|
|
#region Stage X return to 0 after welding complete
|
|
// 26.04.16 NDY - Stage X return to origin(0) after welding
|
|
_AxisX.SetTargetPos(0, TargetPosType.ABS);
|
|
_AxisX.SetMoveVelocityImm(AuroraACS.Speed.M);
|
|
_AxisX.AccelerationImm(AuroraACS.Speed.M);
|
|
_AxisX.DecelerationImm(AuroraACS.Speed.M);
|
|
_AxisX.JerkImm(AuroraACS.Speed.M);
|
|
_AxisX.Move();
|
|
Log.D("[StartMotion] AxisX.Move() to 0 called");
|
|
|
|
res = context.RetryUntilSuccess(
|
|
() => _AxisX.IsReachedTargetPosition(0),
|
|
30 * 1000, 20, true);
|
|
|
|
if (res == E2.TIMEOUT) { Log.E("[EndWelding] Stage X return TIMEOUT"); }
|
|
else if (res == E2.CANCELLED) { Log.E("[EndWelding] Stage X return CANCELLED"); }
|
|
else { Log.I("[EndWelding] Stage X = 0 return complete"); }
|
|
#endregion
|
|
|
|
// 26.04.16 NDY - sequence result set
|
|
context.PutValue(ContextKey.KEY_SEQUENCE_RESULT, true);
|
|
Log.I("[StartMotion] KEY_SEQUENCE_RESULT = true set");
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_CHECK_MOTION_END ====================
|
|
private SequenceActionResult EndWelding(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Log.I("[EndWelding] Entry");
|
|
|
|
_Scanner.WaitForListTaskCompleted(_SystemParameter.WeldLinesTaskTimeOut);
|
|
Log.I("ExecuteList Complete");
|
|
|
|
_MeasurementSpanTime = DateTime.Now.Subtract(_SequenceCompleteTime);
|
|
Log.D($"[TactTime] Complete All Component Weld : {_MeasurementSpanTime.TotalMilliseconds}");
|
|
|
|
// Analog output - COMMAND mode = direct (not list)
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA1, 5, eFunctionType.COMMAND);
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA2, 5, eFunctionType.COMMAND);
|
|
Log.D("[EndWelding] WriteDA(DA1=5, DA2=5) done");
|
|
|
|
_Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);
|
|
Log.D("[EndWelding] JumpAbs(0,0) done");
|
|
|
|
_Scanner.Fly_Return(_Scanner.Config.MarkingOntheFlyParkingPositionX, _Scanner.Config.MarkingOntheFlyParkingPositionY);
|
|
Log.D($"[EndWelding] Fly_Return({_Scanner.Config.MarkingOntheFlyParkingPositionX}, {_Scanner.Config.MarkingOntheFlyParkingPositionY}) done");
|
|
|
|
// _Scanner.SetEndList(); // moved to DoComponentWelding
|
|
|
|
var mesurementTime = DateTime.Now;
|
|
|
|
// Restore CorrectionFile to Vision after welding
|
|
_Scanner.SelectCorrectionTable(1);
|
|
Log.D("[EndWelding] SelectCorrectionTable(1) restored");
|
|
|
|
_MeasurementSpanTime = DateTime.Now.Subtract(mesurementTime);
|
|
Log.D($"[ComponentTeachingRun] Change SelectCorrectionTable Time : {_MeasurementSpanTime.TotalMilliseconds}");
|
|
|
|
return SequenceAction.Ok();
|
|
}
|
|
|
|
// ==================== SEQ_COMPLETE ====================
|
|
private SequenceActionResult Complete(SequenceContext context, string id, SequenceActionResult param)
|
|
{
|
|
Log.D("[Complete] Start");
|
|
context.TryGetValue(ContextKey.KEY_SEQUENCE_RESULT, out bool seqResult);
|
|
SeqTeachingRun_OutParam result = new SeqTeachingRun_OutParam() { Success = seqResult };
|
|
Log.I($"[Complete] seqResult = {seqResult}");
|
|
|
|
if (seqResult == false)
|
|
AlarmManager.Alarm(AlarmCode.ALARM_SEQUENCE_TeachingRun_ResultFailed);
|
|
|
|
Log.D("ComponentTeachingRun Sequence Complete");
|
|
return SequenceAction.Ok(result);
|
|
}
|
|
|
|
// ==================== Helper methods ====================
|
|
private void SaveScannerRecordFileForamt()
|
|
{
|
|
if (_Scanner.Config.UseRecordSignal)
|
|
{
|
|
DateTime startTime = DateTime.Now;
|
|
_Scanner.SaveStackRecord("Normal");
|
|
_ScannerSaveLogTime += DateTime.Now.Subtract(startTime);
|
|
}
|
|
}
|
|
|
|
private void OnForceError(SequenceContext context, string arg2)
|
|
{
|
|
Log.E("===== [OnForceError] Force error occurred =====");
|
|
SaveScannerRecordFileForamt();
|
|
_Scanner.StopExecution();
|
|
Log.D("[OnForceError] StopExecution done");
|
|
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA1, 0, eFunctionType.COMMAND);
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA2, 0, eFunctionType.COMMAND);
|
|
|
|
Thread.Sleep(10);
|
|
_Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);
|
|
Thread.Sleep(10);
|
|
|
|
Log.I("SequenceAction Ok : OnForceError");
|
|
}
|
|
|
|
private void OnStopped(SequenceContext context)
|
|
{
|
|
Log.W("===== [OnStopped] Sequence stopped =====");
|
|
SaveScannerRecordFileForamt();
|
|
_Scanner.StopExecution();
|
|
Log.D("[OnStopped] StopExecution done");
|
|
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA1, 0, eFunctionType.COMMAND);
|
|
_Scanner.WriteDA((uint)eAnalogPortOut.DA2, 0, eFunctionType.COMMAND);
|
|
|
|
Thread.Sleep(10);
|
|
_Scanner.JumpAbs(0, 0, eFunctionType.COMMAND);
|
|
Thread.Sleep(10);
|
|
|
|
Log.I("SequenceAction Ok : OnStopped");
|
|
}
|
|
}
|
|
|
|
public class SeqAutoRunPrismaticScanner_InitParam : InitParam
|
|
{
|
|
public bool IsObjectSelectAll { get; set; }
|
|
public bool UseStream { get; set; }
|
|
public bool UseBlow { get; set; }
|
|
public int IntervalTimeBlowOn { get; set; }
|
|
public int IntervalTimeBlowOff { get; set; }
|
|
public bool NeedSetLaserTiming { get; set; }
|
|
}
|
|
|
|
public class SeqAutoRunPrismaticScanner_OutParam : OutParam
|
|
{
|
|
}
|
|
} |