From 15acd446d86073a84a3c0fe157c81749fdf87b63 Mon Sep 17 00:00:00 2001 From: Aleksey_K Date: Mon, 26 Aug 2024 11:12:30 +0900 Subject: [PATCH] add new classes --- maskMethod.js | 146 ++++++++++++++++++++++++++++ maskVM.js | 176 ---------------------------------- mtxVM.js | 83 ---------------- peakMethod.js | 95 ++++++++++++++++++ peakVM.js | 261 -------------------------------------------------- spmMethod.js | 99 +++++++++++++++++++ spmVM.js | 133 ------------------------- 7 files changed, 340 insertions(+), 653 deletions(-) create mode 100644 maskMethod.js delete mode 100644 maskVM.js delete mode 100644 mtxVM.js create mode 100644 peakMethod.js delete mode 100644 peakVM.js create mode 100644 spmMethod.js delete mode 100644 spmVM.js diff --git a/maskMethod.js b/maskMethod.js new file mode 100644 index 0000000..0ecf056 --- /dev/null +++ b/maskMethod.js @@ -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(); +}; \ No newline at end of file diff --git a/maskVM.js b/maskVM.js deleted file mode 100644 index 3be6d5b..0000000 --- a/maskVM.js +++ /dev/null @@ -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; -}; //построение портрета дефекта \ No newline at end of file diff --git a/mtxVM.js b/mtxVM.js deleted file mode 100644 index 5a0fa74..0000000 --- a/mtxVM.js +++ /dev/null @@ -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; -}; //Построение компонентов и частотных линий на спектре - - - - - - - - - - - - - - - - diff --git a/peakMethod.js b/peakMethod.js new file mode 100644 index 0000000..db4681c --- /dev/null +++ b/peakMethod.js @@ -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(); +}; diff --git a/peakVM.js b/peakVM.js deleted file mode 100644 index 6d2d262..0000000 --- a/peakVM.js +++ /dev/null @@ -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 - }; -}; //определение площадей спектра \ No newline at end of file diff --git a/spmMethod.js b/spmMethod.js new file mode 100644 index 0000000..39df32b --- /dev/null +++ b/spmMethod.js @@ -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(); +}; diff --git a/spmVM.js b/spmVM.js deleted file mode 100644 index 27014ee..0000000 --- a/spmVM.js +++ /dev/null @@ -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 \ No newline at end of file