aleksey_k
/
gtld2-diag-scripts
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

name corrections

develop
aleksey_k 2024-06-11 14:41:46 +09:00
parent 22bf85c8f8
commit 70d05e8726
15 changed files with 137 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
ballscrew/ballscrew.js
View File

@ -4,9 +4,9 @@ var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;
var fnc = gtl.import("user-functions.js");
var mtx = gtl.import("bs_mtx.js");
var def = gtl.import("bs_defs.js");
var fnc = gtl.import("userFunctions.js");
var mtx = gtl.import("bsMTX.js");
var def = gtl.import("bsDefs.js");
//настройки для датчика оборотов
var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); //объявление переменной фильтра
@ -115,12 +115,12 @@ function diagnose() {
case 1: //частота вращения фиксированная
case 2: //частота вращения из поля INFO (виброметр)
filter_spen.frequency = fnc.filter_frequency(); //считаме фильтр для огибающей
filter_spen.width = fnc.filter_width(); //определяем ширину фильтра
spen.frequency = fnc.spec_params().frequency;
spen.lines = fnc.spec_params().lines;
ausp.frequency = fnc.spec_params().frequency;
ausp.lines = fnc.spec_params().lines;
filter_spen.frequency = fnc.bpFreq(); //считаме фильтр для огибающей
filter_spen.width = fnc.bpWidth(); //определяем ширину фильтра
spen.frequency = fnc.specParams().frequency;
spen.lines = fnc.specParams().lines;
ausp.frequency = fnc.specParams().frequency;
ausp.lines = fnc.specParams().lines;
//определение минимально необходимой длительности сигнала для проведения диагностики
let time = []; //массив по времени набора данных
@ -137,7 +137,7 @@ function diagnose() {
//Вывод информации в лог
//Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
var AQ = fnc.spec_square(ausp.data, ausp.frequency / 2, ausp.frequency);
var AQ = fnc.specSquare(ausp.data, ausp.frequency / 2, ausp.frequency);
gtl.log.info("Объект диагностики", options.rbModelName);
gtl.log.info("FREQ", fnc.FREQ());
@ -153,9 +153,9 @@ function diagnose() {
gtl.log.info("Разрешение SPEN", spen.resolution);
gtl.log.info("Ширина AUSP", ausp.frequency);
let spen_mx = mtx.bs_mtx(spen, filter_spen, true);
let spen_df = def.bs_defs(spen_mx, true);
let ausp_mx = mtx.bs_mtx(ausp, 0, false);
let spen_mx = mtx.bsMTX(spen, filter_spen, true);
let spen_df = def.bsDefs(spen_mx, true);
let ausp_mx = mtx.bsMTX(ausp, 0, false);
var res = {
RMSA: rms_spen.value,

10
ballscrew/bsDefs.js
View File

@ -1,6 +1,6 @@
"use strict";
export function bs_defs(mtx, isDeep) {
export function bsDefs(mtx, isDeep) {
var res = {}; //результат
if (isDeep = true) { var key = "dp" } else { var key = "lv" };
var des = {
@ -11,7 +11,7 @@ export function bs_defs(mtx, isDeep) {
BPFI: { ds: "винта", dp: 8, lv: 20 },
}; //описание функциональных частот
function get_note(harmsArr) {
function getNote(harmsArr) {
let note = "Износ"; //описание характера колебаний
let cnt = 0; //количество значений в массиве
for (let i = 0; i <= harmsArr.length - 1; i++) { if (harmsArr[i] > 0) { cnt++ }; };
@ -21,7 +21,7 @@ export function bs_defs(mtx, isDeep) {
return note;
};
function get_level(lvl, thres) {
function getLevel(lvl, thres) {
let level = "Сильный";
switch (true) {
case lvl < 0.5 * thres:
@ -41,8 +41,8 @@ export function bs_defs(mtx, isDeep) {
let lvl = Math.max(...arr); //определяем максимальное значение параметра из массива
let sum = arr.reduce(function (a, b) { return a + b }, 0); //сумма элементов массива
if (sum > 0) {
let note = get_note(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + get_level(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
let note = getNote(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + getLevel(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
};
};
return res;

8
ballscrew/bsMTX.js
View File

@ -1,8 +1,8 @@
"use strict";
var ufc = gtl.import("user-functions.js");
var ufc = gtl.import("userFunctions.js");
export function bs_mtx(spec, filter, isDeep) {
export function bsMTX(spec, filter, isDeep) {
var num = 6; //глубина матрицы (количество гармоник)
var level = 0; //уровень развития дефекта
var res = {}; //результат
@ -15,7 +15,7 @@ export function bs_mtx(spec, filter, isDeep) {
BPFI: { nm: "Частота перекатывания тел качения по винту", fn: ufc.BSSCR(), md: 0, cl: 0xff990090 }
}; //набор функциональных частот
function mod_factor(dSpec, dFilter, ampl, base) {
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);
@ -42,7 +42,7 @@ export function bs_mtx(spec, filter, isDeep) {
if (lines.harms[j].is_present == true) {
switch (isDeep) {
case true:
level = Math.round(mod_factor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
level = Math.round(modFactor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
break;
case false:
level = Math.round(lines.harms[j].level);

26
gear transmission/gear_transmission.js
View File

@ -4,9 +4,9 @@ var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;
var fnc = gtl.import("user-functions.js");
var mtx = gtl.import("gt_mtx.js");
var def = gtl.import("gt_defs.js");
var fnc = gtl.import("userFunctions.js");
var mtx = gtl.import("gtMTX.js");
var def = gtl.import("gtDefs.js");
//настройки для датчика оборотов
var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); //объявление переменной фильтра
@ -115,12 +115,12 @@ function diagnose() {
case 1: //частота вращения фиксированная
case 2: //частота вращения из поля INFO (виброметр)
filter_spen.frequency = fnc.filter_frequency(); //считаме фильтр для огибающей
filter_spen.width = fnc.filter_width(); //определяем ширину фильтра
spen.frequency = fnc.spec_params().frequency;
spen.lines = fnc.spec_params().lines;
ausp.frequency = fnc.spec_params().frequency;
ausp.lines = fnc.spec_params().lines;
filter_spen.frequency = fnc.bpFreq(); //считаме фильтр для огибающей
filter_spen.width = fnc.bpWidth(); //определяем ширину фильтра
spen.frequency = fnc.specParams().frequency;
spen.lines = fnc.specParams().lines;
ausp.frequency = fnc.specParams().frequency;
ausp.lines = fnc.specParams().lines;
//определение минимально необходимой длительности сигнала для проведения диагностики
let time = []; //массив по времени набора данных
@ -137,7 +137,7 @@ function diagnose() {
//Вывод информации в лог
//Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
var AQ = fnc.spec_square(ausp.data, ausp.frequency / 2, ausp.frequency);
var AQ = fnc.specSquare(ausp.data, ausp.frequency / 2, ausp.frequency);
gtl.log.info("Объект диагностики", options.rbModelName);
gtl.log.info("FREQ", fnc.FREQ());
@ -151,9 +151,9 @@ function diagnose() {
gtl.log.info("Разрешение SPEN", spen.resolution);
gtl.log.info("Ширина AUSP", ausp.frequency);
let spen_mx = mtx.gt_mtx(spen, filter_spen, true);
let spen_df = def.gt_defs(spen_mx, true);
let ausp_mx = mtx.gt_mtx(ausp, 0, false);
let spen_mx = mtx.gtMTX(spen, filter_spen, true);
let spen_df = def.gtDefs(spen_mx, true);
let ausp_mx = mtx.gtMTX(ausp, 0, false);
var res = {
RMSA: rms_spen.value,

10
gear transmission/gtDefs.js
View File

@ -1,6 +1,6 @@
"use strict";
export function gt_defs(mtx, isDeep) {
export function gtDefs(mtx, isDeep) {
var res = {}; //результат
if (isDeep = true) { var key = "dp" } else { var key = "lv" };
var des = {
@ -10,7 +10,7 @@ export function gt_defs(mtx, isDeep) {
GTFZ2: { ds: "зацепления зубчатого колеса", dp: 20, lv: 20 }
}; //описание функциональных частот
function get_note(harmsArr) {
function getNote(harmsArr) {
let note = "Биение"; //описание характера колебаний
let cnt = 0; //количество значений в массиве
for (let i = 0; i <= harmsArr.length - 1; i++) { if (harmsArr[i] > 0) { cnt++ }; };
@ -20,7 +20,7 @@ export function gt_defs(mtx, isDeep) {
return note;
};
function get_level(lvl, thres) {
function getLevel(lvl, thres) {
let level = "Сильный";
switch (true) {
case lvl < 0.5 * thres:
@ -40,8 +40,8 @@ export function gt_defs(mtx, isDeep) {
let lvl = Math.max(...arr); //определяем максимальное значение параметра из массива
let sum = arr.reduce(function (a, b) { return a + b }, 0); //сумма элементов массива
if (sum > 0) {
let note = get_note(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + get_level(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
let note = getNote(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + getLevel(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
};
};
return res;

8
gear transmission/gtMTX.js
View File

@ -1,8 +1,8 @@
"use strict";
var ufc = gtl.import("user-functions.js");
var ufc = gtl.import("userFunctions.js");
export function gt_mtx(spec, filter, isDeep) {
export function gtMTX(spec, filter, isDeep) {
var num = 6; //глубина матрицы (количество гармоник)
var level = 0; //уровень развития дефекта
var res = {}; //результат
@ -14,7 +14,7 @@ export function gt_mtx(spec, filter, isDeep) {
GTFZ2: { nm: "Зубцовая частота по второму валу", fn: ufc.GTFZ(), md: ufc.GTF2(), cl: 0xff990090 }
}; //набор функциональных частот
function mod_factor(dSpec, dFilter, ampl, base) {
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);
@ -41,7 +41,7 @@ export function gt_mtx(spec, filter, isDeep) {
if (lines.harms[j].is_present == true) {
switch (isDeep) {
case true:
level = Math.round(mod_factor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
level = Math.round(modFactor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
break;
case false:
level = Math.round(lines.harms[j].level);

30
getMask.js
View File

@ -1,7 +1,7 @@
export function spec_model(spec, tol, color, visible) {
export function specModel(spec, tol, color, visible) {
let result = {}; //результат
let model = spec.base; //исходный массив точек для построения упрощенной модели спектра
let model = spec.base; //массив точек базовой линии для построения упрощенной модели спектра
let imin = 0; //левая граница коридора
let imax = 0; //правая граница коридора
for (let i = 0; i < spec.peaks.length; i++) {
@ -33,19 +33,21 @@ export function spec_model(spec, tol, color, visible) {
return result;
}; //построение упрощенной модели спектра
export function mask(obj) {
export function getMask(obj) {
let result = {}; //результат
let data = obj.src1.data; //массив точек спектра для сравнения с портретом
let mask = obj.src2.base; //исходный массив точек для построения портрета дефекта
let harms = obj.harms; //гармоник портрета
let mask = obj.src2.base; //массив точек базовой линии для построения портрета дефекта
let harms = obj.harms; //кол-во гармоник портрета
if (obj.freq * harms > obj.src2.frequency) { harms = Math.trunc(obj.src2.frequency / obj.freq) }; //проверяем максимальное кол-во гармоник в портрете
let df = 0; //отношение ширины фильтра частотному разрешению спектра
let dl = obj.lvl; //разность уровней гармонической и случайной составляющей вибрации
if (obj.filter != 0) {
df = obj.filter.width / obj.src2.resolution;
dl = 10 * Math.log10((obj.lvl ** 2) * df + 1);
df = obj.src2.frequency / obj.filter.width;
dl = 10 * Math.log10((obj.lvl ** 2) / df + 1);
};
let k = obj.coef; //коэффициент затухания
let x = 0; //индекс элемента массива для гармоники
let dx = 0; //коридор индексов
let xmin = 0; //левая граница коридора
let xmax = 0; //правая граница коридора
let correlation = 0; //коэффициент корреляции
@ -75,8 +77,11 @@ export function mask(obj) {
switch (obj.type) {
case 0: //обычный ряд
for (let i = 1; i <= harms; i++) {
xmin = Math.round(i * (obj.freq - obj.freq * 0.5 * obj.tol / 100) / obj.src2.resolution); //определяем индекс левой границы коридора
xmax = Math.round(i * (obj.freq + obj.freq * 0.5 * obj.tol / 100) / obj.src2.resolution); //определяем индекс правой границы коридора
x = Math.trunc(i * obj.freq / obj.src2.resolution); //определяем инднекс элемента массива для гармоники
dx = Math.trunc(i * (obj.freq * obj.tol / 100) / obj.src2.resolution); //коридор индексов массива для гармоники
xmin = x - Math.round(dx / 2); //определяем индекс левой границы коридора
xmax = x + Math.round(dx / 2); //определяем индекс правой границы коридора
if (xmax > obj.src2.base.length) { xmax = obj.src2.base.length - 2 }; //проверяем выход границы за размер массива
for (let j = xmin; j <= xmax; j++) { mask[j] = obj.src2.base[j] + dl }; //записываем значение глубины модуляции для коридора
dl = dl - (k * dl); //снижаем глубину модуляции с коэффициентом затухания
@ -90,8 +95,11 @@ export function mask(obj) {
break;
case 1: //четные составляющие
for (let i = 1; i <= harms; i++) {
xmin = Math.round(i * (obj.freq - obj.freq * 0.5 * obj.tol / 100) / obj.src2.resolution); //определяем индекс левой границы коридора
xmax = Math.round(i * (obj.freq + obj.freq * 0.5 * obj.tol / 100) / obj.src2.resolution); //определяем индекс правой границы коридора
x = Math.trunc(i * obj.freq / obj.src2.resolution); //инднекс элемента массива для гармоники
dx = Math.trunc(i * (obj.freq * obj.tol / 100) / obj.src2.resolution); //коридор индексов массива для гармоники
xmin = x - Math.round(dx / 2); //определяем индекс левой границы коридора
xmax = x + Math.round(dx / 2); //определяем индекс правой границы коридора
if (xmax > obj.src2.base.length) { xmax = obj.src2.base.length - 2 }; //проверяем выход границы за размер массива
if (i % 2 > 0) {
for (let j = xmin; j <= xmax; j++) { mask[j] = obj.src2.base[j] + k * dl }; //записываем значение глубины модуляции для коридора (нечетная гармоника)

28
getStdMeasures.js 100644
View File

@ -0,0 +1,28 @@
export function getStdMeasure(src) {
let __result = {}; //результат
//фильтрация диапазона в сигнале для определения СКЗ вибрации
var __filter = gtl.add_filter_iir(src);
__filter.kind = gtl.filter_iir.butterworth;
__filter.type = gtl.filter_iir.lowpass;
__filter.order = 8;
__filter.frequency = 1000;
//определение среднего квадратического значения в диапазоне фильтра до 1000 Гц
var __rms = gtl.add_value_rms(__filter);
__rms.time = 0.1;
__rms.avg_cnt = 4;
//определение амплитудного значения в диапазоне фильтра до 1000 Гц
var __ampl = gtl.add_value_ampl(__filter);
__ampl.time = 0.1;
__ampl.avg_cnt = 4;
__result = {
rms1000: __rms,
ampl1000: __ampl
};
return __result;
}; //измерение стандартных параметров

20
kNN/kNN.js
View File

@ -5,9 +5,9 @@ var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;
var fnc = gtl.import("user-functions.js");
var mtx = gtl.import("kn_mtx.js");
var def = gtl.import("kn_defs.js");
var fnc = gtl.import("userFunctions.js");
var mtx = gtl.import("knMTX.js");
var def = gtl.import("knDefs.js");
//настройки для датчика оборотов
var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); //объявление переменной фильтра
@ -107,10 +107,10 @@ function diagnose() {
case 1: //частота вращения фиксированная
case 2: //частота вращения из поля INFO (виброметр)
filter_spen.frequency = fnc.filter_frequency(); //считаме фильтр для огибающей
filter_spen.width = fnc.filter_width(); //определяем ширину фильтра
spen.frequency = fnc.spec_params().frequency;
spen.lines = fnc.spec_params().lines;
filter_spen.frequency = fnc.bpFreq(); //считаме фильтр для огибающей
filter_spen.width = fnc.bpWidth(); //определяем ширину фильтра
spen.frequency = fnc.specParams().frequency;
spen.lines = fnc.specParams().lines;
//определение минимально необходимой длительности сигнала для проведения диагностики
let time = []; //массив по времени набора данных
@ -127,7 +127,7 @@ function diagnose() {
//Вывод информации в лог
//Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
var AQ = fnc.spec_square(ausp.data, ausp.frequency / 2, ausp.frequency);
var AQ = fnc.specSquare(ausp.data, ausp.frequency / 2, ausp.frequency);
gtl.log.info("Объект диагностики", + options.rbModelName);
gtl.log.info("Минимально необходимая частота вращения", fnc.FREQNESS());
@ -144,8 +144,8 @@ function diagnose() {
gtl.log.info("Разрешение SPEN", spen.resolution);
gtl.log.info("Ширина AUSP", ausp.frequency);
let spen_mx = mtx.kn_mtx(spen, filter_spen, true);
let spen_df = def.kn_defs(spen_mx, true);
let spen_mx = mtx.knMTX(spen, filter_spen, true);
let spen_df = def.knDefs(spen_mx, true);
var res = {
RMSA: rms_spen.value,

2
kNN/knDefs.js
View File

@ -1,6 +1,6 @@
"use strict";
export function kn_defs(mtx, isDeep) {
export function knDefs(mtx, isDeep) {
var res = {}; //результат
if (isDeep = true) { var key = "dp" } else { var key = "lv" };
var des = {

8
kNN/knMTX.js
View File

@ -1,8 +1,8 @@
"use strict";
var ufc = gtl.import("user-functions.js");
var ufc = gtl.import("userFunctions.js");
export function kn_mtx(spec, filter, isDeep) {
export function knMTX(spec, filter, isDeep) {
var num = 6; //глубина матрицы (количество гармоник)
var level = 0; //уровень развития дефекта
var res = {}; //результат
@ -15,7 +15,7 @@ export function kn_mtx(spec, filter, isDeep) {
BPFI: { nm: "Частота перекатывания тел качения по внутреннему кольцу", fn: ufc.BPFI(), md: ufc.FREQ(), cl: 0xff990090 }
}; //набор функциональных частот
function mod_factor(dSpec, dFilter, ampl, base) {
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);
@ -42,7 +42,7 @@ export function kn_mtx(spec, filter, isDeep) {
if (lines.harms[j].is_present == true) {
switch (isDeep) {
case true:
level = Math.round(mod_factor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
level = Math.round(modFactor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
break;
case false:
level = Math.round(lines.harms[j].level);

10
rolling bearing/rbDefs.js
View File

@ -1,6 +1,6 @@
"use strict";
export function rb_defs(mtx, isDeep) {
export function rbDefs(mtx, isDeep) {
var res = {}; //результат
if (isDeep = true) { var key = "dp" } else { var key = "lv" };
var des = {
@ -11,7 +11,7 @@ export function rb_defs(mtx, isDeep) {
BPFI: { ds: "внутреннего кольца", dp: 8, lv: 20 },
}; //описание функциональных частот
function get_note(harmsArr) {
function getNote(harmsArr) {
let note = "Износ"; //описание характера колебаний
let cnt = 0; //количество значений в массиве
for (let i = 0; i <= harmsArr.length - 1; i++) { if (harmsArr[i] > 0) { cnt++ }; };
@ -21,7 +21,7 @@ export function rb_defs(mtx, isDeep) {
return note;
};
function get_level(lvl, thres) {
function getLevel(lvl, thres) {
let level = "Сильный";
switch (true) {
case lvl < 0.5 * thres:
@ -41,8 +41,8 @@ export function rb_defs(mtx, isDeep) {
let lvl = Math.max(...arr); //определяем максимальное значение параметра из массива
let sum = arr.reduce(function (a, b) { return a + b }, 0); //сумма элементов массива
if (sum > 0) {
let note = get_note(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + get_level(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
let note = getNote(arr);
res[rows[i]] = note + ' ' + des[rows[i]].ds + ': ' + getLevel(lvl, des[rows[i]][key]) + ' (' + lvl + ')';
};
};
return res;

8
rolling bearing/rbMTX.js
View File

@ -1,8 +1,8 @@
"use strict";
var ufc = gtl.import("user-functions.js");
var ufc = gtl.import("userFunctions.js");
export function rb_mtx(spec, filter, isDeep) {
export function rbMTX(spec, filter, isDeep) {
var num = 6; //глубина матрицы (количество гармоник)
var level = 0; //уровень развития дефекта
var res = {}; //результат
@ -15,7 +15,7 @@ export function rb_mtx(spec, filter, isDeep) {
BPFI: { nm: "Частота перекатывания тел качения по внутреннему кольцу", fn: ufc.BPFI(), md: ufc.FREQ(), cl: 0xff990090 }
}; //набор функциональных частот
function mod_factor(dSpec, dFilter, ampl, base) {
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);
@ -42,7 +42,7 @@ export function rb_mtx(spec, filter, isDeep) {
if (lines.harms[j].is_present == true) {
switch (isDeep) {
case true:
level = Math.round(mod_factor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
level = Math.round(modFactor(spec, filter, lines.harms[j].amplitude, lines.harms[j].base));
break;
case false:
level = Math.round(lines.harms[j].level);

26
rolling bearing/rolling_bearing.js
View File

@ -4,9 +4,9 @@ var options = gtl.options;
var record = gtl.options.record;
var point = gtl.options.point;
var fnc = gtl.import("user-functions.js");
var mtx = gtl.import("rb_mtx.js");
var def = gtl.import("rb_defs.js");
var fnc = gtl.import("userFunctions.js");
var mtx = gtl.import("rbMTX.js");
var def = gtl.import("rbDefs.js");
//настройки для датчика оборотов
var filter_freq = gtl.add_filter_iir(gtl.analog_inputs[record.tachoOptions.tachoChannel]); //объявление переменной фильтра
@ -115,12 +115,12 @@ function diagnose() {
case 1: //частота вращения фиксированная
case 2: //частота вращения из поля INFO (виброметр)
filter_spen.frequency = fnc.filter_frequency(); //считаме фильтр для огибающей
filter_spen.width = fnc.filter_width(); //определяем ширину фильтра
spen.frequency = fnc.spec_params().frequency;
spen.lines = fnc.spec_params().lines;
ausp.frequency = fnc.spec_params().frequency;
ausp.lines = fnc.spec_params().lines;
filter_spen.frequency = fnc.bpFreq(); //считаме фильтр для огибающей
filter_spen.width = fnc.pbWidth(); //определяем ширину фильтра
spen.frequency = fnc.specParams().frequency;
spen.lines = fnc.specParams().lines;
ausp.frequency = fnc.specParams().frequency;
ausp.lines = fnc.specParams().lines;
//определение минимально необходимой длительности сигнала для проведения диагностики
let time = []; //массив времени набора данных
@ -137,7 +137,7 @@ function diagnose() {
//Вывод информации в лог
//Расчет площади спектра вибрации: спектр, начало отсчета в Гц, граничная частота спектра
var AQ = fnc.spec_square(ausp.data, ausp.frequency / 2, ausp.frequency);
var AQ = fnc.specSquare(ausp.data, ausp.frequency / 2, ausp.frequency);
gtl.log.info("Объект диагностики", options.rbModelName);
gtl.log.info("Минимально необходимая частота вращения", fnc.FREQNESS());
@ -154,9 +154,9 @@ function diagnose() {
gtl.log.info("Разрешение SPEN", spen.resolution);
gtl.log.info("Ширина AUSP", ausp.frequency);
let spen_mx = mtx.rb_mtx(spen, filter_spen, true);
let spen_df = def.rb_defs(spen_mx, true);
let ausp_mx = mtx.rb_mtx(ausp, 0, true);
let spen_mx = mtx.rbMTX(spen, filter_spen, true);
let spen_df = def.rbDefs(spen_mx, true);
let ausp_mx = mtx.rbMTX(ausp, 0, true);
var res = {
RMSA: rms_spen.value,

18
userFunctions.js
View File

@ -109,17 +109,17 @@ export function PGFZ() { return pgZ2 * PGFSAT() }; //зубцовая часто
export function TRFBLD() { return FREQ() * trBlades; }; //лопастная частота
export function filter_frequency() {
export function bpFreq() {
//let filter = 6013.41 * Math.log(0.266935 * FREQ() + 1.1201);
let filter = 1850 * Math.sqrt(FREQ());
return filter;
}; //расчетная центральная частота полосового фильтра для спектра огибающей
export function filter_width(number) {
export function bpWidth(number) {
let n = 3;
if (number != null) { n = number };
let kf = (2 ** (1 / n) - 1) / ((2 ** (1 / n)) ** (1 / 2)); //коэффициент для полосового фильтра
let width = kf * filter_frequency();
let width = kf * bpFreq();
return width;
}; //ширина фильтра спектра огибающей
@ -155,7 +155,7 @@ export function tolerance() {
}; return tol;
}; //максимальный коридор обнаружения гармоник (tolerance)
export function spec_params() {
export function specParams() {
let frq = 200; //ширина спектра
let res = 400; //частотное разрешение
function getStandart(value) {
@ -218,7 +218,7 @@ export function spec_params() {
};
};
export function spec_square(data, bnd, frq) {
export function specSquare(data, bnd, frq) {
let lines = data.length; //определение количества линий спектра вибрации
let res = frq / lines; //определение частотного разрешения спектра вибрации (основание прямоугольной трапеции)
let start = 1; //переменная для определения стартового индекса в массиве
@ -228,19 +228,19 @@ export function spec_square(data, bnd, frq) {
return S;
}; //определение площади спектра
export function mod_factor(ampl, base) {
export function modFactor(ampl, base) {
let dl = (ampl - base); //разность уровней гармонической и случайной составляющей вибрации
let df = spec_params().resolution / filter_width(); //отношение частотному разрешению спектра к ширине фильтра
let df = specParams().resolution / bpWidth(); //отношение частотному разрешению спектра к ширине фильтра
let mod = Math.sqrt((10 ** (dl / 10) - 1) * df) * 100;
return mod;
}; //определение условной глубины модуляции
export function deep_factor(ampl, base) {
export function deepFactor(ampl, base) {
let deep = (ampl - base) / (ampl + base) * 100;
return deep;
}; //определение условной глубины модуляции
export function ampl_factor(ampl, base) {
export function amplFactor(ampl, base) {
let crest = (ampl / base);
return crest;
}; //определение амплитудного коэффициента