diff --git a/getCorr.js b/getCorr.js deleted file mode 100644 index c2e48fb..0000000 --- a/getCorr.js +++ /dev/null @@ -1,64 +0,0 @@ -export function getCorr(src1, src2) { - let arr1 = src1.data; - let arr2 = src2.data; - let X = 0; //аргумент 1 - let Y = 0; //аргумент 2 - let Z = 0; //аргумент 3 - let arr1_avg = arr1.reduce((acc, item) => (acc + item)) / arr1.length; //среднее значение массива 1 - let arr2_avg = arr2.reduce((acc, item) => (acc + item)) / arr2.length; //среднее значение массива 2 - - for (let i = 0; i < arr1.length; i++) { - X += (arr1[i] - arr1_avg) * (arr2[i] - arr2_avg); - Y += (arr1[i] - arr1_avg) ** 2; - Z += (arr2[i] - arr2_avg) ** 2; - }; - - return X / (Math.sqrt(Y) * Math.sqrt(Z)); -}; //рассчет корреляции - -export function getAutoCorr(options) { - let result = {}; //результат - let plot = []; //массив значений корреляции для графика - let arr = options.src.data; - 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)); //рассчитываем знаменатель функции - - for (let i = 0; i < T; i++) { - let Rh = arr.slice(- i); //отделяем "хвост" массива - let Lt = arr.slice(0, - i); //отделяем "тело" массива - let arr2 = [].concat(Rh, Lt); //соединяем части массива - for (let j = 0; j < arr.length; j++) { X += (arr[j] - avg) * (arr2[j] - avg); }; - plot.push(X / Y); //записываем значение в массив коэффициентов - X = 0; - }; //смещение массива - - let plot0 = plot.slice(Math.floor(0.01 * plot.length)); //убираем из массива первый 1% значений коэффициента (т.к. в нуле всегда значение 1.0) - let akf_avg = plot0.reduce((acc, item) => (acc + Math.abs(item))) / plot0.length; //среднее значение коэффициента - let akf_sqr = plot0.reduce((acc, item) => (acc + item ** 2)); //сумма квадратов значений - 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; - - //отрисовка графика на plot - if (options.canvas != undefined) { - options.canvas.add( - { - color: options.color, - name: options.name, - x: options.src.resolution, - y: plot - } - ); - }; - - return result; -}; //рассчет автокорреляции \ No newline at end of file diff --git a/getStdMeasures.js b/getMeasures.js similarity index 58% rename from getStdMeasures.js rename to getMeasures.js index 600a65a..2b08c6e 100644 --- a/getStdMeasures.js +++ b/getMeasures.js @@ -1,3 +1,81 @@ +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; //количество отсчетов для усреднения + let __dc = args.dc; //порог срабатывания счетчика + + 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 getAusp(args) { + let __ausp = gtl.add_ausp(args.src); + __ausp.name = args.name; + __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 = 50; //коэффициент сглаживания спектра + __ausp.smoothed_line_color = 0x0000FF; //цвет средней линии + __ausp.harm_tolerance = __ausp.resolution; //диапазон поиска гармоник +/- + return __ausp; +}; //построение спектра вибрации + +export function getSpen(args) { + let __spen = gtl.add_spen(args.src); + __spen.name = args.name; + __spen.frequency = args.frequency; + __spen.resolution = args.resolution; + __spen.average = args.average; + __spen.unit = args.view; + __spen.peak_level = args.level; //порог обнаружения гармоник + + __spen.overlap = 0.5; //коэффициент перекрытия + __spen.window = gtl.spec.rectangular; //тип окна + __spen.smoothing_factor = 50; //коэффициент сглаживания спектра + __spen.smoothed_line_color = 0x0000FF; //цвет средней линии + __spen.harm_tolerance = __spen.resolution; //диапазон поиска гармоник +/- + return __spen; +}; //построение спектра огибающей + export function getStdMeasures(options) { let __source = options.src; let __time = 0.1; diff --git a/getMask.js b/maskVM.js similarity index 97% rename from getMask.js rename to maskVM.js index e4b1bf7..a7b20c0 100644 --- a/getMask.js +++ b/maskVM.js @@ -13,7 +13,7 @@ export function specModel(options) { }; //формируем результат - result["name"] = "model_" + options.src.name; + result["name"] = options.src.name + "_model"; result["resolution"] = options.src.resolution; result["data"] = model; @@ -64,7 +64,7 @@ export function getMask(options) { Z += (b[i] - b_avg) ** 2; }; - return X / (Math.sqrt(Y) * Math.sqrt(Z)); + if (X <= 0) { return 0 } else { return X / (Math.sqrt(Y) * Math.sqrt(Z)) }; }; let arr1 = []; diff --git a/peakVM.js b/peakVM.js new file mode 100644 index 0000000..2a446a4 --- /dev/null +++ b/peakVM.js @@ -0,0 +1,222 @@ +export function getCorr(src1, src2) { + let arr1 = src1.data; + let arr2 = src2.data; + let X = 0; //аргумент 1 + let Y = 0; //аргумент 2 + let Z = 0; //аргумент 3 + let arr1_avg = arr1.reduce((acc, item) => (acc + item)) / arr1.length; //среднее значение массива 1 + let arr2_avg = arr2.reduce((acc, item) => (acc + item)) / arr2.length; //среднее значение массива 2 + + for (let i = 0; i < arr1.length; i++) { + X += (arr1[i] - arr1_avg) * (arr2[i] - arr2_avg); + Y += (arr1[i] - arr1_avg) ** 2; + Z += (arr2[i] - arr2_avg) ** 2; + }; + + return X / (Math.sqrt(Y) * Math.sqrt(Z)); +}; //рассчет корреляции + +export function getAutoCorr(options) { + let result = {}; //результат + let plot = []; //массив значений корреляции для графика + let arr = options.src.data; + 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)); //рассчитываем знаменатель функции + + for (let i = 0; i < T; i++) { + let Rh = arr.slice(- i); //отделяем "хвост" массива + let Lt = arr.slice(0, - i); //отделяем "тело" массива + let arr2 = [].concat(Rh, Lt); //соединяем части массива + for (let j = 0; j < arr.length; j++) { X += (arr[j] - avg) * (arr2[j] - avg); }; + plot.push(X / Y); //записываем значение в массив коэффициентов + X = 0; + }; //смещение массива + + let plot0 = plot.slice(Math.floor(0.01 * plot.length)); //убираем из массива первый 1% значений коэффициента (т.к. в нуле всегда значение 1.0) + let akf_avg = plot0.reduce((acc, item) => (acc + Math.abs(item))) / plot0.length; //среднее значение коэффициента + let akf_sqr = plot0.reduce((acc, item) => (acc + item ** 2)); //сумма квадратов значений + 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; + + //отрисовка графика на plot + if (options.canvas != undefined) { + options.canvas.add( + { + color: options.color, + name: options.name, + x: options.src.resolution, + y: plot + } + ); + }; + + return result; +}; //рассчет автокорреляции + +export function getParams(freq) { + let rpm = freq * 60; //частота в об/мин + let wdt = 0; //граничная частота ФВЧ + let frq = 40 * freq; //граничная частота спектра + let avg = 1; //количество усреднений спектра + let lns = 800; //количество линий спектра + + 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 { + width: wdt, + frequency: frq, + avg: avg, + lines: lns + }; +}; //рассчет параметров спектра + +export function getLevels(freq) { + let rpm = freq * 60; //частота в об/мин + let alr = 0; //уровень предупреждения, g + switch (true) { + case rpm <= 900: + alr = 3.0 * (rpm / 900) ** 0.75; + break; + case (rpm > 900) && (rpm <= 4000): + alr = 3.0; + break; + case (rpm > 4000) && (rpm <= 10000): + alr = 3.0 * (rpm / 4000) ** 0.5; + break; + case rpm > 10000: + alr = 5.0; + default: + break; + }; + return alr +}; //рассчет пороговых уровней + +export function specSquare(spec, L, R) { + let base = spec.base; //массив значений средней линии + let data = spec.data; //массив значений амплитуд + let lines = spec.data.length; //количества линий спектра + let res = spec.resolution; //частотное разрешения спектра (высота прямоугольной трапеции) + let peaks = spec.peaks; //массив обнаруженных гармоник (объекты) + 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 += 0.5 * (base[i] + base[i + 1]) * res; + s1 += 0.5 * (data[i] + data[i + 1]) * res; + if ((s1 - s0) >= 0) { s2 += s1 - s0 }; + if (i <= peaks.length - 1) { s3 += res * peaks[i].level }; + }; + + return { + base: s0, + spec: s1, + harm: s2, + peak: s3 + }; +}; //определение площадей спектра + +export function getPeakVue(options) { + let wav = options.src.data; //массив данных пиковой формы + let crr = options.corr; //результат расчета автокорреляции + let mech = 0; //механические проблемы + let lubr = 0; //проблемы со смазкой + let allert = getLevels(options.freq); //определяем уровень предупреждения, g + + let MaxPK = Math.max(...wav) / 9.81; //максимальное значение амплитуды на пиковой форме, g + let FaultLevel = 2 * allert; //уровень аварии для пиковой формы (Fault = 2 * Allert) + let EstPE = Math.sqrt(crr.ampl) * 100; //расчетный процент периодической энергии + + switch (true) { + case EstPE >= 50: + mech = EstPE * MaxPK / FaultLevel; + lubr = (100 - EstPE) * MaxPK / FaultLevel; + break; + case EstPE < 50: + mech = 0 + lubr = MaxPK / FaultLevel; + break; + default: + break; + }; //определяем действительный расчетный процент периодической энергии + + return { + mechBS: mech, + lubrBS: lubr + }; +}; //оценка состояния методом PeakVue + +export function getPeakVuePlus(options) { + let wav = options.src.data; //массив данных пиковой формы + let spc = options.spec; //объект спектра пиковой формы + let crr = options.corr; //результат расчета автокорреляции + let mech = 0; //механические проблемы + let lubr = 0; //проблемы со смазкой + let allert = getLevels(options.freq); //определяем уровень предупреждения, g + + let MaxPK = Math.max(...wav) / 9.81; //максимальное значение амплитуды на пиковой форме, g + let FaultLevel = 2 * allert; //уровень аварии для пиковой формы (Fault = 2 * Allert) + let EstPE = Math.sqrt(crr.ampl) * 100; //расчетный процент периодической энергии + + switch (true) { + case (EstPE <= 50) && (EstPE > 30): + EstPE = EstPE / 2; + break; + case EstPE < 30: + EstPE = 0; + break; + default: + break; + }; //определяем действительный расчетный процент периодической энергии + + 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; + + return { + mechBS: mech, + lubrBS: lubr, + mechInd: mech * 0.8, //нормализованное значение (для индикатора 0-100 единиц) + lubrInd: lubr * 0.8 //нормализованное значение (для индикатора 0-100 единиц) + }; +}; //оценка состояния методом PeakVuePlus diff --git a/userFunctions.js b/userFunctions.js index 5be3cf4..56855ed 100644 --- a/userFunctions.js +++ b/userFunctions.js @@ -1,3 +1,54 @@ +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; //количество отсчетов для усреднения + let __dc = args.dc; //порог срабатывания счетчика + + 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; +}; //нестабильность частоты вращения в % + //параметры подшипника качения var rbModelName = options.rbModelName || "No Name"; var rbVendor = options.rbVendor || "No Vendor"; @@ -8,6 +59,19 @@ var rb_rollerCount = options.rbRollerCount || 0; //количество тел var rb_angle = (options.rbAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.) var rb_cage = (rb_inner + rb_outer) / 2; //диаметр сепаратора (средний диаметр) +//определение вспомогательных коэффициентов 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)); +export function FTF() { return rb_k1 * FREQ(); }; //частота вращения сепаратора (FTF) +export function BPFO() { return rb_k1 * FREQ() * rb_rollerCount; }; //частота перекатывания тел качения по наружному кольцу (BPFO) +export function BPFI() { return rb_k2 * FREQ() * rb_rollerCount; }; //частота перекатывания тел качения по внутреннему кольцу (BPFI) +export function BSF() { return 2 * FREQ() * (rb_cage / rb_roller) * rb_k1 * rb_k2; }; //частота вращения (контакта) тел качения (BSF) +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; +}; //минимально необходимая частота вращения для компенсации силы тяжести центробежной силой + //параметры ШВП var bsModelName = options.bsModelName || "No Name"; var bsVendor = options.bsVendor || "No Vendor"; @@ -18,205 +82,151 @@ var bs_rollerCount = options.bsRollerCount || 0; //количество тел var bs_angle = (options.bsAngle * Math.PI) / 180 || 0; //угол контакта тел качения (рад.) var bs_cage = (bs_inner + bs_outer) / 2; //средний диаметр +//определение вспомогательных коэффициентов 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)); +export function BSFTF() { return bs_k1 * FREQ(); }; //частота вращения сепаратора (перемещения тел качения) +export function BSNUT() { return bs_k1 * FREQ() * bs_rollerCount; }; //частота перекатывания тел качения по гайке +export function BSSCR() { return bs_k2 * FREQ() * bs_rollerCount; }; //частота перекатывания тел качения по винту +export function BSBAL() { return 2 * FREQ() * (bs_cage / bs_roller) * bs_k1 * bs_k2; }; //частота вращения (контакта) тел качения + //параметры редуктора var gtZ1 = options.gtZ1 || 0; //количество зубьев шестерни var gtZ2 = options.gtZ2 || 0; //количество зубьев зубчатого колеса +export function GTFZ() { return FREQ() * gtZ1; }; //зубцовая частота +export function GTF2() { return FREQ() * (gtZ1 / gtZ2); }; //частота вращения второго вала редуктора //параметры ременной передачи var bdD1 = options.bdD1 || 0; //диаметр ведущего шкива var bdD2 = options.bdD2 || 0; //диаметр ведомого шкива var bdL = options.bdL || 0; //длинна ремня +export function BDF2() { return FREQ() * (bdD1 / bdD2) }; //частота вращения ведомого шкива +export function BDFB() { return FREQ() * (Math.PI * bdD1 / bdL) }; //частота вращения ремня //параметры зубчатой ременной передачи var cbdZ1 = options.cbdZ1 || 0; //количество зубьев ведущего шкива var cbdZ2 = options.cbdZ2 || 0; //количество зубьев ведомого шкива var cbdZ3 = options.cbdZ3 || 0; //количество зубьев ремня +export function CBFZ() { return FREQ() * cbdZ1; }; //зубцовая частота +export function CBDF2() { return FREQ() * (cbdZ1 / cbdZ2) }; //частота вращения ведомого шкива +export function CBDFB() { return FREQ() * (cbdZ1 / cbdZ3) }; //частота вращения ремня //параметры насоса var pmBlades = options.pmBlades || 0; //количество лопастей насосного колеса +export function PMFBLD() { return FREQ() * pmBlades; }; //лопастная частота //параметры планетарной передачи var pgZ1 = options.pgZ1 || 0; //количество зубьев солнца var pgZ2 = options.pgZ2 || 0; //количество зубьев саттелитов var pgZ3 = options.pgZ3 || 0; //количество зубьев короны var pgN = options.pgN || 0; //количество саттелитов - -//параметры турбины -var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины - -//параметры электродвигателя -//var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины - -export function FREQ(src) { - let FR = 0; - if (src != undefined) { FR = src.value * options.tachoRatio } else { - switch (record.tachoOptions.tachoState) { - case 1: - FR = record.tachoOptions.tachoValue * options.tachoRatio; - break; - case 2: - FR = record.tachoOptions.tachoFromInfo * options.tachoRatio; - break; - }; - }; - return FR; -}; //определение частоты вращения в зависимости от источника тахо сигнала (FREQ) - -export function freqIstab(src) { - let freq_max = Math.max(...src.values); - let freq_min = Math.min(...src.values); - let instab = (freq_max - freq_min) / src.value; - return instab; -}; //нестабильность частоты вращения в % - -//определение вспомогательных коэффициентов k1 и k2 для подшипников качения и ШВП -var rb_k1 = 0.5 * (1 - (rb_roller / rb_cage) * Math.cos(rb_angle)); -var rb_k2 = 0.5 * (1 + (rb_roller / rb_cage) * Math.cos(rb_angle)); -var bs_k1 = 0.5 * (1 - (bs_roller / bs_cage) * Math.cos(bs_angle)); -var bs_k2 = 0.5 * (1 + (bs_roller / bs_cage) * Math.cos(bs_angle)); - -export function freqNess() { - let R = (rb_inner / 2) + (rb_roller / 2); //расстояние до центра тяжести тела качения - let freqness = (Math.sqrt(9.81 / (4 * (Math.PI ** 2) * R / 1000))) / rb_k1; - return freqness; -}; //минимально необходимая частота вращения для компенсации силы тяжести центробежной силой - -export function FTF() { return rb_k1 * FREQ(); }; //частота вращения сепаратора (FTF) -export function BPFO() { return rb_k1 * FREQ() * rb_rollerCount; }; //частота перекатывания тел качения по наружному кольцу (BPFO) -export function BPFI() { return rb_k2 * FREQ() * rb_rollerCount; }; //частота перекатывания тел качения по внутреннему кольцу (BPFI) -export function BSF() { return 2 * FREQ() * (rb_cage / rb_roller) * rb_k1 * rb_k2; }; //частота вращения (контакта) тел качения (BSF) - -export function BSFTF() { return bs_k1 * FREQ(); }; //частота вращения сепаратора (перемещения тел качения) -export function BSNUT() { return bs_k1 * FREQ() * bs_rollerCount; }; //частота перекатывания тел качения по гайке -export function BSSCR() { return bs_k2 * FREQ() * bs_rollerCount; }; //частота перекатывания тел качения по винту -export function BSBAL() { return 2 * FREQ() * (bs_cage / bs_roller) * bs_k1 * bs_k2; }; //частота вращения (контакта) тел качения - -export function BDF2() { return FREQ() * (bdD1 / bdD2) }; //частота вращения ведомого шкива -export function BDFB() { return FREQ() * (Math.PI * bdD1 / bdL) }; //частота вращения ремня - -export function CBFZ() { return FREQ() * cbdZ1; }; //зубцовая частота -export function CBDF2() { return FREQ() * (cbdZ1 / cbdZ2) }; //частота вращения ведомого шкива -export function CBDFB() { return FREQ() * (cbdZ1 / cbdZ3) }; //частота вращения ремня - -export function PMFBLD() { return FREQ() * pmBlades; }; //лопастная частота - -export function GTFZ() { return FREQ() * gtZ1; }; //зубцовая частота -export function GTF2() { return FREQ() * (gtZ1 / gtZ2); }; //частота вращения второго вала редуктора - export function PGF2() { return (0.5 * FREQ() * pgZ1) / (pgZ1 + pgZ2); }; //частота вращения выходного вала планетарной передачи export function PGFSAT() { return (0.5 * FREQ()) * (pgZ1 / pgZ2) * ((pgZ1 + 2 * pgZ2) / (pgZ1 + pgZ2)); }; //частота вращения саттелита export function PGFZ() { return pgZ2 * PGFSAT() }; //зубцовая частота +//параметры турбины +var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины export function TRFBLD() { return FREQ() * trBlades; }; //лопастная частота -export function bpFreq() { - //let filter = 6013.41 * Math.log(0.266935 * FREQ() + 1.1201); - let filter = 1850 * Math.sqrt(FREQ()); - return filter; -}; //расчетная центральная частота полосового фильтра для спектра огибающей +//параметры электродвигателя +//var trBlades = options.trBlades || 0; //количество лопастей крыльчатки турбины -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 * bpFreq(); - return width; -}; //ширина фильтра спектра огибающей +export function specParams(freq) { + let __fltr = {}; //объект расчетных параметров полосового фильтра + let __spec = {}; //объект расчетных параметров спектра + let __tol = 0; //коридор обнаружения гармоники + let __frq = 200; //граничная частота спектра + let __lines = 400; //количество линий спектра -export function tolerance() { - let tol = 0; - switch (options.objectType) { - case 0: //объект не выбран - break; - case 1: //подшипник скольжения - break; - case 2: //подшипник качения - tol = (2 * FTF()) / (5 * BPFO()); - break; - case 3: //ШВП - tol = (2 * BSFTF()) / (5 * BSNUT()); - break; - case 4: //редуктор - tol = (2 * FREQ()) / (5 * GTFZ()); - break; - case 5: //ременная передача - break; - case 6: //зубчатый ремень - break; - case 7: //помпа - break; - case 8: //планетарый редуктор - tol = (2 * PGF2()) / (5 * PGFZ()); - break; - case 9: //турбина - break; - case 10: //электродвигатель - break; - }; return tol; -}; //максимальный коридор обнаружения гармоник (tolerance) + let __filter = bpfFreq(freq); //центральная частота полосового фильтра + let __width = bpfWidth(3, __filter); //ширина полосового фильтра для спектра огибающей + + function bpfFreq(rps) { + let __filter = 1850 * Math.sqrt(rps); + //let __filter = 6013.41 * Math.log(0.266935 * rps + 1.1201); + return __filter; + }; + + function bpfWidth(n, filter) { + let kf = (2 ** (1 / n) - 1) / ((2 ** (1 / n)) ** 0.5); //коэффициент для полосового фильтра + let __wdt = kf * filter; + return __wdt; + }; -export function specParams() { - let frq = 200; //ширина спектра - let res = 400; //частотное разрешение function getStandart(value) { - let arr = [50, 100, 200, 400, 800, 1600, 3200, 6400, 12800]; //массив стандартных величин - let t = arr[0]; - if (value >= arr[arr.length - 1]) { t = arr[arr.length - 1] } else { - for (let i = 0; i <= arr.length - 1; i++) { - if (value > arr[i]) { t = arr[i + 1] }; - }; - }; return t + 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; }; switch (options.objectType) { case 0: //объект не выбран break; case 1: //подшипник скольжения - frq = 20 * FREQ(); - res = FREQ() / 8; + __tol = 0; + __frq = 20 * freq; + __lines = __frq / (freq / 8); break; case 2: //подшипник качения - frq = 5 * BPFI() + 4 * FREQ(); - res = FREQ() / 8; + __tol = (2 * FTF()) / (5 * BPFO()); + __frq = getStandart(5 * BPFI() + 4 * freq); + __lines = getStandart(__frq / (freq / 8)); break; case 3: //ШВП - frq = 5 * BSSCR() + 4 * FREQ(); - res = FREQ() / 8; + __tol = (2 * BSFTF()) / (5 * BSNUT()); + __frq = getStandart(5 * BSSCR() + 4 * freq); + __lines = getStandart(__frq / (freq / 8)); break; case 4: //редуктор - frq = 3 * GTFZ() + 4 * FREQ(); - res = FREQ() / 8; + __tol = (2 * freq) / (5 * GTFZ()); + __frq = getStandart(3 * GTFZ() + 4 * freq); + __lines = getStandart(__frq / (freq / 8)); break; case 5: //ременная передача - frq = 400; - res = BDFB() / 4; + __tol = 0; + __frq = getStandart(400); + __lines = getStandart(__frq / (BDFB() / 4)); break; case 6: //зубчатый ремень - frq = 400; - res = CBDFB() / 4; + __tol = 0; + __frq = getStandart(400); + __lines = getStandart(__frq / (CBDFB() / 4)); break; - case 7: //помпа - frq = 3 * PMFBLD() + 4 * FREQ(); - res = FREQ() / 8; + case 7: //помпа (насос) + __tol = 0; + __frq = getStandart(3 * PMFBLD() + 4 * freq); + __lines = getStandart(__frq / (freq / 8)); break; case 8: //планетарый редуктор - frq = 3 * PGFZ() + 4 * FREQ(); - res = PGF2() / 8; + __tol = (2 * PGF2()) / (5 * PGFZ()); + __frq = getStandart(3 * PGFZ() + 4 * freq); + __lines = getStandart(__frq / (PGF2() / 8)); break; case 9: //турбина - frq = 3 * TRFBLD() + 4 * FREQ(); - res = FREQ() / 8; + __tol = 0; + __frq = getStandart(3 * TRFBLD() + 4 * freq); + __lines = getStandart(__frq / (freq / 8)); break; case 10: //электродвигатель - frq = 400; - res = FREQ() / 8; + __tol = 0; + __frq = getStandart(400); + __lines = getStandart(__frq / (freq / 8)); break; - }; return { - frequency: getStandart(frq), - lines: getStandart(getStandart(frq) / res), - resolution: getStandart(frq) / getStandart(getStandart(frq) / res) }; -}; + + __fltr["frequency"] = __filter; + __fltr["width"] = __width; + __spec["frequency"] = __frq; + __spec["lines"] = __lines; + __spec["resolution"] = __frq / __lines; + __spec["tolerance"] = __tol; + + return { + filter: __fltr, + spec: __spec + }; +}; //рассчетные параметры спектра вибрации export function specSquare(spec, L, R) { let base = spec.base; //массив значений средней линии