"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("user-functions.js"); // используемые функции
// Цвета (для справки)
// #ff0000 - красный
// #00ff00 - зелёный
// #0000ff - синий
// #00ddff - голубой
// #ff3dcc - фиолетовый
// #ffff00 - жёлтый


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

// Получение входных сигналов

	// ФИЛЬТР 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 = 1000; // граничная частота спектра
		AUSPv.lines = AUSPv.frequency * 2; // разрешение спектра (количество линий)
		AUSPv.average = 4; // количество усреднений
		AUSPv.unit = gtl.spec.unit; // отображение амплитуды в мм/с
		AUSPv.smoothing_factor = 100; // усреднение средней линии
		AUSPv.smoothed_line_color = 0xff004dff; // цвет средней линии
		AUSPv.peak_level = 0.1; // порог обнаружения гармоник (необходим самый минимальный)
		AUSPv.tolerance = AUSPv.resolution; // диапазон поиска гармоник +/-

	// Настройки для спектров и АФЧХ
	var frequency = 1000; // граничная частота
	var resolution = 0.25; // частотное разрешение
	var average = 3; // количество усреднений
	var overlap = 0; // наложение

	// 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 apfc_pl = gtl.add_apfc(
	// 	{
	// 		"src0" : filter_2_1000v,
	// 		// "src0" : gtl.analog_inputs[signals[0].portNumber],
	// 		"src1" : gtl.analog_inputs[signals[1].portNumber],
	// 		// "name" : "АФЧХ",
	// 		"color" : 0xff0000,
	// 		"visible" : true,
	// 		"freq" : frequency,
	// 		"window" : gtl.spec.rectangular,
	// 		"resolution" : resolution,
	// 		"average" : average,
	// 		"overlap" : overlap,
	// 		"afc" : gtl.apfc.magnitude,
	// 		"pfc" : gtl.apfc.deg
	// 	}
	// );

	// АЧХ (новый метод)
	// var afc_pl = gtl.create_afc(
	// 	{
	// 		// "src0" : filter_2_1000v,
	// 		"src0" : gtl.analog_inputs[signals[0].portNumber],
	// 		"src1" : gtl.analog_inputs[signals[1].portNumber],
	// 		"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,
			// "src0" : gtl.analog_inputs[0],
			"src0" : gtl.analog_inputs[1],
			"src1" : filter_2_1000v,
			"frequency" : frequency,
			"resolution" : resolution,
			"average" : average,
			"overlap" : overlap,
			"window" : gtl.spec.rectangular,
			"view" : gtl.phase.deg,
			"is_single" : false, //по умолчанию - false
			// "delay" : .1, // по умолчанию - 0
			// "start" : false // по умолчанию - true
		}
	);


	// Примечание
	// is_single - тип расчета: однократный или непрерывный. непрерывный - как сейчас. однократный - будет произведен расчет по окончанию набора данных и после этого будет вызван сигнал finished.  после этого до вызова метода start набор данных и расчет производиться не будет.
	// delay  - задержка в секундах. до начала набора данных. полезно, если нужно пропустить данные каких-нибудь переходных процессов.
	// start  - флаг, показывающий, нужно ли начинать набор сразу после создания объекта.  позже можно запустить с помощью метода start().
	// теперь можно окончание расчета не отслеживать по времени, а отлавливать сигнал.
	// пример:
	// var afc = gtl.create_afc(
	// 	{
	// 	  src0 : gtl.analog_inputs[0],
	// 	  src1 : gtl.analog_inputs[1],
	// 	  frequency : 1000,
	// 	  resolution : 1,
	// 	  average : 3,
	// 	  overlap : .5,
	// 	  window : gtl.spec.rectangular,
	// 	  is_single : true, //по умолчанию - false
	// 	  delay : .1, //по умолчанию - 0
	// 	  start : false //по умолчанию - true
	// 	}
	// );
	// let plot1 = gtl.plots.add("plot1");
	// afc.finished.connect(afc_finished);
	// function afc_finished()
	// {
	//   plot1.add(
	// 	{
	// 	color: 0x0000ff,
	// 	name: "afc",
	// 	x: afc.resolution,
	// 	y: afc.data
	// 	}
	//   )
	//   gtl.log.info("afc", "finished");
	// }
	// gtl.log.info("acq time", afc.acq_time);
	// afc.start();
	// //afc.start(2); //старт с задержкой

	
	// Объявление графических плоскостей для построения графиков
		var plot_afc = gtl.plots.add("АЧХ"); // амплитудно-частотная характеристика
		var plot_pfc = gtl.plots.add("ФЧХ"); // фазо-частотная характеристика
		var plot_ausp = gtl.plots.add("Спектр виброскорости"); // создание объекта для спектра
		var plot_afc1 = gtl.plots.add("АЧХ из apfc"); // АЧХ из старого метода apfc
		var plot_pfc1 = gtl.plots.add("ФЧХ из apfc"); // ФЧХ из старого метода apfc 


	// СКЗ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;


// Переменные основные
// масса груза (модуль ветора) - граммы
// в качестве вибрации лучше использовать амплитуду оборотной гармоники (или СКЗ виброскорости)

// Массу пробного груза рекомендуется брать исходя их расчёта:
// m_test = 804 * (P * A)/(R * N), где:
// P - масса ротора; A - вибрация в мм/с; R - радиус плоскости коррекции;
// N - скорость вращения в об/мин

// * - значение получаем из измерительного блока при нажатии кнопки
// ** - значение вводится пользователем
// *** - значение получаем в результате расчёта программы балансировки
var m_test = 30;		// масса пробного груза **
var m_test_calc;		// масса пробного груза расчётная ***
var n = 3000;			// скорость вращения, об/мин ** (для вычисления массы пробного груза)
var FREQ_0 = 3000 / 60;	// частота вращения, об/мин *** (для определения амплитуды оборотной гармоники)
var R = 200;			// радиус установки грузов ** (для вычисления массы пробного груза)
var P = 10000;			// масса ротора, грамм ** (для вычисления массы пробного груза)

var Mb;					// масса балансировочного груза ***
var Mb_corner;			// угол установки балансировочного груза ***

var A0 = 12;			// амплитуда вибрации нулевого пуска */**
var A1 = 15;			// амплитуда вибрации (окружности) пробного пуска №1
var A2 = 10;			// амплитуда вибрации (окружности) пробного пуска №2
var A3 = 18;			// амплитуда вибрации (окружности) пробного пуска №3
var A1_corner = 0;		// угол установки груза пробного пуска №1
var A2_corner = 120;	// угол установки груза пробного пуска №2
var A3_corner = 240;	// угол установки груза пробного пуска №3
var x00 = 0;			// координата центра окружности нулевого пуска по оси X
var y00 = 0;			// координата центра окружности нулевого пуска по оси Y
// переменные для обозначения пересечения окружностей A1 и A2
var d12;				// расстояние между центрами окружностей пробных пусков №1 и 2
var b1;					// расстояние от центра окружности A1 до точки пересечения P11 с окружностью A2
var c1;					// расстояние от центра окружности A2 до точки пересечения P11 с окружностью A1
// d12 = b1 + c1
var P11;				// центральная точка между P21 и P_21 (_ обозначает штрих)
var P21;				// точка пересечения окружностей A1 и A2
var P_21;				// точка пересечения окружностей A1 и A2
var h1;					// расстояние от точки P11 до точки P21 и P_21
var P11_X;				// координата точки P11 по оси X
var P11_Y;				// координата точки P11 по оси Y
var P21_X;				// координата точки P21 по оси X
var P21_Y;				// координата точки P21 по оси Y
var P_21_X;				// координата точки P_21 по оси X
var P_21_Y;				// координата точки P_21 по оси Y

// переменные для обозначения пересечения окружностей A2 и A3
var d23;				// расстояние между центрами окружностей пробных пусков №2 и 3
var b2;					// расстояние от центра окружности A2 до точки пересечения P12 с окружностью A3
var c2;					// расстояние от центра окружности A3 до точки пересечения P12 с окружностью A2
// d23 = b2 + c2
var P12;				// центральная точка между P22 и P_22 (_ обозначает штрих)
var P22;				// точка пересечения окружностей A2 и A3
var P_22;				// точка пересечения окружностей A2 и A3
var h2;					// расстояние от точки P12 до точки P22 и P_22
var P12_X;				// координата точки P12 по оси X
var P12_Y;				// координата точки P12 по оси Y
var P22_X;				// координата точки P22 по оси X
var P22_Y;				// координата точки P22 по оси Y
var P_22_X;				// координата точки P_22 по оси X
var P_22_Y;				// координата точки P_22 по оси Y

// переменные для обозначения пересечения окружностей A3 и A1
var d31;				// расстояние между центрами окружностей пробных пусков №3 и 1
var b3;					// расстояние от центра окружности A3 до точки пересечения P12 с окружностью A1
var c3;					// расстояние от центра окружности A1 до точки пересечения P12 с окружностью A3
// d31 = b3 + c3
var P13;				// центральная точка между P23 и P_23 (_ обозначает штрих)
var P23;				// точка пересечения окружностей A3 и A1
var P_23;				// точка пересечения окружностей A3 и A1
var h3;					// расстояние от точки P13 до точки P23 и P_23
var P13_X;				// координата точки P13 по оси X
var P13_Y;				// координата точки P13 по оси Y
var P23_X;				// координата точки P23 по оси X
var P23_Y;				// координата точки P23 по оси Y
var P_23_X;				// координата точки P_23 по оси X
var P_23_Y;				// координата точки P_23 по оси Y

// точка пересечения окружностей
var K;					// точка пересечения окружностей A1, A2, A3
var K_X;				// координата точки K по оси X
var K_Y;				// координата точки K по оси Y
var OK;					// длина отрезка от центра окружности A0 до точки пересечения окружностей всех пробных пусков


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


function diagnose() {

	// вычисление массы пробного груза (если не выбране свой и есть данные для формулы)
		m_test_calc = 804 * ((P * A0) / (R * n));


    // // Спектр виброскорости (старый метод)
    //   // Набор гармоник частоты вращения F1v (виброскорость)
	// 	var F1v_harms = AUSPv.add_harms_set(FREQ, 1, 0x00ff0000, 1); // красный цвет
	// 	for (let i=0; i <= 0; i++)
	// 	{F1v_harms.harms[i].tolerance = (1+i) * FREQ * 0.1}; // коридор обнаружения гармоник
	// 	F1v_harms.name = "F1v (гарм. ряд част. вращ.)";	
	// 	// 1-я гармоника F1v
	// 		// Проверка наличия оборотной гармоники необходимости проведения баалнсировки
	// 		if (F1v >= RMSv_2_1000 * 0.4) // вклад оборотной гармоники в СКЗv
    //   			{var F1v = F1v_harms.harms[0].level;
	// 			var F1v_test_balance = "необходимо провести балансировку";}
	// 		else {var F1v_test_balance = "проведение балансировки не требуется или нецелесообразно";}


    let __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 __row1 = __tools.harms.add(FREQ_0, 3, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
    __row1.name = "F1v (гарм. ряд част. вращ.)"; // название гармонического ряда
    // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)



    plot_ausp.add(
        {
        	color: 0x0000ff,
        	name: "Спектр виброскорости",
        	x: AUSPv_pl.resolution,
        	y: AUSPv_pl.data,
        	// spec_tools: __tools.to_json()
        });

	// plot_afc.add(
	// 	{
	// 		color: 0x00ff00,
	// 		name: "АЧХ",
	// 		x: afc_pl.resolution,
	// 		y: afc_pl.data
	// 	});

	plot_pfc.add(
		{
			color: 0xff0000,
			name: "ФЧХ",
			x: pfc_pl.resolution,
			y: pfc_pl.data
		});

	// plot_afc1.add(
	// 	{
	// 		color: 0x137a13,
	// 		name: "АЧХ из apfc",
	// 		x: resolution,
	// 		y: apfc_pl.data
	// 	});

	// plot_pfc1.add(
	// 	{
	// 		color: 0x641414,
	// 		name: "ФЧХ из apfc",
	// 		x: apfc_pl.resolution,
	// 		y: apfc_pl.phase
	// 	});

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

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

	var a = __result.harms.rows[0].harms[0].ampl;
    // __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) - обнаружение гармоники указанного гармонического ряда;


// 1) производится "нулевой пуск", записывается значение вибрации A0
// ...выбирается точка с максимальным значением вибрации, далее работаем только с этой точкой

// определение координат точек окружности A0
var x0_array = []; // массив координат точек окружности A0 по оси X
var y0_array = []; // массив координат точек окружности A0 по оси Y
	for (let i=0; i<=359; i++ ) {
		x0_array.push(x00 + A0 * (Math.sin((i) * Math.PI / 180)));
		y0_array.push(y00 + A0 * (Math.cos((i) * Math.PI / 180)));}
//gtl.log.info("centr x00",x00);
//gtl.log.info("centr y00",y00);

// 2) выбирается масса пробного груза (записывается в граммах)

// 3) на плоскости коррекции ротора (место установки грузов) отмечаются углы 0(360), 120 и 240
// ...увеличение угла против направления вращения ротора

// 4) пробный груз по очереди устанавливается в 0(360), 120 и 240 градусов; измеряется вибрация (амплитуда записывается)

// определение координат точек окружностти A1
var x1_array = []; // массив координат точек окружности A1 по оси X
var y1_array = []; // массив координат точек окружности A1 по оси Y
var x01 = x0_array[0];
var y01 = y0_array[0];
	for (let i=0; i<=359; i++ ) {
		x1_array.push(x01 + A1 * (Math.sin((i) * Math.PI / 180)));
		y1_array.push(y01 + A1 * (Math.cos((i) * Math.PI / 180)));}
//gtl.log.info("x0_array[0]",x0_array[0]);
//gtl.log.info("x0_array[360]",x0_array[360]);
//gtl.log.info("centr x01",x01);
//gtl.log.info("centr y01",y01);

// определение координат точек окружностти A2
var x2_array = []; // массив координат точек окружности A2 по оси X
var y2_array = []; // массив координат точек окружности A2 по оси Y
var x02 = x0_array[120];
var y02 = y0_array[120];
	for (let i=0; i<=359; i++ ) {
		x2_array.push(x02 + A2 * (Math.sin((i) * Math.PI / 180)));
		y2_array.push(y02 + A2 * (Math.cos((i) * Math.PI / 180)));}
//gtl.log.info("centr x02",x02);
//gtl.log.info("centr y02",y02);

// определение координат точек окружностти A3
var x3_array = []; // массив координат точек окружности A3 по оси X
var y3_array = []; // массив координат точек окружности A3 по оси Y
var x03 = x0_array[240];
var y03 = y0_array[240];
	for (let i=0; i<=359; i++ ) {
		x3_array.push(x03 + A3 * (Math.sin((i) * Math.PI / 180)));
		y3_array.push(y02 + A3 * (Math.cos((i) * Math.PI / 180)));}
//gtl.log.info("centr x03",x03);
//gtl.log.info("centr y03",y03);

// определение вспомогательных переменных 
d12 = Math.sqrt(Math.pow(x02 - x01, 2) + Math.pow(y02 - y01, 2));
d23 = d12;
d31 = d12;
//gtl.log.info("d12",d12);

c1 = (Math.pow(A1,2) - Math.pow(A2,2) + Math.pow(d12,2)) / (2 * d12);
b1 = d12 - c1;
c2 = (Math.pow(A2,2) - Math.pow(A3,2) + Math.pow(d12,2)) / (2 * d12);
b2 = d12 - c2;
c3 = (Math.pow(A3,2) - Math.pow(A1,2) + Math.pow(d12,2)) / (2 * d12);
b3 = d12 - c3;
//gtl.log.info("c1",c1);
//gtl.log.info("b1",b1);
//gtl.log.info("c2",c2);
//gtl.log.info("b2",b2);
//gtl.log.info("c3",c3);
//gtl.log.info("b3",b3);

h1 = Math.sqrt(Math.pow(A1,2) - Math.pow(c1,2));
h2 = Math.sqrt(Math.pow(A2,2) - Math.pow(c2,2));
h3 = Math.sqrt(Math.pow(A3,2) - Math.pow(c3,2));
//gtl.log.info("h1",h1);
//gtl.log.info("h2",h2);
//gtl.log.info("h3",h3);

P11_X = x01 + ((c1 * (x02 - x01)) / d12);
P11_Y = y01 + ((c1 * (y02 - y01)) / d12);
P21_X = P11_X - ((h1 * (y02 - y01)) / d12);
P21_Y = P11_Y + ((h1 * (x02 - x01)) / d12);
P_21_X = P11_X + ((h1 * (y02 - y01)) / d12);
P_21_Y = P11_Y - ((h1 * (x02 - x01)) / d12);
//gtl.log.info("P11_X",P11_X);
//gtl.log.info("P11_Y",P11_Y);
//gtl.log.info("P21_X",P21_X);
//gtl.log.info("P21_Y",P21_Y);
//gtl.log.info("P_21_X",P_21_X);
//gtl.log.info("P_21_Y",P_21_Y);

P12_X = x02 + ((c2 * (x03 - x02)) / d12);
P12_Y = y02 + ((c2 * (y03 - y02)) / d12);
P22_X = P12_X - ((h2 * (y03 - y02)) / d12);
P22_Y = P12_Y + ((h2 * (x03 - x02)) / d12);
P_22_X = P12_X + ((h2 * (y03 - y02)) / d12);
P_22_Y = P12_Y - ((h2 * (x03 - x02)) / d12);
//gtl.log.info("P12_X",P12_X);
//gtl.log.info("P12_Y",P12_Y);
//gtl.log.info("P22_X",P22_X);
//gtl.log.info("P22_Y",P22_Y);
//gtl.log.info("P_22_X",P_22_X);
//gtl.log.info("P_22_Y",P_22_Y);

P13_X = x03 + ((c3 * (x01 - x03)) / d12);
P13_Y = y03 + ((c3 * (y01 - y03)) / d12);
P23_X = P13_X - ((h3 * (y01 - y03)) / d12);
P23_Y = P13_Y + ((h3 * (x01 - x03)) / d12);
P_23_X = P13_X + ((h3 * (y01 - y03)) / d12);
P_23_Y = P13_Y - ((h3 * (x01 - x03)) / d12);
//gtl.log.info("P13_X",P13_X);
//gtl.log.info("P13_Y",P13_Y);
//gtl.log.info("P23_X",P23_X);
//gtl.log.info("P23_Y",P23_Y);
//gtl.log.info("P_23_X",P_23_X);
//gtl.log.info("P_23_Y",P_23_Y);

K_X = (P_21_X + P_22_X + P_23_X) / 3;
K_Y = (P_21_Y + P_22_Y + P_23_Y) / 3;
//gtl.log.info("K_X",K_X);
//gtl.log.info("K_Y",K_Y);

OK = Math.sqrt(Math.pow(K_X,2) + Math.pow(K_Y,2));
//gtl.log.info("OK",OK);

// определение массы балансировочного груза
Mb = (m_test * A0) / OK;

// определение угла установки балансировочного груза
if ((K_X > 0) && (K_Y >= 0)) {
	 Mb_corner = (Math.acos(Math.abs(K_Y) / OK) * 180 ) / Math.PI}
if ((K_X <= 0) && (K_Y < 0)) {
	 Mb_corner = 180 + (Math.acos(Math.abs(K_Y) / OK) * 180 ) / Math.PI}
if ((K_X < 0) && (K_Y >= 0)) {
	 Mb_corner = 360 - (Math.acos(Math.abs(K_Y) / OK) * 180 ) / Math.PI}
if ((K_X >= 0) && (K_Y < 0)) {
	 Mb_corner = 180 - (Math.acos(Math.abs(K_Y) / OK) * 180 ) / Math.PI}


gtl.log.info("Mb (балансировочный груз)",Mb);
gtl.log.info("Mb_corner (угол установки груза)",Mb_corner);
gtl.log.info("m_test (пробный груз введёный)",m_test);
gtl.log.info("m_test_calc (пробный груз расчётный)",m_test_calc);
gtl.log.info("FREQ_0",FREQ_0);
gtl.log.info("RMSv_2_1000",RMSv_2_1000.value);
gtl.log.info("RMSa",RMSa.value);
gtl.log.info("a",a);
gtl.log.info("gtl.diagnostic.interval",gtl.diagnostic.interval);
// gtl.log.info("AUSPv_pl.acq_time", AUSPv_pl.acq_time);
// gtl.log.info("afc_pl.acq_time", afc_pl.acq_time);
// gtl.log.info("pfc_pl.acq_time", pfc_pl.acq_time);


gtl.diagnostic.stop();
}