gtld2-diag-scripts/user-functions.js

export function get_text() {
    return "hello world";
};

//параметры подшипника качения
var rbModelName = options.rbModelName || "No Name";
var rbVendor = options.rbVendor || "No Vendor";
var d_inner = options.rbInnerD || 0; //диаметр внутреннего кольца
var d_outer = options.rbOuterD || 0; //диаметр наружного кольца
var d_roller = options.rbRollerD || 0; //диаметр тела качения
var z = options.rbRollerCount || 0; //количество тел качения
var angle = (options.rbAngle * 3.1415926) / 180 || 0; //угол контакта тел качения (рад.)
var d_cage = (d_inner + d_outer) / 2; // диаметр сепаратора (средний диаметр)

//параметры редуктора
var gtZ1 = options.gtZ1 || 0; //количество зубьев шестерни
var gtZ2 = options.gtZ2 || 0; //количество зубьев зубчатого колеса

//параметры ременной передачи
var bdD1 = options.bdD1 || 0; //диаметр ведущего шкива
var bdD2 = options.bdD2 || 0; //диаметр ведомого шкива
var bdL = options.bdL || 0; //длинна ремня

//параметры зубчатой ременной передачи
var cbdZ1 = options.cbdZ1 || 0; //количество зубьев ведущего шкива
var cbdZ2 = options.cbdZ2 || 0; //количество зубьев ведомого шкива
var cbdZ3 = options.cbdZ3 || 0; //количество зубьев ремня

//параметры насоса
var pmBlades = options.pmBlades || 0; //количество лопастей насосного колеса

//параметры планетарной передачи
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() {
    let FR = 0;
    switch (record.tachoOptions.tachoState) {
        case 0:
            FR = freq.value * options.tachoRatio;
            break;
        case 1:
            FR = record.tachoOptions.tachoValue * options.tachoRatio;
            break;
        case 2:
            FR = record.tachoOptions.tachoFromInfo * options.tachoRatio;
            break;
    }; return FR;
}; //определение частоты вращения в зависимости от источника тахо сигнала (FREQ) 

export function INSTABILITY() {
    let freq_max = Math.max(...freq.values);
    let freq_min = Math.min(...freq.values);
    let instability = (freq_max - freq_min) / freq.value;
    return instability;
}; //нестабильность частоты вращения в %

//определение вспомогательных коэффициентов k1 и k2 для подшипников качения
var k1 = 0.5 * (1 - (d_roller / d_cage) * Math.cos(angle));
var k2 = 0.5 * (1 + (d_roller / d_cage) * Math.cos(angle));

export function FREQNESS() {
    let R = (d_inner / 2) + (d_roller / 2); //расстояние до центра тяжести тела качения
    let freqness = (Math.sqrt(9.81 / (4 * (Math.PI ** 2) * R / 1000))) / k1;
    return freqness;
}; //минимально необходимая частота вращения для компенсации силы тяжести центробежной силой

export function FTF() { return k1 * FREQ(); }; //частота вращения сепаратора (FTF)
export function BPFO() { return k1 * FREQ() * z; }; //частота перекатывания тел качения по наружному кольцу (BPFO)
export function BPFI() { return k2 * FREQ() * z; }; //частота перекатывания тел качения по внутреннему кольцу (BPFI)
export function BSF() { return 2 * FREQ() * (d_cage / d_roller) * k1 * k2; }; //частота вращения (контакта) тел качения (BSF)

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() }; //зубцовая частота

export function TRFBLD() { return FREQ() * trBlades; }; //лопастная частота

export function filter_frequency() {
    let filter = 6013.41 * Math.log(0.266935 * imp.FREQ() + 1.1201);
    return filter;
}; //расчетная центральная частота полосового фильтра для спектра огибающей 

export function filter_width(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();
    return width;
}; //ширина фильтра спектра огибающей

export function spec_width() {
    let flim = {};
    switch (options.objectType) {
        case 0: //объект не выбран
            break;
        case 1: //подшипник скольжения
            flim = {
                as0: 1600,
                as1: 1600,
                es: 20 * FREQ()
            };
            break;
        case 2: //подшипник качения
            flim = {
                as0: 1600,
                as1: 1600,
                es: 3 * BPFI() + 4 * FREQ()
            };
            break;
        case 3: //ШВП
            break;
        case 4: //редуктор
            flim = {
                as0: 1600,
                as1: 1600,
                es: 3 * GTFZ() + 4 * FREQ()
            };
            break;
        case 5: //ременная передача
            break;
        case 6: //зубчатый ремень
            break;
        case 7: //помпа
            flim = {
                as0: 1600,
                as1: 1600,
                es: 3 * PMFBLD() + 4 * FREQ()
            };
            break;
        case 8: //планетарый редуктор
            flim = {
                as0: 1600,
                as1: 1600,
                es: 3 * PGFZ() + 4 * FREQ()
            };
            break;
        case 9: //турбина
            flim = {
                as0: 1600,
                as1: 1600,
                es: 3 * TRFBLD() + 4 * FREQ()
            };
            break;
        case 10: //электродвигатель
            break;
    }; return flim;
}; //ширина спектров вибрации

export function spec_resolution() {
    let res = 0;
    switch (options.objectType) {
        case 0: //объект не выбран
            break;
        case 1: //подшипник скольжения
            res = FREQ() / 8;
            break;
        case 2: //подшипник качения
            res = FREQ() / 8;
            break;
        case 3: //ШВП
            break;
        case 4: //редуктор
            res = FREQ() / 8;
            break;
        case 5: //ременная передача
            res = BDFB() / 4;
            break;
        case 6: //зубчатый ремень
            res = CBDFB() / 4;
            break;
        case 7: //помпа
            res = FREQ() / 8;
            break;
        case 8: //планетарый редуктор
            res = PGF2() / 8;
            break;
        case 9: //турбина
            res = FREQ() / 8;
            break;
        case 10: //электродвигатель
            break;
    }; return res;
}; //частотное разрешение (разделение двух гармоник с минимальной частотой)

export function spec_lines() { return spec_width().es / spec_resolution(); }; //минимальное количество линий спектра

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: //ШВП
            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)

export function standart_width(width) {
    let STFRQ = 0;
    switch (true) {
        case width <= 50:
            STFRQ = 50;
            break;
        case width <= 100:
            STFRQ = 100;
            break;
        case width <= 200:
            STFRQ = 200;
            break;
        case width <= 400:
            STFRQ = 400;
            break;
        case width <= 800:
            STFRQ = 800;
            break;
        default:
            STFRQ = 1600;
            break;
    }; return STFRQ;
}; //стандартная ширина спектра

export function standart_lines(lines) {
    let STLNS = 0;
    switch (true) {
        case lines <= 200:
            STLNS = 200;
            break;
        case lines <= 400:
            STLNS = 400;
            break;
        case lines <= 800:
            STLNS = 800;
            break;
        case lines <= 1600:
            STLNS = 1600;
            break;
        default:
            STLNS = 3200;
            break;
    }; return STLNS;
}; //стандартное количество линий спектра

export function spec_square(data, bnd, frq) {
    let lines = data.length; //определение количества линий спектра вибрации 
    let res = frq / lines; //определение частотного разрешения спектра вибрации (основание прямоугольной трапеции)
    let start = 1; //переменная для определения стартового индекса в массиве
    let S = 0; //переменная расчетной площади спектра вибрации
    if (bnd !== 0) { start = lines - Math.round((frq - bnd) / res) }; //начальная точка отсчета в массиве (стартовый индекс)
    for (let i = start - 1; i <= lines - 2; i++) { S = S + res * ((data[i] + data[i + 1]) / 2) }; //вычисляем площадь спектра вибрации
    return S;
}; //определение площади спектра

export function mod_factor(ampl, base) {
    let dl = (ampl - base); //разность уровней гармонической и случайной составляющей вибрации  
    let df = spec_resolution() / filter_width(); //отношение ширины фильтра к частотному разрешению спектра
    let mod = Math.sqrt((10 ** (dl / 10) - 1) * df);
    return mod;
}; //определение условной глубины модуляции

export function deep_factor(ampl, base) {
    let deep = (ampl - base) / (ampl + base) * 100;
    return deep;
}; //определение условной глубины модуляции

export function ampl_factor(ampl, base) {
    let crest = ampl / base;
    return crest;
}; //определение амплитудного коэффициента