Exemplo n.º 1
0
        internal void Start(SctuTestParameters parameters, IOClamping clamping, IOGateway gateway)
        {
            _testParameters = parameters;
            _testResults    = new SctuTestResults();

            //_stop = false;

            ClearWarning();

            if (!_isSctuEmulation)
            {
                var devState = (SctuHwState)ReadRegister(REG_DEV_STATE);

                if (devState == SctuHwState.Fault)
                {
                    throw new Exception(string.Format("Sctu is in fault state, reason: {0}", ReadRegister(REG_FAULT_REASON)));
                }

                if (devState == SctuHwState.Disabled)
                {
                    throw new Exception("Sctu is in disabled state");
                }
            }

            MeasurementLogicRoutine(clamping, gateway);
        }
Exemplo n.º 2
0
        private void MeasurementLogicRoutine(IOClamping clamping, IOGateway gateway)
        {
            try
            {
                FiredSctuEvent(SctuHwState.InProcess, _testResults);

                //пишем младшую 16-ти битную половину значения ударного тока
                WriteRegister(REG_SC_VALUE_L, UshortByNum(_testParameters.Value, false));

                //пишем старшую 16-ти битную половину значения ударного тока
                WriteRegister(REG_SC_VALUE_H, UshortByNum(_testParameters.Value, true));

                WriteRegister(REG_DUT_TYPE, (ushort)_testParameters.Type);
                WriteRegister(REG_R_SHUNT, (ushort)_testParameters.ShuntResistance);

                WriteRegister(REG_WAVEFORM_TYPE, (ushort)_testParameters.WaveFormType);

                if (_testParameters.WaveFormType == SctuWaveFormType.Trapezium)
                {
                    WriteRegister(REG_TRAPEZE_EDGE_TIME, _testParameters.TrapezeEdgeTime);
                }

                if (_isSctuEmulation)
                {
                    _deviseState = SctuHwState.WaitTimeOut;
                    _testResults.CurrentValue = 200;
                    _testResults.VoltageValue = 1000;
                    _testResults.MeasureGain  = (double)912 / 1000;

                    if (_ReadGraph)
                    {
                        //эмуляция графика тока
                        for (int i = 1; i <= 11000; i++)
                        {
                            _testResults.CurrentData.Add(10);
                        }

                        //эмуляция графика напряжения
                        for (int i = 1; i <= 11000; i++)
                        {
                            _testResults.VoltageData.Add(30);
                        }
                    }

                    FiredSctuEvent(_deviseState, _testResults);
                }
                else
                {
                    //чтобы пресс не занимал шину CAN - запрещаем ему опрашивать температуры его столика
                    clamping.SetPermissionToScan(false);

                    try
                    {
                        CallAction(ACT_SC_PULSE_CONFIG);
                        Thread.Sleep(3000);

                        var devState = WaitForPulseConfig();

                        if (devState == SctuHwState.PulseConfigReady)
                        {
                            CallAction(ACT_SC_PULSE_START);
                            WaitForTestEnd();

                            //ожидаем состояние SctuHwState.WaitTimeOut
                            devState = WaitForTimeOut();

                            //чтобы на время чтения результатов теста шина CAN была максимально свободной
                            gateway.SetPermissionToScan(false);

                            try
                            {
                                //читаем результаты
                                _testResults.VoltageValue = ReadRegister(REG_DUT_U);

                                //читаем младшие 16 бит измеренного значения ударного тока
                                ushort DutIL = ReadRegister(REG_DUT_I_L);

                                //читаем старшие 16 бит измеренного значения ударного тока
                                ushort DutIH = ReadRegister(REG_DUT_I_H);

                                //формируем из двух прочитанных 16-ти битных значений int значение ударного тока
                                _testResults.CurrentValue = IntByUshorts(DutIL, DutIH);

                                //читаем значение коэффициента усиления. его надо разделить на 1000, показывать с 3-мя знаками после запятой
                                _testResults.MeasureGain = (double)ReadRegister(REG_INFO_K_SHUNT_AMP) / 1000;

                                if (_ReadGraph)
                                {
                                    //ожидаем готовность данных для построения графиков и только после этого их читаем
                                    WaitForGraphDataReady();

                                    //читаем массивы данных тока и напряжения для построения графиков тока и напряжения
                                    ReadArrays(_testResults);
                                }

                                FiredSctuEvent(devState, _testResults);
                            }

                            finally
                            {
                                //разрешаем опрос Gateway
                                gateway.SetPermissionToScan(true);
                            }
                        }
                    }

                    finally
                    {
                        //разрешаем опрос Clamping
                        clamping.SetPermissionToScan(true);
                    }
                }
            }
            catch (Exception ex)
            {
                _deviseState = SctuHwState.Fault;
                FiredSctuEvent(_deviseState, _testResults);
                FireExceptionEvent(ex.Message);

                throw;
            }
        }