jooby-codec 3.15.0 → 7.0.1

package/dist/mtx3/utils/CommandBinaryBuffer.js

@@ -0,0 +1,672 @@
+import { TARIFF_NUMBER, DATE_SIZE, ENERGY_SIZE, getDateTime, setDateTime, getDate, setDate } from '../../mtx1/utils/CommandBinaryBuffer.js';
+import * as bitSet from '../../utils/bitSet.js';
+import { baudRates, events, eventNames } from '../constants/index.js';
+export const OPERATOR_PARAMETERS_SIZE = 95;
+export const OPERATOR_PARAMETERS_EXTENDED_SIZE = 9;
+export const OPERATOR_PARAMETERS_EXTENDED2_SIZE = 28;
+export const OPERATOR_PARAMETERS_EXTENDED4_SIZE = 28;
+export const PACKED_ENERGY_TYPE_SIZE = 1;
+const ENERGY_TYPE_BITS = 4;
+const displaySet1Mask = {
+    SET_ALL_SEGMENT_DISPLAY: 1 << 0,
+    SOFTWARE_VERSION: 1 << 1,
+    TOTAL_ACTIVE_ENERGY: 1 << 2,
+    ACTIVE_ENERGY_T1: 1 << 3,
+    ACTIVE_ENERGY_T2: 1 << 4,
+    ACTIVE_ENERGY_T3: 1 << 5,
+    ACTIVE_ENERGY_T4: 1 << 6,
+    TOTAL_REACTIVE_ENERGY: 1 << 7,
+    REACTIVE_ENERGY_T1: 1 << 8,
+    REACTIVE_ENERGY_T2: 1 << 9,
+    REACTIVE_ENERGY_T3: 1 << 10,
+    REACTIVE_ENERGY_T4: 1 << 11,
+    TOTAL_NEGATIVE_REACTIVE_ENERGY: 1 << 12,
+    NEGATIVE_REACTIVE_ENERGY_T1: 1 << 13,
+    NEGATIVE_REACTIVE_ENERGY_T2: 1 << 14,
+    NEGATIVE_REACTIVE_ENERGY_T3: 1 << 15,
+    NEGATIVE_REACTIVE_ENERGY_T4: 1 << 16,
+    TOTAL_EXPORTED_ACTIVE_ENERGY: 1 << 17,
+    EXPORTED_ACTIVE_ENERGY_T1: 1 << 18,
+    EXPORTED_ACTIVE_ENERGY_T2: 1 << 19,
+    EXPORTED_ACTIVE_ENERGY_T3: 1 << 20,
+    EXPORTED_ACTIVE_ENERGY_T4: 1 << 21,
+    TOTAL_EXPORTED_REACTIVE_ENERGY: 1 << 22,
+    EXPORTED_REACTIVE_ENERGY_T1: 1 << 23,
+    EXPORTED_REACTIVE_ENERGY_T2: 1 << 24,
+    EXPORTED_REACTIVE_ENERGY_T3: 1 << 25,
+    EXPORTED_REACTIVE_ENERGY_T4: 1 << 26,
+    TOTAL_EXPORTED_NEGATIVE_REACTIVE_ENERGY: 1 << 27,
+    EXPORTED_NEGATIVE_REACTIVE_ENERGY_T1: 1 << 28,
+    EXPORTED_NEGATIVE_REACTIVE_ENERGY_T2: 1 << 29,
+    EXPORTED_NEGATIVE_REACTIVE_ENERGY_T3: 1 << 30,
+    EXPORTED_NEGATIVE_REACTIVE_ENERGY_T4: 1 << 31
+};
+const displaySet2Mask = {
+    CURRENT_IN_PHASE_A: 1 << 0,
+    CURRENT_IN_PHASE_B: 1 << 1,
+    CURRENT_IN_PHASE_C: 1 << 2,
+    CURRENT_IN_NEUTRAL: 1 << 3,
+    VOLTAGE_IN_PHASE_A: 1 << 4,
+    VOLTAGE_IN_PHASE_B: 1 << 5,
+    VOLTAGE_IN_PHASE_C: 1 << 6,
+    BATTERY_VOLTAGE: 1 << 7,
+    SUPPLY_FREQUENCY: 1 << 8,
+    TOTAL_ACTIVE_POWER: 1 << 9,
+    ACTIVE_POWER_PHASE_A: 1 << 10,
+    ACTIVE_POWER_PHASE_B: 1 << 11,
+    ACTIVE_POWER_PHASE_C: 1 << 12,
+    TOTAL_REACTIVE_POWER_QPLUS: 1 << 13,
+    REACTIVE_POWER_QPLUS_PHASE_A: 1 << 14,
+    REACTIVE_POWER_QPLUS_PHASE_B: 1 << 15,
+    REACTIVE_POWER_QPLUS_PHASE_C: 1 << 16,
+    TOTAL_REACTIVE_POWER_QMINUS: 1 << 17,
+    REACTIVE_POWER_QMINUS_PHASE_A: 1 << 18,
+    REACTIVE_POWER_QMINUS_PHASE_B: 1 << 19,
+    REACTIVE_POWER_QMINUS_PHASE_C: 1 << 20,
+    TOTAL_POWER_FACTOR: 1 << 21,
+    POWER_FACTOR_PHASE_A: 1 << 22,
+    POWER_FACTOR_PHASE_B: 1 << 23,
+    POWER_FACTOR_PHASE_C: 1 << 24,
+    TOTAL_APPARENT_POWER_QPLUS: 1 << 25,
+    APPARENT_POWER_QPLUS_PHASE_A: 1 << 26,
+    APPARENT_POWER_QPLUS_PHASE_B: 1 << 27,
+    APPARENT_POWER_QPLUS_PHASE_C: 1 << 28,
+    TOTAL_APPARENT_POWER_QMINUS: 1 << 29,
+    APPARENT_POWER_QMINUS_PHASE_A: 1 << 30,
+    APPARENT_POWER_QMINUS_PHASE_B: 1 << 31
+};
+const displaySet3Mask = {
+    APPARENT_POWER_QMINUS_PHASE_C: 1 << 0,
+    MAX_ACTIVE_POWER_DAY_T1: 1 << 1,
+    MAX_ACTIVE_POWER_DAY_T2: 1 << 2,
+    MAX_ACTIVE_POWER_DAY_T3: 1 << 3,
+    MAX_ACTIVE_POWER_DAY_T4: 1 << 4,
+    MAX_ACTIVE_POWER_MONTH_T1: 1 << 5,
+    MAX_ACTIVE_POWER_MONTH_T2: 1 << 6,
+    MAX_ACTIVE_POWER_MONTH_T3: 1 << 7,
+    MAX_ACTIVE_POWER_MONTH_T4: 1 << 8,
+    MAX_REACTIVE_POWER_DAY_T1: 1 << 9,
+    MAX_REACTIVE_POWER_DAY_T2: 1 << 10,
+    MAX_REACTIVE_POWER_DAY_T3: 1 << 11,
+    MAX_REACTIVE_POWER_DAY_T4: 1 << 12,
+    MAX_REACTIVE_POWER_MONTH_T1: 1 << 13,
+    MAX_REACTIVE_POWER_MONTH_T2: 1 << 14,
+    MAX_REACTIVE_POWER_MONTH_T3: 1 << 15,
+    MAX_REACTIVE_POWER_MONTH_T4: 1 << 16,
+    MAX_NEGATIVE_REACTIVE_POWER_DAY_T1: 1 << 17,
+    MAX_NEGATIVE_REACTIVE_POWER_DAY_T2: 1 << 18,
+    MAX_NEGATIVE_REACTIVE_POWER_DAY_T3: 1 << 19,
+    MAX_NEGATIVE_REACTIVE_POWER_DAY_T4: 1 << 20,
+    MAX_NEGATIVE_REACTIVE_POWER_MONTH_T1: 1 << 21,
+    MAX_NEGATIVE_REACTIVE_POWER_MONTH_T2: 1 << 22,
+    MAX_NEGATIVE_REACTIVE_POWER_MONTH_T3: 1 << 23,
+    MAX_NEGATIVE_REACTIVE_POWER_MONTH_T4: 1 << 24,
+    MAX_EXPORTED_ACTIVE_POWER_DAY_T1: 1 << 25,
+    MAX_EXPORTED_ACTIVE_POWER_DAY_T2: 1 << 26,
+    MAX_EXPORTED_ACTIVE_POWER_DAY_T3: 1 << 27,
+    MAX_EXPORTED_ACTIVE_POWER_DAY_T4: 1 << 28,
+    MAX_EXPORTED_ACTIVE_POWER_MONTH_T1: 1 << 29,
+    MAX_EXPORTED_ACTIVE_POWER_MONTH_T2: 1 << 30,
+    MAX_EXPORTED_ACTIVE_POWER_MONTH_T3: 1 << 31
+};
+export const displaySet4BaseMask = {
+    MAX_EXPORTED_ACTIVE_POWER_MONTH_T4: 1 << 0,
+    MAX_EXPORTED_REACTIVE_POWER_DAY_T1: 1 << 1,
+    MAX_EXPORTED_REACTIVE_POWER_DAY_T2: 1 << 2,
+    MAX_EXPORTED_REACTIVE_POWER_DAY_T3: 1 << 3,
+    MAX_EXPORTED_REACTIVE_POWER_DAY_T4: 1 << 4,
+    MAX_EXPORTED_REACTIVE_POWER_MONTH_T1: 1 << 5,
+    MAX_EXPORTED_REACTIVE_POWER_MONTH_T2: 1 << 6,
+    MAX_EXPORTED_REACTIVE_POWER_MONTH_T3: 1 << 7,
+    MAX_EXPORTED_REACTIVE_POWER_MONTH_T4: 1 << 8,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_DAY_T1: 1 << 9,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_DAY_T2: 1 << 10,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_DAY_T3: 1 << 11,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_DAY_T4: 1 << 12,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_MONTH_T1: 1 << 13,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_MONTH_T2: 1 << 14,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_MONTH_T3: 1 << 15,
+    MAX_EXPORTED_NEGATIVE_REACTIVE_POWER_MONTH_T4: 1 << 16,
+    HOUR_MINUTE_SECOND: 1 << 17,
+    DATE_MONTH_YEAR: 1 << 18,
+    CURRENT_TRANSFORMATION_RATIO: 1 << 19,
+    VOLTAGE_TRANSFORMATION_RATIO: 1 << 20,
+    CURRENT_BALANCE: 1 << 21,
+    POWER_THRESHOLD_T1: 1 << 22,
+    POWER_THRESHOLD_T2: 1 << 23,
+    POWER_THRESHOLD_T3: 1 << 24,
+    POWER_THRESHOLD_T4: 1 << 25
+};
+export const displaySet4Mask = {
+    ...displaySet4BaseMask,
+    SORT_DISPLAY_SCREENS: 1 << 29,
+    AUTO_SCREEN_SCROLLING: 1 << 31
+};
+const displaySet5Mask = {
+    EVENT: 1 << 0,
+    PROFILE_P01: 1 << 1,
+    PROFILE_P02: 1 << 2,
+    PROFILE_P03: 1 << 3,
+    PROFILE_P04: 1 << 4,
+    PROFILE_P05: 1 << 5,
+    PROFILE_P06: 1 << 6
+};
+export const relaySetMask = {
+    RELAY_ON_Y: 1 << 0,
+    RELAY_ON_CENTER: 1 << 1,
+    RELAY_ON_PB: 1 << 2,
+    RELAY_ON_TARIFF_1: 1 << 3,
+    RELAY_ON_TARIFF_2: 1 << 4,
+    RELAY_ON_TARIFF_3: 1 << 5,
+    RELAY_ON_TARIFF_4: 1 << 6,
+    RELAY_ON_V_GOOD: 1 << 7,
+    RELAY_OFF_Y: 1 << 8,
+    RELAY_OFF_CENTER: 1 << 9,
+    RELAY_OFF_TARIFF_1: 1 << 10,
+    RELAY_OFF_TARIFF_2: 1 << 11,
+    RELAY_OFF_TARIFF_3: 1 << 12,
+    RELAY_OFF_TARIFF_4: 1 << 13,
+    RELAY_OFF_I_LIMIT: 1 << 14,
+    RELAY_OFF_V_BAD: 1 << 15,
+    RELAY_OFF_DIFF_CURRENT_BAD: 1 << 16,
+    RELAY_OFF_LIM_TARIFF_1: 1 << 17,
+    RELAY_OFF_LIM_TARIFF_2: 1 << 18,
+    RELAY_OFF_LIM_TARIFF_3: 1 << 19,
+    RELAY_OFF_LIM_TARIFF_4: 1 << 20,
+    RELAY_OFF_LIM_VAR_TARIFF_1: 1 << 21,
+    RELAY_OFF_LIM_VAR_TARIFF_2: 1 << 22,
+    RELAY_OFF_LIM_VAR_TARIFF_3: 1 << 23,
+    RELAY_OFF_LIM_VAR_TARIFF_4: 1 << 24,
+    RELAY_ON_PF_MIN: 1 << 25,
+    RELAY_OFF_PF_MIN: 1 << 26,
+    RELAY_ON_TIMEOUT: 1 << 27,
+    RELAY_ON_SALDO: 1 << 28,
+    RELAY_OFF_SALDO: 1 << 29,
+    RELAY_OFF_SALDO_SOFT: 1 << 30
+};
+const typeMeterMask = {
+    TRANSFORMATION_RATIO: 1 << 0,
+    METER_TYPE_R: 1 << 4,
+    ACCUMULATE_BY_R_PLUS_MINUS: 1 << 7
+};
+export const define1Mask = {
+    RESET_DAY_MAX_POWER_KEY: 1 << 0,
+    RESET_MONTH_MAX_POWER_KEY: 1 << 1,
+    BLOCK_KEY_OPTOPORT: 1 << 2,
+    MAGNET_SCREEN_CONST: 1 << 5,
+    ALLOW_BROWNOUT_INDICATION: 1 << 7
+};
+export const displaySet24Mask = {
+    ...displaySet4BaseMask,
+    OPTOPORT_SPEED: 1 << 26,
+    MAGNET_INDUCTION: 1 << 27
+};
+export const relaySetExtMask = {
+    RELAY_OFF_MAGNET: 1 << 0,
+    RELAY_ON_MAGNET_TIMEOUT: 1 << 1,
+    RELAY_ON_MAGNET_AUTO: 1 << 2
+};
+const getSpeedOptoPort = (value) => ({
+    plc: baudRates.valueToRate.plc[bitSet.extractBits(value, 4, 1)],
+    optoport: baudRates.valueToRate.optoport[bitSet.extractBits(value, 4, 5)]
+});
+const setSpeedOptoPort = (speedOptoPort) => {
+    let result = 0;
+    result = bitSet.fillBits(result, 4, 1, Number(baudRates.rateToValue.plc[speedOptoPort.plc]));
+    result = bitSet.fillBits(result, 4, 5, Number(baudRates.rateToValue.optoport[speedOptoPort.optoport]));
+    return result;
+};
+function getPackedEnergies(buffer, energyType, tariffMapByte) {
+    const byte = tariffMapByte >> ENERGY_TYPE_BITS;
+    const wh = [];
+    const vari = [];
+    const vare = [];
+    for (let index = 0; index < TARIFF_NUMBER; index++) {
+        const isTariffExists = !!bitSet.extractBits(byte, 1, index + 1);
+        if (isTariffExists) {
+            wh.push(buffer.getInt32());
+            vari.push(buffer.getInt32());
+            vare.push(buffer.getInt32());
+        }
+        else {
+            wh.push(null);
+            vari.push(null);
+            vare.push(null);
+        }
+    }
+    return { wh, vari, vare };
+}
+function getPackedEnergyType(energyType, energies) {
+    const { wh, vari, vare } = energies;
+    const indexShift = 1 + ENERGY_TYPE_BITS;
+    let tariffsByte = energyType;
+    for (let index = 0; index < TARIFF_NUMBER; index++) {
+        tariffsByte = bitSet.fillBits(tariffsByte, 1, index + indexShift, Number(!!wh[index] && !!vari[index] && !!vare[index]));
+    }
+    return tariffsByte;
+}
+export const getDefaultOperatorParameters = () => ({
+    vpThreshold: 265000,
+    vThreshold: 156000,
+    ipThreshold: 120000,
+    pmaxThreshold0: 31800,
+    pmaxThreshold1: 31800,
+    pmaxThreshold2: 31800,
+    pmaxThreshold3: 31800,
+    rmaxThreshold0: 31800,
+    rmaxThreshold1: 31800,
+    rmaxThreshold2: 31800,
+    rmaxThreshold3: 31800,
+    tint: 30,
+    calcPeriodDate: 1,
+    timeoutDisplay: 127,
+    timeoutScreen: 7,
+    displaySet1: bitSet.toObject(displaySet1Mask, 4229),
+    displaySet2: bitSet.toObject(displaySet2Mask, 139776),
+    displaySet3: bitSet.toObject(displaySet3Mask, 0),
+    relaySet: bitSet.toObject(relaySetMask, 771),
+    speedOptoPort: getSpeedOptoPort(64),
+    ten: 30,
+    tu: 30,
+    timeIntervalPowerOff: 3,
+    reserved: 0,
+    timeoutBadVAVB: 5,
+    freqMax: 55,
+    freqMin: 45,
+    year: 0,
+    month: 0,
+    date: 0,
+    energyDecimalPoint: 2,
+    voltageTransformationRatioNumerator: 1,
+    voltageTransformationRatioDenominator: 1,
+    currentTransformationRatioNumerator: 1,
+    currentTransformationRatioDenominator: 1,
+    typeMeter: bitSet.toObject(typeMeterMask, 0),
+    phMin: 0,
+    timeoutIMax: 5,
+    timeoutPMax: 5,
+    timeoutCos: 5,
+    pMaxDef: 1,
+    displaySet4: bitSet.toObject(displaySet4Mask, 2147876864)
+});
+export const getDefaultOperatorParametersExtended = () => ({
+    timeoutRelayOn: 1,
+    define1: bitSet.toObject(define1Mask, 0),
+    timeoutRelayKey: 0,
+    timeoutRelayAuto: 5
+});
+export const getDefaultOperatorParametersExtended2 = () => ({
+    deltaCorMin: 0,
+    timeoutMagnetOff: 5,
+    relaySetExt: bitSet.toObject(relaySetExtMask, 0),
+    timeoutMagnetOn: 5,
+    defaultPlcPhase: 3,
+    displaySet21: bitSet.toObject(displaySet1Mask, 4231),
+    displaySet22: bitSet.toObject(displaySet2Mask, 31597303),
+    displaySet23: bitSet.toObject(displaySet3Mask, 0),
+    displaySet24: bitSet.toObject(displaySet24Mask, 393216),
+    channel1: 0,
+    channel2: 0,
+    channel3: 0,
+    channel4: 0,
+    channel5: 0,
+    channel6: 0,
+    timeCorrectPeriod: 24,
+    timeCorrectPassHalfhour: false
+});
+export { getDefaultOperatorParametersExtended3 } from '../../mtx1/utils/CommandBinaryBuffer.js';
+export const getOperatorParameters = function (buffer) {
+    return {
+        vpThreshold: buffer.getUint32(),
+        vThreshold: buffer.getUint32(),
+        ipThreshold: buffer.getUint32(),
+        pmaxThreshold0: buffer.getUint32(),
+        pmaxThreshold1: buffer.getUint32(),
+        pmaxThreshold2: buffer.getUint32(),
+        pmaxThreshold3: buffer.getUint32(),
+        rmaxThreshold0: buffer.getUint32(),
+        rmaxThreshold1: buffer.getUint32(),
+        rmaxThreshold2: buffer.getUint32(),
+        rmaxThreshold3: buffer.getUint32(),
+        tint: buffer.getUint8(),
+        calcPeriodDate: buffer.getUint8(),
+        timeoutDisplay: buffer.getUint8(),
+        timeoutScreen: buffer.getUint8(),
+        displaySet1: bitSet.toObject(displaySet1Mask, buffer.getUint32()),
+        displaySet2: bitSet.toObject(displaySet2Mask, buffer.getUint32()),
+        displaySet3: bitSet.toObject(displaySet3Mask, buffer.getUint32()),
+        relaySet: bitSet.toObject(relaySetMask, buffer.getUint32()),
+        speedOptoPort: getSpeedOptoPort(buffer.getUint8()),
+        ten: buffer.getUint8(),
+        tu: buffer.getUint8(),
+        timeIntervalPowerOff: buffer.getUint8(),
+        reserved: buffer.getUint8(),
+        timeoutBadVAVB: buffer.getUint8(),
+        freqMax: buffer.getUint8(),
+        freqMin: buffer.getUint8(),
+        year: buffer.getUint8(),
+        month: buffer.getUint8(),
+        date: buffer.getUint8(),
+        energyDecimalPoint: buffer.getUint8(),
+        voltageTransformationRatioNumerator: buffer.getUint16(),
+        voltageTransformationRatioDenominator: buffer.getUint16(),
+        currentTransformationRatioNumerator: buffer.getUint16(),
+        currentTransformationRatioDenominator: buffer.getUint16(),
+        typeMeter: bitSet.toObject(typeMeterMask, buffer.getUint8()),
+        phMin: buffer.getUint16(),
+        timeoutIMax: buffer.getUint8(),
+        timeoutPMax: buffer.getUint8(),
+        timeoutCos: buffer.getUint8(),
+        pMaxDef: buffer.getUint8(),
+        displaySet4: bitSet.toObject(displaySet4Mask, buffer.getUint32())
+    };
+};
+export const setOperatorParameters = function (buffer, operatorParameters) {
+    buffer.setUint32(operatorParameters.vpThreshold);
+    buffer.setUint32(operatorParameters.vThreshold);
+    buffer.setUint32(operatorParameters.ipThreshold);
+    buffer.setUint32(operatorParameters.pmaxThreshold0);
+    buffer.setUint32(operatorParameters.pmaxThreshold1);
+    buffer.setUint32(operatorParameters.pmaxThreshold2);
+    buffer.setUint32(operatorParameters.pmaxThreshold3);
+    buffer.setUint32(operatorParameters.rmaxThreshold0);
+    buffer.setUint32(operatorParameters.rmaxThreshold1);
+    buffer.setUint32(operatorParameters.rmaxThreshold2);
+    buffer.setUint32(operatorParameters.rmaxThreshold3);
+    buffer.setUint8(operatorParameters.tint);
+    buffer.setUint8(operatorParameters.calcPeriodDate);
+    buffer.setUint8(operatorParameters.timeoutDisplay);
+    buffer.setUint8(operatorParameters.timeoutScreen);
+    buffer.setUint32(bitSet.fromObject(displaySet1Mask, operatorParameters.displaySet1));
+    buffer.setUint32(bitSet.fromObject(displaySet2Mask, operatorParameters.displaySet2));
+    buffer.setUint32(bitSet.fromObject(displaySet3Mask, operatorParameters.displaySet3));
+    buffer.setUint32(bitSet.fromObject(relaySetMask, operatorParameters.relaySet));
+    buffer.setUint8(setSpeedOptoPort(operatorParameters.speedOptoPort));
+    buffer.setUint8(operatorParameters.ten);
+    buffer.setUint8(operatorParameters.tu);
+    buffer.setUint8(operatorParameters.timeIntervalPowerOff);
+    buffer.setUint8(operatorParameters.reserved);
+    buffer.setUint8(operatorParameters.timeoutBadVAVB);
+    buffer.setUint8(operatorParameters.freqMax);
+    buffer.setUint8(operatorParameters.freqMin);
+    buffer.setUint8(operatorParameters.year);
+    buffer.setUint8(operatorParameters.month);
+    buffer.setUint8(operatorParameters.date);
+    buffer.setUint8(operatorParameters.energyDecimalPoint);
+    buffer.setUint16(operatorParameters.voltageTransformationRatioNumerator);
+    buffer.setUint16(operatorParameters.voltageTransformationRatioDenominator);
+    buffer.setUint16(operatorParameters.currentTransformationRatioNumerator);
+    buffer.setUint16(operatorParameters.currentTransformationRatioDenominator);
+    buffer.setUint8(bitSet.fromObject(typeMeterMask, operatorParameters.typeMeter));
+    buffer.setUint16(operatorParameters.phMin);
+    buffer.setUint8(operatorParameters.timeoutIMax);
+    buffer.setUint8(operatorParameters.timeoutPMax);
+    buffer.setUint8(operatorParameters.timeoutCos);
+    buffer.setUint8(operatorParameters.pMaxDef);
+    buffer.setUint32(bitSet.fromObject(displaySet4Mask, operatorParameters.displaySet4));
+};
+export const getOperatorParametersExtended = function (buffer) {
+    return {
+        timeoutRelayOn: buffer.getUint8(),
+        define1: bitSet.toObject(define1Mask, buffer.getUint8()),
+        timeoutRelayKey: buffer.getUint8(),
+        timeoutRelayAuto: buffer.getUint8()
+    };
+};
+export const setOperatorParametersExtended = function (buffer, operatorParametersExtended) {
+    buffer.setUint8(operatorParametersExtended.timeoutRelayOn);
+    buffer.setUint8(bitSet.fromObject(define1Mask, operatorParametersExtended.define1));
+    buffer.setUint8(operatorParametersExtended.timeoutRelayKey);
+    buffer.setUint8(operatorParametersExtended.timeoutRelayAuto);
+    buffer.setUint32(0);
+    buffer.setUint8(0);
+};
+export const getEnergies = function (buffer) {
+    const wh = [];
+    const vari = [];
+    const vare = [];
+    for (let index = 0; index < TARIFF_NUMBER; index++) {
+        wh.push(buffer.getInt32());
+        vari.push(buffer.getInt32());
+        vare.push(buffer.getInt32());
+    }
+    return { wh, vari, vare };
+};
+export const setEnergies = function (buffer, parameters) {
+    for (let index = 0; index < TARIFF_NUMBER; index++) {
+        buffer.setInt32(parameters.wh[index]);
+        buffer.setInt32(parameters.vari[index]);
+        buffer.setInt32(parameters.vare[index]);
+    }
+};
+export const getPackedEnergyWithType = function (buffer) {
+    const byte = buffer.getUint8();
+    const energyType = bitSet.extractBits(byte, ENERGY_TYPE_BITS, 1);
+    const energies = getPackedEnergies(buffer, energyType, byte);
+    return {
+        energyType,
+        energies
+    };
+};
+export const setPackedEnergyWithType = function (buffer, { energyType, energies }) {
+    if (energyType) {
+        const energyTypeByte = getPackedEnergyType(energyType, energies);
+        const tariffsByte = energyTypeByte >> ENERGY_TYPE_BITS;
+        buffer.setUint8(energyTypeByte);
+        for (let index = 0; index < TARIFF_NUMBER; index++) {
+            const isTariffExists = !!bitSet.extractBits(tariffsByte, 1, index + 1);
+            if (isTariffExists) {
+                buffer.setInt32(energies.wh[index]);
+                buffer.setInt32(energies.vari[index]);
+                buffer.setInt32(energies.vare[index]);
+            }
+        }
+        return;
+    }
+    for (let index = 0; index < TARIFF_NUMBER; index++) {
+        buffer.setInt32(energies.wh[index]);
+        buffer.setInt32(energies.vari[index]);
+        buffer.setInt32(energies.vare[index]);
+    }
+};
+export const getEnergyPeriods = function (buffer, energiesNumber) {
+    return new Array(energiesNumber).fill(0).map(() => {
+        const energy = buffer.getUint16();
+        return energy === 0xffff ? undefined : energy;
+    });
+};
+export const setEnergyPeriods = function (buffer, energies) {
+    energies.forEach(energy => buffer.setUint16(energy === undefined ? 0xffff : energy));
+};
+export const getMaxDemand = function (buffer) {
+    return {
+        hourPmax: buffer.getUint8(),
+        minPmax: buffer.getUint8(),
+        pmax: buffer.getInt32(),
+        hourVariMax: buffer.getUint8(),
+        minVariMax: buffer.getUint8(),
+        variMax: buffer.getInt32(),
+        hourVareMax: buffer.getUint8(),
+        minVareMax: buffer.getUint8(),
+        vareMax: buffer.getInt32()
+    };
+};
+export const setMaxDemand = function (buffer, maxDemand) {
+    buffer.setUint8(maxDemand.hourPmax);
+    buffer.setUint8(maxDemand.minPmax);
+    buffer.setInt32(maxDemand.pmax);
+    buffer.setUint8(maxDemand.hourVariMax);
+    buffer.setUint8(maxDemand.minVariMax);
+    buffer.setInt32(maxDemand.variMax);
+    buffer.setUint8(maxDemand.hourVareMax);
+    buffer.setUint8(maxDemand.minVareMax);
+    buffer.setInt32(maxDemand.vareMax);
+};
+export const getDayMaxDemandResponse = function (buffer) {
+    const date = getDate(buffer);
+    const maxDemands = new Array(TARIFF_NUMBER).fill(0).map(() => getMaxDemand(buffer));
+    return { date, maxDemands };
+};
+export const setDayMaxDemandResponse = function (buffer, parameters) {
+    setDate(buffer, parameters.date);
+    parameters.maxDemands.forEach(value => setMaxDemand(buffer, value));
+};
+export const getMonthMaxDemandResponse = function (buffer) {
+    const date = {
+        year: buffer.getUint8(),
+        month: buffer.getUint8()
+    };
+    const maxDemands = new Array(TARIFF_NUMBER).fill(0).map(() => getMaxDemand(buffer));
+    return { date, maxDemands };
+};
+export const setMonthMaxDemandResponse = function (buffer, parameters) {
+    buffer.setUint8(parameters.date.year);
+    buffer.setUint8(parameters.date.month);
+    parameters.maxDemands.forEach(value => setMaxDemand(buffer, value));
+};
+export const getEvent = function (buffer) {
+    const data = {
+        hours: buffer.getUint8(),
+        minutes: buffer.getUint8(),
+        seconds: buffer.getUint8(),
+        event: buffer.getUint8()
+    };
+    const { event } = data;
+    const { bytesLeft } = buffer;
+    data.eventName = eventNames[event];
+    switch (event) {
+        case events.POWER_OVER_RELAY_OFF:
+            if (bytesLeft < 4) {
+                return data;
+            }
+            data.power = [buffer.getUint8(), buffer.getUint8(), buffer.getUint8(), buffer.getUint8()];
+            break;
+        case events.CMD_CHANGE_TIME:
+        case events.TIME_CORRECT:
+            if (bytesLeft < 8) {
+                return data;
+            }
+            data.newDate = getDateTime(buffer);
+            break;
+        default:
+            break;
+    }
+    return data;
+};
+export const setEvent = function (buffer, event) {
+    buffer.setUint8(event.hours);
+    buffer.setUint8(event.minutes);
+    buffer.setUint8(event.seconds);
+    buffer.setUint8(event.event);
+    switch (event.event) {
+        case events.POWER_OVER_RELAY_OFF:
+            for (const item of event.power) {
+                buffer.setUint8(item);
+            }
+            break;
+        case events.CMD_CHANGE_TIME:
+        case events.TIME_CORRECT:
+            setDateTime(buffer, event.newDate);
+            break;
+        default: break;
+    }
+};
+export const getDemand = function (buffer) {
+    const date0 = buffer.getUint8();
+    const date1 = buffer.getUint8();
+    return {
+        date: {
+            year: date0 >> 1,
+            month: ((date0 << 3) & 0x0f) | (date1 >> 5),
+            date: date1 & 0x1f
+        },
+        demandType: buffer.getUint8(),
+        firstIndex: buffer.getUint16(),
+        count: buffer.getUint8(),
+        period: buffer.getUint8()
+    };
+};
+export const setDemand = function (buffer, parameters) {
+    const date0 = (parameters.date.year << 1) | ((parameters.date.month >> 3) & 0x01);
+    const date1 = ((parameters.date.month << 5) & 0xe0) | (parameters.date.date & 0x1f);
+    buffer.setUint8(date0);
+    buffer.setUint8(date1);
+    buffer.setUint8(parameters.demandType);
+    buffer.setUint16(parameters.firstIndex);
+    buffer.setUint8(parameters.count);
+    buffer.setUint8(parameters.period);
+};
+export const getOperatorParametersExtended2 = function (buffer) {
+    const operatorParametersExtended2 = {
+        deltaCorMin: buffer.getUint8(),
+        timeoutMagnetOff: buffer.getUint8(),
+        relaySetExt: bitSet.toObject(relaySetExtMask, buffer.getUint8()),
+        timeoutMagnetOn: buffer.getUint8(),
+        defaultPlcPhase: buffer.getUint8(),
+        displaySet21: bitSet.toObject(displaySet1Mask, buffer.getUint32()),
+        displaySet22: bitSet.toObject(displaySet2Mask, buffer.getUint32()),
+        displaySet23: bitSet.toObject(displaySet3Mask, buffer.getUint32()),
+        displaySet24: bitSet.toObject(displaySet24Mask, buffer.getUint32()),
+        channel1: buffer.getUint8(),
+        channel2: buffer.getUint8(),
+        channel3: buffer.getUint8(),
+        channel4: buffer.getUint8(),
+        channel5: buffer.getUint8(),
+        channel6: buffer.getUint8(),
+        timeCorrectPeriod: 0,
+        timeCorrectPassHalfhour: false
+    };
+    const timeCorrectPeriod = buffer.getUint8();
+    operatorParametersExtended2.timeCorrectPeriod = timeCorrectPeriod & 0x7f;
+    operatorParametersExtended2.timeCorrectPassHalfhour = !!(timeCorrectPeriod & 0x80);
+    return operatorParametersExtended2;
+};
+export const setOperatorParametersExtended2 = function (buffer, operatorParametersExtended2) {
+    const timeCorrectPeriod = operatorParametersExtended2.timeCorrectPeriod
+        | (operatorParametersExtended2.timeCorrectPassHalfhour ? 0x80 : 0);
+    buffer.setUint8(operatorParametersExtended2.deltaCorMin);
+    buffer.setUint8(operatorParametersExtended2.timeoutMagnetOff);
+    buffer.setUint8(bitSet.fromObject(relaySetExtMask, operatorParametersExtended2.relaySetExt));
+    buffer.setUint8(operatorParametersExtended2.timeoutMagnetOn);
+    buffer.setUint8(operatorParametersExtended2.defaultPlcPhase);
+    buffer.setUint32(bitSet.fromObject(displaySet1Mask, operatorParametersExtended2.displaySet21));
+    buffer.setUint32(bitSet.fromObject(displaySet2Mask, operatorParametersExtended2.displaySet22));
+    buffer.setUint32(bitSet.fromObject(displaySet3Mask, operatorParametersExtended2.displaySet23));
+    buffer.setUint32(bitSet.fromObject(displaySet24Mask, operatorParametersExtended2.displaySet24));
+    buffer.setUint8(operatorParametersExtended2.channel1);
+    buffer.setUint8(operatorParametersExtended2.channel2);
+    buffer.setUint8(operatorParametersExtended2.channel3);
+    buffer.setUint8(operatorParametersExtended2.channel4);
+    buffer.setUint8(operatorParametersExtended2.channel5);
+    buffer.setUint8(operatorParametersExtended2.channel6);
+    buffer.setUint8(timeCorrectPeriod);
+};
+export const getOperatorParametersExtended4 = function (buffer) {
+    return {
+        displaySet5: bitSet.toObject(displaySet5Mask, buffer.getUint32()),
+        displaySet25: bitSet.toObject(displaySet5Mask, buffer.getUint32()),
+        displaySet31: bitSet.toObject(displaySet1Mask, buffer.getUint32()),
+        displaySet32: bitSet.toObject(displaySet2Mask, buffer.getUint32()),
+        displaySet33: bitSet.toObject(displaySet3Mask, buffer.getUint32()),
+        displaySet34: bitSet.toObject(displaySet4Mask, buffer.getUint32()),
+        displaySet35: bitSet.toObject(displaySet5Mask, buffer.getUint32())
+    };
+};
+export const setOperatorParametersExtended4 = function (buffer, operatorParametersExtended) {
+    buffer.setUint32(bitSet.fromObject(displaySet5Mask, operatorParametersExtended.displaySet5));
+    buffer.setUint32(bitSet.fromObject(displaySet5Mask, operatorParametersExtended.displaySet25));
+    buffer.setUint32(bitSet.fromObject(displaySet1Mask, operatorParametersExtended.displaySet31));
+    buffer.setUint32(bitSet.fromObject(displaySet2Mask, operatorParametersExtended.displaySet32));
+    buffer.setUint32(bitSet.fromObject(displaySet3Mask, operatorParametersExtended.displaySet33));
+    buffer.setUint32(bitSet.fromObject(displaySet4Mask, operatorParametersExtended.displaySet34));
+    buffer.setUint32(bitSet.fromObject(displaySet5Mask, operatorParametersExtended.displaySet35));
+};
+export const getPackedEnergiesWithDateSize = (parameters) => {
+    const { wh, vari, vare } = parameters.energies;
+    if (parameters?.energyType) {
+        const energiesNumber = [...wh, ...vari, ...vare].filter(energy => energy !== null).length;
+        return DATE_SIZE + PACKED_ENERGY_TYPE_SIZE + (energiesNumber * ENERGY_SIZE);
+    }
+    return DATE_SIZE + ENERGY_SIZE * TARIFF_NUMBER;
+};
+//# sourceMappingURL=CommandBinaryBuffer.js.map