jooby-codec 3.14.0 → 7.0.1

package/dist/mtx1/utils/CommandBinaryBuffer.js

@@ -0,0 +1,782 @@
+import * as bitSet from '../../utils/bitSet.js';
+import * as DeviceType from './deviceType.js';
+import getHexFromBytes from '../../utils/getHexFromBytes.js';
+import getBytesFromHex from '../../utils/getBytesFromHex.js';
+import * as frameTypes from '../constants/frameTypes.js';
+import frameNames from '../constants/frameNames.js';
+import * as events from '../constants/events.js';
+import eventNames from '../constants/eventNames.js';
+export const frameHeaderSize = 5;
+export const defaultFrameHeader = {
+    type: frameTypes.DATA_REQUEST,
+    destination: 0xffff,
+    source: 0xfffe
+};
+export const TARIFF_PLAN_SIZE = 11;
+export const OPERATOR_PARAMETERS_SIZE = 74;
+export const SEASON_PROFILE_DAYS_NUMBER = 7;
+export const SEASON_PROFILE_SIZE = 2 + SEASON_PROFILE_DAYS_NUMBER;
+export const TARIFF_NUMBER = 4;
+export const PACKED_ENERGY_TYPE_SIZE = 1;
+export const ENERGY_SIZE = 4;
+export const DATE_SIZE = 3;
+export const MIN_HALF_HOUR_PERIODS = 48;
+export const MAX_HALF_HOUR_PERIODS = 50;
+export const MIN_HALF_HOUR_COMMAND_SIZE = 3 + (MIN_HALF_HOUR_PERIODS * 2);
+export const MAX_HALF_HOUR_COMMAND_SIZE = 4 + (MAX_HALF_HOUR_PERIODS * 2);
+const baseDisplaySetMask = {
+    SET_ALL_SEGMENT_DISPLAY: 0x0001,
+    SOFTWARE_VERSION: 0x0002,
+    TOTAL_ACTIVE_ENERGY: 0x0004,
+    ACTIVE_ENERGY_T1: 0x0008,
+    ACTIVE_ENERGY_T2: 0x0010,
+    ACTIVE_ENERGY_T3: 0x0020,
+    ACTIVE_ENERGY_T4: 0x0040,
+    ACTIVE_POWER_PER_PHASE: 0x0080,
+    ACTIVE_POWER_IN_NEUTRAL: 0x0100,
+    CURRENT_IN_PHASE: 0x0200,
+    CURRENT_IN_NEUTRAL: 0x0400,
+    VOLTAGE: 0x0800,
+    HOUR_MINUTE_SECOND: 0x1000,
+    DATE_MONTH_YEAR: 0x2000,
+    TOTAL_EXPORTED_ACTIVE_ENERGY: 0x4000,
+    EXPORTED_ACTIVE_ENERGY_T1: 0x8000,
+    EXPORTED_ACTIVE_ENERGY_T2: 0x00010000,
+    EXPORTED_ACTIVE_ENERGY_T3: 0x00020000,
+    EXPORTED_ACTIVE_ENERGY_T4: 0x00040000,
+    POWER_FACTOR_PHASE_A: 0x00080000,
+    POWER_FACTOR_PHASE_B: 0x00100000,
+    BATTERY_VOLTAGE: 0x00200000,
+    POWER_THRESHOLD_T1: 0x00400000,
+    POWER_THRESHOLD_T2: 0x00800000,
+    POWER_THRESHOLD_T3: 0x01000000,
+    POWER_THRESHOLD_T4: 0x02000000,
+    CURRENT_BALANCE: 0x20000000
+};
+const displaySetMask = {
+    ...baseDisplaySetMask,
+    AUTO_SCREEN_SCROLLING: 0x80000000
+};
+const displaySetExtMask = {
+    ...baseDisplaySetMask,
+    MAGNET_INDUCTION: 0x08000000,
+    OPTOPORT_SPEED: 0x40000000,
+    SORT_DISPLAY_SCREENS: 0x80000000
+};
+const relaySet1Mask = {
+    RELAY_ON_Y: 0x01,
+    RELAY_ON_CENTER: 0x02,
+    RELAY_ON_PB: 0x04,
+    RELAY_ON_TARIFF_1: 0x08,
+    RELAY_ON_TARIFF_2: 0x10,
+    RELAY_ON_TARIFF_3: 0x20,
+    RELAY_ON_TARIFF_4: 0x40,
+    RELAY_ON_V_GOOD: 0x80
+};
+const relaySet2Mask = {
+    RELAY_OFF_Y: 0x01,
+    RELAY_OFF_CENTER: 0x02,
+    RELAY_OFF_TARIFF_1: 0x04,
+    RELAY_OFF_TARIFF_2: 0x08,
+    RELAY_OFF_TARIFF_3: 0x10,
+    RELAY_OFF_TARIFF_4: 0x20,
+    RELAY_OFF_I_LIMIT: 0x40,
+    RELAY_OFF_V_BAD: 0x80
+};
+const relaySet3Mask = {
+    RELAY_OFF_LIM_TARIFF_1: 0x02,
+    RELAY_OFF_LIM_TARIFF_2: 0x04,
+    RELAY_OFF_LIM_TARIFF_3: 0x08,
+    RELAY_OFF_LIM_TARIFF_4: 0x10,
+    RELAY_OFF_PF_MIN: 0x20
+};
+const relaySet4Mask = {
+    RELAY_ON_TIMEOUT: 0x01,
+    RELAY_ON_SALDO: 0x02,
+    RELAY_OFF_SALDO: 0x04,
+    RELAY_OFF_SALDO_SOFT: 0x08,
+    RELAY_OFF_MAGNET: 0x10,
+    RELAY_ON_MAGNET_TIMEOUT: 0x20,
+    RELAY_ON_MAGNET_AUTO: 0x40
+};
+const relaySet5Mask = {
+    RELAY_OFF_UNEQUAL_CURRENT: 0x01,
+    RELAY_ON_UNEQUAL_CURRENT: 0x02,
+    RELAY_OFF_BIPOLAR_POWER: 0x04,
+    RELAY_ON_BIPOLAR_POWER: 0x08
+};
+const define1Mask = {
+    BLOCK_KEY_OPTOPORT: 0x02,
+    MAGNET_SCREEN_CONST: 0x20
+};
+export const eventStatusMask = {
+    CASE_OPEN: 2 ** 0,
+    MAGNETIC_ON: 2 ** 1,
+    PARAMETERS_UPDATE_REMOTE: 2 ** 2,
+    PARAMETERS_UPDATE_LOCAL: 2 ** 3,
+    RESTART: 2 ** 4,
+    ERROR_ACCESS: 2 ** 5,
+    TIME_SET: 2 ** 6,
+    TIME_CORRECT: 2 ** 7,
+    DEVICE_FAILURE: 2 ** 8,
+    CASE_TERMINAL_OPEN: 2 ** 9,
+    CASE_MODULE_OPEN: 2 ** 10,
+    TARIFF_TABLE_SET: 2 ** 11,
+    TARIFF_TABLE_GET: 2 ** 12,
+    PROTECTION_RESET_EM: 2 ** 13,
+    PROTECTION_RESET_MAGNETIC: 2 ** 14
+};
+export const extendedCurrentValues2RelayStatusMask = {
+    RELAY_STATE: 2 ** 0,
+    RELAY_UBAD: 2 ** 1,
+    RELAY_UNEQ_CURRENT: 2 ** 4,
+    RELAY_OFF_CENTER: 2 ** 5,
+    RELAY_IMAX: 2 ** 6,
+    RELAY_PMAX: 2 ** 7
+};
+const extendedCurrentValues2RelayStatus2Mask = {
+    RELAY_COSFI: 2 ** 0,
+    RELAY_SALDO_OFF_FLAG: 2 ** 1,
+    RELAY_UNEQUAL_CURRENT_OFF: 2 ** 2,
+    RELAY_BIPOLAR_POWER_OFF: 2 ** 3,
+    RELAY_SALDO_OFF_ON_MAX_POWER: 2 ** 4,
+    RELAY_HARD_ST1: 2 ** 5,
+    RELAY_MAGNET_OFF: 2 ** 6,
+    RELAY_P_MINUS_MAX_OFF: 2 ** 7
+};
+const extendedCurrentValues2Status1Mask = {
+    MAXVA: 2 ** 0,
+    MINVA: 2 ** 1,
+    MAXT: 2 ** 2,
+    MINT: 2 ** 3,
+    MAXF: 2 ** 4,
+    MINF: 2 ** 5,
+    MAXIA: 2 ** 6,
+    MAXP: 2 ** 7
+};
+const extendedCurrentValues2Status2Mask = {
+    MAX_POWER_SALDO: 2 ** 0,
+    BATTERY_VBAT_BAD: 2 ** 1,
+    CLOCK_UNSET: 2 ** 3,
+    MIN_COS_FI: 2 ** 5
+};
+const extendedCurrentValues2Status3Mask = {
+    UNEQUAL_CURRENT: 2 ** 0,
+    BIPOLAR_POWER: 2 ** 1,
+    POWER_A_NEGATIVE: 2 ** 6,
+    POWER_B_NEGATIVE: 2 ** 7
+};
+const operatorParametersExtended3RelaySetMask = {
+    RELAY_OFF_LIMIT_P_MINUS_T1: 0x08,
+    RELAY_OFF_LIMIT_P_MINUS_T2: 0x10,
+    RELAY_OFF_LIMIT_P_MINUS_T3: 0x20,
+    RELAY_OFF_LIMIT_P_MINUS_T4: 0x40
+};
+function getPackedEnergies(buffer, energyType, tariffMapByte) {
+    const byte = tariffMapByte >> TARIFF_NUMBER;
+    const energies = new Array(TARIFF_NUMBER).fill(0);
+    energies.forEach((energy, index) => {
+        const isTariffExists = !!bitSet.extractBits(byte, 1, index + 1);
+        if (isTariffExists) {
+            energies[index] = buffer.getInt32();
+        }
+        else {
+            energies[index] = null;
+        }
+    });
+    return energies;
+}
+function setPackedEnergyType(buffer, energyType, energies) {
+    const indexShift = 1 + TARIFF_NUMBER;
+    let tariffsByte = energyType;
+    energies.forEach((energy, index) => {
+        tariffsByte = bitSet.fillBits(tariffsByte, 1, index + indexShift, Number(!!energy));
+    });
+    buffer.setUint8(tariffsByte);
+}
+function getEnergyPeriod(period) {
+    if (period === 0xffff) {
+        return {
+            tariff: undefined,
+            energy: undefined
+        };
+    }
+    return {
+        tariff: ((period >> 14) & 0x03),
+        energy: (period & 0x3fff)
+    };
+}
+function setEnergyPeriod(buffer, { tariff, energy }) {
+    if (tariff !== undefined && energy !== undefined) {
+        buffer.setUint16((tariff << 14) | (energy & 0x3fff));
+    }
+    else {
+        buffer.setUint16(0xffff);
+    }
+}
+export const getDayProfileFromByte = (value) => ({
+    tariff: bitSet.extractBits(value, 2, 1),
+    isFirstHalfHour: !bitSet.extractBits(value, 1, 3),
+    hour: bitSet.extractBits(value, 5, 4)
+});
+export const getByteFromDayProfile = (dayProfile) => {
+    let value = 0;
+    value = bitSet.fillBits(value, 2, 1, dayProfile.tariff);
+    value = bitSet.fillBits(value, 1, 3, +!dayProfile.isFirstHalfHour);
+    value = bitSet.fillBits(value, 5, 4, dayProfile.hour);
+    return value;
+};
+export const getDefaultSeasonProfile = () => ({
+    month: 1,
+    date: 1,
+    dayIndexes: [0, 0, 0, 0, 0, 0, 0]
+});
+export const getDefaultOperatorParameters = () => ({
+    vpThreshold: 265000,
+    vThreshold: 156000,
+    ipThreshold: 120000,
+    pmaxThreshold0: 31800,
+    pmaxThreshold1: 31800,
+    pmaxThreshold2: 31800,
+    pmaxThreshold3: 31800,
+    speedOptoPort: 0,
+    tint: 30,
+    calcPeriodDate: 1,
+    timeoutDisplay: 127,
+    timeoutScreen: 7,
+    displaySet: bitSet.toObject(displaySetMask, 0x80003184),
+    relaySet4: bitSet.toObject(relaySet4Mask, 0),
+    relaySet3: bitSet.toObject(relaySet3Mask, 0),
+    relaySet2: bitSet.toObject(relaySet2Mask, 3),
+    relaySet1: bitSet.toObject(relaySet1Mask, 3),
+    displayType: 0,
+    ten: 0,
+    timeoutRefresh: 240,
+    deltaCorMin: 15,
+    timeoutMagnetOff: 5,
+    timeoutMagnetOn: 5,
+    define1: bitSet.toObject(define1Mask, 0),
+    timeoutRelayOn: 1,
+    timeoutRelayKey: 0,
+    timeoutRelayAuto: 5,
+    timeoutBadVAVB: 5,
+    freqMax: 55,
+    freqMin: 45,
+    phMin: 0,
+    year: 0,
+    month: 0,
+    date: 0,
+    energyDecimalPoint: 2,
+    typeMeter: 0,
+    timeoutIMax: 5,
+    timeoutPMax: 5,
+    timeoutCos: 5,
+    pMaxDef: 1,
+    displaySetExt: bitSet.toObject(displaySetExtMask, 0x8383fff),
+    timeoutUneqCurrent: 5,
+    timeoutBipolarPower: 5,
+    relaySet5: bitSet.toObject(relaySet5Mask, 0),
+    timeCorrectPeriod: 24,
+    timeCorrectPassHalfhour: false
+});
+export const getDefaultOperatorParametersExtended3 = () => ({
+    pmaxMinusThreshold0: 0,
+    pmaxMinusThreshold1: 0,
+    pmaxMinusThreshold2: 0,
+    pmaxMinusThreshold3: 0,
+    relaySet: bitSet.toObject(operatorParametersExtended3RelaySetMask, 0)
+});
+export const getFrameHeader = function (buffer) {
+    const type = buffer.getUint8();
+    const typeName = frameNames[type];
+    const destination = buffer.getUint16();
+    const source = buffer.getUint16();
+    return {
+        type,
+        typeName,
+        destination,
+        source
+    };
+};
+export const setFrameHeader = function (buffer, { type = defaultFrameHeader.type, destination = defaultFrameHeader.destination, source = defaultFrameHeader.source }) {
+    buffer.setUint8(type);
+    buffer.setUint16(destination);
+    buffer.setUint16(source);
+};
+export const getDeviceId = function (buffer) {
+    const manufacturer = getHexFromBytes(buffer.getBytes(3), { separator: '' });
+    const type = buffer.getUint8();
+    const year = buffer.getUint8();
+    const serial = getHexFromBytes(buffer.getBytes(3), { separator: '' });
+    return { manufacturer, type, year, serial };
+};
+export const setDeviceId = function (buffer, { manufacturer, type, year, serial }) {
+    buffer.setBytes(getBytesFromHex(manufacturer));
+    buffer.setUint8(type);
+    buffer.setUint8(year);
+    buffer.setBytes(getBytesFromHex(serial));
+};
+export const getDateTime = function (buffer) {
+    return {
+        isSummerTime: !!buffer.getUint8(),
+        seconds: buffer.getUint8(),
+        minutes: buffer.getUint8(),
+        hours: buffer.getUint8(),
+        day: buffer.getUint8(),
+        date: buffer.getUint8(),
+        month: buffer.getUint8(),
+        year: buffer.getUint8()
+    };
+};
+export const setDateTime = function (buffer, dateTime) {
+    buffer.setUint8(dateTime.isSummerTime ? 1 : 0);
+    buffer.setUint8(dateTime.seconds);
+    buffer.setUint8(dateTime.minutes);
+    buffer.setUint8(dateTime.hours);
+    buffer.setUint8((dateTime.day || 0));
+    buffer.setUint8(dateTime.date);
+    buffer.setUint8(dateTime.month);
+    buffer.setUint8(dateTime.year);
+};
+export const getTariffPlan = function (buffer) {
+    return {
+        id: buffer.getUint32(),
+        tariffSet: buffer.getUint8(),
+        activateYear: buffer.getUint8(),
+        activateMonth: buffer.getUint8(),
+        activateDay: buffer.getUint8(),
+        specialProfilesArraySize: buffer.getUint8(),
+        seasonProfilesArraySize: buffer.getUint8(),
+        dayProfilesArraySize: buffer.getUint8()
+    };
+};
+export const setTariffPlan = function (buffer, tariffPlan) {
+    buffer.setUint32(tariffPlan.id);
+    buffer.setUint8(tariffPlan.tariffSet);
+    buffer.setUint8(tariffPlan.activateYear);
+    buffer.setUint8(tariffPlan.activateMonth);
+    buffer.setUint8(tariffPlan.activateDay);
+    buffer.setUint8(tariffPlan.specialProfilesArraySize);
+    buffer.setUint8(tariffPlan.seasonProfilesArraySize);
+    buffer.setUint8(tariffPlan.dayProfilesArraySize);
+};
+export const getTimeCorrectionParameters = function (buffer) {
+    return {
+        monthTransitionSummer: buffer.getUint8(),
+        dateTransitionSummer: buffer.getUint8(),
+        hoursTransitionSummer: buffer.getUint8(),
+        hoursCorrectSummer: buffer.getUint8(),
+        monthTransitionWinter: buffer.getUint8(),
+        dateTransitionWinter: buffer.getUint8(),
+        hoursTransitionWinter: buffer.getUint8(),
+        hoursCorrectWinter: buffer.getUint8(),
+        isCorrectionNeeded: buffer.getUint8() === 1
+    };
+};
+export const setTimeCorrectionParameters = function (buffer, parameters) {
+    buffer.setUint8(parameters.monthTransitionSummer);
+    buffer.setUint8(parameters.dateTransitionSummer);
+    buffer.setUint8(parameters.hoursTransitionSummer);
+    buffer.setUint8(parameters.hoursCorrectSummer);
+    buffer.setUint8(parameters.monthTransitionWinter);
+    buffer.setUint8(parameters.dateTransitionWinter);
+    buffer.setUint8(parameters.hoursTransitionWinter);
+    buffer.setUint8(parameters.hoursCorrectWinter);
+    buffer.setUint8(+parameters.isCorrectionNeeded);
+};
+export const getDayProfile = function (buffer) {
+    return getDayProfileFromByte(buffer.getUint8());
+};
+export const setDayProfile = function (buffer, dayProfile) {
+    buffer.setUint8(getByteFromDayProfile(dayProfile));
+};
+export const getSeasonProfile = function (buffer) {
+    return {
+        month: buffer.getUint8(),
+        date: buffer.getUint8(),
+        dayIndexes: new Array(SEASON_PROFILE_DAYS_NUMBER).fill(0).map(() => buffer.getUint8())
+    };
+};
+export const setSeasonProfile = function (buffer, seasonProfile) {
+    buffer.setUint8(seasonProfile.month);
+    buffer.setUint8(seasonProfile.date);
+    seasonProfile.dayIndexes.forEach(value => buffer.setUint8(value));
+};
+export const getSpecialDay = function (buffer) {
+    return {
+        month: buffer.getUint8(),
+        date: buffer.getUint8(),
+        dayIndex: buffer.getUint8(),
+        isPeriodic: buffer.getUint8() === 0
+    };
+};
+export const setSpecialDay = function (buffer, specialDay) {
+    buffer.setUint8(specialDay.month);
+    buffer.setUint8(specialDay.date);
+    buffer.setUint8(specialDay.dayIndex);
+    buffer.setUint8(+!specialDay.isPeriodic);
+};
+export const getDeviceType = function (buffer) {
+    return DeviceType.fromBytes(buffer.getBytes(9));
+};
+export const setDeviceType = function (buffer, deviceType) {
+    buffer.setBytes(DeviceType.toBytes(deviceType));
+};
+export const getOperatorParameters = function (buffer) {
+    const operatorParameters = {
+        vpThreshold: buffer.getUint32(),
+        vThreshold: buffer.getUint32(),
+        ipThreshold: buffer.getUint32(),
+        pmaxThreshold0: buffer.getUint32(),
+        pmaxThreshold1: buffer.getUint32(),
+        pmaxThreshold2: buffer.getUint32(),
+        pmaxThreshold3: buffer.getUint32(),
+        speedOptoPort: buffer.getUint8(),
+        tint: buffer.getUint8(),
+        calcPeriodDate: buffer.getUint8(),
+        timeoutDisplay: buffer.getUint8(),
+        timeoutScreen: buffer.getUint8(),
+        displaySet: bitSet.toObject(displaySetMask, buffer.getUint32()),
+        relaySet4: bitSet.toObject(relaySet4Mask, buffer.getUint8()),
+        relaySet3: bitSet.toObject(relaySet3Mask, buffer.getUint8()),
+        relaySet2: bitSet.toObject(relaySet2Mask, buffer.getUint8()),
+        relaySet1: bitSet.toObject(relaySet1Mask, buffer.getUint8()),
+        displayType: buffer.getUint8(),
+        ten: buffer.getUint8(),
+        timeoutRefresh: buffer.getUint16(),
+        deltaCorMin: buffer.getUint8(),
+        timeoutMagnetOff: buffer.getUint8(),
+        timeoutMagnetOn: buffer.getUint8(),
+        define1: bitSet.toObject(define1Mask, buffer.getUint8()),
+        timeoutRelayOn: buffer.getUint8(),
+        timeoutRelayKey: buffer.getUint8(),
+        timeoutRelayAuto: buffer.getUint8(),
+        timeoutBadVAVB: buffer.getUint8(),
+        freqMax: buffer.getUint8(),
+        freqMin: buffer.getUint8(),
+        phMin: buffer.getUint16(),
+        year: buffer.getUint8(),
+        month: buffer.getUint8(),
+        date: buffer.getUint8(),
+        energyDecimalPoint: buffer.getUint8(),
+        typeMeter: buffer.getUint8(),
+        timeoutIMax: buffer.getUint8(),
+        timeoutPMax: buffer.getUint8(),
+        timeoutCos: buffer.getUint8(),
+        pMaxDef: buffer.getUint8(),
+        displaySetExt: bitSet.toObject(displaySetExtMask, buffer.getUint32()),
+        timeoutUneqCurrent: buffer.getUint8(),
+        timeoutBipolarPower: buffer.getUint8(),
+        relaySet5: bitSet.toObject(relaySet5Mask, buffer.getUint8()),
+        timeCorrectPeriod: 0,
+        timeCorrectPassHalfhour: false
+    };
+    const timeCorrectPeriod = buffer.getUint8();
+    operatorParameters.timeCorrectPeriod = timeCorrectPeriod & 0x7f;
+    operatorParameters.timeCorrectPassHalfhour = !!(timeCorrectPeriod & 0x80);
+    return operatorParameters;
+};
+export const setOperatorParameters = function (buffer, operatorParameters) {
+    const timeCorrectPeriod = operatorParameters.timeCorrectPeriod
+        | (operatorParameters.timeCorrectPassHalfhour ? 0x80 : 0);
+    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.setUint8(operatorParameters.speedOptoPort);
+    buffer.setUint8(operatorParameters.tint);
+    buffer.setUint8(operatorParameters.calcPeriodDate);
+    buffer.setUint8(operatorParameters.timeoutDisplay);
+    buffer.setUint8(operatorParameters.timeoutScreen);
+    buffer.setUint32(bitSet.fromObject(displaySetMask, operatorParameters.displaySet));
+    buffer.setUint8(bitSet.fromObject(relaySet4Mask, operatorParameters.relaySet4));
+    buffer.setUint8(bitSet.fromObject(relaySet3Mask, operatorParameters.relaySet3));
+    buffer.setUint8(bitSet.fromObject(relaySet2Mask, operatorParameters.relaySet2));
+    buffer.setUint8(bitSet.fromObject(relaySet1Mask, operatorParameters.relaySet1));
+    buffer.setUint8(operatorParameters.displayType);
+    buffer.setUint8(operatorParameters.ten);
+    buffer.setUint16(operatorParameters.timeoutRefresh);
+    buffer.setUint8(operatorParameters.deltaCorMin);
+    buffer.setUint8(operatorParameters.timeoutMagnetOff);
+    buffer.setUint8(operatorParameters.timeoutMagnetOn);
+    buffer.setUint8(bitSet.fromObject(define1Mask, operatorParameters.define1));
+    buffer.setUint8(operatorParameters.timeoutRelayOn);
+    buffer.setUint8(operatorParameters.timeoutRelayKey);
+    buffer.setUint8(operatorParameters.timeoutRelayAuto);
+    buffer.setUint8(operatorParameters.timeoutBadVAVB);
+    buffer.setUint8(operatorParameters.freqMax);
+    buffer.setUint8(operatorParameters.freqMin);
+    buffer.setUint16(operatorParameters.phMin);
+    buffer.setUint8(operatorParameters.year);
+    buffer.setUint8(operatorParameters.month);
+    buffer.setUint8(operatorParameters.date);
+    buffer.setUint8(operatorParameters.energyDecimalPoint);
+    buffer.setUint8(operatorParameters.typeMeter);
+    buffer.setUint8(operatorParameters.timeoutIMax);
+    buffer.setUint8(operatorParameters.timeoutPMax);
+    buffer.setUint8(operatorParameters.timeoutCos);
+    buffer.setUint8(operatorParameters.pMaxDef);
+    buffer.setUint32(bitSet.fromObject(displaySetExtMask, operatorParameters.displaySetExt));
+    buffer.setUint8(operatorParameters.timeoutUneqCurrent);
+    buffer.setUint8(operatorParameters.timeoutBipolarPower);
+    buffer.setUint8(bitSet.fromObject(relaySet5Mask, operatorParameters.relaySet5));
+    buffer.setUint8(timeCorrectPeriod);
+};
+export const getPackedEnergyWithType = function (buffer) {
+    const byte = buffer.getUint8();
+    const energyType = bitSet.extractBits(byte, TARIFF_NUMBER, 1);
+    const energies = getPackedEnergies(buffer, energyType, byte);
+    return {
+        energyType,
+        energies
+    };
+};
+export const setPackedEnergyWithType = function (buffer, { energyType, energies }) {
+    if (energyType) {
+        setPackedEnergyType(buffer, energyType, energies);
+    }
+    energies.forEach(energy => {
+        if (energy !== null) {
+            buffer.setInt32(energy);
+        }
+    });
+};
+export const getEnergies = function (buffer) {
+    return new Array(TARIFF_NUMBER).fill(0).map(() => buffer.getInt32());
+};
+export const setEnergies = function (buffer, energies) {
+    energies.forEach(value => buffer.setInt32(value));
+};
+export const getDate = function (buffer) {
+    return {
+        year: buffer.getUint8(),
+        month: buffer.getUint8(),
+        date: buffer.getUint8()
+    };
+};
+export const setDate = function (buffer, date) {
+    buffer.setUint8(date.year);
+    buffer.setUint8(date.month);
+    buffer.setUint8(date.date);
+};
+export const getSaldoParameters = function (buffer) {
+    return {
+        coefficients: new Array(4).fill(0).map(() => buffer.getUint32()),
+        decimalPointTariff: buffer.getUint8(),
+        indicationThreshold: buffer.getInt32(),
+        relayThreshold: buffer.getInt32(),
+        mode: buffer.getUint8(),
+        saldoOffTimeBegin: buffer.getUint8(),
+        saldoOffTimeEnd: buffer.getUint8(),
+        decimalPointIndication: buffer.getUint8(),
+        powerThreshold: buffer.getUint32(),
+        creditThreshold: buffer.getInt32()
+    };
+};
+export const setSaldoParameters = function (buffer, saldoParameters) {
+    saldoParameters.coefficients.forEach(value => buffer.setUint32(value));
+    buffer.setUint8(saldoParameters.decimalPointTariff);
+    buffer.setInt32(saldoParameters.indicationThreshold);
+    buffer.setInt32(saldoParameters.relayThreshold);
+    buffer.setUint8(saldoParameters.mode);
+    buffer.setUint8(saldoParameters.saldoOffTimeBegin);
+    buffer.setUint8(saldoParameters.saldoOffTimeEnd);
+    buffer.setUint8(saldoParameters.decimalPointIndication);
+    buffer.setUint32(saldoParameters.powerThreshold);
+    buffer.setInt32(saldoParameters.creditThreshold);
+};
+export const getEnergyPeriods = function (buffer, periodsNumber) {
+    const periods = new Array(periodsNumber).fill(0).map(() => buffer.getUint16());
+    return periods.map(period => getEnergyPeriod(period));
+};
+export const setEnergyPeriods = function (buffer, periods) {
+    periods.forEach(period => setEnergyPeriod(buffer, period));
+};
+export const getEventStatus = function (buffer) {
+    const eventStatus = buffer.getUint16();
+    return bitSet.toObject(eventStatusMask, eventStatus);
+};
+export const setEventStatus = function (buffer, parameters) {
+    buffer.setUint16(bitSet.fromObject(eventStatusMask, parameters));
+};
+export const getExtendedCurrentValues2 = function (buffer) {
+    const uBattery = buffer.getUint16();
+    const relayStatus = bitSet.toObject(extendedCurrentValues2RelayStatusMask, buffer.getUint8());
+    const relayStatus2 = bitSet.toObject(extendedCurrentValues2RelayStatus2Mask, buffer.getUint8());
+    const status1 = bitSet.toObject(extendedCurrentValues2Status1Mask, buffer.getUint8());
+    const status2 = bitSet.toObject(extendedCurrentValues2Status2Mask, buffer.getUint8());
+    const status3 = bitSet.toObject(extendedCurrentValues2Status3Mask, buffer.getUint8());
+    return {
+        uBattery,
+        relayStatus,
+        relayStatus2,
+        status1,
+        status2,
+        status3
+    };
+};
+export const setExtendedCurrentValues2 = function (buffer, parameters) {
+    const { uBattery, relayStatus, relayStatus2, status1, status2, status3 } = parameters;
+    buffer.setUint16(uBattery);
+    buffer.setUint8(bitSet.fromObject(extendedCurrentValues2RelayStatusMask, relayStatus));
+    buffer.setUint8(bitSet.fromObject(extendedCurrentValues2RelayStatus2Mask, relayStatus2));
+    buffer.setUint8(bitSet.fromObject(extendedCurrentValues2Status1Mask, status1));
+    buffer.setUint8(bitSet.fromObject(extendedCurrentValues2Status2Mask, status2));
+    buffer.setUint8(bitSet.fromObject(extendedCurrentValues2Status3Mask, status3));
+};
+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 getDemandParameters = function (buffer) {
+    const channelParam1 = buffer.getUint8();
+    const counterInterval = buffer.getUint8();
+    const channelParam2 = buffer.getUint8();
+    return { channelParam1, counterInterval, channelParam2 };
+};
+export const setDemandParameters = function (buffer, parameters) {
+    buffer.setUint8(parameters.channelParam1);
+    buffer.setUint8(parameters.counterInterval);
+    buffer.setUint8(parameters.channelParam2);
+    buffer.setUint8(0);
+};
+export const getDayMaxDemandResponse = function (buffer) {
+    const date = getDate(buffer);
+    const power = new Array(TARIFF_NUMBER).fill(0).map(() => ({
+        hours: buffer.getUint8(),
+        minutes: buffer.getUint8(),
+        power: buffer.getUint32()
+    }));
+    return { date, power };
+};
+export const setDayMaxDemandResponse = function (buffer, parameters) {
+    setDate(buffer, parameters.date);
+    parameters.power.forEach(value => {
+        buffer.setUint8(value.hours);
+        buffer.setUint8(value.minutes);
+        buffer.setUint32(value.power);
+    });
+};
+export const getOperatorParametersExtended3 = function (buffer) {
+    return {
+        pmaxMinusThreshold0: buffer.getUint32(),
+        pmaxMinusThreshold1: buffer.getUint32(),
+        pmaxMinusThreshold2: buffer.getUint32(),
+        pmaxMinusThreshold3: buffer.getUint32(),
+        relaySet: bitSet.toObject(operatorParametersExtended3RelaySetMask, buffer.getUint8())
+    };
+};
+export const setOperatorParametersExtended3 = function (buffer, parameters) {
+    const { pmaxMinusThreshold0, pmaxMinusThreshold1, pmaxMinusThreshold2, pmaxMinusThreshold3, relaySet } = parameters;
+    buffer.setUint32(pmaxMinusThreshold0);
+    buffer.setUint32(pmaxMinusThreshold1);
+    buffer.setUint32(pmaxMinusThreshold2);
+    buffer.setUint32(pmaxMinusThreshold3);
+    buffer.setUint8(bitSet.fromObject(operatorParametersExtended3RelaySetMask, relaySet));
+};
+export const getMonthMaxPowerByTariffs = function (buffer) {
+    return new Array(TARIFF_NUMBER).fill(0).map(() => ({
+        date: buffer.getUint8(),
+        hours: buffer.getUint8(),
+        minutes: buffer.getUint8(),
+        power: buffer.getUint32()
+    }));
+};
+export const setMonthMaxPowerByTariffs = function (buffer, tariffs) {
+    tariffs.forEach(tariff => {
+        buffer.setUint8(tariff.date);
+        buffer.setUint8(tariff.hours);
+        buffer.setUint8(tariff.minutes);
+        buffer.setUint32(tariff.power);
+    });
+};
+export const getDefaultTimeCorrectionParameters = () => ({
+    monthTransitionSummer: 3,
+    dateTransitionSummer: 0,
+    hoursTransitionSummer: 3,
+    hoursCorrectSummer: 1,
+    monthTransitionWinter: 10,
+    dateTransitionWinter: 0,
+    hoursTransitionWinter: 4,
+    hoursCorrectWinter: 1,
+    isCorrectionNeeded: true
+});
+export const getPackedEnergiesWithDateSize = (parameters) => {
+    if (parameters?.energyType) {
+        const energiesNumber = parameters.energies.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