682 lines
22 KiB
C#
682 lines
22 KiB
C#
using CommunityToolkit.Mvvm.ComponentModel;
|
|
using HMIToolkit;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using Heisig.HMI.AdsManager;
|
|
using CommunityToolkit.Mvvm.Input;
|
|
using TwinCAT.TypeSystem;
|
|
using System.Collections.ObjectModel;
|
|
using System.Security.Policy;
|
|
using System.Printing;
|
|
using System.Windows;
|
|
using Common;
|
|
using InfineonHMI.Model;
|
|
|
|
namespace InfineonHMI;
|
|
|
|
public sealed partial class KukaRobotPageVM : ObservableValidator, IDisposable
|
|
{
|
|
|
|
private const string sStartRobotJob = "_adsVariable_kukaStartRobotJob";
|
|
private const string sAbortRobotJob = "_adsVariable_kukaAbortRobotJob";
|
|
private const string sResetState = "_adsVariable_kukaResetState";
|
|
private const string sClearState = "_adsVariable_kukaClearState";
|
|
private const string sAcknPLCJob = "_adsVariable_kukaAcknPLCJob";
|
|
private const string sCoolplateIndex = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.byPlaceOnCoolPlate";
|
|
private const string sHotplateIndex = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.byPlaceOnHotPlate";
|
|
private const string sPieceThickness = "_adsVariable_kukaPieceThickness";
|
|
private const string sJobGrippSide = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.byGripperNumber";
|
|
private const string sJobGrippType = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.byGripperNumber";
|
|
private const string sChuckMagazinPlace = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.byChuckNumber";
|
|
private const string sSelectedRobotJob = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.eJob";
|
|
private const string sActiveRobotJob = "_adsVariable_kukaActiveRobotJob";
|
|
private const string sFinishedRobotJob = "_adsVariable_kukaFinishedRobotJob";
|
|
private const string sSelectedPLCJob = "_adsVariable_kukaPLCJob";
|
|
private const string sOffsetPick_X = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosX";
|
|
private const string sOffsetPick_Y = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosY";
|
|
private const string sOffsetPlace_X = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosX";
|
|
private const string sOffsetPlace_Y = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosY";
|
|
private const string sOffsetNIOPick_X = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosX";
|
|
private const string sOffsetNIOPick_Y = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosY";
|
|
private const string sOffsetNIOPlace_X = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosX";
|
|
private const string sOffsetNIOPlace_Y = "GVL_SCADA.stMachine.stKukaRobot.stJobParams.rPosY";
|
|
|
|
|
|
private BMSControlModeEntry currentControlMode;
|
|
public BMSControlModeEntry CurrentControlMode
|
|
{
|
|
get { return currentControlMode; }
|
|
set
|
|
{
|
|
currentControlMode = value;
|
|
ccmChanged();
|
|
}
|
|
}
|
|
private E_BMS_CONTROL_MODE bmsControlMode;
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeRobotJob;
|
|
|
|
[ObservableProperty]
|
|
private RobotJobentry robotJobActiveValue;
|
|
|
|
[ObservableProperty]
|
|
private RobotJobentry robotJobFinishedValue;
|
|
|
|
[ObservableProperty]
|
|
private bool canStartRobotJob;
|
|
|
|
[ObservableProperty]
|
|
private HMIControlButtonVM? startButton;
|
|
|
|
[ObservableProperty]
|
|
private bool canAbortRobotJob;
|
|
|
|
[ObservableProperty]
|
|
private HMIControlButtonVM? abortButton;
|
|
|
|
private const string sChuckOnPlace1 = "_adsVariable_MagazinPlace1";
|
|
private const string sChuckOnPlace2 = "_adsVariable_MagazinPlace2";
|
|
private const string sChuckOnPlace3 = "_adsVariable_MagazinPlace3";
|
|
private const string sChuckOnPlace4 = "_adsVariable_MagazinPlace4";
|
|
private const string sChuckOnPlace5 = "_adsVariable_MagazinPlace5";
|
|
private const string sChuckOnPlace6 = "_adsVariable_MagazinPlace6";
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace1;
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace2;
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace3;
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace4;
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace5;
|
|
|
|
[ObservableProperty]
|
|
private Visibility magazinPlace6;
|
|
|
|
private int jobGrippSide;
|
|
public int JobGrippSide
|
|
{
|
|
get { return jobGrippSide; }
|
|
set
|
|
{
|
|
SetProperty(ref jobGrippSide, value);
|
|
_adsManager?.WriteValue(sJobGrippSide, value);
|
|
}
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeJobGrippSide;
|
|
|
|
|
|
private int jobGrippType;
|
|
public int JobGrippType
|
|
{
|
|
get { return jobGrippType; }
|
|
set
|
|
{
|
|
SetProperty(ref jobGrippType, value);
|
|
_adsManager?.WriteValue(sJobGrippType, value);
|
|
|
|
}
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeJobGrippType;
|
|
|
|
|
|
private int chuckMagazinPlace;
|
|
public int ChuckMagazinPlace
|
|
{
|
|
get { return chuckMagazinPlace; }
|
|
set
|
|
{
|
|
SetProperty(ref chuckMagazinPlace, value);
|
|
_adsManager?.WriteValue(sChuckMagazinPlace, value);
|
|
}
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeChuckMagazinPlace;
|
|
|
|
|
|
private double pieceThickness;
|
|
public double PieceThickness
|
|
{
|
|
get { return pieceThickness; }
|
|
set
|
|
{
|
|
SetProperty(ref pieceThickness, value);
|
|
_adsManager?.WriteValue(sPieceThickness, value);
|
|
}
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private bool canChangePieceThickness;
|
|
|
|
|
|
private double offsetPick_X;
|
|
public double OffsetPick_X
|
|
{
|
|
get { return offsetPick_X; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetPick_X, value);
|
|
_adsManager?.WriteValue(sOffsetPick_X, value);
|
|
}
|
|
}
|
|
|
|
|
|
private double offsetPick_Y;
|
|
public double OffsetPick_Y
|
|
{
|
|
get { return offsetPick_Y; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetPick_Y, value);
|
|
_adsManager?.WriteValue(sOffsetPick_Y, value);
|
|
}
|
|
}
|
|
[ObservableProperty]
|
|
private bool canChangeOffsetPick;
|
|
|
|
|
|
private double offsetPlace_X;
|
|
public double OffsetPlace_X
|
|
{
|
|
get { return offsetPlace_X; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetPlace_X, value);
|
|
_adsManager?.WriteValue(sOffsetPlace_X, value);
|
|
}
|
|
}
|
|
|
|
private double offsetPlace_Y;
|
|
public double OffsetPlace_Y
|
|
{
|
|
get { return offsetPlace_Y; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetPlace_Y, value);
|
|
_adsManager?.WriteValue(sOffsetPlace_Y, value);
|
|
}
|
|
}
|
|
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeOffsetPlace;
|
|
|
|
|
|
private double offsetNIOPick_X;
|
|
public double OffsetNIOPick_X
|
|
{
|
|
get { return offsetNIOPick_X; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetNIOPick_X, value);
|
|
_adsManager?.WriteValue(sOffsetNIOPick_X, value);
|
|
}
|
|
}
|
|
|
|
private double offsetNIOPick_Y;
|
|
public double OffsetNIOPick_Y
|
|
{
|
|
get { return offsetNIOPick_Y; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetNIOPick_Y, value);
|
|
_adsManager?.WriteValue(sOffsetNIOPick_Y, value);
|
|
}
|
|
}
|
|
[ObservableProperty]
|
|
private bool canChangeOffsetNIOPick;
|
|
|
|
|
|
private double offsetNIOPlace_X;
|
|
public double OffsetNIOPlace_X
|
|
{
|
|
get { return offsetNIOPlace_X; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetNIOPlace_X, value);
|
|
_adsManager?.WriteValue(sOffsetNIOPlace_X, value);
|
|
}
|
|
}
|
|
|
|
private double offsetNIOPlace_Y;
|
|
public double OffsetNIOPlace_Y
|
|
{
|
|
get { return offsetNIOPlace_Y; }
|
|
set
|
|
{
|
|
SetProperty(ref offsetNIOPlace_Y, value);
|
|
_adsManager?.WriteValue(sOffsetNIOPlace_Y, value);
|
|
}
|
|
}
|
|
[ObservableProperty]
|
|
private bool canChangeOffsetNIOPlace;
|
|
|
|
|
|
private int hotplateIndex;
|
|
public int HotplateIndex
|
|
{
|
|
get { return hotplateIndex; }
|
|
set
|
|
{
|
|
SetProperty(ref hotplateIndex, value);
|
|
_adsManager?.WriteValue(sHotplateIndex, value);
|
|
}
|
|
|
|
|
|
}
|
|
[ObservableProperty]
|
|
private bool canChangeHotPlateIndex;
|
|
|
|
|
|
private int coolplateIndex;
|
|
public int CoolplateIndex
|
|
{
|
|
get { return coolplateIndex; }
|
|
set
|
|
{
|
|
SetProperty(ref coolplateIndex, value);
|
|
_adsManager?.WriteValue(sCoolplateIndex, value);
|
|
}
|
|
}
|
|
|
|
[ObservableProperty] private PackMLControlVM kukaRobotPackMLControlVm;
|
|
|
|
[ObservableProperty]
|
|
private bool canChangeCoolPlateIndex;
|
|
|
|
[ObservableProperty]
|
|
private RobotJobenum robotJob;
|
|
|
|
[ObservableProperty]
|
|
private ObservableCollection<RobotJobentry> robotJobs =
|
|
[
|
|
new RobotJobentry(RobotJobenum.NONE, " ------- "),
|
|
new RobotJobentry(RobotJobenum.PICK_TRAYFEEDER, "10 - Hole Teil von Trayfeeder 'Eingabe' "),
|
|
new RobotJobentry(RobotJobenum.PLACE_TRAYFEEDER, "11 - Lege Teil in Trayfeeder 'Ausgabe' "),
|
|
new RobotJobentry(RobotJobenum.PUT_ALIGNMENT, "15 - Lege Teil auf Ausrichtstation"),
|
|
new RobotJobentry(RobotJobenum.PICK_ALIGNMENT, "16 - Hole Teil von Ausrichtstation"),
|
|
new RobotJobentry(RobotJobenum.PUT_ETCHER_1, "20 - Lege Teil in Ätzer 1"),
|
|
new RobotJobentry(RobotJobenum.PUT_ETCHER_2, "21 - Lege Teil in Ätzer 2"),
|
|
new RobotJobentry(RobotJobenum.PICK_ETCHER_1, "22 - Hole Teil aus Ätzer 1"),
|
|
new RobotJobentry(RobotJobenum.PICK_ETCHER_2, "23 - Hole Teil aus Ätzer 2"),
|
|
new RobotJobentry(RobotJobenum.SWITCH_ETCHER_1, "24 - Tausche Teile in Ätzer 1"),
|
|
new RobotJobentry(RobotJobenum.SWITCH_ETCHER_2, "25 - Tausche Teile in Ätzer 2"),
|
|
new RobotJobentry(RobotJobenum.PUT_HVTEST_HOT, "30 - Lege Teil in HV-Teststation Warm"),
|
|
new RobotJobentry(RobotJobenum.PUT_HVTEST_COLD, "31 - Lege Teil in HV-Teststation Kalt"),
|
|
new RobotJobentry(RobotJobenum.PICK_HVTEST_HOT, "32 - Hole Teil aus HV-Teststation Warm"),
|
|
new RobotJobentry(RobotJobenum.PICK_HVTEST_COLD, "33 - Hole Teil aus HV-Teststation Kalt"),
|
|
new RobotJobentry(RobotJobenum.PUT_HOTPLATE, "40 - Lege Teil auf Heizplatte"),
|
|
new RobotJobentry(RobotJobenum.PICK_HOTPLATE, "41 - Hole Teil von Heizplatte"),
|
|
new RobotJobentry(RobotJobenum.PUT_COOLPLATE, "42 - Lege Teil auf Kühlplatte"),
|
|
new RobotJobentry(RobotJobenum.PICK_COOLPLATE, "43 - Hole Teil von Kühlplatte"),
|
|
new RobotJobentry(RobotJobenum.PICK_GRIPPER, "50 - Hole anderen Greifertyp"),
|
|
new RobotJobentry(RobotJobenum.PICK_CHUCK_ETCHER_1, "60 - Hole Drehteller aus Ätzer 1"),
|
|
new RobotJobentry(RobotJobenum.PICK_CHUCK_ETCHER_2, "61 - Hole Drehteller aus Ätzer 2"),
|
|
new RobotJobentry(RobotJobenum.PUT_CHUCK_ETCHER_1, "62 - Lege Drehteller in Ätzer 1"),
|
|
new RobotJobentry(RobotJobenum.PUT_CHUCK_ETCHER_2, "63 - Lege Drehteller in Ätzer 2"),
|
|
new RobotJobentry(RobotJobenum.PUT_CHUCK_MAGAZIN, "64 - Lege Drehteller in Magazin"),
|
|
new RobotJobentry(RobotJobenum.PICK_CHUCK_MAGAZIN, "65 - Hole Drehteller von Magazin"),
|
|
new RobotJobentry(RobotJobenum.PUT_NIO_STATION, "70 - Lege Teil auf NIO-TRAY"),
|
|
new RobotJobentry(RobotJobenum.PICK_NIO_STATION, "71 - Hole Teil von NIO-TRAY"),
|
|
new RobotJobentry(RobotJobenum.WARMUP, "80 - Aufwärmprogramm")
|
|
];
|
|
|
|
[ObservableProperty]
|
|
private ObservableCollection<PLCJobentry> pLCJobs =
|
|
[
|
|
new PLCJobentry(PLCJobenum.NONE, " ------- "),
|
|
new PLCJobentry(PLCJobenum.SCAN_QR_CODE, "10 - QR Code Scannen"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_ON_ALIGNER, "15 - Vakuum Ausrichtstation einschalten"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_OFF_ALIGNER, "16 - Vakuum Ausrichtstation ausschalten"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_ON_ETCHER_1, "20 - Vakuum Ätzer 1 einschalten"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_ON_ETCHER_2, "21 - Vakuum Ätzer 2 einschalten"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_OFF_ETCHER_1, "22 - Vakuum Ätzer 1 ausschalten"),
|
|
new PLCJobentry(PLCJobenum.VACUUM_OFF_ETCHER_2, "23 - Vakuum Ätzer 2 ausschalten"),
|
|
new PLCJobentry(PLCJobenum.CHUCK_OPEN_ETCHER_1, "60 - Drehteller Ätzer 1 entriegeln"),
|
|
new PLCJobentry(PLCJobenum.CHUCK_OPEN_ETCHER_2, "61 - Drehteller Ätzer 2 entriegeln"),
|
|
new PLCJobentry(PLCJobenum.CHUCK_CLOSE_ETCHER_1, "62 - Drehteller Ätzer 1 verriegeln"),
|
|
new PLCJobentry(PLCJobenum.CHUCK_CLOSE_ETCHER_2, "63 - Drehteller Ätzer 2 verriegeln"),
|
|
];
|
|
|
|
private RobotJobentry selectedRobotJob;
|
|
public RobotJobentry SelectedRobotJob
|
|
{
|
|
get { return selectedRobotJob; }
|
|
set
|
|
{
|
|
SetProperty(ref selectedRobotJob, value);
|
|
CanChangeChuckMagazinPlace = (value == RobotJobs.First(i => i.eJob == RobotJobenum.PICK_CHUCK_MAGAZIN))
|
|
|| (value == RobotJobs.First(i => i.eJob == RobotJobenum.PUT_CHUCK_MAGAZIN));
|
|
CanChangeJobGrippType = value == RobotJobs.First(i => i.eJob == RobotJobenum.PICK_GRIPPER);
|
|
|
|
_adsManager?.WriteValue(sSelectedRobotJob, SelectedRobotJob.eJob);
|
|
}
|
|
}
|
|
|
|
[ObservableProperty]
|
|
private PLCJobentry selectedPLCJob;
|
|
|
|
|
|
private readonly IAdsManager? _adsManager;
|
|
|
|
public KukaRobotPageVM()
|
|
{
|
|
StartButton = new HMIControlButtonVM();
|
|
AbortButton = new HMIControlButtonVM();
|
|
selectedRobotJob = RobotJobs.First(i => i.eJob == RobotJobenum.WARMUP);
|
|
robotJobActiveValue = RobotJobs.First(i => i.eJob == RobotJobenum.PUT_HVTEST_COLD);
|
|
robotJobFinishedValue = RobotJobs.First(i => i.eJob == RobotJobenum.PICK_HOTPLATE);
|
|
selectedPLCJob = PLCJobs.First(i => i.eJob == PLCJobenum.NONE);
|
|
|
|
canChangeRobotJob = true;currentControlMode = new BMSControlModeEntry(E_BMS_CONTROL_MODE.MANUAL, "Manual");
|
|
KukaRobotPackMLControlVm = new PackMLControlVM();
|
|
|
|
KukaRobotPackMLControlVm.STitle = "Kuka Roboter";
|
|
}
|
|
|
|
public KukaRobotPageVM(IAdsManager adsManager)
|
|
{
|
|
_adsManager = adsManager;
|
|
|
|
StartButton = new HMIControlButtonVM(_adsManager, sStartRobotJob);
|
|
AbortButton = new HMIControlButtonVM(_adsManager, sAbortRobotJob);
|
|
currentControlMode = new BMSControlModeEntry(E_BMS_CONTROL_MODE.MANUAL, "Manual");
|
|
CurrentControlMode = new BMSControlModeEntry(E_BMS_CONTROL_MODE.MANUAL, "Manual");
|
|
|
|
selectedRobotJob = RobotJobs.First(i => i.eJob == RobotJobenum.NONE);
|
|
robotJobActiveValue = RobotJobs.First(i => i.eJob == RobotJobenum.NONE);
|
|
robotJobFinishedValue = RobotJobs.First(i => i.eJob == RobotJobenum.NONE);
|
|
selectedPLCJob = PLCJobs.First(i => i.eJob == PLCJobenum.NONE);
|
|
|
|
|
|
KukaRobotPackMLControlVm = new PackMLControlVM(_adsManager, "GVL_SCADA.stMachine.stKukaRobot.stStationCmds");
|
|
|
|
KukaRobotPackMLControlVm.STitle = "Kuka Roboter";
|
|
|
|
_adsManager.Register(sJobGrippSide, OnJobGrippSideValueChanged);
|
|
_adsManager.Register(sJobGrippType, OnJobGrippTypeValueChanged);
|
|
_adsManager.Register(sChuckMagazinPlace, OnChuckMagazinPlaceValueChanged);
|
|
_adsManager.Register(sPieceThickness, OnPieceThicknessValueChanged);
|
|
_adsManager.Register(sSelectedPLCJob, OnSelectedPLCJobValueChanged);
|
|
_adsManager.Register(sSelectedRobotJob, OnSelectedRobotJobValueChanged);
|
|
_adsManager.Register(sActiveRobotJob, OnActiveRobotJobValueChanged);
|
|
_adsManager.Register(sFinishedRobotJob, OnFinishedRobotJobValueChanged);
|
|
_adsManager.Register(sOffsetPick_X, OnOffsetPickXValueChanged);
|
|
_adsManager.Register(sOffsetPick_Y, OnOffsetPickYValueChanged);
|
|
_adsManager.Register(sCoolplateIndex, OnCoolPlateIndexValueChanged);
|
|
_adsManager.Register(sHotplateIndex, OnHotPlateIndexValueChanged);
|
|
_adsManager.Register(sOffsetNIOPlace_Y, OnOffsetNIOPlaceYValueChanged);
|
|
_adsManager.Register(sOffsetNIOPlace_X, OnOffsetNIOPlaceXValueChanged);
|
|
_adsManager.Register(sOffsetNIOPick_Y, OnOffsetNIOPickYValueChanged);
|
|
_adsManager.Register(sOffsetNIOPick_X, OnOffsetNIOPickXValueChanged);
|
|
_adsManager.Register(sOffsetPlace_Y, OnOffsetPlaceYValueChanged);
|
|
_adsManager.Register(sOffsetPlace_X, OnOffsetPlaceXValueChanged);
|
|
|
|
_adsManager.Register(sChuckOnPlace1, ChuckOnPlace1Changed);
|
|
_adsManager.Register(sChuckOnPlace2, ChuckOnPlace2Changed);
|
|
_adsManager.Register(sChuckOnPlace3, ChuckOnPlace3Changed);
|
|
_adsManager.Register(sChuckOnPlace4, ChuckOnPlace4Changed);
|
|
_adsManager.Register(sChuckOnPlace5, ChuckOnPlace5Changed);
|
|
_adsManager.Register(sChuckOnPlace6, ChuckOnPlace6Changed);
|
|
|
|
canChangeRobotJob = true;
|
|
canChangeJobGrippType = false;
|
|
|
|
canChangeChuckMagazinPlace = false;
|
|
canChangeJobGrippType = false;
|
|
|
|
_adsManager.Register("GVL_SCADA.eCurrentControlMode", CurrentControlModeChanged);
|
|
|
|
}
|
|
|
|
private void OnJobGrippSideValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
JobGrippSide = (byte)e.Value;
|
|
}
|
|
private void OnJobGrippTypeValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
JobGrippType = (byte)e.Value;
|
|
}
|
|
private void OnChuckMagazinPlaceValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
ChuckMagazinPlace = (byte)e.Value;
|
|
}
|
|
private void OnPieceThicknessValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
PieceThickness = (int)e.Value;
|
|
}
|
|
private void OnSelectedPLCJobValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
SelectedPLCJob = PLCJobs.First(i => (ushort)i.eJob == (ushort)e.Value);
|
|
}
|
|
private void OnSelectedRobotJobValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
SelectedRobotJob = RobotJobs.First(i => (ushort)i.eJob == (ushort)e.Value);
|
|
}
|
|
private void OnActiveRobotJobValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
RobotJobActiveValue = RobotJobs.First(i => (ushort)i.eJob == (ushort)e.Value);
|
|
}
|
|
private void OnFinishedRobotJobValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
RobotJobFinishedValue = RobotJobs.First(i => (ushort)i.eJob == (ushort)e.Value);
|
|
}
|
|
private void OnHotPlateIndexValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
HotplateIndex = (byte)e.Value;
|
|
}
|
|
private void OnCoolPlateIndexValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
CoolplateIndex = (byte)e.Value;
|
|
}
|
|
private void OnOffsetPickXValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetPick_X = (float)e.Value;
|
|
}
|
|
private void OnOffsetPickYValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetPick_Y = (float)e.Value;
|
|
}
|
|
private void OnOffsetPlaceXValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetPlace_X = (float)e.Value;
|
|
}
|
|
private void OnOffsetPlaceYValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetPlace_Y = (float)e.Value;
|
|
}
|
|
private void OnOffsetNIOPickXValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetNIOPick_X = (float)e.Value;
|
|
}
|
|
private void OnOffsetNIOPickYValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetNIOPick_Y = (float)e.Value;
|
|
}
|
|
private void OnOffsetNIOPlaceXValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetNIOPlace_X = (float)e.Value;
|
|
}
|
|
private void OnOffsetNIOPlaceYValueChanged(object sender, ValueChangedEventArgs e)
|
|
{
|
|
OffsetNIOPlace_Y = (float)e.Value;
|
|
}
|
|
|
|
private void ChuckOnPlace1Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace1 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace1 = Visibility.Hidden;
|
|
}
|
|
}
|
|
private void ChuckOnPlace2Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace2 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace2 = Visibility.Hidden;
|
|
}
|
|
}
|
|
private void ChuckOnPlace3Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace3 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace3 = Visibility.Hidden;
|
|
}
|
|
}
|
|
private void ChuckOnPlace4Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace4 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace4 = Visibility.Hidden;
|
|
}
|
|
}
|
|
private void ChuckOnPlace5Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace5 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace5 = Visibility.Hidden;
|
|
}
|
|
}
|
|
private void ChuckOnPlace6Changed(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
if ((bool)e.Value)
|
|
{
|
|
MagazinPlace6 = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
MagazinPlace6 = Visibility.Hidden;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
StartButton?.Dispose();
|
|
StartButton = null;
|
|
AbortButton?.Dispose();
|
|
AbortButton = null;
|
|
|
|
_adsManager?.Deregister(sJobGrippSide, OnJobGrippSideValueChanged);
|
|
_adsManager?.Deregister(sJobGrippType, OnJobGrippTypeValueChanged);
|
|
_adsManager?.Deregister(sChuckMagazinPlace, OnChuckMagazinPlaceValueChanged);
|
|
_adsManager?.Deregister(sPieceThickness, OnPieceThicknessValueChanged);
|
|
_adsManager?.Deregister(sSelectedPLCJob, OnSelectedPLCJobValueChanged);
|
|
_adsManager?.Deregister(sSelectedRobotJob, OnSelectedRobotJobValueChanged);
|
|
_adsManager?.Deregister(sActiveRobotJob, OnActiveRobotJobValueChanged);
|
|
_adsManager?.Deregister(sFinishedRobotJob, OnFinishedRobotJobValueChanged);
|
|
_adsManager?.Deregister(sOffsetPick_X, OnOffsetPickXValueChanged);
|
|
_adsManager?.Deregister(sOffsetPick_Y, OnOffsetPickYValueChanged);
|
|
_adsManager?.Deregister(sCoolplateIndex, OnCoolPlateIndexValueChanged);
|
|
_adsManager?.Deregister(sHotplateIndex, OnHotPlateIndexValueChanged);
|
|
_adsManager?.Deregister(sOffsetNIOPlace_Y, OnOffsetNIOPlaceYValueChanged);
|
|
_adsManager?.Deregister(sOffsetNIOPlace_X, OnOffsetNIOPlaceXValueChanged);
|
|
_adsManager?.Deregister(sOffsetNIOPick_Y, OnOffsetNIOPickYValueChanged);
|
|
_adsManager?.Deregister(sOffsetNIOPick_X, OnOffsetNIOPickXValueChanged);
|
|
_adsManager?.Deregister(sOffsetPlace_Y, OnOffsetPlaceYValueChanged);
|
|
_adsManager?.Deregister(sOffsetPlace_X, OnOffsetPlaceXValueChanged);
|
|
|
|
_adsManager?.Deregister(sChuckOnPlace1, ChuckOnPlace1Changed);
|
|
_adsManager?.Deregister(sChuckOnPlace2, ChuckOnPlace2Changed);
|
|
_adsManager?.Deregister(sChuckOnPlace3, ChuckOnPlace3Changed);
|
|
_adsManager?.Deregister(sChuckOnPlace4, ChuckOnPlace4Changed);
|
|
_adsManager?.Deregister(sChuckOnPlace5, ChuckOnPlace5Changed);
|
|
_adsManager?.Deregister(sChuckOnPlace6, ChuckOnPlace6Changed);
|
|
|
|
_adsManager?.Deregister("GVL_SCADA.eCurrentControlMode", CurrentControlModeChanged);
|
|
|
|
}
|
|
|
|
private void CurrentControlModeChanged(object? sender, ValueChangedEventArgs e)
|
|
{
|
|
bmsControlMode = (E_BMS_CONTROL_MODE)e.Value;
|
|
currentControlMode.eMode = bmsControlMode;
|
|
currentControlMode.Name = "Test";
|
|
ccmChanged();
|
|
|
|
}
|
|
|
|
private void ccmChanged()
|
|
{
|
|
if (currentControlMode.eMode == E_BMS_CONTROL_MODE.MANUAL)
|
|
{
|
|
CanChangeCoolPlateIndex = true;
|
|
CanChangeHotPlateIndex = true;
|
|
CanChangeOffsetNIOPick = true;
|
|
CanChangeOffsetNIOPlace = true;
|
|
CanChangeOffsetPick = true;
|
|
CanChangeOffsetPlace = true;
|
|
CanChangePieceThickness = true;
|
|
CanChangeRobotJob = true;
|
|
CanChangeJobGrippSide = true;
|
|
|
|
}
|
|
else
|
|
{
|
|
CanChangeCoolPlateIndex = false;
|
|
CanChangeHotPlateIndex = false;
|
|
CanChangeOffsetNIOPick = false;
|
|
CanChangeOffsetNIOPlace = false;
|
|
CanChangeOffsetPick = false;
|
|
CanChangeOffsetPlace = false;
|
|
CanChangePieceThickness = false;
|
|
CanChangeRobotJob = false;
|
|
CanChangeJobGrippSide = false;
|
|
}
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void ClearState()
|
|
{
|
|
_adsManager?.WriteValue(sClearState, true);
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void ResetState()
|
|
{
|
|
_adsManager?.WriteValue(sResetState, true);
|
|
}
|
|
|
|
[RelayCommand]
|
|
private void StartRobotJob()
|
|
{
|
|
_adsManager?.WriteValue(sStartRobotJob, true);
|
|
}
|
|
|
|
|
|
[RelayCommand]
|
|
private void AbortRobotJob()
|
|
{
|
|
_adsManager?.WriteValue(sAbortRobotJob, true);
|
|
}
|
|
} |