793 lines
38 KiB
JavaScript
793 lines
38 KiB
JavaScript
"use strict";
|
||
|
||
var signals = gtl.options.record.signalsModel;
|
||
var options = gtl.options;
|
||
var record = gtl.options.record;
|
||
var point = gtl.options.point;
|
||
|
||
// Импорт функций
|
||
var imp = gtl.import("functions_for_balance.js");
|
||
var fnc = gtl.import("user-functions.js");
|
||
|
||
// Цвета (для справки)
|
||
// #ff0000 - красный
|
||
// #00ff00 - салатовый
|
||
// #0fae1a - зелёный
|
||
// #0000ff - синий
|
||
// #00ddff - голубой
|
||
// #ff3dcc - фиолетовый
|
||
// #ffff00 - жёлтый
|
||
|
||
// ***** БАЛАНСИРОВОЧНЫЙ КАЛЬКУЛЯТОР. ДВЕ ПЛОСКОСТИ (использование ДКВ) *****
|
||
// **************************************************************************
|
||
|
||
// Получение входных сигналов
|
||
// Определение частоты вращения по параметру freq.dc
|
||
let freq = gtl.add_value_freq(gtl.analog_inputs[record.tachoOptions.tachoChannel]);
|
||
freq.time = 1; // длина (время) отрезка сигнала
|
||
freq.avg_cnt = 3; // количество усреднений
|
||
freq.dc = -0.05; // уровень, при переходе через который вычисляются периоды
|
||
// Настройки для спектров и АФЧХ
|
||
let frequency; // граничная частота
|
||
let resolution = 0.5; // частотное разрешение
|
||
let average = 3; // количество усреднений
|
||
let overlap = 0; // наложение
|
||
let filter_A_vibr; // фильтр сигнала A вибрации
|
||
let filter_B_vibr; // фильтр сигнала B вибрации
|
||
|
||
// Канал A
|
||
// ФИЛЬТР_A 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
|
||
let filter_A_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
|
||
filter_A_2_1000.kind = gtl.filter_iir.butterworth;
|
||
filter_A_2_1000.type = gtl.filter_iir.bandpass;
|
||
filter_A_2_1000.order = 6;
|
||
filter_A_2_1000.frequency = 501; // центральная частота полосового фильтра
|
||
filter_A_2_1000.width = 998; // ширина полосы фильтра
|
||
let filter_A_2_1000v = gtl.add_intg(filter_A_2_1000); // интегрирование
|
||
filter_A_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
|
||
// Фильтр A для виброперемещения
|
||
let filter_A_2_300s = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
|
||
filter_A_2_300s.kind = gtl.filter_iir.butterworth;
|
||
filter_A_2_300s.type = gtl.filter_iir.bandpass; // полосовой фильтр
|
||
filter_A_2_300s.order = 4;
|
||
filter_A_2_300s.frequency = 151; // центральная частота
|
||
filter_A_2_300s.width = 298; // ширина полосы
|
||
|
||
// Канал B
|
||
// ФИЛЬТР_B 2...1000 Гц, полосовой фильтр для СКЗ виброскорости и спектра
|
||
let filter_B_2_1000 = gtl.add_filter_iir(gtl.analog_inputs[signals[1].portNumber]);
|
||
filter_B_2_1000.kind = gtl.filter_iir.butterworth;
|
||
filter_B_2_1000.type = gtl.filter_iir.bandpass;
|
||
filter_B_2_1000.order = 6;
|
||
filter_B_2_1000.frequency = 501; // центральная частота полосового фильтра
|
||
filter_B_2_1000.width = 998; // ширина полосы фильтра
|
||
let filter_B_2_1000v = gtl.add_intg(filter_B_2_1000); // интегрирование
|
||
filter_B_2_1000v.taps = 1; // степень интегрирования (скорость из ускорения - 1-нарное)
|
||
// Фильтр B для виброперемещения
|
||
let filter_B_2_300s = gtl.add_filter_iir(gtl.analog_inputs[signals[1].portNumber]);
|
||
filter_B_2_300s.kind = gtl.filter_iir.butterworth;
|
||
filter_B_2_300s.type = gtl.filter_iir.bandpass; // полосовой фильтр
|
||
filter_B_2_300s.order = 4;
|
||
filter_B_2_300s.frequency = 151; // центральная частота
|
||
filter_B_2_300s.width = 298; // ширина полосы
|
||
|
||
// Переключатель источника сигнала - относительная / абсолютная вибрация
|
||
// 0 - относительная вибрация (датчик виброперемещения)
|
||
// 1 - абсолютная вибрация (датчик виброускорения)
|
||
let select_vibr_sign = gtl.options.customOptions.select_vibr_sign;
|
||
|
||
|
||
// Выбор фильтра и параметров спектров в зависимости от значения переключателя источника сигнала вибрации
|
||
if (select_vibr_sign == 1)
|
||
{
|
||
filter_A_vibr = filter_A_2_1000v;
|
||
filter_B_vibr = filter_B_2_1000v;
|
||
frequency = 1000;
|
||
}
|
||
else if (select_vibr_sign == 0)
|
||
{
|
||
filter_A_vibr = filter_A_2_300s;
|
||
filter_B_vibr = filter_B_2_300s;
|
||
frequency = 300;
|
||
}
|
||
|
||
// Спектр_A для получения 1-й гармоники частоты вращения
|
||
let AUSP_A = gtl.add_ausp(filter_A_vibr); // объявление переменной спектра
|
||
AUSP_A.color = 0x00ff0000; // цвет спектра
|
||
AUSP_A.name = "AUSP_A"; // имя спектра
|
||
AUSP_A.frequency = frequency; // граничная частота спектра
|
||
AUSP_A.lines = AUSP_A.frequency * 1/resolution; // разрешение спектра (количество линий)
|
||
AUSP_A.average = average; // количество усреднений
|
||
AUSP_A.unit = gtl.spec.unit; // отображение амплитуды в мм/с
|
||
AUSP_A.smoothing_factor = 100; // усреднение средней линии
|
||
AUSP_A.smoothed_line_color = 0xff004dff; // цвет средней линии
|
||
AUSP_A.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный)
|
||
AUSP_A.tolerance = AUSP_A.resolution; // диапазон поиска гармоник +/-
|
||
// СКЗ_A
|
||
let RMS_A = gtl.add_value_rms(filter_A_vibr);
|
||
RMS_A.time = 1;
|
||
RMS_A.avg_cnt = 3;
|
||
|
||
// Спектр_B для получения 1-й гармоники частоты вращения
|
||
let AUSP_B = gtl.add_ausp(filter_B_vibr); // объявление переменной спектра
|
||
AUSP_B.color = 0x00ff0000; // цвет спектра
|
||
AUSP_B.name = "AUSP_A"; // имя спектра
|
||
AUSP_B.frequency = frequency; // граничная частота спектра
|
||
AUSP_B.lines = AUSP_B.frequency * 1/resolution; // разрешение спектра (количество линий)
|
||
AUSP_B.average = average; // количество усреднений
|
||
AUSP_B.unit = gtl.spec.unit; // отображение амплитуды в мм/с
|
||
AUSP_B.smoothing_factor = 100; // усреднение средней линии
|
||
AUSP_B.smoothed_line_color = 0xff004dff; // цвет средней линии
|
||
AUSP_B.peak_level = 0.001; // порог обнаружения гармоник (необходим самый минимальный)
|
||
AUSP_B.tolerance = AUSP_B.resolution; // диапазон поиска гармоник +/-
|
||
// СКЗ_B
|
||
let RMS_B = gtl.add_value_rms(filter_B_vibr);
|
||
RMS_B.time = 1;
|
||
RMS_B.avg_cnt = 3;
|
||
|
||
|
||
// Спектр вибрации точки A
|
||
var AUSP_A_pl = gtl.create_ausp(
|
||
{
|
||
"src" : filter_A_vibr,
|
||
"frequency" : frequency,
|
||
"resolution" : resolution,
|
||
"average" : average,
|
||
"overlap" : overlap,
|
||
"window" : gtl.spec.rectangular,
|
||
"view" : gtl.spec.unit
|
||
}
|
||
);
|
||
// ФЧХ точки A
|
||
var pfc_A_pl = gtl.create_pfc(
|
||
{
|
||
"src0" : filter_A_vibr,
|
||
"src1" : gtl.analog_inputs[record.tachoOptions.tachoChannel],
|
||
"frequency" : frequency,
|
||
"resolution" : resolution,
|
||
"average" : average,
|
||
"overlap" : overlap,
|
||
"window" : gtl.spec.rectangular,
|
||
"view" : gtl.phase.deg,
|
||
// "range" : gtl.phase.positive,
|
||
"is_single" : false
|
||
}
|
||
);
|
||
|
||
// Спектр виброскорости точки B
|
||
var AUSP_B_pl = gtl.create_ausp(
|
||
{
|
||
"src" : filter_B_vibr,
|
||
"frequency" : frequency,
|
||
"resolution" : resolution,
|
||
"average" : average,
|
||
"overlap" : overlap,
|
||
"window" : gtl.spec.rectangular,
|
||
"view" : gtl.spec.unit
|
||
}
|
||
);
|
||
// ФЧХ точки B
|
||
var pfc_B_pl = gtl.create_pfc(
|
||
{
|
||
"src0" : filter_B_vibr,
|
||
"src1" : gtl.analog_inputs[record.tachoOptions.tachoChannel],
|
||
"frequency" : frequency,
|
||
"resolution" : resolution,
|
||
"average" : average,
|
||
"overlap" : overlap,
|
||
"window" : gtl.spec.rectangular,
|
||
"view" : gtl.phase.deg,
|
||
// "range" : gtl.phase.positive,
|
||
"is_single" : false
|
||
}
|
||
);
|
||
|
||
// "range": gtl.phase.negative,
|
||
// "delay" : .1, // по умолчанию - 0
|
||
// "start" : false // по умолчанию - true
|
||
|
||
// Объявление графических плоскостей для построения графиков
|
||
let plot_pfc = gtl.plots.add("ФЧХ"); // фазо-частотная характеристика
|
||
let plot_ausp = gtl.plots.add("Спектры вибрации"); // объект для спектра
|
||
let plot_vibr = gtl.plots.add("Векторы вибрации"); // объект для векторов вибрации
|
||
let plot_disb = gtl.plots.add("Расположение дисбалансов"); // объект для дисбаланса
|
||
|
||
// gtl.log.info("размер массива AUSPv_pl", AUSPv_pl.data.length);
|
||
// gtl.log.info("размер массива pfc_pl", pfc_pl.data.length);
|
||
|
||
// Переменные основные
|
||
// параметр вибрации (модуль вектора) - виброскорость (мм/с)
|
||
// угол (фаза) вектора - градусы
|
||
// масса груза (модуль ветора) - граммы
|
||
// DCI - Dynamic Coefficient of Influence (динамический коэффициент влияния)
|
||
// * - значение получаем из измерительного блока при нажатии кнопки
|
||
// ** - значение вводится пользователем
|
||
// *** - значение получаем в результате расчёта программы балансировки
|
||
// значение переменной с нижним подчёркиванием (..._) берётся из "дополнительных опций"; если оно не задано, то рассчитывается в скрипте
|
||
|
||
let A0_ = gtl.options.customOptions.A0; // модуль вектора начальной вибрации точки A */**
|
||
let A0 = A0_; // модуль вектора начальной вибрации точки A */** (конечное значение)
|
||
let A0_phase_ = gtl.options.customOptions.A0_phase; // фаза вектора начальной вибрации точки A */**
|
||
let A0_phase = A0_phase_; // фаза вектора начальной вибрации точки A */** (конечное значение)
|
||
let A3_ = gtl.options.customOptions.A3; // модуль вектора вибрации точки A после установки балансировочного груза в плоскость 1 */**
|
||
let A3; // модуль вектора вибрации точки A после установки балансировочного груза в плоскость 1 */** (конечное значение)
|
||
let A3_phase_ = gtl.options.customOptions.A3_phase; // фаза вектора вибрации точки A после установки балансировочного груза в плоскость 1 */**
|
||
let A3_phase; // фаза вектора вибрации точки A после установки балансировочного груза в плоскость 1 */** (конечное значение)
|
||
let dA3; // модуль вектора дельты вибрации точки A после установки балансировочного груза в плоскость 1 ***
|
||
let dA3_phase; // фаза вектора дельты вибрации точки A после установки балансировочного груза в плоскость 1 ***
|
||
|
||
let B0_ = gtl.options.customOptions.B0; // модуль вектора начальной вибрации точки B */**
|
||
let B0 = B0_; // модуль вектора начальной вибрации точки B */** (конечное значение)
|
||
let B0_phase_ = gtl.options.customOptions.B0_phase; // фаза вектора начальной вибрации точки B */**
|
||
let B0_phase = B0_phase_; // фаза вектора начальной вибрации точки B */** (конечное значение)
|
||
let B3_ = gtl.options.customOptions.B3; // модуль вектора вибрации точки B после установки балансировочного груза в плоскость 2 */**
|
||
let B3; // модуль вектора вибрации точки B после установки балансировочного груза в плоскость 2 */** (конечное значение)
|
||
let B3_phase_ = gtl.options.customOptions.B3_phase; // фаза вектора вибрации точки B после установки балансировочного груза в плоскость 2 */**
|
||
let B3_phase; // фаза вектора вибрации точки B после установки балансировочного груза в плоскость 2 */** (конечное значение)
|
||
let dB3; // модуль вектора дельты вибрации точки B после установки балансировочного груза в плоскость 2 ***
|
||
let dB3_phase; // фаза вектора дельты вибрации точки B после установки балансировочного груза в плоскость 2 ***
|
||
|
||
|
||
|
||
// Переменные вспомогательные необходимые для расчётов
|
||
let A0_phase_X; // угол наклона вектора A0 к оси X
|
||
let A0_phase_Y; // угол наклона вектора A0 к оси Y
|
||
let A0_1_X; // начальная координата вектора A0 по оси X
|
||
let A0_2_X; // конечная координата вектора A0 по оси X
|
||
let A0_1_Y; // начальная координата вектора A0 по оси Y
|
||
let A0_2_Y; // конечная координата вектора A0 по оси Y
|
||
|
||
let A3_phase_X; // угол наклона вектора A3 к оси X
|
||
let A3_phase_Y; // угол наклона вектора A3 к оси Y
|
||
let A3_1_X; // начальная координата вектора A3 по оси X
|
||
let A3_2_X; // конечная координата вектора A3 по оси X
|
||
let A3_1_Y; // начальная координата вектора A3 по оси Y
|
||
let A3_2_Y; // конечная координата вектора A3 по оси Y
|
||
|
||
let dA3_1_X; // начальная координата вектора dA3 по оси X
|
||
let dA3_2_X; // конечная координата вектора dA3 по оси X
|
||
let dA3_1_Y; // начальная координата вектора dA3 по оси Y
|
||
let dA3_2_Y; // конечная координата вектора dA3 по оси Y
|
||
|
||
let B0_phase_X; // угол наклона вектора B0 к оси X
|
||
let B0_phase_Y; // угол наклона вектора B0 к оси Y
|
||
let B0_1_X; // начальная координата вектора B0 по оси X
|
||
let B0_2_X; // конечная координата вектора B0 по оси X
|
||
let B0_1_Y; // начальная координата вектора B0 по оси Y
|
||
let B0_2_Y; // конечная координата вектора B0 по оси Y
|
||
|
||
let B3_phase_X; // угол наклона вектора B3 к оси X
|
||
let B3_phase_Y; // угол наклона вектора B3 к оси Y
|
||
let B3_1_X; // начальная координата вектора B3 по оси X
|
||
let B3_2_X; // конечная координата вектора B3 по оси X
|
||
let B3_1_Y; // начальная координата вектора B3 по оси Y
|
||
let B3_2_Y; // конечная координата вектора B3 по оси Y
|
||
|
||
let dB3_1_X; // начальная координата вектора dB3 по оси X
|
||
let dB3_2_X; // конечная координата вектора dB3 по оси X
|
||
let dB3_1_Y; // начальная координата вектора dB3 по оси Y
|
||
let dB3_2_Y; // конечная координата вектора dB3 по оси Y
|
||
|
||
|
||
// ***** РАСЧЁТЫ *****
|
||
// gtl.diagnostic.interval = 15;
|
||
gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time) + 0.1;
|
||
|
||
let state = record.tachoOptions.tachoState; // начальное состояние после выбора источника тахо сигнала
|
||
|
||
function diagnose() {
|
||
|
||
// Нестабильность частоты вращения
|
||
var freq_max = Math.max(...freq.values);
|
||
var freq_min = Math.min(...freq.values);
|
||
var instability = ((freq_max - freq_min) / freq.value) * 100; // * 100%
|
||
|
||
switch (state) {
|
||
|
||
case 0: // считаем частоту вращения и настраиваем спектры
|
||
var freq_max = Math.max(...freq.values);
|
||
var freq_min = Math.min(...freq.values);
|
||
var instability = (freq_max - freq_min) / freq.value;
|
||
|
||
// if (instability > imp.tolerance()) {
|
||
if (instability > 0.3) {
|
||
gtl.log.info("Критическая нестабильность частоты вращения, %", instability * 100);
|
||
gtl.log.info("Результат:", "Диагностика прервана");
|
||
//gtl.diagnostic.stop(); //принудительная остановка диагностики
|
||
|
||
let __result = {
|
||
Result: false
|
||
};
|
||
gtl.results = __result;
|
||
};
|
||
|
||
// Определение минимально необходимой длительности сигнала для проведения диагностики
|
||
gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;;
|
||
state = 3;
|
||
break;
|
||
|
||
case 1: // Частота вращения фиксированная
|
||
// Определение минимально необходимой длительности сигнала для проведения диагностики
|
||
gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;
|
||
state = 3;
|
||
break;
|
||
|
||
case 2: // Частота вращения из поля INFO (виброметр)
|
||
// Определение минимально необходимой длительности сигнала для проведения диагностики
|
||
gtl.diagnostic.interval = Math.max(AUSP_A.acq_time, AUSP_A_pl.acq_time, pfc_A_pl.acq_time) + 0.1;
|
||
state = 3;
|
||
break;
|
||
|
||
case 3: // Выполняем анализ спектов
|
||
// Очистка партретов спектров
|
||
AUSP_A.clear_harms_sets();
|
||
AUSP_B.clear_harms_sets();
|
||
|
||
// Спектры вибрации точки A
|
||
let __AUSP_A_tools = gtl.create_spec_tools(
|
||
{
|
||
data: AUSP_A_pl.data,
|
||
df: AUSP_A_pl.resolution,
|
||
base: {
|
||
factor: 100,
|
||
visible: true,
|
||
color: 0x00ff00
|
||
},
|
||
peaks: {
|
||
color: 0xff0000,
|
||
visible: true,
|
||
level: 0.000001
|
||
},
|
||
harms: {
|
||
tolerance: 1
|
||
}
|
||
});
|
||
let __row_AUSP_A = __AUSP_A_tools.harms.add(freq.value, 1, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
|
||
__row_AUSP_A.name = "F1_A (гарм. ряд част. вращ. точки A)"; // название гармонического ряда
|
||
// __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)
|
||
|
||
let __pfc_A_tools = gtl.create_spec_tools(
|
||
{
|
||
data: pfc_A_pl.data,
|
||
df: pfc_A_pl.resolution,
|
||
base: {
|
||
factor: 100,
|
||
visible: true,
|
||
color: 0x0000ff
|
||
},
|
||
peaks: {
|
||
color: 0xff0000,
|
||
visible: true,
|
||
level: 0.000001
|
||
},
|
||
harms: {
|
||
tolerance: 1
|
||
}
|
||
});
|
||
let __row_phase_A = __pfc_A_tools.harms.add(freq.value, 1, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес)
|
||
__row_phase_A.name = "F1_A_phase (гарм. ряд част. вращ. точки A)"; // название гармонического ряда
|
||
|
||
// Спектры вибрации точки B
|
||
let __AUSP_B_tools = gtl.create_spec_tools(
|
||
{
|
||
data: AUSP_B_pl.data,
|
||
df: AUSP_B_pl.resolution,
|
||
base: {
|
||
factor: 100,
|
||
visible: true,
|
||
color: 0x00ff00
|
||
},
|
||
peaks: {
|
||
color: 0xff0000,
|
||
visible: true,
|
||
level: 0.000001
|
||
},
|
||
harms: {
|
||
tolerance: 1
|
||
}
|
||
});
|
||
let __row_AUSP_B = __AUSP_B_tools.harms.add(freq.value, 1, 0x0000ff, 1); // добавление набора гармоник (частота, количество, цвет, вес)
|
||
__row_AUSP_B.name = "F1_B (гарм. ряд част. вращ. точки B)"; // название гармонического ряда
|
||
// __row1.modulate(5, 2, 0x00ff00, 1); // добавление амплитудной модуляции для набора гармоник (частота, количество, цвет, вес)
|
||
|
||
let __pfc_B_tools = gtl.create_spec_tools(
|
||
{
|
||
data: pfc_B_pl.data,
|
||
df: pfc_B_pl.resolution,
|
||
base: {
|
||
factor: 100,
|
||
visible: true,
|
||
color: 0x0000ff
|
||
},
|
||
peaks: {
|
||
color: 0xff0000,
|
||
visible: true,
|
||
level: 0.000001
|
||
},
|
||
harms: {
|
||
tolerance: 1
|
||
}
|
||
});
|
||
let __row_phase_B = __pfc_B_tools.harms.add(freq.value, 1, 0x00ff00, 1); // добавление набора гармоник (частота, количество, цвет, вес)
|
||
__row_phase_B.name = "F1_B_phase (гарм. ряд част. вращ. точки B)"; // название гармонического ряда
|
||
|
||
|
||
|
||
// Построение графиков
|
||
// Вибрация точки A
|
||
plot_ausp.add(
|
||
{
|
||
color: 0x0000ff,
|
||
name: "Спектр вибрации точки A",
|
||
x: AUSP_A_pl.resolution,
|
||
y: AUSP_A_pl.data,
|
||
spec_tools: __AUSP_A_tools.to_json()
|
||
});
|
||
plot_pfc.add(
|
||
{
|
||
color: 0xff0000,
|
||
name: "ФЧХ вибрации точки A",
|
||
x: pfc_A_pl.resolution,
|
||
y: pfc_A_pl.data,
|
||
spec_tools: __pfc_A_tools.to_json()
|
||
});
|
||
let __result1_A = __AUSP_A_tools.to_json();
|
||
let __result2_A = __pfc_A_tools.to_json();
|
||
// Амплитуда гармонического ряда частоты вращения
|
||
var F1_1_a_A = __result1_A.harms.rows[0].harms[0].ampl;
|
||
// Частота гармонического ряда частоты вращения
|
||
var F1_1_f_A = __result1_A.harms.rows[0].harms[0].freq;
|
||
// Фаза (амплитуда) гармонического ряда частоты вращения
|
||
var F1_1_ph_A = __result2_A.harms.rows[0].harms[0].ampl;
|
||
|
||
// Вибрация точки B
|
||
plot_ausp.add(
|
||
{
|
||
color: 0x0000ff,
|
||
name: "Спектр вибрации точки B",
|
||
x: AUSP_B_pl.resolution,
|
||
y: AUSP_B_pl.data,
|
||
spec_tools: __AUSP_B_tools.to_json()
|
||
});
|
||
plot_pfc.add(
|
||
{
|
||
color: 0xff0000,
|
||
name: "ФЧХ вибрации точки B",
|
||
x: pfc_B_pl.resolution,
|
||
y: pfc_B_pl.data,
|
||
spec_tools: __pfc_B_tools.to_json()
|
||
});
|
||
let __result1_B = __AUSP_B_tools.to_json();
|
||
let __result2_B = __pfc_B_tools.to_json();
|
||
// Амплитуда гармонического ряда частоты вращения
|
||
var F1_1_a_B = __result1_B.harms.rows[0].harms[0].ampl;
|
||
// Частота гармонического ряда частоты вращения
|
||
var F1_1_f_B = __result1_B.harms.rows[0].harms[0].freq;
|
||
// Фаза (амплитуда) гармонического ряда частоты вращения
|
||
var F1_1_ph_B = __result2_B.harms.rows[0].harms[0].ampl;
|
||
|
||
|
||
// Проверка наличия оборотной гармоники и необходимости проведения баалнсировки
|
||
var test_balance = ""; // переменная для текста о необходимости проведения балансировки
|
||
if (F1_1_a_A >= RMS_A * 0.4 || F1_1_a_B >= RMS_B * 0.4) // вклад оборотной гармоники в СКЗ
|
||
{test_balance = "необходимо провести балансировку";}
|
||
else {test_balance = "проведение балансировки не требуется или нецелесообразно";}
|
||
|
||
|
||
// РАСЧЁТЫ (балансировочный калькулятор)
|
||
// ШАГ 3 - контрольный пуск:
|
||
// измерение вибрации A3 и B3 после установки баалнсировочных грузов
|
||
// определение целесообразности проведения добалансировки
|
||
// из предыдущих шагов переносятся: амплитуда и фаза вибрации A0, B0
|
||
// построение графиков A0, A3 и dA3, B0, B3 и dB3
|
||
|
||
|
||
// Определение конечных значений переменных
|
||
// A3 вибрация после установки балансировочного груза в плоскость 1
|
||
if (A3_ != 0) {A3 = A3_} // принимает значение из опций
|
||
else {A3 = F1_1_a_A} // принимает значение из спектра сигнала
|
||
if (A3_phase_ != 0) {A3_phase = A3_phase_} // принимает значение из опций
|
||
else {A3_phase = F1_1_ph_A} // принимает значение из спектра сигнала
|
||
|
||
// B3 вибрация после установки балансировочного груза в плоскость 2
|
||
if (B3_ != 0) {B3 = B3_} // принимает значение из опций
|
||
else {B3 = F1_1_a_B} // принимает значение из спектра сигнала
|
||
if (B3_phase_ != 0) {B3_phase = B3_phase_} // принимает значение из опций
|
||
else {B3_phase = F1_1_ph_B} // принимает значение из спектра сигнала
|
||
|
||
|
||
// определение угла наклона вектора A0 к осям X и Y
|
||
if (A0_phase <= 90) {
|
||
A0_phase_X = 90 - A0_phase}
|
||
if (A0_phase <= 180) {
|
||
A0_phase_X = A0_phase - 90}
|
||
if (A0_phase <= 270) {
|
||
A0_phase_X = 270 - A0_phase}
|
||
if (A0_phase <= 360) {
|
||
A0_phase_X = A0_phase - 270}
|
||
if (A0_phase <= 90) {
|
||
A0_phase_Y = A0_phase}
|
||
if (A0_phase <= 180) {
|
||
A0_phase_Y = 180 - A0_phase}
|
||
if (A0_phase <= 270) {
|
||
A0_phase_Y = A0_phase - 180}
|
||
if (A0_phase <= 360) {
|
||
A0_phase_Y = 360 - A0_phase}
|
||
// определение координат вектора A0
|
||
var xA0_array = []; // массив координат точек вектора A0 по оси X
|
||
var yA0_array = []; // массив координат точек вектора A0 по оси Y
|
||
A0_1_X = 0;
|
||
if (A0_phase <= 180) {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0
|
||
} else {A0_2_X = Math.abs(Math.cos(A0_phase_X * 3.1415/180)) * A0 * (-1)}
|
||
A0_1_Y = 0;
|
||
if (A0_phase <= 90 || A0_phase >= 270) {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0
|
||
} else {A0_2_Y = Math.abs(Math.cos(A0_phase_Y * 3.1415/180)) * A0 * (-1)}
|
||
xA0_array[0] = A0_1_X;
|
||
xA0_array[1] = A0_2_X;
|
||
yA0_array[0] = A0_1_Y;
|
||
yA0_array[1] = A0_2_Y;
|
||
|
||
// определение угла наклона вектора A3 к осям X и Y
|
||
if (A3_phase <= 90) {
|
||
A3_phase_X = 90 - A3_phase}
|
||
if (A3_phase <= 180) {
|
||
A3_phase_X = A3_phase - 90}
|
||
if (A3_phase <= 270) {
|
||
A3_phase_X = 270 - A3_phase}
|
||
if (A3_phase <= 360) {
|
||
A3_phase_X = A3_phase - 270}
|
||
if (A3_phase <= 90) {
|
||
A3_phase_Y = A3_phase}
|
||
if (A3_phase <= 180) {
|
||
A3_phase_Y = 180 - A3_phase}
|
||
if (A3_phase <= 270) {
|
||
A3_phase_Y = A3_phase - 180}
|
||
if (A3_phase <= 360) {
|
||
A3_phase_Y = 360 - A3_phase}
|
||
// определение координат вектора A3
|
||
var xA3_array = []; // массив координат точек вектора A3 по оси X
|
||
var yA3_array = []; // массив координат точек вектора A3 по оси Y
|
||
A3_1_X = 0;
|
||
if (A3_phase <= 180) {A3_2_X = Math.abs(Math.cos(A3_phase_X * 3.1415/180)) * A3
|
||
} else {A3_2_X = Math.abs(Math.cos(A3_phase_X * 3.1415/180)) * A3 * (-1)}
|
||
A3_1_Y = 0;
|
||
if (A3_phase <= 90 || A3_phase >= 270) {A3_2_Y = Math.abs(Math.cos(A3_phase_Y * 3.1415/180)) * A3
|
||
} else {A3_2_Y = Math.abs(Math.cos(A3_phase_Y * 3.1415/180)) * A3 * (-1)}
|
||
xA3_array[0] = A3_1_X;
|
||
xA3_array[1] = A3_2_X;
|
||
yA3_array[0] = A3_1_Y;
|
||
yA3_array[1] = A3_2_Y;
|
||
|
||
// определение модуля вектора dA3
|
||
var xdA3_array = []; // массив координат точек вектора dA3 по оси X
|
||
var ydA3_array = []; // массив координат точек вектора dA3 по оси Y
|
||
dA3_1_X = A0_2_X;
|
||
dA3_2_X = A3_2_X;
|
||
dA3_1_Y = A0_2_Y;
|
||
dA3_2_Y = A3_2_Y;
|
||
dA3 = Math.sqrt(Math.pow(dA3_2_X - dA3_1_X, 2) + Math.pow(dA3_2_Y - dA3_1_Y, 2))
|
||
xdA3_array[0] = dA3_1_X;
|
||
xdA3_array[1] = dA3_2_X;
|
||
ydA3_array[0] = dA3_1_Y;
|
||
ydA3_array[1] = dA3_2_Y;
|
||
// определение фазы вектора dA3
|
||
if ((dA3_2_Y < dA3_1_Y) && (dA3_2_X < dA3_1_X)) {
|
||
dA3_phase = 180 + (((Math.acos((Math.abs(dA3_2_Y - dA3_1_Y)) / dA3)) * 180 ) / 3.1415)}
|
||
if ((dA3_2_Y > dA3_1_Y) && (dA3_2_X > dA3_1_X)) {
|
||
dA3_phase = (((Math.acos((Math.abs(dA3_2_Y - dA3_1_Y)) / dA3)) * 180 ) / 3.1415)}
|
||
if ((dA3_2_Y > dA3_1_Y) && (dA3_2_X < dA3_1_X)) {
|
||
dA3_phase = 360 - (((Math.acos((Math.abs(dA3_2_Y - dA3_1_Y)) / dA3)) * 180 ) / 3.1415)}
|
||
if ((dA3_2_Y < dA3_1_Y) && (dA3_2_X > dA3_1_X)) {
|
||
dA3_phase = 180 - (((Math.acos((Math.abs(dA3_2_Y - dA3_1_Y)) / dA3)) * 180 ) / 3.1415)}
|
||
if (dA3_phase > 360) {dA3_phase = dA3_phase - 360}
|
||
|
||
// определение угла наклона вектора B0 к осям X и Y
|
||
if (B0_phase <= 90) {
|
||
B0_phase_X = 90 - B0_phase}
|
||
if (B0_phase <= 180) {
|
||
B0_phase_X = B0_phase - 90}
|
||
if (B0_phase <= 270) {
|
||
B0_phase_X = 270 - B0_phase}
|
||
if (B0_phase <= 360) {
|
||
B0_phase_X = B0_phase - 270}
|
||
if (B0_phase <= 90) {
|
||
B0_phase_Y = B0_phase}
|
||
if (B0_phase <= 180) {
|
||
B0_phase_Y = 180 - B0_phase}
|
||
if (B0_phase <= 270) {
|
||
B0_phase_Y = B0_phase - 180}
|
||
if (B0_phase <= 360) {
|
||
B0_phase_Y = 360 - B0_phase}
|
||
// определение координат вектора B0
|
||
var xB0_array = []; // массив координат точек вектора B0 по оси X
|
||
var yB0_array = []; // массив координат точек вектора B0 по оси Y
|
||
B0_1_X = 0;
|
||
if (B0_phase <= 180) {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0
|
||
} else {B0_2_X = Math.abs(Math.cos(B0_phase_X * 3.1415/180)) * B0 * (-1)}
|
||
B0_1_Y = 0;
|
||
if (B0_phase <= 90 || B0_phase >= 270) {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0
|
||
} else {B0_2_Y = Math.abs(Math.cos(B0_phase_Y * 3.1415/180)) * B0 * (-1)}
|
||
xB0_array[0] = B0_1_X;
|
||
xB0_array[1] = B0_2_X;
|
||
yB0_array[0] = B0_1_Y;
|
||
yB0_array[1] = B0_2_Y;
|
||
|
||
// определение угла наклона вектора B3 к осям X и Y
|
||
if (B3_phase <= 90) {
|
||
B3_phase_X = 90 - B3_phase}
|
||
if (B3_phase <= 180) {
|
||
B3_phase_X = B3_phase - 90}
|
||
if (B3_phase <= 270) {
|
||
B3_phase_X = 270 - B3_phase}
|
||
if (B3_phase <= 360) {
|
||
B3_phase_X = B3_phase - 270}
|
||
if (B3_phase <= 90) {
|
||
B3_phase_Y = B3_phase}
|
||
if (B3_phase <= 180) {
|
||
B3_phase_Y = 180 - B3_phase}
|
||
if (B3_phase <= 270) {
|
||
B3_phase_Y = B3_phase - 180}
|
||
if (B3_phase <= 360) {
|
||
B3_phase_Y = 360 - B3_phase}
|
||
// определение координат вектора B3
|
||
var xB3_array = []; // массив координат точек вектора B3 по оси X
|
||
var yB3_array = []; // массив координат точек вектора B3 по оси Y
|
||
B3_1_X = 0;
|
||
if (B3_phase <= 180) {B3_2_X = Math.abs(Math.cos(B3_phase_X * 3.1415/180)) * B3
|
||
} else {B3_2_X = Math.abs(Math.cos(B3_phase_X * 3.1415/180)) * B3 * (-1)}
|
||
B3_1_Y = 0;
|
||
if (B3_phase <= 90 || B3_phase >= 270) {B3_2_Y = Math.abs(Math.cos(B3_phase_Y * 3.1415/180)) * B3
|
||
} else {B3_2_Y = Math.abs(Math.cos(B3_phase_Y * 3.1415/180)) * B3 * (-1)}
|
||
xB3_array[0] = B3_1_X;
|
||
xB3_array[1] = B3_2_X;
|
||
yB3_array[0] = B3_1_Y;
|
||
yB3_array[1] = B3_2_Y;
|
||
|
||
// определение модуля вектора dB3
|
||
var xdB3_array = []; // массив координат точек вектора dB3 по оси X
|
||
var ydB3_array = []; // массив координат точек вектора dB3 по оси Y
|
||
dB3_1_X = B0_2_X;
|
||
dB3_2_X = B3_2_X;
|
||
dB3_1_Y = B0_2_Y;
|
||
dB3_2_Y = B3_2_Y;
|
||
dB3 = Math.sqrt(Math.pow(dB3_2_X - dB3_1_X, 2) + Math.pow(dB3_2_Y - dB3_1_Y, 2))
|
||
xdB3_array[0] = dB3_1_X;
|
||
xdB3_array[1] = dB3_2_X;
|
||
ydB3_array[0] = dB3_1_Y;
|
||
ydB3_array[1] = dB3_2_Y;
|
||
// определение фазы вектора dB3
|
||
if ((dB3_2_Y < dB3_1_Y) && (dB3_2_X < dB3_1_X)) {
|
||
dB3_phase = 180 + (((Math.acos((Math.abs(dB3_2_Y - dB3_1_Y)) / dB3)) * 180 ) / 3.1415)}
|
||
if ((dB3_2_Y > dB3_1_Y) && (dB3_2_X > dB3_1_X)) {
|
||
dB3_phase = (((Math.acos((Math.abs(dB3_2_Y - dB3_1_Y)) / dB3)) * 180 ) / 3.1415)}
|
||
if ((dB3_2_Y > dB3_1_Y) && (dB3_2_X < dB3_1_X)) {
|
||
dB3_phase = 360 - (((Math.acos((Math.abs(dB3_2_Y - dB3_1_Y)) / dB3)) * 180 ) / 3.1415)}
|
||
if ((dB3_2_Y < dB3_1_Y) && (dB3_2_X > dB3_1_X)) {
|
||
dB3_phase = 180 - (((Math.acos((Math.abs(dB3_2_Y - dB3_1_Y)) / dB3)) * 180 ) / 3.1415)}
|
||
if (dB3_phase > 360) {dB3_phase = dB3_phase - 360}
|
||
|
||
|
||
// определение координат точек окружности графика для отображения векторов вибрации
|
||
var xV_array = []; // массив координат точек окружности V по оси X
|
||
var yV_array = []; // массив координат точек окружности V по оси Y
|
||
var x0V = 0; // центр в начале координат
|
||
var y0V = 0; // центр в начале координат
|
||
for (let i=0; i<=359; i++ ) {
|
||
xV_array.push(x0V + (Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.1) * (Math.sin((i) * Math.PI / 180)));
|
||
yV_array.push(y0V + (Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.1) * (Math.cos((i) * Math.PI / 180)));}
|
||
|
||
|
||
// Графики вибрации
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x0000ff,
|
||
name: "Вибрация_A0",
|
||
x: xA0_array,
|
||
y: yA0_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x00ff00,
|
||
name: "Вибрация_A3",
|
||
x: xA3_array,
|
||
y: yA3_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0xff0000,
|
||
name: "Вибрация_dA3",
|
||
x: xdA3_array,
|
||
y: ydA3_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x0000ff,
|
||
name: "Вибрация_B0",
|
||
x: xB0_array,
|
||
y: yB0_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x00ff00,
|
||
name: "Вибрация_B3",
|
||
x: xB3_array,
|
||
y: yB3_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0xff0000,
|
||
name: "Вибрация_dB3",
|
||
x: xdB3_array,
|
||
y: ydB3_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x00ffffff,
|
||
name: "График векторов вибрации",
|
||
x: xV_array,
|
||
y: yV_array,
|
||
});
|
||
plot_vibr.add(
|
||
{
|
||
color: 0x00ffffff,
|
||
name: "границы",
|
||
x: [-(Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), -(Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), (Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), (Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2)],
|
||
y: [(Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), -(Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), -(Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2), (Math.max(A0,A3,dA3,B0,B3,dB3)+Math.max(A0,A3,dA3,B0,B3,dB3)*0.2)]
|
||
});
|
||
|
||
|
||
gtl.log.info("RMS_A",RMS_A.value);
|
||
gtl.log.info("A0",A0);
|
||
gtl.log.info("A0_phase",A0_phase);
|
||
gtl.log.info("A3",A3);
|
||
gtl.log.info("A3_phase",A3_phase);
|
||
gtl.log.info("F1_1_ph_A (фаза)",F1_1_ph_A);
|
||
gtl.log.info("F1_1_a_A (ампл)",F1_1_a_A);
|
||
gtl.log.info("F1_1_f_A (част)",F1_1_f_A);
|
||
gtl.log.info("RMS_B",RMS_B.value);
|
||
gtl.log.info("B0",B0);
|
||
gtl.log.info("B0_phase",B0_phase);
|
||
gtl.log.info("B3",B3);
|
||
gtl.log.info("B3_phase",B3_phase);
|
||
gtl.log.info("F1_1_ph_B (фаза)",F1_1_ph_B);
|
||
gtl.log.info("F1_1_a_B (ампл)",F1_1_a_B);
|
||
gtl.log.info("F1_1_f_B (част)",F1_1_f_B);
|
||
gtl.log.info("Частота вращения, Гц", freq.value);
|
||
gtl.log.info("Нестабильность частоты вращения, %", instability*100);
|
||
gtl.log.info("Необходимость проведения балансировки",test_balance);
|
||
|
||
|
||
// Выдача результата (results)
|
||
let __result = {
|
||
|
||
_001_Ампл_гарм_1F1_A: F1_1_a_A,
|
||
_002_Фаза_част_вращ_F1_A: F1_1_ph_A,
|
||
_003_Ампл_вибр_пуска_A0: A0,
|
||
_004_Фаза_вибр_пуска_A0: A0_phase,
|
||
_005_Ампл_вибр_пуска_A3: A3,
|
||
_006_Фаза_вибр_пуска_A3: A3_phase,
|
||
_007_СКЗ_вибр_A: RMS_A.value,
|
||
|
||
_008_Ампл_гарм_1F1_B: F1_1_a_B,
|
||
_009_Фаза_част_вращ_F1_B: F1_1_ph_B,
|
||
_010_Ампл_вибр_пуска_B0: B0,
|
||
_011_Фаза_вибр_пуска_B0: B0_phase,
|
||
_012_Ампл_вибр_пуска_B3: B3,
|
||
_013_Фаза_вибр_пуска_B3: B3_phase,
|
||
_014_СКЗ_вибр_B: RMS_B.value,
|
||
|
||
_015_Частота_вращения_F1: freq.value,
|
||
_016_Нестаб_част_вращ: instability*100,
|
||
_017_Тестирование: test_balance,
|
||
};
|
||
|
||
gtl.results = {"result": __result};
|
||
|
||
gtl.diagnostic.stop();
|
||
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
} |