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

var fnc = gtl.import("userFunctions.js");
var def = gtl.import("sbDefs.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 filter_spen = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной фильтра
filter_spen.kind = gtl.filter_iir.butterworth; //тип окна
filter_spen.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
filter_spen.order = 4; //порядок фильтра
filter_spen.frequency = 8000; //центральная частота полосового фильтра
filter_spen.width = 1840; //ширина полосы фильтра

//полосовой фильтр 10-10000 Гц
var band10_10k = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной фильтра
band10_10k.kind = gtl.filter_iir.butterworth; //тип окна
band10_10k.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
band10_10k.order = 10; //порядок фильтра
band10_10k.frequency = 5005; //центральная частота полосового фильтра
band10_10k.width = 9990; //ширина полосы фильтра

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

//интегратор
var int = gtl.add_intg(band10_1k); //интегрирование сигнала виброускорения
int.taps = 1; //степень интегрирования (скорость из ускорения - 1-нарное интегрирование)

//дополнительный ФВЧ от 10 Гц
var hpf10 = gtl.add_filter_iir(int); //назначение переменной фильтра
hpf10.kind = gtl.filter_iir.butterworth; //тип окна
hpf10.type = gtl.filter_iir.highpass; //тип фильтра (полосовой)
hpf10.order = 10; //порядок фильтра
hpf10.frequency = 10; //граничная частота полосового фильтра

//ФВЧ от 5000 Гц (эксцесс)
var hpf5 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной фильтра
hpf5.kind = gtl.filter_iir.butterworth; //тип окна
hpf5.type = gtl.filter_iir.highpass; //тип фильтра (полосовой)
hpf5.order = 10; //порядок фильтра
hpf5.frequency = 5000; //граничная частота полосового фильтра

//[Блок настройки спектров]
//мониторинговый спектр виброускорения
var ausp2 = gtl.add_ausp(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной спектра вибрации
ausp2.name = "AUSP[mon]"; //присвоение имени спектра
ausp2.color = 0x0000ffff; //цвет линии спектра
ausp2.frequency = 25600; //граничная частота спектра
ausp2.lines = 1600; //разрешение спектра (количество линий)
ausp2.average = 6; //количество усреднений
//ausp2.overlap = 30; //коэффициент перекрытия
ausp2.unit = gtl.spec.db; //отображение в дБ
gtl.log.info("AUSP[mon]: время", ausp2.acq_time + " сек.");

//спектр виброускорения
var ausp = gtl.add_ausp(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной спектра вибрации
ausp.name = "AUSP[A]"; //присвоение имени спектра
ausp.color = 0x0000ff00; //цвет линии спектра
ausp.frequency = 400; //граничная частота спектра
ausp.lines = 400; //разрешение спектра (количество линий)
ausp.average = 6; //количество усреднений
ausp.overlap = .30; //коэффициент перекрытия
ausp.unit = gtl.spec.db; //отображение в дБ
ausp.smoothing_factor = 50; //коэффициент сглаживания (средней линии)
ausp.smoothed_line_color = 0x000000ff; //цвет линии сглаживания (средней линии)
ausp.peak_level = 20; //порог обнаружения гармоник
ausp.harm_tolerance = ausp.resolution * 4; //диапазон поиска гармоник +/-
gtl.log.info("AUSP[A]: время", ausp.acq_time + " сек.");

//спектр огибающей виброускорения
var spen = gtl.add_spen(filter_spen); //назначение переменной спектра огибающей
spen.name = "SPEN[A]"; //присвоение имени спектра огибающей
spen.color = 0x00ff0000; //цвет линии спектра огибающей
spen.frequency = 400; //граничная частота спектра огибающей
spen.lines = 400; //разрешение спектра огибающей (количество линий)
spen.average = 8; //количество усреднений
spen.overlap = .30; //коэффициент перекрытия
spen.unit = gtl.spec.db; //отображение в дБ
spen.window = gtl.spec.hann; //окно
spen.smoothing_factor = 50; //коэффициент сглаживания (средней линии)
spen.smoothed_line_color = 0x000000ff; //цвет средней линии
spen.peak_level = 10; //порог обнаружения гармоник
spen.harm_tolerance = spen.resolution * 4; //диапазон поиска гармоник +/-
gtl.log.info("SPEN[A]: время", spen.acq_time + " сек.");

//спектр виброскорости
var ausp_v = gtl.add_ausp(hpf10); //назначение переменной спектра вибрации
ausp_v.name = "AUSP[V]"; //присвоение имени спектра
ausp_v.color = 0x6A5ACD; //цвет линии спектра
ausp_v.frequency = 1000; //граничная частота спектра
ausp_v.lines = 500; //разрешение спектра (количество линий)
ausp_v.average = 6; //количество усреднений
//ausp_v.overlap = 30; //коэффициент перекрытия
ausp_v.unit = gtl.spec.unit; //отображение в дБ
ausp_v.smoothing_factor = 50; //коэффициент сглаживания (средней линии)
ausp_v.smoothed_line_color = 0x000000ff; //цвет линии сглаживания (средней линии)
ausp_v.peak_level = 0.0005; //порог обнаружения гармоник
ausp_v.harm_tolerance = ausp_v.resolution * 4; //диапазон поиска гармоник +/-
gtl.log.info("AUSP[V]: время", ausp_v.acq_time + " сек.");

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

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

//RMS виброскорости в диапазоне 10-1000 Гц
var rms_v = gtl.add_value_rms(hpf10); //объявление переменной СКЗ
rms_v.time = 0.5; //время выборки
rms_v.avg_cnt = 4; //количество усреднений

//коэффициент эксцесса в диапазоне от 5000 Гц
var kurt = gtl.add_value_kurt(hpf5); //объявление переменной частоты вращения
kurt.time = 0.5; //время выборки
kurt.avg_cnt = 4; //количество усреднений
 
//коэффициент эксцесса огибающей сигнала
var kurt_spen = gtl.get_kurt_value(spen.env);

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

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

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

            if (fnc.FREQ() <= fnc.FREQNESS()) {
                gtl.log.info("Частота вращения меньше минимально рекомендуемой", "Минимально рекомендуемая частота: " + fnc.FREQNESS());
            };

        case 1: //частота вращения фиксированная
        case 2: //частота вращения из поля INFO (виброметр)
            filter_spen.frequency = fnc.bpFreq(); //считаем фильтр для огибающей
            filter_spen.width = fnc.bpWidth(); //определяем ширину фильтра   
            spen.frequency = fnc.specParams().frequency;
            spen.lines = fnc.specParams().lines * 2;
            ausp.frequency = fnc.specParams().frequency;
            ausp.lines = fnc.specParams().lines * 2;
            ausp_v.frequency = fnc.specParams().frequency;
            ausp_v.lines = fnc.specParams().lines * 2;

            //определение минимально необходимой длительности сигнала для проведения диагностики
            let time = []; //массив времени набора данных 
            time.push(ausp2.acq_time);
            time.push(ausp.acq_time);
            time.push(spen.acq_time);
            time.push(ausp_v.acq_time);
            let max_acq = Math.max(...time);
            gtl.diagnostic.interval = max_acq;
            gtl.log.info("Массив времени набора данных:", time);
            state = 3;
            break;

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

            //Вывод информации в лог
            //Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
            var SQR_spen = fnc.specSquare(spen.base, 0, spen.frequency);

            gtl.log.info("Объект диагностики", options.rbModelName);
            gtl.log.info("SPEN: Расчетная частота полосового фильтра", filter_spen.frequency);
            gtl.log.info("SPEN: Ширина фильтра", filter_spen.width);
            gtl.log.info("SPEN: Граничная частота", spen.frequency);
            gtl.log.info("SPEN: Количество линий", spen.lines);
            gtl.log.info("SPEN: Разрешение", spen.resolution);
            gtl.log.info("AUSP: Граничная частота", ausp.frequency);
            gtl.log.info("AUSP: Количество линий", ausp.lines);
            gtl.log.info("AUSP: Разрешение", ausp.resolution);

            gtl.log.info("RMS виброускорения в диапазоне огибающей", rms_spen.value);
            gtl.log.info("RMS виброускорения в диапазоне 10-10000 Гц", rms_a.value);
            gtl.log.info("RMS виброскорости в диапазоне 10-1000 Гц", 1000 * rms_v.value);
            gtl.log.info("Площадь под огибающей", SQR_spen);
            gtl.log.info("Эксцесс от 5 кГц", kurt.value);
            gtl.log.info("Эксцесс по огибающей сигнала", kurt_spen.value);

            var defects = def.defects();
          
            canvas.add(
                {
                    color: ausp.color,
                    name: ausp.name,
                    x: ausp.resolution,
                    y: ausp.data
                }
            ); //рисуем спектр вибрации на плоскости

            canvas.add(
                {
                    color: spen.color,
                    name: spen.name,
                    x: spen.resolution,
                    y: spen.data
                }
            ); //рисуем спектр огибающей на плоскости

            canvas2.add(
                {
                    color: ausp_v.color,
                    name: ausp_v.name,
                    x: ausp_v.resolution,
                    y: ausp_v.data
                }
            ); //рисуем спектр виброскорости на плоскости

            let __result = {
                RMS: rms_spen.value,
                RMSA: rms_a.value,
                RMSV: 1000 * rms_v.value,
                SQR: SQR_spen,
                Kurt: kurt.value,
                Kurt_spen: "Нет данных"
            };

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

        default:
            break;
    }
}