2024-07-10 04:16:27 +03:00
|
|
|
|
export function getFreq(args) {
|
|
|
|
|
let FR = {}; //объект данных по частоте вращения
|
|
|
|
|
switch (record.tachoOptions.tachoState) {
|
|
|
|
|
case 0:
|
|
|
|
|
if (args != undefined) {
|
|
|
|
|
let __src = args.src; //источник сигнала частоты вращения
|
|
|
|
|
let __frq = args.freq; //граничная частота фильтрации сигнала
|
|
|
|
|
let __time = args.time; //интервал измерения частоты вращения
|
|
|
|
|
let __avg = args.avg; //количество отсчетов для усреднения
|
2024-07-17 07:37:36 +03:00
|
|
|
|
let __dc = 0; //порог срабатывания счетчика
|
|
|
|
|
if (args.dc != undefined) { __dc = args.dc };
|
2024-07-10 04:16:27 +03:00
|
|
|
|
|
|
|
|
|
let __fltr = gtl.add_filter_iir(__src);
|
|
|
|
|
__fltr.kind = gtl.filter_iir.butterworth;
|
|
|
|
|
__fltr.type = gtl.filter_iir.lowpass;
|
|
|
|
|
__fltr.order = 10;
|
|
|
|
|
__fltr.frequency = __frq;
|
|
|
|
|
|
|
|
|
|
let __freq = gtl.add_value_freq(__fltr);
|
|
|
|
|
__freq.time = __time;
|
|
|
|
|
__freq.avg_cnt = __avg;
|
|
|
|
|
__freq.dc = __dc;
|
|
|
|
|
FR["value"] = __freq.value * options.tachoRatio;
|
|
|
|
|
FR["values"] = __freq.values;
|
|
|
|
|
FR["time"] = args.time * args.avg;
|
|
|
|
|
} else {
|
|
|
|
|
FR["value"] = 0;
|
|
|
|
|
FR["values"] = [0];
|
|
|
|
|
FR["time"] = 0;
|
|
|
|
|
};
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
FR["value"] = record.tachoOptions.tachoValue * options.tachoRatio;
|
|
|
|
|
FR["values"] = [0];
|
|
|
|
|
FR["time"] = 0;
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
FR["value"] = record.tachoOptions.tachoFromInfo * options.tachoRatio;
|
|
|
|
|
FR["values"] = [0];
|
|
|
|
|
FR["time"] = 0;
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
return FR;
|
|
|
|
|
}; //определение частоты вращения в зависимости от источника тахо сигнала
|
|
|
|
|
|
|
|
|
|
export function freqIstab(src) {
|
|
|
|
|
let __max = Math.max(...src.values);
|
|
|
|
|
let __min = Math.min(...src.values);
|
|
|
|
|
let __instab = (__max - __min) / src.value;
|
|
|
|
|
return __instab;
|
|
|
|
|
}; //нестабильность частоты вращения в %
|
|
|
|
|
|
2023-11-15 16:06:15 +03:00
|
|
|
|
//параметры подшипника качения
|
|
|
|
|
var rbModelName = options.rbModelName || "No Name";
|
|
|
|
|
var rbVendor = options.rbVendor || "No Vendor";
|
2024-04-23 09:15:59 +03:00
|
|
|
|
var rb_inner = options.rbInnerD || 0; //диаметр внутреннего кольца
|
|
|
|
|
var rb_outer = options.rbOuterD || 0; //диаметр наружного кольца
|
|
|
|
|
var rb_roller = options.rbRollerD || 0; //диаметр тела качения
|
|
|
|
|
var rb_rollerCount = options.rbRollerCount || 0; //количество тел качения
|
|
|
|
|
var rb_angle = (options.rbAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.)
|
|
|
|
|
var rb_cage = (rb_inner + rb_outer) / 2; //диаметр сепаратора (средний диаметр)
|
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
//определение вспомогательных коэффициентов k1 и k2 для подшипников качения
|
|
|
|
|
let rb_k1 = 0.5 * (1 - (rb_roller / rb_cage) * Math.cos(rb_angle));
|
|
|
|
|
let rb_k2 = 0.5 * (1 + (rb_roller / rb_cage) * Math.cos(rb_angle));
|
2024-07-10 05:27:03 +03:00
|
|
|
|
export function FREQ(freq) { return freq }; //частота вращения
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function FTF(freq) { return rb_k1 * freq }; //частота вращения сепаратора (FTF)
|
|
|
|
|
export function BPFO(freq) { return rb_k1 * freq * rb_rollerCount }; //частота перекатывания тел качения по наружному кольцу (BPFO)
|
|
|
|
|
export function BPFI(freq) { return rb_k2 * freq * rb_rollerCount }; //частота перекатывания тел качения по внутреннему кольцу (BPFI)
|
|
|
|
|
export function BSF(freq) { return 2 * freq * (rb_cage / rb_roller) * rb_k1 * rb_k2 }; //частота вращения (контакта) тел качения (BSF)
|
2024-07-10 04:16:27 +03:00
|
|
|
|
export function freqNess() {
|
|
|
|
|
let R = (rb_inner / 2) + (rb_roller / 2); //расстояние до центра тяжести тела качения
|
|
|
|
|
let __fness = (Math.sqrt(9.81 / (4 * (Math.PI ** 2) * R / 1000))) / rb_k1;
|
|
|
|
|
return __fness;
|
|
|
|
|
}; //минимально необходимая частота вращения для компенсации силы тяжести центробежной силой
|
|
|
|
|
|
2024-04-23 09:15:59 +03:00
|
|
|
|
//параметры ШВП
|
|
|
|
|
var bsModelName = options.bsModelName || "No Name";
|
|
|
|
|
var bsVendor = options.bsVendor || "No Vendor";
|
|
|
|
|
var bs_inner = options.bsInnerD || 0; //диаметр внутреннего кольца
|
|
|
|
|
var bs_outer = options.bsOuterD || 0; //диаметр наружного кольца
|
|
|
|
|
var bs_roller = options.bsRollerD || 0; //диаметр тела качения
|
|
|
|
|
var bs_rollerCount = options.bsRollerCount || 0; //количество тел качения
|
|
|
|
|
var bs_angle = (options.bsAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.)
|
|
|
|
|
var bs_cage = (bs_inner + bs_outer) / 2; //средний диаметр
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
//определение вспомогательных коэффициентов k1 и k2 для ШВП
|
|
|
|
|
let bs_k1 = 0.5 * (1 - (bs_roller / bs_cage) * Math.cos(bs_angle));
|
|
|
|
|
let bs_k2 = 0.5 * (1 + (bs_roller / bs_cage) * Math.cos(bs_angle));
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function BSFTF(freq) { return bs_k1 * freq }; //частота вращения сепаратора (перемещения тел качения)
|
|
|
|
|
export function BSNUT(freq) { return bs_k1 * freq * bs_rollerCount }; //частота перекатывания тел качения по гайке
|
|
|
|
|
export function BSSCR(freq) { return bs_k2 * freq * bs_rollerCount }; //частота перекатывания тел качения по винту
|
|
|
|
|
export function BSBAL(freq) { return 2 * freq * (bs_cage / bs_roller) * bs_k1 * bs_k2 }; //частота вращения (контакта) тел качения
|
2024-07-10 04:16:27 +03:00
|
|
|
|
|
2023-11-15 16:06:15 +03:00
|
|
|
|
//параметры редуктора
|
|
|
|
|
var gtZ1 = options.gtZ1 || 0; //количество зубьев шестерни
|
|
|
|
|
var gtZ2 = options.gtZ2 || 0; //количество зубьев зубчатого колеса
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function GTFZ(freq) { return freq * gtZ1 }; //зубцовая частота
|
|
|
|
|
export function GTF2(freq) { return freq * (gtZ1 / gtZ2) }; //частота вращения второго вала редуктора
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры ременной передачи
|
|
|
|
|
var bdD1 = options.bdD1 || 0; //диаметр ведущего шкива
|
|
|
|
|
var bdD2 = options.bdD2 || 0; //диаметр ведомого шкива
|
|
|
|
|
var bdL = options.bdL || 0; //длинна ремня
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function BDF2(freq) { return freq * (bdD1 / bdD2) }; //частота вращения ведомого шкива
|
|
|
|
|
export function BDFB(freq) { return freq * (Math.PI * bdD1 / bdL) }; //частота вращения ремня
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры зубчатой ременной передачи
|
|
|
|
|
var cbdZ1 = options.cbdZ1 || 0; //количество зубьев ведущего шкива
|
|
|
|
|
var cbdZ2 = options.cbdZ2 || 0; //количество зубьев ведомого шкива
|
|
|
|
|
var cbdZ3 = options.cbdZ3 || 0; //количество зубьев ремня
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function CBFZ(freq) { return freq * cbdZ1 }; //зубцовая частота
|
|
|
|
|
export function CBDF2(freq) { return freq * (cbdZ1 / cbdZ2) }; //частота вращения ведомого шкива
|
|
|
|
|
export function CBDFB(freq) { return freq * (cbdZ1 / cbdZ3) }; //частота вращения ремня
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры насоса
|
|
|
|
|
var pmBlades = options.pmBlades || 0; //количество лопастей насосного колеса
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function PMFBLD(freq) { return freq * pmBlades }; //лопастная частота
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры планетарной передачи
|
|
|
|
|
var pgZ1 = options.pgZ1 || 0; //количество зубьев солнца
|
|
|
|
|
var pgZ2 = options.pgZ2 || 0; //количество зубьев саттелитов
|
|
|
|
|
var pgZ3 = options.pgZ3 || 0; //количество зубьев короны
|
|
|
|
|
var pgN = options.pgN || 0; //количество саттелитов
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function PGF2(freq) { return (0.5 * freq * pgZ1) / (pgZ1 + pgZ2) }; //частота вращения выходного вала планетарной передачи
|
|
|
|
|
export function PGFSAT(freq) { return (0.5 * freq) * (pgZ1 / pgZ2) * ((pgZ1 + 2 * pgZ2) / (pgZ1 + pgZ2)) }; //частота вращения саттелита
|
|
|
|
|
export function PGFZ(freq) { return pgZ2 * PGFSAT(freq) }; //зубцовая частота
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры турбины
|
|
|
|
|
var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины
|
2024-07-10 04:32:59 +03:00
|
|
|
|
export function TRFBLD(freq) { return freq * trBlades }; //лопастная частота
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
//параметры электродвигателя
|
|
|
|
|
//var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины
|
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
export function specParams(freq) {
|
|
|
|
|
let __fltr = {}; //объект расчетных параметров полосового фильтра
|
|
|
|
|
let __spec = {}; //объект расчетных параметров спектра
|
|
|
|
|
let __tol = 0; //коридор обнаружения гармоники
|
|
|
|
|
let __frq = 200; //граничная частота спектра
|
|
|
|
|
let __lines = 400; //количество линий спектра
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
let __filter = bpfFreq(freq); //центральная частота полосового фильтра
|
|
|
|
|
let __width = bpfWidth(3, __filter); //ширина полосового фильтра для спектра огибающей
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
function bpfFreq(rps) {
|
|
|
|
|
let __filter = 1850 * Math.sqrt(rps);
|
|
|
|
|
//let __filter = 6013.41 * Math.log(0.266935 * rps + 1.1201);
|
|
|
|
|
return __filter;
|
|
|
|
|
};
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-10 04:16:27 +03:00
|
|
|
|
function bpfWidth(n, filter) {
|
|
|
|
|
let kf = (2 ** (1 / n) - 1) / ((2 ** (1 / n)) ** 0.5); //коэффициент для полосового фильтра
|
|
|
|
|
let __wdt = kf * filter;
|
|
|
|
|
return __wdt;
|
|
|
|
|
};
|
2024-04-23 08:17:44 +03:00
|
|
|
|
|
|
|
|
|
function getStandart(value) {
|
2024-07-10 04:16:27 +03:00
|
|
|
|
let arr = [50, 100, 200, 400, 800, 1600, 3200, 6400, 12800];
|
|
|
|
|
let __res = 0;
|
|
|
|
|
arr.some((elem, i) => { if (value <= elem) { __res = arr[i]; return __res; }; });
|
|
|
|
|
return __res;
|
2024-04-23 08:17:44 +03:00
|
|
|
|
};
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
|
|
|
|
switch (options.objectType) {
|
|
|
|
|
case 0: //объект не выбран
|
|
|
|
|
break;
|
|
|
|
|
case 1: //подшипник скольжения
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__tol = 0;
|
|
|
|
|
__frq = 20 * freq;
|
|
|
|
|
__lines = __frq / (freq / 8);
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 2: //подшипник качения
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__tol = (2 * FTF(freq)) / (5 * BPFO(freq));
|
|
|
|
|
__frq = getStandart(5 * BPFI(freq) + 4 * freq);
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 3: //ШВП
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__tol = (2 * BSFTF(freq)) / (5 * BSNUT(freq));
|
|
|
|
|
__frq = getStandart(5 * BSSCR(freq) + 4 * freq);
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 4: //редуктор
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__tol = (2 * freq) / (5 * GTFZ(freq));
|
|
|
|
|
__frq = getStandart(3 * GTFZ(freq) + 4 * freq);
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 5: //ременная передача
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__tol = 0;
|
|
|
|
|
__frq = getStandart(400);
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__lines = getStandart(__frq / (BDFB(freq) / 4));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 6: //зубчатый ремень
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__tol = 0;
|
|
|
|
|
__frq = getStandart(400);
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__lines = getStandart(__frq / (CBDFB(freq) / 4));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
2024-07-10 04:16:27 +03:00
|
|
|
|
case 7: //помпа (насос)
|
|
|
|
|
__tol = 0;
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__frq = getStandart(3 * PMFBLD(freq) + 4 * freq);
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 8: //планетарый редуктор
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__tol = (2 * PGF2(freq)) / (5 * PGFZ(freq));
|
|
|
|
|
__frq = getStandart(3 * PGFZ(freq) + 4 * freq);
|
|
|
|
|
__lines = getStandart(__frq / (PGF2(freq) / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 9: //турбина
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__tol = 0;
|
2024-07-10 04:32:59 +03:00
|
|
|
|
__frq = getStandart(3 * TRFBLD(freq) + 4 * freq);
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
|
|
|
|
case 10: //электродвигатель
|
2024-07-10 04:16:27 +03:00
|
|
|
|
__tol = 0;
|
|
|
|
|
__frq = getStandart(400);
|
|
|
|
|
__lines = getStandart(__frq / (freq / 8));
|
2023-11-15 16:06:15 +03:00
|
|
|
|
break;
|
2024-04-23 09:15:59 +03:00
|
|
|
|
};
|
2024-07-10 04:16:27 +03:00
|
|
|
|
|
|
|
|
|
__fltr["frequency"] = __filter;
|
|
|
|
|
__fltr["width"] = __width;
|
|
|
|
|
__spec["frequency"] = __frq;
|
|
|
|
|
__spec["lines"] = __lines;
|
|
|
|
|
__spec["resolution"] = __frq / __lines;
|
|
|
|
|
__spec["tolerance"] = __tol;
|
|
|
|
|
|
|
|
|
|
return {
|
|
|
|
|
filter: __fltr,
|
|
|
|
|
spec: __spec
|
|
|
|
|
};
|
|
|
|
|
}; //рассчетные параметры спектра вибрации
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-03 02:57:42 +03:00
|
|
|
|
export function specSquare(spec, L, R) {
|
2024-07-17 07:37:36 +03:00
|
|
|
|
let __base = spec.base; //массив значений средней линии
|
|
|
|
|
let __data = spec.data; //массив значений амплитуд
|
|
|
|
|
let __lines = spec.data.length; //количества линий спектра
|
|
|
|
|
let __res = spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции)
|
|
|
|
|
let __start = 0; //стартовый индекс в массиве
|
|
|
|
|
let __end = __lines; //конечный индекс в массиве
|
2024-07-03 02:57:42 +03:00
|
|
|
|
let s0 = 0; //площадь под базовой линией
|
|
|
|
|
let s1 = 0; //площадь всего спектра
|
|
|
|
|
let s2 = 0; //площадь над базовой линией
|
|
|
|
|
let s3 = 0; //площадь обнаруженных гармоник
|
2024-07-17 07:37:36 +03:00
|
|
|
|
if (L != undefined) { __start = Math.round(L / __res) };
|
|
|
|
|
if (R != undefined) { __end = Math.round(R / __res) };
|
2024-07-03 02:57:42 +03:00
|
|
|
|
|
2024-07-17 07:37:36 +03:00
|
|
|
|
for (let i = __start; i <= __end - 1; i++) {
|
2024-07-23 04:08:35 +03:00
|
|
|
|
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 };
|
2024-07-03 02:57:42 +03:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return {
|
|
|
|
|
base: s0,
|
|
|
|
|
spec: s1,
|
|
|
|
|
harm: s2,
|
|
|
|
|
peak: s3
|
|
|
|
|
};
|
|
|
|
|
}; //определение площадей спектра
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-07-08 03:06:00 +03:00
|
|
|
|
export function modFactor(options) {
|
2024-07-17 07:37:36 +03:00
|
|
|
|
let __dl = (options.ampl - options.base); //разность уровней гармонической и случайной составляющей вибрации
|
|
|
|
|
let __df = options.spec.frequency / options.fltr.width; //отношение граничной частоты спектра к ширине фильтра
|
|
|
|
|
let __mod = Math.sqrt((10 ** (__dl / 10) - 1) * __df);
|
|
|
|
|
return __mod;
|
2024-07-03 03:45:56 +03:00
|
|
|
|
}; //определение глубины модуляции ВЧ составляющих
|
2023-11-15 16:06:15 +03:00
|
|
|
|
|
2024-06-11 08:41:46 +03:00
|
|
|
|
export function deepFactor(ampl, base) {
|
2024-07-17 07:37:36 +03:00
|
|
|
|
let __deep = (ampl - base) / (ampl + base) * 100;
|
|
|
|
|
return __deep;
|
2023-11-15 16:06:15 +03:00
|
|
|
|
}; //определение условной глубины модуляции
|
|
|
|
|
|
2024-06-11 08:41:46 +03:00
|
|
|
|
export function amplFactor(ampl, base) {
|
2024-07-17 07:37:36 +03:00
|
|
|
|
let __crest = (ampl / base);
|
|
|
|
|
return __crest;
|
2023-11-15 16:06:15 +03:00
|
|
|
|
}; //определение амплитудного коэффициента
|
2024-07-23 04:08:35 +03:00
|
|
|
|
|
|
|
|
|
export 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;
|
|
|
|
|
}; //перевод значений массива в дБ
|
|
|
|
|
|
|
|
|
|
export function getAusp(args) {
|
|
|
|
|
let __ausp = gtl.add_ausp(args.src);
|
|
|
|
|
__ausp.name = args.name;
|
|
|
|
|
__ausp.color = args.color;
|
|
|
|
|
__ausp.frequency = args.frequency;
|
|
|
|
|
__ausp.resolution = args.resolution;
|
|
|
|
|
__ausp.average = args.average;
|
|
|
|
|
__ausp.unit = args.view;
|
|
|
|
|
if (args.level != undefined) { __ausp.peak_level = args.level }; //порог обнаружения гармоник
|
|
|
|
|
|
|
|
|
|
__ausp.overlap = 0.5; //коэффициент перекрытия
|
|
|
|
|
__ausp.window = gtl.spec.rectangular; //тип окна
|
|
|
|
|
__ausp.smoothing_factor = 100; //коэффициент сглаживания спектра
|
|
|
|
|
__ausp.smoothed_line_color = 0xFFFF00; //цвет средней линии
|
|
|
|
|
__ausp.harm_tolerance = __ausp.resolution; //диапазон поиска гармоник +/-
|
|
|
|
|
return __ausp;
|
|
|
|
|
}; //построение спектра вибрации
|
|
|
|
|
|
|
|
|
|
export function getSpen(args) {
|
|
|
|
|
let __spen = gtl.add_spen(args.src);
|
|
|
|
|
__spen.name = args.name;
|
|
|
|
|
__spen.color = args.color;
|
|
|
|
|
__spen.frequency = args.frequency;
|
|
|
|
|
__spen.resolution = args.resolution;
|
|
|
|
|
__spen.average = args.average;
|
|
|
|
|
__spen.unit = args.view;
|
|
|
|
|
if (args.level != undefined) { __spen.peak_level = args.level }; //порог обнаружения гармоник
|
|
|
|
|
|
|
|
|
|
__spen.overlap = 0.5; //коэффициент перекрытия
|
|
|
|
|
__spen.window = gtl.spec.rectangular; //тип окна
|
|
|
|
|
__spen.smoothing_factor = 100; //коэффициент сглаживания спектра
|
|
|
|
|
__spen.smoothed_line_color = 0xFFFF00; //цвет средней линии
|
|
|
|
|
__spen.harm_tolerance = __spen.resolution; //диапазон поиска гармоник +/-
|
|
|
|
|
|
|
|
|
|
return __spen;
|
|
|
|
|
}; //построение спектра огибающей
|
|
|
|
|
|
2024-07-24 09:39:38 +03:00
|
|
|
|
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]; //название гармонического ряда
|
2024-07-25 03:57:53 +03:00
|
|
|
|
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]; //пороговый уровень сильного дефекта
|
2024-07-24 09:39:38 +03:00
|
|
|
|
|
|
|
|
|
let __row = __tools.harms.add(
|
|
|
|
|
{
|
|
|
|
|
frequency: __freq, //функциональная частота
|
2024-07-25 03:57:53 +03:00
|
|
|
|
count: __count, //количество гармоник
|
2024-07-24 09:39:38 +03:00
|
|
|
|
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;
|
|
|
|
|
}; //Построение компонентов и частотных линий на спектре
|
|
|
|
|
|
2024-07-23 04:08:35 +03:00
|
|
|
|
export function getStdMeasures(options) {
|
|
|
|
|
let __source = options.src;
|
|
|
|
|
let __time = 0.1;
|
|
|
|
|
let __avg = 5;
|
|
|
|
|
|
|
|
|
|
if (options.time != undefined) { __time = options.time };
|
|
|
|
|
if (options.avg != undefined) { __avg = options.avg };
|
|
|
|
|
|
|
|
|
|
function getFilter(L, R) {
|
|
|
|
|
let __filter = gtl.add_filter_iir(__source);
|
|
|
|
|
__filter.kind = gtl.filter_iir.butterworth;
|
|
|
|
|
__filter.order = 10;
|
|
|
|
|
|
|
|
|
|
switch (L) {
|
|
|
|
|
case "lowpass":
|
|
|
|
|
__filter.type = gtl.filter_iir.lowpass;
|
|
|
|
|
__filter.frequency = R;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case "highpass":
|
|
|
|
|
__filter.type = gtl.filter_iir.highpass;
|
|
|
|
|
__filter.frequency = R;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
__filter.type = gtl.filter_iir.bandpass;
|
|
|
|
|
__filter.frequency = (R - L) / 2 + L;
|
|
|
|
|
__filter.width = R - L;
|
|
|
|
|
break;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return __filter;
|
|
|
|
|
}; //формирование фильтра
|
|
|
|
|
|
|
|
|
|
function getIntg(src, taps, scale) {
|
|
|
|
|
let __intg = gtl.add_intg(src);
|
|
|
|
|
__intg.taps = taps;
|
|
|
|
|
__intg.scale = scale;
|
|
|
|
|
|
|
|
|
|
return __intg;
|
|
|
|
|
}; //интегрирование сигнала
|
|
|
|
|
|
|
|
|
|
function getRMS(src) {
|
|
|
|
|
let __rms = gtl.add_value_rms(src);
|
|
|
|
|
__rms.time = __time;
|
|
|
|
|
__rms.avg_cnt = __avg;
|
|
|
|
|
|
|
|
|
|
return __rms;
|
|
|
|
|
}; //получение СКЗ
|
|
|
|
|
|
|
|
|
|
function getAmpl(src) {
|
|
|
|
|
let __ampl = gtl.add_value_ampl(src);
|
|
|
|
|
__ampl.time = __time;
|
|
|
|
|
__ampl.avg_cnt = __avg;
|
|
|
|
|
|
|
|
|
|
return __ampl;
|
|
|
|
|
}; //получение амплитуды
|
|
|
|
|
|
|
|
|
|
function getPtP(src) {
|
2024-08-22 02:28:17 +03:00
|
|
|
|
let __ptp = gtl.add_value_peak_to_peak(src);
|
|
|
|
|
__ptp.time = __time;
|
|
|
|
|
__ptp.avg_cnt = __avg;
|
2024-07-23 04:08:35 +03:00
|
|
|
|
|
|
|
|
|
return __ptp;
|
|
|
|
|
}; //получение размаха
|
|
|
|
|
|
|
|
|
|
function getKurt(src) {
|
|
|
|
|
let __kurt = gtl.add_value_kurt(src);
|
|
|
|
|
__kurt.time = __time;
|
|
|
|
|
__kurt.avg_cnt = __avg;
|
|
|
|
|
|
|
|
|
|
return __kurt;
|
|
|
|
|
}; //получение эксцесса
|
|
|
|
|
|
|
|
|
|
//[Набор фильтров]
|
|
|
|
|
let __filter_2_200 = getFilter(2, 200);
|
|
|
|
|
let __filter_2_1000 = getFilter(2, 1000);
|
|
|
|
|
let __filter_10_1000 = getFilter(10, 1000);
|
|
|
|
|
let __filter_2_3000 = getFilter(2, 3000);
|
|
|
|
|
let __filter_2_10000 = getFilter(2, 10000);
|
|
|
|
|
let __filter_100_10000 = getFilter(100, 10000);
|
|
|
|
|
let __filter_2_5k = getFilter(2500, 5000);
|
|
|
|
|
let __filter_5_10k = getFilter(5000, 10000);
|
|
|
|
|
let __filter_10_20k = getFilter(10000, 20000);
|
|
|
|
|
let __filter_30_40k = getFilter(30000, 40000);
|
|
|
|
|
let __filter_40_80k = getFilter(40000, 80000);
|
|
|
|
|
|
|
|
|
|
//[Набор интеграторов]
|
|
|
|
|
let __pre_int1 = getIntg(__filter_2_1000, 1, 1000);
|
|
|
|
|
let __pre_int2 = getIntg(__filter_10_1000, 1, 1000);
|
|
|
|
|
let __pre_int3 = getIntg(__filter_2_200, 2, 1);
|
|
|
|
|
|
|
|
|
|
//[Расчет набора параметров]
|
|
|
|
|
let __rms_A2_3000 = getRMS(__filter_2_3000); //СКЗ виброускорения в диапазоне 2-3000 Гц
|
|
|
|
|
let __rms_A2_10000 = getRMS(__filter_2_10000); //СКЗ виброускорения в диапазоне 2-10000 Гц
|
|
|
|
|
let __rms_A100_10000 = getRMS(__filter_100_10000); //СКЗ виброускорения в диапазоне 100-10000 Гц
|
|
|
|
|
|
|
|
|
|
let __ampl_A100_10000 = getAmpl(__filter_100_10000); //амплитуда виброускорения в диапазоне 100-10000 Гц
|
|
|
|
|
let __ampl_full = getAmpl(__source); //амплитуда виброускорения во всем диапазоне измерения
|
|
|
|
|
|
|
|
|
|
let __rms_V2_1000 = getRMS(__pre_int1); //СКЗ виброскорости в диапазоне 2-1000 Гц
|
|
|
|
|
let __rms_V10_1000 = getRMS(__pre_int2); //СКЗ виброскорости в диапазоне 10-1000 Гц
|
|
|
|
|
let __rms_S2_200 = getRMS(__pre_int3); //СКЗ виброперемещения в диапазоне 2-200 Гц
|
|
|
|
|
|
|
|
|
|
let __ptp_S2_200 = getPtP(__pre_int3); //размах виброперемещения в диапазоне 2-200 Гц
|
|
|
|
|
|
|
|
|
|
let __kurt_full = getKurt(__source); //эксцесс во всем диапазоне измерения
|
|
|
|
|
let __kurt_2_5k = getKurt(__filter_2_5k); //эксцесс в полосе 2.5-5 кГц
|
|
|
|
|
let __kurt_5_10k = getKurt(__filter_5_10k); //эксцесс в полосе 5-10 кГц
|
|
|
|
|
let __kurt_10_20k = getKurt(__filter_10_20k); //эксцесс в полосе 10-20 кГц
|
|
|
|
|
let __kurt_30_40k = getKurt(__filter_30_40k); //эксцесс в полосе 30-40 кГц
|
|
|
|
|
let __kurt_40_80k = getKurt(__filter_40_80k); //эксцесс в полосе 40-80 кГц
|
|
|
|
|
|
|
|
|
|
let __result = {
|
|
|
|
|
rms_A2_3000: __rms_A2_3000,
|
|
|
|
|
rms_A2_10000: __rms_A2_10000,
|
|
|
|
|
rms_A100_10000: __rms_A100_10000,
|
|
|
|
|
ampl_A100_10000: __ampl_A100_10000,
|
|
|
|
|
ampl_full: __ampl_full,
|
|
|
|
|
rms_V2_1000: __rms_V2_1000,
|
|
|
|
|
rms_V10_1000: __rms_V10_1000,
|
|
|
|
|
rms_S2_200: __rms_S2_200,
|
|
|
|
|
ptp_S2_200: __ptp_S2_200,
|
|
|
|
|
kurt_full: __kurt_full,
|
|
|
|
|
kurt_2_5k: __kurt_2_5k,
|
|
|
|
|
kurt_5_10k: __kurt_5_10k,
|
|
|
|
|
kurt_10_20k: __kurt_10_20k,
|
|
|
|
|
kurt_30_40k: __kurt_30_40k,
|
|
|
|
|
kurt_40_80k: __kurt_40_80k,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return __result;
|
|
|
|
|
}; //измерение стандартных параметров
|