1032 lines
46 KiB
C#
1032 lines
46 KiB
C#
using Aurora;
|
|
using Aurora.Api;
|
|
using Aurora.Api.Manager;
|
|
using Aurora.View;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Windows.Input;
|
|
using System.Windows.Threading;
|
|
using static AuroraTriggerBoard.Trigger;
|
|
using static AuroraTriggerBoard.ITrigger;
|
|
using static AuroraTriggerBoard.TriggerConfig;
|
|
|
|
namespace AuroraTriggerBoard.SJT
|
|
{
|
|
public class UCTriggerBoardViewModel : NotifyPropertyChangedBase
|
|
{
|
|
Aurora.Api.Logger Log = new Aurora.Api.Logger("Trigger Board");
|
|
|
|
public ICommand CMD_ViewLoaded { get; }
|
|
public ICommand CMD_ViewUnloaded { get; }
|
|
public ICommand CMD_CheckTeachingMode { get; }
|
|
public ICommand CMD_Setting { get; private set; }
|
|
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_GetTriggetCountErrorCountMaxFrequency { get; private set; } // TriggerCount, ErrorCount, MaxFrequency
|
|
public ICommand CMD_ResetTriggerCount { get; private set; }
|
|
public ICommand CMD_SetTriggerCount { get; private set; }
|
|
|
|
public ICommand CMD_GetAllParameter { get; private set; }
|
|
|
|
private readonly DispatcherTimer MonitorTimer;
|
|
internal AuroraTriggerBoard.Trigger _Trigger;
|
|
internal AuroraTriggerBoard.ITrigger _ITrigger;
|
|
private readonly IDeviceManager _DeviceManager;
|
|
IAuroraEnvironment _auroraEnv;
|
|
|
|
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 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 EncoderMode encoderInputByIndex;
|
|
public EncoderMode EncoderInputByIndex { get => encoderInputByIndex; set => SetProperty(ref encoderInputByIndex, value); }
|
|
|
|
private EncoderPositionMap tableSettingIndex;
|
|
|
|
public EncoderPositionMap TableSettingIndex { get => tableSettingIndex; set => SetProperty(ref tableSettingIndex, value); }
|
|
|
|
private EncoderDirection encoderDirectionIndex;
|
|
|
|
public EncoderDirection EncoderDirectionIndex { get => encoderDirectionIndex; set => SetProperty(ref encoderDirectionIndex, value); }
|
|
|
|
private TriggerGenMode generatorModeIndex;
|
|
|
|
public TriggerGenMode GeneratorModeIndex { get => generatorModeIndex; set => SetProperty(ref generatorModeIndex, value); }
|
|
|
|
private ChannelOutMode chOutputModeIndex;
|
|
|
|
public ChannelOutMode ChOutputModeIndex { get => chOutputModeIndex; set => SetProperty(ref chOutputModeIndex, value); }
|
|
|
|
public List<EncoderMode> EncModes { get; }
|
|
public List<EncoderPositionMap> EncPosMaps { get; }
|
|
public List<EncoderDirection> EncDirections { get; }
|
|
public List<TriggerGenMode> TrigGenModes { get; }
|
|
public List<ChannelOutMode> TrigChOutModes { get; }
|
|
|
|
public bool IsFirst = false;
|
|
|
|
private double timer_Set; public double Timer_Set { get => timer_Set; set => SetProperty(ref timer_Set, value); }
|
|
|
|
private uint trigLimit_Set; public uint TrigLimit_Set { get => trigLimit_Set; set => SetProperty(ref trigLimit_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 bool?[] checkedChannel = new bool?[8]; public bool?[] CheckedChannel { get => checkedChannel; set => SetProperty(ref checkedChannel, value); }
|
|
|
|
|
|
private double[] widthChannel = new double[8]; public double[] WidthChannel { get => widthChannel; set => SetProperty(ref widthChannel, value); }
|
|
|
|
|
|
private double[] delayChannel = new double[8]; public double[] DelayChannel { get => delayChannel; set => SetProperty(ref delayChannel, value); }
|
|
|
|
|
|
private int _seqStartEnc; public int Seq_StartEnc { get => _seqStartEnc; set => SetProperty(ref _seqStartEnc, value); }
|
|
private int _seqIntervalEnc; public int Seq_IntervalEnc { get => _seqIntervalEnc; set => SetProperty(ref _seqIntervalEnc, value); }
|
|
private int _seqIterationCnt; public int Seq_IterationCnt{ get => _seqIterationCnt; set => SetProperty(ref _seqIterationCnt, value); }
|
|
|
|
private int encoderTriggerCount;
|
|
public int EncoderTriggerCount { get => encoderTriggerCount; set => SetProperty(ref encoderTriggerCount, value); }
|
|
|
|
private int _triggerCount;
|
|
public int TriggerCount { get => _triggerCount; set => SetProperty(ref _triggerCount, value); }
|
|
private int _errorCount;
|
|
public int ErrorCount { get => _errorCount; set => SetProperty(ref _errorCount, value); }
|
|
private double _maxFrequencyt;
|
|
public double MaxFrequency { get => _maxFrequencyt; set => SetProperty(ref _maxFrequencyt, value); }
|
|
|
|
public UCTriggerBoardViewModel(IAuroraEnvironment env, string deviceId)
|
|
{
|
|
_Trigger = env.DeviceManager[deviceId] as AuroraTriggerBoard.Trigger;
|
|
_DeviceManager = env.DeviceManager;
|
|
_auroraEnv = env;
|
|
|
|
EncModes = Enum.GetValues(typeof(EncoderMode)).Cast<EncoderMode>().ToList();
|
|
EncPosMaps = Enum.GetValues(typeof(EncoderPositionMap)).Cast<EncoderPositionMap>().ToList();
|
|
EncDirections = Enum.GetValues(typeof(EncoderDirection)).Cast<EncoderDirection>().ToList();
|
|
TrigGenModes = Enum.GetValues(typeof(TriggerGenMode)).Cast<TriggerGenMode>().ToList();
|
|
TrigChOutModes = Enum.GetValues(typeof(ChannelOutMode)).Cast<ChannelOutMode>().ToList();
|
|
|
|
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_GetTriggetCountErrorCountMaxFrequency = new DelegateCommand(PerformCMD_GetTriggetCountErrorCountMaxFrequency);
|
|
CMD_ResetTriggerCount = new DelegateCommand(PerformCMD_ResetTriggerCount);
|
|
CMD_SetTriggerCount = new DelegateCommand(PerformCMD_SetTriggerCount);
|
|
|
|
CMD_GetAllParameter = new DelegateCommand(PerformCMD_GetAllParameter);
|
|
|
|
MonitorTimer = new DispatcherTimer();
|
|
MonitorTimer.Tick += OnMonitoring;
|
|
MonitorTimer.Interval = TimeSpan.FromMilliseconds(1000);
|
|
|
|
IsFirst = true;
|
|
|
|
var config = _DeviceManager.GetDeviceConfig(_Trigger.DeviceId) as TriggerConfig;
|
|
Timer_Set = config.trigTimerSet;
|
|
TrigLimit_Set = config.trigLimitSet;
|
|
//CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
|
|
//CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
|
|
//CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
|
|
//CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
|
|
//CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
|
|
//CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
|
|
//CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
|
|
//CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;
|
|
//CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
|
|
//CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
|
|
//CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
|
|
//CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
|
|
//CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
|
|
//CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
|
|
//CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
|
|
//CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;
|
|
for (int i = 0; i < 8; i++) {
|
|
CheckedChannel[i] = config.strobeChData.Count >= (i+1) ? config.strobeChData[i].strobeEnable : false;
|
|
WidthChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeWidth : 0.0;
|
|
DelayChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeStartDelay : 0.0;
|
|
}
|
|
|
|
TableSettingIndex = config.encposmaptype;
|
|
EncoderInputByIndex = config.encinputmode;
|
|
EncoderDirectionIndex = config.EncDir;
|
|
GeneratorModeIndex = config.trigGenMode;
|
|
ChOutputModeIndex = config.chOutMode;
|
|
|
|
Seq_StartEnc = config.seqStartEnc;
|
|
Seq_IntervalEnc = config.seqIntervalEnc;
|
|
Seq_IterationCnt = config.seqIterationCnt;
|
|
}
|
|
|
|
private void Unloaded(object obj) { MonitorTimer.Stop(); IsFirst = true; }
|
|
|
|
private void Loaded(object obj) => MonitorTimer.Start();
|
|
|
|
private bool CheckVersionAndInitialize()
|
|
{
|
|
//_Trigger.ValueInit();
|
|
|
|
_Trigger.GetHWVersion(out string hw_ver, out string sw_ver);
|
|
_Trigger.GetDllVersion(out string dll_ver);
|
|
|
|
HW_Ver = hw_ver;
|
|
SW_Ver = sw_ver;
|
|
DLL_Ver = dll_ver;
|
|
|
|
// <Inkjet> 초기 세팅
|
|
//Timer_Set = 10000;
|
|
//TrigLimit_Set = 0;
|
|
//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;
|
|
|
|
//_Trigger.GetTrigTimeFreq(out uint TimerFreq_10ns);
|
|
//_Trigger.GetTrigTimeLimit(out uint TimeLimit);
|
|
//Timer_Set = ((double)(TimerFreq_10ns)) / 100.0;
|
|
//TrigLimit_Set = TimeLimit;
|
|
//CheckedChannel1 = config.strobeChData.Count >= 1 ? config.strobeChData[0].strobeEnable : false;
|
|
//CheckedChannel2 = config.strobeChData.Count >= 2 ? config.strobeChData[1].strobeEnable : false;
|
|
//CheckedChannel3 = config.strobeChData.Count >= 3 ? config.strobeChData[2].strobeEnable : false;
|
|
//CheckedChannel4 = config.strobeChData.Count >= 4 ? config.strobeChData[3].strobeEnable : false;
|
|
//CheckedChannel5 = config.strobeChData.Count >= 5 ? config.strobeChData[4].strobeEnable : false;
|
|
//CheckedChannel6 = config.strobeChData.Count >= 6 ? config.strobeChData[5].strobeEnable : false;
|
|
//CheckedChannel7 = config.strobeChData.Count >= 7 ? config.strobeChData[6].strobeEnable : false;
|
|
//CheckedChannel8 = config.strobeChData.Count >= 8 ? config.strobeChData[7].strobeEnable : false;
|
|
|
|
//TableSettingIndex = (int)config.encposmaptype;
|
|
//EncoderInputByIndex = (int)config.encinputmode;
|
|
//EncoderDirectionIndex = (int)config.EncDir;
|
|
//GeneratorModeIndex = (int)config.trigGenMode;
|
|
//ChOutputModeIndex = (int)config.chOutMode;
|
|
|
|
//ushort rtn;
|
|
////uint[] Strobe_Ch_Para = new uint[17];
|
|
//byte mask = 0x00;
|
|
//double[] Width = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
|
|
//double[] Delay = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
|
|
|
|
//rtn = _Trigger.GetStrobe(0, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel1 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel1 = Width[0];
|
|
|
|
// DelayChannel1 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(1, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel2 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel2 = Width[0];
|
|
|
|
// DelayChannel2 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(2, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel3 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel3 = Width[0];
|
|
|
|
// DelayChannel3 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(3, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel4 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel4 = Width[0];
|
|
|
|
// DelayChannel4 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(4, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel5 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel5 = Width[0];
|
|
|
|
// DelayChannel5 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(5, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel6 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel6 = Width[0];
|
|
|
|
// DelayChannel6 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(6, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel7 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel7 = Width[0];
|
|
|
|
// DelayChannel7 = Delay[0];
|
|
//}
|
|
|
|
//rtn = _Trigger.GetStrobe(7, ref mask, ref Width, ref Delay);
|
|
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {1} Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// CheckedChannel8 = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel8 = Width[0];
|
|
|
|
// DelayChannel8 = Delay[0];
|
|
//}
|
|
//for (int i = 0; i < 0; i++) {
|
|
// rtn = _Trigger.GetStrobe((byte)i, ref mask, ref Width, ref Delay);
|
|
|
|
// if (rtn != 0) {
|
|
// Log.D($"Get Strobe Channel Parameter Fail Ch : {i+1} Err Code : {rtn:0x04}");
|
|
// } else {
|
|
// CheckedChannel[i] = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
// WidthChannel[i] = Width[0];
|
|
|
|
// DelayChannel[i] = Delay[0];
|
|
// }
|
|
//}
|
|
|
|
//rtn = _Trigger.GetEncPosMapTableUse(out EncoderPositionMap encposmap);
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Trig Encoder Enable Parameter Fail Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// TableSettingIndex = encposmap;
|
|
//}
|
|
|
|
//rtn = _Trigger.GetEncoderDirection(out EncoderDirection encdirection);
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Trig Encoder Direction Parameter Fail Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// EncoderDirectionIndex = encdirection;
|
|
//}
|
|
|
|
//rtn = _Trigger.GetCntInType(out uint cnttype);
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Trig Encoder Input Type Parameter Fail Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// EncoderInputByIndex = (EncoderMode)cnttype;
|
|
//}
|
|
|
|
//rtn = _Trigger.GetTrigMode(out TriggerGenMode _triggenmode, out ChannelOutMode _trigchoutmode);
|
|
//if (rtn != 0) {
|
|
// Log.D($"Get Trig Mode Parameter Fail Err Code : {rtn:0x04}");
|
|
//} else {
|
|
// GeneratorModeIndex = _triggenmode;
|
|
// ChOutputModeIndex = _trigchoutmode;
|
|
//}
|
|
|
|
//EncoderInputByIndex = (int)config.encinputmode;
|
|
|
|
var config = _DeviceManager.GetDeviceConfig(_Trigger.DeviceId) as TriggerConfig;
|
|
Timer_Set = config.trigTimerSet;
|
|
TrigLimit_Set = config.trigLimitSet;
|
|
for (int i = 0; i < 8; i++) {
|
|
CheckedChannel[i] = config.strobeChData.Count >= (i + 1) ? config.strobeChData[i].strobeEnable : false;
|
|
}
|
|
|
|
TableSettingIndex = config.encposmaptype;
|
|
EncoderInputByIndex = config.encinputmode;
|
|
EncoderDirectionIndex = config.EncDir;
|
|
GeneratorModeIndex = config.trigGenMode;
|
|
ChOutputModeIndex = config.chOutMode;
|
|
|
|
Seq_StartEnc = config.seqStartEnc;
|
|
Seq_IntervalEnc = config.seqIntervalEnc;
|
|
Seq_IterationCnt = config.seqIterationCnt;
|
|
|
|
// <HairPinTwister>
|
|
return !(HW_Ver == null && SW_Ver == null);
|
|
|
|
}
|
|
|
|
private void OnMonitoring(object sender, EventArgs e)
|
|
{
|
|
if (_Trigger.IsActivated && IsFirst)
|
|
{
|
|
IsFirst = false;
|
|
CheckVersionAndInitialize();
|
|
}
|
|
}
|
|
|
|
private void PerformCMD_CheckTeachingMode(object obj)
|
|
{
|
|
string cmd_Param = obj as string;
|
|
if (cmd_Param == "Normal")
|
|
{
|
|
TableSettingIndex = 0;
|
|
EncoderInputByIndex = EncoderMode.Real;
|
|
EncoderDirectionIndex = 0;
|
|
//GeneratorModeIndex = 2;
|
|
//ChOutputModeIndex = 0;
|
|
GeneratorModeIndex = TriggerGenMode.Timer;
|
|
ChOutputModeIndex = ChannelOutMode.Simple;
|
|
}
|
|
else // cmd_Param == "Teaching"
|
|
{
|
|
TableSettingIndex = 0;
|
|
EncoderInputByIndex = EncoderMode.Simulation;
|
|
EncoderDirectionIndex = 0;
|
|
//GeneratorModeIndex = 1;
|
|
//ChOutputModeIndex = 0;
|
|
GeneratorModeIndex = TriggerGenMode.Timer;
|
|
ChOutputModeIndex = ChannelOutMode.Simple;
|
|
}
|
|
}
|
|
|
|
private void PerformCMD_Setting(object obj)
|
|
{
|
|
//SetTriggerTableSetting()
|
|
//int i = TableSettingIndex;
|
|
EncoderPositionMap encposmap = TableSettingIndex;
|
|
ushort rtn;
|
|
//if (i == 0)
|
|
if (encposmap == EncoderPositionMap.Normal) {
|
|
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)
|
|
rtn = _Trigger.SetEncoderDirection(EncoderDirectionIndex == 0 ? EncoderDirection.Forward : EncoderDirection.Backward); // 0 : normal / 1 : reverse
|
|
Log.D(string.Format("EncoderDirection Setting {0}, {1}", EncoderDirectionIndex == 0 ? "Normal" : "Reverse", rtn == 0 ? "OK" : "FAIL"));
|
|
if(rtn !=0) return;
|
|
|
|
// 2. Set Input Trigger Generation mode and Out mode
|
|
TriggerGenMode GenMode = GeneratorModeIndex; // 0 -> Sequence, 1 -> Timer, 2 -> ExternalInput
|
|
//switch (GeneratorModeIndex) {
|
|
// //case 0: GenMode = TriggerGenMode.Sequence; break;
|
|
// //case 1: GenMode = TriggerGenMode.Timer; break;
|
|
// //default: GenMode = TriggerGenMode.ExternalInput; break;
|
|
// case 0: GenMode = TriggerGenMode.Sequence; break;
|
|
// case 1: GenMode = TriggerGenMode.Direct; break;
|
|
// case 3: GenMode = TriggerGenMode.Timer; break;
|
|
// case 4: GenMode = TriggerGenMode.ExternalInput; break;
|
|
// default: GenMode = TriggerGenMode.Timer; break;
|
|
//}
|
|
|
|
ChannelOutMode OutMode = ChOutputModeIndex; // 0 - > Simple, 1 -> DirectMask;
|
|
//OutMode = ChOutputModeIndex == 0 ? ChannelOutMode.Simple : ChannelOutMode.DirectMask;
|
|
//switch (ChOutputModeIndex) {
|
|
// case 0: OutMode = ChannelOutMode.SeqBy1Trig; break;
|
|
// case 1: OutMode = ChannelOutMode.Simple; break;
|
|
// case 2: OutMode = ChannelOutMode.SequenceMask; break;
|
|
// default: OutMode = ChannelOutMode.Simple; break;
|
|
//}
|
|
|
|
rtn = _Trigger.SetTrigMode(GenMode, OutMode);
|
|
Log.D(string.Format("4-2 Trig Generation Mode: {0}, Out Mode {1}, result {2}", GenMode, OutMode, rtn == 0 ? "OK" : "FAIL"));
|
|
if(rtn != 0) return;
|
|
|
|
rtn = _Trigger.SetTrigLimit(TrigLimit_Set);
|
|
Log.D($"4-2 Trig Limit: {TrigLimit_Set}, result {rtn}");
|
|
if (rtn != 0) return;
|
|
|
|
// 3. Set parameter according to GenMode
|
|
int i = 0;
|
|
//switch ((int)GenMode)
|
|
switch (GenMode) {
|
|
//case 0: { // Sequence mode
|
|
case TriggerGenMode.Sequence: {
|
|
/*<HairPinTwister>
|
|
// 1. SetEncoderMode
|
|
ushort rtn = _Trigger.SetEncoderMode(EncoderMode.Real); // CntInType = 0
|
|
Log.D(string.Format("Set External Encoder(CntInType) {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
|
|
|
|
// 2. SetTrigLimit
|
|
rtn = _Trigger.SetTrigLimit((uint)mode); // SimulTrigLimit = 0
|
|
Log.D(string.Format("Set Trig Limit(SimulTrigLimit) {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
|
|
*/
|
|
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 * (int)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);
|
|
Log.D(string.Format("Set Normal Trig Mode (SetTrigSet) {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
}
|
|
break;
|
|
|
|
//case 3: { // Timer mode
|
|
case TriggerGenMode.Timer: {
|
|
|
|
//double.TryParse(Timer_Set, out double timerPeriod_us);
|
|
rtn = _Trigger.SetTrigTimerSeq(Timer_Set);
|
|
Log.D(string.Format("Set Timer Trig Mode {0} {1}",
|
|
rtn == 0 ? "OK" : "FAIL", rtn == 0 ? "" :
|
|
rtn == 0x0101 ? "Setting Error" : "Run Error"));
|
|
|
|
//<HairPinTwister> 2. SetTrigLimit
|
|
/*
|
|
rtn = _Trigger.SetTrigLimit((uint)mode); // SimulTrigLimit = 0
|
|
Log.D(string.Format("Set Trig Limit(SimulTrigLimit) {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
*/
|
|
}
|
|
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;
|
|
}*/
|
|
Log.D($"Trig Generation Mode: {GeneratorModeIndex.ToString()}, Parameter Setting {(rtn == 0 ? "OK" : "FAIL")}");
|
|
if(rtn != 0) 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;
|
|
for (i = 0; i < 8; i++) {
|
|
StrobeEnable[i][0] = (bool)CheckedChannel[i];
|
|
Trig_Delay[i][0] = DelayChannel[i];
|
|
Trig_Width[i][0] = WidthChannel[i];
|
|
}
|
|
|
|
double[] Trig_Width_Delay_us = new double[16];
|
|
//switch ((int)OutMode)
|
|
switch (OutMode) {
|
|
//case 0: // Sequencial output by 1 trigger
|
|
case ChannelOutMode.SeqBy1Trig:
|
|
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:
|
|
case ChannelOutMode.Simple:
|
|
byte[] MaskBitSet = new byte[8 * 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();
|
|
|
|
Log.D(string.Format("SJT Trigger Start {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
}
|
|
private void PerformCMD_TriggerStop(object obj)
|
|
{
|
|
ushort rtn = _Trigger.StopTrigger();
|
|
|
|
Log.D(string.Format("SJT Trigger Stop {0}", rtn == 0 ? "OK" : "FAIL"));
|
|
}
|
|
|
|
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 if (ch == "All") { chIndex = 8; }
|
|
else { chIndex = 0; }
|
|
|
|
if(chIndex == 8) {
|
|
for(int i = 0; i < 8; i++) {
|
|
SetChStrobe(i);
|
|
}
|
|
} else {
|
|
SetChStrobe(chIndex);
|
|
}
|
|
|
|
//<HaripinTwister>
|
|
// // Trigger Out Mode - View(Index) 0: Simple => enum 3: DirectMask
|
|
//ChannelOutMode OutMode = ChannelOutMode.DirectMask; // DirectMask Mode only - hardcoded
|
|
// 4. Set OutMode related parameters
|
|
//bool isParamSet = SetOutModeParameters(OutMode);
|
|
//Log.D(string.Format("Out Mode: {0} Parameter Setting {1}", "Simple(Direct) Mask", isParamSet ? "OK" : "FAIL"));
|
|
}
|
|
|
|
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;
|
|
//}
|
|
StrobeEnable[Strobe_Ch][0] = (bool)CheckedChannel[chIndex];
|
|
Trig_Width[Strobe_Ch][0] = WidthChannel[chIndex];
|
|
Trig_Delay[Strobe_Ch][0] = DelayChannel[chIndex];
|
|
|
|
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 = (int)encoderCount;
|
|
}
|
|
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 void PerformCMD_GetTriggetCountErrorCountMaxFrequency(object obj)
|
|
{
|
|
uint[] trig_Count = new uint[17]; //0 -> Total Matched count, 1~8 -> Each Channel Trig Out Count
|
|
uint[] error_Count = new uint[16];
|
|
float[] maxFreq = new float[16];
|
|
|
|
//TriggerCount
|
|
|
|
//_Trigger.GetTriggerCnt(ref triggerCount);
|
|
//TriggerCount = (int)triggerCount;
|
|
_Trigger.GetTrigNErrCnt(ref trig_Count, ref error_Count, ref maxFreq);
|
|
|
|
uint triggerCount = 0;
|
|
triggerCount = trig_Count[0];
|
|
|
|
uint errorCount = 0;
|
|
errorCount = error_Count[0] + error_Count[1] + error_Count[2] + error_Count[3] + error_Count[4] + error_Count[5] + error_Count[6] + error_Count[7] +
|
|
error_Count[8] + error_Count[9] + error_Count[10] + error_Count[11] + error_Count[12] + error_Count[13] + error_Count[14] + error_Count[15];
|
|
|
|
float maxFrequency = 0.0f;
|
|
for (int i = 0; i < 16; i++) {
|
|
if (maxFrequency < maxFreq[i]) {
|
|
maxFrequency = maxFreq[i];
|
|
}
|
|
}
|
|
|
|
TriggerCount = (int)triggerCount;
|
|
ErrorCount = (int)errorCount;
|
|
MaxFrequency = (double)maxFrequency;
|
|
|
|
}
|
|
private void PerformCMD_ResetTriggerCount(object obj)
|
|
{
|
|
_Trigger.ResetTriggerCount();
|
|
}
|
|
private void PerformCMD_SetTriggerCount(object obj)
|
|
{
|
|
//_Trigger.SetEncoderCount(Convert.ToInt32(EncoderTriggerCount));
|
|
}
|
|
|
|
private void PerformCMD_GetAllParameter(object obj)
|
|
{
|
|
_Trigger.GetHWVersion(out string hw_ver, out string sw_ver);
|
|
_Trigger.GetDllVersion(out string dll_ver);
|
|
|
|
_Trigger.GetTrigTimeFreq(out uint TimerFreq_10ns);
|
|
_Trigger.GetTrigTimeLimit(out uint TimeLimit);
|
|
Timer_Set = ((double)(TimerFreq_10ns)) / 100.0;
|
|
TrigLimit_Set = TimeLimit;
|
|
|
|
ushort rtn;
|
|
//uint[] Strobe_Ch_Para = new uint[17];
|
|
byte mask = 0x00;
|
|
double[] Width = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
|
|
double[] Delay = new double[8] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
|
|
|
|
rtn = _Trigger.GetStrobe(0, ref mask, ref Width, ref Delay);
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
rtn = _Trigger.GetStrobe((byte)i, ref mask, ref Width, ref Delay);
|
|
|
|
if (rtn != 0) {
|
|
Log.D($"Get Strobe Channel Parameter Fail Ch : {i + 1} Err Code : {rtn:0x04}");
|
|
} else {
|
|
CheckedChannel[i] = (1 == ((mask >> 0) & 0x1)) ? true : false;
|
|
|
|
WidthChannel[i] = Width[0];
|
|
|
|
DelayChannel[i] = Delay[0];
|
|
}
|
|
}
|
|
|
|
rtn = _Trigger.GetEncPosMapTableUse(out EncoderPositionMap encposmap);
|
|
if (rtn != 0) {
|
|
Log.D($"Get Trig Encoder Enable Parameter Fail Err Code : {rtn:0x04}");
|
|
} else {
|
|
TableSettingIndex = encposmap;
|
|
}
|
|
|
|
rtn = _Trigger.GetEncoderDirection(out EncoderDirection encdirection);
|
|
if (rtn != 0) {
|
|
Log.D($"Get Trig Encoder Direction Parameter Fail Err Code : {rtn:0x04}");
|
|
} else {
|
|
EncoderDirectionIndex = encdirection;
|
|
}
|
|
|
|
rtn = _Trigger.GetCntInType(out uint cnttype);
|
|
if (rtn != 0) {
|
|
Log.D($"Get Trig Encoder Input Type Parameter Fail Err Code : {rtn:0x04}");
|
|
} else {
|
|
EncoderInputByIndex = (EncoderMode)cnttype;
|
|
}
|
|
|
|
rtn = _Trigger.GetTrigMode(out TriggerGenMode _triggenmode, out ChannelOutMode _trigchoutmode);
|
|
if (rtn != 0) {
|
|
Log.D($"Get Trig Mode Parameter Fail Err Code : {rtn:0x04}");
|
|
} else {
|
|
GeneratorModeIndex = _triggenmode;
|
|
ChOutputModeIndex = _trigchoutmode;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|