src/lib/server/controllerTransforms.js - master - Alcatraz/Wagomon

src/lib/server/controllerTransforms.js
82 строки3 KB
saitgalineu
start
25 фев 2026, 16:24
25 фев 2026, 16:24e8a3e93
import { Parser } from 'expr-eval';

const formulaParser = new Parser();

export function convertAnalog(rawValue, row) {
    if (rawValue == null) return null;

    const bit_resolution = Number(row.bit_resolution);
    const min_value = Number(row.min_value);
    const max_value = Number(row.max_value);
    const min_current = Number(row.min_current);
    const max_current = Number(row.max_current);
    const correction = Number(row.correction) || 0;

    if (isNaN(bit_resolution) || isNaN(min_value) || isNaN(max_value) || isNaN(min_current) || isNaN(max_current)) {
        console.warn('Некорректные данные в параметрах row:', row);
        return null;
    }

    if (!row.formula || !row.formula.expression) {
        console.warn('Формула для аналогового датчика не задана (ожидался formula_id/analog_formulas):', row);
        return null;
    }

    try {
        const maxDigital = 2 ** bit_resolution;
        const current_mA = (rawValue / maxDigital) * (max_current - min_current) + min_current;

        const expr = formulaParser.parse(row.formula.expression);
        const context = {
            raw: Number(rawValue),
            current: current_mA,
            min_value,
            max_value,
            min_current,
            max_current,
            bit_resolution
        };

        let normal_value = expr.evaluate(context);
        if (typeof normal_value !== 'number' || isNaN(normal_value)) {
            console.warn('Результат выражения формулы не число:', normal_value, 'row:', row);
            return null;
        }

        const corrected_value = normal_value + correction;
        return +corrected_value.toFixed(2);
    } catch (err) {
        console.warn('Ошибка вычисления формулы для аналогового датчика:', err, 'row:', row);
        return null;
    }
}

export function convertBinary(rawValue, row) {
    if (rawValue == null) return null;
    const value = rawValue;
    const needInvert = row.need_invert === true || row.need_invert === 1 || row.need_invert == "1";
    return needInvert ? !value : value;
}

export function buildRange(rows) {
    const addresses = rows
        .map(r => Number(r.connection_id))
        .filter((addr) => Number.isInteger(addr) && addr >= 0);
    if (addresses.length === 0) return null;
    const minAddress = Math.min(...addresses);
    const maxAddress = Math.max(...addresses);
    const shift = minAddress > 0 ? 1 : 0;
    const normalizedMin = Math.min(...addresses.map(addr => addr - shift));
    const normalizedMax = Math.max(...addresses.map(addr => addr - shift));
    return { start: normalizedMin, length: normalizedMax - normalizedMin + 1, shift };
}

export function resolveRawValue(row, range, data) {
    if (!range || !Array.isArray(data)) return undefined;
    const address = Number(row.connection_id);
    if (!Number.isInteger(address)) return undefined;
    const normalizedAddress = address - (range.shift ?? 0);
    const idx = normalizedAddress - range.start;
    if (idx < 0 || idx >= data.length) return undefined;
    return data[idx];
}