"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 - салатовый
// #0fae1a - зелёный
// #0000ff - синий
// #00ddff - голубой
// #ff3dcc - фиолетовый
// #ffff00 - жёлтый

// ***** БАЛАНСИРОВОЧНЫЙ КАЛЬКУЛЯТОР. ДВЕ ПЛОСКОСТИ *****
// ******************************************************

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

	// Канал A
	// ФИЛЬТР_A 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
		let filter_A_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
		filter_A_2_1000.kind = gtl.filter_iir.butterworth;
		filter_A_2_1000.type = gtl.filter_iir.bandpass;
		filter_A_2_1000.order = 6;
		filter_A_2_1000.frequency = 501; // центральная частота полосового фильтра
		filter_A_2_1000.width = 998; // ширина полосы фильтра
		let filter_A_2_1000v = gtl.add_intg(filter_A_2_1000); // интегрирование
		filter_A_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
	// Фильтр A для виброперемещения
		let filter_A_2_300s = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
		filter_A_2_300s.kind = gtl.filter_iir.butterworth;
    	filter_A_2_300s.type = gtl.filter_iir.bandpass; // полосовой фильтр
		filter_A_2_300s.order = 4;
		filter_A_2_300s.frequency = 151; // центральная частота
    	filter_A_2_300s.width = 298; // ширина полосы

	// Канал B
	// ФИЛЬТР_B 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
		let filter_B_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[1].portNumber]);
		filter_B_2_1000.kind = gtl.filter_iir.butterworth;
		filter_B_2_1000.type = gtl.filter_iir.bandpass;
		filter_B_2_1000.order = 6;
		filter_B_2_1000.frequency = 501; // центральная частота полосового фильтра
		filter_B_2_1000.width = 998; // ширина полосы фильтра
		let filter_B_2_1000v = gtl.add_intg(filter_B_2_1000); // интегрирование
		filter_B_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
	// Фильтр B для виброперемещения
		let filter_B_2_300s = gtl.add_filter_iir(gtl.analog_inputs[signals[1].portNumber]);
		filter_B_2_300s.kind = gtl.filter_iir.butterworth;
    	filter_B_2_300s.type = gtl.filter_iir.bandpass; // полосовой фильтр
		filter_B_2_300s.order = 4;
		filter_B_2_300s.frequency = 151; // центральная частота
    	filter_B_2_300s.width = 298; // ширина полосы

	// Переключатель источника сигнала - относительная / абсолютная вибрация
		// 0 - относительная вибрация (датчик виброперемещения)
		// 1 - абсолютная вибрация (датчик виброускорения)
		let select_vibr_sign = gtl.options.customOptions.select_vibr_sign;


	// Выбор фильтра и параметров спектров в зависимости от значения переключателя источника сигнала вибрации
		if (select_vibr_sign == 1)
		{
			filter_A_vibr = filter_A_2_1000v;
			filter_B_vibr = filter_B_2_1000v;
			frequency = 1000;
		}
		else if (select_vibr_sign == 0)
		{
			filter_A_vibr = filter_A_2_300s;
			filter_B_vibr = filter_B_2_300s;
			frequency = 300;			
		}

	// Спектр_A для получения 1-й гармоники частоты вращения
		let AUSP_A = gtl.add_ausp(filter_A_vibr); // объявление переменной спектра
		AUSP_A.color = 0x00ff0000; // цвет спектра
		AUSP_A.name = "AUSP_A"; // имя спектра
		AUSP_A.frequency = frequency; // граничная частота спектра
		AUSP_A.lines = AUSP_A.frequency * 1/resolution; // разрешение спектра (количество линий)
		AUSP_A.average = average; // количество усреднений
		AUSP_A.unit = gtl.spec.unit; // отображение амплитуды в мм/с
		AUSP_A.smoothing_factor = 100; // усреднение средней линии
		AUSP_A.smoothed_line_color = 0xff004dff; // цвет средней линии
		AUSP_A.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный)
		AUSP_A.tolerance = AUSP_A.resolution; // диапазон поиска гармоник +/-
	// СКЗ_A
		let RMS_A = gtl.add_value_rms(filter_A_vibr);
		RMS_A.time = 1;
		RMS_A.avg_cnt = 3;

	// Спектр_B для получения 1-й гармоники частоты вращения
		let AUSP_B = gtl.add_ausp(filter_B_vibr); // объявление переменной спектра
		AUSP_B.color = 0x00ff0000; // цвет спектра
		AUSP_B.name = "AUSP_A"; // имя спектра
		AUSP_B.frequency = frequency; // граничная частота спектра
		AUSP_B.lines = AUSP_B.frequency * 1/resolution; // разрешение спектра (количество линий)
		AUSP_B.average = average; // количество усреднений
		AUSP_B.unit = gtl.spec.unit; // отображение амплитуды в мм/с
		AUSP_B.smoothing_factor = 100; // усреднение средней линии
		AUSP_B.smoothed_line_color = 0xff004dff; // цвет средней линии
		AUSP_B.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный)
		AUSP_B.tolerance = AUSP_B.resolution; // диапазон поиска гармоник +/-
	// СКЗ_B
		let RMS_B = gtl.add_value_rms(filter_B_vibr);
		RMS_B.time = 1;
		RMS_B.avg_cnt = 3;


	// Спектр вибрации точки A
	var AUSP_A_pl = gtl.create_ausp(
		{
			"src" : filter_A_vibr,
			"frequency" : frequency,
			"resolution" : resolution,
			"average" : average,
			"overlap" : overlap,
			"window" : gtl.spec.rectangular,
			"view" : gtl.spec.unit
		}
	);
	// ФЧХ точки A
	var pfc_A_pl = gtl.create_pfc(
		{
			"src0" : filter_A_vibr,
			"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
		}
	);

	// Спектр виброскорости точки B
	var AUSP_B_pl = gtl.create_ausp(
		{
			"src" : filter_B_vibr,
			"frequency" : frequency,
			"resolution" : resolution,
			"average" : average,
			"overlap" : overlap,
			"window" : gtl.spec.rectangular,
			"view" : gtl.spec.unit
		}
	);
	// ФЧХ точки B
	var pfc_B_pl = gtl.create_pfc(
		{
			"src0" : filter_B_vibr,
			"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

// Объявление графических плоскостей для построения графиков
	let plot_pfc = gtl.plots.add("ФЧХ"); // фазо-частотная характеристика
	let plot_ausp = gtl.plots.add("Спектры вибрации"); // объект для спектра
	let plot_vibr = gtl.plots.add("Векторы вибрации"); // объект для векторов вибрации
	let plot_disb = 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 A0_ = gtl.options.customOptions.A0; 			// модуль вектора начальной вибрации точки A */**
let A0 = A0_;										// модуль вектора начальной вибрации точки A */** (конечное значение)
let A0_phase_ = gtl.options.customOptions.A0_phase;	// фаза вектора начальной вибрации точки A */**
let A0_phase = A0_phase_; 							// фаза вектора начальной вибрации точки A */** (конечное значение)
let A2_ = gtl.options.customOptions.A2;				// модуль вектора вибрации точки A после установки пробного груза в плоскость 2 */**
let A2;												// модуль вектора вибрации точки A после установки пробного груза в плоскость 2 */** (конечное значение)
let A2_phase_ = gtl.options.customOptions.A2_phase;	// фаза вектора вибрации точки A после установки пробного груза в плоскость 2 */**
let A2_phase;										// фаза вектора вибрации точки A после установки пробного груза в плоскость 2 */** (конечное значение)
let dA2;											// модуль вектора дельты вибрации точки A после установки пробного груза в плоскость 2 ***
let dA2_phase;										// фаза вектора дельты вибрации точки A после установки пробного груза в плоскость 2 ***

let B0_ = gtl.options.customOptions.B0; 			// модуль вектора начальной вибрации точки B */**
let B0 = B0_;										// модуль вектора начальной вибрации точки B */** (конечное значение)
let B0_phase_ = gtl.options.customOptions.B0_phase;	// фаза вектора начальной вибрации точки B */**
let B0_phase = B0_phase_; 							// фаза вектора начальной вибрации точки B */** (конечное значение)
let B2_ = gtl.options.customOptions.B2;				// модуль вектора вибрации точки B после установки пробного груза в плоскость 2 */**
let B2;												// модуль вектора вибрации точки B после установки пробного груза в плоскость 2*/** (конечное значение)
let B2_phase_ = gtl.options.customOptions.B2_phase;	// фаза вектора вибрации точки B после установки пробного груза в плоскость 2 */**
let B2_phase;										// фаза вектора вибрации точки B после установки пробного груза в плоскость 2 */** (конечное значение)
let dB2												// модуль вектора дельты вибрации точки B после установки пробного груза в плоскость 2 ***
let dB2_phase;										// фаза вектора дельты вибрации точки B после установки пробного груза в плоскость 2 ***


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

let A2_phase_X;		// угол наклона вектора A2к оси X
let A2_phase_Y;		// угол наклона вектора A2 к оси Y
let A2_1_X;			// начальная координата вектора A2 по оси X
let A2_2_X;			// конечная координата вектора A2 по оси X
let A2_1_Y;			// начальная координата вектора A2 по оси Y
let A2_2_Y;			// конечная координата вектора A2 по оси Y

let dA2_1_X;		// начальная координата вектора dA2 по оси X
let dA2_2_X;		// конечная координата вектора dA2 по оси X
let dA2_1_Y;		// начальная координата вектора dA2 по оси Y
let dA2_2_Y;		// конечная координата вектора dA2 по оси Y

let B0_phase_X;		// угол наклона вектора B0 к оси X
let B0_phase_Y;		// угол наклона вектора B0 к оси Y
let B0_1_X;			// начальная координата вектора B0 по оси X
let B0_2_X;			// конечная координата вектора B0 по оси X
let B0_1_Y;			// начальная координата вектора B0 по оси Y
let B0_2_Y;			// конечная координата вектора B0 по оси Y

let B2_phase_X;		// угол наклона вектора B2 к оси X
let B2_phase_Y;		// угол наклона вектора B2 к оси Y
let B2_1_X;			// начальная координата вектора B2 по оси X
let B2_2_X;			// конечная координата вектора B2 по оси X
let B2_1_Y;			// начальная координата вектора B2 по оси Y
let B2_2_Y;			// конечная координата вектора B2 по оси Y

let dB2_1_X;		// начальная координата вектора dB2 по оси X
let dB2_2_X;		// конечная координата вектора dB2 по оси X
let dB2_1_Y;		// начальная координата вектора dB2 по оси Y
let dB2_2_Y;		// конечная координата вектора dB2 по оси Y


// ***** РАСЧЁТЫ *****
// gtl.diagnostic.interval = 15;
gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_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(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;;
		state = 3;
		break;
  
	case 1: // Частота вращения фиксированная
		// Определение минимально необходимой длительности сигнала для проведения диагностики
		gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;
		state = 3;
		break;
  
	case 2: // Частота вращения из поля INFO (виброметр)
		// Определение минимально необходимой длительности сигнала для проведения диагностики
		gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;
		state = 3;
		break;
  
	case 3: // Выполняем анализ спектов
		// Очистка партретов спектров
		AUSP_A.clear_harms_sets();
		AUSP_B.clear_harms_sets();

// Спектры вибрации точки A
    let __AUSP_A_tools = gtl.create_spec_tools(
        {
            data: AUSP_A_pl.data,
            df: AUSP_A_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x00ff00
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });
    let __row_AUSP_A = __AUSP_A_tools.harms.add(freq.value, 1, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row_AUSP_A.name = "F1_A (гарм. ряд част. вращ. точки A)"; // название гармонического ряда
    // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)
	
	let __pfc_A_tools = gtl.create_spec_tools(
        {
            data: pfc_A_pl.data,
            df: pfc_A_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x0000ff
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });
	let __row_phase_A = __pfc_A_tools.harms.add(freq.value, 1, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row_phase_A.name = "F1_A_phase (гарм. ряд част. вращ. точки A)"; // название гармонического ряда

// Спектры вибрации точки B
    let __AUSP_B_tools = gtl.create_spec_tools(
        {
            data: AUSP_B_pl.data,
            df: AUSP_B_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x00ff00
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });
    let __row_AUSP_B = __AUSP_B_tools.harms.add(freq.value, 1, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row_AUSP_B.name = "F1_B (гарм. ряд част. вращ. точки B)"; // название гармонического ряда
    // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)
	
	let __pfc_B_tools = gtl.create_spec_tools(
        {
            data: pfc_B_pl.data,
            df: pfc_B_pl.resolution,
            base: {
                factor: 100,
                visible: true,
                color: 0x0000ff
            },
            peaks: {
                color: 0xff0000,
                visible: true,
                level: 0.000001
            },
            harms: {
                tolerance: 1
            }
        });
	let __row_phase_B = __pfc_B_tools.harms.add(freq.value, 1, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row_phase_B.name = "F1_B_phase (гарм. ряд част. вращ. точки B)"; // название гармонического ряда



// Построение графиков
	// Вибрация точки A
    plot_ausp.add(
        {
        	color: 0x0000ff,
        	name: "Спектр вибрации точки A",
        	x: AUSP_A_pl.resolution,
        	y: AUSP_A_pl.data,
        	spec_tools: __AUSP_A_tools.to_json()
        });
	plot_pfc.add(
		{
			color: 0xff0000,
			name: "ФЧХ вибрации точки A",
			x: pfc_A_pl.resolution,
			y: pfc_A_pl.data,
			spec_tools: __pfc_A_tools.to_json()
		});
    let __result1_A = __AUSP_A_tools.to_json();
	let __result2_A = __pfc_A_tools.to_json();
		// Амплитуда гармонического ряда частоты вращения
		var F1_1_a_A = __result1_A.harms.rows[0].harms[0].ampl;
		// Частота гармонического ряда частоты вращения
		var F1_1_f_A = __result1_A.harms.rows[0].harms[0].freq;
		// Фаза (амплитуда) гармонического ряда частоты вращения
		var F1_1_ph_A = __result2_A.harms.rows[0].harms[0].ampl;

	// Вибрация точки B
    plot_ausp.add(
        {
        	color: 0x0000ff,
        	name: "Спектр вибрации точки B",
        	x: AUSP_B_pl.resolution,
        	y: AUSP_B_pl.data,
        	spec_tools: __AUSP_B_tools.to_json()
        });
	plot_pfc.add(
		{
			color: 0xff0000,
			name: "ФЧХ вибрации точки B",
			x: pfc_B_pl.resolution,
			y: pfc_B_pl.data,
			spec_tools: __pfc_B_tools.to_json()
		});
    let __result1_B = __AUSP_B_tools.to_json();
	let __result2_B = __pfc_B_tools.to_json();
		// Амплитуда гармонического ряда частоты вращения
		var F1_1_a_B = __result1_B.harms.rows[0].harms[0].ampl;
		// Частота гармонического ряда частоты вращения
		var F1_1_f_B = __result1_B.harms.rows[0].harms[0].freq;
		// Фаза (амплитуда) гармонического ряда частоты вращения
		var F1_1_ph_B = __result2_B.harms.rows[0].harms[0].ampl;

	
// РАСЧЁТЫ (балансировочный калькулятор)
// ШАГ 5 - вибрация пробного пуска A2 и B2 (пробный груз в плоскости 2):
	// измерение вибрации A2 и B2 (или ввод вручную)
	// из предыдущих шагов переносятся: амплитуда и фаза вибрации A0, B0
	// построение графиков вибрации A0, A2 и dA2, B0, B2 и dB2

		// Определение конечных значений переменных
			// A2 вибрация после установки пробного груза в плоскость 2
			if (A2_ != 0) {A2 = A2_} // принимает значение из опций
			else {A2 = F1_1_a_A} // принимает значение из спектра сигнала
			if (A2_phase_ != 0) {A2_phase = A2_phase_} // принимает значение из опций
			else {A2_phase = F1_1_ph_A} // принимает значение из спектра сигнала

			// B2 вибрация после установки пробного груза в плоскость 2
			if (B2_ != 0) {B2 = B2_} // принимает значение из опций
			else {B2 = F1_1_a_B} // принимает значение из спектра сигнала
			if (B2_phase_ != 0) {B2_phase = B2_phase_} // принимает значение из опций
			else {B2_phase = F1_1_ph_B} // принимает значение из спектра сигнала


	// определение угла наклона вектора 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
		var xA0_array = []; // массив координат точек вектора A0 по оси X
		var yA0_array = []; // массив координат точек вектора A0 по оси Y
		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)}
		xA0_array[0] = A0_1_X;
		xA0_array[1] = A0_2_X;
		yA0_array[0] = A0_1_Y;
		yA0_array[1] = A0_2_Y;

	// определение угла наклона вектора A2 к осям X и Y
		if (A2_phase <= 90) {
		A2_phase_X = 90 - A2_phase}
			if (A2_phase <= 180) {
			A2_phase_X = A2_phase - 90}
				if (A2_phase <= 270) {
				A2_phase_X = 270 - A2_phase}
					if (A2_phase <= 360) {
					A2_phase_X = A2_phase - 270}
		if (A2_phase <= 90) {
		A2_phase_Y = A2_phase}
			if (A2_phase <= 180) {
			A2_phase_Y = 180 - A2_phase}
				if (A2_phase <= 270) {
				A2_phase_Y = A2_phase - 180}
					if (A2_phase <= 360) {
					A2_phase_Y = 360 - A2_phase}
	// определение координат вектора A2
		var xA2_array = []; // массив координат точек вектора A2 по оси X
		var yA2_array = []; // массив координат точек вектора A2 по оси Y
		A2_1_X = 0;
		if (A2_phase <= 180) {A2_2_X = Math.abs(Math.cos(A2_phase_X * 3.1415/180)) * A2
			} else {A2_2_X = Math.abs(Math.cos(A2_phase_X * 3.1415/180)) * A2 * (-1)}
		A2_1_Y = 0;
		if (A2_phase <= 90 || A2_phase >= 270) {A2_2_Y = Math.abs(Math.cos(A2_phase_Y * 3.1415/180)) * A2
			} else {A2_2_Y = Math.abs(Math.cos(A2_phase_Y * 3.1415/180)) * A2 * (-1)}
		xA2_array[0] = A2_1_X;
		xA2_array[1] = A2_2_X;
		yA2_array[0] = A2_1_Y;
		yA2_array[1] = A2_2_Y;

	// определение модуля вектора dA2
		var xdA2_array = []; // массив координат точек вектора dA2 по оси X
		var ydA2_array = []; // массив координат точек вектора dA2 по оси Y
		dA2_1_X = A0_2_X;
		dA2_2_X = A2_2_X;
		dA2_1_Y = A0_2_Y;
		dA2_2_Y = A2_2_Y;
		dA2 = Math.sqrt(Math.pow(dA2_2_X - dA2_1_X, 2) + Math.pow(dA2_2_Y - dA2_1_Y, 2))
		xdA2_array[0] = dA2_1_X;
		xdA2_array[1] = dA2_2_X;
		ydA2_array[0] = dA2_1_Y;
		ydA2_array[1] = dA2_2_Y;
	// определение фазы вектора dA2
		if ((dA2_2_Y < dA2_1_Y) && (dA2_2_X < dA2_1_X)) {
			dA2_phase = 180 + (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
		if ((dA2_2_Y > dA2_1_Y) && (dA2_2_X > dA2_1_X)) {
			dA2_phase = (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
		if ((dA2_2_Y > dA2_1_Y) && (dA2_2_X < dA2_1_X)) {
			dA2_phase = 360 - (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
		if ((dA2_2_Y < dA2_1_Y) && (dA2_2_X > dA2_1_X)) {
			dA2_phase = 180 - (((Math.acos((Math.abs(dA2_2_Y - dA2_1_Y)) / dA2)) * 180 ) / 3.1415)}
			if (dA2_phase > 360) {dA2_phase = dA2_phase - 360}

	// определение угла наклона вектора B0 к осям X и Y
		if (B0_phase <= 90) {
		B0_phase_X = 90 - B0_phase}
			if (B0_phase <= 180) {
			B0_phase_X = B0_phase - 90}
				if (B0_phase <= 270) {
				B0_phase_X = 270 - B0_phase}
					if (B0_phase <= 360) {
					B0_phase_X = B0_phase - 270}
		if (B0_phase <= 90) {
		B0_phase_Y = B0_phase}
			if (B0_phase <= 180) {
			B0_phase_Y = 180 - B0_phase}
				if (B0_phase <= 270) {
				B0_phase_Y = B0_phase - 180}
					if (B0_phase <= 360) {
					B0_phase_Y = 360 - B0_phase}
	// определение координат вектора B0
		var xB0_array = []; // массив координат точек вектора B0 по оси X
		var yB0_array = []; // массив координат точек вектора B0 по оси Y
		B0_1_X = 0;
		if (B0_phase <= 180) {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0
			} else {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0 * (-1)}
		B0_1_Y = 0;
		if (B0_phase <= 90 || B0_phase >= 270) {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0
			} else {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0 * (-1)}
		xB0_array[0] = B0_1_X;
		xB0_array[1] = B0_2_X;
		yB0_array[0] = B0_1_Y;
		yB0_array[1] = B0_2_Y;

	// определение угла наклона вектора B2 к осям X и Y
		if (B2_phase <= 90) {
		B2_phase_X = 90 - B2_phase}
			if (B2_phase <= 180) {
			B2_phase_X = B2_phase - 90}
				if (B2_phase <= 270) {
				B2_phase_X = 270 - B2_phase}
					if (B2_phase <= 360) {
					B2_phase_X = B2_phase - 270}
		if (B2_phase <= 90) {
		B2_phase_Y = B2_phase}
			if (B2_phase <= 180) {
			B2_phase_Y = 180 - B2_phase}
				if (B2_phase <= 270) {
				B2_phase_Y = B2_phase - 180}
					if (B2_phase <= 360) {
					B2_phase_Y = 360 - B2_phase}
	// определение координат вектора B2
		var xB2_array = []; // массив координат точек вектора B2 по оси X
		var yB2_array = []; // массив координат точек вектора B2 по оси Y
		B2_1_X = 0;
		if (B2_phase <= 180) {B2_2_X = Math.abs(Math.cos(B2_phase_X * 3.1415/180)) * B2
			} else {B2_2_X = Math.abs(Math.cos(B2_phase_X * 3.1415/180)) * B2 * (-1)}
		B2_1_Y = 0;
		if (B2_phase <= 90 || B2_phase >= 270) {B2_2_Y = Math.abs(Math.cos(B2_phase_Y * 3.1415/180)) * B2
			} else {B2_2_Y = Math.abs(Math.cos(B2_phase_Y * 3.1415/180)) * B2 * (-1)}
		xB2_array[0] = B2_1_X;
		xB2_array[1] = B2_2_X;
		yB2_array[0] = B2_1_Y;
		yB2_array[1] = B2_2_Y;

	// определение модуля вектора dB2
		var xdB2_array = []; // массив координат точек вектора dB2 по оси X
		var ydB2_array = []; // массив координат точек вектора dB2 по оси Y
		dB2_1_X = B0_2_X;
		dB2_2_X = B2_2_X;
		dB2_1_Y = B0_2_Y;
		dB2_2_Y = B2_2_Y;
		dB2 = Math.sqrt(Math.pow(dB2_2_X - dB2_1_X, 2) + Math.pow(dB2_2_Y - dB2_1_Y, 2))
		xdB2_array[0] = dB2_1_X;
		xdB2_array[1] = dB2_2_X;
		ydB2_array[0] = dB2_1_Y;
		ydB2_array[1] = dB2_2_Y;
	// определение фазы вектора dB2
		if ((dB2_2_Y < dB2_1_Y) && (dB2_2_X < dB2_1_X)) {
			dB2_phase = 180 + (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
		if ((dB2_2_Y > dB2_1_Y) && (dB2_2_X > dB2_1_X)) {
			dB2_phase = (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
		if ((dB2_2_Y > dB2_1_Y) && (dB2_2_X < dB2_1_X)) {
			dB2_phase = 360 - (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
		if ((dB2_2_Y < dB2_1_Y) && (dB2_2_X > dB2_1_X)) {
			dB2_phase = 180 - (((Math.acos((Math.abs(dB2_2_Y - dB2_1_Y)) / dB2)) * 180 ) / 3.1415)}
			if (dB2_phase > 360) {dB2_phase = dB2_phase - 360}

	// определение координат точек окружности графика для отображения векторов вибрации
		var xV_array = []; // массив координат точек окружности V по оси X
		var yV_array = []; // массив координат точек окружности V по оси Y
		var x0V = 0; // центр в начале координат
		var y0V = 0; // центр в начале координат
			for (let i=0; i<=359; i++ ) {
				xV_array.push(x0V + (Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.1) * (Math.sin((i) * Math.PI / 180)));
				yV_array.push(y0V + (Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.1) * (Math.cos((i) * Math.PI / 180)));}


// Графики вибрации
	plot_vibr.add(
        {
        	color: 0x0000ff,
        	name: "Вибрация_A0",
        	x: xA0_array,
        	y: yA0_array,
        });
	plot_vibr.add(
        {
        	color: 0x00ff00,
        	name: "Вибрация_A2",
        	x: xA2_array,
        	y: yA2_array,
        });
	plot_vibr.add(
        {
        	color: 0xff0000,
        	name: "Вибрация_dA2",
        	x: xdA2_array,
        	y: ydA2_array,
        });
	plot_vibr.add(
        {
        	color: 0x0000ff,
        	name: "Вибрация_B0",
        	x: xB0_array,
        	y: yB0_array,
        });
	plot_vibr.add(
        {
        	color: 0x00ff00,
        	name: "Вибрация_B2",
        	x: xB2_array,
        	y: yB2_array,
        });
	plot_vibr.add(
        {
        	color: 0xff0000,
        	name: "Вибрация_dB2",
        	x: xdB2_array,
        	y: ydB2_array,
        });	
	plot_vibr.add(
        {
        	color: 0x00ffffff,
        	name: "График векторов вибрации",
        	x: xV_array,
        	y: yV_array,
        });
	plot_vibr.add(
		{
			color: 0x00ffffff,
			name: "границы",
			x: [-(Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), -(Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), (Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), (Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2)],
			y: [(Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), -(Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), -(Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2), (Math.max(A0,A2,dA2,B0,B2,dB2)+Math.max(A0,A2,dA2,B0,B2,dB2)*0.2)]
		});


gtl.log.info("RMS_A",RMS_A.value);
gtl.log.info("A0",A0);
gtl.log.info("A0_phase",A0_phase);
gtl.log.info("A2",A2);
gtl.log.info("A2_phase",A2_phase);
gtl.log.info("F1_1_ph_A (фаза)",F1_1_ph_A);
gtl.log.info("F1_1_a_A (ампл)",F1_1_a_A);
gtl.log.info("F1_1_f_A (част)",F1_1_f_A);
gtl.log.info("RMS_B",RMS_B.value);
gtl.log.info("B0",B0);
gtl.log.info("B0_phase",B0_phase);
gtl.log.info("B2",B2);
gtl.log.info("B2_phase",B2_phase);
gtl.log.info("F1_1_ph_B (фаза)",F1_1_ph_B);
gtl.log.info("F1_1_a_B (ампл)",F1_1_a_B);
gtl.log.info("F1_1_f_B (част)",F1_1_f_B);
gtl.log.info("Частота вращения, Гц", freq.value);
gtl.log.info("Нестабильность частоты вращения, %", instability*100);


    // Выдача результата (results)
    let __result = {

		_001_Ампл_гарм_1F1_A: F1_1_a_A,
		_002_Фаза_част_вращ_F1_A: F1_1_ph_A,
		_003_Ампл_вибр_пуска_A0: A0,
		_004_Фаза_вибр_пуска_A0: A0_phase,
		_005_Ампл_вибр_пуска_A2: A2,
		_006_Фаза_вибр_пуска_A2: A2_phase,
		_007_СКЗ_вибр_A: RMS_A.value,

		_008_Ампл_гарм_1F1_B: F1_1_a_B,
		_009_Фаза_част_вращ_F1_B: F1_1_ph_B,
		_010_Ампл_вибр_пуска_B0: B0,
		_011_Фаза_вибр_пуска_B0: B0_phase,
		_012_Ампл_вибр_пуска_B2: B2,
		_013_Фаза_вибр_пуска_B2: B2_phase,
		_014_СКЗ_вибр_B: RMS_B.value,
		
		_015_Частота_вращения_F1: freq.value,
		_016_Нестаб_част_вращ: instability*100,
	  };

gtl.results = {"result": __result};

gtl.diagnostic.stop();

break;

default:
	break;
}
}