"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; // наложение // Канал 0 // ФИЛЬТР 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра var filter0_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]); filter0_2_1000.kind = gtl.filter_iir.butterworth; filter0_2_1000.type = gtl.filter_iir.bandpass; filter0_2_1000.order = 6; filter0_2_1000.frequency = 502; // центральная частота полосового фильтра filter0_2_1000.width = 1000; // ширина полосы фильтра var filter0_2_1000v = gtl.add_intg(filter0_2_1000); // интегрирование filter0_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное) // Спектр виброскорости для получения 1-й гармоники частоты вращения var AUSPv0 = gtl.add_ausp(filter0_2_1000v); // объявление переменной спектра AUSPv0.color = 0x00ff0000; // цвет спектра AUSPv0.name = "AUSPv0"; // имя спектра AUSPv0.frequency = frequency; // граничная частота спектра AUSPv0.lines = AUSPv0.frequency * 1/resolution; // разрешение спектра (количество линий) AUSPv0.average = average; // количество усреднений AUSPv0.unit = gtl.spec.unit; // отображение амплитуды в мм/с AUSPv0.smoothing_factor = 100; // усреднение средней линии AUSPv0.smoothed_line_color = 0xff004dff; // цвет средней линии AUSPv0.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный) AUSPv0.tolerance = AUSPv0.resolution; // диапазон поиска гармоник +/- // СКЗv var RMSv0_2_1000 = gtl.add_value_rms(filter0_2_1000v); RMSv0_2_1000.time = 1; RMSv0_2_1000.avg_cnt = 3; // СКЗa var RMSa0 = gtl.add_value_rms(gtl.analog_inputs[signals[0].portNumber]); RMSa0.time = 1; RMSa0.avg_cnt = 3; // Канал 1 // ФИЛЬТР 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра var filter1_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[1].portNumber]); filter1_2_1000.kind = gtl.filter_iir.butterworth; filter1_2_1000.type = gtl.filter_iir.bandpass; filter1_2_1000.order = 6; filter1_2_1000.frequency = 502; // центральная частота полосового фильтра filter1_2_1000.width = 1000; // ширина полосы фильтра var filter1_2_1000v = gtl.add_intg(filter1_2_1000); // интегрирование filter1_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное) // Спектр виброскорости для получения 1-й гармоники частоты вращения var AUSPv1 = gtl.add_ausp(filter1_2_1000v); // объявление переменной спектра AUSPv1.color = 0x00ff0000; // цвет спектра AUSPv1.name = "AUSPv1"; // имя спектра AUSPv1.frequency = frequency; // граничная частота спектра AUSPv1.lines = AUSPv1.frequency * 1/resolution; // разрешение спектра (количество линий) AUSPv1.average = average; // количество усреднений AUSPv1.unit = gtl.spec.unit; // отображение амплитуды в мм/с AUSPv1.smoothing_factor = 100; // усреднение средней линии AUSPv1.smoothed_line_color = 0xff004dff; // цвет средней линии AUSPv1.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный) AUSPv1.tolerance = AUSPv1.resolution; // диапазон поиска гармоник +/- // СКЗv var RMSv1_2_1000 = gtl.add_value_rms(filter1_2_1000v); RMSv1_2_1000.time = 1; RMSv1_2_1000.avg_cnt = 3; // СКЗa var RMSa1 = gtl.add_value_rms(gtl.analog_inputs[signals[1].portNumber]); RMSa1.time = 1; RMSa1.avg_cnt = 3; // Спектр виброскорости (новый метод) var AUSPv0_pl = gtl.create_ausp( { "src" : filter0_2_1000v, "frequency" : frequency, "resolution" : resolution, "average" : average, "overlap" : overlap, "window" : gtl.spec.rectangular, "view" : gtl.spec.unit } ); var AUSPv1_pl = gtl.create_ausp( { "src" : filter1_2_1000v, "frequency" : frequency, "resolution" : resolution, "average" : average, "overlap" : overlap, "window" : gtl.spec.rectangular, "view" : gtl.spec.unit } ); // ФЧХ (новый метод) var pfc0_pl = gtl.create_pfc( { "src0" : filter0_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, //по умолчанию - false // "delay" : .1, // по умолчанию - 0 // "start" : false // по умолчанию - true } ); var pfc1_pl = gtl.create_pfc( { "src0" : filter1_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, //по умолчанию - false // "delay" : .1, // по умолчанию - 0 // "start" : false // по умолчанию - true } ); // Объявление графических плоскостей для построения графиков var plot_ausp0 = gtl.plots.add("Спектр виброскорости 0"); // создание объекта для спектра var plot_ausp1 = gtl.plots.add("Спектр виброскорости 1"); // создание объекта для спектра var plot_pfc0 = gtl.plots.add("ФЧХ 0"); // фазо-частотная характеристика var plot_pfc1 = gtl.plots.add("ФЧХ 1"); // фазо-частотная характеристика // Переменные основные // параметр вибрации (модуль вектора) - виброскорость (мм/с) // угол (фаза) вектора - градусы // масса груза (модуль ветора) - граммы // DCI - Dynamic Coefficient of Influence (динамический коэффициент влияния) // * - значение получаем из измерительного блока при нажатии кнопки // ** - значение вводится пользователем // *** - значение получаем в результате расчёта программы балансировки // значение переменной с нижним подчёркиванием (..._) берётся из "дополнительных опций"; если оно не задано, то рассчитывается в скрипте 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; // модуль вектора начальной вибрации в точке A */** var A0 = 8; // модуль вектора начальной вибрации в точке A */** (конечное значение) let A0_phase_ = gtl.options.customOptions.A0_phase; // фаза вектора начальной вибрации в точке A */** var A0_phase; // фаза вектора начальной вибрации в точке A */** (конечное значение) let B0_ = gtl.options.customOptions.B0; // модуль вектора начальной вибрации в точке B */** var B0; // модуль вектора начальной вибрации в точке B */** (конечное значение) let B0_phase_ = gtl.options.customOptions.B0_phase; // фаза вектора начальной вибрации в точке B */** var B0_phase; // фаза вектора начальной вибрации в точке B */** (конечное значение) let m11_test_ = gtl.options.customOptions.m11_test; // модуль вектора пробного груза при 1-ом пуске в плоскости 1** let m11_test; // модуль вектора пробного груза при 1-ом пуске в плоскости 1** (конечное значение) let m11_test_corner = gtl.options.customOptions.m11_test_corner;// угол вектора пробного груза при 1-ом пуске в плоскости 1 ** let m22_test_ = gtl.options.customOptions.m22_test; // модуль вектора пробного груза при 2-ом пуске в плоскости 2 ** let m22_test; // модуль вектора пробного груза при 2-ом пуске в плоскости 2 **(конечное значение) let m22_test_corner = gtl.options.customOptions.m22_test_corner;// угол вектора пробного груза при 2-ом пуске в плоскости 2 ** let A1_ = gtl.options.customOptions.A1; // модуль вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */** var A1; // модуль вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */** (конечное значение) let A1_phase_ = gtl.options.customOptions.A1_phase; // фаза вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */** var A1_phase; // фаза вектора вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 */** (конечное значение) var dA1; // модуль вектора дельты вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 *** var dA1_phase; // фаза вектора дельты вибрации в точке A 1-го пробного пуска с грузом в плоскости 1 *** let B1_ = gtl.options.customOptions.B1; // модуль вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */** var B1; // модуль вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */** (конечное значение) var B1_phase_ = gtl.options.customOptions.B1_phase; // фаза вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */** var B1_phase; // фаза вектора вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 */** (конечное значение) var dB1_phase; // фаза вектора дельты вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 *** var dB1; // модуль вектора дельты вибрации в точке B 1-го пробного пуска с грузом в плоскости 1 *** let A2_ = gtl.options.customOptions.A2; // модуль вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */** var A2; // модуль вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */** (конечное значение) let A2_phase_ = gtl.options.customOptions.A2_phase; // фаза вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */** var A2_phase; // фаза вектора вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 */** (конечное значение) var dA2; // модуль вектора дельты вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 *** var dA2_phase; // фаза вектора дельты вибрации в точке A 2-го пробного пуска с грузом в плоскости 2 *** let B2_ = gtl.options.customOptions.B2; // модуль вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */** var B2; // модуль вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */** (конечное значение) let B2_phase_ = gtl.options.customOptions.B2_phase; // фаза вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */** var B2_phase; // фаза вектора вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 */** (конечное значение) var dB2; // модуль вектора дельты вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 *** var dB2_phase; // фаза вектора дельты вибрации в точке B 2-го пробного пуска с грузом в плоскости 2 *** let DCI_A1_ = gtl.options.customOptions.DCI_A1; // модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/*** var DCI_A1; // модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/*** (конечное значение) let DCI_A1_phase_ = gtl.options.customOptions.DCI_A1_phase; // фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/*** var DCI_A1_phase; // фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке A **/*** (конечное значение) let DCI_B1_ = gtl.options.customOptions.DCI_B1; // модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/*** var DCI_B1; // модуль (мм/с/граммы) ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/*** (конечное значение) let DCI_B1_phase_ = gtl.options.customOptions.DCI_B1_phase; // фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/*** var DCI_B1_phase; // фаза ДКВ груза m11_test в плоскости 1 на вибрацию в точке B **/*** (конечное значение) let DCI_A2_ = gtl.options.customOptions.DCI_A2; // модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/*** var DCI_A2; // модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/*** (конечное значение) let DCI_A2_phase_ = gtl.options.customOptions.DCI_A2_phase; // фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/*** var DCI_A2_phase; // фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке A **/*** (конечное значение) let DCI_B2_ = gtl.options.customOptions.DCI_B2; // модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/*** var DCI_B2; // модуль (мм/с/граммы) ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/*** (конечное значение) let DCI_B2_phase_ = gtl.options.customOptions.DCI_B2_phase; // фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/*** var DCI_B2_phase; // фаза ДКВ груза m22_test в плоскости 2 на вибрацию в точке B **/*** (конечное значение) var Mb1; // модуль вектора балансировочного груза в плоскости 1 *** var Mb1_corner; // угол вектора балансировочного груза в плоскости 1 *** var Mb2; // модуль вектора балансировочного груза в плоскости 2 *** var Mb2_corner; // угол вектора балансировочного груза в плоскости 2 *** var Mdisb1; // масса дисбаланса в плоскости 1 *** var Mdisb1_corner; // угол расположения дисбаланса в плоскости 1 *** var Mdisb2; // масса дисбаланса в плоскости 2 *** var Mdisb2_corner; // угол расположения дисбаланса в плоскости 2 *** // Переменные вспомогательные 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 B0_phase_X; // угол наклона вектора B0 к оси X var B0_phase_Y; // угол наклона вектора B0 к оси Y var B0_1_X; // начальная координата вектора B0 по оси X var B0_2_X; // конечная координата вектора B0 по оси X var B0_1_Y; // начальная координата вектора B0 по оси Y var B0_2_Y; // конечная координата вектора B0 по оси 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 dA1_1_X; // начальная координата вектора dA1 по оси X var dA1_2_X; // конечная координата вектора dA1 по оси X var dA1_1_Y; // начальная координата вектора dA1 по оси Y var dA1_2_Y; // конечная координата вектора dA1 по оси Y var A2_phase_X; // угол наклона вектора A2 к оси X var A2_phase_Y; // угол наклона вектора A2 к оси Y var A2_1_X; // начальная координата вектора A2 по оси X var A2_2_X; // конечная координата вектора A2 по оси X var A2_1_Y; // начальная координата вектора A2 по оси Y var A2_2_Y; // конечная координата вектора A2 по оси Y var dA2_1_X; // начальная координата вектора dA2 по оси X var dA2_2_X; // конечная координата вектора dA2 по оси X var dA2_1_Y; // начальная координата вектора dA2 по оси Y var dA2_2_Y; // конечная координата вектора dA2 по оси Y var B1_phase_X; // угол наклона вектора A1 к оси X var B1_phase_Y; // угол наклона вектора A1 к оси Y var B1_1_X; // начальная координата вектора A1 по оси X var B1_2_X; // конечная координата вектора A1 по оси X var B1_1_Y; // начальная координата вектора A1 по оси Y var B1_2_Y; // конечная координата вектора A1 по оси Y var dB1_1_X; // начальная координата вектора dB1 по оси X var dB1_2_X; // конечная координата вектора dB1 по оси X var dB1_1_Y; // начальная координата вектора dB1 по оси Y var dB1_2_Y; // конечная координата вектора dB1 по оси Y var B2_phase_X; // угол наклона вектора A1 к оси X var B2_phase_Y; // угол наклона вектора A1 к оси Y var B2_1_X; // начальная координата вектора A1 по оси X var B2_2_X; // конечная координата вектора A1 по оси X var B2_1_Y; // начальная координата вектора A1 по оси Y var B2_2_Y; // конечная координата вектора A1 по оси Y var dB2_1_X; // начальная координата вектора dB2 по оси X var dB2_2_X; // конечная координата вектора dB2 по оси X var dB2_1_Y; // начальная координата вектора dB2 по оси Y var dB2_2_Y; // конечная координата вектора dB2 по оси Y var m11_test_corner_X; // угол наклона вектора m11_test к оси X var m11_test_corner_Y; // угол наклона вектора m11_test к оси Y var m11_test_1_X; // начальная координата вектора m11_test по оси X var m11_test_2_X; // конечная координата вектора m11_test по оси X var m11_test_1_Y; // начальная координата вектора m11_test по оси Y var m11_test_2_Y; // конечная координата вектора m11_test по оси Y var m22_test_corner_X; // угол наклона вектора m22_test к оси X var m22_test_corner_Y; // угол наклона вектора m22_test к оси Y var m22_test_1_X; // начальная координата вектора m22_test по оси X var m22_test_2_X; // конечная координата вектора m22_test по оси X var m22_test_1_Y; // начальная координата вектора m22_test по оси Y var m22_test_2_Y; // конечная координата вектора m22_test по оси Y // ***** РАСЧЁТЫ ***** // gtl.diagnostic.interval = 10; gtl.diagnostic.interval = Math.max(AUSPv0.acq_time, AUSPv0_pl.acq_time, pfc0_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(AUSPv0.acq_time, AUSPv0_pl.acq_time, pfc0_pl.acq_time) + 0.1; state = 3; break; case 1: // Частота вращения фиксированная // Определение минимально необходимой длительности сигнала для проведения диагностики gtl.diagnostic.interval = Math.max(AUSPv0.acq_time, AUSPv0_pl.acq_time, pfc0_pl.acq_time) + 0.1; state = 3; break; case 2: // Частота вращения из поля INFO (виброметр) // Определение минимально необходимой длительности сигнала для проведения диагностики gtl.diagnostic.interval = Math.max(AUSPv0.acq_time, AUSPv0_pl.acq_time, pfc0_pl.acq_time) + 0.1; state = 3; break; case 3: // Выполняем анализ спектов // Очистка партретов спектров AUSPv0.clear_harms_sets(); AUSPv1.clear_harms_sets(); let __AUSPv0_tools = gtl.create_spec_tools( { data: AUSPv0_pl.data, df: AUSPv0_pl.resolution, base: { factor: 100, visible: true, color: 0x00ff00 }, peaks: { color: 0xff0000, visible: true, level: 0.000001 }, harms: { tolerance: 1 } }); let __row0 = __AUSPv0_tools.harms.add(freq.value, 3, 0xff0000, 1); // добавление набора гармоник (частота, количество, цвет, вес) __row0.name = "F1v0 (гарм. ряд част. вращ.)"; // название гармонического ряда // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес) let __pfc0_tools = gtl.create_spec_tools( { data: pfc0_pl.data, df: pfc0_pl.resolution, base: { factor: 100, visible: true, color: 0x0000ff }, peaks: { color: 0xff0000, visible: true, level: 0.000001 }, harms: { tolerance: 1 } }); let __row0_phase = __pfc0_tools.harms.add(freq.value, 3, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес) __row0_phase.name = "F1v_phase (гарм. ряд част. вращ.)"; // название гармонического ряда let __result1_0 = __AUSPv0_tools.to_json(); let __result2_0 = __pfc0_tools.to_json(); let __AUSPv1_tools = gtl.create_spec_tools( { data: AUSPv1_pl.data, df: AUSPv1_pl.resolution, base: { factor: 100, visible: true, color: 0x00ff00 }, peaks: { color: 0xff0000, visible: true, level: 0.000001 }, harms: { tolerance: 1 } }); let __row1 = __AUSPv1_tools.harms.add(freq.value, 3, 0xff0000, 1); // добавление набора гармоник (частота, количество, цвет, вес) __row1.name = "F1v1 (гарм. ряд част. вращ.)"; // название гармонического ряда // __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес) let __pfc1_tools = gtl.create_spec_tools( { data: pfc1_pl.data, df: pfc1_pl.resolution, base: { factor: 100, visible: true, color: 0x0000ff }, peaks: { color: 0xff0000, visible: true, level: 0.000001 }, harms: { tolerance: 1 } }); let __row1_phase = __pfc1_tools.harms.add(freq.value, 3, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес) __row1_phase.name = "F1v1_phase (гарм. ряд част. вращ.)"; // название гармонического ряда let __result1_1 = __AUSPv1_tools.to_json(); let __result2_1 = __pfc1_tools.to_json(); // Отрисовка графиков plot_ausp0.add( { color: 0x0000ff, name: "Спектр виброскорости 0", x: AUSPv0_pl.resolution, y: AUSPv0_pl.data, spec_tools: __AUSPv0_tools.to_json() }); plot_pfc0.add( { color: 0xff0000, name: "ФЧХ 0", x: pfc0_pl.resolution, y: pfc0_pl.data, spec_tools: __pfc0_tools.to_json() }); plot_ausp1.add( { color: 0x0000ff, name: "Спектр виброскорости 1", x: AUSPv1_pl.resolution, y: AUSPv1_pl.data, spec_tools: __AUSPv1_tools.to_json() }); plot_pfc1.add( { color: 0xff0000, name: "ФЧХ 1", x: pfc1_pl.resolution, y: pfc1_pl.data, spec_tools: __pfc1_tools.to_json() }); // Амплитуда гармонического ряда частоты вращения (канал 0) var F1_0_1_a = __result1_0.harms.rows[0].harms[0].ampl; var F1_0_2_a = __result1_0.harms.rows[0].harms[1].ampl; var F1_0_3_a = __result1_0.harms.rows[0].harms[2].ampl; // Частота гармонического ряда частоты вращения (канал 0) var F1_0_1_f = __result1_0.harms.rows[0].harms[0].freq; var F1_0_2_f = __result1_0.harms.rows[0].harms[1].freq; var F1_0_3_f = __result1_0.harms.rows[0].harms[2].freq; // Амплитуда гармонического ряда частоты вращения (канал 1) var F1_1_1_a = __result1_1.harms.rows[0].harms[0].ampl; var F1_1_2_a = __result1_1.harms.rows[0].harms[1].ampl; var F1_1_3_a = __result1_1.harms.rows[0].harms[2].ampl; // Частота гармонического ряда частоты вращения (канал 1) var F1_1_1_f = __result1_1.harms.rows[0].harms[0].freq; var F1_1_2_f = __result1_1.harms.rows[0].harms[1].freq; var F1_1_3_f = __result1_1.harms.rows[0].harms[2].freq; // Проверка наличия оборотной гармоники и необходимости проведения балансировки var test_balance = ""; // переменная для текста о необходимости проведения балансировки if (F1_0_1_a >= RMSv0_2_1000 * 0.4 || F1_1_1_a >= RMSv1_2_1000 * 0.4) // вклад оборотной гармоники в СКЗv {test_balance = "необходимо провести балансировку";} else {test_balance = "проведение балансировки не требуется или нецелесообразно";} // Фаза (амплитуда) гармонического ряда частоты вращения (канал 0) var F1_0_1_ph = __result2_0.harms.rows[0].harms[0].ampl; var F1_0_2_ph = __result2_0.harms.rows[0].harms[1].ampl; var F1_0_3_ph = __result2_0.harms.rows[0].harms[2].ampl; // Фаза (амплитуда) гармонического ряда частоты вращения (канал 1) var F1_1_1_ph = __result2_1.harms.rows[0].harms[0].ampl; var F1_1_2_ph = __result2_1.harms.rows[0].harms[1].ampl; var F1_1_3_ph = __result2_1.harms.rows[0].harms[2].ampl; // __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 - начальная вибрация в точке A if (A0_ != 0) {A0 = A0_} // принимает значение из опций else {A0 = F1_0_1_a} // принимает значение из спектра сигнала if (A0_phase_ != 0) {A0_phase = A0_phase_} // принимает значение из опций else {A0_phase = F1_0_1_ph} // принимает значение из спектра сигнала // B0 - начальная вибрация в точке B if (B0_ != 0) {B0 = B0_} // принимает значение из опций else {B0 = F1_1_1_a} // принимает значение из спектра сигнала if (B0_phase_ != 0) {B0_phase = B0_phase_} // принимает значение из опций else {B0_phase = F1_1_1_ph} // принимает значение из спектра сигнала // A1 - вибрация в точке A после установки пробного груза в плоскость 1 if (A1_ != 0) {A1 = A1_} // принимает значение из опций else {A1 = F1_0_1_a} // принимает значение из спектра сигнала if (A1_phase_ != 0) {A1_phase = A1_phase_} // принимает значение из опций else {A1_phase = F1_0_1_ph} // принимает значение из спектра сигнала // B1 - вибрация в точке B после установки пробного груза в плоскость 1 if (B1_ != 0) {B1 = B1_} // принимает значение из опций else {B1 = F1_1_1_a} // принимает значение из спектра сигнала if (B1_phase_ != 0) {B1_phase = B1_phase_} // принимает значение из опций else {B1_phase = F1_1_1_ph} // принимает значение из спектра сигнала // A2 - вибрация в точке A после установки пробного груза в плоскость 2 if (A2_ != 0) {A2 = A2_} // принимает значение из опций else {A2 = F1_0_1_a} // принимает значение из спектра сигнала if (A2_phase_ != 0) {A2_phase = A2_phase_} // принимает значение из опций else {A2_phase = F1_0_1_ph} // принимает значение из спектра сигнала // B2 - вибрация в точке B после установки пробного груза в плоскость 2 if (B2_ != 0) {B2 = B2_} // принимает значение из опций else {B2 = F1_1_1_a} // принимает значение из спектра сигнала if (B2_phase_ != 0) {B2_phase = B2_phase_} // принимает значение из опций else {B2_phase = F1_1_1_ph} // принимает значение из спектра сигнала // DCI_A1 - ДКВ груза m11_test в плоскости 1 на вибрацию в точке A if (DCI_A1_ != 0) {DCI_A1 = DCI_A1_} // принимает значение из опций else {DCI_A1 = 0} // принимает значение из расчётов (пока ноль) if (DCI_A1_phase_ != 0) {DCI_A1_phase = DCI_A1_phase_} // принимает значение из опций else {DCI_A1_phase = 0} // вычисляется в скрипте (пока ноль) // DCI_B1 - ДКВ груза m11_test в плоскости 1 на вибрацию в точке B if (DCI_B1_ != 0) {DCI_B1 = DCI_B1_} // принимает значение из опций else {DCI_B1 = 0} // принимает значение из расчётов (пока ноль) if (DCI_B1_phase_ != 0) {DCI_B1_phase = DCI_B1_phase_} // принимает значение из опций else {DCI_B1_phase = 0} // вычисляется в скрипте (пока ноль) // DCI_A2 - ДКВ груза m22_test в плоскости 2 на вибрацию в точке A if (DCI_A2_ != 0) {DCI_A2 = DCI_A2_} // принимает значение из опций else {DCI_A2 = 0} // принимает значение из расчётов (пока ноль) if (DCI_A2_phase_ != 0) {DCI_A2_phase = DCI_A2_phase_} // принимает значение из опций else {DCI_A2_phase = 0} // вычисляется в скрипте (пока ноль) // DCI_B2 - ДКВ груза m22_test в плоскости 2 на вибрацию в точке B if (DCI_B2_ != 0) {DCI_B2 = DCI_B2_} // принимает значение из опций else {DCI_B2 = 0} // принимает значение из расчётов (пока ноль) if (DCI_B2_phase_ != 0) {DCI_B2_phase = DCI_B2_phase_} // принимает значение из опций else {DCI_B2_phase = 0} // вычисляется в скрипте (пока ноль) // вычисление массы пробного груза (если не выбран свой и есть данные для формулы) var m_test_calc = 804 * ((P * A0) / (R * n)); // m11_test масса пробного груза в плоскости 1 (1-й пробный пуск) if (m11_test_ != 0) {m11_test = m11_test_} // принимает значение из опций else {m11_test = m_test_calc} // принимает значение из расчёта // m22_test масса пробного груза в плоскости 2 (2-й пробный пуск) if (m22_test_ != 0) {m22_test = m22_test_} // принимает значение из опций else {m22_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)} // определение угла наклона вектора 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 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)} // определение угла наклона вектора m11_test к осям X и Y if (m11_test_corner <= 90) { m11_test_corner_X = 90 - m11_test_corner} if (m11_test_corner <= 180) { m11_test_corner_X = m11_test_corner - 90} if (m11_test_corner <= 270) { m11_test_corner_X = 270 - m11_test_corner} if (m11_test_corner <= 360) { m11_test_corner_X = m11_test_corner - 270} if (m11_test_corner <= 90) { m11_test_corner_Y = m11_test_corner} if (m11_test_corner <= 180) { m11_test_corner_Y = 180 - m11_test_corner} if (m11_test_corner <= 270) { m11_test_corner_Y = m11_test_corner - 180} if (m11_test_corner <= 360) { m11_test_corner_Y = 360 - m11_test_corner} // определение координат вектора m11_test m11_test_1_X = 0; if (m11_test_corner <= 180) {m11_test_2_X = Math.abs(Math.cos(m11_test_corner_X * 3.1415/180)) * m11_test * (-1) } else {m11_test_2_X = Math.abs(Math.cos(m11_test_corner_X * 3.1415/180)) * m11_test} m11_test_1_Y = 0; if (m11_test_corner <= 90 || m11_test_corner >= 270) {m11_test_2_Y = Math.abs(Math.cos(m11_test_corner_Y * 3.1415/180)) * m11_test } else {m11_test_2_Y = Math.abs(Math.cos(m11_test_corner_Y * 3.1415/180)) * m11_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)} // определение угла наклона вектора 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 B1_1_X = 0; if (B1_phase <= 180) {B1_2_X = Math.abs(Math.cos(B1_phase_X * 3.1415/180)) * B1 } else {B1_2_X = Math.abs(Math.cos(B1_phase_X * 3.1415/180)) * B1 * (-1)} B1_1_Y = 0; if (B1_phase <= 90 || B1_phase >= 270) {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * 3.1415/180)) * B1 } else {B1_2_Y = Math.abs(Math.cos(B1_phase_Y * 3.1415/180)) * B1 * (-1)} // определение модуля вектора dA1 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)); // определение фазы вектора 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 ) / 3.1415)} 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 ) / 3.1415)} 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 ) / 3.1415)} 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 ) / 3.1415)} if (dA1_phase > 360) {dA1_phase = dA1_phase - 360} // определение модуля вектора dB1 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)); // определение фазы вектора 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 ) / 3.1415)} 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 ) / 3.1415)} 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 ) / 3.1415)} 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 ) / 3.1415)} if (dB1_phase > 360) {dB1_phase = dB1_phase - 360} // определение угла наклона вектора m22_test к осям X и Y if (m22_test_corner <= 90) { m22_test_corner_X = 90 - m22_test_corner} if (m22_test_corner <= 180) { m22_test_corner_X = m22_test_corner - 90} if (m22_test_corner <= 270) { m22_test_corner_X = 270 - m22_test_corner} if (m22_test_corner <= 360) { m22_test_corner_X = m22_test_corner - 270} if (m22_test_corner <= 90) { m22_test_corner_Y = m22_test_corner} if (m22_test_corner <= 180) { m22_test_corner_Y = 180 - m22_test_corner} if (m22_test_corner <= 270) { m22_test_corner_Y = m22_test_corner - 180} if (m22_test_corner <= 360) { m22_test_corner_Y = 360 - m22_test_corner} // определение координат вектора m22_test m22_test_1_X = 0; if (m22_test_corner <= 180) {m22_test_2_X = Math.abs(Math.cos(m22_test_corner_X * 3.1415/180)) * m22_test * (-1) } else {m22_test_2_X = Math.abs(Math.cos(m22_test_corner_X * 3.1415/180)) * m22_test} m22_test_1_Y = 0; if (m22_test_corner <= 90 || m22_test_corner >= 270) {m22_test_2_Y = Math.abs(Math.cos(m22_test_corner_Y * 3.1415/180)) * m22_test } else {m22_test_2_Y = Math.abs(Math.cos(m22_test_corner_Y * 3.1415/180)) * m22_test * (-1)} // определение угла наклона вектора 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 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)} // определение угла наклона вектора 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 (B1_phase <= 360) { B2_phase_Y = 360 - B2_phase} // определение координат вектора B2 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)} // определение модуля вектора dA2 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)); // определение фазы вектора 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} // определение модуля вектора dB2 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)); // определение фазы вектора 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} // определение модуля вектора DCI_A1 DCI_A1 = dA1 / m11_test; // опредение фаза вектора DCI_A1 if ((dA1_phase - m11_test_corner) < 0) { DCI_A1_phase = (dA1_phase - m11_test_corner) + 360} else if ((dA1_phase - m11_test_corner) > 360) { DCI_A1_phase = (dA1_phase - m11_test_corner) - 360} else {DCI_A1_phase = (dA1_phase - m11_test_corner)} // определение модуля вектора DCI_B1 DCI_B1 = dB1 / m11_test; // опредение фаза вектора DCI_B1 if ((dB1_phase - m11_test_corner) < 0) { DCI_B1_phase = (dB1_phase - m11_test_corner) + 360} else if ((dB1_phase - m11_test_corner) > 360) { DCI_B1_phase = (dB1_phase - m11_test_corner) - 360} else {DCI_B1_phase = (dB1_phase - m11_test_corner)} // определение модуля вектора DCI_A2 DCI_A2 = dA2 / m22_test; // опредение фаза вектора DCI_A2 if ((dA2_phase - m22_test_corner) < 0) { DCI_A2_phase = (dA2_phase - m22_test_corner) + 360} else if ((dA2_phase - m22_test_corner) > 360) { DCI_A2_phase = (dA2_phase - m22_test_corner) - 360} else {DCI_A2_phase = (dA2_phase - m22_test_corner)} // определение модуля вектора DCI_B2 DCI_B2 = dB2 / m22_test; // опредение фаза вектора DCI_B2 if ((dB2_phase - m22_test_corner) < 0) { DCI_B2_phase = (dB2_phase - m22_test_corner) + 360} else if ((dB2_phase - m22_test_corner) > 360) { DCI_B2_phase = (dB2_phase - m22_test_corner) - 360} else {DCI_B2_phase = (dB2_phase - m22_test_corner)} // формулы для определение векторов балансировочных грузов // Mb1 = (B0 * DCI_A2 - A0 * DCI_B2) / (DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2) // Mb2 = (A0 * DCI_B1 - B0 * DCI_A1) / (DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2) // ... вычисления этих формул делим на этапы // 1) В0 * DCI_A2 // 2) A0 * DCI_B2 // 3) A0 * DCI_B1 // 4) B0 * DCI_A1 // 5) В0 * DCI_A2 - A0 * DCI_B2 // 6) A0 * DCI_B1 - B0 * DCI_A1 // 7) DCI_A1 * DCI_B2 // 8) DCI_B1 * DCI_A2 // 9) DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2 // определение модуля вектора B0 * DCI_A2 var B0_DCI_A2 = B0 * DCI_A2; // определение фазы вектора В0 * DCI_A2 var B0_DCI_A2_phase; if ((B0_phase + DCI_A2_phase) >360) { B0_DCI_A2_phase = B0_phase + DCI_A2_phase - 360 } else {B0_DCI_A2_phase = B0_phase + DCI_A2_phase} // определение угла наклона вектора В0 * DCI_A2 к осям X и Y var B0_DCI_A2_phase_X; var B0_DCI_A2_phase_Y; if (B0_DCI_A2_phase <= 90) { B0_DCI_A2_phase_X = 90 - B0_DCI_A2_phase} if (B0_DCI_A2_phase <= 180) { B0_DCI_A2_phase_X = B0_DCI_A2_phase - 90} if (B0_DCI_A2_phase <= 270) { B0_DCI_A2_phase_X = 270 - B0_DCI_A2_phase} if (B0_DCI_A2_phase <= 360) { B0_DCI_A2_phase_X = B0_DCI_A2_phase - 270} if (B0_DCI_A2_phase <= 90) { B0_DCI_A2_phase_Y = B0_DCI_A2_phase} if (B0_DCI_A2_phase <= 180) { B0_DCI_A2_phase_Y = 180 - B0_DCI_A2_phase} if (B0_DCI_A2_phase <= 270) { B0_DCI_A2_phase_Y = B0_DCI_A2_phase - 180} if (B0_DCI_A2_phase <= 360) { B0_DCI_A2_phase_Y = 360 - B0_DCI_A2_phase} // определение координат вектора В0 * DCI_A2 var B0_DCI_A2_1_X = 0; var B0_DCI_A2_2_X; if (B0_DCI_A2_phase <= 180) {B0_DCI_A2_2_X = Math.abs(Math.cos(B0_DCI_A2_phase_X * 3.1415/180)) * B0_DCI_A2 } else {B0_DCI_A2_2_X = Math.abs(Math.cos(B0_DCI_A2_phase_X * 3.1415/180)) * B0_DCI_A2 * (-1)} var B0_DCI_A2_1_Y = 0; var B0_DCI_A2_2_Y; if (B0_DCI_A2_phase <= 90 || B0_DCI_A2_phase >= 270) {B0_DCI_A2_2_Y = Math.abs(Math.cos(B0_DCI_A2_phase_Y * 3.1415/180)) * B0_DCI_A2 } else {B0_DCI_A2_2_Y = Math.abs(Math.cos(B0_DCI_A2_phase_Y * 3.1415/180)) * B0_DCI_A2 * (-1)} // определение модуля вектора A0 * DCI_B2 var A0_DCI_B2 = A0 * DCI_B2; // определение фазы вектора A0 * DCI_B2 var A0_DCI_B2_phase; if ((A0_phase + DCI_B2_phase) >360) { A0_DCI_B2_phase = A0_phase + DCI_B2_phase - 360 } else {A0_DCI_B2_phase = A0_phase + DCI_B2_phase} // определение угла наклона вектора A0 * DCI_B2 к осям X и Y var A0_DCI_B2_phase_X; var A0_DCI_B2_phase_Y; if (A0_DCI_B2_phase <= 90) { A0_DCI_B2_phase_X = 90 - A0_DCI_B2_phase} if (A0_DCI_B2_phase <= 180) { A0_DCI_B2_phase_X = A0_DCI_B2_phase - 90} if (A0_DCI_B2_phase <= 270) { A0_DCI_B2_phase_X = 270 - A0_DCI_B2_phase} if (A0_DCI_B2_phase <= 360) { A0_DCI_B2_phase_X = A0_DCI_B2_phase - 270} if (A0_DCI_B2_phase <= 90) { A0_DCI_B2_phase_Y = A0_DCI_B2_phase} if (A0_DCI_B2_phase <= 180) { A0_DCI_B2_phase_Y = 180 - A0_DCI_B2_phase} if (A0_DCI_B2_phase <= 270) { A0_DCI_B2_phase_Y = A0_DCI_B2_phase - 180} if (A0_DCI_B2_phase <= 360) { A0_DCI_B2_phase_Y = 360 - A0_DCI_B2_phase} // определение координат вектора A0 * DCI_B2 var A0_DCI_B2_1_X = 0; var A0_DCI_B2_2_X; if (A0_DCI_B2_phase <= 180) {A0_DCI_B2_2_X = Math.abs(Math.cos(A0_DCI_B2_phase_X * 3.1415/180)) * A0_DCI_B2 } else {A0_DCI_B2_2_X = Math.abs(Math.cos(A0_DCI_B2_phase_X * 3.1415/180)) * A0_DCI_B2 * (-1)} var A0_DCI_B2_1_Y = 0; var A0_DCI_B2_2_Y; if (A0_DCI_B2_phase <= 90 || A0_DCI_B2_phase >= 270) {A0_DCI_B2_2_Y = Math.abs(Math.cos(A0_DCI_B2_phase_Y * 3.1415/180)) * A0_DCI_B2 } else {A0_DCI_B2_2_Y = Math.abs(Math.cos(A0_DCI_B2_phase_Y * 3.1415/180)) * A0_DCI_B2 * (-1)} // определение модуля вектора A0 * DCI_B1 var A0_DCI_B1 = A0 * DCI_B1; // определение фазы вектора A0 * DCI_B1 var A0_DCI_B1_phase; if ((A0_phase + DCI_B1_phase) >360) { A0_DCI_B1_phase = A0_phase + DCI_B1_phase - 360 } else {A0_DCI_B1_phase = A0_phase + DCI_B1_phase} // определение угла наклона вектора A0 * DCI_B1 к осям X и Y var A0_DCI_B1_phase_X; var A0_DCI_B1_phase_Y; if (A0_DCI_B1_phase <= 90) { A0_DCI_B1_phase_X = 90 - A0_DCI_B1_phase} if (A0_DCI_B1_phase <= 180) { A0_DCI_B1_phase_X = A0_DCI_B1_phase - 90} if (A0_DCI_B1_phase <= 270) { A0_DCI_B1_phase_X = 270 - A0_DCI_B1_phase} if (A0_DCI_B1_phase <= 360) { A0_DCI_B1_phase_X = A0_DCI_B1_phase - 270} if (A0_DCI_B1_phase <= 90) { A0_DCI_B1_phase_Y = A0_DCI_B1_phase} if (A0_DCI_B1_phase <= 180) { A0_DCI_B1_phase_Y = 180 - A0_DCI_B1_phase} if (A0_DCI_B1_phase <= 270) { A0_DCI_B1_phase_Y = A0_DCI_B1_phase - 180} if (A0_DCI_B1_phase <= 360) { A0_DCI_B1_phase_Y = 360 - A0_DCI_B1_phase} // определение координат вектора A0 * DCI_B1 var A0_DCI_B1_1_X = 0; var A0_DCI_B1_2_X; if (A0_DCI_B1_phase <= 180) {A0_DCI_B1_2_X = Math.abs(Math.cos(A0_DCI_B1_phase_X * 3.1415/180)) * A0_DCI_B1 } else {A0_DCI_B1_2_X = Math.abs(Math.cos(A0_DCI_B1_phase_X * 3.1415/180)) * A0_DCI_B1 * (-1)} var A0_DCI_B1_1_Y = 0; var A0_DCI_B1_2_Y; if (A0_DCI_B1_phase <= 90 || A0_DCI_B1_phase >= 270) {A0_DCI_B1_2_Y = Math.abs(Math.cos(A0_DCI_B1_phase_Y * 3.1415/180)) * A0_DCI_B1 } else {A0_DCI_B1_2_Y = Math.abs(Math.cos(A0_DCI_B1_phase_Y * 3.1415/180)) * A0_DCI_B1 * (-1)} // определение модуля вектора B0 * DCI_A1 var B0_DCI_A1 = B0 * DCI_A1; // определение фазы вектора A0 * DCI_B1 var B0_DCI_A1_phase; if ((B0_phase + DCI_A1_phase) >360) { B0_DCI_A1_phase = B0_phase + DCI_A1_phase - 360 } else {B0_DCI_A1_phase = B0_phase + DCI_A1_phase} // определение угла наклона вектора B0 * DCI_A1 к осям X и Y var B0_DCI_A1_phase_X; var B0_DCI_A1_phase_Y; if (B0_DCI_A1_phase <= 90) { B0_DCI_A1_phase_X = 90 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 180) { B0_DCI_A1_phase_X = B0_DCI_A1_phase - 90} if (B0_DCI_A1_phase <= 270) { B0_DCI_A1_phase_X = 270 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 360) { B0_DCI_A1_phase_X = B0_DCI_A1_phase - 270} if (B0_DCI_A1_phase <= 90) { B0_DCI_A1_phase_Y = B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 180) { B0_DCI_A1_phase_Y = 180 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 270) { B0_DCI_A1_phase_Y = B0_DCI_A1_phase - 180} if (B0_DCI_A1_phase <= 360) { B0_DCI_A1_phase_Y = 360 - B0_DCI_A1_phase} // определение координат вектора B0 * DCI_A1 var B0_DCI_A1_1_X = 0; var B0_DCI_A1_2_X; if (B0_DCI_A1_phase <= 180) {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 } else {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 * (-1)} var B0_DCI_A1_1_Y = 0; var B0_DCI_A1_2_Y; if (B0_DCI_A1_phase <= 90 || B0_DCI_A1_phase >= 270) {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 } else {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 * (-1)} // определение фазы вектора B0 * DCI_A1 var B0_DCI_A1_phase; if ((B0_phase + DCI_A1_phase) >360) { B0_DCI_A1_phase = B0_phase + DCI_A1_phase - 360 } else {B0_DCI_A1_phase = B0_phase + DCI_A1_phase} // определение угла наклона вектора B0 * DCI_A1 к осям X и Y var B0_DCI_A1_phase_X; var B0_DCI_A1_phase_Y; if (B0_DCI_A1_phase <= 90) { B0_DCI_A1_phase_X = 90 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 180) { B0_DCI_A1_phase_X = B0_DCI_A1_phase - 90} if (B0_DCI_A1_phase <= 270) { B0_DCI_A1_phase_X = 270 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 360) { B0_DCI_A1_phase_X = B0_DCI_A1_phase - 270} if (B0_DCI_A1_phase <= 90) { B0_DCI_A1_phase_Y = B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 180) { B0_DCI_A1_phase_Y = 180 - B0_DCI_A1_phase} if (B0_DCI_A1_phase <= 270) { B0_DCI_A1_phase_Y = B0_DCI_A1_phase - 180} if (B0_DCI_A1_phase <= 360) { B0_DCI_A1_phase_Y = 360 - B0_DCI_A1_phase} // определение координат вектора B0 * DCI_A1 var B0_DCI_A1_1_X = 0; var B0_DCI_A1_2_X; if (B0_DCI_A1_phase <= 180) {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 } else {B0_DCI_A1_2_X = Math.abs(Math.cos(B0_DCI_A1_phase_X * 3.1415/180)) * B0_DCI_A1 * (-1)} var B0_DCI_A1_1_Y = 0; var B0_DCI_A1_2_Y; if (B0_DCI_A1_phase <= 90 || B0_DCI_A1_phase >= 270) {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 } else {B0_DCI_A1_2_Y = Math.abs(Math.cos(B0_DCI_A1_phase_Y * 3.1415/180)) * B0_DCI_A1 * (-1)} // определение модуля вектора B0 * DCI_A2 - A0 * DCI_B2 var B0_DCIA2_A0_DCIB2; var B0_DCIA2_A0_DCIB2_1_X = A0_DCI_B2_2_X; var B0_DCIA2_A0_DCIB2_1_Y = A0_DCI_B2_2_Y; var B0_DCIA2_A0_DCIB2_2_X = B0_DCI_A2_2_X; var B0_DCIA2_A0_DCIB2_2_Y = B0_DCI_A2_2_Y; B0_DCIA2_A0_DCIB2 = Math.sqrt(Math.pow(B0_DCIA2_A0_DCIB2_2_X - B0_DCIA2_A0_DCIB2_1_X, 2) + Math.pow(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y, 2)); // определение фазы вектора B0 * DCI_A2 - A0 * DCI_B2 var B0_DCIA2_A0_DCIB2_phase; if ((B0_DCIA2_A0_DCIB2_2_X > B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y >= B0_DCIA2_A0_DCIB2_1_Y)) { B0_DCIA2_A0_DCIB2_phase = (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)} if ((B0_DCIA2_A0_DCIB2_2_X <= B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y < B0_DCIA2_A0_DCIB2_1_Y)) { B0_DCIA2_A0_DCIB2_phase = (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415) + 180} if ((B0_DCIA2_A0_DCIB2_2_X < B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y >= B0_DCIA2_A0_DCIB2_1_Y)) { B0_DCIA2_A0_DCIB2_phase = 360 - (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)} if ((B0_DCIA2_A0_DCIB2_2_X >= B0_DCIA2_A0_DCIB2_1_X) && (B0_DCIA2_A0_DCIB2_2_Y < B0_DCIA2_A0_DCIB2_1_Y)) { B0_DCIA2_A0_DCIB2_phase = 180 - (((Math.acos((Math.abs(B0_DCIA2_A0_DCIB2_2_Y - B0_DCIA2_A0_DCIB2_1_Y)) / B0_DCIA2_A0_DCIB2)) * 180 ) / 3.1415)} // определение модуля вектора A0 * DCI_B1 - B0 * DCI_A1 var A0_DCIB1_B0_DCIA1; var A0_DCIB1_B0_DCIA1_1_X = B0_DCI_A1_2_X; var A0_DCIB1_B0_DCIA1_1_Y = B0_DCI_A1_2_Y; var A0_DCIB1_B0_DCIA1_2_X = A0_DCI_B1_2_X; var A0_DCIB1_B0_DCIA1_2_Y = A0_DCI_B1_2_Y; A0_DCIB1_B0_DCIA1 = Math.sqrt(Math.pow(A0_DCIB1_B0_DCIA1_2_X - A0_DCIB1_B0_DCIA1_1_X, 2) + Math.pow(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y, 2)); // определение фазы вектора A0 * DCI_B1 - B0 * DCI_A1 var A0_DCIB1_B0_DCIA1_phase; if ((A0_DCIB1_B0_DCIA1_2_X > A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y >= A0_DCIB1_B0_DCIA1_1_Y)) { A0_DCIB1_B0_DCIA1_phase = (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)} if ((A0_DCIB1_B0_DCIA1_2_X <= A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y < A0_DCIB1_B0_DCIA1_1_Y)) { A0_DCIB1_B0_DCIA1_phase = (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415) + 180} if ((A0_DCIB1_B0_DCIA1_2_X < A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y >= A0_DCIB1_B0_DCIA1_1_Y)) { A0_DCIB1_B0_DCIA1_phase = 360 - (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)} if ((A0_DCIB1_B0_DCIA1_2_X >= A0_DCIB1_B0_DCIA1_1_X) && (A0_DCIB1_B0_DCIA1_2_Y < A0_DCIB1_B0_DCIA1_1_Y)) { A0_DCIB1_B0_DCIA1_phase = 180 - (((Math.acos((Math.abs(A0_DCIB1_B0_DCIA1_2_Y - A0_DCIB1_B0_DCIA1_1_Y)) / A0_DCIB1_B0_DCIA1)) * 180 ) / 3.1415)} // определение модуля вектора DCI_A1 * DCI_B2 var DCIA1_DCIB2 = DCI_A1 * DCI_B2; // определение фазы вектора DCI_A1 * DCI_B2 var DCIA1_DCIB2_phase; if ((DCI_A1_phase + DCI_B2_phase) >360) { DCIA1_DCIB2_phase = DCI_A1_phase + DCI_B2_phase - 360 } else {DCIA1_DCIB2_phase = DCI_A1_phase + DCI_B2_phase} // определение угла наклона вектора DCI_A1 * DCI_B2 к осям X и Y var DCIA1_DCIB2_phase_X; var DCIA1_DCIB2_phase_Y; if (DCIA1_DCIB2_phase <= 90) { DCIA1_DCIB2_phase_X = 90 - DCIA1_DCIB2_phase} if (DCIA1_DCIB2_phase <= 180) { DCIA1_DCIB2_phase_X = DCIA1_DCIB2_phase - 90} if (DCIA1_DCIB2_phase <= 270) { DCIA1_DCIB2_phase_X = 270 - DCIA1_DCIB2_phase} if (DCIA1_DCIB2_phase <= 360) { DCIA1_DCIB2_phase_X = DCIA1_DCIB2_phase - 270} if (DCIA1_DCIB2_phase <= 90) { DCIA1_DCIB2_phase_Y = DCIA1_DCIB2_phase} if (DCIA1_DCIB2_phase <= 180) { DCIA1_DCIB2_phase_Y = 180 - DCIA1_DCIB2_phase} if (DCIA1_DCIB2_phase <= 270) { DCIA1_DCIB2_phase_Y = DCIA1_DCIB2_phase - 180} if (DCIA1_DCIB2_phase <= 360) { DCIA1_DCIB2_phase_Y = 360 - DCIA1_DCIB2_phase} // определение координат вектора DCI_A1 * DCI_B2 var DCIA1_DCIB2_1_X = 0; var DCIA1_DCIB2_2_X; if (DCIA1_DCIB2_phase <= 180) {DCIA1_DCIB2_2_X = Math.abs(Math.cos(DCIA1_DCIB2_phase_X * 3.1415/180)) * DCIA1_DCIB2 } else {DCIA1_DCIB2_2_X = Math.abs(Math.cos(DCIA1_DCIB2_phase_X * 3.1415/180)) * DCIA1_DCIB2 * (-1)} var DCIA1_DCIB2_1_Y = 0; var DCIA1_DCIB2_2_Y; if (DCIA1_DCIB2_phase <= 90 || DCIA1_DCIB2_phase >= 270) {DCIA1_DCIB2_2_Y = Math.abs(Math.cos(DCIA1_DCIB2_phase_Y * 3.1415/180)) * DCIA1_DCIB2 } else {DCIA1_DCIB2_2_Y = Math.abs(Math.cos(DCIA1_DCIB2_phase_Y * 3.1415/180)) * DCIA1_DCIB2 * (-1)} // определение модуля вектора DCI_B1 * DCI_A2 var DCIB1_DCIA2 = DCI_B1 * DCI_A2; // определение фазы вектора DCI_B1 * DCI_A2 var DCIB1_DCIA2_phase; if ((DCI_B1_phase + DCI_A2_phase) >360) { DCIB1_DCIA2_phase = DCI_B1_phase + DCI_A2_phase - 360 } else {DCIB1_DCIA2_phase = DCI_B1_phase + DCI_A2_phase} // определение угла наклона вектора DCI_B1 * DCI_A2 к осям X и Y var DCIB1_DCIA2_phase_X; var DCIB1_DCIA2_phase_Y; if (DCIB1_DCIA2_phase <= 90) { DCIB1_DCIA2_phase_X = 90 - DCIB1_DCIA2_phase} if (DCIB1_DCIA2_phase <= 180) { DCIB1_DCIA2_phase_X = DCIB1_DCIA2_phase - 90} if (DCIB1_DCIA2_phase <= 270) { DCIB1_DCIA2_phase_X = 270 - DCIB1_DCIA2_phase} if (DCIB1_DCIA2_phase <= 360) { DCIB1_DCIA2_phase_X = DCIB1_DCIA2_phase - 270} if (DCIB1_DCIA2_phase <= 90) { DCIB1_DCIA2_phase_Y = DCIB1_DCIA2_phase} if (DCIB1_DCIA2_phase <= 180) { DCIB1_DCIA2_phase_Y = 180 - DCIB1_DCIA2_phase} if (DCIB1_DCIA2_phase <= 270) { DCIB1_DCIA2_phase_Y = DCIB1_DCIA2_phase - 180} if (DCIB1_DCIA2_phase <= 360) { DCIB1_DCIA2_phase_Y = 360 - DCIB1_DCIA2_phase} // определение координат вектора DCI_B1 * DCI_A2 var DCIB1_DCIA2_1_X = 0; var DCIB1_DCIA2_2_X; if (DCIB1_DCIA2_phase <= 180) {DCIB1_DCIA2_2_X = Math.abs(Math.cos(DCIB1_DCIA2_phase_X * 3.1415/180)) * DCIB1_DCIA2 } else {DCIB1_DCIA2_2_X = Math.abs(Math.cos(DCIB1_DCIA2_phase_X * 3.1415/180)) * DCIB1_DCIA2 * (-1)} var DCIB1_DCIA2_1_Y = 0; var DCIB1_DCIA2_2_Y; if (DCIB1_DCIA2_phase <= 90 || DCIB1_DCIA2_phase >= 270) {DCIB1_DCIA2_2_Y = Math.abs(Math.cos(DCIB1_DCIA2_phase_Y * 3.1415/180)) * DCIB1_DCIA2 } else {DCIB1_DCIA2_2_Y = Math.abs(Math.cos(DCIB1_DCIA2_phase_Y * 3.1415/180)) * DCIB1_DCIA2 * (-1)} // определение модуля вектора DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2 var DCIA1_DCIB2_DCIB1_DCIA2; var DCIA1_DCIB2_DCIB1_DCIA2_1_X = DCIB1_DCIA2_2_X; var DCIA1_DCIB2_DCIB1_DCIA2_1_Y = DCIB1_DCIA2_2_Y; var DCIA1_DCIB2_DCIB1_DCIA2_2_X = DCIA1_DCIB2_2_X; var DCIA1_DCIB2_DCIB1_DCIA2_2_Y = DCIA1_DCIB2_2_Y; DCIA1_DCIB2_DCIB1_DCIA2 = Math.sqrt(Math.pow(DCIA1_DCIB2_DCIB1_DCIA2_2_X - DCIA1_DCIB2_DCIB1_DCIA2_1_X, 2) + Math.pow(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y, 2)); // определение фазы вектора DCI_A1 * DCI_B2 - DCI_B1 * DCI_A2 var DCIA1_DCIB2_DCIB1_DCIA2_phase; if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X > DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y >= DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) { DCIA1_DCIB2_DCIB1_DCIA2_phase = (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)} if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X <= DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y < DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) { DCIA1_DCIB2_DCIB1_DCIA2_phase = (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415) + 180} if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X < DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y >= DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) { DCIA1_DCIB2_DCIB1_DCIA2_phase = 360 - (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)} if ((DCIA1_DCIB2_DCIB1_DCIA2_2_X >= DCIA1_DCIB2_DCIB1_DCIA2_1_X) && (DCIA1_DCIB2_DCIB1_DCIA2_2_Y < DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) { DCIA1_DCIB2_DCIB1_DCIA2_phase = 180 - (((Math.acos((Math.abs(DCIA1_DCIB2_DCIB1_DCIA2_2_Y - DCIA1_DCIB2_DCIB1_DCIA2_1_Y)) / DCIA1_DCIB2_DCIB1_DCIA2)) * 180 ) / 3.1415)} // определение массы корректирующей массы Mb1 (плоскость 1) Mb1 = B0_DCIA2_A0_DCIB2 / DCIA1_DCIB2_DCIB1_DCIA2; // опредение угла установки корректирующей массы Mb1 (плоскость 1) if ((B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) < 0) { Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) + 360} else if ((B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) > 360) { Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) - 360} else {Mb1_corner = (B0_DCIA2_A0_DCIB2_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase)} // определение массы дисбаланса плоскости 1 Mdisb1 = Mb1; // равен массе балансировочного груза // определение угла расположения дисбаланса плоскости 1 if ((Mb1_corner + 180) > 360) { Mdisb1_corner = (Mb1_corner + 180) - 360} else if ((Mb1_corner + 180) < 0) { Mdisb1_corner = (Mb1_corner + 180) + 360} else {Mdisb1_corner = (Mb1_corner + 180)} // определение массы корректирующей массы Mb2 (плоскость 2) Mb2 = A0_DCIB1_B0_DCIA1 / DCIA1_DCIB2_DCIB1_DCIA2; // опредение угла установки корректирующей массы Mb2 (плоскость 2) if ((A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) < 0) { Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) + 360} else if ((A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) > 360) { Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase) - 360} else {Mb2_corner = (A0_DCIB1_B0_DCIA1_phase - DCIA1_DCIB2_DCIB1_DCIA2_phase)} // определение массы дисбаланса плоскости 2 Mdisb2 = Mb2; // равен массе балансировочного груза // определение угла расположения дисбаланса плоскости 2 if ((Mb2_corner + 180) > 360) { Mdisb2_corner = (Mb2_corner + 180) - 360} else if ((Mb2_corner + 180) < 0) { Mdisb2_corner = (Mb2_corner + 180) + 360} else {Mdisb2_corner = (Mb2_corner + 180)} gtl.log.info("Mb1 (баланс. груз 1-й плоскости)",Mb1); gtl.log.info("Mb1_corner (угол баланс. груза 1-й плоск.)",Mb1_corner); gtl.log.info("Mdisb1 (дисбаланс 1-й плоскости)",Mdisb1); gtl.log.info("Mdisb1_corner (угол расположения дисбаланса 1-й плоскости)",Mdisb1_corner); gtl.log.info("Mb2 (баланс. груз 2-й плоскости)",Mb2); gtl.log.info("Mb2_corner (угол баланс. груза 2-й плоск.)",Mb2_corner); gtl.log.info("Mdisb2 (дисбаланс 2-й плоскости)",Mdisb2); gtl.log.info("Mdisb2_corner (угол расположения дисбаланса 2-й плоскости)",Mdisb2_corner); gtl.log.info("m11_test (пробный груз введёный)",m11_test); gtl.log.info("m22_test (пробный груз введёный)",m22_test); gtl.log.info("RMSv0_2_1000",RMSv0_2_1000.value); gtl.log.info("RMSa0",RMSa0.value); gtl.log.info("RMSv1_2_1000",RMSv1_2_1000.value); gtl.log.info("RMSa1",RMSa1.value); gtl.log.info("Необходимость проведения балансировки",test_balance); gtl.log.info("F1_0_3_ph (фаза)",F1_0_3_ph); gtl.log.info("F1_0_3_a (ампл)",F1_0_3_a); gtl.log.info("F1_0_3_f (част)",F1_0_3_f); gtl.log.info("F1_0_2_ph (фаза)",F1_0_2_ph); gtl.log.info("F1_0_2_a (ампл)",F1_0_2_a); gtl.log.info("F1_0_2_f (част)",F1_0_2_f); gtl.log.info("F1_0_1_ph (фаза)",F1_0_1_ph); gtl.log.info("F1_0_1_a (ампл)",F1_0_1_a); gtl.log.info("F1_0_1_f (част)",F1_0_1_f); gtl.log.info("F1_1_3_ph (фаза)",F1_1_3_ph); gtl.log.info("F1_1_3_a (ампл)",F1_1_3_a); gtl.log.info("F1_1_3_f (част)",F1_1_3_f); gtl.log.info("F1_1_2_ph (фаза)",F1_1_2_ph); gtl.log.info("F1_1_2_a (ампл)",F1_1_2_a); gtl.log.info("F1_1_2_f (част)",F1_1_2_f); gtl.log.info("F1_1_1_ph (фаза)",F1_1_1_ph); gtl.log.info("F1_1_1_a (ампл)",F1_1_1_a); gtl.log.info("F1_1_1_f (част)",F1_1_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, Нестаб_част_вращ: instability*100, Тестирование: test_balance, Ампл_гарм_1F1_точка_A: F1_0_1_a, Фаза_част_вращ_F1_точка_A: F1_0_1_ph, Примен_пробный_груз_плоскости_1: m11_test, Расч_масса_пробного_груза: m_test_calc, Масса_баланс_груза_плоскости_1: Mb1, Угол_баланс_груза_плоскости_1: Mb1_corner, СКЗ_виброскор_точки_A: RMSv0_2_1000.value, Ампл_гарм_1F1_точка_B: F1_1_1_a, Фаза_част_вращ_F1_точка_B: F1_1_1_ph, Примен_пробный_груз_плоскости_2: m22_test, Масса_баланс_груза_плоскости_2: Mb2, Угол_баланс_груза_плоскости_2: Mb2_corner, СКЗ_виброскор_точки_B: RMSv1_2_1000.value, ДКВ_A1: DCI_A1, ДКВ_A1_phase: DCI_A1_phase, ДКВ_B1: DCI_B1, ДКВ_B1_phase: DCI_B1_phase, ДКВ_A2: DCI_A2, ДКВ_A2_phase: DCI_A2_phase, ДКВ_B2: DCI_B2, ДКВ_B2_phase: DCI_B2_phase, }; gtl.results = {"result_ausp0": __result1_0, "result_pfc0": __result2_0, "result_ausp1": __result1_1, "result_pfc1": __result2_1, "result_общий": __result3}; gtl.diagnostic.stop(); break; default: break; } }