s.savelievrem
/
balancer_calc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
balancer_calc/scripts/Две_плоскости_с_фазой (до р...

1407 lines
77 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"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;
}
}
Reference in New Issue View Git Blame Copy Permalink