"use strict";
var signals = gtl.options.record.signalsModel;
var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;

var imp = gtl.import("unimodule.js");

//настройки для датчика оборотов
var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); //объявление переменной фильтра
filter_freq.kind = gtl.filter_iir.butterworth; //тип окна
filter_freq.type = gtl.filter_iir.lowpass; //тип фильтра (ФНЧ)
filter_freq.order = 8; //порядок фильтра
filter_freq.frequency = 10; //граничная частота фильтра

//определение частоты вращения
var freq = gtl.add_value_freq(filter_freq);
freq.time = 1;
freq.avg_cnt = 6;
//gtl.diagnostic.interval = /*1*/10;

//[Блок настройки параметров измерений]
//мониторинговый спектр вибрации
var ausp2 = gtl.add_ausp(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной спектра вибрации
ausp2.name = "AUSPm"; //присвоение имени спектра
ausp2.color = 0x0000ffff; //цвет линии спектра
ausp2.frequency = 1600; //граничная частота спектра
ausp2.lines = 1600; //разрешение спектра (количество линий)
ausp2.average = 6; //количество усреднений
ausp2.unit = gtl.spec.db; //отображение в дБ

//спектр вибрации
var ausp = gtl.add_ausp(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной спектра вибрации
ausp.name = "AUSPd"; //присвоение имени спектра
ausp.color = 0x00008500; //цвет линии спектра
//ausp.frequency = 1600; //граничная частота спектра
ausp.lines = 1600; //разрешение спектра (количество линий)
ausp.average = 6; //количество усреднений
ausp.unit = gtl.spec.db; //отображение в дБ
ausp.smoothing_factor = 50; //коэффициент сглаживания спектра
ausp.smoothed_line_color = 0x000000ff; //цвет линии сглаживания (средней линии)
ausp.peak_level = 20; //порог обнаружения гармоник
ausp.harm_tolerance = ausp.resolution; //диапазон поиска гармоник +/-

//фильтр для формирования спектра огибающей
var n = 3; //количество долей октавного фильтра
var kf = (2 ** (1 / n) - 1) / ((2 ** (1 / n)) ** (1 / 2));//коэффициент для полосового фильтра
var filter_spen = gtl.add_filter_iir(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной фильтра
filter_spen.kind = gtl.filter_iir.butterworth; //тип окна
filter_spen.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
filter_spen.order = 10; //порядок фильтра
filter_spen.frequency = 8000; //центральная частота полосового фильтра
//filter_spen.frequency = 6013.41 * Math.log(0.266935 * imp.FREQ() + 1.1201); //расчетная центральная частота полосового фильтра
filter_spen.color = 255;
filter_spen.width = kf * filter_spen.frequency; //ширина полосы фильтра

//спектр огибающей
var spen = gtl.add_spen(filter_spen); //назначение переменной спектра огибающей
spen.name = "SPEN"; //присвоение имени спектра огибающей
spen.color = 0x00ff7373; //цвет линии спектра огибающей
//spen.frequency = spen_frequency(); //граничная частота спектра огибающей
//spen.lines = spen_lines(); //разрешение спектра огибающей (количество линий)
spen.average = 8; //количество усреднений
spen.unit = gtl.spec.db; //отображение в дБ
spen.window = gtl.spec.hann; //окно
spen.smoothing_factor = 100; //коэффициент сглаживания спектра
spen.smoothed_line_color = 0xff004dff; //цвет средней линии
spen.peak_level = 10; //порог обнаружения гармоник
spen.harm_tolerance = spen.resolution; //диапазон поиска гармоник +/-

//RMS и Amplitude в диапазоне спектра огибающей (контроль работы сил трения)
var rms_spen = gtl.add_value_rms(filter_spen); //назначение переменной RMS (spen)
var ampl_spen = gtl.add_value_ampl(filter_spen); //назначение переменной Amplitude (spen)
rms_spen.name = "RMS (spen)" //присвоение имени RMS (spen)
rms_spen.time = 0.5; //интервал расчета RMS (spen)
ampl_spen.time = 0.5; //интервал расчета Amplitude (spen)
rms_spen.avg_cnt = 4; //количество усреднений RMS (spen)
ampl_spen.avg_cnt = 4; //количество усреднений Amplitude (spen)

//RMS и Amplitude в УВЧ диапазоне 10-25 кГц (контроль разрыва масляной пленки) 
var filter_uhf = gtl.add_filter_iir(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной фильтра (предварительный)
filter_uhf.kind = gtl.filter_iir.butterworth; //тип окна
filter_uhf.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
filter_uhf.order = 10; //порядок фильтра
filter_uhf.frequency = 17500; //центральная частота полосового фильтра
filter_uhf.width = 15000; //ширина полосы фильтра

var rms_uhf = gtl.add_value_rms(filter_uhf); //назначение переменной RMS
var ampl_uhf = gtl.add_value_ampl(filter_uhf); //назначение переменной Amplitude
rms_uhf.name = "RMS (uhf)" //присвоение имени RMS (uhf)
rms_uhf.time = 0.5; //интервал расчета RMS (uhf)
ampl_uhf.time = 0.5; //интервал расчета Amplitude (uhf)
rms_uhf.avg_cnt = 4; //количество усреднений RMS (uhf)
ampl_uhf.avg_cnt = 4; //количество усреднений Amplitude (uhf)

//Виброскорость в дипазоне 2-1000 Гц (вибромониторинг)
var filter2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной фильтра (предварительный)
filter2_1000.kind = gtl.filter_iir.butterworth; //тип окна
filter2_1000.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
filter2_1000.order = 10; //порядок фильтра
filter2_1000.frequency = 501; //центральная частота полосового фильтра
filter2_1000.width = 998; //ширина полосы фильтра
var filter2_1000v = gtl.add_intg(filter2_1000); // интегрирование
filter2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)

var rms_v2 = gtl.add_value_rms(filter2_1000v); //назначение переменной RMS(V)
rms_v2.name = "RMS(V) 2-1000 Гц" //присвоение имени RMS(V)
rms_v2.time = 0.5; //интервал расчета RMS(V)
rms_v2.avg_cnt = 4; //количество усреднений RMS(V)

//Виброскорость в дипазоне 10-1000 Гц (вибромониторинг)
var filter10_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].signalChannel]); //назначение переменной фильтра (предварительный)
filter10_1000.kind = gtl.filter_iir.butterworth; //тип окна
filter10_1000.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
filter10_1000.order = 10; //порядок фильтра
filter10_1000.frequency = 505; //центральная частота полосового фильтра
filter10_1000.width = 990; //ширина полосы фильтра
var filter10_1000v = gtl.add_intg(filter10_1000); // интегрирование
filter10_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)

var rms_v10 = gtl.add_value_rms(filter10_1000v); //назначение переменной RMS(V)
rms_v10.name = "RMS(V) 10-1000 Гц" //присвоение имени RMS(V)
rms_v10.time = 0.5; //интервал расчета RMS(V)
rms_v10.avg_cnt = 4; //количество усреднений RMS(V)

//[Диагностика]
gtl.diagnostic.interval = freq.time * freq.avg_cnt;
let state = record.tachoOptions.tachoState; //начальное состояние после выбора источника тахо сигнала
let acq_time = 0;

function diagnose() {
    switch (state) {
        case 0: // считаем частоту вращения и настраиваем спектры
            if (imp.INSTABILITY() > imp.tolerance()) {
                gtl.log.info("Критическая нестабильность частоты вращения, %", imp.INSTABILITY() * 100);
                gtl.log.info("Результат:", "Диагностика прервана");
                //gtl.diagnostic.stop(); //принудительная остановка диагностики

                let __result = {
                    Result: false
                };
                gtl.results = __result;
            };

            //установка стандартной ширины спектра огибающей и количества линий спектра
            spen.frequency = imp.standart_width();
            spen.lines = imp.standart_lines();
            filter_spen.frequency = 6013.41 * Math.log(0.266935 * imp.FREQ() + 1.1201);
            ausp.frequency = imp.standart_width();
            //ausp.lines = imp.standart_lines();

            //определение минимально необходимой длительности сигнала для проведения диагностики
            var acq_times = [];
            acq_times.push(ausp.acq_time);
            acq_times.push(spen.acq_time);
            acq_time = Math.max(...acq_times);

            gtl.diagnostic.interval = acq_time;
            state = 3;
            break;

        case 1: //частота вращения фиксированная
            //установка стандартной ширины спектра огибающей и количества линий спектра
            spen.frequency = imp.standart_width();
            spen.lines = imp.standart_lines();
            filter_spen.frequency = 6013.41 * Math.log(0.266935 * imp.FREQ() + 1.1201);
            ausp.frequency = imp.standart_width();
            //ausp.lines = imp.standart_lines();

            //определение минимально необходимой длительности сигнала для проведения диагностики
            var acq_times = [];
            acq_times.push(ausp.acq_time);
            acq_times.push(spen.acq_time);
            acq_time = Math.max(...acq_times);

            gtl.diagnostic.interval = acq_time;
            state = 3;
            break;

        case 2: //частота вращения из поля INFO (виброметр)
            //установка стандартной ширины спектра огибающей и количества линий спектра
            spen.frequency = imp.standart_width();
            spen.lines = imp.standart_lines();
            //filter_spen.frequency = 6013.41 * Math.log(0.266935 * imp.FREQ() + 1.1201);
            ausp.frequency = imp.standart_width();
            //ausp.lines = imp.standart_lines();

            //определение минимально необходимой длительности сигнала для проведения диагностики
            var acq_times = [];
            acq_times.push(ausp.acq_time);
            acq_times.push(spen.acq_time);
            acq_time = Math.max(...acq_times);

            gtl.diagnostic.interval = acq_time;
            state = 3;
            break;

        case 3: //выполняем анализ спектов
            ausp.clear_harms_sets(); //сброс отрисовки набора гармоник в спектре вибрации
            spen.clear_harms_sets(); //сброс отрисовки набора гармоник в спектре огибающей

            //[Блок настройки определения гармоник в спектрах]
            //AUSP
            //присваиваем набору гармоник переменную, добавляем гармоники: частота, кол-во (default = 10), цвет, вес.
            var Nsat = options.pgN; 
                        
            var ausp_f1 = ausp.add_harms_set(imp.FREQ(), 10, 0xff004dff, 1); //биение ведущего вала
            for (let i = 0; i <= 9; i++) { ausp_f1.harms[i].tolerance = (1 + i) * imp.FREQ() * imp.tolerance() }; //коридор обнаружения гармоник
            ausp_f1.name = 'Биение ведущего вала';

            var ausp_f2 = ausp.add_harms_set(imp.PGF2(), 10, 0xff004dff, 1); //биение ведомого вала
            for (let i = 0; i <= 9; i++) { ausp_f2.harms[i].tolerance = (1 + i) * imp.PGF2() * imp.tolerance() };
            ausp_f2.name = 'Биение ведомого вала';

            var ausp_fz1 = ausp.add_harms_set(Nsat * (imp.FREQ() - imp.PGF2()), 5, 0xff004dff, 1); //дефект ведущей шестерни
            for (let i = 0; i <= 4; i++) { ausp_fz1.harms[i].tolerance = (1 + i) * Nsat * (imp.FREQ() - imp.PGF2()) * imp.tolerance() };
            ausp_fz1.name = 'Дефект ведущей шестерни';

            var ausp_fsat = ausp.add_harms_set(2 * imp.PGFSAT(), 5, 0xff004dff, 1); //Дефекты сателлита
            for (let i = 0; i <= 4; i++) { ausp_fsat.harms[i].tolerance = (1 + i) * imp.PGFSAT() * imp.tolerance() };
            ausp_fsat.name = 'Дефекты сателлита';

            var ausp_fcrown = ausp.add_harms_set(Nsat * imp.PGF2(), 5, 0xff004dff, 1); //Дефекты короны
            for (let i = 0; i <= 4; i++) { ausp_fcrown.harms[i].tolerance = (1 + i) * Nsat * imp.PGF2() * imp.tolerance() };
            ausp_fcrown.name = 'Дефекты короны';

            var ausp_fz2 = ausp.add_harms_set(imp.PGFZ(), 5, 0xff004dff, 1); //Дефекты зубчатого зацепления
            for (let i = 0; i <= 4; i++) { ausp_fz2.harms[i].tolerance = (1 + i) * imp.PGFZ() * imp.tolerance() };
            ausp_fz2.name = 'Дефекты зубчатого зацепления';

            //добавляем модулирующие гармоники: частота, кол-во, цвет, вес
            //ausp.harms_sets[2].modulate(imp.FREQ(), 2, 0x000000ff, 1); //модуляция Fн +/- Fвр1
            //ausp.harms_sets[3].modulate(imp.GTF2(), 2, 0x000000ff, 1); //модуляция Fн +/- Fвр2

            //при необходимости можно изменить параметры каждой гармоники индивидуально
            /*
            ausp.harms_sets[0].harms[0].color = 0x0000ffff;
            ausp.harms_sets[0].harms[0].weight = 1;
            ausp.harms_sets[0].harms[2].color = 0x0000ff00;
            ausp.harms_sets[0].harms[0].weight = 0.5;
            ausp.harms_sets[0].modulating[0].harms[0].color = 0x00ffff00;
            ausp.harms_sets[0].modulating[0].harms[0].weight = 5;
            */

            //SPEN
            //присваиваем набору гармоник переменную, добавляем гармоники: частота, кол-во (default = 10), цвет, вес.
            var spen_f1 = spen.add_harms_set(imp.FREQ(), 10, 0xff004dff, 1); //биение ведущего вала
            for (let i = 0; i <= 9; i++) { spen_f1.harms[i].tolerance = (1 + i) * imp.FREQ() * imp.tolerance() }; //коридор обнаружения гармоник
            spen_f1.name = 'Биение ведущего вала';

            var spen_f2 = spen.add_harms_set(imp.PGF2(), 10, 0xff004dff, 1); //биение ведомого вала
            for (let i = 0; i <= 9; i++) { spen_f2.harms[i].tolerance = (1 + i) * imp.PGF2() * imp.tolerance() };
            spen_f2.name = 'Биение ведомого вала';

            var spen_fz1 = spen.add_harms_set(Nsat * (imp.FREQ() - imp.PGF2()), 5, 0xff004dff, 1); //дефект ведущей шестерни
            for (let i = 0; i <= 4; i++) { spen_fz1.harms[i].tolerance = (1 + i) * Nsat * (imp.FREQ() - imp.PGF2()) * imp.tolerance() };
            spen_fz1.name = 'Дефект ведущей шестерни';

            var spen_fsat = spen.add_harms_set(2 * imp.PGFSAT(), 5, 0xff004dff, 1); //Дефекты сателлита
            for (let i = 0; i <= 4; i++) { spen_fsat.harms[i].tolerance = (1 + i) * imp.PGFSAT() * imp.tolerance() };
            spen_fsat.name = 'Дефекты сателлита';

            var spen_fcrown = spen.add_harms_set(Nsat * imp.PGF2(), 5, 0xff004dff, 1); //Дефекты короны
            for (let i = 0; i <= 4; i++) { spen_fcrown.harms[i].tolerance = (1 + i) * Nsat * imp.PGF2() * imp.tolerance() };
            spen_fcrown.name = 'Дефекты короны';

            var spen_fz2 = spen.add_harms_set(imp.PGFZ(), 3, 0xff004dff, 1); //Дефекты зубчатого зацепления
            for (let i = 0; i <= 2; i++) { spen_fz2.harms[i].tolerance = (1 + i) * imp.PGFZ() * imp.tolerance() };
            spen_fz2.name = 'Дефекты зубчатого зацепления';

            //добавляем модулирующие гармоники: частота, кол-во, цвет, вес
            //spen.harms_sets[2].modulate(imp.FREQ(), 2, 0x000000ff, 1); //модуляция Fн +/- Fвр1
            //spen.harms_sets[3].modulate(imp.GTF2(), 2, 0x000000ff, 1); //модуляция Fн +/- Fвр2

            //при необходимости можно изменить параметры каждой гармоники индивидуально
            /*
            spen.harms_sets[0].harms[0].color = 0x0000ffff;
            spen.harms_sets[0].harms[0].weight = 1;
            spen.harms_sets[0].harms[2].color = 0x0000ff00;
            spen.harms_sets[0].harms[0].weight = 0.5;
            spen.harms_sets[0].modulating[0].harms[0].color = 0x00ffff00;
            spen.harms_sets[0].modulating[0].harms[0].weight = 5;
            */

            //Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
            var AQ = imp.ausp_square(ausp2.data, 800, ausp2.frequency);

            //[Блок диагностики]
            //вывод информации в лог
            //gtl.log.info("description", function)

            gtl.log.info("Минимально необходимая длительность сигнала", acq_time);
            gtl.log.info("FREQ", imp.FREQ());
            gtl.log.info("FZ", imp.PGFZ());
            gtl.log.info("F2", imp.PGF2());
            gtl.log.info("Граничная частота спектра", imp.spen_frequency());
            gtl.log.info("Расчетное разрешение спектра", imp.spen_resolution());
            gtl.log.info("Расчетное количество линий", imp.spen_lines());
            gtl.log.info("Расчетный коридор обнаружения, %", imp.tolerance() * 100);
            gtl.log.info("spen.frequency", spen.frequency);
            gtl.log.info("spen.lines", spen.lines);
            gtl.log.info("СКЗ(A) ВЧ вибрации", rms_spen.value);
            gtl.log.info("СКЗ(A) УВЧ вибрации", rms_uhf.value);
            gtl.log.info("ПФ(A) в ВЧ диапазоне", ampl_spen.value / rms_spen.value);
            gtl.log.info("ПФ(A) в УВЧ диапазоне", ampl_uhf.value / rms_uhf.value);
            gtl.log.info("СКЗ(V) 2-1000 Гц", rms_v2.value);
            gtl.log.info("СКЗ(V) 10-1000 Гц", rms_v10.value);

            //вывод количества гармоник
            //ausp.harms_sets[0].get_count(1, 2, 1, true);
            //1 - начало отсчета гармоники;
            //2 - допуситмое количество пропущенных в ряду;
            //3 - количество модулирующих с одной стороны;
            //4 - модулирующие с двух сторон (true);

            //вывод параметров гармоник
            //ausp_set0.harms[1].is_present); //гармоника есть (есть превышение на порогом)
            //ausp_set0.harms[1].amplitude); //амплитуда
            //ausp_set0.harms[1].level); //превышении над средней
            //ausp_set0.harms[1].base); //уровень фона под гармоникой
            //ausp_set0.harms[1].tolerance; //коридор обнаружения гармоники

            var Defect = false;
            var Defect_type = [];

            //биение ведущего вала
            if (
                spen.harms_sets[0].get_count(1, 2) >= 3 & 
                ausp.harms_sets[0].get_count(1, 2) >= 3 
            ) {
                Defect = true;
                Defect_type.push("Биение ведущего вала");
                for (i = 0; i <= 9; i++) {
                    if (spen_f1.harms[i].is_present == true)
                        gtl.log.info("Биение ведущего вала. Признаки в ES " + (i + 1) + "Fвр1", imp.deep_factor(spen_f1.harms[i].amplitude, spen_f1.harms[i].base));
                }
                for (i = 0; i <= 9; i++) {
                    if (ausp_f1.harms[i].is_present == true)
                        gtl.log.info("Биение ведущего вала. Признаки в AS " + (i + 1) + "Fвр1", ausp_f1.harms[i].amplitude);
                }
            }
            else
                gtl.log.info("Биение ведущего вала", "Признаков дефекта не обнаружено");

            //биение ведомого вала
            if (
                spen.harms_sets[1].get_count(1, 2) >= 3 &
                ausp.harms_sets[1].get_count(1, 2) >= 3
            ) {
                Defect = true;
                Defect_type.push("Биение ведомого вала");
                for (i = 0; i <= 9; i++) {
                    if (spen_f2.harms[i].is_present == true)
                        gtl.log.info("Биение ведомого вала. Признаки в ES " + (i + 1) + "Fвр2", imp.deep_factor(spen_f2.harms[i].amplitude, spen_f2.harms[i].base));
                }
                for (i = 0; i <= 9; i++) {
                    if (ausp_f2.harms[i].is_present == true)
                        gtl.log.info("Биение ведомого вала. Признаки в ES " + (i + 1) + "Fвр2", ausp_f2.harms[i].amplitude);
                }
            } else
                gtl.log.info("Биение ведомого вала", "Признаков дефекта не обнаружено");

            //дефект ведущей шестерни
            if (
                spen.harms_sets[2].get_count(1, 1) > 2 &
                ausp.harms_sets[2].get_count(1, 1) > 2
            ) {
                Defect = true;
                Defect_type.push("Дефект ведущей шестерни");
                for (i = 0; i <= 4; i++) {
                    if (spen_fz1.harms[i].is_present == true)
                        gtl.log.info("Дефект ведущей шестерни. Признаки в ES " + (i + 1) + "Fвр1", imp.deep_factor(spen_fz1.harms[i].amplitude, spen_fz1.harms[i].base));
                }
                for (i = 0; i <= 4; i++) {
                    if (ausp_fz1.harms[i].is_present == true)
                        gtl.log.info("Дефект ведущей шестерни. Признаки в AS " + (i + 1) + "Fz1", ausp_fz1.harms[i].amplitude);
                }
            }
            else
                gtl.log.info("Дефект ведущей шестерни", "Признаков дефекта не обнаружено");

            //дефект сателлита
            if (
                spen.harms_sets[3].get_count(1, 1) > 2 &
                ausp.harms_sets[3].get_count(1, 1) > 2
            ) {
                Defect = true;
                Defect_type.push("Дефект сателлита");
                for (i = 0; i <= 4; i++) {
                    if (spen_fsat.harms[i].is_present == true)
                        gtl.log.info("Дефект сателлита. Признаки в ES " + (i + 1) + "Fсат", imp.deep_factor(spen_fsat.harms[i].amplitude, spen_fsat.harms[i].base));
                }
                for (i = 0; i <= 4; i++) {
                    if (ausp_fsat.harms[i].is_present == true)
                        gtl.log.info("Дефект сателлита. Признаки в AS " + (i + 1) + "Fсат", ausp_fsat.harms[i].amplitude);
                }
            }
            else
                gtl.log.info("Дефект сателлита", "Признаков дефекта не обнаружено");

            //дефект короны
            if (
                spen.harms_sets[4].get_count(1, 1) > 2 &
                ausp.harms_sets[4].get_count(1, 1) > 2
            ) {
                Defect = true;
                Defect_type.push("Дефект короны");
                for (i = 0; i <= 4; i++) {
                    if (spen_fcrown.harms[i].is_present == true)
                        gtl.log.info("Дефект короны. Признаки в ES " + (i + 1) + "Fвр2", imp.deep_factor(spen_fcrown.harms[i].amplitude, spen_fcrown.harms[i].base));
                }
                for (i = 0; i <= 4; i++) {
                    if (ausp_fcrown.harms[i].is_present == true)
                        gtl.log.info("Дефект короны. Признаки в AS " + (i + 1) + "Fвр2", ausp_fcrown.harms[i].amplitude);
                }
            }
            else
                gtl.log.info("Дефект короны", "Признаков дефекта не обнаружено");

            //дефекты зубчатого зацепления
            if (
                spen.harms_sets[5].get_count(1, 1) > 2 &
                ausp.harms_sets[5].get_count(1, 1) > 2
            ) {
                Defect = true;
                Defect_type.push("Дефекты зубчатого зацепления");
                for (i = 0; i <= 4; i++) {
                    if (spen_fz2.harms[i].is_present == true)
                        gtl.log.info("Дефекты зубчатого зацепления. Признаки в ES " + (i + 1) + "Fz", imp.deep_factor(spen_fz2.harms[i].amplitude, spen_fz2.harms[i].base));
                }
                for (i = 0; i <= 4; i++) {
                    if (ausp_fz2.harms[i].is_present == true)
                        gtl.log.info("Дефекты зубчатого зацепления. Признаки в AS " + (i + 1) + "Fz", ausp_fz2.harms[i].amplitude);
                }
            }
            else
                gtl.log.info("Дефекты зубчатого зацепления", "Признаков дефекта не обнаружено");

            let __result = {
                "Result": true,
                "RMS(A)": rms_spen.value,
                "RMS_UHF(A)": rms_uhf.value,
                "PF(A)": ampl_spen.value / rms_spen.value,
                "PF_UHF(A)": ampl_uhf.value / rms_uhf.value,
                "RMS(V) 2-1000 Гц": rms_v2.value,
                "RMS(V) 10-1000 Гц": rms_v10.value,
                "Square": AQ,
                "Defects": Defect,
                "Types": Defect_type
            };

            gtl.results = __result;
            gtl.diagnostic.stop();
            break;

        default:
            break;
    }
}