"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("functions_for_balance.js");
var fnc = gtl.import("user-functions.js");

// Цвета (для справки)
// #ff0000 - красный
// #00ff00 - зелёный
// #0000ff - синий
// #00ddff - голубой
// #ff3dcc - фиолетовый
// #ffff00 - жёлтый

// ***** БАЛАНСИРОВОЧНЫЙ КАЛЬКУЛЯТОР. ОДНА ПЛОСКОСТЬ с фазой *****
// ***************************************************************

// Получение входных сигналов
	// Определение частоты вращения по параметру freq.dc
		var freq = gtl.add_value_freq(gtl.analog_inputs[record.tachoOptions.tachoChannel]);
		freq.time = 1; // длина (время) отрезка сигнала
		freq.avg_cnt = 3; // количество усреднений
		freq.dc = -0.05; // уровень, при переходе через который вычисляются периоды
	// Настройки для спектров и АФЧХ
		var frequency = 1000; // граничная частота
		var resolution = 0.5; // частотное разрешение
		var average = 3; // количество усреднений
		var overlap = 0; // наложение

	// ФИЛЬТР 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
		var filter_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
		filter_2_1000.kind = gtl.filter_iir.butterworth;
		filter_2_1000.type = gtl.filter_iir.bandpass;
		filter_2_1000.order = 6;
		filter_2_1000.frequency = 502; // центральная частота полосового фильтра
		filter_2_1000.width = 1000; // ширина полосы фильтра
		var filter_2_1000v = gtl.add_intg(filter_2_1000); // интегрирование
		filter_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)

	// Спектр виброскорости для получения 1-й гармоники частоты вращения
		var AUSPv = gtl.add_ausp(filter_2_1000v); // объявление переменной спектра
		AUSPv.color = 0x00ff0000; // цвет спектра
		AUSPv.name = "AUSPv"; // имя спектра
		AUSPv.frequency = frequency; // граничная частота спектра
		AUSPv.lines = AUSPv.frequency * 1/resolution; // разрешение спектра (количество линий)
		AUSPv.average = average; // количество усреднений
		AUSPv.unit = gtl.spec.unit; // отображение амплитуды в мм/с
		AUSPv.smoothing_factor = 100; // усреднение средней линии
		AUSPv.smoothed_line_color = 0xff004dff; // цвет средней линии
		AUSPv.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный)
		AUSPv.tolerance = AUSPv.resolution; // диапазон поиска гармоник +/-
	// СКЗv
		var RMSv_2_1000 = gtl.add_value_rms(filter_2_1000v);
		RMSv_2_1000.time = 1;
		RMSv_2_1000.avg_cnt = 3;
	// СКЗa
		var RMSa = gtl.add_value_rms(gtl.analog_inputs[signals[0].portNumber]);
		RMSa.time = 1;
		RMSa.avg_cnt = 3;

	// var idx = 1; // индекс канала вибрации (канал 0 - опорный)
	// var cnt = record.signalsModel.length; // количество каналов вибрации

	// Спектр виброскорости (новый метод)
	var AUSPv_pl = gtl.create_ausp(
		{
			"src" : filter_2_1000v,
			"frequency" : frequency,
			"resolution" : resolution,
			"average" : average,
			"overlap" : overlap,
			"window" : gtl.spec.rectangular,
			"view" : gtl.spec.unit
		}
	);

	// ФЧХ (новый метод)
	var pfc_pl = gtl.create_pfc(
		{
			"src0" : filter_2_1000v,
			"src1" : gtl.analog_inputs[record.tachoOptions.tachoChannel],
			"frequency" : frequency,
			"resolution" : resolution,
			"average" : average,
			"overlap" : overlap,
			"window" : gtl.spec.rectangular,
			"view" : gtl.phase.deg,
			// "range" : gtl.phase.positive,
			"is_single" : false
		}
	);
			// "range": gtl.phase.negative,
			// "delay" : .1, // по умолчанию - 0
			// "start" : false // по умолчанию - true
// Объявление графических плоскостей для построения графиков
	var plot_pfc = gtl.plots.add("ФЧХ"); // фазо-частотная характеристика
	var plot_ausp = gtl.plots.add("Спектр виброскорости"); // создание объекта для спектра

	gtl.log.info("размер массива AUSPv_pl", AUSPv_pl.data.length);
	gtl.log.info("размер массива pfc_pl", pfc_pl.data.length);

// Переменные основные
// параметр вибрации (модуль вектора) - виброскорость (мм/с)
// угол (фаза) вектора - градусы
// масса груза (модуль ветора) - граммы
// DCI - Dynamic Coefficient of Influence (динамический коэффициент влияния)
// * - значение получаем из измерительного блока при нажатии кнопки
// ** - значение вводится пользователем
// *** - значение получаем в результате расчёта программы балансировки
// значение переменной с нижним подчёркиванием (..._) берётся из "дополнительных опций"; если оно не задано, то рассчитывается в скрипте

let m_test_ = gtl.options.customOptions.m_test; 			// модуль вектора пробного груза **
let m_test_corner = gtl.options.customOptions.m_test_corner;// угол вектора пробного груза **
var m_test; 												// модуль вектора пробного груза ** (конечное значение)
var m_test_calc;											// масса пробного груза расчётная ***
let n = gtl.options.customOptions.n; 						// скорость вращения, об/мин ** (для вычисления массы пробного груза)
var FREQ_0 = n / 60;										// частота вращения, об/мин *** (для определения амплитуды оборотной гармоники)
let R = gtl.options.customOptions.R; 						// радиус установки грузов ** (для вычисления массы пробного груза)
let P = gtl.options.customOptions.P; 						// масса ротора, грамм ** (для вычисления массы пробного груза)

let A0_ = gtl.options.customOptions.A0; 				// модуль вектора начальной вибрации */**
var A0;													// модуль вектора начальной вибрации */** (конечное значение)
let A0_phase_ = gtl.options.customOptions.A0_phase;		// фаза вектора начальной вибрации */**
var A0_phase; 											// фаза вектора начальной вибрации */** (конечное значение)
let A1_ = gtl.options.customOptions.A1;					// модуль вектора вибрации после установки пробного груза */**
let A1;													// модуль вектора вибрации после установки пробного груза */** (конечное значение)
var A1_phase_ = gtl.options.customOptions.A1_phase;		// фаза вектора вибрации после установки пробного груза */**
var A1_phase;											// фаза вектора вибрации после установки пробного груза */** (конечное значение)
var dA;													// модуль вектора дельты вибрации после установки пробного груза ***
var dA_phase;											// фаза вектора дельты вибрации после установки пробного груза ***
let DCI_ = gtl.options.customOptions.DCI;				// модуль (мм/с/граммы) динамического коэффициента влияния **/***
var DCI;												// модуль (мм/с/граммы) динамического коэффициента влияния **/*** (конечное значение)
let DCI_phase_ = gtl.options.customOptions.DCI_phase;	// фаза динамического коэффициента влияния **/***
let DCI_phase;											// фаза динамического коэффициента влияния **/*** (конечное значение)
var Mb;													// модуль вектора балансировочного груза ***
var Mb_corner;											// угол вектора балансировочного груза ***
var Mdisb;												// масса дисбаланса ***
var Mdisb_corner;										// угол расположения дисбаланса ***
var A2;													// модуль вектора вибрации после установки балансировочного груза ***
var A2_phase;											// фаза вектора вибрации после установки балансировочного груза ***

// Переменные вспомогательные необходимые для расчётов
var A0_phase_X;		// угол наклона вектора A0 к оси X
var A0_phase_Y;		// угол наклона вектора A0 к оси Y
var A0_1_X;			// начальная координата вектора A0 по оси X
var A0_2_X;			// конечная координата вектора A0 по оси X
var A0_1_Y;			// начальная координата вектора A0 по оси Y
var A0_2_Y;			// конечная координата вектора A0 по оси Y

var A1_phase_X;		// угол наклона вектора A1 к оси X
var A1_phase_Y;		// угол наклона вектора A1 к оси Y
var A1_1_X;			// начальная координата вектора A1 по оси X
var A1_2_X;			// конечная координата вектора A1 по оси X
var A1_1_Y;			// начальная координата вектора A1 по оси Y
var A1_2_Y;			// конечная координата вектора A1 по оси Y

var dA_1_X;			// начальная координата вектора dA по оси X
var dA_2_X;			// конечная координата вектора dA по оси X
var dA_1_Y;			// начальная координата вектора dA по оси Y
var dA_2_Y;			// конечная координата вектора dA по оси Y

var m_test_corner_X;// угол наклона вектора m_test к оси X
var m_test_corner_Y;// угол наклона вектора m_test к оси Y
var m_test_1_X;		// начальная координата вектора m_test по оси X
var m_test_2_X;		// конечная координата вектора m_test по оси X
var m_test_1_Y;		// начальная координата вектора m_test по оси Y
var m_test_2_Y;		// конечная координата вектора m_test по оси Y


// ***** РАСЧЁТЫ *****
// gtl.diagnostic.interval = 15;
gtl.diagnostic.interval = Math.max(AUSPv.acq_time, AUSPv_pl.acq_time, pfc_pl.acq_time) + 0.1;

let state = record.tachoOptions.tachoState; // начальное состояние после выбора источника тахо сигнала

function diagnose() {

// Нестабильность частоты вращения
var freq_max = Math.max(...freq.values);
var freq_min = Math.min(...freq.values);
var instability = ((freq_max - freq_min) / freq.value) * 100; // * 100%

switch (state) {

	case 0: // считаем частоту вращения и настраиваем спектры
		var freq_max = Math.max(...freq.values);
		var freq_min = Math.min(...freq.values);
		var instability = (freq_max - freq_min) / freq.value;
  
		// if (instability > imp.tolerance()) {
		if (instability > 0.3) {
			gtl.log.info("Критическая нестабильность частоты вращения, %", instability * 100);
			gtl.log.info("Результат:", "Диагностика прервана");
			//gtl.diagnostic.stop(); //принудительная остановка диагностики
  
			let __result = {
				Result: false
			};
			gtl.results = __result;
		};
  
		// Определение минимально необходимой длительности сигнала для проведения диагностики
		gtl.diagnostic.interval = Math.max(AUSPv.acq_time, AUSPv_pl.acq_time, pfc_pl.acq_time) + 0.1;;
		state = 3;
		break;
  
	case 1: // Частота вращения фиксированная
		// Определение минимально необходимой длительности сигнала для проведения диагностики
		gtl.diagnostic.interval = Math.max(AUSPv.acq_time, AUSPv_pl.acq_time, pfc_pl.acq_time) + 0.1;
		state = 3;
		break;
  
	case 2: // Частота вращения из поля INFO (виброметр)
		// Определение минимально необходимой длительности сигнала для проведения диагностики
		gtl.diagnostic.interval = Math.max(AUSPv.acq_time, AUSPv_pl.acq_time, pfc_pl.acq_time) + 0.1;
		state = 3;
		break;
  
	case 3: // Выполняем анализ спектов
		// Очистка партретов спектров
		AUSPv.clear_harms_sets();


    let __AUSPv_tools = gtl.create_spec_tools(
        {
            data: AUSPv_pl.data,
            df: AUSPv_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x00ff00
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });

    let __row_AUSPv = __AUSPv_tools.harms.add(freq.value, 3, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row_AUSPv.name = "F1v (гарм. ряд част. вращ.)"; // название гармонического ряда
    // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)
	

	let __pfc_tools = gtl.create_spec_tools(
        {
            data: pfc_pl.data,
            df: pfc_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x0000ff
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });

	let __row1_phase = __pfc_tools.harms.add(freq.value, 3, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row1_phase.name = "F1v_phase (гарм. ряд част. вращ.)"; // название гармонического ряда

// Построение графиков
    plot_ausp.add(
        {
        	color: 0x0000ff,
        	name: "Спектр виброскорости",
        	x: AUSPv_pl.resolution,
        	y: AUSPv_pl.data,
        	spec_tools: __AUSPv_tools.to_json()
        });
	plot_pfc.add(
		{
			color: 0xff0000,
			name: "ФЧХ",
			x: pfc_pl.resolution,
			y: pfc_pl.data,
			spec_tools: __pfc_tools.to_json()
		});

    let __result1 = __AUSPv_tools.to_json();
	let __result2 = __pfc_tools.to_json();


		// Амплитуда гармонического ряда частоты вращения
		var F1_1_a = __result1.harms.rows[0].harms[0].ampl;
		var F1_2_a = __result1.harms.rows[0].harms[1].ampl;
		var F1_3_a = __result1.harms.rows[0].harms[2].ampl;

		// Частота гармонического ряда частоты вращения
		var F1_1_f = __result1.harms.rows[0].harms[0].freq;
		var F1_2_f = __result1.harms.rows[0].harms[1].freq;
		var F1_3_f = __result1.harms.rows[0].harms[2].freq;

		// Фаза (амплитуда) гармонического ряда частоты вращения
		var F1_1_ph = __result2.harms.rows[0].harms[0].ampl;
		var F1_2_ph = __result2.harms.rows[0].harms[1].ampl;
		var F1_3_ph = __result2.harms.rows[0].harms[2].ampl;

	// Проверка наличия оборотной гармоники и необходимости проведения баалнсировки
	var test_balance = ""; // переменная для текста о необходимости проведения балансировки
		if (F1_1_a >= RMSv_2_1000 * 0.4) // вклад оборотной гармоники в СКЗv
      		{test_balance = "необходимо провести балансировку";}
		else {test_balance = "проведение балансировки не требуется или нецелесообразно";}

    // __result.data; - массив значений амплитуд составляющих спектра;
    // __result.base.data; - массив значений средней линии;
    // __result.peaks.data; - массив обнаруженных гармоник;
    // __result.peaks.data[i]; - обращение к i - й обнаруженной гармонике и ее свойствам;

    // freq - частота обнаруженной гармоники;
    // ampl - амплитудное значение обнаруженной  гармоники;
    // level - уровень обнаруженной гармоники над средней линией;
    // index - индекс обнаруженной гармоники;

    // __result.harms.rows; - массив построенных гармонических рядов;
    // __result.harms.rows[i]; - обращение к i - му гармоническому ряду;
    // __result.harms.rows[i].harms; - массив гармоник i - го гармонического ряда;
    // __result.harms.rows[i].harms[j]; - обращение к j - й гармонике и ее свойствам i - го гармонического ряда;

    // freq - частота гармоники указанного гармонического ряда;
    // ampl - амплитудное значение гармоники указанного гармонического ряда;
    // base - уровень средней линии под гармоникой указанного гармонического ряда;
    // level - уровень гармоники над средней линией указанного гармонического ряда;
    // is_present(true / false) - обнаружение гармоники указанного гармонического ряда;

// РАСЧЁТЫ (балансировочный калькулятор)

		// Определение конечных значений переменных
			// A0 начальная вибрация
			if (A0_ != 0) {A0 = A0_} // принимает значение из опций
			else {A0 = F1_1_a} // принимает значение из спектра сигнала
			if (A0_phase_ != 0) {A0_phase = A0_phase_} // принимает значение из опций
			else {A0_phase = F1_1_ph} // принимает значение из спектра сигнала

			// A1 вибрация после установки пробного груза
			if (A1_ != 0) {A1 = A1_} // принимает значение из опций
			else {A1 = F1_1_a} // принимает значение из спектра сигнала
			if (A1_phase_ != 0) {A1_phase = A1_phase_} // принимает значение из опций
			else {A1_phase = F1_1_ph} // принимает значение из спектра сигнала

		// вычисление массы пробного груза (если не выбране свой и есть данные для формулы)
			m_test_calc = 804 * ((P * A0) / (R * n));	
			// m_test масса пробного груза
			if (m_test_ != 0) {m_test = m_test_} // принимает значение из опций
			else {m_test = m_test_calc} // принимает значение из расчёта

	// определение угла наклона вектора A0 к осям X и Y
		if (A0_phase <= 90) {
		A0_phase_X = 90 - A0_phase}
			if (A0_phase <= 180) {
			A0_phase_X = A0_phase - 90}
				if (A0_phase <= 270) {
				A0_phase_X = 270 - A0_phase}
					if (A0_phase <= 360) {
					A0_phase_X = A0_phase - 270}
		if (A0_phase <= 90) {
		A0_phase_Y = A0_phase}
			if (A0_phase <= 180) {
			A0_phase_Y = 180 - A0_phase}
				if (A0_phase <= 270) {
				A0_phase_Y = A0_phase - 180}
					if (A0_phase <= 360) {
					A0_phase_Y = 360 - A0_phase}
	
	// определение координат вектора A0
		A0_1_X = 0;
		if (A0_phase <= 180) {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0
			} else {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0 * (-1)}
		A0_1_Y = 0;
		if (A0_phase <= 90 || A0_phase >= 270) {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0
			} else {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0 * (-1)}

	// определение угла наклона вектора m_test к осям X и Y
		if (m_test_corner <= 90) {
		m_test_corner_X = 90 - m_test_corner}
			if (m_test_corner <= 180) {
			m_test_corner_X = m_test_corner - 90}
				if (m_test_corner <= 270) {
				m_test_corner_X = 270 - m_test_corner}
					if (m_test_corner <= 360) {
					m_test_corner_X = m_test_corner - 270}
		if (m_test_corner <= 90) {
		m_test_corner_Y = m_test_corner}
			if (m_test_corner <= 180) {
			m_test_corner_Y = 180 - m_test_corner}
				if (m_test_corner <= 270) {
				m_test_corner_Y = m_test_corner - 180}
					if (m_test_corner <= 360) {
					m_test_corner_Y = 360 - m_test_corner}

	// определение координат вектора m_test
		m_test_1_X = 0;
		if (m_test_corner <= 180) {m_test_2_X = Math.abs(Math.cos(m_test_corner_X * 3.1415/180)) * m_test * (-1)
			} else {m_test_2_X = Math.abs(Math.cos(m_test_corner_X * 3.1415/180)) * m_test}
		m_test_1_Y = 0;
		if (m_test_corner <= 90 || m_test_corner >= 270) {m_test_2_Y = Math.abs(Math.cos(m_test_corner_Y * 3.1415/180)) * m_test
			} else {m_test_2_Y = Math.abs(Math.cos(m_test_corner_Y * 3.1415/180)) * m_test * (-1)}

	// определение угла наклона вектора A1 к осям X и Y
		if (A1_phase <= 90) {
		A1_phase_X = 90 - A1_phase}
			if (A1_phase <= 180) {
			A1_phase_X = A1_phase - 90}
				if (A1_phase <= 270) {
				A1_phase_X = 270 - A1_phase}
					if (A1_phase <= 360) {
					A1_phase_X = A1_phase - 270}
		if (A1_phase <= 90) {
		A1_phase_Y = A1_phase}
			if (A1_phase <= 180) {
			A1_phase_Y = 180 - A1_phase}
				if (A1_phase <= 270) {
				A1_phase_Y = A1_phase - 180}
					if (A1_phase <= 360) {
					A1_phase_Y = 360 - A1_phase}
	// определение координат вектора A1
		A1_1_X = 0;
		if (A1_phase <= 180) {A1_2_X = Math.abs(Math.cos(A1_phase_X * 3.1415/180)) * A1
			} else {A1_2_X = Math.abs(Math.cos(A1_phase_X * 3.1415/180)) * A1 * (-1)}
		A1_1_Y = 0;
		if (A1_phase <= 90 || A1_phase >= 270) {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * 3.1415/180)) * A1
			} else {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * 3.1415/180)) * A1 * (-1)}

	// определение модуля вектора dA
		dA_1_X = A0_2_X;
		dA_2_X = A1_2_X;
		dA_1_Y = A0_2_Y;
		dA_2_Y = A1_2_Y;
		dA = Math.sqrt(Math.pow(dA_2_X - dA_1_X, 2) + Math.pow(dA_2_Y - dA_1_Y, 2))

	// определение фазы вектора dA
		if ((dA_2_Y < dA_1_Y) && (dA_2_X < dA_1_X)) {
			dA_phase = 180 + (((Math.acos((Math.abs(dA_2_Y - dA_1_Y)) / dA)) * 180 ) / 3.1415)}
		if ((dA_2_Y > dA_1_Y) && (dA_2_X > dA_1_X)) {
			dA_phase = (((Math.acos((Math.abs(dA_2_Y - dA_1_Y)) / dA)) * 180 ) / 3.1415)}
		if ((dA_2_Y > dA_1_Y) && (dA_2_X < dA_1_X)) {
			dA_phase = 360 - (((Math.acos((Math.abs(dA_2_Y - dA_1_Y)) / dA)) * 180 ) / 3.1415)}
		if ((dA_2_Y < dA_1_Y) && (dA_2_X > dA_1_X)) {
			dA_phase = 180 - (((Math.acos((Math.abs(dA_2_Y - dA_1_Y)) / dA)) * 180 ) / 3.1415)}
			if (dA_phase > 360) {dA_phase = dA_phase - 360}

	// определение модуля вектора DCI (ДКВ)
		if (DCI_ != 0) {DCI = DCI_} // принимает значение из опций
		else {DCI = dA / m_test} // принимает значение из расчётов

	// определение фазы вектора DCI
		if (DCI_phase_ != 0) {DCI_phase = DCI_phase_} // принимает значение из опций
		else {DCI_phase = dA_phase - m_test_corner} // вычисляется в скрипте

	// определение модуля вектора Mb
		Mb = A0 / DCI;
		// Mb = (m_test * A0) / dA;

	// определение угла вектора Mb
		if ((A0_phase - DCI_phase + 180) < 360) {
			Mb_corner = (A0_phase - DCI_phase + 180)
			} else {Mb_corner = (A0_phase - DCI_phase + 180) - 360}
		// if ((m_test_corner + A0_phase - dA_phase + 180) < 360) {
		// 	Mb_corner = (m_test_corner + A0_phase - dA_phase + 180)
		// 	} else {Mb_corner = (m_test_corner + A0_phase - dA_phase + 180) - 360}

	// определение массы дисбаланса
		Mdisb = Mb; // равен массе балансировочного груза

	// определение угла расположения дисбаланса
		if ((Mb_corner + 180) > 360) {
	 		Mdisb_corner = (Mb_corner + 180) - 360}
		else if ((Mb_corner + 180) < 0) {
	 		Mdisb_corner = (Mb_corner + 180) + 360}
		else {Mdisb_corner = (Mb_corner + 180)}



gtl.log.info("Mb (балансировочный груз)",Mb);
gtl.log.info("Mb_corner (угол установки груза)",Mb_corner);
gtl.log.info("Mdisb (дисбаланс)",Mdisb);
gtl.log.info("Mdisb_corner (угол расположения дисбаланса)",Mdisb_corner);
gtl.log.info("m_test (пробный груз введёный)",m_test);
gtl.log.info("m_test_calc (пробный груз расчётный)",m_test_calc);
gtl.log.info("RMSv_2_1000",RMSv_2_1000.value);
gtl.log.info("RMSa",RMSa.value);
gtl.log.info("Необходимость проведения балансировки",test_balance);
gtl.log.info("F1_3_ph (фаза)",F1_3_ph);
gtl.log.info("F1_3_a (ампл)",F1_3_a);
gtl.log.info("F1_3_f (част)",F1_3_f);
gtl.log.info("F1_2_ph (фаза)",F1_2_ph);
gtl.log.info("F1_2_a (ампл)",F1_2_a);
gtl.log.info("F1_2_f (част)",F1_2_f);
gtl.log.info("F1_1_ph (фаза)",F1_1_ph);
gtl.log.info("F1_1_a (ампл)",F1_1_a);
gtl.log.info("F1_1_f (част)",F1_1_f);
gtl.log.info("gtl.diagnostic.interval",gtl.diagnostic.interval);
gtl.log.info("Частота вращения freq.value", freq.value);
gtl.log.info("Нестабильность частоты вращения, %", instability*100);


    // Выдача результата (results)
    let __result3 = {
		Частота_вращения_F1: freq.value,
		Ампл_гарм_1F1: F1_1_a,
		Фаза_част_вращ_F1: F1_1_ph,
		Тестирование: test_balance,
		Примен_пробный_груз: m_test,
		Расч_масса_пробного_груза: m_test_calc,
		Масса_баланс_груза: Mb,
		Угол_баланс_груза: Mb_corner,
		СКЗ_виброскор: RMSv_2_1000.value,
		Нестаб_част_вращ: instability*100,
		ДКВ_модуль: DCI,
		ДКВ_фаза: DCI_phase
		
	  };

gtl.results = {"result_ausp": __result1,
				"result_pfc": __result2,
				"result_общий": __result3};

gtl.diagnostic.stop();

break;

default:
	break;
}
}