506 lines
21 KiB
C#
506 lines
21 KiB
C#
using Aurora;
|
|
using Aurora.Api;
|
|
using Aurora.View;
|
|
using AuroraLaserScanner;
|
|
using CoreUnit.Scanner.UserControl.ScannerCanvas;
|
|
using Microsoft.Office.Interop.Excel;
|
|
using MilUI;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Input;
|
|
using VisionCommon;
|
|
using VisionUI;
|
|
using WeldingCommon.RMS;
|
|
using WeldingCommon.Sequences;
|
|
using WeldingCommon.Utils;
|
|
|
|
namespace WeldingCommon.Views
|
|
{
|
|
public class UCTestSequenceViewModel : NotifyPropertyChangedBase
|
|
{
|
|
private readonly Logger Log = new Logger("UCTestSequenceViewModel");
|
|
|
|
public ICommand CMD_VisibleChanged { get; }
|
|
public ICommand CMD_RunSeqMarkGrid { get; }
|
|
public ICommand CMD_RunSeqScannerCalibration { get; }
|
|
public ICommand CMD_RunSeqReceiveCellInfo { get; }
|
|
public ICommand CMD_RunSeqReportCellResult { get; }
|
|
public ICommand CMD_RunSeqScoutFlyingVision { get; }
|
|
public ICommand CMD_RunSeqScoutNormal { get; }
|
|
public ICommand CMD_RunSeqUploadWeldingList { get; }
|
|
public ICommand CMD_RunSeqTeachingRun { get; }
|
|
|
|
private readonly IAuroraEnvironment _Aurora;
|
|
|
|
private readonly ISequence _SeqMarkGrid;
|
|
private bool _IsSequenceRunning_SeqMarkGrid;
|
|
public bool IsSequenceRunning_SeqMarkGrid { get => _IsSequenceRunning_SeqMarkGrid; set => SetProperty(ref _IsSequenceRunning_SeqMarkGrid, value); }
|
|
|
|
private readonly ISequence _SeqScannerCalibration;
|
|
private bool _IsSequenceRunning_SeqScannerCalibration;
|
|
public bool IsSequenceRunning_SeqScannerCalibration { get => _IsSequenceRunning_SeqScannerCalibration; set => SetProperty(ref _IsSequenceRunning_SeqScannerCalibration, value); }
|
|
|
|
private readonly ISequence _SeqReceiveCellInfo;
|
|
private bool _IsSequenceRunning_SeqReceiveCellInfo;
|
|
public bool IsSequenceRunning_SeqReceiveCellInfo { get => _IsSequenceRunning_SeqReceiveCellInfo; set => SetProperty(ref _IsSequenceRunning_SeqReceiveCellInfo, value); }
|
|
|
|
private readonly ISequence _SeqReportCellResult;
|
|
private bool _IsSequenceRunning_SeqReportCellResult;
|
|
public bool IsSequenceRunning_SeqReportCellResult { get => _IsSequenceRunning_SeqReportCellResult; set => SetProperty(ref _IsSequenceRunning_SeqReportCellResult, value); }
|
|
|
|
private readonly ISequence _SeqScoutFlyingVision;
|
|
private bool _IsSequenceRunning_SeqScoutFlyingVision;
|
|
public bool IsSequenceRunning_SeqScoutFlyingVision { get => _IsSequenceRunning_SeqScoutFlyingVision; set => SetProperty(ref _IsSequenceRunning_SeqScoutFlyingVision, value); }
|
|
|
|
private readonly ISequence _SeqScoutNormal;
|
|
private bool _IsSequenceRunning_SeqScoutNormal;
|
|
public bool IsSequenceRunning_SeqScoutNormal { get => _IsSequenceRunning_SeqScoutNormal; set => SetProperty(ref _IsSequenceRunning_SeqScoutNormal, value); }
|
|
|
|
private readonly ISequence _SeqUploadWeldingList;
|
|
private bool _IsSequenceRunning_SeqUploadWeldingList;
|
|
public bool IsSequenceRunning_SeqUploadWeldingList { get => _IsSequenceRunning_SeqUploadWeldingList; set => SetProperty(ref _IsSequenceRunning_SeqUploadWeldingList, value); }
|
|
|
|
private readonly ISequence _SeqTeachingRun;
|
|
private bool _IsSequenceRunning_SeqTeachingRun;
|
|
public bool IsSequenceRunning_SeqTeachingRun { get => _IsSequenceRunning_SeqTeachingRun; set => SetProperty(ref _IsSequenceRunning_SeqTeachingRun, value); }
|
|
|
|
private ScannerCanvasUserCtrl _ScannerCanvasUserCtrl;
|
|
|
|
public UCTestSequenceViewModel(IAuroraEnvironment aurora)
|
|
{
|
|
_Aurora = aurora;
|
|
|
|
var mainPage = CommonHelper.GetMainPage();
|
|
_ScannerCanvasUserCtrl = mainPage.ScannerCanvasCtrlTeaching;
|
|
|
|
_SeqMarkGrid = _Aurora.SequenceEntry[CommonSequenceIds.SeqMarkGrid];
|
|
_SeqScannerCalibration = _Aurora.SequenceEntry[CommonSequenceIds.SeqScannerCalibration];
|
|
_SeqReceiveCellInfo = _Aurora.SequenceEntry[CommonSequenceIds.SeqReceiveCellInfo];
|
|
_SeqReportCellResult = _Aurora.SequenceEntry[CommonSequenceIds.SeqReportCellResult];
|
|
_SeqScoutFlyingVision = _Aurora.SequenceEntry[CommonSequenceIds.SeqScoutFlyingVision];
|
|
_SeqScoutNormal = _Aurora.SequenceEntry[CommonSequenceIds.SeqScoutNormal];
|
|
_SeqUploadWeldingList = _Aurora.SequenceEntry[CommonSequenceIds.SeqUploadWeldingList];
|
|
_SeqTeachingRun = _Aurora.SequenceEntry[CommonSequenceIds.SeqTeachingRun];
|
|
|
|
CMD_RunSeqMarkGrid = new DelegateCommand(PerformCmdRunSeqMarkGrid);
|
|
CMD_RunSeqScannerCalibration = new DelegateCommand(PerformCmdRunSeqScannerCalibration);
|
|
CMD_RunSeqReceiveCellInfo = new DelegateCommand(PerformCmdRunSeqReceiveCellInfo);
|
|
CMD_RunSeqReportCellResult = new DelegateCommand(PerformCmdRunSeqReportCellResult);
|
|
CMD_RunSeqScoutFlyingVision = new DelegateCommand(PerformCmdRunSeqScoutFlyingVision);
|
|
CMD_RunSeqScoutNormal = new DelegateCommand(PerformCmdRunSeqScoutNormal);
|
|
CMD_RunSeqUploadWeldingList = new DelegateCommand(PerformCmdRunSeqUploadWeldingList);
|
|
CMD_RunSeqTeachingRun = new DelegateCommand(PerformCmdRunSeqTeachingRun);
|
|
}
|
|
|
|
private void PerformCmdRunSeqMarkGrid(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqMarkGrid.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqMarkGrid"), Log);
|
|
return;
|
|
}
|
|
|
|
// ScannerCalibrationViewModel 에 설정된 값으로 세팅이 됨
|
|
var param = new SeqMarkGrid_InitParam() {
|
|
ColumnCount = 13,
|
|
RowCount = 13,
|
|
UnitLength = 10,
|
|
MarkPower = 10,
|
|
MarkSpeed = 100,
|
|
MarkLength = 10,
|
|
};
|
|
|
|
IsSequenceRunning_SeqMarkGrid = true;
|
|
_SeqMarkGrid.Start(param, OnComplete_SeqMarkGrid);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqMarkGrid.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqMarkGrid = false;
|
|
_SeqMarkGrid.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqMarkGrid(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqMarkGrid_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqMarkGrid = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqMarkGrid"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqMarkGrid = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqMarkGrid"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqScannerCalibration(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqScannerCalibration.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScannerCalibration"), Log);
|
|
return;
|
|
}
|
|
|
|
// ScannerCalibrationViewModel 에 설정된 값으로 세팅이 됨
|
|
var param = new SeqScannerCalibration_InitParam() {
|
|
FovInfo = null,
|
|
IsVisionCalibration = true,
|
|
ColumnCount = 13,
|
|
RowCount = 13,
|
|
UnitLength = 10,
|
|
TiltingDegree = 0,
|
|
CheckOffset = 10,
|
|
MasterPosOffsetX = 0,
|
|
MasterPosOffsetY = 0,
|
|
};
|
|
|
|
IsSequenceRunning_SeqScannerCalibration = true;
|
|
_SeqScannerCalibration.Start(param, OnComplete_SeqScannerCalibration);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqScannerCalibration.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqScannerCalibration = false;
|
|
_SeqScannerCalibration.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqScannerCalibration(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqScannerCalibration_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqScannerCalibration = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqScannerCalibration"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqScannerCalibration = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqScannerCalibration"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqReceiveCellInfo(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqReceiveCellInfo.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqReceiveCellInfo"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqReceiveCellInfo_InitParam() {
|
|
|
|
};
|
|
|
|
IsSequenceRunning_SeqReceiveCellInfo = true;
|
|
_SeqReceiveCellInfo.Start(param, OnComplete_SeqReceiveCellInfo);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqReceiveCellInfo.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqReceiveCellInfo = false;
|
|
_SeqReceiveCellInfo.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqReceiveCellInfo(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqReceiveCellInfo_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqReceiveCellInfo = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqReceiveCellInfo"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqReceiveCellInfo = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqReceiveCellInfo"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqReportCellResult(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqReportCellResult.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqReportCellResult"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqReportCellResult_InitParam() {
|
|
EDC_Interface = new EDC(),
|
|
|
|
};
|
|
|
|
IsSequenceRunning_SeqReportCellResult = true;
|
|
_SeqReportCellResult.Start(param, OnComplete_SeqReportCellResult);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqReportCellResult.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqReportCellResult = false;
|
|
_SeqReportCellResult.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqReportCellResult(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqReportCellResult_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqReportCellResult = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqReportCellResult"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqReportCellResult = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqReportCellResult"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqScoutFlyingVision(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqScoutFlyingVision.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScoutFlyingVision"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqScoutFlyingVision_InitParam() {
|
|
IsRealTimeScout = false,
|
|
ScoutSeqParams = new ScoutSeqParams(VisionRecipeManager.GetFovInfos()[0], eDisplayType.Machine_B),
|
|
SequenceAutoRunCount = 0,
|
|
WeldingScannerListNo = eListNo.LIST2,
|
|
};
|
|
|
|
IsSequenceRunning_SeqScoutFlyingVision = true;
|
|
_SeqScoutFlyingVision.Start(param, OnComplete_SeqScoutFlyingVision);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqScoutFlyingVision.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqScoutFlyingVision = false;
|
|
_SeqScoutFlyingVision.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqScoutFlyingVision(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqScoutFlyingVision_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqScoutFlyingVision = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqScoutFlyingVision"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqScoutFlyingVision = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqScoutFlyingVision"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqScoutNormal(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqScoutNormal.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqScoutNormal"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqScoutNormal_InitParam() {
|
|
IsRealTimeScout = false,
|
|
ScoutSeqParams = new ScoutSeqParams(VisionRecipeManager.GetFovInfos()[0], eDisplayType.Machine_B),
|
|
};
|
|
|
|
IsSequenceRunning_SeqScoutNormal = true;
|
|
_SeqScoutNormal.Start(param, OnComplete_SeqScoutNormal);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqScoutNormal.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqScoutNormal = false;
|
|
_SeqScoutNormal.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqScoutNormal(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqScoutNormal_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqScoutNormal = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqScoutNormal"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqScoutNormal = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqScoutNormal"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqUploadWeldingList(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqUploadWeldingList.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqUploadWeldingList"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqUploadWeldingList_InitParam() {
|
|
NeedSetLaserTiming = false,
|
|
IncludeListStartEnd = true,
|
|
CellMeasureCenterOffsetX = 0,
|
|
CellMeasureCenterOffsetY = 0,
|
|
SelectedDrawObjectList = _ScannerCanvasUserCtrl.Model.Layers[0].Objects,
|
|
WeldingScannerListNo = eListNo.LIST1,
|
|
};
|
|
|
|
IsSequenceRunning_SeqUploadWeldingList = true;
|
|
_SeqUploadWeldingList.Start(param, OnComplete_SeqUploadWeldingList);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqUploadWeldingList.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqUploadWeldingList = false;
|
|
_SeqUploadWeldingList.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqUploadWeldingList(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqUploadWeldingList_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqUploadWeldingList = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqUploadWeldingList"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqUploadWeldingList = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqUploadWeldingList"));
|
|
}
|
|
|
|
private void PerformCmdRunSeqTeachingRun(object commandParameter)
|
|
{
|
|
switch ((string)commandParameter) {
|
|
case "Run": {
|
|
if (_SeqTeachingRun.RunState == SequenceRunState.Running) {
|
|
MessageUtil.ShowWarningToast(string.Format("이미 시퀀스가 Start 상태입니다.", "SeqTeachingRun"), Log);
|
|
return;
|
|
}
|
|
|
|
var param = new SeqTeachingRun_InitParam() {
|
|
UseStream = false,
|
|
IsObjectSelectAll = true,
|
|
UseBlow = false,
|
|
IntervalTimeBlowOn = 10,
|
|
IntervalTimeBlowOff = 10,
|
|
NeedSetLaserTiming = false,
|
|
};
|
|
|
|
IsSequenceRunning_SeqTeachingRun = true;
|
|
_SeqTeachingRun.Start(param, OnComplete_SeqTeachingRun);
|
|
}
|
|
break;
|
|
|
|
case "Stop": {
|
|
if (_SeqTeachingRun.RunState == SequenceRunState.Idle) {
|
|
return;
|
|
}
|
|
|
|
IsSequenceRunning_SeqTeachingRun = false;
|
|
_SeqTeachingRun.Stop();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnComplete_SeqTeachingRun(SequenceActionResult res)
|
|
{
|
|
if (res != null) {
|
|
if (res.Param is SeqTeachingRun_OutParam result && result.Success == true) {
|
|
IsSequenceRunning_SeqTeachingRun = false;
|
|
MessageUtil.ShowSuccessToast(string.Format("Success SeqTeachingRun"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
IsSequenceRunning_SeqTeachingRun = false;
|
|
MessageUtil.ShowWarningToast(string.Format("Fail SeqTeachingRun"));
|
|
}
|
|
|
|
}
|
|
}
|