jooby-codec 3.15.0 → 7.1.0

package/dist/analog/utils/CommandBinaryBuffer.js

@@ -0,0 +1,1336 @@
+import * as bitSet from '../../utils/bitSet.js';
+import invertObject from '../../utils/invertObject.js';
+import getHexFromBytes from '../../utils/getHexFromBytes.js';
+import getBytesFromHex from '../../utils/getBytesFromHex.js';
+import roundNumber from '../../utils/roundNumber.js';
+import { extractBits, fillBits } from '../../utils/bitSet.js';
+import { getDateFromTime2000, getTime2000FromDate } from './time.js';
+import * as hardwareTypes from '../constants/hardwareTypes.js';
+import * as deviceParameters from '../constants/deviceParameters.js';
+import deviceParameterNames from '../constants/deviceParameterNames.js';
+import * as archive from '../constants/archive.js';
+import * as channelTypes from '../constants/channelTypes.js';
+import spreadFactorNames from '../constants/rx2SpreadFactorNames.js';
+const INITIAL_YEAR = 2000;
+const MONTH_BIT_SIZE = 4;
+const DATE_BIT_SIZE = 5;
+const YEAR_START_INDEX = 1;
+const UNKNOWN_BATTERY_VOLTAGE = 4095;
+const EXTEND_BIT_MASK = 0x80;
+const LAST_BIT_INDEX = 7;
+const DATA_SENDING_INTERVAL_SECONDS_COEFFICIENT = 600;
+const PARAMETER_RX2_FREQUENCY_COEFFICIENT = 100;
+const SERIAL_NUMBER_SIZE = 6;
+const MAGNETIC_INFLUENCE_BIT_INDEX = 8;
+const LEGACY_HOUR_COUNTER_SIZE = 2 + 4;
+const LEGACY_HOUR_DIFF_SIZE = 2;
+const GAS_HARDWARE_TYPES = [
+    hardwareTypes.GASI2,
+    hardwareTypes.GASI3,
+    hardwareTypes.GASI1,
+    hardwareTypes.GASIC,
+    hardwareTypes.NBIOT
+];
+const TWO_CHANNELS_HARDWARE_TYPES = [
+    hardwareTypes.IMP2AS,
+    hardwareTypes.IMP2EU,
+    hardwareTypes.IMP2IN,
+    hardwareTypes.NOVATOR
+];
+const ELIMP_HARDWARE_TYPES = [
+    hardwareTypes.ELIMP
+];
+const FOUR_CHANNELS_HARDWARE_TYPES = [
+    hardwareTypes.IMP4EU,
+    hardwareTypes.IMP4IN
+];
+const MTX_HARDWARE_TYPES = [
+    hardwareTypes.MTXLORA
+];
+const TWO_BYTES_HARDWARE_TYPES = [...FOUR_CHANNELS_HARDWARE_TYPES, ...MTX_HARDWARE_TYPES];
+const gasBitMask = {
+    isBatteryLow: Math.pow(2, 0),
+    isMagneticInfluence: Math.pow(2, 1),
+    isButtonReleased: Math.pow(2, 2),
+    isConnectionLost: Math.pow(2, 3)
+};
+const twoChannelBitMask = {
+    isBatteryLow: Math.pow(2, 0),
+    isConnectionLost: Math.pow(2, 3),
+    isFirstChannelInactive: Math.pow(2, 4),
+    isSecondChannelInactive: Math.pow(2, 5)
+};
+const elimpBitMask = {
+    isConnectionLost: Math.pow(2, 3)
+};
+const fourChannelBitMask = {
+    isBatteryLow: Math.pow(2, 0),
+    isConnectionLost: Math.pow(2, 3),
+    isFirstChannelInactive: Math.pow(2, 4),
+    isSecondChannelInactive: Math.pow(2, 5),
+    isThirdChannelInactive: Math.pow(2, 6),
+    isForthChannelInactive: Math.pow(2, 8)
+};
+const mtxBitMask = {
+    isMeterCaseOpen: Math.pow(2, 0),
+    isMagneticInfluence: Math.pow(2, 1),
+    isParametersSetRemotely: Math.pow(2, 2),
+    isParametersSetLocally: Math.pow(2, 3),
+    isMeterProgramRestarted: Math.pow(2, 4),
+    isLockedOut: Math.pow(2, 5),
+    isTimeSet: Math.pow(2, 6),
+    isTimeCorrected: Math.pow(2, 7),
+    isMeterFailure: Math.pow(2, 8),
+    isMeterTerminalBoxOpen: Math.pow(2, 9),
+    isModuleCompartmentOpen: Math.pow(2, 10),
+    isTariffPlanChanged: Math.pow(2, 11),
+    isNewTariffPlanReceived: Math.pow(2, 12),
+    isElectromagneticInfluenceReset: Math.pow(2, 13),
+    isMagneticInfluenceReset: Math.pow(2, 14)
+};
+const usWaterMeterEventBitMask = {
+    transportMode: 0x01,
+    frequencyOutput: 0x02,
+    reverseFlow: 0x04,
+    tamperBreak: 0x08,
+    leakage: 0x10,
+    pipeBreak: 0x20,
+    pipeEmpty: 0x40,
+    batteryDischarge: 0x80
+};
+const getChannelTypeSize = ({ type }) => {
+    let size = 1;
+    switch (type) {
+        case channelTypes.IDLE:
+        case channelTypes.PULSE_SENSOR:
+        case channelTypes.POWER_CHANNEL:
+            break;
+        case channelTypes.BINARY_SENSOR:
+            size += 2;
+            break;
+        case channelTypes.TEMPERATURE_SENSOR:
+            size += 5;
+            break;
+        default:
+            break;
+    }
+    return size;
+};
+const parametersSizeMap = {
+    [deviceParameters.REPORTING_DATA_INTERVAL]: 1 + 4,
+    [deviceParameters.DAY_CHECKOUT_HOUR]: 1 + 1,
+    [deviceParameters.REPORTING_DATA_TYPE]: 1 + 1,
+    [deviceParameters.PRIORITY_DATA_DELIVERY_TYPE]: 1 + 1,
+    [deviceParameters.ACTIVATION_METHOD]: 1 + 1,
+    [deviceParameters.BATTERY_DEPASSIVATION_INFO]: 1 + 6,
+    [deviceParameters.BATTERY_MINIMAL_LOAD_TIME]: 1 + 4,
+    [deviceParameters.CHANNELS_CONFIG]: 1 + 1,
+    [deviceParameters.RX2_CONFIG]: 1 + 4,
+    [deviceParameters.ABSOLUTE_DATA]: 1 + 9,
+    [deviceParameters.ABSOLUTE_DATA_ENABLE]: 1 + 1,
+    [deviceParameters.SERIAL_NUMBER]: 1 + 6,
+    [deviceParameters.GEOLOCATION]: 1 + 10,
+    [deviceParameters.EXTRA_FRAME_INTERVAL]: 1 + 2,
+    [deviceParameters.ABSOLUTE_DATA_MULTI_CHANNEL]: 1 + 10,
+    [deviceParameters.ABSOLUTE_DATA_ENABLE_MULTI_CHANNEL]: 1 + 2,
+    [deviceParameters.PULSE_CHANNELS_SCAN_CONFIG]: 1 + 3,
+    [deviceParameters.PULSE_CHANNELS_SET_CONFIG]: 1 + 1,
+    [deviceParameters.BATTERY_DEPASSIVATION_CONFIG]: 1 + 4,
+    [deviceParameters.MQTT_SSL_ENABLE]: 1 + 1,
+    [deviceParameters.MQTT_DATA_RECEIVE_CONFIG]: 1 + 3,
+    [deviceParameters.MQTT_DATA_SEND_CONFIG]: 1 + 3,
+    [deviceParameters.NBIOT_SSL_CONFIG]: 1 + 2,
+    [deviceParameters.NBIOT_SSL_CACERT_SET]: 1 + 4,
+    [deviceParameters.NBIOT_SSL_CLIENT_CERT_SET]: 1 + 4,
+    [deviceParameters.NBIOT_SSL_CLIENT_KEY_SET]: 1 + 4,
+    [deviceParameters.REPORTING_DATA_CONFIG]: 1 + 4,
+    [deviceParameters.EVENTS_CONFIG]: 1 + 3,
+    [deviceParameters.NBIOT_LED_INDICATION]: 1 + 2,
+    [deviceParameters.NBIOT_SIM]: 1 + 3,
+    [deviceParameters.EXTRA_PAYLOAD_ENABLE]: 1 + 1,
+    [deviceParameters.TIME_SYNCHRONIZATION_PERIOD_VIA_MAC]: 1 + 4,
+    [deviceParameters.KEEP_LORA_CONNECTION_ON_REMOVAL]: 1 + 1,
+    [deviceParameters.ACTIVATE_MODULE]: 1 + 1
+};
+const fourChannelsBitMask = {
+    channel1: Math.pow(2, 0),
+    channel2: Math.pow(2, 1),
+    channel3: Math.pow(2, 2),
+    channel4: Math.pow(2, 3)
+};
+export const getChannelsMaskFromNumber = (value) => {
+    const object = bitSet.toObject(fourChannelsBitMask, value);
+    return { channel1: object.channel1, channel2: object.channel2, channel3: object.channel3, channel4: object.channel4 };
+};
+export const setChannelsMaskToNumber = (channelsMask) => {
+    const { channel1, channel2, channel3, channel4 } = channelsMask;
+    return bitSet.fromObject(fourChannelsBitMask, { channel1, channel2, channel3, channel4 });
+};
+const getChannelsMask = (buffer) => getChannelsMaskFromNumber(buffer.getUint8());
+const setChannelsMask = (buffer, channelsMask) => (buffer.setUint8(setChannelsMaskToNumber(channelsMask)));
+const byteToPulseCoefficientMap = {
+    128: 1,
+    129: 5,
+    130: 10,
+    131: 100,
+    132: 1000,
+    133: 10000,
+    134: 100000
+};
+const pulseCoefficientToByteMap = invertObject(byteToPulseCoefficientMap);
+const isMSBSet = (value) => !!(value & 0x80);
+const getNbiotSslWrite = (buffer) => ({
+    size: buffer.getUint16(),
+    position: buffer.getUint16(),
+    chunk: buffer.getBytesLeft()
+});
+const setNbiotSslWrite = (buffer, parameter) => {
+    if (parameter.size !== parameter.chunk.length) {
+        throw new Error('ssl chunk size parameter doesn\'t match actual ssl chunk size');
+    }
+    buffer.setUint16(parameter.size);
+    buffer.setUint16(parameter.position);
+    buffer.setBytes(parameter.chunk);
+};
+const getNbiotSslSet = (buffer) => ({ crc32: buffer.getUint32() });
+const setNbiotSslSet = (buffer, parameter) => {
+    buffer.setUint32(parameter.crc32);
+};
+const deviceParameterConvertersMap = {
+    [deviceParameters.REPORTING_DATA_INTERVAL]: {
+        get: (buffer) => ({
+            specialSchedulePeriod: buffer.getUint8() * DATA_SENDING_INTERVAL_SECONDS_COEFFICIENT,
+            firstDaysSpecialSchedule: buffer.getUint8(),
+            lastDaysSpecialSchedule: buffer.getUint8(),
+            period: buffer.getUint8() * DATA_SENDING_INTERVAL_SECONDS_COEFFICIENT
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.specialSchedulePeriod / DATA_SENDING_INTERVAL_SECONDS_COEFFICIENT);
+            buffer.setUint8(parameter.firstDaysSpecialSchedule);
+            buffer.setUint8(parameter.lastDaysSpecialSchedule);
+            buffer.setUint8(parameter.period / DATA_SENDING_INTERVAL_SECONDS_COEFFICIENT);
+        }
+    },
+    [deviceParameters.DAY_CHECKOUT_HOUR]: {
+        get: (buffer) => ({
+            value: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.value);
+        }
+    },
+    [deviceParameters.REPORTING_DATA_TYPE]: {
+        get: (buffer) => ({
+            type: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.type);
+        }
+    },
+    [deviceParameters.PRIORITY_DATA_DELIVERY_TYPE]: {
+        get: (buffer) => ({ value: buffer.getUint8() }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.value);
+        }
+    },
+    [deviceParameters.ACTIVATION_METHOD]: {
+        get: (buffer) => ({
+            type: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.type);
+        }
+    },
+    [deviceParameters.BATTERY_DEPASSIVATION_INFO]: {
+        get: (buffer) => ({
+            loadTime: buffer.getUint16(),
+            internalResistance: buffer.getUint16(),
+            lowVoltage: buffer.getUint16()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint16(parameter.loadTime);
+            buffer.setUint16(parameter.internalResistance);
+            buffer.setUint16(parameter.lowVoltage);
+        }
+    },
+    [deviceParameters.BATTERY_MINIMAL_LOAD_TIME]: {
+        get: (buffer) => ({
+            value: buffer.getUint32()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint32(parameter.value);
+        }
+    },
+    [deviceParameters.CHANNELS_CONFIG]: {
+        get: (buffer) => ({ value: buffer.getUint8() }),
+        set: (buffer, parameter) => {
+            if (parameter.value < 0 || parameter.value > 18) {
+                throw new Error('channels config must be between 0-18');
+            }
+            buffer.setUint8(parameter.value);
+        }
+    },
+    [deviceParameters.RX2_CONFIG]: {
+        get: (buffer) => {
+            const spreadFactor = buffer.getUint8();
+            const spreadFactorName = spreadFactorNames[spreadFactor];
+            const frequency = buffer.getUint24() * PARAMETER_RX2_FREQUENCY_COEFFICIENT;
+            return { spreadFactor, spreadFactorName, frequency };
+        },
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.spreadFactor);
+            buffer.setUint24(parameter.frequency / PARAMETER_RX2_FREQUENCY_COEFFICIENT);
+        }
+    },
+    [deviceParameters.ABSOLUTE_DATA]: {
+        get: (buffer) => ({
+            meterValue: buffer.getUint32(),
+            pulseCoefficient: getPulseCoefficient(buffer),
+            value: buffer.getUint32()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint32(parameter.meterValue);
+            setPulseCoefficient(buffer, parameter.pulseCoefficient);
+            buffer.setUint32(parameter.value);
+        }
+    },
+    [deviceParameters.ABSOLUTE_DATA_ENABLE]: {
+        get: (buffer) => ({ state: buffer.getUint8() }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.state);
+        }
+    },
+    [deviceParameters.SERIAL_NUMBER]: {
+        get: (buffer) => ({
+            value: getHexFromBytes(buffer.getBytes(SERIAL_NUMBER_SIZE))
+        }),
+        set: (buffer, parameter) => {
+            getBytesFromHex(parameter.value).forEach(byte => buffer.setUint8(byte));
+        }
+    },
+    [deviceParameters.GEOLOCATION]: {
+        get: (buffer) => ({
+            latitude: roundNumber(buffer.getFloat32()),
+            longitude: roundNumber(buffer.getFloat32()),
+            altitude: roundNumber(buffer.getUint16())
+        }),
+        set: (buffer, parameter) => {
+            buffer.setFloat32(roundNumber(parameter.latitude));
+            buffer.setFloat32(roundNumber(parameter.longitude));
+            buffer.setUint16(roundNumber(parameter.altitude));
+        }
+    },
+    [deviceParameters.EXTRA_FRAME_INTERVAL]: {
+        get: (buffer) => ({ value: buffer.getUint16() }),
+        set: (buffer, parameter) => {
+            buffer.setUint16(parameter.value);
+        }
+    },
+    [deviceParameters.ABSOLUTE_DATA_MULTI_CHANNEL]: {
+        get: (buffer) => ({
+            channel: getChannelValue(buffer),
+            meterValue: buffer.getUint32(),
+            pulseCoefficient: getPulseCoefficient(buffer),
+            value: buffer.getUint32()
+        }),
+        set: (buffer, parameter) => {
+            setChannelValue(buffer, parameter.channel);
+            buffer.setUint32(parameter.meterValue);
+            setPulseCoefficient(buffer, parameter.pulseCoefficient);
+            buffer.setUint32(parameter.value);
+        }
+    },
+    [deviceParameters.ABSOLUTE_DATA_ENABLE_MULTI_CHANNEL]: {
+        get: (buffer) => ({
+            channel: getChannelValue(buffer),
+            state: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            setChannelValue(buffer, parameter.channel);
+            buffer.setUint8(parameter.state);
+        }
+    },
+    [deviceParameters.PULSE_CHANNELS_SCAN_CONFIG]: {
+        get: (buffer) => ({
+            channelList: getChannels(buffer),
+            pullUpTime: buffer.getUint8(),
+            scanTime: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            if (parameter.pullUpTime < 17) {
+                throw new Error('minimal value for pullUpTime - 17');
+            }
+            if (parameter.scanTime < 15) {
+                throw new Error('minimal value for scanTime - 15');
+            }
+            setChannels(buffer, parameter.channelList.map(index => ({ index })));
+            buffer.setUint8(parameter.pullUpTime);
+            buffer.setUint8(parameter.scanTime);
+        }
+    },
+    [deviceParameters.PULSE_CHANNELS_SET_CONFIG]: {
+        get: getChannelsMask,
+        set: setChannelsMask
+    },
+    [deviceParameters.BATTERY_DEPASSIVATION_CONFIG]: {
+        get: (buffer) => ({
+            resistanceStartThreshold: buffer.getUint16(),
+            resistanceStopThreshold: buffer.getUint16()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint16(parameter.resistanceStartThreshold);
+            buffer.setUint16(parameter.resistanceStopThreshold);
+        }
+    },
+    [deviceParameters.MQTT_SESSION_CONFIG]: {
+        get: (buffer) => ({
+            clientId: buffer.getString(),
+            username: buffer.getString(),
+            password: buffer.getString(),
+            cleanSession: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.clientId);
+            buffer.setString(parameter.username);
+            buffer.setString(parameter.password);
+            buffer.setUint8(parameter.cleanSession);
+        }
+    },
+    [deviceParameters.MQTT_BROKER_ADDRESS]: {
+        get: (buffer) => ({
+            hostName: buffer.getString(),
+            port: buffer.getUint16()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.hostName);
+            buffer.setUint16(parameter.port);
+        }
+    },
+    [deviceParameters.MQTT_SSL_ENABLE]: {
+        get: (buffer) => ({
+            enable: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.enable);
+        }
+    },
+    [deviceParameters.MQTT_TOPIC_PREFIX]: {
+        get: (buffer) => ({
+            topicPrefix: buffer.getString()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.topicPrefix);
+        }
+    },
+    [deviceParameters.MQTT_DATA_RECEIVE_CONFIG]: {
+        get: (buffer) => ({
+            qos: buffer.getUint8(),
+            count: buffer.getUint8(),
+            timeout: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.qos);
+            buffer.setUint8(parameter.count);
+            buffer.setUint8(parameter.timeout);
+        }
+    },
+    [deviceParameters.MQTT_DATA_SEND_CONFIG]: {
+        get: (buffer) => ({
+            qos: buffer.getUint8(),
+            retain: buffer.getUint8(),
+            newestSendFirst: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.qos);
+            buffer.setUint8(parameter.retain);
+            buffer.setUint8(parameter.newestSendFirst);
+        }
+    },
+    [deviceParameters.NBIOT_SSL_CONFIG]: {
+        get: (buffer) => ({
+            securityLevel: buffer.getUint8(),
+            version: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.securityLevel);
+            buffer.setUint8(parameter.version);
+        }
+    },
+    [deviceParameters.NBIOT_SSL_CACERT_WRITE]: {
+        get: getNbiotSslWrite,
+        set: setNbiotSslWrite
+    },
+    [deviceParameters.NBIOT_SSL_CACERT_SET]: {
+        get: getNbiotSslSet,
+        set: setNbiotSslSet
+    },
+    [deviceParameters.NBIOT_SSL_CLIENT_CERT_WRITE]: {
+        get: getNbiotSslWrite,
+        set: setNbiotSslWrite
+    },
+    [deviceParameters.NBIOT_SSL_CLIENT_CERT_SET]: {
+        get: getNbiotSslSet,
+        set: setNbiotSslSet
+    },
+    [deviceParameters.NBIOT_SSL_CLIENT_KEY_WRITE]: {
+        get: getNbiotSslWrite,
+        set: setNbiotSslWrite
+    },
+    [deviceParameters.NBIOT_SSL_CLIENT_KEY_SET]: {
+        get: getNbiotSslSet,
+        set: setNbiotSslSet
+    },
+    [deviceParameters.NBIOT_DEVICE_SOFTWARE_UPDATE]: {
+        get: (buffer) => ({
+            softwareImageUrl: buffer.getString()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.softwareImageUrl);
+        }
+    },
+    [deviceParameters.NBIOT_MODULE_FIRMWARE_UPDATE]: {
+        get: (buffer) => ({
+            moduleFirmwareImageUrl: buffer.getString()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.moduleFirmwareImageUrl);
+        }
+    },
+    [deviceParameters.REPORTING_DATA_CONFIG]: {
+        get: (buffer) => ({
+            dataType: buffer.getUint8(),
+            hour: buffer.getUint8(),
+            minutes: buffer.getUint8(),
+            countToSend: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.dataType);
+            buffer.setUint8(parameter.hour);
+            buffer.setUint8(parameter.minutes);
+            buffer.setUint8(parameter.countToSend);
+        }
+    },
+    [deviceParameters.EVENTS_CONFIG]: {
+        get: (buffer) => ({
+            eventId: buffer.getUint8(),
+            sendEvent: buffer.getUint8(),
+            saveEvent: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.eventId);
+            buffer.setUint8(parameter.sendEvent);
+            buffer.setUint8(parameter.saveEvent);
+        }
+    },
+    [deviceParameters.NBIOT_MODULE_INFO]: {
+        get: (buffer) => ({
+            moduleInfo: buffer.getString()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.moduleInfo);
+        }
+    },
+    [deviceParameters.NBIOT_BANDS]: {
+        get: (buffer) => {
+            const count = buffer.getUint8();
+            const bands = [];
+            for (let index = 0; index < count; index++) {
+                bands.push(buffer.getUint8());
+            }
+            return { bands };
+        },
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.bands.length);
+            for (const band of parameter.bands) {
+                buffer.setUint8(band);
+            }
+        }
+    },
+    [deviceParameters.NBIOT_APN]: {
+        get: (buffer) => ({
+            apn: buffer.getString()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.apn);
+        }
+    },
+    [deviceParameters.NBIOT_LED_INDICATION]: {
+        get: (buffer) => ({
+            enableLed: buffer.getUint8(),
+            enableNbiotNetworkLed: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.enableLed);
+            buffer.setUint8(parameter.enableNbiotNetworkLed);
+        }
+    },
+    [deviceParameters.NBIOT_SIM]: {
+        get: (buffer) => ({
+            enable: buffer.getUint8(),
+            pin: buffer.getUint16()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.enable);
+            buffer.setUint16(parameter.pin);
+        }
+    },
+    [deviceParameters.CHANNEL_TYPE]: {
+        get: (buffer) => (getChannelType(buffer)),
+        set: (buffer, parameter) => (setChannelType(buffer, parameter))
+    },
+    [deviceParameters.EXTRA_PAYLOAD_ENABLE]: {
+        get: (buffer) => ({
+            enable: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.enable);
+        }
+    },
+    [deviceParameters.TIME_SYNCHRONIZATION_PERIOD_VIA_MAC]: {
+        get: (buffer) => ({
+            period: buffer.getUint32()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint32(parameter.period);
+        }
+    },
+    [deviceParameters.KEEP_LORA_CONNECTION_ON_REMOVAL]: {
+        get: (buffer) => ({
+            value: buffer.getUint8() !== 0
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.value ? 1 : 0);
+        }
+    },
+    [deviceParameters.NBIOT_NTP_SERVER]: {
+        get: (buffer) => ({
+            server: buffer.getString(),
+            port: buffer.getUint16()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setString(parameter.server);
+            buffer.setUint16(parameter.port);
+        }
+    },
+    [deviceParameters.ACTIVATE_MODULE]: {
+        get: (buffer) => ({
+            enable: buffer.getUint8()
+        }),
+        set: (buffer, parameter) => {
+            buffer.setUint8(parameter.enable);
+        }
+    }
+};
+export const getEventStatusSize = (hardwareType) => (TWO_BYTES_HARDWARE_TYPES.indexOf(hardwareType) !== -1 ? 2 : 1);
+export const getParameterSize = (parameter) => {
+    let size;
+    let data;
+    switch (parameter.id) {
+        case deviceParameters.MQTT_SESSION_CONFIG:
+            data = parameter.data;
+            size = 1 + 1;
+            size += data.clientId.length + 1;
+            size += data.username.length + 1;
+            size += data.password.length + 1;
+            break;
+        case deviceParameters.MQTT_BROKER_ADDRESS:
+            data = parameter.data;
+            size = 1 + 2;
+            size += data.hostName.length + 1;
+            break;
+        case deviceParameters.MQTT_TOPIC_PREFIX:
+            data = parameter.data;
+            size = 1;
+            size += data.topicPrefix.length + 1;
+            break;
+        case deviceParameters.NBIOT_SSL_CACERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_WRITE:
+            data = parameter.data;
+            size = 1 + 2 + 2;
+            size += data.chunk.length;
+            break;
+        case deviceParameters.NBIOT_DEVICE_SOFTWARE_UPDATE:
+            data = parameter.data;
+            size = 1;
+            size += data.softwareImageUrl.length + 1;
+            break;
+        case deviceParameters.NBIOT_MODULE_FIRMWARE_UPDATE:
+            data = parameter.data;
+            size = 1;
+            size += data.moduleFirmwareImageUrl.length + 1;
+            break;
+        case deviceParameters.NBIOT_MODULE_INFO:
+            data = parameter.data;
+            size = 1 + 1 + data.moduleInfo.length;
+            break;
+        case deviceParameters.NBIOT_BANDS:
+            data = parameter.data;
+            size = 1 + 1;
+            size += data.bands.length;
+            break;
+        case deviceParameters.NBIOT_APN:
+            data = parameter.data;
+            size = 1 + 1 + data.apn.length;
+            break;
+        case deviceParameters.CHANNEL_TYPE:
+            data = parameter.data;
+            size = 1 + getChannelTypeSize(data);
+            break;
+        case deviceParameters.NBIOT_NTP_SERVER:
+            data = parameter.data;
+            size = 1 + 1 + data.server.length + 2;
+            break;
+        default:
+            size = parametersSizeMap[parameter.id];
+    }
+    if (size === undefined) {
+        throw new Error('unknown parameter id');
+    }
+    return size;
+};
+export const getRequestParameterSize = (parameter) => {
+    let size;
+    switch (parameter.id) {
+        case deviceParameters.ABSOLUTE_DATA_MULTI_CHANNEL:
+        case deviceParameters.ABSOLUTE_DATA_ENABLE_MULTI_CHANNEL:
+        case deviceParameters.REPORTING_DATA_CONFIG:
+        case deviceParameters.EVENTS_CONFIG:
+        case deviceParameters.CHANNEL_TYPE:
+            size = 2;
+            break;
+        default:
+            size = 1;
+            break;
+    }
+    return size;
+};
+export const getResponseParameterSize = (parameter) => {
+    let size;
+    switch (parameter.id) {
+        case deviceParameters.MQTT_SESSION_CONFIG:
+        case deviceParameters.NBIOT_SSL_CACERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_WRITE:
+        case deviceParameters.NBIOT_SSL_CACERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_SET:
+        case deviceParameters.NBIOT_DEVICE_SOFTWARE_UPDATE:
+        case deviceParameters.NBIOT_MODULE_FIRMWARE_UPDATE:
+            size = 1;
+            break;
+        case deviceParameters.MQTT_BROKER_ADDRESS:
+        case deviceParameters.MQTT_TOPIC_PREFIX:
+        case deviceParameters.NBIOT_MODULE_INFO:
+        case deviceParameters.NBIOT_BANDS:
+        case deviceParameters.NBIOT_APN:
+        case deviceParameters.CHANNEL_TYPE:
+        case deviceParameters.NBIOT_NTP_SERVER:
+            size = getParameterSize(parameter);
+            break;
+        default:
+            size = parametersSizeMap[parameter.id];
+    }
+    if (size === undefined) {
+        throw new Error('unknown parameter id');
+    }
+    return size;
+};
+export const getMagneticInfluenceBit = (byte) => (!!extractBits(byte, 1, MAGNETIC_INFLUENCE_BIT_INDEX));
+export const setMagneticInfluenceBit = (byte, value) => (fillBits(byte, 1, MAGNETIC_INFLUENCE_BIT_INDEX, +value));
+export const getLegacyHourCounterSize = (hourCounter) => (LEGACY_HOUR_COUNTER_SIZE + (hourCounter.diff.length * LEGACY_HOUR_DIFF_SIZE));
+export const getExtendedValue = function (buffer) {
+    let value = 0;
+    let isByteExtended = true;
+    let position = 0;
+    while (isByteExtended && buffer.offset <= buffer.data.length) {
+        const byte = buffer.getUint8();
+        isByteExtended = !!(byte & EXTEND_BIT_MASK);
+        value += ((byte & 0x7f) << (7 * position)) >>> 0;
+        ++position;
+    }
+    return value;
+};
+export const setExtendedValue = function (buffer, value) {
+    if (value === 0) {
+        buffer.setUint8(0);
+        return;
+    }
+    const data = [];
+    let encodedValue = value;
+    while (encodedValue) {
+        data.push(EXTEND_BIT_MASK | (encodedValue & 0x7f));
+        encodedValue >>>= 7;
+    }
+    const lastByte = data.pop();
+    if (lastByte) {
+        data.push(lastByte & 0x7f);
+    }
+    data.forEach(extendedValue => buffer.setUint8(extendedValue));
+};
+export const getExtendedValueSize = function (bits) {
+    const extBits = Math.ceil(bits / 7);
+    const totalBits = bits + extBits;
+    const extBytes = Math.ceil(totalBits / 8);
+    return extBytes;
+};
+export const getTime = function (buffer) {
+    return buffer.getUint32();
+};
+export const setTime = function (buffer, value) {
+    buffer.setUint32(value);
+};
+export const getBatteryVoltage = function (buffer) {
+    const lowVoltageByte = buffer.getUint8();
+    const lowAndHightVoltageByte = buffer.getUint8();
+    const highVoltageByte = buffer.getUint8();
+    let underLowLoad = lowVoltageByte << 4;
+    underLowLoad |= (lowAndHightVoltageByte & 0xf0) >> 4;
+    let underHighLoad = ((lowAndHightVoltageByte & 0x0f) << 8) | highVoltageByte;
+    if (underHighLoad === UNKNOWN_BATTERY_VOLTAGE) {
+        underHighLoad = undefined;
+    }
+    if (underLowLoad === UNKNOWN_BATTERY_VOLTAGE) {
+        underLowLoad = undefined;
+    }
+    return { underLowLoad, underHighLoad };
+};
+export const setBatteryVoltage = function (buffer, batteryVoltage) {
+    let { underLowLoad, underHighLoad } = batteryVoltage;
+    if (underLowLoad === undefined) {
+        underLowLoad = UNKNOWN_BATTERY_VOLTAGE;
+    }
+    if (underHighLoad === undefined) {
+        underHighLoad = UNKNOWN_BATTERY_VOLTAGE;
+    }
+    const lowVoltageByte = (underLowLoad >> 4) & 0xff;
+    const lowAndHighVoltageByte = ((underLowLoad & 0x0f) << 4) | ((underHighLoad >> 8) & 0x0f);
+    const highVoltageByte = underHighLoad & 0xff;
+    [lowVoltageByte, lowAndHighVoltageByte, highVoltageByte].forEach(byte => buffer.setUint8(byte));
+};
+export const getLegacyCounterValue = function (buffer) {
+    return buffer.getUint24();
+};
+export const setLegacyCounterValue = function (buffer, value) {
+    buffer.setUint24(value);
+};
+export const getLegacyCounter = function (buffer, byte = buffer.getUint8(), isArchiveValue = false) {
+    const value = getLegacyCounterValue(buffer);
+    return {
+        isMagneticInfluence: getMagneticInfluenceBit(byte),
+        value: isArchiveValue && value === archive.EMPTY_VALUE ? 0 : value
+    };
+};
+export const setLegacyCounter = function (buffer, counter, byte = 0, isArchiveValue = false) {
+    buffer.setUint8(setMagneticInfluenceBit(byte, counter.isMagneticInfluence));
+    setLegacyCounterValue(buffer, isArchiveValue && counter.value === 0 ? archive.EMPTY_VALUE : counter.value);
+};
+export const getChannels = function (buffer) {
+    const channelList = [];
+    let extended = true;
+    let channelIndex = 1;
+    while (extended) {
+        const byte = buffer.getUint8();
+        const bits = byte.toString(2).padStart(LAST_BIT_INDEX + 1, '0').split('').reverse();
+        bits.forEach((bit, index) => {
+            const value = Number(bit);
+            if (index === LAST_BIT_INDEX) {
+                extended = !!value;
+            }
+            else {
+                if (value) {
+                    channelList.push(channelIndex);
+                }
+                ++channelIndex;
+            }
+        });
+    }
+    return channelList;
+};
+export const setChannels = function (buffer, channelList) {
+    if (channelList.length === 0) {
+        buffer.setUint8(0);
+        return;
+    }
+    channelList.sort((a, b) => a.index - b.index);
+    const maxChannel = Math.max(...channelList.map(({ index }) => index));
+    const size = (maxChannel - (maxChannel % 8)) / 8;
+    const data = new Array(size + 1).fill(0);
+    let byte = 0;
+    data.forEach((_, byteIndex) => {
+        let channelIndex = (byteIndex * LAST_BIT_INDEX) + 1;
+        const maxChannelIndex = channelIndex + LAST_BIT_INDEX;
+        while (channelIndex < maxChannelIndex) {
+            const channel = channelList.find((item => item.index === channelIndex));
+            if (channel !== undefined) {
+                byte |= 1 << ((channel.index - 1) % LAST_BIT_INDEX);
+            }
+            ++channelIndex;
+        }
+        if (data[byteIndex + 1] !== undefined) {
+            byte |= 1 << LAST_BIT_INDEX;
+        }
+        data[byteIndex] = byte;
+        byte = 0;
+    });
+    data.forEach((value) => buffer.setUint8(value));
+};
+export const getChannelValue = function (buffer) {
+    return buffer.getUint8() + 1;
+};
+export const setChannelValue = function (buffer, value) {
+    if (value < 1) {
+        throw new Error('channel must be 1 or greater');
+    }
+    buffer.setUint8(value - 1);
+};
+export const getChannelsValuesWithHourDiff = function (buffer, isArchiveValue = false) {
+    const date = getDate(buffer);
+    const { hour, hours } = getHours(buffer);
+    const channels = getChannels(buffer);
+    const channelList = [];
+    date.setUTCHours(hour);
+    channels.forEach(channelIndex => {
+        const diff = [];
+        const value = getExtendedValue(buffer);
+        for (let diffHour = 1; diffHour < hours; ++diffHour) {
+            diff.push(getExtendedValue(buffer));
+        }
+        channelList.push({
+            value: isArchiveValue && value === archive.EMPTY_VALUE ? 0 : value,
+            diff,
+            index: channelIndex
+        });
+    });
+    return { startTime2000: getTime2000FromDate(date), hours, channelList };
+};
+export const setChannelsValuesWithHourDiff = function (buffer, hours, startTime2000, channelList, isArchiveValue = false) {
+    const date = getDateFromTime2000(startTime2000);
+    const hour = date.getUTCHours();
+    setDate(buffer, date);
+    setHours(buffer, hour, hours);
+    setChannels(buffer, channelList);
+    channelList.forEach(({ value, diff }) => {
+        setExtendedValue(buffer, isArchiveValue && value === 0 ? archive.EMPTY_VALUE : value);
+        diff.forEach(diffValue => setExtendedValue(buffer, diffValue));
+    });
+};
+export const getHours = function (buffer, byte = buffer.getUint8()) {
+    if (byte === 0) {
+        return { hours: 0, hour: 0 };
+    }
+    const hours = ((byte & 0xe0) >> 5) + 1;
+    const hour = byte & 0x1f;
+    return { hours, hour };
+};
+export const setHours = function (buffer, hour, hours) {
+    if (hour === 0 && hours === 0) {
+        buffer.setUint8(0);
+        return;
+    }
+    buffer.setUint8((((hours - 1) & 0x07) << 5) | (hour & 0x1f));
+};
+export const getDate = function (buffer) {
+    const yearMonthByte = buffer.getUint8();
+    const monthDateByte = buffer.getUint8();
+    const year = yearMonthByte >> YEAR_START_INDEX;
+    const month = ((yearMonthByte & 0x01) << MONTH_BIT_SIZE - YEAR_START_INDEX) | (monthDateByte >> DATE_BIT_SIZE);
+    const monthDay = monthDateByte & 0x1f;
+    return new Date(Date.UTC(year + INITIAL_YEAR, month - 1, monthDay, 0, 0, 0, 0));
+};
+export const setDate = function (buffer, dateOrTime) {
+    let date;
+    if (dateOrTime instanceof Date) {
+        date = dateOrTime;
+    }
+    else {
+        date = getDateFromTime2000(dateOrTime);
+    }
+    const year = date.getUTCFullYear() - INITIAL_YEAR;
+    const month = date.getUTCMonth() + 1;
+    const day = date.getUTCDate();
+    const yearMonthByte = (year << YEAR_START_INDEX) | (month >> MONTH_BIT_SIZE - YEAR_START_INDEX);
+    const monthDateByte = ((month & 0x07) << DATE_BIT_SIZE) | day;
+    [yearMonthByte, monthDateByte].forEach(byte => buffer.setUint8(byte));
+};
+export const getPulseCoefficient = function (buffer) {
+    const pulseCoefficient = buffer.getUint8();
+    if (isMSBSet(pulseCoefficient)) {
+        const value = byteToPulseCoefficientMap[pulseCoefficient];
+        if (value) {
+            return value;
+        }
+        throw new Error('pulseCoefficient MSB is set, but value unknown');
+    }
+    return pulseCoefficient;
+};
+export const setPulseCoefficient = function (buffer, value) {
+    if (value in pulseCoefficientToByteMap) {
+        const byte = pulseCoefficientToByteMap[value];
+        if (byte) {
+            buffer.setUint8(byte);
+        }
+        else {
+            throw new Error('pulseCoefficient MSB is set, but value unknown');
+        }
+    }
+    else {
+        buffer.setUint8(value);
+    }
+};
+export const getChannelsWithAbsoluteValues = function (buffer) {
+    const channels = getChannels(buffer);
+    const channelList = [];
+    channels.forEach(channelIndex => {
+        channelList.push({
+            pulseCoefficient: getPulseCoefficient(buffer),
+            value: getExtendedValue(buffer),
+            index: channelIndex
+        });
+    });
+    return channelList;
+};
+export const setChannelsWithAbsoluteValues = function (buffer, channelList) {
+    setChannels(buffer, channelList);
+    channelList.forEach(({ value, pulseCoefficient }) => {
+        setPulseCoefficient(buffer, pulseCoefficient);
+        setExtendedValue(buffer, value);
+    });
+};
+export const getChannelsAbsoluteValuesWithHourDiff = function (buffer, hours) {
+    const channels = getChannels(buffer);
+    const channelList = [];
+    channels.forEach(channelIndex => {
+        const pulseCoefficient = getPulseCoefficient(buffer);
+        const value = getExtendedValue(buffer);
+        const diff = [];
+        for (let hourIndex = 1; hourIndex < hours; ++hourIndex) {
+            diff.push(getExtendedValue(buffer));
+        }
+        channelList.push({
+            diff,
+            value,
+            pulseCoefficient,
+            index: channelIndex
+        });
+    });
+    return channelList;
+};
+export const setChannelsAbsoluteValuesWithHourDiff = function (buffer, channelList) {
+    setChannels(buffer, channelList);
+    channelList.forEach(({ value, diff, pulseCoefficient }) => {
+        setPulseCoefficient(buffer, pulseCoefficient);
+        setExtendedValue(buffer, value);
+        diff.forEach(diffValue => setExtendedValue(buffer, diffValue));
+    });
+};
+export const getEventStatus = function (buffer, hardwareType) {
+    let status;
+    if (GAS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        status = bitSet.toObject(gasBitMask, buffer.getUint8());
+    }
+    else if (TWO_CHANNELS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        status = bitSet.toObject(twoChannelBitMask, buffer.getUint8());
+    }
+    else if (ELIMP_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        status = bitSet.toObject(elimpBitMask, buffer.getUint8());
+    }
+    else if (FOUR_CHANNELS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        status = bitSet.toObject(fourChannelBitMask, buffer.getUint16(true));
+    }
+    else if (MTX_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        status = bitSet.toObject(mtxBitMask, buffer.getUint16(true));
+    }
+    else if (hardwareType === hardwareTypes.US_WATER) {
+        const event = bitSet.toObject(usWaterMeterEventBitMask, buffer.getUint8());
+        status = { event, error: buffer.getUint8() };
+    }
+    else {
+        throw new Error('wrong hardwareType');
+    }
+    return status;
+};
+export const setEventStatus = function (buffer, hardwareType, status) {
+    if (GAS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        buffer.setUint8(bitSet.fromObject(gasBitMask, status));
+    }
+    else if (TWO_CHANNELS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        buffer.setUint8(bitSet.fromObject(twoChannelBitMask, status));
+    }
+    else if (ELIMP_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        buffer.setUint8(bitSet.fromObject(elimpBitMask, status));
+    }
+    else if (FOUR_CHANNELS_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        buffer.setUint16(bitSet.fromObject(fourChannelBitMask, status) | (1 << 7), true);
+    }
+    else if (MTX_HARDWARE_TYPES.indexOf(hardwareType) !== -1) {
+        buffer.setUint16(bitSet.fromObject(mtxBitMask, status), true);
+    }
+    else if (hardwareType === hardwareTypes.US_WATER) {
+        const data = status;
+        buffer.setUint8(bitSet.fromObject(usWaterMeterEventBitMask, data.event));
+        buffer.setUint8(data.error);
+    }
+    else {
+        throw new Error('wrong hardwareType');
+    }
+};
+export const getParameter = function (buffer) {
+    const id = buffer.getUint8();
+    const name = deviceParameterNames[id];
+    if (!deviceParameterConvertersMap[id] || !deviceParameterConvertersMap[id].get) {
+        throw new Error(`parameter ${id} is not supported`);
+    }
+    const data = deviceParameterConvertersMap[id].get(buffer);
+    return { id, name, data };
+};
+export const setParameter = function (buffer, parameter) {
+    const { id, data } = parameter;
+    if (!deviceParameterConvertersMap[id] || !deviceParameterConvertersMap[id].set) {
+        throw new Error(`parameter ${id} is not supported`);
+    }
+    buffer.setUint8(id);
+    deviceParameterConvertersMap[id].set(buffer, data);
+};
+export const getRequestParameter = function (buffer) {
+    const id = buffer.getUint8();
+    const name = deviceParameterNames[id];
+    let data = null;
+    switch (id) {
+        case deviceParameters.ABSOLUTE_DATA_ENABLE_MULTI_CHANNEL:
+        case deviceParameters.ABSOLUTE_DATA_MULTI_CHANNEL:
+        case deviceParameters.CHANNEL_TYPE:
+            data = { channel: getChannelValue(buffer) };
+            break;
+        case deviceParameters.REPORTING_DATA_CONFIG:
+            data = { dataType: buffer.getUint8() };
+            break;
+        case deviceParameters.EVENTS_CONFIG:
+            data = { eventId: buffer.getUint8() };
+            break;
+        default:
+            break;
+    }
+    return { id, name, data };
+};
+export const setRequestParameter = function (buffer, parameter) {
+    const { id, data: parameterData } = parameter;
+    let data;
+    buffer.setUint8(id);
+    switch (id) {
+        case deviceParameters.ABSOLUTE_DATA_MULTI_CHANNEL:
+        case deviceParameters.ABSOLUTE_DATA_ENABLE_MULTI_CHANNEL:
+        case deviceParameters.CHANNEL_TYPE:
+            data = parameterData;
+            setChannelValue(buffer, data.channel);
+            break;
+        case deviceParameters.REPORTING_DATA_CONFIG:
+            data = parameterData;
+            buffer.setUint8(data.dataType);
+            break;
+        case deviceParameters.EVENTS_CONFIG:
+            data = parameterData;
+            buffer.setUint8(data.eventId);
+            break;
+        default:
+            break;
+    }
+};
+export const getResponseParameter = function (buffer) {
+    const id = buffer.getUint8();
+    const name = deviceParameterNames[id];
+    let data;
+    if (!deviceParameterConvertersMap[id] || !deviceParameterConvertersMap[id].get) {
+        throw new Error(`parameter ${id} is not supported`);
+    }
+    switch (id) {
+        case deviceParameters.MQTT_SESSION_CONFIG:
+        case deviceParameters.NBIOT_SSL_CACERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_WRITE:
+        case deviceParameters.NBIOT_SSL_CACERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_SET:
+        case deviceParameters.NBIOT_DEVICE_SOFTWARE_UPDATE:
+        case deviceParameters.NBIOT_MODULE_FIRMWARE_UPDATE:
+            data = null;
+            break;
+        default:
+            data = deviceParameterConvertersMap[id].get(buffer);
+    }
+    return { id, name, data };
+};
+export const setResponseParameter = function (buffer, parameter) {
+    const { id, data } = parameter;
+    if (!deviceParameterConvertersMap[id] || !deviceParameterConvertersMap[id].set) {
+        throw new Error(`parameter ${id} is not supported`);
+    }
+    buffer.setUint8(id);
+    switch (id) {
+        case deviceParameters.MQTT_SESSION_CONFIG:
+        case deviceParameters.NBIOT_SSL_CACERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_WRITE:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_WRITE:
+        case deviceParameters.NBIOT_SSL_CACERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_CERT_SET:
+        case deviceParameters.NBIOT_SSL_CLIENT_KEY_SET:
+        case deviceParameters.NBIOT_DEVICE_SOFTWARE_UPDATE:
+        case deviceParameters.NBIOT_MODULE_FIRMWARE_UPDATE:
+            break;
+        default:
+            deviceParameterConvertersMap[id].set(buffer, data);
+    }
+};
+export const getLegacyHourDiff = function (buffer) {
+    const stateWithValueByte = buffer.getUint8();
+    const valueLowerByte = buffer.getUint8();
+    return {
+        isMagneticInfluence: getMagneticInfluenceBit(stateWithValueByte),
+        value: ((stateWithValueByte & 0x1f) << 8) | valueLowerByte
+    };
+};
+export const setLegacyHourDiff = function (buffer, diff) {
+    const bytes = [diff.value >> 8, diff.value & 0xff];
+    bytes[0] = setMagneticInfluenceBit(bytes[0], diff.isMagneticInfluence);
+    bytes.forEach(byte => buffer.setUint8(byte));
+};
+export const getLegacyHourCounterWithDiff = function (buffer, isArchiveValue = false) {
+    const date = getDate(buffer);
+    const byte = buffer.getUint8();
+    const { hour } = getHours(buffer, byte);
+    const value = getLegacyCounterValue(buffer);
+    const counter = {
+        isMagneticInfluence: getMagneticInfluenceBit(byte),
+        value: isArchiveValue && value === archive.EMPTY_VALUE ? 0 : value
+    };
+    const diff = [];
+    while (buffer.offset < buffer.data.length) {
+        diff.push(getLegacyHourDiff(buffer));
+    }
+    date.setUTCHours(hour);
+    return { startTime2000: getTime2000FromDate(date), counter, diff };
+};
+export const setLegacyHourCounterWithDiff = function (buffer, hourCounter, isArchiveValue = false) {
+    const date = getDateFromTime2000(hourCounter.startTime2000);
+    const hour = date.getUTCHours();
+    const { value } = hourCounter.counter;
+    setDate(buffer, date);
+    setHours(buffer, hour, 1);
+    buffer.seek(buffer.offset - 1);
+    const byte = buffer.getUint8();
+    buffer.seek(buffer.offset - 1);
+    buffer.setUint8(setMagneticInfluenceBit(byte, hourCounter.counter.isMagneticInfluence));
+    setLegacyCounterValue(buffer, isArchiveValue && value === 0 ? archive.EMPTY_VALUE : value);
+    hourCounter.diff.forEach(diffItem => setLegacyHourDiff(buffer, diffItem));
+};
+export const getChannelsValuesWithHourDiffExtended = function (buffer, isArchiveValue = false) {
+    const date = getDate(buffer);
+    const hour = buffer.getUint8();
+    const hours = buffer.getUint8();
+    const channels = getChannels(buffer);
+    const channelList = [];
+    date.setUTCHours(hour);
+    channels.forEach(channelIndex => {
+        const diff = [];
+        const value = getExtendedValue(buffer);
+        for (let diffHour = 0; diffHour < hours; ++diffHour) {
+            diff.push(getExtendedValue(buffer));
+        }
+        channelList.push({
+            value: isArchiveValue && value === archive.EMPTY_VALUE ? 0 : value,
+            diff,
+            index: channelIndex
+        });
+    });
+    return { startTime2000: getTime2000FromDate(date), hour, hours, channelList };
+};
+export const setChannelsValuesWithHourDiffExtended = function (buffer, parameters, isArchiveValue = false) {
+    const date = getDateFromTime2000(parameters.startTime2000);
+    setDate(buffer, date);
+    buffer.setUint8(parameters.hour);
+    buffer.setUint8(parameters.hours);
+    setChannels(buffer, parameters.channelList);
+    parameters.channelList.forEach(({ value, diff }) => {
+        setExtendedValue(buffer, isArchiveValue && value === 0 ? archive.EMPTY_VALUE : value);
+        diff.forEach(diffValue => setExtendedValue(buffer, diffValue));
+    });
+};
+export const getDataSegment = function (buffer) {
+    const segmentationSessionId = buffer.getUint8();
+    const flag = buffer.getUint8();
+    return {
+        segmentationSessionId,
+        segmentIndex: extractBits(flag, 3, 1),
+        segmentsNumber: extractBits(flag, 3, 5),
+        isLast: Boolean(extractBits(flag, 1, 8)),
+        data: buffer.getBytesLeft()
+    };
+};
+export const setDataSegment = function (buffer, parameters) {
+    let flag = fillBits(0, 3, 1, parameters.segmentIndex);
+    flag = fillBits(flag, 3, 5, parameters.segmentsNumber);
+    flag = fillBits(flag, 1, 8, +parameters.isLast);
+    buffer.setUint8(parameters.segmentationSessionId);
+    buffer.setUint8(flag);
+    buffer.setBytes(parameters.data);
+};
+export const getBinarySensor = function (buffer) {
+    const activeStateTimeMs = buffer.getUint16();
+    return { activeStateTimeMs };
+};
+export const setBinarySensor = function (buffer, parameters) {
+    buffer.setUint16(parameters.activeStateTimeMs);
+};
+export const getTemperatureSensor = function (buffer) {
+    const measurementPeriod = buffer.getUint16();
+    const hysteresisSec = buffer.getUint8();
+    const highTemperatureThreshold = buffer.getInt8();
+    const lowTemperatureThreshold = buffer.getInt8();
+    return {
+        measurementPeriod,
+        hysteresisSec,
+        highTemperatureThreshold,
+        lowTemperatureThreshold
+    };
+};
+export const setTemperatureSensor = function (buffer, parameters) {
+    buffer.setUint16(parameters.measurementPeriod);
+    buffer.setUint8(parameters.hysteresisSec);
+    buffer.setInt8(parameters.highTemperatureThreshold);
+    buffer.setInt8(parameters.lowTemperatureThreshold);
+};
+export const getChannelType = function (buffer) {
+    const channel = getChannelValue(buffer);
+    const type = buffer.getUint8();
+    let parameters = {};
+    switch (type) {
+        case channelTypes.BINARY_SENSOR:
+            parameters = getBinarySensor(buffer);
+            break;
+        case channelTypes.TEMPERATURE_SENSOR:
+            parameters = getTemperatureSensor(buffer);
+            break;
+        default:
+            break;
+    }
+    return {
+        channel,
+        type,
+        parameters
+    };
+};
+export const setChannelType = function (buffer, { type, channel, parameters }) {
+    setChannelValue(buffer, channel);
+    buffer.setUint8(type);
+    switch (type) {
+        case channelTypes.BINARY_SENSOR:
+            setBinarySensor(buffer, parameters);
+            break;
+        case channelTypes.TEMPERATURE_SENSOR:
+            setTemperatureSensor(buffer, parameters);
+            break;
+        default:
+            break;
+    }
+};
+//# sourceMappingURL=CommandBinaryBuffer.js.map