public static int Width(uint ascanNum, uint ascanPort, GateType type, ref double width)
{
int error_code;
int gateNum = (int)type;
uint attr = DaqAttrType.gate[gateNum].Width;
double val = 0;
if (ascanNum < ascanNumMin || ascanNum > ascanNumMax)
{
error_code = -1;
return(error_code);
}
if (type < gateTypeMin || type > gateTypeMax)
{
error_code = -1;
return(error_code);
}
error_code = DAQ.daqGet(ascanNum, ascanPort, attr, ref val);
if (error_code != (int)PDAQ_ERR.GOOD)
{
MessageShow.show("Error:Get the Width of gate failed", "错误：获得门的宽度失败");
return(error_code);
}
width = val;
SetGateDAQ.setWidthDictionary(ascanNum, ascanPort, type, width);
return(error_code);
}
private void setTolMonitorMin(GateType gateType, DGateType dGateType, double tolMonitorMin)
{
if ((TolMonitorMode)tolMonitorMode1 == TolMonitorMode.Gate)
{
SetGateDAQ.TolMonitorMin(SelectAscan.sessionIndex, SelectAscan.port, gateType, tolMonitorMin);
}
else
{
SetDGateDAQ.TolMonitorMin(SelectAscan.sessionIndex, SelectAscan.port, dGateType, tolMonitorMin);
}
}
private void setTolMonitorSc(GateType gateType, DGateType dGateType, uint suppressCnt)
{
if ((TolMonitorMode)tolMonitorMode1 == TolMonitorMode.Gate)
{
SetGateDAQ.TolMonitorSc(SelectAscan.sessionIndex, SelectAscan.port, gateType, suppressCnt);
}
else
{
SetDGateDAQ.TolMonitorSc(SelectAscan.sessionIndex, SelectAscan.port, dGateType, suppressCnt);
}
}
private void radioButtonOff_Click(object sender, EventArgs e)
{
if (SetBatchDAQ.isOn)
{
SetBatchDAQ.AlarmActive(SelectAscan.sessionIndex, gateNum, GateAlarmActive.OFF);
}
else
{
SetGateDAQ.AlarmActive(SelectAscan.sessionIndex, SelectAscan.port, gateNum, GateAlarmActive.OFF);
}
//gatePara.gateLogicOnOff = true;
}
public static bool setTofMode(uint sessionIndex, uint port, GateType gateNum, TofMode tofMode)
{
int error_code;
bool isSetPre = false;
AscanWaveDectionMode waveMode = AscanWaveDectionMode.Rf;
IFActive iFGate = IFActive.OFF;
error_code = GetGateDAQ.IFActive(SelectAscan.sessionIndex, SelectAscan.port, GateType.I, ref iFGate);
if (error_code != 0)
{
return(isSetPre = true);
}
error_code = GetAsacnVideoDAQ.DetectionWaveMode(SelectAscan.sessionIndex, SelectAscan.port, ref waveMode);
if (error_code != 0)
{
return(isSetPre = true);
}
if (tofMode == TofMode.ZeroAfter || tofMode == TofMode.ZeroBefore)
{
if (waveMode != AscanWaveDectionMode.Rf)
{
MessageShow.show("Warn:TOF Mode = Zero Befor,Need to set Wave Mode->RF Mode!",
"警告：TOF模式为Zero Befor，必须设置检波模式为RF模式");
return(isSetPre = true);
}
else if ((gateNum == GateType.I) && (iFGate == IFActive.ON))
{
MessageShow.show("Warn:The function of IF Gate or IF Start has opened, can't Set!",
"警告：IF Gate 或 IF Start功能开启，不能设置!");
return(isSetPre = true);
}
}
else if (tofMode == TofMode.Peak)
{
if ((gateNum == GateType.I) && (iFGate == IFActive.ON))
{
MessageShow.show("Warn:The function of IF Gate or IF Start has opened, can't Set!",
"警告:IF Gate 或 IF Start功能开启，不能设置!");
return(isSetPre = true);
}
}
error_code = SetGateDAQ.tofMode(SelectAscan.sessionIndex, SelectAscan.port, gateNum, tofMode);
if (error_code != 0)
{
return(isSetPre = true);
}
return(isSetPre);
}
private void numUpDownSupressCount_Click(object sender, EventArgs e)
{
uint supressCount = Convert.ToUInt32(numUpDownSupressCount.Value);
if (SetBatchDAQ.isOn)
{
SetBatchDAQ.ScCounter(SelectAscan.sessionIndex, gateNum, supressCount);
}
else
{
SetGateDAQ.ScCounter(SelectAscan.sessionIndex, SelectAscan.port, gateNum, supressCount);
}
}
public static bool setTofMode(uint sessionIndex, GateType gateNum, TofMode tofMode)
{
bool isSetPre = false;
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
if (batchSessionsInfo[i].sessionIndex == sessionIndex)
{
isSetPre = SetGateDAQ.setTofMode(sessionIndex, (uint)batchSessionsInfo[i].port, gateNum, tofMode);
if (isSetPre)
{
break;
}
}
}
return(isSetPre);
}
public static int ScCounter(uint sessionIndex, GateType gateNum, uint supressCount)
{
int error_code = 0;
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
if (batchSessionsInfo[i].sessionIndex == sessionIndex)
{
error_code = SetGateDAQ.ScCounter(sessionIndex, (uint)batchSessionsInfo[i].port, gateNum, supressCount);
if (error_code != 0)
{
break;
}
}
}
return(error_code);
}
public static int AlarmLogic(uint sessionIndex, GateType gateNum, GateAlarmLogic logic)
{
int error_code = 0;
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
if (batchSessionsInfo[i].sessionIndex == sessionIndex)
{
error_code = SetGateDAQ.AlarmLogic(sessionIndex, (uint)batchSessionsInfo[i].port, gateNum, logic);
if (error_code != 0)
{
break;
}
}
}
return(error_code);
}
public static int GateIFActive(uint sessionIndex, GateType gateNum, IFActive active)
{
int error_code = 0;
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
if (batchSessionsInfo[i].sessionIndex == sessionIndex)
{
error_code = SetGateDAQ.iFActive(sessionIndex, (uint)batchSessionsInfo[i].port, gateNum, active);
if (error_code != 0)
{
break;
}
}
}
return(error_code);
}
public static int GateThreshold(uint sessionIndex, GateType gateNum, double threshold)
{
int error_code = 0;
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
if (batchSessionsInfo[i].sessionIndex == sessionIndex)
{
error_code = SetGateDAQ.Threshold(sessionIndex, (uint)batchSessionsInfo[i].port, gateNum, threshold);
if (error_code != 0)
{
break;
}
}
}
return(error_code);
}
private void setCheckBox(int tolMonitorIndex, GateType gateType, DGateType dGateType)
{
bool isCheckBoxChecked;
isCheckBoxChecked = ((CheckBox)(Controls.Find("checkBox" + tolMonitorIndex + "ON", true)[0])).Checked;
if (isCheckBoxChecked == true)
{
setControlsEnabled(tolMonitorIndex, true);
((RadioButton)(Controls.Find("dGate" + tolMonitorIndex, true)[0])).Checked = true;//Active double gate tolerance monitor defaultly
}
else
{
setControlsEnabled(tolMonitorIndex, false);
SetGateDAQ.TolMonitorActive(SelectAscan.sessionIndex, SelectAscan.port, gateType, TMActive.OFF);
SetDGateDAQ.TolMonitorActive(SelectAscan.sessionIndex, SelectAscan.port, dGateType, TMActive.OFF);
}
}
private void setGateDelay()
{
int error_code;
double delay = Convert.ToDouble(numUpDownDelay.Value);
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.GateDlay(SelectAscan.sessionIndex, gateNum, delay);
}
else
{
error_code = SetGateDAQ.Delay(SelectAscan.sessionIndex, SelectAscan.port, gateNum, delay);
}
if (error_code != 0)
{
return;
}
UpdateGateLine();
}
private void getGateTolMonitor(GateType gateType, DGateType dGatetType, int tolMonitorIndex)
{
int error_code;
double min = 0;
double max = 0;
uint suppressCnt = 0;
//Close double gate tolerance active
error_code = SetDGateDAQ.TolMonitorActive(SelectAscan.sessionIndex, SelectAscan.port, dGatetType, TMActive.OFF);
if (error_code != 0)
{
return;
}
//Open gate tolerance active
error_code = SetGateDAQ.TolMonitorActive(SelectAscan.sessionIndex, SelectAscan.port, gateType, TMActive.ON);
if (error_code != 0)
{
return;
}
error_code = GetGateDAQ.TolMonitorMax(SelectAscan.sessionIndex, SelectAscan.port, gateType, ref max);
if (error_code != 0)
{
return;
}
((NumericUpDown)(Controls.Find("numUpDownMax" + tolMonitorIndex, true)[0])).Text = max.ToString();
error_code = GetGateDAQ.TolMonitorMin(SelectAscan.sessionIndex, SelectAscan.port, gateType, ref min);
if (error_code != 0)
{
return;
}
((NumericUpDown)(Controls.Find("numUpDownMin" + tolMonitorIndex, true)[0])).Text = min.ToString();
error_code = GetGateDAQ.TolMonitorSc(SelectAscan.sessionIndex, SelectAscan.port, gateType, ref suppressCnt);
if (error_code != 0)
{
return;
}
((NumericUpDown)(Controls.Find("numUpDownSc" + tolMonitorIndex, true)[0])).Text = suppressCnt.ToString();
}
private void setGateThreshold()
{
int error_code;
double threshold = Convert.ToDouble(numUpDownThreshold.Value);
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.GateThreshold(SelectAscan.sessionIndex, gateNum, threshold);
}
else
{
error_code = SetGateDAQ.Threshold(SelectAscan.sessionIndex, SelectAscan.port, gateNum, threshold);
}
if (error_code != 0)
{
return;
}
UpdateGateLine();
}
private void setGateWidth()
{
int error_code;
double width = Convert.ToDouble(numUpDownWidth.Value);
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.GateWidth(SelectAscan.sessionIndex, gateNum, width);
}
else
{
error_code = SetGateDAQ.Width(SelectAscan.sessionIndex, SelectAscan.port, gateNum, width);
}
if (error_code != 0)
{
return;
}
UpdateGateLine();
}
private void numUpDownSupressCount_KeyPress(object sender, KeyPressEventArgs e)
{
uint supressCount = Convert.ToUInt32(numUpDownSupressCount.Value);
if (!(Char.IsNumber(e.KeyChar)) && e.KeyChar != (char)8)//(char)8 is the Key of BackSpace
{
e.Handled = true;
}
if (e.KeyChar == (char)Keys.Enter)
{
if (SetBatchDAQ.isOn)
{
SetBatchDAQ.ScCounter(SelectAscan.sessionIndex, gateNum, supressCount);
}
else
{
SetGateDAQ.ScCounter(SelectAscan.sessionIndex, SelectAscan.port, gateNum, supressCount);
}
}
}
/**Set alram logic to positive or negtive*/
private void setGateLogic(GateAlarmLogic logic)
{
int error_code;
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.AlarmLogic(SelectAscan.sessionIndex, gateNum, logic);
error_code |= SetBatchDAQ.AlarmActive(SelectAscan.sessionIndex, gateNum, GateAlarmActive.ON);
}
else
{
error_code = SetGateDAQ.AlarmLogic(SelectAscan.sessionIndex, SelectAscan.port, gateNum, logic);
error_code = SetGateDAQ.AlarmActive(SelectAscan.sessionIndex, SelectAscan.port, gateNum, GateAlarmActive.ON);
}
if (error_code != 0)
{
return;
}
}
private void checkBoxOn_Click(object sender, EventArgs e)
{
int error_code;
uint supressCount = 0;
if (checkBoxOn.Checked == true)
{
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.ScActive(SelectAscan.sessionIndex, gateNum, SuppressCounterActive.ON);
}
else
{
error_code = SetGateDAQ.ScActive(SelectAscan.sessionIndex, SelectAscan.port, gateNum, SuppressCounterActive.ON);
}
error_code |= GetGateDAQ.ScCounter(SelectAscan.sessionIndex, SelectAscan.port, gateNum, ref supressCount);
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.ScCounter(SelectAscan.sessionIndex, gateNum, supressCount);
}
if (error_code != 0)
{
checkBoxOn.Checked = false;
return;
}
numUpDownSupressCount.Enabled = true;
numUpDownSupressCount.Value = Convert.ToDecimal(supressCount);
}
else
{
error_code = SetGateDAQ.ScActive(SelectAscan.sessionIndex, SelectAscan.port, gateNum, SuppressCounterActive.OFF);
if (error_code != 0)
{
checkBoxOn.Checked = true;
return;
}
numUpDownSupressCount.Enabled = false;
}
}
private void setTofMode(TofMode tofMode, RadioButton rad)
{
bool isSetPre = false;
if (SetBatchDAQ.isOn)
{
isSetPre = SetBatchDAQ.setTofMode(SelectAscan.sessionIndex, gateNum, tofMode);
}
else
{
isSetPre = SetGateDAQ.setTofMode(SelectAscan.sessionIndex, SelectAscan.port, gateNum, tofMode);
}
if (isSetPre)
{
preRdo.Checked = true;
}
else
{
preRdo = rad;
}
}
/**Set Gate DAQ*/
private static int setGate(uint ascanNum, uint ascanPort, GateType gateType, PGate param)
{
int error_code;
error_code = SetGateDAQ.Delay(ascanNum, ascanPort, gateType, param.Delay);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.Width(ascanNum, ascanPort, gateType, param.Width);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.Threshold(ascanNum, ascanPort, gateType, param.Threshold);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.iFActive(ascanNum, ascanPort, gateType, param.IF);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.tofMode(ascanNum, ascanPort, gateType, param.TofMode);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DnsActive(ascanNum, ascanPort, gateType, param.DnsActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DnsBw(ascanNum, ascanPort, gateType, param.DnsBw);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DnsStart(ascanNum, ascanPort, gateType, param.DnsStart);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DnsStep(ascanNum, ascanPort, gateType, param.DnsStep);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.AlarmLogic(ascanNum, ascanPort, gateType, param.AlarmLogic);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.ScActive(ascanNum, ascanPort, gateType, param.ScActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.ScCounter(ascanNum, ascanPort, gateType, param.ScCounter);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DtsActive(ascanNum, ascanPort, gateType, param.DtsActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DtsBand(ascanNum, ascanPort, gateType, param.DtsBand);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DtsStart(ascanNum, ascanPort, gateType, param.DtsStart);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.DtsStep(ascanNum, ascanPort, gateType, param.DtsStep);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.TolMonitorActive(ascanNum, ascanPort, gateType, param.TolMonitorActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.TolMonitorMax(ascanNum, ascanPort, gateType, param.TolMonitorMax);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.TolMonitorMin(ascanNum, ascanPort, gateType, param.TolMonitorMin);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.TolMonitorSc(ascanNum, ascanPort, gateType, param.TolMonitorSc);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.AlarmActive(ascanNum, ascanPort, gateType, param.AlarmActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.AlarmMode(ascanNum, ascanPort, gateType, param.AlarmMode);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.AlarmSignalLength(ascanNum, ascanPort, gateType, param.AlarmSignalLength);
if (error_code != 0)
{
return(error_code);
}
//error_code = SetGateDAQ.AlarmTimeLength(ascanNum, gateType, param.);
//if (error_code != 0)
// return error_code;
error_code = SetGateDAQ.AlarmActiveLevel(ascanNum, ascanPort, gateType, param.AlarmActiveLevel);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.MeasActive(ascanNum, ascanPort, gateType, param.MeasActive);
if (error_code != 0)
{
return(error_code);
}
error_code = SetGateDAQ.MeasMode(ascanNum, ascanPort, gateType, param.MeasMode);
if (error_code != 0)
{
return(error_code);
}
return(error_code);
}
/*
* private void FormGatePosition_Paint(object sender, PaintEventArgs e)
* {
* e.Graphics.DrawLine(new Pen(SystemColors.GradientActiveCaption, 3), 1, 0, 1, this.Height);
* }
*/
private void checkBoxIF_Click(object sender, EventArgs e)
{
if ((int)gateNum == 0)
{
int error_code = 0;
TofMode tofMode = TofMode.Flank;
List <TofMode> list = new List <TofMode>();
list.Clear();
if (checkBoxIF.Checked)
{
if (SetBatchDAQ.isOn)
{
error_code = SetBatchDAQ.getTOfMode(SelectAscan.sessionIndex, GateType.I, list);
for (int i = 0; i < list.Count; i++)
{
if (list[i] != TofMode.Flank)
{
MessageShow.show("Warning:The TOF Mode GateI must select Flank mode!", "警告：门模式门I未选择Flank模式!");
checkBoxIF.Checked = false;
return;
}
}
error_code |= SetBatchDAQ.GateIFActive(SelectAscan.sessionIndex, GateType.I, IFActive.ON);
error_code |= SetBatchDAQ.AscanVideoIFActive(SelectAscan.sessionIndex, GateType.I, AscanIFActive.ON);
if (error_code != 0)
{
return;
}
}
else
{
error_code = GetGateDAQ.TofMode(SelectAscan.sessionIndex, SelectAscan.port, GateType.I, ref tofMode);
if (tofMode != TofMode.Flank)
{
MessageShow.show("Warning:The TOF Mode GateI must select Flank mode!", "警告：门模式门I未选择Flank模式!");
checkBoxIF.Checked = false;
return;
}
error_code |= SetGateDAQ.iFActive(SelectAscan.sessionIndex, SelectAscan.port, GateType.I, IFActive.ON);
error_code |= SetAscanVideoDAQ.IFActive(SelectAscan.sessionIndex, SelectAscan.port, AscanIFActive.ON);
if (error_code != 0)
{
return;
}
}
}
else
{
if (SetBatchDAQ.isOn)
{
error_code = SetGateDAQ.iFActive(SelectAscan.sessionIndex, SelectAscan.port, GateType.I, IFActive.OFF);
error_code |= SetAscanVideoDAQ.IFActive(SelectAscan.sessionIndex, SelectAscan.port, AscanIFActive.OFF);
}
{
error_code = SetGateDAQ.iFActive(SelectAscan.sessionIndex, SelectAscan.port, GateType.I, IFActive.OFF);
error_code |= SetAscanVideoDAQ.IFActive(SelectAscan.sessionIndex, SelectAscan.port, AscanIFActive.OFF);
}
if (error_code != 0)
{
return;
}
FormList.MDIChild.drawGateIWhenIfStartDisabled();
}
}
if ((int)gateNum == 1)
{
MessageShow.show("Warning:The Gate must select GateI!", "警告：门模式未选择门I!");
checkBoxIF.Checked = false;
return;
}
if ((int)gateNum == 2)
{
MessageShow.show("Warning:The Gate must select GateI!", "警告：门模式未选择门I!");
checkBoxIF.Checked = false;
return;
}
if ((int)gateNum == 3)
{
MessageShow.show("Warning:The Gate must select GateI!", "警告：门模式未选择门I!");
checkBoxIF.Checked = false;
return;
}
}
//使得筛选的通道和当前显示通道所有参数变得一样
public static int Param(uint sessionIndex, uint selPort)
{
int error_code = 0;
bool isSetPre = false;
double delay = 0;
double range = 0;
double gain = 0;
uint envlopDecay = 0;
AscanWaveDectionMode waveMode = AscanWaveDectionMode.SemiPositve;
RecieverType type = RecieverType.Pc;
AscanEnvelopActive envelopActive = AscanEnvelopActive.OFF;
int gateTol = 4;
TofMode tofMode = TofMode.Flank;
TofMode[] tofModeArr = new TofMode[gateTol];
GateAlarmLogic[] gateAlarmLogic = new GateAlarmLogic[gateTol];
GateAlarmActive[] gateAlarmActive = new GateAlarmActive[gateTol];
double[] gateDelay = new double[gateTol];
double[] gateWidth = new double[gateTol];
double[] threshold = new double[gateTol];
SuppressCounterActive[] scActive = new SuppressCounterActive[gateTol];
uint[] scCount = new uint[gateTol];
IFActive ifActive = IFActive.OFF;
AscanIFActive ascanIfActive = AscanIFActive.OFF;
//取得当前通道的所有参数
error_code = GetAsacnVideoDAQ.Delay(sessionIndex, selPort, ref delay);
error_code |= GetAsacnVideoDAQ.Range(sessionIndex, selPort, ref range);
error_code |= GetAsacnVideoDAQ.Range(sessionIndex, selPort, ref range);
error_code |= GetRecieverDAQ.AnalogGain(sessionIndex, selPort, ref gain);
error_code |= GetAsacnVideoDAQ.EnvlopDecayFactor(sessionIndex, selPort, ref envlopDecay);
error_code |= GetAsacnVideoDAQ.DetectionWaveMode(sessionIndex, selPort, ref waveMode);
error_code |= GetPulserTransmitDAQ.RecieverMode(sessionIndex, selPort, ref type);
error_code |= GetAsacnVideoDAQ.EnvlopActive(sessionIndex, selPort, ref envelopActive);
error_code |= GetGateDAQ.IFActive(sessionIndex, selPort, GateType.I, ref ifActive);
error_code |= GetAsacnVideoDAQ.IFActive(sessionIndex, selPort, ref ascanIfActive);
for (int i = 0; i < gateTol; i++)
{
GateType gateIndex = (GateType)i;
error_code |= GetGateDAQ.TofMode(sessionIndex, selPort, gateIndex, ref tofModeArr[i]);
error_code |= GetGateDAQ.AlarmLogic(sessionIndex, selPort, gateIndex, ref gateAlarmLogic[i]);
error_code |= GetGateDAQ.AlarmActive(sessionIndex, selPort, gateIndex, ref gateAlarmActive[i]);
error_code |= GetGateDAQ.Delay(sessionIndex, selPort, gateIndex, ref gateDelay[i]);
error_code |= GetGateDAQ.Width(sessionIndex, selPort, gateIndex, ref gateWidth[i]);
error_code |= GetGateDAQ.Threshold(sessionIndex, selPort, gateIndex, ref threshold[i]);
error_code |= GetGateDAQ.ScActive(sessionIndex, selPort, gateIndex, ref scActive[i]);
error_code |= GetGateDAQ.ScCounter(sessionIndex, selPort, gateIndex, ref scCount[i]);
}
if (error_code != 0)
{
return(error_code);
}
//赋值
for (int i = 0; i < batchSessionsInfo.Count; i++)
{
uint port = (uint)batchSessionsInfo[i].port;
uint seIndex = (uint)batchSessionsInfo[i].sessionIndex;
//第二种情况||batchSessionsInfo[i].sessionIndex ！= sessionIndex
//if (batchSessionsInfo[i].sessionIndex == sessionIndex && port != selPort )//以selPort号为依据配置同一块板卡的其他虚拟通道的参数
{
error_code = SetAscanVideoDAQ.Delay(seIndex, port, delay);
error_code |= SetAscanVideoDAQ.Range(seIndex, port, range);
error_code |= SetReceiverDAQ.AnalogGain(seIndex, port, gain);
error_code |= SetAscanVideoDAQ.EnvlopDecayFactor(seIndex, port, envlopDecay);
isSetPre = SetAscanVideoDAQ.WaveMode(seIndex, port, waveMode);
error_code |= SetPulserTransmitDAQ.RecieverMode(seIndex, port, type);
error_code |= SetAscanVideoDAQ.EnvlopActive(seIndex, port, envelopActive);
for (int j = 0; j < gateTol; j++)
{
GateType gateIndex = (GateType)j;
isSetPre |= SetGateDAQ.setTofMode(seIndex, port, gateIndex, tofModeArr[j]);
error_code |= SetGateDAQ.AlarmLogic(seIndex, port, gateIndex, gateAlarmLogic[j]);
error_code |= SetGateDAQ.AlarmActive(seIndex, port, gateIndex, gateAlarmActive[j]);
error_code |= SetGateDAQ.Delay(seIndex, port, gateIndex, gateDelay[j]);
error_code |= SetGateDAQ.Width(seIndex, port, gateIndex, gateWidth[j]);
error_code |= SetGateDAQ.Threshold(seIndex, port, gateIndex, threshold[j]);
error_code |= SetGateDAQ.ScActive(seIndex, port, gateIndex, scActive[j]);
error_code |= SetGateDAQ.ScCounter(seIndex, port, gateIndex, scCount[j]);
if (error_code != 0)
{
return(error_code);
}
}
error_code |= GetGateDAQ.TofMode(seIndex, port, GateType.I, ref tofMode);
if (ifActive == IFActive.ON && ascanIfActive == AscanIFActive.ON)
{
if (tofMode != TofMode.Flank)
{
MessageShow.show("Warning:" + seIndex + port + "The TOF Mode GateI must select Flank mode!",
"警告：" + sessionIndex + port + "门模式门I未选择Flank模式!");
return(error_code = -1);
}
else
{
error_code |= SetGateDAQ.iFActive(seIndex, port, GateType.I, IFActive.ON);
error_code |= SetAscanVideoDAQ.IFActive(seIndex, port, AscanIFActive.ON);
}
}
else
{
error_code |= SetGateDAQ.iFActive(seIndex, port, GateType.I, IFActive.OFF);
error_code |= SetAscanVideoDAQ.IFActive(seIndex, port, AscanIFActive.OFF);
}
if (error_code != 0)
{
return(error_code);
}
}
}
return(error_code);
}
