841 lines
39 KiB
C#
841 lines
39 KiB
C#
using Aurora;
|
|
using Aurora.Api;
|
|
using Aurora.View;
|
|
using System;
|
|
using System.Windows;
|
|
using System.Windows.Input;
|
|
using System.Windows.Threading;
|
|
using static AuroraTriggerBoard.Trigger;
|
|
|
|
namespace AuroraTriggerBoard.SJTV3
|
|
{
|
|
public class UCTriggerBoardV3ViewModel : NotifyPropertyChangedBase
|
|
{
|
|
Aurora.Api.Logger Log = new Aurora.Api.Logger("Trigger Board");
|
|
|
|
public ICommand CMD_ViewLoaded { get; }
|
|
public ICommand CMD_ViewUnloaded { get; }
|
|
public ICommand CMD_GetEncoderEnable { get; }
|
|
public ICommand CMD_SetEncoderEnable { get; private set; }
|
|
public ICommand CMD_GetRunMode { get; }
|
|
public ICommand CMD_SetRunMode { get; private set; }
|
|
public ICommand CMD_GetEncoderDir { get; }
|
|
public ICommand CMD_SetEncoderDir { get; private set; }
|
|
public ICommand CMD_GetInputPolarity { get; }
|
|
public ICommand CMD_SetInputPolarity { get; private set; }
|
|
public ICommand CMD_GetTriggerPolarity { get; }
|
|
public ICommand CMD_SetTriggerPolarity { get; private set; }
|
|
public ICommand CMD_GetStrobePolarity { get; }
|
|
public ICommand CMD_SetStrobePolarity { get; private set; }
|
|
public ICommand CMD_GetTriggerStartDelay { get; }
|
|
public ICommand CMD_SetTriggerStartDelay { get; private set; }
|
|
public ICommand CMD_GetTriggerWidth { get; }
|
|
public ICommand CMD_SetTriggerWidth { get; private set; }
|
|
public ICommand CMD_GetTriggerCount { get; }
|
|
public ICommand CMD_SetTriggerCount { get; private set; }
|
|
public ICommand CMD_GetTriggerPulse { get; }
|
|
public ICommand CMD_SetTriggerPulse { get; private set; }
|
|
public ICommand CMD_GetStrobeStartDelay { get; }
|
|
public ICommand CMD_SetStrobeStartDelay { get; private set; }
|
|
public ICommand CMD_GetStrobeWidth { get; }
|
|
public ICommand CMD_SetStrobeWidth { get; private set; }
|
|
public ICommand CMD_GetEndTrig { get; }
|
|
public ICommand CMD_TriggerStop { get; private set; }
|
|
public ICommand CMD_TriggerStart { get; private set; }
|
|
public ICommand CMD_SetStrobe { get; private set; }
|
|
public ICommand CMD_GetEncoderCnt { get; private set; }
|
|
public ICommand CMD_ResetEncoderCount { get; private set; }
|
|
public ICommand CMD_SetEncoderCount { get; private set; }
|
|
public ICommand CMD_ResetSystem { get; private set; }
|
|
public ICommand CMD_ResetTrigger { get; private set; }
|
|
public ICommand CMD_DebugMessageClear { get; private set; }
|
|
|
|
private readonly DispatcherTimer MonitorTimer;
|
|
internal AuroraTriggerBoard.Trigger _Trigger;
|
|
|
|
public bool IsFirst = false;
|
|
public UCTriggerBoardV3ViewModel(Device device)
|
|
{
|
|
_Trigger = device as AuroraTriggerBoard.Trigger;
|
|
|
|
CMD_ViewLoaded = new DelegateCommand(Loaded);
|
|
CMD_ViewUnloaded = new DelegateCommand(Unloaded);
|
|
|
|
//CMD_CheckTeachingMode = new DelegateCommand(PerformCMD_CheckTeachingMode);
|
|
//CMD_Setting = new DelegateCommand(PerformCMD_Setting);
|
|
CMD_TriggerStop = new DelegateCommand(PerformCMD_TriggerStop);
|
|
CMD_TriggerStart = new DelegateCommand(PerformCMD_TriggerStart);
|
|
CMD_SetStrobe = new DelegateCommand(PerformCMD_SetStrobe);
|
|
CMD_GetEncoderCnt = new DelegateCommand(PerformCMD_GetEncoderCnt);
|
|
CMD_ResetEncoderCount = new DelegateCommand(PerformCMD_ResetEncoderCount);
|
|
CMD_SetEncoderCount = new DelegateCommand(PerformCMD_SetEncoderCount);
|
|
CMD_ResetSystem = new DelegateCommand(PerformCMD_ResetSystem);
|
|
|
|
CMD_GetEncoderEnable = new DelegateCommand(PerformCMD_GetEncoderEnable);
|
|
CMD_SetEncoderEnable = new DelegateCommand(PerformCMD_SetEncoderEnable);
|
|
CMD_GetRunMode = new DelegateCommand(PerformCMD_GetRunMode);
|
|
CMD_SetRunMode = new DelegateCommand(PerformCMD_SetRunMode);
|
|
CMD_GetEncoderDir = new DelegateCommand(PerformCMD_GetEncoderDir);
|
|
CMD_SetEncoderDir = new DelegateCommand(PerformCMD_SetEncoderDir);
|
|
CMD_GetInputPolarity = new DelegateCommand(PerformCMD_GetInputPolarity);
|
|
CMD_SetInputPolarity = new DelegateCommand(PerformCMD_SetInputPolarity);
|
|
CMD_GetTriggerPolarity = new DelegateCommand(PerformCMD_GetTriggerPolarity);
|
|
CMD_SetTriggerPolarity = new DelegateCommand(PerformCMD_SetTriggerPolarity);
|
|
CMD_GetStrobePolarity = new DelegateCommand(PerformCMD_GetStrobePolarity);
|
|
CMD_SetStrobePolarity = new DelegateCommand(PerformCMD_SetStrobePolarity);
|
|
CMD_GetTriggerStartDelay = new DelegateCommand(PerformCMD_GetTriggerStartDelay);
|
|
CMD_SetTriggerStartDelay = new DelegateCommand(PerformCMD_SetTriggerStartDelay);
|
|
CMD_GetTriggerWidth = new DelegateCommand(PerformCMD_GetTriggerWidth);
|
|
CMD_SetTriggerWidth = new DelegateCommand(PerformCMD_SetTriggerWidth);
|
|
CMD_GetTriggerCount = new DelegateCommand(PerformCMD_GetTriggerCount);
|
|
CMD_SetTriggerCount = new DelegateCommand(PerformCMD_SetTriggerCount);
|
|
CMD_GetTriggerPulse = new DelegateCommand(PerformCMD_GetTriggerPulse);
|
|
CMD_SetTriggerPulse = new DelegateCommand(PerformCMD_SetTriggerPulse);
|
|
CMD_GetStrobeStartDelay = new DelegateCommand(PerformCMD_GetStrobeStartDelay);
|
|
CMD_SetStrobeStartDelay = new DelegateCommand(PerformCMD_SetStrobeStartDelay);
|
|
CMD_GetStrobeWidth = new DelegateCommand(PerformCMD_GetStrobeWidth);
|
|
CMD_SetStrobeWidth = new DelegateCommand(PerformCMD_SetStrobeWidth);
|
|
CMD_GetEndTrig = new DelegateCommand(PerformCMD_GetEndTrig);
|
|
CMD_ResetTrigger = new DelegateCommand(PerformCMD_ResetTrigger);
|
|
CMD_DebugMessageClear = new DelegateCommand(PerformCMD_DebugMessageClear);
|
|
|
|
MonitorTimer = new DispatcherTimer();
|
|
MonitorTimer.Tick += OnMonitoring;
|
|
MonitorTimer.Interval = TimeSpan.FromMilliseconds(1000);
|
|
|
|
IsFirst = true;
|
|
|
|
//EncoderEnableStatus = _Trigger._Config.EncEnable == true ? 1 : 0;
|
|
//TrigRunModeStatus = _Trigger._Config.RunMode;
|
|
//EncoderDirectionIndex = _Trigger._Config.EncDir == EncoderDirection.Forward ? 0 : 1;
|
|
//InputPolarityStatus = _Trigger._Config.Inputpol == true ? 0 : 1;
|
|
//TrigPolarityStatus = _Trigger._Config.Triggerpol == true ? 0 : 1;
|
|
//StrobePolarityStatus = _Trigger._Config.Strobepol == true ? 0 : 1;
|
|
//TrigStartDelayStatus = _Trigger._Config.triggercnt.ToString();
|
|
//TrigWidthStatus = _Trigger._Config.triggerwidth.ToString();
|
|
//TrigPulseStatus = _Trigger._Config.triggerpulse.ToString();
|
|
//StrobeStartDelayStatus = _Trigger._Config.triggercnt.ToString();
|
|
//StrobeWidthStatus = _Trigger._Config.triggerwidth.ToString();
|
|
|
|
var config = Application.Current.AuroraEnv().DeviceManager.GetDeviceConfig(device.DeviceId) as TriggerV3Config;
|
|
//var InsSetting = Application.Current.AuroraEnv().SettingEntry[SettingIds.Inspection] as InspectionSetting;
|
|
EncoderEnableStatus = config.EncEnable == true ? 1 : 0;
|
|
EncoderDirectionIndex = config.EncDir == EncoderDirection.Forward ? 0 : 1;
|
|
TrigRunModeStatus = config.RunMode;
|
|
InputPolarityStatus = config.Inputpol == true ? 1 : 0;
|
|
TrigPolarityStatus = config.Triggerpol == true ? 1 : 0;
|
|
StrobePolarityStatus = config.Strobepol == true ? 1 : 0;
|
|
TrigStartDelayStatus = config.StartDelay.ToString();
|
|
TrigWidthStatus = config.triggerwidth.ToString();
|
|
TriggerCountStatus = config.triggercnt.ToString();
|
|
TrigPulseStatus = config.triggerpulse.ToString();
|
|
StrobeStartDelayStatus = config.StrobeStartDelay.ToString();
|
|
StrobeWidthStatus = config.StrobeWidth.ToString();
|
|
//AuroraEnv.DeviceManager.SaveDeviceConfig(DeviceIds.TriggerBoardFDI);
|
|
}
|
|
|
|
private string hW_Ver;
|
|
|
|
public string HW_Ver { get => hW_Ver; set => SetProperty(ref hW_Ver, value); }
|
|
|
|
private string sW_Ver;
|
|
|
|
public string SW_Ver { get => sW_Ver; set => SetProperty(ref sW_Ver, value); }
|
|
|
|
private string dLL_Ver;
|
|
|
|
public string DLL_Ver { get => dLL_Ver; set => SetProperty(ref dLL_Ver, value); }
|
|
|
|
private void Unloaded(object obj)
|
|
{
|
|
//MonitorTimer.Stop();
|
|
}
|
|
|
|
private void Loaded(object obj)
|
|
{
|
|
//MonitorTimer.Start();
|
|
}
|
|
|
|
private void CheckVersionAndInitialize()
|
|
{
|
|
//_Trigger.ValueInit();
|
|
|
|
//string hw_ver, sw_ver, dll_ver;
|
|
//_Trigger.GetHWVersion(out hw_ver, out sw_ver);
|
|
//_Trigger.GetDllVersion(out dll_ver);
|
|
|
|
//HW_Ver = hw_ver;
|
|
//SW_Ver = sw_ver;
|
|
//DLL_Ver = dll_ver;
|
|
|
|
Timer_Set = 10000;
|
|
CheckedChannel1 = false;
|
|
CheckedChannel2 = false;
|
|
CheckedChannel3 = false;
|
|
CheckedChannel4 = false;
|
|
CheckedChannel5 = false;
|
|
CheckedChannel6 = false;
|
|
CheckedChannel7 = false;
|
|
CheckedChannel8 = false;
|
|
|
|
TableSettingIndex = 0;
|
|
EncoderInputByIndex = 0;
|
|
EncoderDirectionIndex = 0;
|
|
GeneratorModeIndex = 2;
|
|
ChOutputModeIndex = 0;
|
|
|
|
EncoderEnableStatus = 0;
|
|
TrigRunModeStatus = 0;
|
|
EncoderDirStatus = 0;
|
|
InputPolarityStatus = 0;
|
|
TrigPolarityStatus = 0;
|
|
StrobePolarityStatus = 0;
|
|
}
|
|
|
|
private void OnMonitoring(object sender, EventArgs e)
|
|
{
|
|
if (_Trigger.IsActivated) {
|
|
if (IsFirst == true) {
|
|
IsFirst = false;
|
|
CheckVersionAndInitialize();
|
|
}
|
|
}
|
|
}
|
|
|
|
private int encoderInputByIndex;
|
|
|
|
public int EncoderInputByIndex { get => encoderInputByIndex; set => SetProperty(ref encoderInputByIndex, value); }
|
|
|
|
private int tableSettingIndex;
|
|
|
|
public int TableSettingIndex { get => tableSettingIndex; set => SetProperty(ref tableSettingIndex, value); }
|
|
|
|
private int encoderDirectionIndex;
|
|
|
|
public int EncoderDirectionIndex { get => encoderDirectionIndex; set => SetProperty(ref encoderDirectionIndex, value); }
|
|
|
|
private int generatorModeIndex;
|
|
|
|
public int GeneratorModeIndex { get => generatorModeIndex; set => SetProperty(ref generatorModeIndex, value); }
|
|
|
|
private int chOutputModeIndex;
|
|
|
|
public int ChOutputModeIndex { get => chOutputModeIndex; set => SetProperty(ref chOutputModeIndex, value); }
|
|
|
|
private int encoderEnableSts;
|
|
public int EncoderEnableStatus { get => encoderEnableSts; set => SetProperty(ref encoderEnableSts, value); }
|
|
|
|
private int trigRunModeSts;
|
|
public int TrigRunModeStatus { get => trigRunModeSts; set => SetProperty(ref trigRunModeSts, value); }
|
|
|
|
private int encoderDirSts;
|
|
public int EncoderDirStatus { get => encoderDirSts; set => SetProperty(ref encoderDirSts, value); }
|
|
|
|
private int inputPolaritySts;
|
|
public int InputPolarityStatus { get => inputPolaritySts; set => SetProperty(ref inputPolaritySts, value); }
|
|
|
|
private int trigPolaritySts;
|
|
public int TrigPolarityStatus { get => trigPolaritySts; set => SetProperty(ref trigPolaritySts, value); }
|
|
|
|
private int strobePolaritySts;
|
|
public int StrobePolarityStatus { get => strobePolaritySts; set => SetProperty(ref strobePolaritySts, value); }
|
|
|
|
private string trigStartDelaySts;
|
|
public string TrigStartDelayStatus { get => trigStartDelaySts; set => SetProperty(ref trigStartDelaySts, value); }
|
|
|
|
private string trigWidthSts;
|
|
public string TrigWidthStatus { get => trigWidthSts; set => SetProperty(ref trigWidthSts, value); }
|
|
|
|
private string trigCountSts;
|
|
|
|
public string TriggerCountStatus { get => trigCountSts; set => SetProperty(ref trigCountSts, value); }
|
|
|
|
private string trigPulseSts;
|
|
public string TrigPulseStatus { get => trigPulseSts; set => SetProperty(ref trigPulseSts, value); }
|
|
|
|
private string strobeStartDelaySts;
|
|
public string StrobeStartDelayStatus { get => strobeStartDelaySts; set => SetProperty(ref strobeStartDelaySts, value); }
|
|
|
|
private string strobeWidthSts;
|
|
public string StrobeWidthStatus { get => strobeWidthSts; set => SetProperty(ref strobeWidthSts, value); }
|
|
|
|
private string endTrigSts;
|
|
public string EndTrigStatus { get => endTrigSts; set => SetProperty(ref endTrigSts, value); }
|
|
|
|
private void PerformCMD_GetEncoderEnable(object obj)
|
|
{
|
|
byte encoderEnable=0;
|
|
ushort ret = _Trigger.GetEncEnable(ref encoderEnable);
|
|
EncoderEnableStatus = encoderEnable;
|
|
DebugMessageString = String.Format("PerformCMD_GetEncoderEnable Ret : {0:x} {1:d}", ret, encoderEnable);
|
|
}
|
|
|
|
private void PerformCMD_SetEncoderEnable(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetEncEnable(Convert.ToByte(EncoderEnableStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetEncoderEnable Ret : {0:x}", ret);
|
|
}
|
|
|
|
private void PerformCMD_GetRunMode(object obj)
|
|
{
|
|
byte runMode = 0;
|
|
ushort ret = _Trigger.GetRunMode(ref runMode);
|
|
TrigRunModeStatus = runMode;
|
|
DebugMessageString = String.Format("PerformCMD_GetRunMode Ret : {0:x} {1:d}", ret, runMode);
|
|
}
|
|
private void PerformCMD_SetRunMode(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetRunMode(Convert.ToByte(TrigRunModeStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetRunMode Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetEncoderDir(object obj)
|
|
{
|
|
AuroraTriggerBoard.Trigger.EncoderDirection EncoderDir = 0;
|
|
ushort ret = _Trigger.GetEncoderDirection(out EncoderDir);
|
|
EncoderDirectionIndex = (int)EncoderDir;
|
|
DebugMessageString = String.Format("PerformCMD_GetEncoderDir Ret : {0:x} {1:d}", ret, EncoderDir);
|
|
}
|
|
private void PerformCMD_SetEncoderDir(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetEncoderDirection((AuroraTriggerBoard.Trigger.EncoderDirection)EncoderDirectionIndex);
|
|
DebugMessageString = String.Format("PerformCMD_SetEncoderDir Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetInputPolarity(object obj)
|
|
{
|
|
byte inPolarity = 0;
|
|
ushort ret = _Trigger.GetInputPol(ref inPolarity);
|
|
InputPolarityStatus = (int)inPolarity;
|
|
DebugMessageString = String.Format("PerformCMD_GetInputPolarity Ret : {0:x} {1:d}", ret, inPolarity);
|
|
}
|
|
private void PerformCMD_SetInputPolarity(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetInputPol(Convert.ToByte(InputPolarityStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetInputPolarity Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetTriggerPolarity(object obj)
|
|
{
|
|
byte trigPolarity = 0;
|
|
ushort ret = _Trigger.GetTriggerPol(ref trigPolarity);
|
|
TrigPolarityStatus = (int)trigPolarity;
|
|
DebugMessageString = String.Format("PerformCMD_GetTriggerPolarity Ret : {0:x} {1:d}", ret, trigPolarity);
|
|
}
|
|
private void PerformCMD_SetTriggerPolarity(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetTriggerPol(Convert.ToByte(TrigPolarityStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetTriggerPolarity Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetStrobePolarity(object obj)
|
|
{
|
|
byte strobePolarity = 0;
|
|
ushort ret = _Trigger.GetStrobePol(ref strobePolarity);
|
|
StrobePolarityStatus = (int)strobePolarity;
|
|
DebugMessageString = String.Format("PerformCMD_GetStrobePolarity Ret : {0:x} {1:d}", ret, strobePolarity);
|
|
}
|
|
private void PerformCMD_SetStrobePolarity(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetStrobePol(Convert.ToByte(StrobePolarityStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetStrobePolarity Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetTriggerStartDelay(object obj)
|
|
{
|
|
uint startDelay = 0;
|
|
ushort ret = _Trigger.GetTriggerStartdelay(ref startDelay);
|
|
TrigStartDelayStatus = startDelay.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetTriggerStartDelay Ret : {0:x} {1:d}", ret, startDelay);
|
|
}
|
|
private void PerformCMD_SetTriggerStartDelay(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetTriggerStartdelay(Convert.ToUInt32(TrigStartDelayStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetTriggerStartDelay Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetTriggerWidth(object obj)
|
|
{
|
|
uint width = 0;
|
|
ushort ret = _Trigger.GetTriggerWidth(ref width);
|
|
TrigWidthStatus = width.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetTriggerWidth Ret : {0:x} {1:d}", ret, width);
|
|
}
|
|
private void PerformCMD_SetTriggerWidth(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetTriggerWidth(Convert.ToUInt32(TrigWidthStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetTriggerWidth Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetTriggerCount(object obj)
|
|
{
|
|
uint trigCount = 0;
|
|
ushort ret = _Trigger.GetTriggerCnt(ref trigCount);
|
|
TriggerCountStatus = trigCount.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetTriggerCount Ret : {0:x} {1:d}", ret, trigCount);
|
|
}
|
|
private void PerformCMD_SetTriggerCount(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetTriggerCnt(Convert.ToUInt32(TriggerCountStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetTriggerCount Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetTriggerPulse(object obj)
|
|
{
|
|
uint trigPulse = 0;
|
|
ushort ret = _Trigger.GetTrigPulse(ref trigPulse);
|
|
TrigPulseStatus = trigPulse.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetTriggerPulse Ret : {0:x} {1:d}", ret, trigPulse);
|
|
}
|
|
private void PerformCMD_SetTriggerPulse(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetTrigPulse(Convert.ToUInt32(TrigPulseStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetTriggerPulse Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetStrobeStartDelay(object obj)
|
|
{
|
|
uint startDelay = 0;
|
|
ushort ret = _Trigger.GetStrobeStartdelay(ref startDelay);
|
|
StrobeStartDelayStatus = startDelay.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetStrobeStartDelay Ret : {0:x} {1:d}", ret, startDelay);
|
|
}
|
|
private void PerformCMD_SetStrobeStartDelay(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetStrobeStartdelay(Convert.ToUInt32(StrobeStartDelayStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetStrobeStartDelay Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetStrobeWidth(object obj)
|
|
{
|
|
uint width = 0;
|
|
ushort ret = _Trigger.GetStrobeWidth(ref width);
|
|
StrobeWidthStatus = width.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetStrobeWidth Ret : {0:x} {1:d}", ret, width);
|
|
}
|
|
private void PerformCMD_SetStrobeWidth(object obj)
|
|
{
|
|
ushort ret = _Trigger.SetStrobeWidth(Convert.ToUInt32(StrobeWidthStatus));
|
|
DebugMessageString = String.Format("PerformCMD_SetStrobeWidth Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_GetEndTrig(object obj)
|
|
{
|
|
byte endtrig = 0;
|
|
ushort ret = _Trigger.GetEndTrigger(ref endtrig);
|
|
EndTrigStatus = endtrig.ToString();
|
|
DebugMessageString = String.Format("PerformCMD_GetEndTrig Ret : {0:x} {1:d}", ret, endtrig);
|
|
}
|
|
private void PerformCMD_ResetTrigger(object obj)
|
|
{
|
|
ushort ret = _Trigger.ResetTriggerCount();
|
|
DebugMessageString = String.Format("PerformCMD_ResetTrigger Ret : {0:x}", ret);
|
|
}
|
|
private void PerformCMD_DebugMessageClear(object obj)
|
|
{
|
|
DebugMessageString = "";
|
|
}
|
|
|
|
private void PerformCMD_Setting(object obj)
|
|
{
|
|
//SetTriggerTableSetting()
|
|
int i = TableSettingIndex;
|
|
ushort rtn;
|
|
if (i == 0) {
|
|
rtn = _Trigger.DisableTrigCorrectTable();
|
|
if (rtn == 0) {
|
|
Log.D("Encoder / Position 1:1 Match Setting OK");
|
|
} else {
|
|
Log.D("Encoder / Position 1:1 Match Setting Fail");
|
|
}
|
|
} else {
|
|
double[] Pos_Table = new double[256];
|
|
ulong[] Enc_Table = new ulong[256];
|
|
for (int J = 0; J < 256; J++) {
|
|
Pos_Table[J] = 0;
|
|
Enc_Table[J] = 0;
|
|
}
|
|
Pos_Table[0] = 0; Pos_Table[1] = 10000; Pos_Table[2] = 20000; Pos_Table[3] = 30000; Pos_Table[4] = 40000; Pos_Table[5] = 100000000;
|
|
Enc_Table[0] = 0; Enc_Table[1] = 1010000; Enc_Table[2] = 1020000; ; Enc_Table[3] = 1030000; Enc_Table[4] = 1040000; Enc_Table[5] = 100000040000;
|
|
|
|
rtn = _Trigger.SetTrigCorrectTable(Pos_Table, Enc_Table);
|
|
|
|
if (rtn == 0) {
|
|
Log.D("Encoder / Position Calibration Mode Setting OK");
|
|
} else {
|
|
Log.D("Encoder / Position Calibration Mode Setting Fail");
|
|
}
|
|
}
|
|
////
|
|
///
|
|
|
|
//SetDropWatcherSetting()
|
|
// 1. Set Input mode (Encoder or Automatic increase)
|
|
i = EncoderDirectionIndex;
|
|
rtn = _Trigger.SetEncoderDirection(i == 0 ? EncoderDirection.Forward : EncoderDirection.Backward); // 0 : normal / 1 : reverse
|
|
if (rtn == 0) {
|
|
if (0 == i) Log.D("EncoderDirection Normal");
|
|
else Log.D("EncoderDirection Reverse");
|
|
} else {
|
|
Log.D("EncoderDirection Set Fail");
|
|
return;
|
|
}
|
|
|
|
// 2. Set Input Trigger Generation mode and Out mode
|
|
TriggerGenMode GenMode; // 0 -> Sequence, 1 -> Timer, 2 -> ExternalInput
|
|
i = GeneratorModeIndex;
|
|
switch (i) {
|
|
case 0: GenMode = TriggerGenMode.Sequence; break;
|
|
case 1: GenMode = TriggerGenMode.Timer; break;
|
|
default: GenMode = TriggerGenMode.ExternalInput; break;
|
|
}
|
|
|
|
ChannelOutMode OutMode; // 0 - > Simple, 1 -> DirectMask;
|
|
i = ChOutputModeIndex;
|
|
if (i == 0) { OutMode = ChannelOutMode.Simple; } else { OutMode = ChannelOutMode.DirectMask; }
|
|
|
|
rtn = _Trigger.SetTrigMode(GenMode, OutMode);
|
|
|
|
if (rtn == 0) {
|
|
Log.D("4-2 Trig Generation Mode : {GenMode} / Trig Out Mode : {OutMode}");
|
|
} else {
|
|
Log.D("Trigger Set Fail");
|
|
return;
|
|
}
|
|
|
|
// 3. Set parameter according to GenMode
|
|
switch ((int)GenMode) {
|
|
case 0: // Sequence mode
|
|
{
|
|
byte NumberOfTrigSet = 2; // Max 254
|
|
TrigSeqSet[] TrigCmdSet = new TrigSeqSet[254]; // Max Sequence Set : 254
|
|
|
|
for (int k = 0; k < NumberOfTrigSet; k++) {
|
|
TrigCmdSet[k].StartPosition = (1000000 * i) - 100;
|
|
TrigCmdSet[k].Interval = 10.5;
|
|
TrigCmdSet[k].Iteration = 1000;
|
|
//TrigCmdSet[i].Out2_SeqMode_Sel = (byte)(k % 7); // You can select 0~6 MaskSeqSet, if you don't use OutMode == 2 ignore this
|
|
//TrigCmdSet[i].WD_Set_Sel = (byte)(k % 8); // Width Delay Set select
|
|
}
|
|
|
|
rtn = _Trigger.SetTriggerSet(NumberOfTrigSet, ref TrigCmdSet);
|
|
if (rtn == 0)
|
|
Log.D("Set Normal Trig Mode OK");
|
|
else
|
|
Log.D("Set Normal Trig Mode Fail");
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
|
|
//double.TryParse(Timer_Set, out double timerPeriod_us);
|
|
rtn = _Trigger.SetTrigTimerSeq(Timer_Set);
|
|
|
|
if (0 != rtn) {
|
|
if (rtn == 0x0101) Log.D("Timer Trig Mode Setting ERROR");
|
|
else Log.D("Timer Trig Mode Run Error");
|
|
} else {
|
|
Log.D("Set Timer Trig Mode OK");
|
|
}
|
|
break;
|
|
|
|
}
|
|
/* NumberOfTrigSet = 20; // Max 254
|
|
for (i = 0; i < NumberOfTrigSet; i++) {
|
|
TrigCmdSet[i].TrigStart_Pos = 1000 - ( 1000 * i);
|
|
TrigCmdSet[i].TrigInterbal = -101;
|
|
TrigCmdSet[i].Iteration_Num = 10;
|
|
}*/
|
|
|
|
if (rtn == 0) {
|
|
Log.D("Trig Generation Mode Parameter Setting OK");
|
|
} else {
|
|
Log.D("Trig Generation Mode Parameter Setting Fail");
|
|
return;
|
|
}
|
|
|
|
// 4. Set parameter according to OutMode
|
|
|
|
//double Trig_Width_Delay_us[16];
|
|
bool[][] StrobeEnable = new bool[8][];
|
|
double[][] Trig_Width = new double[8][];
|
|
double[][] Trig_Delay = new double[8][];
|
|
for (i = 0; i < 8; i++) {
|
|
StrobeEnable[i] = new bool[8];
|
|
Trig_Width[i] = new double[8];
|
|
Trig_Delay[i] = new double[8];
|
|
for (int j = 0; j < 8; j++) {
|
|
StrobeEnable[i][j] = false;
|
|
Trig_Width[i][j] = 0;
|
|
Trig_Delay[i][j] = 0;
|
|
}
|
|
}
|
|
|
|
byte Strobe_Ch = 0;
|
|
|
|
StrobeEnable[0][0] = (bool)CheckedChannel1;
|
|
Trig_Delay[0][0] = DelayChannel1;
|
|
Trig_Width[0][0] = WidthChannel1;
|
|
StrobeEnable[1][0] = (bool)CheckedChannel2;
|
|
Trig_Delay[1][0] = DelayChannel2;
|
|
Trig_Width[1][0] = WidthChannel2;
|
|
StrobeEnable[2][0] = (bool)CheckedChannel3;
|
|
Trig_Delay[2][0] = DelayChannel3;
|
|
Trig_Width[2][0] = WidthChannel3;
|
|
StrobeEnable[3][0] = (bool)CheckedChannel4;
|
|
Trig_Delay[3][0] = DelayChannel4;
|
|
Trig_Width[3][0] = WidthChannel4;
|
|
StrobeEnable[4][0] = (bool)CheckedChannel5;
|
|
Trig_Delay[4][0] = DelayChannel5;
|
|
Trig_Width[4][0] = WidthChannel5;
|
|
StrobeEnable[5][0] = (bool)CheckedChannel6;
|
|
Trig_Delay[5][0] = DelayChannel6;
|
|
Trig_Width[5][0] = WidthChannel6;
|
|
StrobeEnable[6][0] = (bool)CheckedChannel7;
|
|
Trig_Delay[6][0] = DelayChannel7;
|
|
Trig_Width[6][0] = WidthChannel7;
|
|
StrobeEnable[7][0] = (bool)CheckedChannel8;
|
|
Trig_Delay[7][0] = DelayChannel8;
|
|
Trig_Width[7][0] = WidthChannel8;
|
|
|
|
double[] Trig_Width_Delay_us = new double[16];
|
|
switch ((int)OutMode) {
|
|
case 0: // Sequencial output by 1 trigger
|
|
// Sequencial output by 1 trigger
|
|
uint Trig_Mask = 0;
|
|
for (int j = 0; j < /*SJT_STROBE_MAX_CH*/8; j++) {
|
|
Strobe_Ch = (byte)j;
|
|
for (i = 0; i < /*SJT_STROBE_MAX_STEP*/8; i++) {
|
|
if (StrobeEnable[Strobe_Ch][i]) Trig_Mask |= (uint)(0x1 << i);
|
|
else Trig_Mask &= (uint)(0xff ^ (0x1 << i));
|
|
|
|
Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
|
|
Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
|
|
}
|
|
_Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
|
|
}
|
|
break;
|
|
|
|
|
|
case 2:
|
|
byte[] MaskBitSet = new byte[8];
|
|
|
|
for (i = 0; i < 8; i++)
|
|
MaskBitSet[i] = 0;
|
|
|
|
for (i = 0; i < /*SJT_STROBE_MAX_CH*/8; i++) {
|
|
for (int j = 0; j < /*SJT_STROBE_MAX_STEP*/8; j++) {
|
|
if (true == StrobeEnable[i][j]) {
|
|
MaskBitSet[j] |= (byte)(0x1 << i);
|
|
}
|
|
|
|
}
|
|
}
|
|
rtn = _Trigger.SetMaskSet(ref MaskBitSet);
|
|
for (int j = 0; j < /*SJT_STROBE_MAX_CH*/8; j++) {
|
|
Strobe_Ch = (byte)j;
|
|
Trig_Mask = 0;
|
|
for (i = 0; i < /*SJT_STROBE_MAX_STEP*/8; i++) {
|
|
//if (m_bStrobe_En[Strobe_Ch][i]) StrobeSet_Ch[Strobe_Ch].Sequence_Mask |= (0x1 << i);
|
|
if (((MaskBitSet[i] >> j) & 0x1) == 1) Trig_Mask |= (uint)(0x1 << i);
|
|
else Trig_Mask &= (uint)(0xff ^ (0x1 << i));
|
|
|
|
|
|
Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
|
|
Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
|
|
}
|
|
|
|
_Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (rtn == 0)
|
|
Log.D("Trig Output Mode Parameter Setting OK");
|
|
else
|
|
Log.D("Trig Output Mode Parameter Setting Fail");
|
|
}
|
|
private void PerformCMD_TriggerStart(object obj)
|
|
{
|
|
ushort rtn = _Trigger.StartTrigger();
|
|
|
|
if (rtn == 0)
|
|
Log.D("SJT Trigger Start OK");
|
|
else
|
|
Log.D("SJT Trigger Start Fail");
|
|
}
|
|
private void PerformCMD_TriggerStop(object obj)
|
|
{
|
|
ushort rtn = _Trigger.StopTrigger();
|
|
|
|
if (rtn == 0)
|
|
Log.D("SJT Trigger Stop OK");
|
|
else
|
|
Log.D("SJT Trigger Stop Fail");
|
|
}
|
|
|
|
private double timer_Set;
|
|
|
|
public double Timer_Set { get => timer_Set; set => SetProperty(ref timer_Set, value); }
|
|
|
|
private bool? checkedChannel1;
|
|
private bool? checkedChannel2;
|
|
private bool? checkedChannel3;
|
|
private bool? checkedChannel4;
|
|
private bool? checkedChannel5;
|
|
private bool? checkedChannel6;
|
|
private bool? checkedChannel7;
|
|
private bool? checkedChannel8;
|
|
public bool? CheckedChannel1 { get => checkedChannel1; set => SetProperty(ref checkedChannel1, value); }
|
|
public bool? CheckedChannel2 { get => checkedChannel2; set => SetProperty(ref checkedChannel2, value); }
|
|
public bool? CheckedChannel3 { get => checkedChannel3; set => SetProperty(ref checkedChannel3, value); }
|
|
public bool? CheckedChannel4 { get => checkedChannel4; set => SetProperty(ref checkedChannel4, value); }
|
|
public bool? CheckedChannel5 { get => checkedChannel5; set => SetProperty(ref checkedChannel5, value); }
|
|
public bool? CheckedChannel6 { get => checkedChannel6; set => SetProperty(ref checkedChannel6, value); }
|
|
public bool? CheckedChannel7 { get => checkedChannel7; set => SetProperty(ref checkedChannel7, value); }
|
|
public bool? CheckedChannel8 { get => checkedChannel8; set => SetProperty(ref checkedChannel8, value); }
|
|
|
|
private double widthChannel1;
|
|
private double widthChannel2;
|
|
private double widthChannel3;
|
|
private double widthChannel4;
|
|
private double widthChannel5;
|
|
private double widthChannel6;
|
|
private double widthChannel7;
|
|
private double widthChannel8;
|
|
public double WidthChannel1 { get => widthChannel1; set => SetProperty(ref widthChannel1, value); }
|
|
public double WidthChannel2 { get => widthChannel2; set => SetProperty(ref widthChannel2, value); }
|
|
public double WidthChannel3 { get => widthChannel3; set => SetProperty(ref widthChannel3, value); }
|
|
public double WidthChannel4 { get => widthChannel4; set => SetProperty(ref widthChannel4, value); }
|
|
public double WidthChannel5 { get => widthChannel5; set => SetProperty(ref widthChannel5, value); }
|
|
public double WidthChannel6 { get => widthChannel6; set => SetProperty(ref widthChannel6, value); }
|
|
public double WidthChannel7 { get => widthChannel7; set => SetProperty(ref widthChannel7, value); }
|
|
public double WidthChannel8 { get => widthChannel8; set => SetProperty(ref widthChannel8, value); }
|
|
|
|
private double delayChannel1;
|
|
private double delayChannel2;
|
|
private double delayChannel3;
|
|
private double delayChannel4;
|
|
private double delayChannel5;
|
|
private double delayChannel6;
|
|
private double delayChannel7;
|
|
private double delayChannel8;
|
|
|
|
public double DelayChannel1 { get => delayChannel1; set => SetProperty(ref delayChannel1, value); }
|
|
public double DelayChannel2 { get => delayChannel2; set => SetProperty(ref delayChannel2, value); }
|
|
public double DelayChannel3 { get => delayChannel3; set => SetProperty(ref delayChannel3, value); }
|
|
public double DelayChannel4 { get => delayChannel4; set => SetProperty(ref delayChannel4, value); }
|
|
public double DelayChannel5 { get => delayChannel5; set => SetProperty(ref delayChannel5, value); }
|
|
public double DelayChannel6 { get => delayChannel6; set => SetProperty(ref delayChannel6, value); }
|
|
public double DelayChannel7 { get => delayChannel7; set => SetProperty(ref delayChannel7, value); }
|
|
public double DelayChannel8 { get => delayChannel8; set => SetProperty(ref delayChannel8, value); }
|
|
|
|
private void PerformCMD_SetStrobe(object obj)
|
|
{
|
|
string ch = obj as string;
|
|
int chIndex = 0;
|
|
if (ch == "Ch1") { chIndex = 0; } else if (ch == "Ch2") { chIndex = 1; } else if (ch == "Ch3") { chIndex = 2; } else if (ch == "Ch4") { chIndex = 3; } else if (ch == "Ch5") { chIndex = 4; } else if (ch == "Ch6") { chIndex = 5; } else if (ch == "Ch7") { chIndex = 6; } else if (ch == "Ch8") { chIndex = 7; } else { chIndex = 0; }
|
|
|
|
SetChStrobe(chIndex);
|
|
}
|
|
|
|
private void SetChStrobe(int chIndex)
|
|
{
|
|
byte Strobe_Ch = (byte)chIndex;
|
|
uint Trig_Mask = 0;
|
|
|
|
bool[][] StrobeEnable = new bool[8][];
|
|
double[][] Trig_Width = new double[8][];
|
|
double[][] Trig_Delay = new double[8][];
|
|
for (int i = 0; i < 8; i++) {
|
|
StrobeEnable[i] = new bool[8];
|
|
Trig_Width[i] = new double[8];
|
|
Trig_Delay[i] = new double[8];
|
|
|
|
for (int j = 0; j < 8; j++) {
|
|
StrobeEnable[i][j] = false;
|
|
Trig_Width[i][j] = 0;
|
|
Trig_Delay[i][j] = 0;
|
|
}
|
|
|
|
}
|
|
|
|
switch (chIndex) {
|
|
case 0: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel1;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel1;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel1;
|
|
}
|
|
break;
|
|
case 1: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel2;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel2;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel2;
|
|
}
|
|
break;
|
|
case 2: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel3;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel3;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel3;
|
|
}
|
|
break;
|
|
case 3: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel4;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel4;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel4;
|
|
}
|
|
break;
|
|
case 4: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel5;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel5;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel5;
|
|
}
|
|
break;
|
|
case 5: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel6;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel6;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel6;
|
|
}
|
|
break;
|
|
case 6: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel7;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel7;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel7;
|
|
}
|
|
break;
|
|
case 7: {
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel8;
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel8;
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel8;
|
|
}
|
|
break;
|
|
}
|
|
|
|
double[] Trig_Width_Delay_us = new double[16];
|
|
for (int i = 0; i < 8; i++) {
|
|
if (StrobeEnable[Strobe_Ch][i]) Trig_Mask |= (uint)(0x1 << i);
|
|
else Trig_Mask &= (uint)(0xff ^ (0x1 << i));
|
|
|
|
Trig_Width_Delay_us[i * 2] = Trig_Width[Strobe_Ch][i];
|
|
Trig_Width_Delay_us[i * 2 + 1] = Trig_Delay[Strobe_Ch][i];
|
|
}
|
|
|
|
_Trigger.SetStrobe(Strobe_Ch, Trig_Mask, Trig_Width_Delay_us);
|
|
}
|
|
private void PerformCMD_GetEncoderCnt(object obj)
|
|
{
|
|
long encoderCount;
|
|
_Trigger.GetEncoderCount(out encoderCount);
|
|
EncoderTriggerCount = encoderCount.ToString();
|
|
}
|
|
private void PerformCMD_ResetEncoderCount(object obj)
|
|
{
|
|
_Trigger.ResetEncoderCount();
|
|
}
|
|
private void PerformCMD_SetEncoderCount(object obj)
|
|
{
|
|
_Trigger.SetEncoderCount(Convert.ToInt32(EncoderTriggerCount));
|
|
}
|
|
private void PerformCMD_ResetSystem(object obj)
|
|
{
|
|
_Trigger.ResetSystem();
|
|
}
|
|
|
|
private string encoderTriggerCount;
|
|
|
|
public string EncoderTriggerCount { get => encoderTriggerCount; set => SetProperty(ref encoderTriggerCount, value); }
|
|
|
|
private string debugMessageString;
|
|
public string DebugMessageString { get => debugMessageString; set => SetProperty(ref debugMessageString, value); }
|
|
}
|
|
}
|