"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]); let freq_time = gtl.options.customOptions.freq_time; // длина (время) отрезка сигнала let freq_avg_cnt = gtl.options.customOptions.freq_avg_cnt; // количество усреднений freq.time = freq_time; freq.avg_cnt = freq_avg_cnt; freq.dc = gtl.options.customOptions.freq_dc; // уровень, при переходе через который вычисляются периоды // Настройки для спектров и АФЧХ let frequency; // граничная частота let resolution = gtl.options.customOptions.resolution; // частотное разрешение let average = gtl.options.customOptions.average; // количество усреднений let overlap = gtl.options.customOptions.overlap; // наложение let peak_level = gtl.options.customOptions.peak_level; // порог обнаружения гармоник let filter_A_vibr; // фильтр сигнала A вибрации let filter_B_vibr; // фильтр сигнала B вибрации let channel_A = gtl.options.customOptions.channel_A; // выбор канала A let channel_B = gtl.options.customOptions.channel_B; // выбор канала B // Канал A // ФИЛЬТР_A 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра let filter_A_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[channel_A].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[channel_A].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[channel_B].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[channel_B].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 = peak_level; // порог обнаружения гармоник 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_B"; // имя спектра 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 = peak_level; // порог обнаружения гармоник 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], "src0" : gtl.analog_inputs[record.tachoOptions.tachoChannel], "src1" : filter_A_vibr, "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], "src0" : gtl.analog_inputs[record.tachoOptions.tachoChannel], "src1" : filter_B_vibr, "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 A1_ = gtl.options.customOptions.A1; // модуль вектора вибрации точки A после установки пробного груза в плоскость 1 */** let A1; // модуль вектора вибрации точки A после установки пробного груза в плоскость 1 */** (конечное значение) let A1_phase_ = gtl.options.customOptions.A1_phase; // фаза вектора вибрации точки A после установки пробного груза в плоскость 1 */** let A1_phase; // фаза вектора вибрации точки A после установки пробного груза в плоскость 1 */** (конечное значение) let dA1; // модуль вектора дельты вибрации точки A после установки пробного груза в плоскость 1 *** let dA1_phase; // фаза вектора дельты вибрации точки A после установки пробного груза в плоскость 1 *** 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 B1_ = gtl.options.customOptions.B1; // модуль вектора вибрации точки B после установки пробного груза в плоскость 1 */** let B1; // модуль вектора вибрации точки B после установки пробного груза в плоскость 1 */** (конечное значение) let B1_phase_ = gtl.options.customOptions.B1_phase; // фаза вектора вибрации точки B после установки пробного груза в плоскость 1 */** let B1_phase; // фаза вектора вибрации точки B после установки пробного груза в плоскость 1 */** (конечное значение) let dB1; // модуль вектора дельты вибрации точки B после установки пробного груза в плоскость 1 *** let dB1_phase; // фаза вектора дельты вибрации точки B после установки пробного груза в плоскость 1 *** // Переменные вспомогательные необходимые для расчётов 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 A1_phase_X; // угол наклона вектора A1 к оси X let A1_phase_Y; // угол наклона вектора A1 к оси Y let A1_1_X; // начальная координата вектора A1 по оси X let A1_2_X; // конечная координата вектора A1 по оси X let A1_1_Y; // начальная координата вектора A1 по оси Y let A1_2_Y; // конечная координата вектора A1 по оси Y let dA1_1_X; // начальная координата вектора dA1 по оси X let dA1_2_X; // конечная координата вектора dA1 по оси X let dA1_1_Y; // начальная координата вектора dA1 по оси Y let dA1_2_Y; // конечная координата вектора dA1 по оси 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 B1_phase_X; // угол наклона вектора B1 к оси X let B1_phase_Y; // угол наклона вектора B1 к оси Y let B1_1_X; // начальная координата вектора B1 по оси X let B1_2_X; // конечная координата вектора B1 по оси X let B1_1_Y; // начальная координата вектора B1 по оси Y let B1_2_Y; // конечная координата вектора B1 по оси Y let dB1_1_X; // начальная координата вектора dB1 по оси X let dB1_2_X; // конечная координата вектора dB1 по оси X let dB1_1_Y; // начальная координата вектора dB1 по оси Y let dB1_2_Y; // конечная координата вектора dB1 по оси 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; // РАСЧЁТЫ (балансировочный калькулятор) // ШАГ 3 - вибрация пробного пуска A1 и B1 (пробный груз в плоскости 1): // измерение начальной A1 и B1 (или ввод вручную) // из предыдущих шагов переносятся: амплитуда и фаза вибрации A0, B0 // построение графиков A0, A1 и dA1, B0, B1 и dB1 // Определение конечных значений переменных // A1 вибрация после установки пробного груза в плоскость 1 if (A1_ != "-") {A1 = A1_} // принимает значение из опций else {A1 = F1_1_a_A} // принимает значение из спектра сигнала if (A1_phase_ != "-") {A1_phase = A1_phase_} // принимает значение из опций else {A1_phase = F1_1_ph_A} // принимает значение из спектра сигнала // B1 вибрация после установки пробного груза в плоскость 1 if (B1_ != "-") {B1 = B1_} // принимает значение из опций else {B1 = F1_1_a_B} // принимает значение из спектра сигнала if (B1_phase_ != "-") {B1_phase = B1_phase_} // принимает значение из опций else {B1_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 * Math.PI/180)) * A0 } else {A0_2_X = Math.abs(Math.cos(A0_phase_X * Math.PI/180)) * A0 * (-1)} A0_1_Y = 0; if (A0_phase <= 90 || A0_phase >= 270) {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * Math.PI/180)) * A0 } else {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * Math.PI/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; // определение угла наклона вектора 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 var xA1_array = []; // массив координат точек вектора A1 по оси X var yA1_array = []; // массив координат точек вектора A1 по оси Y A1_1_X = 0; if (A1_phase <= 180) {A1_2_X = Math.abs(Math.cos(A1_phase_X * Math.PI/180)) * A1 } else {A1_2_X = Math.abs(Math.cos(A1_phase_X * Math.PI/180)) * A1 * (-1)} A1_1_Y = 0; if (A1_phase <= 90 || A1_phase >= 270) {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * Math.PI/180)) * A1 } else {A1_2_Y = Math.abs(Math.cos(A1_phase_Y * Math.PI/180)) * A1 * (-1)} xA1_array[0] = A1_1_X; xA1_array[1] = A1_2_X; yA1_array[0] = A1_1_Y; yA1_array[1] = A1_2_Y; // определение модуля вектора dA1 var xdA1_array = []; // массив координат точек вектора dA1 по оси X var ydA1_array = []; // массив координат точек вектора dA1 по оси Y dA1_1_X = A0_2_X; dA1_2_X = A1_2_X; dA1_1_Y = A0_2_Y; dA1_2_Y = A1_2_Y; dA1 = Math.sqrt(Math.pow(dA1_2_X - dA1_1_X, 2) + Math.pow(dA1_2_Y - dA1_1_Y, 2)) xdA1_array[0] = dA1_1_X; xdA1_array[1] = dA1_2_X; ydA1_array[0] = dA1_1_Y; ydA1_array[1] = dA1_2_Y; // определение фазы вектора dA1 if ((dA1_2_Y < dA1_1_Y) && (dA1_2_X < dA1_1_X)) { dA1_phase = 180 + (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / Math.PI)} if ((dA1_2_Y > dA1_1_Y) && (dA1_2_X > dA1_1_X)) { dA1_phase = (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / Math.PI)} if ((dA1_2_Y > dA1_1_Y) && (dA1_2_X < dA1_1_X)) { dA1_phase = 360 - (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / Math.PI)} if ((dA1_2_Y < dA1_1_Y) && (dA1_2_X > dA1_1_X)) { dA1_phase = 180 - (((Math.acos((Math.abs(dA1_2_Y - dA1_1_Y)) / dA1)) * 180 ) / Math.PI)} if (dA1_phase > 360) {dA1_phase = dA1_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 * Math.PI/180)) * B0 } else {B0_2_X = Math.abs(Math.cos(B0_phase_X * Math.PI/180)) * B0 * (-1)} B0_1_Y = 0; if (B0_phase <= 90 || B0_phase >= 270) {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * Math.PI/180)) * B0 } else {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * Math.PI/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; // определение угла наклона вектора B1 к осям X и Y if (B1_phase <= 90) { B1_phase_X = 90 - B1_phase} if (B1_phase <= 180) { B1_phase_X = B1_phase - 90} if (B1_phase <= 270) { B1_phase_X = 270 - B1_phase} if (B1_phase <= 360) { B1_phase_X = B1_phase - 270} if (B1_phase <= 90) { B1_phase_Y = B1_phase} if (B1_phase <= 180) { B1_phase_Y = 180 - B1_phase} if (B1_phase <= 270) { B1_phase_Y = B1_phase - 180} if (B1_phase <= 360) { B1_phase_Y = 360 - B1_phase} // определение координат вектора B1 var xB1_array = []; // массив координат точек вектора B1 по оси X var yB1_array = []; // массив координат точек вектора B1 по оси Y B1_1_X = 0; if (B1_phase <= 180) {B1_2_X = Math.abs(Math.cos(B1_phase_X * Math.PI/180)) * B1 } else {B1_2_X = Math.abs(Math.cos(B1_phase_X * Math.PI/180)) * B1 * (-1)} B1_1_Y = 0; if (B1_phase <= 90 || B1_phase >= 270) {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * Math.PI/180)) * B1 } else {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * Math.PI/180)) * B1 * (-1)} xB1_array[0] = B1_1_X; xB1_array[1] = B1_2_X; yB1_array[0] = B1_1_Y; yB1_array[1] = B1_2_Y; // определение модуля вектора dB1 var xdB1_array = []; // массив координат точек вектора dB1 по оси X var ydB1_array = []; // массив координат точек вектора dB1 по оси Y dB1_1_X = B0_2_X; dB1_2_X = B1_2_X; dB1_1_Y = B0_2_Y; dB1_2_Y = B1_2_Y; dB1 = Math.sqrt(Math.pow(dB1_2_X - dB1_1_X, 2) + Math.pow(dB1_2_Y - dB1_1_Y, 2)) xdB1_array[0] = dB1_1_X; xdB1_array[1] = dB1_2_X; ydB1_array[0] = dB1_1_Y; ydB1_array[1] = dB1_2_Y; // определение фазы вектора dB1 if ((dB1_2_Y < dB1_1_Y) && (dB1_2_X < dB1_1_X)) { dB1_phase = 180 + (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / Math.PI)} if ((dB1_2_Y > dB1_1_Y) && (dB1_2_X > dB1_1_X)) { dB1_phase = (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / Math.PI)} if ((dB1_2_Y > dB1_1_Y) && (dB1_2_X < dB1_1_X)) { dB1_phase = 360 - (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / Math.PI)} if ((dB1_2_Y < dB1_1_Y) && (dB1_2_X > dB1_1_X)) { dB1_phase = 180 - (((Math.acos((Math.abs(dB1_2_Y - dB1_1_Y)) / dB1)) * 180 ) / Math.PI)} if (dB1_phase > 360) {dB1_phase = dB1_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,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.1) * (Math.sin((i) * Math.PI / 180))); yV_array.push(y0V + (Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*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: "Вибрация_A1", x: xA1_array, y: yA1_array, }); plot_vibr.add( { color: 0xff0000, name: "Вибрация_dA1", x: xdA1_array, y: ydA1_array, }); plot_vibr.add( { color: 0x0000ff, name: "Вибрация_B0", x: xB0_array, y: yB0_array, }); plot_vibr.add( { color: 0x00ff00, name: "Вибрация_B1", x: xB1_array, y: yB1_array, }); plot_vibr.add( { color: 0xff0000, name: "Вибрация_dB1", x: xdB1_array, y: ydB1_array, }); plot_vibr.add( { color: 0x00ffffff, name: "График векторов вибрации", x: xV_array, y: yV_array, }); plot_vibr.add( { color: 0x00ffffff, name: "границы", x: [-(Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), -(Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), (Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), (Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2)], y: [(Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), -(Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), -(Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*0.2), (Math.max(A0,A1,dA1,B0,B1,dB1)+Math.max(A0,A1,dA1,B0,B1,dB1)*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("A1",A1); gtl.log.info("A1_phase",A1_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("B1",B1); gtl.log.info("B1_phase",B1_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_Ампл_вибр_пуска_A1: A1, _006_Фаза_вибр_пуска_A1: A1_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_Ампл_вибр_пуска_B1: B1, _013_Фаза_вибр_пуска_B1: B1_phase, _014_СКЗ_вибр_B: RMS_B.value, _015_Частота_вращения_F1: freq.value, _016_Нестаб_част_вращ: instability*100, }; gtl.results = {"result": __result}; gtl.diagnostic.stop(); break; default: break; } }