private void BtnStart_OnClick(object sender, RoutedEventArgs e)
{
if (IsRunning)
{
return;
}
//если пресс был зажат вручную - не стоит пробовать зажимать его ещё раз
ClampParameters.SkipClamping = Cache.Clamp.ManualClamping;
var commPar = new Types.Commutation.TestParameters()
{
BlockIndex = (!Cache.Clamp.UseTmax) ? Types.Commutation.HWBlockIndex.Block1 : Types.Commutation.HWBlockIndex.Block2,
CommutationType = ConverterUtil.MapCommutationType(CommType),
Position = ConverterUtil.MapModulePosition(ModPosition)
};
var parameters = new List <BaseTestParametersAndNormatives>(1);
parameters.Add(Parameters);
if (!Cache.Net.Start(commPar, ClampParameters, parameters))
{
return;
}
IsRunning = true;
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters)
{
_Parameters = Parameters;
if (_State == DeviceState.InProcess)
{
throw new Exception("TOU test is already started");
}
_Result = new TestResults()
{
TestTypeId = _Parameters.TestTypeId,
};
if (!_IsTOUEmulation)
{
//Считываем регистр состояния
var devState = (HWDeviceState)ReadRegister(REG_DEV_STATE);
//Проверяем на наличие ошибки либо отключения
CheckDevStateThrow(devState);
if (devState != HWDeviceState.Ready)
{
string error = "Launch test, TOU State not Ready, function Start";
SystemHost.Journal.AppendLog(ComplexParts.TOU, LogMessageType.Note, error);
throw new Exception(error);
}
}
MeasurementLogicRoutine(commParameters);
return(_State);
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters)
{
m_Parameters = Parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("IH test is already started.");
}
m_Result = new TestResults();
m_Result.TestTypeId = m_Parameters.TestTypeId;
m_Stop = false;
if (!m_IsEmulation)
{
//смотрим состояние Gate
m_IOGate.ClearWarning();
ushort State = m_IOGate.ReadDeviceState();
switch (State)
{
case (ushort)Types.Gate.HWDeviceState.Fault:
ushort faultReason = m_IOGate.ReadFaultReason();
FireNotificationEvent(ComplexParts.Gate, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, faultReason, (ushort)HWDisableReason.None);
break;
case (ushort)Types.Gate.HWDeviceState.Disabled:
ushort disableReason = m_IOGate.ReadDisableReason();
FireNotificationEvent(ComplexParts.Gate, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, disableReason);
break;
}
//смотрим состояние StLs
m_IOStLs.ClearWarning();
State = m_IOStLs.ReadDeviceState();
switch (State)
{
case (ushort)Types.VTM.HWDeviceState.Fault:
ushort faultReason = m_IOStLs.ReadFaultReason();
FireNotificationEvent(ComplexParts.SL, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, faultReason, (ushort)HWDisableReason.None);
break;
case (ushort)Types.VTM.HWDeviceState.Disabled:
ushort disableReason = m_IOStLs.ReadDisableReason();
FireNotificationEvent(ComplexParts.SL, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, disableReason);
break;
}
}
MeasurementLogicRoutine(commParameters);
return(m_State);
}
internal DeviceState Start(Types.BVT.TestParameters parameters, Types.Commutation.TestParameters commParameters)
{
m_Parameters = parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("BVT test is already started");
}
m_Result = new Types.BVT.TestResults {
TestTypeId = parameters.TestTypeId
};
m_Stop = false;
ClearWarning();
if (!m_IsBVTEmulation)
{
var devState = (Types.BVT.HWDeviceState)ReadRegister(REG_DEVICE_STATE);
if (devState == Types.BVT.HWDeviceState.Fault)
{
var faultReason = (Types.BVT.HWFaultReason)ReadRegister(REG_FAULT_REASON);
FireNotificationEvent(Types.BVT.HWProblemReason.None, Types.BVT.HWWarningReason.None, faultReason,
Types.BVT.HWDisableReason.None);
throw new Exception(string.Format("BVT is in fault state, reason: {0}", faultReason));
}
if (devState == Types.BVT.HWDeviceState.Disabled)
{
var disableReason = (Types.BVT.HWDisableReason)ReadRegister(REG_DISABLE_REASON);
FireNotificationEvent(Types.BVT.HWProblemReason.None, Types.BVT.HWWarningReason.None,
Types.BVT.HWFaultReason.None, disableReason);
throw new Exception(string.Format("BVT is in disabled state, reason: {0}", disableReason));
}
}
m_State = DeviceState.InProcess;
FireBvtAllEvent(m_State);
MeasurementLogicRoutine(commParameters);
if (m_State != DeviceState.Success)
{
FireBvtAllEvent(m_State);
}
return(m_State);
}
private void BtnStart_OnClick(object sender, RoutedEventArgs e)
{
if (VM.IsRunning)
{
return;
}
VM.IsRunning = true;
var paramGate = new Types.Gate.TestParameters {
IsEnabled = false
};
var paramVtm = new Types.VTM.TestParameters {
IsEnabled = false
};
var paramBvt = new Types.BVT.TestParameters {
IsEnabled = false
};
var paramATU = new Types.ATU.TestParameters {
IsEnabled = false
};
var paramQrrTq = new Types.QrrTq.TestParameters {
IsEnabled = false
};
var paramIH = new Types.IH.TestParameters {
IsEnabled = false
};
var paramRCC = new Types.RCC.TestParameters {
IsEnabled = false
};
//если пресс был зажат вручную - не стоит пробовать зажимать его ещё раз
VM.Clamping.SkipClamping = Cache.Clamp.ManualClamping;
Types.Commutation.TestParameters commutation = new Types.Commutation.TestParameters()
{
BlockIndex = (!Cache.Clamp.UseTmax) ? Types.Commutation.HWBlockIndex.Block1 : Types.Commutation.HWBlockIndex.Block2,
CommutationType = ConverterUtil.MapCommutationType(VM.CommutationType),
Position = ConverterUtil.MapModulePosition(VM.Position)
};
if (!Cache.Net.Start(paramGate, paramVtm, paramBvt, paramATU, paramQrrTq, paramIH, paramRCC, commutation, VM.Clamping, VM.TOU))
{
return;
}
ClearStatus();
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters, out RCCResult resultRCC)
{
m_Parameters = Parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("RCC test is already started.");
}
m_Result = new TestResults();
m_Result.TestTypeId = m_Parameters.TestTypeId;
m_Stop = false;
if (!m_IsEmulation)
{
//результат прозвонки цепи катод-катод не определён
resultRCC = RCCResult.OPRESULT_NONE;
//смотрим состояние Gate
m_IOGate.ClearWarning();
ushort State = m_IOGate.ReadDeviceState();
switch (State)
{
case (ushort)Types.Gate.HWDeviceState.Fault:
ushort faultReason = m_IOGate.ReadFaultReason();
FireNotificationEvent(ComplexParts.Gate, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, faultReason, (ushort)HWDisableReason.None);
return((DeviceState)State);
case (ushort)Types.Gate.HWDeviceState.Disabled:
ushort disableReason = m_IOGate.ReadDisableReason();
FireNotificationEvent(ComplexParts.Gate, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, disableReason);
return((DeviceState)State);
}
}
MeasurementLogicRoutine(commParameters);
resultRCC = m_Result.RCC;
return(m_State);
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
FireAllEvent(m_State);
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.Gate, Commutation.CommutationType, Commutation.Position) ==
DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireAllEvent(m_State);
return;
}
if (Kelvin())
{
Resistance();
IgtVgt();
Ih();
Il();
}
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireAllEvent(m_State);
return;
}
m_State = m_Stop ? DeviceState.Stopped : DeviceState.Success;
FireAllEvent(m_State);
}
catch (Exception ex)
{
m_IOCommutation.Switch(Types.Commutation.CommutationMode.None);
m_State = DeviceState.Fault;
FireAllEvent(m_State);
FireExceptionEvent(ex.Message);
throw;
}
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters)
{
m_Parameters = Parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("dVdt test is already started");
}
m_Result = new TestResults()
{
TestTypeId = m_Parameters.TestTypeId,
Mode = m_Parameters.Mode,
VoltageRate = (ushort)Parameters.VoltageRate
};
m_Stop = false;
ClearWarning();
if (!m_IsdVdtEmulation)
{
var devState = (HWDeviceState)ReadRegister(REG_DEVICE_STATE);
if (devState == HWDeviceState.Fault)
{
var faultReason = (HWFaultReason)ReadRegister(REG_FAULT_REASON);
FireNotificationEvent(HWWarningReason.None, faultReason,
HWDisableReason.None);
throw new Exception(string.Format("dVdt is in fault state, reason: {0}", faultReason));
}
if (devState == HWDeviceState.Disabled)
{
var disableReason = (HWDisableReason)ReadRegister(REG_DISABLE_REASON);
FireNotificationEvent(HWWarningReason.None,
HWFaultReason.None, disableReason);
throw new Exception(string.Format("dVdt is in disabled state, reason: {0}", disableReason));
}
}
MeasurementLogicRoutine(commParameters);
return(m_State);
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
//уведомляем UI о том, что мы находимся в состоянии m_State с результатами измерений m_Result
FireEvent(m_State, m_Result);
if (m_IsEmulation)
{
//эмулируем успешный результат измерений
m_State = DeviceState.Success;
m_Result.RCC = RCCResult.OPRESULT_OK;
}
else
{
//включаем требуемую коммутацию
m_IOCommutation.WriteRegister(IOCommutation.REG_MODULE_TYPE, (ushort)Commutation.CommutationType);
m_IOCommutation.CallAction(IOCommutation.ACT_COMM2_RCC);
//запускаем прозвонку цепи катод-катод
m_IOGate.CallAction(IOGate.ACT_START_RCC);
WaitForEndOfGateTest();
//прозвонка цепи катод-катод успешно исполнена
m_State = DeviceState.Success;
//считываем значение регистра результата
m_Result.RCC = (RCCResult)m_IOGate.ReadRegister(IOGate.REG_TEST_FINISHED);
}
FireEvent(m_State, m_Result);
}
catch (Exception e)
{
m_State = DeviceState.Fault;
FireEvent(m_State, m_Result);
FireExceptionEvent(e.Message);
throw;
}
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters)
{
m_Parameters = Parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("QrrTq test is already started.");
}
//запоминаем в каком режиме будут выполняться измерения
m_Result = new TestResults {
Mode = m_Parameters.Mode, OffStateVoltage = m_Parameters.OffStateVoltage, OsvRate = (ushort)m_Parameters.OsvRate
};
m_Result.TestTypeId = m_Parameters.TestTypeId;
m_Stop = false;
if (!m_IsEmulation)
{
ushort State = ReadRegister(REG_DEV_STATE);
switch (State)
{
case (ushort)HWDeviceState.DS_Fault:
ushort faultReason = ReadRegister(REG_FAULT_REASON);
FireNotificationEvent((ushort)HWProblemReason.None, (ushort)HWWarningReason.None, faultReason, (ushort)HWDisableReason.None);
break;
case (ushort)HWDeviceState.DS_Disabled:
ushort disableReason = ReadRegister(REG_DISABLE_REASON);
FireNotificationEvent((ushort)HWProblemReason.None, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, disableReason);
break;
}
}
MeasurementLogicRoutine(commParameters);
return(m_State);
}
internal DeviceState Start(TestParameters Parameters, Types.Commutation.TestParameters commParameters)
{
m_Parameters = Parameters;
if (m_State == DeviceState.InProcess)
{
throw new Exception("ATU test is already started.");
}
m_Result = new TestResults();
m_Result.TestTypeId = m_Parameters.TestTypeId;
m_Stop = false;
if (!m_IsATUEmulation)
{
ushort State = ReadRegister(REG_DEV_STATE);
switch (State)
{
case (ushort)HWDeviceState.DS_Fault:
ushort faultReason = ReadRegister(REG_FAULT_REASON);
FireNotificationEvent((ushort)HWWarningReason.None, faultReason, (ushort)HWDisableReason.None);
throw new Exception(string.Format("ATU is in 'DS_Fault' state, reason: {0}", faultReason));
case (ushort)HWDeviceState.DS_Disabled:
ushort disableReason = ReadRegister(REG_DISABLE_REASON);
FireNotificationEvent((ushort)HWWarningReason.None, (ushort)HWFaultReason.None, disableReason);
throw new Exception(string.Format("ATU is in 'DS_Disabled' state, reason: {0}", disableReason));
}
}
MeasurementLogicRoutine(commParameters);
return(m_State);
}
private void BtnStart_OnClick(object sender, RoutedEventArgs e)
{
UserSettings.Default.ShuntResistance = TextBoxResistance.Text;
UserSettings.Default.Save();
StartButtonEnabled(false);
ClearStatus();
CommType = Settings.Default.SinglePositionModuleMode ? Types.Commutation.ModuleCommutationType.Direct : Types.Commutation.ModuleCommutationType.MT3;
var commPar = new Types.Commutation.TestParameters()
{
BlockIndex = (!Cache.Clamp.UseTmax) ? Types.Commutation.HWBlockIndex.Block1 : Types.Commutation.HWBlockIndex.Block2,
CommutationType = ConverterUtil.MapCommutationType(CommType),
Position = ConverterUtil.MapModulePosition(ModPosition)
};
//если пресс был зажат вручную - не стоит пробовать зажимать его ещё раз
ClampParameters.SkipClamping = Cache.Clamp.ManualClamping;
var parameters = new List <BaseTestParametersAndNormatives>(1);
parameters.Add(Parameters);
Cache.Net.Start(commPar, ClampParameters, parameters);
}
bool IExternalControl.Start(Types.Gate.TestParameters ParametersGate, Types.VTM.TestParameters ParametersSL,
Types.BVT.TestParameters ParametersBvt, Types.ATU.TestParameters ParametersAtu, Types.QrrTq.TestParameters ParametersQrrTq, Types.IH.TestParameters ParametersIH, Types.RCC.TestParameters ParametersRCC,
Types.Commutation.TestParameters ParametersComm, Types.Clamping.TestParameters ParametersClamp, Types.TOU.TestParameters ParametersTOU)
{
return(_IoMain.Start(ParametersGate, ParametersSL, ParametersBvt, ParametersAtu, ParametersQrrTq, ParametersIH, ParametersRCC, ParametersComm, ParametersClamp, ParametersTOU));
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
FireVTMEvent(m_State, m_Result, 0);
var timeStamp = Environment.TickCount + m_Timeout;
if (!m_IsSLEmulation)
{
while (Environment.TickCount < timeStamp)
{
var devState = (Types.VTM.HWDeviceState)ReadRegister(REG_DEVICE_STATE, true);
if (devState == Types.VTM.HWDeviceState.PowerReady)
{
break;
}
Thread.Sleep(50);
}
}
if (Environment.TickCount > timeStamp)
{
m_State = DeviceState.Fault;
return;
}
if (!m_Parameter.IsSelfTest)
{
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.VTM, Commutation.CommutationType, Commutation.Position) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireVTMEvent(m_State, m_Result, 0);
return;
}
}
var current = 0;
if (!m_IsSLEmulation)
{
if (m_Parameter.IsSelfTest)
{
m_Result.CapacitorsArray = new List <float>
{
ReadRegister(REG_V11, true) / 10.0f,
ReadRegister(REG_V12, true) / 10.0f,
ReadRegister(REG_V21, true) / 10.0f,
ReadRegister(REG_V22, true) / 10.0f,
ReadRegister(REG_V31, true) / 10.0f,
ReadRegister(REG_V32, true) / 10.0f,
ReadRegister(REG_V41, true) / 10.0f,
ReadRegister(REG_V42, true) / 10.0f,
ReadRegister(REG_V51, true) / 10.0f,
ReadRegister(REG_V52, true) / 10.0f
};
CallAction(ACT_RUN_SELF_TEST);
for (var i = 0; i < m_Result.CapacitorsArray.Count; i++)
{
if (m_Result.CapacitorsArray[i] > 100)
{
m_Result.CapacitorsArray[i] = 100;
}
}
}
else
{
switch (m_Parameter.TestType)
{
case Types.VTM.VTMTestType.Ramp:
{
WriteRegister(REG_MEASUREMENT_TYPE, MEASURE_RAMP);
WriteRegister(REG_RAMP_DESIRED_CURRENT, m_Parameter.RampCurrent);
WriteRegister(REG_RAMP_DESIRED_TIME, m_Parameter.RampTime);
WriteRegister(REG_HEATING_ENABLE, (ushort)(m_Parameter.IsRampOpeningEnabled ? 1 : 0));
if (m_Parameter.IsRampOpeningEnabled)
{
WriteRegister(REG_HEATING_CURRENT, m_Parameter.RampOpeningCurrent);
WriteRegister(REG_HEATING_TIME, m_Parameter.RampOpeningTime);
}
current = m_Parameter.RampCurrent;
}
break;
case Types.VTM.VTMTestType.Sinus:
{
WriteRegister(REG_MEASUREMENT_TYPE, MEASURE_SIN);
WriteRegister(REG_SIN_DESIRED_CURRENT, m_Parameter.SinusCurrent);
WriteRegister(REG_SIN_DESIRED_TIME, m_Parameter.SinusTime);
current = m_Parameter.SinusCurrent;
}
break;
case Types.VTM.VTMTestType.Curve:
{
WriteRegister(REG_MEASUREMENT_TYPE, MEASURE_S_CURVE);
WriteRegister(REG_SCURVE_DESIRED_CURRENT, m_Parameter.CurveCurrent);
WriteRegister(REG_SCURVE_DESIRED_TIME, m_Parameter.CurveTime);
WriteRegister(REG_SCURVE_ADD_TIME, m_Parameter.CurveAddTime);
WriteRegister(REG_SCURVE_FACTOR, m_Parameter.CurveFactor);
current = m_Parameter.CurveCurrent;
}
break;
}
WriteRegister(REG_USE_FULL_SCALE, (ushort)(m_Parameter.UseFullScale ? 1 : 0));
WriteRegister(REG_DISABLE_VTM_PP, (ushort)(m_Parameter.UseLsqMethod ? 0 : 1));
WriteRegister(REG_REPETITION_COUNT, m_Parameter.Count);
CallAction(ACT_START_TEST);
}
m_State = WaitForEndOfTest();
}
else
{
m_State = DeviceState.Success;
}
if (!m_Parameter.IsSelfTest)
{
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireVTMEvent(m_State, m_Result, 0);
return;
}
}
m_Result.IsSelftest = m_Parameter.IsSelfTest;
if (m_IsSLEmulation)
{
m_Result.Voltage = EMU_DEFAULT_VTM;
m_Result.Current = EMU_DEFAULT_ITM;
}
else
{
m_Result.Voltage = ReadRegister(REG_TEST_RESULT);
m_Result.Current = ReadRegister(REG_TEST_CURRENT_RESULT);
if (m_ReadGraph)
{
m_Result.DesiredArray = ReadArrayFastS(ARR_SCOPE_DESIRED);
m_Result.ITMArray = ReadArrayFastS(ARR_SCOPE_ITM);
m_Result.VTMArray = ReadArrayFastS(ARR_SCOPE_VTM);
}
if (m_Parameter.IsSelfTest)
{
m_Result.SelfTestArray = ReadArrayFastS(ARR_SELF_TEST);
}
}
FireVTMEvent(m_State, m_Result, current);
}
catch (Exception ex)
{
if (!m_Parameter.IsSelfTest)
{
m_IOCommutation.Switch(Types.Commutation.CommutationMode.None);
}
m_State = DeviceState.Fault;
FireVTMEvent(DeviceState.Fault, m_Result, 0);
FireExceptionEvent(ex.Message);
throw;
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
//сбрасываем возможные предупреждения
CallAction(ACT_CLR_WARNING);
//уведомляем UI о том, что мы находимся в состоянии m_State с результатами измерений m_Result
FireQrrTqEvent(m_State, m_Result);
//пишем тип измерения
WriteRegister(REG_MODE, (ushort)m_Parameters.Mode);
//пишем амплитуду прямого тока (в А)
WriteRegister(REG_DIRECT_CURRENT, m_Parameters.DirectCurrent);
//пишем длительность импульса прямого тока (в мкс)
WriteRegister(REG_DC_PULSE_WIDTH, m_Parameters.DCPulseWidth);
//пишем скорость нарастания прямого тока (в А/мкс)
WriteRegister(REG_DC_RISE_RATE, (ushort)(m_Parameters.DCRiseRate * 10));
//пишем скорость спада тока (в А/мкс)
ushort DCFallRate = (ushort)m_Parameters.DCFallRate;
WriteRegister(REG_DC_FALL_RATE, (ushort)(DCFallRate * 10));
//пишем прямое повторное напряжение (в В)
WriteRegister(REG_OFF_STATE_VOLTAGE, m_Parameters.OffStateVoltage);
//пишем скорость нарастания прямого повторного напряжения (в В/мкс)
if (m_Parameters.Mode == TMode.QrrTq)
{
ushort OsvRate = (ushort)m_Parameters.OsvRate;
WriteRegister(REG_OSV_RATE, OsvRate);
}
//пишем метод измерения Trr "Измерение trr по методу 90%-50%"
int TrrMeasureBy9050Method = m_Parameters.TrrMeasureBy9050Method == false ? 0 : 1;
WriteRegister(REG_TRR_MEASURE_BY_9050_METHOD, (ushort)TrrMeasureBy9050Method);
if (m_IsEmulation)
{
//эмулируем успешный результат измерений
m_State = DeviceState.Success;
Random rnd = new Random();
FireKindOfFreezingEvent((ushort)rnd.Next(1, 1000));
m_Result.Idc = 1;
m_Result.Qrr = 2 / 10f;
m_Result.Irr = 3;
m_Result.Trr = 4 / 10f;
m_Result.DCFactFallRate = 6 / 10f;
m_Result.Tq = 5 / 10f;
if (m_NeedReadGraf)
{
for (int i = 1; i <= 2000; i++)
{
//эмуляция графика тока
m_Result.CurrentData.Add(1500);
//эмуляция графика напряжения
m_Result.VoltageData.Add(600);
}
}
//проверяем отображение Problem, Warning, Fault
FireNotificationEvent(7, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, (ushort)HWDisableReason.None);
FireNotificationEvent((ushort)HWProblemReason.None, 2, (ushort)HWFaultReason.None, (ushort)HWDisableReason.None);
FireNotificationEvent((ushort)HWProblemReason.None, (ushort)HWWarningReason.None, 1, (ushort)HWDisableReason.None);
}
else
{
//запускаем процесс измерения
CallAction(ACT_START_TEST);
//ждём окончания процесса измерения
m_State = WaitForEndOfTest();
//если тест успешно завершён - считываем результаты измерения из блока QrrTq
if (m_State == DeviceState.Success)
{
//если значение регистра REG_FINISHED содержит значение 1 (OPRESULT_OK), то можно считать оцифрованные значения тока из EP_SlaveData и результаты измерений из соответствующих регистров
ushort finishedResult = ReadRegister(REG_FINISHED);
if ((HWFinishedResult)finishedResult == HWFinishedResult.Ok)
{
m_Result.Idc = ReadRegisterS(REG_RES_IDC);
//значения Qrr, Irr, Trr надо читать только в режиме измерения 'Qrr'
if (m_Parameters.Mode == TMode.Qrr)
{
//в регистре хранится умноженное на 10 значение
m_Result.Qrr = ReadRegisterS(REG_RES_QRR) / 10f;
m_Result.Irr = ReadRegisterS(REG_RES_IRR);
//в регистре хранится умноженное на 10 значение
m_Result.Trr = ReadRegisterS(REG_RES_TRR) / 10f;
}
//в регистре хранится умноженное на 10 значение
m_Result.DCFactFallRate = ReadRegisterS(REG_RES_DC_FACT_FALL_RATE) / 10f;
//читаем из регистра измеренное значение Tq только в режиме измерения Tq
m_Result.Tq = m_Parameters.Mode == TMode.QrrTq ? ReadRegisterS(REG_RES_TQ) / 10f : 0;
//если нужно читать данные для построения графиков - читаем их
if (m_NeedReadGraf)
{
ReadArrays(m_Result);
}
}
}
}
FireQrrTqEvent(m_State, m_Result);
}
catch (Exception e)
{
m_State = DeviceState.Fault;
FireQrrTqEvent(m_State, m_Result);
FireExceptionEvent(e.Message);
throw;
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters commutation)
{
var internalState = DeviceState.InProcess;
var data = new List <BvtInputParameters>()
{
new BvtInputParameters
{
TestType = m_Parameters.TestType,
CurrentLimit = m_Parameters.CurrentLimit,
PlateTime = m_Parameters.PlateTime,
RampUpVoltage = m_Parameters.RampUpVoltage,
StartVoltage = m_Parameters.StartVoltage,
VoltageFrequency = m_Parameters.VoltageFrequency,
FrequencyDivisor = m_Parameters.FrequencyDivisor,
VoltageLimitD = m_Parameters.VoltageLimitD,
VoltageLimitR = m_Parameters.VoltageLimitR,
MeasurementMode = m_Parameters.MeasurementMode,
IsUdsmUrsm = false
}
};
if (m_Parameters.UseUdsmUrsm)
{
data.Add(new BvtInputParameters()
{
TestType = m_Parameters.UdsmUrsmTestType,
CurrentLimit = m_Parameters.UdsmUrsmCurrentLimit,
PlateTime = m_Parameters.UdsmUrsmPlateTime,
RampUpVoltage = m_Parameters.UdsmUrsmRampUpVoltage,
StartVoltage = m_Parameters.UdsmUrsmStartVoltage,
VoltageFrequency = m_Parameters.UdsmUrsmVoltageFrequency,
FrequencyDivisor = m_Parameters.UdsmUrsmFrequencyDivisor,
VoltageLimitD = m_Parameters.UdsmUrsmVoltageLimitD,
VoltageLimitR = m_Parameters.UdsmUrsmVoltageLimitR,
MeasurementMode = BVTMeasurementMode.ModeI,
IsUdsmUrsm = true
});
}
foreach (var bvtInputParameter in data)
{
try
{
WriteRegister(REG_LIMIT_CURRENT, (ushort)(bvtInputParameter.CurrentLimit * 10));
WriteRegister(REG_PLATE_TIME, bvtInputParameter.PlateTime);
WriteRegister(REG_RAMPUP_RATE, (ushort)(bvtInputParameter.RampUpVoltage * 10));
WriteRegister(REG_START_VOLTAGE, bvtInputParameter.StartVoltage);
WriteRegister(REG_VOLTAGE_FREQUENCY, bvtInputParameter.VoltageFrequency);
WriteRegister(REG_FREQUENCY_DIVISOR, bvtInputParameter.FrequencyDivisor);
WriteRegister(REG_MEASUREMENT_MODE,
bvtInputParameter.MeasurementMode == Types.BVT.BVTMeasurementMode.ModeI
? MEASURE_MODE_I
: MEASURE_MODE_V);
if (bvtInputParameter.TestType == Types.BVT.BVTTestType.Both ||
bvtInputParameter.TestType == Types.BVT.BVTTestType.Direct)
{
internalState = DeviceState.InProcess;
FireBvtEvent(internalState, m_Result, BVTTestType.Direct, bvtInputParameter.IsUdsmUrsm);
if (m_IOCommutation.Switch(commutation.CommutationType == HWModuleCommutationType.Reverse ?
CommutationMode.BVTR : CommutationMode.BVTD
, commutation.CommutationType, commutation.Position) ==
DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireBvtAllEvent(m_State);
return;
}
WriteRegister(REG_LIMIT_VOLTAGE, bvtInputParameter.VoltageLimitD);
WriteRegister(REG_MEASUREMENT_TYPE, MEASURE_TYPE_AC_D);
CallAction(ACT_START_TEST);
if (!m_IsBVTEmulation)
{
internalState = WaitForEndOfTest();
if (bvtInputParameter.IsUdsmUrsm)
{
m_Result.VDSM = (ushort)Math.Abs(ReadRegisterS(REG_RESULT_V));
m_Result.IDSM = Math.Abs(ReadRegisterS(REG_RESULT_I) / 10.0f);
}
else
{
m_Result.VDRM = (ushort)Math.Abs(ReadRegisterS(REG_RESULT_V));
m_Result.IDRM = Math.Abs(ReadRegisterS(REG_RESULT_I) / 10.0f);
}
if (m_ReadGraph)
{
ReadArrays(m_Result, true);
}
}
else
{
internalState = DeviceState.Success;
if (bvtInputParameter.IsUdsmUrsm)
{
m_Result.VDSM = Convert.ToUInt16(EMU_DEFAULT_VDRM * new Random((int)DateTime.Now.Ticks).NextDouble());
m_Result.IDSM = Convert.ToUInt16(EMU_DEFAULT_IDRM * 300 * new Random((int)DateTime.Now.Ticks).NextDouble());
}
else
{
m_Result.VDRM = Convert.ToUInt16(EMU_DEFAULT_VDRM * new Random((int)DateTime.Now.Ticks).NextDouble());
m_Result.IDRM = Convert.ToUInt16(EMU_DEFAULT_IDRM * 300 * new Random((int)DateTime.Now.Ticks).NextDouble());
}
}
FireBvtEvent(internalState, m_Result, BVTTestType.Direct, bvtInputParameter.IsUdsmUrsm);
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireBvtAllEvent(m_State);
return;
}
}
else
{
internalState = DeviceState.Success;
}
if ((internalState == DeviceState.Success) &&
(bvtInputParameter.TestType == Types.BVT.BVTTestType.Both ||
bvtInputParameter.TestType == Types.BVT.BVTTestType.Reverse))
{
internalState = DeviceState.InProcess;
FireBvtEvent(internalState, m_Result, BVTTestType.Reverse, bvtInputParameter.IsUdsmUrsm);
if (m_IOCommutation.Switch(commutation.CommutationType == HWModuleCommutationType.Reverse ?
CommutationMode.BVTD: CommutationMode.BVTR, commutation.CommutationType, commutation.Position) ==
DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireBvtAllEvent(m_State);
return;
}
WriteRegister(REG_LIMIT_VOLTAGE, bvtInputParameter.VoltageLimitR);
WriteRegister(REG_MEASUREMENT_TYPE, MEASURE_TYPE_AC_R);
CallAction(ACT_START_TEST);
if (!m_IsBVTEmulation)
{
internalState = WaitForEndOfTest();
if (bvtInputParameter.IsUdsmUrsm)
{
m_Result.VRSM = (ushort)Math.Abs(ReadRegisterS(REG_RESULT_V));
m_Result.IRSM = Math.Abs(ReadRegisterS(REG_RESULT_I) / 10.0f);
}
else
{
m_Result.VRRM = (ushort)Math.Abs(ReadRegisterS(REG_RESULT_V));
m_Result.IRRM = Math.Abs(ReadRegisterS(REG_RESULT_I) / 10.0f);
}
if (m_ReadGraph)
{
ReadArrays(m_Result, false);
}
}
else
{
internalState = DeviceState.Success;
if (bvtInputParameter.IsUdsmUrsm)
{
m_Result.VRSM = Convert.ToUInt16(EMU_DEFAULT_VRRM * new Random((int)DateTime.Now.Ticks).NextDouble());
m_Result.IRSM = Convert.ToUInt16(EMU_DEFAULT_IRRM * 300 * new Random((int)DateTime.Now.Ticks).NextDouble());
}
else
{
m_Result.VRRM = Convert.ToUInt16(EMU_DEFAULT_VRRM * new Random((int)DateTime.Now.Ticks).NextDouble());
m_Result.IRRM = Convert.ToUInt16(EMU_DEFAULT_IRRM * 300 * new Random((int)DateTime.Now.Ticks).NextDouble());
}
}
FireBvtEvent(internalState, m_Result, BVTTestType.Reverse, bvtInputParameter.IsUdsmUrsm);
}
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
FireBvtAllEvent(m_State);
return;
}
m_State = internalState;
}
catch (Exception ex)
{
m_IOCommutation.Switch(Types.Commutation.CommutationMode.None);
m_State = DeviceState.Fault;
FireBvtAllEvent(m_State);
FireExceptionEvent(ex.Message);
throw;
}
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
//уведомляем UI о том, что мы находимся в состоянии m_State с результатами измерений m_Result
FireEvent(m_State, m_Result);
m_IOCommutation.CallAction(IOCommutation.ACT_COMM_IH);
try
{
m_IOGate.WriteRegister(130, 1);
try
{
m_IOGate.CallAction(IOGate.ACT_START_IH);//102
m_IOStLs.WriteRegister(128, 1);
m_IOStLs.WriteRegister(140, m_Parameters.Itm);
m_IOStLs.WriteRegister(141, 10000);
m_IOStLs.WriteRegister(160, 1);
m_IOStLs.CallAction(100);
if (m_IsEmulation)
{
//эмулируем успешный результат измерений
m_State = DeviceState.Success;
m_Result.Ih = 10;
//проверяем отображение Problem, Warning, Fault
FireNotificationEvent(ComplexParts.IH, 7, (ushort)HWWarningReason.None, (ushort)HWFaultReason.None, (ushort)HWDisableReason.None);
FireNotificationEvent(ComplexParts.IH, (ushort)HWProblemReason.None, 2, (ushort)HWFaultReason.None, (ushort)HWDisableReason.None);
FireNotificationEvent(ComplexParts.IH, (ushort)HWProblemReason.None, (ushort)HWWarningReason.None, 1, (ushort)HWDisableReason.None);
}
else
{
if (WaitForEndOfSLTest() == DeviceState.Success)
{
WaitForEndOfGateTest();
//тесты в обоих блоках завершились успешно, поэтому читаем регистры результатов
m_State = DeviceState.Success;
m_Result.Ih = m_IOGate.ReadRegister(201);
}
}
}
finally
{
//регистр 130 не зависимо от результата измерения надо выставить в ноль
m_IOGate.WriteRegister(130, 0);
}
}
finally
{
//выполняем команду 110 на блоке коммутации
m_IOCommutation.CallAction(110);
}
FireEvent(m_State, m_Result);
}
catch (Exception e)
{
m_State = DeviceState.Fault;
FireEvent(m_State, m_Result);
FireExceptionEvent(e.Message);
throw;
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
FiredVdtEvent(m_State, m_Result);
WriteRegister(REG_DESIRED_VOLTAGE, m_Parameters.Voltage);
//перед измерением dVdt исполняем команду включения коммутации см. требование http://elma.pe.local/Tasks/Task/Execute/108699
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.DVDT, Commutation.CommutationType, Commutation.Position) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
m_Result.Passed = false;
FiredVdtEvent(m_State, m_Result);
return;
}
if (m_IsdVdtEmulation)
{
//в режиме эмуляции эмулируем успешный результат проверки
m_State = DeviceState.Success;
m_Result.Passed = true;
//значение VoltageRate имеет смысл только для режима "Определение"
if (m_Parameters.Mode == DvdtMode.Detection)
{
m_Result.VoltageRate = 2200;
}
else
{
m_Result.VoltageRate = 0;
}
}
else
{
if (m_Parameters.Mode == DvdtMode.Confirmation)
{
//режим "Подтверждение" (Confirmation)
bool opened = false;
ushort testCount = 0;
//повторяем тест подтверждения столько раз, сколько задано в параметре "Число повторений теста подтверждения", тест имеет смысл пока прибор не открылся. если прибор открылся - он считается браком, повторять тест подтверждения для бракованного прибора нет смысла
while ((!opened) && (testCount < m_Parameters.ConfirmationCount))
{
switch (m_Parameters.VoltageRate)
{
case VoltageRate.V500:
CallAction(ACT_START_TEST_500);
break;
case VoltageRate.V1000:
CallAction(ACT_START_TEST_1000);
break;
case VoltageRate.V1600:
CallAction(ACT_START_TEST_1600);
break;
case VoltageRate.V2000:
CallAction(ACT_START_TEST_2000);
break;
case VoltageRate.V2500:
CallAction(ACT_START_TEST_2500);
break;
}
m_State = WaitForEndOfTest();
opened = (ReadRegisterS(REG_TEST_RESULT) == 0);
m_Result.Passed = !opened;
//увеличиваем счётчик выполненных тестов "Подтверждение"
testCount++;
}
}
else
{
if (m_Parameters.Mode == DvdtMode.Detection)
{
//режим "Определение" (Detection)
//формируем стек шагов по которым будем шагать
var Steps = new List <ushort>();
PrepareSteps(Steps);
ushort TestVoltageRate = 0;
ushort i = 0;
bool opened = false;
bool moveDown = false;
while (true)
{
//считываем скорость роста напряжения на которой мы собрались тестировать прибор
TestVoltageRate = Steps[i];
//запускаем проверку прибора на скорости роста напряжения TestVoltageRate
WriteRegister(REG_VOLTAGE_RATE, TestVoltageRate);
CallAction(ACT_START_TEST_CUSTOM);
m_State = WaitForEndOfTest();
opened = (ReadRegisterS(REG_TEST_RESULT) == 0);
//если мы проверили прибор на максимальной скорости роста напряжения и он не открылся - он годен, тест завершён
if ((i == Steps.Count - 1) && (!opened))
{
m_Result.Passed = true;
m_Result.VoltageRate = TestVoltageRate;
break;
}
//если мы спустились на самую первую ступеньку после того, как было зафиксировано открытие прибора и на этой последней ступеньке было зафиксировано открытие прибора - прибор брак, тест завершён
if ((i == 0) && opened)
{
m_Result.Passed = false;
m_Result.VoltageRate = 0;
break;
}
//если мы двигаемся вниз и прибор не открылся - прибор годен для TestVoltageRate, тест завершён
if (moveDown && (!opened))
{
m_Result.Passed = true;
m_Result.VoltageRate = TestVoltageRate;
break;
}
//если почему-то индекс i стал больше, чем число шагов минус 1
if (i > Steps.Count - 1)
{
throw new Exception("scme.service.io.iodvdt.cs MeasurementLogicRoutine. (i>Steps.Count-1.");
}
//если почему-то индекс i стал отрицательным
if (i < 0)
{
throw new Exception("scme.service.io.iodvdt.cs MeasurementLogicRoutine. i<0.");
}
//если мы пошли вниз - дорога вверх уже закрыта
if (opened || moveDown)
{
moveDown = true;
i--;
}
else
{
i++;
}
}
}
}
}
FiredVdtEvent(m_State, m_Result);
}
catch (Exception ex)
{
m_State = DeviceState.Fault;
FiredVdtEvent(m_State, m_Result);
FireExceptionEvent(ex.Message);
throw;
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
m_State = DeviceState.InProcess;
//перед измерением очищаем только Warning. сброс состояния Fault не делаем, т.к. он переводит ATU в состояние None
ClearWarning();
//уведомляем UI о том, что мы находимся в состоянии m_State с результатами измерений m_Result
FireATUEvent(m_State, m_Result);
//пишем значение амплитуды предварительного импульса тока в блок ATU
WriteRegister(REG_PRE_PULSE_VALUE, m_Parameters.PrePulseValue);
//пишем значение требуемой мощности в блок ATU
WriteRegister(REG_POWER_VALUE, m_Parameters.PowerValue);
if (m_IsATUEmulation)
{
//эмулируем успешный результат измерений
m_State = DeviceState.Success;
m_Result.UBR = 3000; //В
m_Result.UPRSM = 1800; //В
m_Result.IPRSM = RoundTwoDigits(10257 / 1000d); //А уровень отображения реализует вывод до 2 десятых
m_Result.PRSM = RoundTwoDigits(316 / 100d); //в регистре сидит значение Bт/10. переводим его в кВт уровень отображения реализует вывод до 2 десятых
//проверяем обработку не удачного окончания измерения
FireNotificationEvent((ushort)HWWarningReason.Short, (ushort)HWFaultReason.None, (ushort)HWDisableReason.None);
FireNotificationEvent((ushort)HWWarningReason.None, (ushort)HWFaultReason.ChargeError, (ushort)HWDisableReason.None);
}
else
{
//перед каждым измерением выполняем включение специальной коммутации для блока ATU для подключения требуемого измерительного блока к испытуемому прибору
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.ATU, Commutation.CommutationType, Commutation.Position) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
//раз коммутация не удалась - выставляем значения всех измеряемых параметров в ноль
m_Result.UBR = 0;
m_Result.UPRSM = 0;
m_Result.IPRSM = 0;
m_Result.PRSM = 0;
FireATUEvent(m_State, m_Result);
return;
}
//запускаем процесс измерения
CallAction(ACT_START_TEST);
//ждём окончания процесса измерения
m_State = WaitForEndOfTest();
//считываем результаты измерения из блока ATU
m_Result.UBR = ReadRegisterS(REG_CASCADING_VOLTAGE_VALUE_MEASURE);
m_Result.UPRSM = ReadRegisterS(REG_VOLTAGE_VALUE_MEASURE);
m_Result.IPRSM = RoundTwoDigits(ReadRegisterS(REG_CURRENT_VALUE_MEASURE) / 1000d); //А уровень отображения реализует вывод до 2 десятых
m_Result.PRSM = RoundTwoDigits(ReadRegisterS(REG_POWER_VALUE_MEASURE) / 100d); //в регистре сидит значение Bт/10. переводим его в кВт уровень отображения реализует вывод до 2 десятых
//по окончании процесса измерения - отключаем коммутацию
if (m_IOCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
m_State = DeviceState.Fault;
//коммутация не удалась, оставляем содержимое m_Result без изменения
FireATUEvent(m_State, m_Result);
return;
}
}
FireATUEvent(m_State, m_Result);
}
catch (Exception e)
{
m_IOCommutation.Switch(Types.Commutation.CommutationMode.None);
m_State = DeviceState.Fault;
FireATUEvent(m_State, m_Result);
FireExceptionEvent(e.Message);
throw;
}
}
private void MeasurementLogicRoutine(Types.Commutation.TestParameters Commutation)
{
try
{
_State = DeviceState.InProcess;
CallAction(ACT_CLEAR_WARNING);
FireTOUEvent(_State, _Result);
if (_IsTOUEmulation)
{
Random rand = new Random(DateTime.Now.Millisecond);
var randValue = rand.Next(0, 2);
//if (randValue == 0)
//{
// _State = DeviceState.Problem;
// Thread.Sleep(500);
// //проверяем отображение Problem, Warning, Fault
// FireNotificationEvent(HWProblemReason.None, HWWarningReason.AnperageOutOfRange, HWFaultReason.NoPotensialSignal, HWDisableReason.None);
// Thread.Sleep(500);
// FireTOUEvent(_State, _Result);
//}
//else
//{
//Как в RAC проверка ошибок
Thread.Sleep(500);
FireNotificationEvent(HWProblemReason.None, HWWarningReason.CurrentOutOfRange, HWFaultReason.None, HWDisableReason.None);
Thread.Sleep(500);
FireNotificationEvent(HWProblemReason.None, HWWarningReason.None, HWFaultReason.Overflow90, HWDisableReason.None);
Thread.Sleep(500);
_Result.ITM = (float)rand.NextDouble() * 1000;
_Result.TGD = (float)rand.NextDouble() * 1000;
_Result.TGT = (float)rand.NextDouble() * 1000;
_State = DeviceState.Success;
FireTOUEvent(_State, _Result);
//}
}
else
{
if (ActiveCommutation.Switch(Types.Commutation.CommutationMode.TOU, Commutation.CommutationType, Commutation.Position) == DeviceState.Fault)
{
_State = DeviceState.Fault;
FireTOUEvent(_State, _Result);
return;
}
WriteRegister(REG_CURRENT_VALUE, _Parameters.CurrentAmplitude);
CallAction(ACT_START_TEST);
WaitState(HWDeviceState.Ready);
ushort finish = ReadRegister(REG_TEST_FINISHED);
_Result.ITM = ReadRegister(REG_MEAS_CURRENT_VALUE);
_Result.TGD = ReadRegister(REG_MEAS_TIME_DELAY);
_Result.TGT = ReadRegister(REG_MEAS_TIME_ON);
_State = DeviceState.Success;
FireTOUEvent(_State, _Result);
if (finish != OPRESULT_OK)
{
HWFaultReason faultReason = (HWFaultReason)ReadRegister(REG_PROBLEM);
HWWarningReason warningReason = (HWWarningReason)ReadRegister(REG_WARNING);
FireNotificationEvent(HWProblemReason.None, warningReason, faultReason, HWDisableReason.None);
}
//по окончании процесса измерения - отключаем коммутацию
if (ActiveCommutation.Switch(Types.Commutation.CommutationMode.None) == DeviceState.Fault)
{
_State = DeviceState.Fault;
FireTOUEvent(_State, _Result);
return;
}
}
}
catch (Exception ex)
{
ActiveCommutation.Switch(Types.Commutation.CommutationMode.None);
_State = DeviceState.Fault;
FireTOUEvent(_State, _Result);
FireExceptionEvent(ex.Message);
throw;
}
}