add new classes
parent
5c1bd9012a
commit
15acd446d8
|
|
@ -0,0 +1,146 @@
|
||||||
|
"use strict";
|
||||||
|
var signals = gtl.options.record.signalsModel;
|
||||||
|
var options = gtl.options;
|
||||||
|
var record = gtl.options.record;
|
||||||
|
var point = gtl.options.point;
|
||||||
|
|
||||||
|
var fnc = gtl.import("userFunctions.js");
|
||||||
|
var msk = gtl.import("maskVM.js");
|
||||||
|
let maskClass = gtl.import("maskClass.js").maskClass;
|
||||||
|
|
||||||
|
var __frq = fnc.getFreq(
|
||||||
|
/*{
|
||||||
|
src: gtl.analog_inputs[signals[0].portNumber], //источник сигнала частоты вращения
|
||||||
|
freq: 10, //граничная частота фильтрации сигнала
|
||||||
|
time: 1, //интервал измерения частоты вращения
|
||||||
|
avg: 4, //количество отсчетов для усреднения
|
||||||
|
dc: -0.05 //порог срабатывания счетчика
|
||||||
|
}*/
|
||||||
|
).value; //получаем частоту вращения
|
||||||
|
|
||||||
|
let canvas0 = gtl.plots.add("Мониторинговый спектр");
|
||||||
|
let canvas1 = gtl.plots.add("Спектр вибраци");
|
||||||
|
let canvas2 = gtl.plots.add("Спектр огибающей");
|
||||||
|
|
||||||
|
var ausp2 = fnc.getAusp(
|
||||||
|
{
|
||||||
|
src: gtl.analog_inputs[signals[0].portNumber], //источник сигнала
|
||||||
|
name: "AUSPm", //имя спектра
|
||||||
|
color: 0x001E90FF, //цвет в формате HEX
|
||||||
|
frequency: 25600, //граничная частота
|
||||||
|
resolution: 16, //частотное разрешение
|
||||||
|
average: 6, //количество усреднений
|
||||||
|
view: gtl.spec.db, //единицы отображения (дБ)
|
||||||
|
}
|
||||||
|
); //мониторинговый спектр
|
||||||
|
|
||||||
|
var ausp = fnc.getAusp(
|
||||||
|
{
|
||||||
|
src: gtl.analog_inputs[signals[0].portNumber], //источник сигнала
|
||||||
|
name: "AUSPd", //имя спектра
|
||||||
|
color: 0x0000FF00, //цвет в формате HEX
|
||||||
|
frequency: 800, //граничная частота
|
||||||
|
resolution: 1, //частотное разрешение
|
||||||
|
average: 6, //количество усреднений
|
||||||
|
view: gtl.spec.db, //единицы отображения (дБ)
|
||||||
|
level: 20 //уровень обнаружения гармоник
|
||||||
|
}
|
||||||
|
); //диагностический спектр вибрации
|
||||||
|
|
||||||
|
//фильтр для формирования спектра огибающей
|
||||||
|
var filter_spen = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]); //назначение переменной фильтра
|
||||||
|
filter_spen.kind = gtl.filter_iir.butterworth; //тип окна
|
||||||
|
filter_spen.type = gtl.filter_iir.bandpass; //тип фильтра (полосовой)
|
||||||
|
filter_spen.order = 10; //порядок фильтра
|
||||||
|
filter_spen.frequency = 6400; //центральная частота полосового фильтра
|
||||||
|
filter_spen.width = 1482; //ширина полосы фильтра
|
||||||
|
|
||||||
|
var spen = fnc.getSpen(
|
||||||
|
{
|
||||||
|
src: filter_spen, //источник сигнала
|
||||||
|
name: "SPEN", //имя спектра
|
||||||
|
color: 0x00ff0000, //цвет в формате HEX
|
||||||
|
frequency: 200, //граничная частота
|
||||||
|
resolution: 0.25, //частотное разрешение
|
||||||
|
average: 8, //количество усреднений
|
||||||
|
view: gtl.spec.db, //единицы отображения (дБ)
|
||||||
|
level: 10 //уровень обнаружения гармоник
|
||||||
|
}
|
||||||
|
); //спектр огибающей
|
||||||
|
|
||||||
|
//[Диагностика]
|
||||||
|
gtl.diagnostic.interval = gtl.acq_time;
|
||||||
|
let __result = {}; //объект для формирования результата
|
||||||
|
|
||||||
|
function diagnose() {
|
||||||
|
|
||||||
|
var __set = {
|
||||||
|
"Износ наружного кольца": [0x42AAFF, fnc.BPFO(__frq), 6, 13, 0, 0.3],
|
||||||
|
"Перекос наружного кольца": [0x4285B4, fnc.BPFO(__frq), 4, 12, 1, 0.1],
|
||||||
|
"Дефект наружного кольца": [0x6A5ACD, fnc.BPFO(__frq), 6, 13, 0, 0.07],
|
||||||
|
"Износ внутреннего кольца": [0x89AC76, fnc.FREQ(__frq), 6, 13, 0, 0.3],
|
||||||
|
"Перекос внутреннего кольца": [0x34C924, fnc.FREQ(__frq), 6, 12, 1, 0.1],
|
||||||
|
"Дефект внутреннего кольца": [0x008000, fnc.BPFI(__frq), 6, 8, 0, 0.07],
|
||||||
|
"Дефект тел качения": [0xFFA000, fnc.BSF(__frq), 5, 10, 0, 0.3],
|
||||||
|
"Износ тел качения и сепаратора": [0xFF2400, fnc.FTF(__frq), 4, 6, 0, 0.5]
|
||||||
|
}; //набор портретов предполагаемых дефектов [цвет, частота, кол-во, уровень, тип ряда, коэфф затухания]
|
||||||
|
|
||||||
|
canvas0.add(
|
||||||
|
{
|
||||||
|
color: ausp2.color,
|
||||||
|
name: ausp2.name,
|
||||||
|
x: ausp2.resolution,
|
||||||
|
y: ausp2.data
|
||||||
|
}
|
||||||
|
); //рисуем мониторинговый спектр вибрации на plot
|
||||||
|
|
||||||
|
canvas1.add(
|
||||||
|
{
|
||||||
|
color: ausp.color,
|
||||||
|
name: ausp.name,
|
||||||
|
x: ausp.resolution,
|
||||||
|
y: ausp.data
|
||||||
|
}
|
||||||
|
); //рисуем спектр вибрации на plot*/
|
||||||
|
|
||||||
|
let __spen_tools = fnc.createTools(
|
||||||
|
{
|
||||||
|
spec: spen, //спектр для построения модели (объект)
|
||||||
|
set: __set, //источник данных для построения частотных линий
|
||||||
|
tol: 1 //коридор обнаружения гармоники на портрете, %
|
||||||
|
}
|
||||||
|
); //формируем компоненты и частотные линии на спектре огибающей
|
||||||
|
|
||||||
|
canvas2.add(
|
||||||
|
{
|
||||||
|
color: spen.color,
|
||||||
|
name: spen.name,
|
||||||
|
x: spen.resolution,
|
||||||
|
y: spen.data,
|
||||||
|
spec_tools: __spen_tools.to_json()
|
||||||
|
}
|
||||||
|
); //рисуем спектр огибающей на plot
|
||||||
|
|
||||||
|
let __mask = new maskClass(
|
||||||
|
{
|
||||||
|
spec: spen, //спектр для построения модели (объект)
|
||||||
|
set: __set, //источник данных для построения портретов дефектов
|
||||||
|
filter: filter_spen, //полосовой фильтр (для определения разницы амплитуд гармонической и случайной составляющей)
|
||||||
|
tol: 1, //коридор обнаружения гармоники на портрете, %
|
||||||
|
color: 0xFF0000, //цвет отрисовки модели спектра в формате HEX
|
||||||
|
visible: true //отображение графиков
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
gtl.log.info("FREQ", fnc.FREQ(__frq));
|
||||||
|
gtl.log.info("FTF", fnc.FTF(__frq));
|
||||||
|
gtl.log.info("BPFO", fnc.BPFO(__frq));
|
||||||
|
gtl.log.info("BPFI", fnc.BPFI(__frq));
|
||||||
|
gtl.log.info("BSF", fnc.BSF(__frq));
|
||||||
|
|
||||||
|
__result["Дефекты"] = __mask.getResult(); //обнаруженные дефекты
|
||||||
|
__result["const"] = spen.data[0]; //постоянная составляющая спектра огибающей
|
||||||
|
gtl.results = __result;
|
||||||
|
|
||||||
|
gtl.diagnostic.stop();
|
||||||
|
};
|
||||||
176
maskVM.js
176
maskVM.js
|
|
@ -1,176 +0,0 @@
|
||||||
export function getMask(options) {
|
|
||||||
let __result = {}; //результат
|
|
||||||
let __spec = options.spec; //источник данных для построения модели
|
|
||||||
let __set = options.set; //источник данных для построения портретов дефектов
|
|
||||||
let __rows = Object.keys(__set); //массив ключей объекта (наименование портретов)
|
|
||||||
|
|
||||||
let __model = specModel(
|
|
||||||
{
|
|
||||||
src: __spec, //спектр для построения модели (объект)
|
|
||||||
tol: options.tol, //коридор обнаружения гармоники, %
|
|
||||||
color: options.color, //цвет модели в формате HEX
|
|
||||||
canvas: options.canvas //координатная плоскость для отрисовки
|
|
||||||
}
|
|
||||||
); //рисуем упрощенную модель спектра огибающей
|
|
||||||
|
|
||||||
for (let i = 0; i < __rows.length; i++) {
|
|
||||||
let __mask_name = __rows[i]; //имена портретов
|
|
||||||
let __arr = __set[__mask_name]; //массив значений
|
|
||||||
let __mask = createMask(
|
|
||||||
{
|
|
||||||
name: __mask_name, //имя маски дефекта
|
|
||||||
src1: __model, //модель спектра для анализа (объект)
|
|
||||||
src2: __spec, //базовый спектр для построения портрета (объект)
|
|
||||||
filter: options.filter, //полосовой фильтр (для определения разницы амплитуд гармонической и случайной составляющей)
|
|
||||||
color: __arr[0], //цвет портрета в формате HEX
|
|
||||||
freq: __arr[1], //функциональная частота, Гц
|
|
||||||
harms: __arr[2], //кол-во гармоник в портрете, шт
|
|
||||||
lvl: __arr[3], //глубина модуляции сильного дефекта для портрета, %
|
|
||||||
tol: options.tol, //коридор обнаружения гармоники на портрете, %
|
|
||||||
type: __arr[4], //тип портрета (0 - обычный ряд, 1 - четные составляющие)
|
|
||||||
coef: __arr[5], //коэффициент затухания гармоник портрета: дефект (0.05 - 0.10), износ (0.30 - 0.50)
|
|
||||||
canvas: options.canvas //координатная плоскость для отрисовки маски
|
|
||||||
}
|
|
||||||
);
|
|
||||||
if (__mask.corr >= 0.5) { __result[__mask.name] = __mask.corr }; //добавляем данные в результат
|
|
||||||
gtl.log.info("Вероятность: " + __mask.name, __mask.corr); //выводим корреляцию гармоник в лог
|
|
||||||
};
|
|
||||||
|
|
||||||
return __result;
|
|
||||||
}; //оценка состояния методом maskVM
|
|
||||||
|
|
||||||
function specModel(options) {
|
|
||||||
let __result = {}; //результат
|
|
||||||
let __model = options.src.base; //массив точек базовой линии для построения упрощенной модели спектра
|
|
||||||
let imin = 0; //левая граница коридора
|
|
||||||
let imax = 0; //правая граница коридора
|
|
||||||
for (let i = 0; i < options.src.peaks.length; i++) {
|
|
||||||
let freq = options.src.peaks[i].freq; //получаем значение частоты гармоники из массива обнаруженных гармоник
|
|
||||||
let level = options.src.peaks[i].level; //получаем значение уровня гармоники из массива обнаруженных гармоник
|
|
||||||
imin = Math.round((freq - freq * 0.5 * options.tol / 100) / options.src.resolution);
|
|
||||||
imax = Math.round((freq + freq * 0.5 * options.tol / 100) / options.src.resolution);
|
|
||||||
if (imax > options.src.base.length) { imax = options.src.base.length - 1 }; //проверяем выход границы за размер массива
|
|
||||||
for (let j = imin; j <= imax; j++) { __model[j] = options.src.base[j] + level };
|
|
||||||
};
|
|
||||||
|
|
||||||
//формируем результат
|
|
||||||
__result["name"] = options.src.name + "_model";
|
|
||||||
__result["resolution"] = options.src.resolution;
|
|
||||||
__result["data"] = __model;
|
|
||||||
|
|
||||||
//отрисовка графика на plot
|
|
||||||
if (options.canvas != undefined) {
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: options.color,
|
|
||||||
name: __result.name,
|
|
||||||
x: __result.resolution,
|
|
||||||
y: __model
|
|
||||||
}
|
|
||||||
);
|
|
||||||
};
|
|
||||||
|
|
||||||
return __result;
|
|
||||||
}; //построение упрощенной модели спектра
|
|
||||||
|
|
||||||
function createMask(options) {
|
|
||||||
let result = {}; //результат
|
|
||||||
let data = options.src1.data; //массив точек спектра для сравнения с портретом
|
|
||||||
let mask = options.src2.base; //массив точек базовой линии для построения портрета дефекта
|
|
||||||
let harms = options.harms; //кол-во гармоник портрета
|
|
||||||
if (options.freq * harms > options.src2.frequency) { harms = Math.trunc(options.src2.frequency / options.freq) }; //проверяем максимальное кол-во гармоник в портрете
|
|
||||||
let df = 0; //отношение ширины фильтра частотному разрешению спектра
|
|
||||||
let dl = options.lvl; //разность уровней гармонической и случайной составляющей вибрации
|
|
||||||
if (options.filter != 0) {
|
|
||||||
df = options.src2.frequency / options.filter.width;
|
|
||||||
dl = 10 * Math.log10((options.lvl ** 2) / df + 1);
|
|
||||||
};
|
|
||||||
let k = options.coef; //коэффициент затухания
|
|
||||||
let x = 0; //индекс элемента массива для гармоники
|
|
||||||
let dx = 0; //коридор индексов
|
|
||||||
let xmin = 0; //левая граница коридора
|
|
||||||
let xmax = 0; //правая граница коридора
|
|
||||||
let correlation = 0; //коэффициент корреляции
|
|
||||||
|
|
||||||
function corr(a, b) {
|
|
||||||
let X = 0; //аргумент 1
|
|
||||||
let Y = 0; //аргумент 2
|
|
||||||
let Z = 0; //аргумент 3
|
|
||||||
let a_avg = a.reduce((acc, item) => (acc + item)) / a.length; //среднее значение массива 1
|
|
||||||
let b_avg = b.reduce((acc, item) => (acc + item)) / b.length; //среднее значение массива 2
|
|
||||||
|
|
||||||
for (let i = 0; i < a.length; i++) {
|
|
||||||
X += (a[i] - a_avg) * (b[i] - b_avg);
|
|
||||||
Y += (a[i] - a_avg) ** 2;
|
|
||||||
Z += (b[i] - b_avg) ** 2;
|
|
||||||
};
|
|
||||||
|
|
||||||
if (X <= 0) { return 0 } else { return X / (Math.sqrt(Y) * Math.sqrt(Z)) };
|
|
||||||
};
|
|
||||||
|
|
||||||
let arr1 = [];
|
|
||||||
let arr2 = [];
|
|
||||||
switch (options.type) {
|
|
||||||
case 0: //обычный ряд
|
|
||||||
for (let i = 1; i <= harms; i++) {
|
|
||||||
x = Math.trunc(i * options.freq / options.src2.resolution); //определяем инднекс элемента массива для гармоники
|
|
||||||
dx = Math.trunc(i * (options.freq * options.tol / 100) / options.src2.resolution); //коридор индексов массива для гармоники
|
|
||||||
xmin = x - Math.round(dx / 2); //определяем индекс левой границы коридора
|
|
||||||
xmax = x + Math.round(dx / 2); //определяем индекс правой границы коридора
|
|
||||||
|
|
||||||
if (xmax > options.src2.base.length) { xmax = options.src2.base.length - 2 }; //проверяем выход границы за размер массива
|
|
||||||
for (let j = xmin; j <= xmax; j++) { mask[j] = options.src2.base[j] + dl }; //записываем значение глубины модуляции для коридора
|
|
||||||
dl = dl - (k * dl); //снижаем глубину модуляции с коэффициентом затухания
|
|
||||||
|
|
||||||
for (let j = xmin - 2; j <= xmax + 2; j++) {
|
|
||||||
arr1.push(mask[j]);
|
|
||||||
arr2.push(data[j]);
|
|
||||||
}; //формируем массивы портретной гармоники и спектра (модели) под портретом
|
|
||||||
correlation += corr(arr1, arr2); //рассчитываем корреляцию данных из массивов
|
|
||||||
};
|
|
||||||
break;
|
|
||||||
case 1: //четные составляющие
|
|
||||||
for (let i = 1; i <= harms; i++) {
|
|
||||||
x = Math.trunc(i * options.freq / options.src2.resolution); //инднекс элемента массива для гармоники
|
|
||||||
dx = Math.trunc(i * (options.freq * options.tol / 100) / options.src2.resolution); //коридор индексов массива для гармоники
|
|
||||||
xmin = x - Math.round(dx / 2); //определяем индекс левой границы коридора
|
|
||||||
xmax = x + Math.round(dx / 2); //определяем индекс правой границы коридора
|
|
||||||
|
|
||||||
if (xmax > options.src2.base.length) { xmax = options.src2.base.length - 2 }; //проверяем выход границы за размер массива
|
|
||||||
if (i % 2 > 0) {
|
|
||||||
for (let j = xmin; j <= xmax; j++) { mask[j] = options.src2.base[j] + k * dl }; //записываем значение глубины модуляции для коридора (нечетная гармоника)
|
|
||||||
} else {
|
|
||||||
for (let j = xmin; j <= xmax; j++) { mask[j] = options.src2.base[j] + dl }; //записываем значение глубины модуляции для коридора (четная гармоника)
|
|
||||||
dl = dl - (k * dl); //снижаем глубину модуляции с коэффициентом затухания
|
|
||||||
};
|
|
||||||
|
|
||||||
for (let j = xmin - 2; j <= xmax + 2; j++) {
|
|
||||||
arr1.push(mask[j]);
|
|
||||||
arr2.push(data[j]);
|
|
||||||
}; //формируем массивы портретной гармоники и спектра (модели) под портретом
|
|
||||||
correlation += corr(arr1, arr2); //рассчитываем корреляцию данных из массивов
|
|
||||||
};
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
};
|
|
||||||
|
|
||||||
//формируем результат
|
|
||||||
result["name"] = options.name; //имя маски дефекта
|
|
||||||
result["corr"] = correlation / harms; //средняя корреляция
|
|
||||||
result["data"] = mask; //массив данных портрета
|
|
||||||
|
|
||||||
//отрисовка графика на plot
|
|
||||||
if (options.canvas != undefined) {
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: options.color,
|
|
||||||
name: options.name + " (" + result.corr.toFixed(2) + ")",
|
|
||||||
x: options.src2.resolution,
|
|
||||||
y: mask
|
|
||||||
}
|
|
||||||
);
|
|
||||||
};
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}; //построение портрета дефекта
|
|
||||||
83
mtxVM.js
83
mtxVM.js
|
|
@ -1,83 +0,0 @@
|
||||||
export function modFactor(dSpec, dFilter, ampl, base) {
|
|
||||||
let dl = (ampl - base); //разность уровней гармонической и случайной составляющей вибрации
|
|
||||||
let df = dSpec.frequency / dFilter.width; //отношение частотному разрешению спектра к ширине фильтра
|
|
||||||
let mod = Math.sqrt((10 ** (dl / 10) - 1) * df);
|
|
||||||
return mod;
|
|
||||||
}; //определение глубины модуляции ВЧ составляющих
|
|
||||||
|
|
||||||
export function createTools(options) {
|
|
||||||
let __spec = options.spec; //источник данных спектра
|
|
||||||
let __set = {}; //источник данных для построения частотных линий
|
|
||||||
if (options.set != undefined) { __set = options.set };
|
|
||||||
|
|
||||||
let __tools = gtl.create_spec_tools(
|
|
||||||
{
|
|
||||||
data: __spec.data, //массив значений амплитуд спектра
|
|
||||||
df: __spec.resolution, //частотное разрешение спектра
|
|
||||||
base: {
|
|
||||||
factor: 100, //коэффициент сглаживания базовой линии
|
|
||||||
visible: true, //отображение базовой линии
|
|
||||||
color: 0xFFFF00 //цвет базовой линии в формате HEX
|
|
||||||
},
|
|
||||||
peaks: {
|
|
||||||
color: __spec.color, //цвет маркеров обнаруженных гармоник
|
|
||||||
visible: false, //отображение маркеров
|
|
||||||
level: __spec.peak_level //уровень обнаружения гармоник в спектре
|
|
||||||
},
|
|
||||||
harms: {
|
|
||||||
tolerance: options.tol //коридор обнаружения гармоник в спектре
|
|
||||||
}
|
|
||||||
}
|
|
||||||
);
|
|
||||||
|
|
||||||
let __rows = Object.keys(__set); //массив ключей объекта (наименование частот)
|
|
||||||
for (let i = 0; i < __rows.length; i++) {
|
|
||||||
let __name = __rows[i]; //название гармонического ряда
|
|
||||||
let __arr = __set[__name]; //массив значений
|
|
||||||
let __color = __arr[0]; //цвет ряда в формате HEX
|
|
||||||
let __freq = __arr[1]; //расчетная частота
|
|
||||||
let __count = __arr[2]; //количество гармоник
|
|
||||||
let __mod = __arr[3]; //модулирующая частота
|
|
||||||
let __lvl = __arr[4]; //пороговый уровень сильного дефекта
|
|
||||||
|
|
||||||
let __row = __tools.harms.add(
|
|
||||||
{
|
|
||||||
frequency: __freq, //функциональная частота
|
|
||||||
count: __count, //количество гармоник
|
|
||||||
color: __color, //цвет линий
|
|
||||||
weight: 2, //толщина линий
|
|
||||||
visible: false //отображение линий
|
|
||||||
}
|
|
||||||
);
|
|
||||||
__row.name = __name;
|
|
||||||
|
|
||||||
if (options.mod != 0) {
|
|
||||||
__row.modulate(
|
|
||||||
{
|
|
||||||
frequency: __mod, //частота амплитудной модуляции
|
|
||||||
count: 2, //количество боковых составляющих слева и справа
|
|
||||||
color: __color, //цвет линий в формате HEX
|
|
||||||
weight: 0.5 //толщина линий
|
|
||||||
}
|
|
||||||
);
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
return __tools;
|
|
||||||
}; //Построение компонентов и частотных линий на спектре
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -0,0 +1,95 @@
|
||||||
|
"use strict";
|
||||||
|
var signals = gtl.options.record.signalsModel;
|
||||||
|
var options = gtl.options;
|
||||||
|
var record = gtl.options.record;
|
||||||
|
var point = gtl.options.point;
|
||||||
|
|
||||||
|
let __mes = gtl.import("userFunctions.js");
|
||||||
|
let __pvm = gtl.import("peakVM.js");
|
||||||
|
let peakClass = gtl.import("peakClass.js").peakClass;
|
||||||
|
let __corr = gtl.import("corrVM.js");
|
||||||
|
|
||||||
|
|
||||||
|
let __frq = __mes.getFreq(
|
||||||
|
/*{
|
||||||
|
src: gtl.analog_inputs[signals[0].portNumber], //источник сигнала частоты вращения
|
||||||
|
freq: 10, //граничная частота фильтрации сигнала
|
||||||
|
time: 1, //интервал измерения частоты вращения
|
||||||
|
avg: 4, //количество отсчетов для усреднения
|
||||||
|
dc: -0.05 //порог срабатывания счетчика
|
||||||
|
}*/
|
||||||
|
).value; //получаем частоту вращения
|
||||||
|
|
||||||
|
let __sets = __pvm.getParams(__frq); //получаем настройки парметров ФВЧ и спектра
|
||||||
|
|
||||||
|
//фильтр для формирования пиковой формы сигнала
|
||||||
|
let __fltr = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
|
||||||
|
__fltr.kind = gtl.filter_iir.butterworth; //тип окна
|
||||||
|
__fltr.type = gtl.filter_iir.highpass; //тип фильтра (ФНЧ)
|
||||||
|
__fltr.order = 10; //порядок фильтра
|
||||||
|
__fltr.frequency = __sets.filter.frequency; //граничная частота фильтра
|
||||||
|
|
||||||
|
//формирование амплитуд для построения пиковой формы сигнала
|
||||||
|
let __ampl = gtl.add_value_peak_to_peak(__fltr);//gtl.add_value_ampl(__fltr);
|
||||||
|
__ampl.name = "Пиковая форма";
|
||||||
|
__ampl.color = 0x2B6CC4;
|
||||||
|
__ampl.time = 0.001; //время выборки
|
||||||
|
__ampl.avg_cnt = 7700; //количество отсчетов
|
||||||
|
|
||||||
|
let __max = gtl.create_moving_peak_to_peak(
|
||||||
|
{
|
||||||
|
src: __fltr,
|
||||||
|
name: "max",
|
||||||
|
time: 0.001
|
||||||
|
}
|
||||||
|
); //формируем сигнал максимальных амплитуд для построения спектра
|
||||||
|
|
||||||
|
let ausp = __mes.getAusp(
|
||||||
|
{
|
||||||
|
src: __max, //источник сигнала
|
||||||
|
name: "Спектр пиковой формы", //имя спектра
|
||||||
|
color: 0xF34723, //цвет в формате HEX
|
||||||
|
frequency: __sets.spec.frequency, //граничная частота
|
||||||
|
resolution: __sets.spec.resolution, //частотное разрешение
|
||||||
|
average: __sets.spec.avg, //количество усреднений
|
||||||
|
view: gtl.spec.unit, //единицы отображения (дБ)
|
||||||
|
level: 0.002 //уровень обнаружения гармоник
|
||||||
|
}
|
||||||
|
); //вычисляем спектр пиковой формы
|
||||||
|
|
||||||
|
let __plots = gtl.plots.add("Spectral");
|
||||||
|
|
||||||
|
//[Диагностика]
|
||||||
|
gtl.diagnostic.interval = gtl.acq_time;
|
||||||
|
function diagnose() {
|
||||||
|
|
||||||
|
let __peak = new peakClass(
|
||||||
|
{
|
||||||
|
src: __ampl, //объект с массивом данных пиковой формы
|
||||||
|
freq: __frq, //частота вращения, Гц
|
||||||
|
spec: ausp, //спектр пиковой формы
|
||||||
|
visible: false, //отображение графиков
|
||||||
|
}
|
||||||
|
)
|
||||||
|
|
||||||
|
let __ausp_tools = __mes.createTools(
|
||||||
|
{
|
||||||
|
spec: ausp, //спектр для построения модели (объект)
|
||||||
|
//set: __set, //источник данных для построения частотных линий
|
||||||
|
tol: 1 //коридор обнаружения гармоники на портрете, %
|
||||||
|
}
|
||||||
|
); //формируем компоненты и частотные линии на спектре
|
||||||
|
|
||||||
|
__plots.add(
|
||||||
|
{
|
||||||
|
color: ausp.color,
|
||||||
|
name: ausp.name,
|
||||||
|
x: ausp.resolution,
|
||||||
|
y: ausp.data,
|
||||||
|
spec_tools: __ausp_tools.to_json()
|
||||||
|
}
|
||||||
|
); //рисуем спектр пиковой формы
|
||||||
|
|
||||||
|
gtl.results = __peak.getResult();
|
||||||
|
gtl.diagnostic.stop();
|
||||||
|
};
|
||||||
261
peakVM.js
261
peakVM.js
|
|
@ -1,261 +0,0 @@
|
||||||
export function getPeak(options) {
|
|
||||||
let __result = {}; //результат
|
|
||||||
let __wav = options.src; //массив данных пиковой формы
|
|
||||||
let __freq = options.freq; //частота вращения
|
|
||||||
let __mech = 0; //механические проблемы
|
|
||||||
let __lubr = 0; //проблемы со смазкой
|
|
||||||
let __allert = getLevels(__freq); //определяем уровень предупреждения, g
|
|
||||||
|
|
||||||
let __form = getWave(
|
|
||||||
{
|
|
||||||
src: __wav, //объект с данными максимальных амплитуд
|
|
||||||
lvl: __allert, //пороговый уровень предупреждения, g
|
|
||||||
canvas: options.canvas1 //координатная плоскость для отрисовки графика
|
|
||||||
}
|
|
||||||
); //получаем пиковую форму сигнала с порогами
|
|
||||||
|
|
||||||
let __crr = getAutoCorr(
|
|
||||||
{
|
|
||||||
name: "Корреляционная функция", //имя для графика
|
|
||||||
src: __wav, //объект с данными максимальных амплитуд
|
|
||||||
lag: 0.5, //коэффициент смещения сигнала
|
|
||||||
color: 0x00A550, //цвет отрисовки графика в формате HEX
|
|
||||||
canvas: options.canvas2 //координатная плоскость для отрисовки графика
|
|
||||||
}
|
|
||||||
); //вычисляем автокорреляционную функцию
|
|
||||||
|
|
||||||
let MaxPK = Math.max(...__wav.values); //максимальное значение амплитуды на пиковой форме, g
|
|
||||||
let FaultLevel = 2 * __allert; //уровень аварии для пиковой формы (Fault = 2 * Allert)
|
|
||||||
let EstPE = Math.sqrt(__crr.ampl) * 100; //расчетный процент периодической энергии
|
|
||||||
|
|
||||||
if (options.spec != undefined) {
|
|
||||||
let __spc = options.spec; //объект спектра пиковой формы
|
|
||||||
let GS = MaxPK / FaultLevel; //общая серьезность проблемы
|
|
||||||
let SQpeak = specSquare(__spc).peak; //площадь обнаруженных гармонических составляющих
|
|
||||||
let SQspec = specSquare(__spc).harm; //площадь над базовой линией
|
|
||||||
let PE = (SQpeak ** 2 / SQspec ** 2); //доля периодической энергии
|
|
||||||
let NPE = (SQspec ** 2 - SQpeak ** 2) / SQspec ** 2; //доля непериодической энергии
|
|
||||||
|
|
||||||
__mech = GS * PE * 100;
|
|
||||||
__lubr = GS * NPE * 100;
|
|
||||||
|
|
||||||
__result = {
|
|
||||||
mechBS: __mech,
|
|
||||||
lubrBS: __lubr,
|
|
||||||
//mechInd: __mech * 0.8, //нормализованное значение (для индикатора 0-100 единиц)
|
|
||||||
//lubrInd: __lubr * 0.8 //нормализованное значение (для индикатора 0-100 единиц)
|
|
||||||
};
|
|
||||||
} else {
|
|
||||||
switch (true) {
|
|
||||||
case EstPE >= 50:
|
|
||||||
__mech = EstPE * MaxPK / FaultLevel;
|
|
||||||
__lubr = (100 - EstPE) * MaxPK / FaultLevel;
|
|
||||||
break;
|
|
||||||
case (EstPE <= 50) && (EstPE > 30):
|
|
||||||
EstPE = EstPE / 2;
|
|
||||||
__mech = EstPE * MaxPK / FaultLevel;
|
|
||||||
__lubr = (100 - EstPE) * MaxPK / FaultLevel;
|
|
||||||
break;
|
|
||||||
case EstPE < 30:
|
|
||||||
__mech = 0
|
|
||||||
__lubr = MaxPK / FaultLevel;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}; //определяем действительный расчетный процент периодической энергии
|
|
||||||
|
|
||||||
__result = {
|
|
||||||
mechBS: __mech,
|
|
||||||
lubrBS: __lubr
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
return __result;
|
|
||||||
}; //оценка состояния методом PeakVM
|
|
||||||
|
|
||||||
export function getParams(freq) {
|
|
||||||
let rpm = freq * 60; //частота в об/мин
|
|
||||||
let wdt = 0; //граничная частота ФВЧ
|
|
||||||
let frq = 40 * freq; //граничная частота спектра
|
|
||||||
let lns = 800; //количество линий спектра
|
|
||||||
let avg = 1; //количество усреднений спектра
|
|
||||||
|
|
||||||
switch (true) {
|
|
||||||
case rpm <= 700:
|
|
||||||
wdt = 500;
|
|
||||||
lns = 800;
|
|
||||||
break;
|
|
||||||
case (rpm > 700) && (rpm <= 1500):
|
|
||||||
wdt = 1000;
|
|
||||||
lns = 800;
|
|
||||||
break;
|
|
||||||
case (rpm > 1500) && (rpm <= 3000):
|
|
||||||
wdt = 2000;
|
|
||||||
lns = 1600;
|
|
||||||
break;
|
|
||||||
case (rpm > 3000) && (rpm <= 4000):
|
|
||||||
wdt = 2000;
|
|
||||||
lns = 1600;
|
|
||||||
case rpm > 4000:
|
|
||||||
wdt = 5000;
|
|
||||||
lns = 1600;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
};
|
|
||||||
return {
|
|
||||||
filter: { frequency: wdt },
|
|
||||||
spec: {
|
|
||||||
frequency: frq,
|
|
||||||
lines: lns,
|
|
||||||
resolution: frq / lns,
|
|
||||||
avg: avg
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}; //рассчет параметров спектра
|
|
||||||
|
|
||||||
export function getLevels(freq) {
|
|
||||||
let rpm = freq * 60; //частота в об/мин
|
|
||||||
let alr = 0; //уровень предупреждения, g
|
|
||||||
switch (true) {
|
|
||||||
case rpm <= 900:
|
|
||||||
alr = 3.0 * (rpm / 900) ** 0.75; //1.5 => 3.0 для формы Peak-To-Peak
|
|
||||||
break;
|
|
||||||
case (rpm > 900) && (rpm <= 4000):
|
|
||||||
alr = 3.0; //1.5 => 3.0 для формы Peak-To-Peak
|
|
||||||
break;
|
|
||||||
case (rpm > 4000) && (rpm <= 10000):
|
|
||||||
alr = 3.0 * (rpm / 4000) ** 0.5; //1.5 => 3.0 для формы Peak-To-Peak
|
|
||||||
break;
|
|
||||||
case rpm > 10000:
|
|
||||||
alr = 5.0; //3.0 => 5.0 для формы Peak-To-Peak
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
};
|
|
||||||
return alr
|
|
||||||
}; //рассчет пороговых уровней
|
|
||||||
|
|
||||||
function getWave(options) {
|
|
||||||
let __src = options.src; //источник данных
|
|
||||||
let __allert = 0;
|
|
||||||
let __fault = 0;
|
|
||||||
if (options.lvl != undefined) {
|
|
||||||
__allert = options.lvl;
|
|
||||||
__fault = 2 * __allert;
|
|
||||||
};
|
|
||||||
|
|
||||||
if (options.canvas != undefined) {
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: __src.color,
|
|
||||||
name: __src.name,
|
|
||||||
x: __src.time,
|
|
||||||
y: __src.values
|
|
||||||
}
|
|
||||||
); //рисуем Waveform
|
|
||||||
|
|
||||||
if (__allert != 0) {
|
|
||||||
let __alr = __src.values.map((item) => (item = __allert));
|
|
||||||
let __flt = __src.values.map((item) => (item = __fault));
|
|
||||||
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFFFF00,
|
|
||||||
name: "allert",
|
|
||||||
x: __src.time,
|
|
||||||
y: __alr
|
|
||||||
}
|
|
||||||
); //рисуем линию предупреждения
|
|
||||||
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFF0000,
|
|
||||||
name: "fault",
|
|
||||||
x: __src.time,
|
|
||||||
y: __flt
|
|
||||||
}
|
|
||||||
); //рисуем линию опасности
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
return {
|
|
||||||
color: __src.color,
|
|
||||||
name: __src.name,
|
|
||||||
time: __src.time,
|
|
||||||
values: __src.values
|
|
||||||
}
|
|
||||||
}; //пиковая форма сигнала
|
|
||||||
|
|
||||||
function getAutoCorr(options) {
|
|
||||||
let result = {}; //результат
|
|
||||||
let plot = []; //массив значений корреляции для графика
|
|
||||||
let arr = options.src.values;
|
|
||||||
let arr2 = arr.concat(arr); //расширяем массив данных
|
|
||||||
let lag = 0.5;
|
|
||||||
let X = 0; //аргумент 1
|
|
||||||
let Y = 0; //аргумент 2
|
|
||||||
|
|
||||||
if (options.lag <= 0.5) { lag = options.lag } else { lag = 0.5 };
|
|
||||||
let T = Math.floor(arr.length * lag); //определяем количество индексов (шагов) для смещения массива
|
|
||||||
let avg = arr.reduce((acc, item) => (acc + item)) / arr.length; //среднее значение массива
|
|
||||||
Y = arr.reduce((acc, item) => (acc + (item - avg) ** 2), 0); //рассчитываем знаменатель функции
|
|
||||||
|
|
||||||
for (let i = 0; i < T; i++) {
|
|
||||||
X = 0;
|
|
||||||
for (let j = 0; j < arr.length; j++) { X += (arr[j] - avg) * (arr2[j + i] - avg) };
|
|
||||||
plot.push(X / Y); //записываем значение в массив коэффициентов
|
|
||||||
}; //смещение массива
|
|
||||||
|
|
||||||
let plot0 = plot.slice(Math.floor(0.01 * plot.length)); //убираем из массива первый 1% значений коэффициента (т.к. в нуле всегда значение 1.0)
|
|
||||||
let akf_avg = plot0.reduce((acc, item) => (acc + Math.abs(item)), 0) / plot0.length; //среднее значение коэффициента
|
|
||||||
let akf_sqr = plot0.reduce((acc, item) => (acc + item ** 2), 0); //сумма квадратов значений
|
|
||||||
let akf_rms = Math.sqrt(akf_sqr / plot0.length); //СКЗ коэффициента
|
|
||||||
let akf_max = Math.max(...plot0); //определяем максимальное значение коэффициента
|
|
||||||
|
|
||||||
result["avg"] = akf_avg;
|
|
||||||
result["rms"] = akf_rms;
|
|
||||||
result["ampl"] = akf_max;
|
|
||||||
result["data"] = plot;
|
|
||||||
|
|
||||||
if (options.canvas != undefined) {
|
|
||||||
options.canvas.add(
|
|
||||||
{
|
|
||||||
color: options.color,
|
|
||||||
name: options.name,
|
|
||||||
x: options.src.time,
|
|
||||||
y: plot
|
|
||||||
}
|
|
||||||
);
|
|
||||||
}; //отрисовка графика на plot
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}; //рассчет автокорреляции
|
|
||||||
|
|
||||||
function specSquare(spec, L, R) {
|
|
||||||
let __base = spec.base; //массив значений средней линии
|
|
||||||
let __data = spec.data; //массив значений амплитуд
|
|
||||||
let __lines = spec.data.length; //количества линий спектра
|
|
||||||
let __res = spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции)
|
|
||||||
let __start = 0; //стартовый индекс в массиве
|
|
||||||
let __end = __lines; //конечный индекс в массиве
|
|
||||||
let s0 = 0; //площадь под базовой линией
|
|
||||||
let s1 = 0; //площадь всего спектра
|
|
||||||
let s2 = 0; //площадь над базовой линией
|
|
||||||
let s3 = 0; //площадь обнаруженных гармоник
|
|
||||||
if (L != undefined) { __start = Math.round(L / __res) };
|
|
||||||
if (R != undefined) { __end = Math.round(R / __res) };
|
|
||||||
|
|
||||||
for (let i = __start; i <= __end - 1; i++) {
|
|
||||||
s0 += __base[i] * __res;
|
|
||||||
s1 += __data[i] * __res;
|
|
||||||
let __delta = __data[i] - __base[i];
|
|
||||||
if (__delta >= 0) { s2 += __delta * __res };
|
|
||||||
if (__delta >= spec.peak_level) { s3 += __delta * __res };
|
|
||||||
};
|
|
||||||
|
|
||||||
return {
|
|
||||||
base: s0,
|
|
||||||
spec: s1,
|
|
||||||
harm: s2,
|
|
||||||
peak: s3
|
|
||||||
};
|
|
||||||
}; //определение площадей спектра
|
|
||||||
|
|
@ -0,0 +1,99 @@
|
||||||
|
"use strict";
|
||||||
|
var signals = gtl.options.record.signalsModel;
|
||||||
|
var options = gtl.options;
|
||||||
|
var record = gtl.options.record;
|
||||||
|
var point = gtl.options.point;
|
||||||
|
|
||||||
|
let __mes = gtl.import("userFunctions.js");
|
||||||
|
let spmClass = gtl.import("spmClass.js").spmClass;
|
||||||
|
|
||||||
|
let __frq = __mes.getFreq(
|
||||||
|
/*{
|
||||||
|
src: gtl.analog_inputs[signals[0].portNumber], //источник сигнала частоты вращения
|
||||||
|
freq: 10, //граничная частота фильтрации сигнала
|
||||||
|
time: 1, //интервал измерения частоты вращения
|
||||||
|
avg: 4, //количество отсчетов для усреднения
|
||||||
|
dc: -0.05 //порог срабатывания счетчика
|
||||||
|
}*/
|
||||||
|
).value; //получаем частоту вращения
|
||||||
|
|
||||||
|
//фильтр для формирования сигнала
|
||||||
|
let __fltr = gtl.add_filter_iir(gtl.analog_inputs[signals[0].portNumber]);
|
||||||
|
__fltr.kind = gtl.filter_iir.butterworth; //тип окна
|
||||||
|
__fltr.type = gtl.filter_iir.bandpass; //тип фильтра (ФНЧ)
|
||||||
|
__fltr.order = 10; //порядок фильтра
|
||||||
|
__fltr.frequency = 32000; //центральная частота полосового фильтра
|
||||||
|
__fltr.width = 7360; //ширина полосового фильтра
|
||||||
|
|
||||||
|
//формирование амплитуд для расчета коврового уровня dBc (за 200 импульсов в сек)
|
||||||
|
let __cpt = gtl.add_value_ampl(__fltr);
|
||||||
|
__cpt.name = "Ковровый уровень";
|
||||||
|
__cpt.color = 0x2B6CC4;
|
||||||
|
__cpt.time = 0.005; //время выборки
|
||||||
|
__cpt.avg_cnt = 200; //количество отсчетов
|
||||||
|
|
||||||
|
//формирование амплитуд для расчета максимального уровня dBm (максимум за 2 сек)
|
||||||
|
let __max = gtl.add_value_ampl(__fltr);
|
||||||
|
__max.name = "SPM импульсы";
|
||||||
|
__max.color = 0x2B6CC4;
|
||||||
|
__max.time = 0.001; //время выборки
|
||||||
|
__max.avg_cnt = 2000; //количество отсчетов
|
||||||
|
|
||||||
|
let __imp = gtl.create_moving_max(
|
||||||
|
{
|
||||||
|
src: __fltr,
|
||||||
|
name: "SPM форма",
|
||||||
|
time: 0.001
|
||||||
|
}
|
||||||
|
); //формируем сигнал максимальных амплитуд для построения спектра
|
||||||
|
|
||||||
|
let spen = __mes.getSpen(
|
||||||
|
{
|
||||||
|
src: __imp, //источник сигнала
|
||||||
|
name: "SPM спектр огибающей", //имя спектра
|
||||||
|
color: 0x00ff0000, //цвет в формате HEX
|
||||||
|
frequency: 200, //граничная частота
|
||||||
|
resolution: 0.25, //частотное разрешение
|
||||||
|
average: 8, //количество усреднений
|
||||||
|
view: gtl.spec.db, //единицы отображения (дБ)
|
||||||
|
level: 5 //уровень обнаружения гармоник в дБ
|
||||||
|
}
|
||||||
|
); //вычисляем спектр огибающей пиковой формы
|
||||||
|
|
||||||
|
let canvas1 = gtl.plots.add("Spectral");
|
||||||
|
|
||||||
|
//[Диагностика]
|
||||||
|
gtl.diagnostic.interval = gtl.acq_time;
|
||||||
|
function diagnose() {
|
||||||
|
|
||||||
|
let __spm = new spmClass(
|
||||||
|
{
|
||||||
|
src1: __cpt, //объект с массивом данных для расчета коврового уровня
|
||||||
|
src2: __max, //объект с массивом данных определения маскимума импульсов
|
||||||
|
freq: __frq, //частота вращения
|
||||||
|
d_inner: options.rbInnerD, //диаметр внутреннего кольца подшипника
|
||||||
|
visible: true
|
||||||
|
}
|
||||||
|
);
|
||||||
|
|
||||||
|
let __spen_tools = __mes.createTools(
|
||||||
|
{
|
||||||
|
spec: spen, //спектр для построения модели (объект)
|
||||||
|
//set: __set, //источник данных для построения частотных линий
|
||||||
|
tol: 1 //коридор обнаружения гармоники на портрете, %
|
||||||
|
}
|
||||||
|
); //формируем компоненты и частотные линии на спектре огибающей
|
||||||
|
|
||||||
|
canvas1.add(
|
||||||
|
{
|
||||||
|
color: spen.color,
|
||||||
|
name: spen.name,
|
||||||
|
x: spen.resolution,
|
||||||
|
y: spen.data,
|
||||||
|
spec_tools: __spen_tools.to_json()
|
||||||
|
}
|
||||||
|
); //рисуем спектр огибающей spm
|
||||||
|
|
||||||
|
gtl.results = __spm.getResult();
|
||||||
|
gtl.diagnostic.stop();
|
||||||
|
};
|
||||||
133
spmVM.js
133
spmVM.js
|
|
@ -1,133 +0,0 @@
|
||||||
export function getSpm(args) {
|
|
||||||
let __src1 = args.src1.values; //массив данных амплитуд импульсов для расчета коврового уровня
|
|
||||||
let __src2 = args.src2.values; //массив данных амплитуд импульсов для определения максимума
|
|
||||||
let __frq = args.freq; //частота вращения
|
|
||||||
let __d = args.d_inner; //диаметр внутреннего кольца подшипника
|
|
||||||
|
|
||||||
let __cpt = todB(__src1); //переводим значения массива в дБ
|
|
||||||
let __max = todB(__src2); //переводим значения массива в дБ
|
|
||||||
|
|
||||||
let __dBi = getdBi(__d, __frq * 60); //вычисляем естественный уровень вибрации нового подшипника
|
|
||||||
let __dBc = Math.sqrt(__cpt.reduce((acc, item) => (acc + item ** 2), 0) / __cpt.length); //вычисляем ковровый уровень (СКЗ) в дБ
|
|
||||||
let __dBm = Math.max(...__max); //вычисляем максимальную амплитуду импульсов в дБ
|
|
||||||
let __dBn = __dBm - __dBi; //нормализованное значение амплитуды
|
|
||||||
|
|
||||||
let __max0 = __max.slice(0); //делаем копию массива для сортировки
|
|
||||||
let __maxSort = __max0.sort((a, b) => (b - a)); //сортируем массив по убыванию
|
|
||||||
let __max40 = __maxSort.slice(0, 40); //выделяем 40 первых (максимальных) значений из массива
|
|
||||||
let __LR = __max40.reduce((acc, item) => (acc + item), 0) / __max40.length; //определяем LR (среднее из 40 импульсов)
|
|
||||||
|
|
||||||
let __max1000 = __max.slice(0, __max.length / 2); //выделяем 1000 значений из массива
|
|
||||||
let __HR = Math.sqrt(__max1000.reduce((acc, item) => (acc + item ** 2), 0) / __max1000.length); //вычисляем HR (СКЗ) в дБ
|
|
||||||
|
|
||||||
let __state = "Норма"; //общее состояние
|
|
||||||
switch (true) {
|
|
||||||
case (__dBn > 20) && (__dBn < 35):
|
|
||||||
__state = "Предупреждение";
|
|
||||||
break;
|
|
||||||
case __dBn >= 35:
|
|
||||||
__state = "Опасность";
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
};
|
|
||||||
|
|
||||||
args.canvas.add(
|
|
||||||
{
|
|
||||||
color: args.src2.color,
|
|
||||||
name: args.src2.name,
|
|
||||||
x: args.src2.time,
|
|
||||||
y: __max
|
|
||||||
}
|
|
||||||
); //рисуем форму импульсов SPM
|
|
||||||
|
|
||||||
args.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFFFF00,
|
|
||||||
name: "dBc",
|
|
||||||
x: args.src2.time,
|
|
||||||
y: __max.map((item) => (item = __dBc))
|
|
||||||
}
|
|
||||||
); //рисуем уровень dBc
|
|
||||||
|
|
||||||
args.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFF0000,
|
|
||||||
name: "dBm",
|
|
||||||
x: args.src2.time,
|
|
||||||
y: __max.map((item) => (item = __dBm))
|
|
||||||
}
|
|
||||||
); //рисуем уровень dBm
|
|
||||||
|
|
||||||
args.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFFA500,
|
|
||||||
name: "HR",
|
|
||||||
x: args.src2.time,
|
|
||||||
y: __max.map((item) => (item = __HR))
|
|
||||||
}
|
|
||||||
); //рисуем уровень HR
|
|
||||||
|
|
||||||
args.canvas.add(
|
|
||||||
{
|
|
||||||
color: 0xFF00CC,
|
|
||||||
name: "LR",
|
|
||||||
x: args.src2.time,
|
|
||||||
y: __max.map((item) => (item = __LR))
|
|
||||||
}
|
|
||||||
); //рисуем уровень LR
|
|
||||||
|
|
||||||
let __result = {
|
|
||||||
dBi: __dBi,
|
|
||||||
dBc: __dBc,
|
|
||||||
dBm: __dBm,
|
|
||||||
dBn: __dBn,
|
|
||||||
HR: __HR,
|
|
||||||
LR: __LR,
|
|
||||||
state: __state
|
|
||||||
};
|
|
||||||
|
|
||||||
return __result;
|
|
||||||
}; //оценка состояния методом spmVM
|
|
||||||
|
|
||||||
function todB(arr, type) {
|
|
||||||
let __limit = 3e-4; //пороговое значение
|
|
||||||
if (type != undefined) {
|
|
||||||
switch (type) {
|
|
||||||
case 0: __limit = 1e-6; break;
|
|
||||||
case 1: __limit = 1e-9; break;
|
|
||||||
case 2: __limit = 1e-12; break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
let __result = arr.map((item) => (item = 20 * Math.log10(item / __limit)));
|
|
||||||
return __result;
|
|
||||||
}; //перевод значений массива в дБ
|
|
||||||
|
|
||||||
function getdBi(d, rpm) {
|
|
||||||
const a = 3.135283064375708;
|
|
||||||
const b = 4.999746694992378;
|
|
||||||
const k = -58.16048390995372;
|
|
||||||
|
|
||||||
function getLogUnitValue(lin_unit_value, base, k, c) {
|
|
||||||
return c * Math.log(lin_unit_value) / Math.log(base) + k;
|
|
||||||
};
|
|
||||||
|
|
||||||
function getDLogUnitValue(d) {
|
|
||||||
const base = 0.5921510231527015;
|
|
||||||
const k = -3.015055963296224;
|
|
||||||
const c = -0.9111115009540;
|
|
||||||
return getLogUnitValue(d, base, k, c);
|
|
||||||
};
|
|
||||||
|
|
||||||
function getRpmLogUnitValue(rpm) {
|
|
||||||
const base = 6.69896278136537;
|
|
||||||
const k = -0.008927920952982967;
|
|
||||||
const c = 3.3041976536011;
|
|
||||||
return getLogUnitValue(rpm, base, k, c);
|
|
||||||
};
|
|
||||||
|
|
||||||
return a * getDLogUnitValue(d) + b * getRpmLogUnitValue(rpm) + k;
|
|
||||||
}; //расчет естественного уровня вибрации dBi
|
|
||||||
Loading…
Reference in New Issue