mclimate-payload-helper 1.2.19 → 1.2.21

package/src/encoders/TRingThermostatCommands.test.ts

@@ -0,0 +1,23 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+
+describe('TringThermostatCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('thermostat')
+
+	test('SetThermostatTarget encodes target temperature', () => {
+		expect(commandBuilder.build('SetThermostatTarget', { target: 21.5 })).toStrictEqual(
+			new BaseCommand('SetThermostatTarget', 0x01, '00', '00', '00', 'D7', '00'),
+		)
+	})
+
+	test('SetThermostatConfig encodes config payload', () => {
+		expect(
+			commandBuilder.build('SetThermostatConfig', { time: 5, temp_span: 2, temp_sampling: 3, target: 22 }),
+		).toStrictEqual(new BaseCommand('SetThermostatConfig', 0x02, '05', '02', '03', 'DC', '00'))
+	})
+
+	test('SetKeepAlive encodes keepalive payload with padding', () => {
+		expect(commandBuilder.build('SetKeepAlive', { time: 10 })).toStrictEqual(
+			new BaseCommand('SetKeepAlive', 0x02, '0A', '00', '00', '00', '00'),
+		)
+	})
+})

package/src/encoders/TValveCommands.test.ts

@@ -0,0 +1,98 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('TValveCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('t_valve')
+
+	test('SetOpenCloseTime encodes opening and closing time', () => {
+		expect(commandBuilder.build('SetOpenCloseTime', { openingTime: 5, closingTime: 10 })).toStrictEqual(
+			new BaseCommand('SetOpenCloseTime', 0x01, '05', '0A'),
+		)
+	})
+
+	test('SetLED encodes led id, behavior and seconds', () => {
+		expect(commandBuilder.build('SetLED', { ledId: 1, behavior: 2, seconds: 5 })).toStrictEqual(
+			new BaseCommand('SetLED', 0x02, '01', '02', '05'),
+		)
+	})
+
+	test('SetBuzzer packs volume/frequency and timing', () => {
+		expect(
+			commandBuilder.build('SetBuzzer', { volume: 8, frequency: 4, activeTime: 10, onTime: 20, offTime: 30 }),
+		).toStrictEqual(new BaseCommand('SetBuzzer', 0x03, '84', '0A', '02', '03'))
+	})
+
+	test('SetEmergencyOpenings encodes max openings', () => {
+		expect(commandBuilder.build('SetEmergencyOpenings', { maxOpenings: 7 })).toStrictEqual(
+			new BaseCommand('SetEmergencyOpenings', 0x04, '07'),
+		)
+	})
+
+	test('SetManualControl encodes open/close bits', () => {
+		expect(commandBuilder.build('SetManualControl', { enableOpen: true, enableClose: false })).toStrictEqual(
+			new BaseCommand('SetManualControl', 0x05, '00000001'),
+		)
+	})
+
+	test('SetFloodAlarmTime encodes alarm time', () => {
+		expect(commandBuilder.build('SetFloodAlarmTime', { time: 12 })).toStrictEqual(
+			new BaseCommand('SetFloodAlarmTime', 0x06, '0C'),
+		)
+	})
+
+	test('SetKeepAlive encodes keepalive', () => {
+		expect(commandBuilder.build('SetKeepAlive', { time: 5 })).toStrictEqual(new BaseCommand('SetKeepAlive', 0x07, '05'))
+	})
+
+	test('SetWorkingVoltage scales voltage before encoding', () => {
+		expect(commandBuilder.build('SetWorkingVoltage', { voltage: 2000 })).toStrictEqual(
+			new BaseCommand('SetWorkingVoltage', 0x09, '32'),
+		)
+	})
+
+	test('SetValveState encodes valve state', () => {
+		expect(commandBuilder.build('SetValveState', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetValveState', 0x0c, '01'),
+		)
+	})
+
+	test('SetOpenCloseTimeExtended encodes extended times', () => {
+		expect(commandBuilder.build('SetOpenCloseTimeExtended', { openingTime: 300, closingTime: 400 })).toStrictEqual(
+			new BaseCommand('SetOpenCloseTimeExtended', 0x0d, '012C', '0190'),
+		)
+	})
+
+	test('SetSingleTimeValveState encodes state and time', () => {
+		expect(commandBuilder.build('SetSingleTimeValveState', { state: 1, time: 60 })).toStrictEqual(
+			new BaseCommand('SetSingleTimeValveState', 0x14, '01', '003C'),
+		)
+	})
+
+	test('SetDeviceFloodSensor encodes enable bit', () => {
+		expect(commandBuilder.build('SetDeviceFloodSensor', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetDeviceFloodSensor', 0x0a, '1'),
+		)
+	})
+
+	test('SetJoinRetryPeriod scales minutes before encoding', () => {
+		expect(commandBuilder.build('SetJoinRetryPeriod', { period: 10 })).toStrictEqual(
+			new BaseCommand('SetJoinRetryPeriod', 0x15, '78'),
+		)
+	})
+
+	test('SetUplinkType forwards uplink type', () => {
+		expect(commandBuilder.build('SetUplinkType', { type: '01' })).toStrictEqual(
+			new BaseCommand('SetUplinkType', 0x17, '01'),
+		)
+	})
+
+	test('SetWatchDogParams encodes confirmed/unconfirmed uplinks', () => {
+		expect(commandBuilder.build('SetWatchDogParams', { confirmedUplinks: 2, unconfirmedUplinks: 3 })).toStrictEqual(
+			new BaseCommand('SetWatchDogParams', 0x19, '02', '03'),
+		)
+	})
+
+	test('Invalid SetOpenCloseTime throws validation error', () => {
+		expect(() => commandBuilder.build('SetOpenCloseTime', { openingTime: -1, closingTime: 1 })).toThrow(CustomError)
+	})
+})

package/src/encoders/TemperatureCommonCommands.test.ts

@@ -0,0 +1,16 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('TemperatureCommonCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('vicki')
+
+	test('SetTemperatureRange encodes min and max', () => {
+		expect(commandBuilder.build('SetTemperatureRange', { min: 5, max: 25 })).toStrictEqual(
+			new BaseCommand('SetTemperatureRange', 0x08, '05', '19'),
+		)
+	})
+
+	test('Invalid SetTemperatureRange throws validation error', () => {
+		expect(() => commandBuilder.build('SetTemperatureRange', { min: 0, max: 25 })).toThrow(CustomError)
+	})
+})

package/src/encoders/VickiCommands.test.ts

@@ -0,0 +1,275 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('VickiCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('vicki')
+
+	test('SetOpenWindow encodes enabled, close time, motor position and delta', () => {
+		expect(
+			commandBuilder.build('SetOpenWindow', { enabled: true, delta: 5, closeTime: 30, motorPosition: 300 }),
+		).toStrictEqual(new BaseCommand('SetOpenWindow', 0x06, '01', '06', '2C', '15', '5'))
+	})
+
+	test('SetInternalAlgoParams encodes period and P values', () => {
+		expect(commandBuilder.build('SetInternalAlgoParams', { period: 2, pFirstLast: 3, pNext: 4 })).toStrictEqual(
+			new BaseCommand('SetInternalAlgoParams', 0x0c, '02', '03', '04'),
+		)
+	})
+
+	test('SetOperationalMode encodes mode', () => {
+		expect(commandBuilder.build('SetOperationalMode', { mode: '01' })).toStrictEqual(
+			new BaseCommand('SetOperationalMode', 0x0d, '01'),
+		)
+	})
+
+	test('SetTargetTemperature uses precise path for floats', () => {
+		expect(commandBuilder.build('SetTargetTemperature', { targetTemperature: 21.5 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperature', 0x51, '00D7'),
+		)
+	})
+
+	test('SetTargetTemperature uses integer path', () => {
+		expect(commandBuilder.build('SetTargetTemperature', { targetTemperature: 22 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperature', 0x0e, '16'),
+		)
+	})
+
+	test('SetExternalTemperature encodes temperature', () => {
+		expect(commandBuilder.build('SetExternalTemperature', { temp: 25 })).toStrictEqual(
+			new BaseCommand('SetExternalTemperature', 0x0f, '19'),
+		)
+	})
+
+	test('SetInternalAlgoTdiffParams encodes cold and warm deltas', () => {
+		expect(commandBuilder.build('SetInternalAlgoTdiffParams', { cold: 10, warm: 20 })).toStrictEqual(
+			new BaseCommand('SetInternalAlgoTdiffParams', 0x1a, '0A', '14'),
+		)
+	})
+
+	test('SetPrimaryOperationalMode encodes mode', () => {
+		expect(commandBuilder.build('SetPrimaryOperationalMode', { mode: '01' })).toStrictEqual(
+			new BaseCommand('SetPrimaryOperationalMode', 0x1e, '01'),
+		)
+	})
+
+	test('SetBatteryRangesBoundaries encodes three boundaries', () => {
+		expect(
+			commandBuilder.build('SetBatteryRangesBoundaries', { Boundary1: 100, Boundary2: 200, Boundary3: 300 }),
+		).toStrictEqual(new BaseCommand('SetBatteryRangesBoundaries', 0x20, '0064', '00C8', '012C'))
+	})
+
+	test('SetBatteryRangesOverVoltage encodes ranges with fixed first value', () => {
+		expect(commandBuilder.build('SetBatteryRangesOverVoltage', { Range1: 10, Range2: 20, Range3: 30 })).toStrictEqual(
+			new BaseCommand('SetBatteryRangesOverVoltage', 0x22, '0E', '0A', '14', '1E'),
+		)
+	})
+
+	test('SetOvac encodes ovac value', () => {
+		expect(commandBuilder.build('SetOvac', { ovac: 12 })).toStrictEqual(new BaseCommand('SetOvac', 0x26, '0C'))
+	})
+
+	test('SetProportionalAlgorithmParameters encodes coefficient and period', () => {
+		expect(commandBuilder.build('SetProportionalAlgorithmParameters', { coefficient: 5, period: 60 })).toStrictEqual(
+			new BaseCommand('SetProportionalAlgorithmParameters', 0x2a, '05', '3C'),
+		)
+	})
+
+	test('SetTemperatureControlAlgorithm encodes algorithm', () => {
+		expect(commandBuilder.build('SetTemperatureControlAlgorithm', { algorithm: '02' })).toStrictEqual(
+			new BaseCommand('SetTemperatureControlAlgorithm', 0x2c, '02'),
+		)
+	})
+
+	test('SetMotorPositionOnly encodes motor position', () => {
+		expect(commandBuilder.build('SetMotorPositionOnly', { position: 300 })).toStrictEqual(
+			new BaseCommand('SetMotorPositionOnly', 0x2d, '012C'),
+		)
+	})
+
+	test('SetTargetTemperatureAndMotorPosition encodes position and temperature', () => {
+		expect(
+			commandBuilder.build('SetTargetTemperatureAndMotorPosition', { motorPosition: 400, targetTemperature: 21 }),
+		).toStrictEqual(new BaseCommand('SetTargetTemperatureAndMotorPosition', 0x31, '0190', '15'))
+	})
+
+	test('SetChildLockBehavior encodes behavior', () => {
+		expect(commandBuilder.build('SetChildLockBehavior', { behavior: 1 })).toStrictEqual(
+			new BaseCommand('SetChildLockBehavior', 0x35, '01'),
+		)
+	})
+
+	test('SetProportionalGain encodes fixed-point gain', () => {
+		expect(commandBuilder.build('SetProportionalGain', { proportionalGain: 1 })).toStrictEqual(
+			new BaseCommand('SetProportionalGain', 0x37, '020000'),
+		)
+	})
+
+	test('SetExternalTemperatureFloat encodes temperature *10', () => {
+		expect(commandBuilder.build('SetExternalTemperatureFloat', { temp: 12.3 })).toStrictEqual(
+			new BaseCommand('SetExternalTemperatureFloat', 0x3c, '007B'),
+		)
+	})
+
+	test('SetIntegralGain encodes fixed-point gain', () => {
+		expect(commandBuilder.build('SetIntegralGain', { integralGain: 2 })).toStrictEqual(
+			new BaseCommand('SetIntegralGain', 0x3e, '040000'),
+		)
+	})
+
+	test('SetPiRunPeriod encodes period', () => {
+		expect(commandBuilder.build('SetPiRunPeriod', { period: 15 })).toStrictEqual(
+			new BaseCommand('SetPiRunPeriod', 0x41, '0F'),
+		)
+	})
+
+	test('SetTemperatureHysteresis encodes hysteresis *10', () => {
+		expect(commandBuilder.build('SetTemperatureHysteresis', { hysteresis: 0.5 })).toStrictEqual(
+			new BaseCommand('SetTemperatureHysteresis', 0x43, '05'),
+		)
+	})
+
+	test('SetOpenWindowPrecisely encodes enable, duration and delta', () => {
+		expect(commandBuilder.build('SetOpenWindowPrecisely', { enabled: true, duration: 25, delta: 1.5 })).toStrictEqual(
+			new BaseCommand('SetOpenWindowPrecisely', 0x45, '01', '05', '0F'),
+		)
+	})
+
+	test('SetForceAttach encodes enabled flag', () => {
+		expect(commandBuilder.build('SetForceAttach', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetForceAttach', 0x47, '01'),
+		)
+	})
+
+	test('SetAntiFreezeParams encodes temperatures *10', () => {
+		expect(
+			commandBuilder.build('SetAntiFreezeParams', {
+				activatedTemperature: 5,
+				deactivatedTemperature: 6,
+				targetTemperature: 7,
+			}),
+		).toStrictEqual(new BaseCommand('SetAntiFreezeParams', 0x49, '32', '3C', '46'))
+	})
+
+	test('SetMaxAllowedIntegralValue encodes value *10', () => {
+		expect(commandBuilder.build('SetMaxAllowedIntegralValue', { value: 10 })).toStrictEqual(
+			new BaseCommand('SetMaxAllowedIntegralValue', 0x4c, '0064'),
+		)
+	})
+
+	test('SetValveOpennessInPercentage encodes openness', () => {
+		expect(commandBuilder.build('SetValveOpennessInPercentage', { value: 55 })).toStrictEqual(
+			new BaseCommand('SetValveOpennessInPercentage', 0x4e, '37'),
+		)
+	})
+
+	test('SetValveOpennessRangeInPercentage encodes inverted range', () => {
+		expect(commandBuilder.build('SetValveOpennessRangeInPercentage', { min: 10, max: 90 })).toStrictEqual(
+			new BaseCommand('SetValveOpennessRangeInPercentage', 0x4f, '0A', '5A'),
+		)
+	})
+
+	test('SetTemperatureOffset encodes offset', () => {
+		expect(commandBuilder.build('SetTemperatureOffset', { value: 0 })).toStrictEqual(
+			new BaseCommand('SetTemperatureOffset', 0x53, '1C'),
+		)
+	})
+
+	test('SetHeatingEvent encodes schedule payload', () => {
+		expect(
+			commandBuilder.build('SetHeatingEvent', {
+				eventIndex: 0,
+				startHour: 8,
+				startMinute: 1,
+				targetTemperature: 25.8,
+				daysActive: {
+					monday: true,
+					tuesday: true,
+					wednesday: true,
+					thursday: true,
+					friday: true,
+					saturday: false,
+					sunday: false,
+				},
+			}),
+		).toStrictEqual(new BaseCommand('SetHeatingEvent', 0x59, '00', '08', '01', '0102', '1F'))
+	})
+
+	test('SetHeatingEventState encodes event index and state', () => {
+		expect(commandBuilder.build('SetHeatingEventState', { eventIndex: 16, active: true })).toStrictEqual(
+			new BaseCommand('SetHeatingEventState', 0x6b, '10', '01'),
+		)
+	})
+
+	test('SetTimeRequestByMACcommand encodes enable flag', () => {
+		expect(commandBuilder.build('SetTimeRequestByMACcommand', { enabled: true })).toStrictEqual(
+			new BaseCommand('SetTimeRequestByMACcommand', 0x6d, '01'),
+		)
+	})
+
+	test('SetHeatingSchedule encodes schedule dates', () => {
+		expect(
+			commandBuilder.build('SetHeatingSchedule', { startMonth: 0, startDay: 1, endMonth: 11, endDay: 31 }),
+		).toStrictEqual(new BaseCommand('SetHeatingSchedule', 0x5b, '00', '01', '0B', '1F'))
+	})
+
+	test('SetDeviceTime encodes timestamp bytes', () => {
+		expect(commandBuilder.build('SetDeviceTime', { timestamp: 1690000000 })).toStrictEqual(
+			new BaseCommand('SetDeviceTime', 0x5d, '64', 'BB', '5A', '80'),
+		)
+	})
+
+	test('SetDeviceTimeZone encodes offset with two’s complement for negatives', () => {
+		expect(commandBuilder.build('SetDeviceTimeZone', { offsetHours: -3 })).toStrictEqual(
+			new BaseCommand('SetDeviceTimeZone', 0x5f, 'FD'),
+		)
+	})
+
+	test('SetAutomaticSetpointRestore encodes time/10', () => {
+		expect(commandBuilder.build('SetAutomaticSetpointRestore', { time: 30 })).toStrictEqual(
+			new BaseCommand('SetAutomaticSetpointRestore', 0x61, '03'),
+		)
+	})
+
+	test('SetOfflineTargetTemperature encodes target *10', () => {
+		expect(commandBuilder.build('SetOfflineTargetTemperature', { targetTemperature: 21.5 })).toStrictEqual(
+			new BaseCommand('SetOfflineTargetTemperature', 0x65, '00D7'),
+		)
+	})
+
+	test('SetOfflineTargetTemperature encodes disable payload when target is 0', () => {
+		expect(commandBuilder.build('SetOfflineTargetTemperature', { targetTemperature: 0 })).toStrictEqual(
+			new BaseCommand('SetOfflineTargetTemperature', 0x65, '0000'),
+		)
+	})
+
+	test('SetInternalAlgoTemporaryState encodes enable/disable flag', () => {
+		expect(commandBuilder.build('SetInternalAlgoTemporaryState', { enabled: false })).toStrictEqual(
+			new BaseCommand('SetInternalAlgoTemporaryState', 0x67, '01'),
+		)
+	})
+
+	test('SetTemperatureLevels encodes six level temperatures', () => {
+		expect(
+			commandBuilder.build('SetTemperatureLevels', {
+				scaleLevel0: 5.0,
+				scaleLevel1: 10.0,
+				scaleLevel2: 15.0,
+				scaleLevel3: 20.0,
+				scaleLevel4: 22.5,
+				scaleLevel5: 25.0,
+			}),
+		).toStrictEqual(new BaseCommand('SetTemperatureLevels', 0x69, '0032', '0064', '0096', '00C8', '00E1', '00FA'))
+	})
+
+	test('SetLedIndicationDuration encodes doubled duration', () => {
+		expect(commandBuilder.build('SetLedIndicationDuration', { duration: 1.5 })).toStrictEqual(
+			new BaseCommand('SetLedIndicationDuration', 0x63, '03'),
+		)
+	})
+
+	test('Invalid SetOpenWindow params throw validation error', () => {
+		expect(() =>
+			commandBuilder.build('SetOpenWindow', { enabled: true, delta: -1, closeTime: 1, motorPosition: 1 }),
+		).toThrow(CustomError)
+	})
+})

package/src/encoders/WirelessThermostatCommands.test.ts

@@ -0,0 +1,70 @@
+import { BaseCommand, CommandBuilder } from '@/encoders'
+import { CustomError } from '@/utils'
+
+describe('WirelessThermostatCommands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('wireless_thermostat')
+
+	test('SetTargetTemperature uses precise path for floats', () => {
+		expect(commandBuilder.build('SetTargetTemperature', { targetTemperature: 21.5 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperature', 0x50, '00D7'),
+		)
+	})
+
+	test('SetTargetTemperature uses integer path', () => {
+		expect(commandBuilder.build('SetTargetTemperature', { targetTemperature: 22 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperature', 0x2e, '16'),
+		)
+	})
+
+	test('SetHeatingStatus encodes status flag', () => {
+		expect(commandBuilder.build('SetHeatingStatus', { status: 1 })).toStrictEqual(
+			new BaseCommand('SetHeatingStatus', 0x31, '01'),
+		)
+	})
+
+	test('SetDisplayRefreshPeriod encodes period', () => {
+		expect(commandBuilder.build('SetDisplayRefreshPeriod', { period: 4 })).toStrictEqual(
+			new BaseCommand('SetDisplayRefreshPeriod', 0x33, '04'),
+		)
+	})
+
+	test('SetTargetSendDelay encodes delay', () => {
+		expect(commandBuilder.build('SetTargetSendDelay', { time: 10 })).toStrictEqual(
+			new BaseCommand('SetTargetSendDelay', 0x35, '0A'),
+		)
+	})
+
+	test('SetAutomaticHeatingStatus encodes toggle', () => {
+		expect(commandBuilder.build('SetAutomaticHeatingStatus', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetAutomaticHeatingStatus', 0x37, '01'),
+		)
+	})
+
+	test('SetSensorMode encodes mode', () => {
+		expect(commandBuilder.build('SetSensorMode', { state: 1 })).toStrictEqual(
+			new BaseCommand('SetSensorMode', 0x39, '01'),
+		)
+	})
+
+	test('SetTemperatureHysteresis encodes hysteresis *10', () => {
+		expect(commandBuilder.build('SetTemperatureHysteresis', { hysteresis: 0.5 })).toStrictEqual(
+			new BaseCommand('SetTemperatureHysteresis', 0x4e, '05'),
+		)
+	})
+
+	test('SetTargetTemperaturePrecisely encodes temperature *10', () => {
+		expect(commandBuilder.build('SetTargetTemperaturePrecisely', { targetTemperature: 21.5 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperaturePrecisely', 0x50, '00D7'),
+		)
+	})
+
+	test('SetTargetTemperatureStep encodes step *10', () => {
+		expect(commandBuilder.build('SetTargetTemperatureStep', { value: 0.5 })).toStrictEqual(
+			new BaseCommand('SetTargetTemperatureStep', 0x52, '05'),
+		)
+	})
+
+	test('Invalid SetTargetTemperatureStep throws validation error', () => {
+		expect(() => commandBuilder.build('SetTargetTemperatureStep', { value: 0 })).toThrow(CustomError)
+	})
+})

package/src/test/payloadDecoders.test.ts

@@ -924,44 +924,44 @@ describe('HTPirLite payload decoder', () => {
 })
 describe('MultiSensor payload decoder', () => {
 	test('simple keepalive', () => {
-		expect(uplinkPayloadParser('810001061AA91F0E0008133D00E506', DeviceType.MultiSensor)).toStrictEqual({
-			deltaTMinC: 0,
-			deltaTMaxC: 0.1,
-			avgTempC: 0.6,
-			relativeHumidity: 26,
-			pressureMbar: 958.47,
-			staticAQI: 60.78,
-			eCO2ppm: 652.55,
-			tvocRaw: 8,
-			tvocPpbApprox: 8,
-			lightLux: 75,
-			noiseDb: 61,
-			pirTriggerCount: 0,
-			deviceVoltageMv: 3576,
-			deviceVoltage: 3.58,
-			powerSourceRaw: 6,
-			powerSource: 'Battery',
+		expect(uplinkPayloadParser('820F17CB2DA80D0600040A3A01DD03', DeviceType.MultiSensor)).toStrictEqual({
+			averageTemperature: 45.9,
+			minTemperature: 44.4,
+			maxTemperature: 47,
+			relativeHumidity: 45,
+			pressure: 956.94,
+			staticAQI: 25,
+			eCO2: 508.24,
+			bVOC: 4,
+			lightLevel: 39,
+			noiseLevel: 58,
+			pirTriggerCount: 1,
+			batteryVoltage: 3.51,
+			pir: false,
+			hallSensorEvent: false,
+			staticAQIAccuracy: 1,
+			powerSourceStatus: 1,
 		})
 	})
 	test('keepalive with response of preloaded code', () => {
-		expect(uplinkPayloadParser('1202810001061AA91F0E0008133D00E506', DeviceType.MultiSensor)).toStrictEqual({
+		expect(uplinkPayloadParser('1202820F17CB2DA80D0600040A3A01DD03', DeviceType.MultiSensor)).toStrictEqual({
 			keepAliveTime: 2,
-			deltaTMinC: 0,
-			deltaTMaxC: 0.1,
-			avgTempC: 0.6,
-			relativeHumidity: 26,
-			pressureMbar: 958.47,
-			staticAQI: 60.78,
-			eCO2ppm: 652.55,
-			tvocRaw: 8,
-			tvocPpbApprox: 8,
-			lightLux: 75,
-			noiseDb: 61,
-			pirTriggerCount: 0,
-			deviceVoltageMv: 3576,
-			deviceVoltage: 3.58,
-			powerSourceRaw: 6,
-			powerSource: 'Battery',
+			averageTemperature: 45.9,
+			minTemperature: 44.4,
+			maxTemperature: 47,
+			relativeHumidity: 45,
+			pressure: 956.94,
+			staticAQI: 25,
+			eCO2: 508.24,
+			bVOC: 4,
+			lightLevel: 39,
+			noiseLevel: 58,
+			pirTriggerCount: 1,
+			batteryVoltage: 3.51,
+			pir: false,
+			hallSensorEvent: false,
+			staticAQIAccuracy: 1,
+			powerSourceStatus: 1,
 		})
 	})
 })

package/src/test.txt

@@ -0,0 +1 @@
+test

package/dist/encoders/FanCoilThermostat.d.ts

@@ -1,61 +0,0 @@
-import { BaseCommand } from '../encoders';
-import { FanCoilThermostatCommandTypes } from '../encoders/types';
-export declare class FanCoilThermostatCommands {
-    static setTargetTemperatureStep(params: FanCoilThermostatCommandTypes.SetTargetTemperatureStepParams): BaseCommand;
-    static getTargetTemperatureStep(): BaseCommand;
-    static setKeysLock(params: FanCoilThermostatCommandTypes.SetKeysLockParams): BaseCommand;
-    static getKeysLock(): BaseCommand;
-    static setFanCoilTarget(params: FanCoilThermostatCommandTypes.SetFanCoilTargetParams): BaseCommand;
-    static setTargetTemperature(params: FanCoilThermostatCommandTypes.SetTargetTemperatureFanCoilParams): BaseCommand;
-    static setFctOperationalMode(params: FanCoilThermostatCommandTypes.SetFctOperationalModeParams): BaseCommand;
-    static setValveOpenCloseTime(params: FanCoilThermostatCommandTypes.SetValveOpenCloseTimeParams): BaseCommand;
-    static getValveOpenCloseTime(): BaseCommand;
-    static setExtAutomaticTemperatureControl(params: FanCoilThermostatCommandTypes.SetExtAutomaticTemperatureControlParams): BaseCommand;
-    static getExtAutomaticTemperatureControl(): BaseCommand;
-    static setFanSpeed(params: FanCoilThermostatCommandTypes.SetFanSpeedParams): BaseCommand;
-    static getFanSpeed(): BaseCommand;
-    static setFanSpeedLimit(params: FanCoilThermostatCommandTypes.SetFanSpeedLimitParams): BaseCommand;
-    static getFanSpeedLimit(): BaseCommand;
-    static setEcmVoltageRange(params: FanCoilThermostatCommandTypes.SetEcmVoltageRangeParams): BaseCommand;
-    static getEcmVoltageRange(): BaseCommand;
-    static setEcmStartUpTime(params: FanCoilThermostatCommandTypes.SetEcmStartUpTimeParams): BaseCommand;
-    static getEcmStartUpTime(): BaseCommand;
-    static setEcmRelay(params: FanCoilThermostatCommandTypes.SetEcmRelayParams): BaseCommand;
-    static getEcmRelay(): BaseCommand;
-    static setFrostProtection(params: FanCoilThermostatCommandTypes.SetFrostProtectionParams): BaseCommand;
-    static getFrostProtection(): BaseCommand;
-    static setFrostProtectionSettings(params: FanCoilThermostatCommandTypes.SetFrostProtectionSettingsParams): BaseCommand;
-    static getFrostProtectionSettings(): BaseCommand;
-    static setAllowedOperationalModes(params: FanCoilThermostatCommandTypes.SetAllowedOperationalModesParams): BaseCommand;
-    static getAllowedOperationalModes(): BaseCommand;
-    static setCoolingSetpointNotOccupied(params: FanCoilThermostatCommandTypes.SetCoolingSetpointNotOccupiedParams): BaseCommand;
-    static getCoolingSetpointNotOccupied(): BaseCommand;
-    static setHeatingSetpointNotOccupied(params: FanCoilThermostatCommandTypes.SetHeatingSetpointNotOccupiedParams): BaseCommand;
-    static getHeatingSetpointNotOccupied(): BaseCommand;
-    static setTempSensorCompensation(params: FanCoilThermostatCommandTypes.SetTempSensorCompensationParams): BaseCommand;
-    static getTempSensorCompensation(): BaseCommand;
-    static setFanSpeedNotOccupied(params: FanCoilThermostatCommandTypes.SetFanSpeedNotOccupiedParams): BaseCommand;
-    static getFanSpeedNotOccupied(): BaseCommand;
-    static setAutomaticChangeover(params: FanCoilThermostatCommandTypes.SetAutomaticChangeoverParams): BaseCommand;
-    static getAutomaticChangeover(): BaseCommand;
-    static setWiringDiagram(params: FanCoilThermostatCommandTypes.SetWiringDiagramParams): BaseCommand;
-    static getWiringDiagram(): BaseCommand;
-    static setOccFunction(params: FanCoilThermostatCommandTypes.SetOccFunctionParams): BaseCommand;
-    static getOccFunction(): BaseCommand;
-    static setAutomaticChangeoverThreshold(params: FanCoilThermostatCommandTypes.SetAutomaticChangeoverThresholdParams): BaseCommand;
-    static getAutomaticChangeoverThreshold(): BaseCommand;
-    static setDeviceStatus(params: FanCoilThermostatCommandTypes.SetDeviceStatusParams): BaseCommand;
-    static getDeviceStatus(): BaseCommand;
-    static setReturnOfPowerOperation(params: FanCoilThermostatCommandTypes.SetReturnOfPowerOperationParams): BaseCommand;
-    static getReturnOfPowerOperation(): BaseCommand;
-    static setDeltaTemperature1(params: FanCoilThermostatCommandTypes.SetDeltaTemperature1Params): BaseCommand;
-    static getDeltaTemperature1(): BaseCommand;
-    static setDeltaTemperature2and3(params: FanCoilThermostatCommandTypes.SetDeltaTemperature2and3Params): BaseCommand;
-    static getDeltaTemperature2and3(): BaseCommand;
-    static getFrostProtectionStatus(): BaseCommand;
-    static getOccupancySensorStatusSetPoint(): BaseCommand;
-    static getOccupancySensorStatus(): BaseCommand;
-    static getDewPointSensorStatus(): BaseCommand;
-    static getFilterAlarm(): BaseCommand;
-}
-//# sourceMappingURL=FanCoilThermostat.d.ts.map

package/dist/encoders/FanCoilThermostat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FanCoilThermostat.d.ts","sourceRoot":"","sources":["../../src/encoders/FanCoilThermostat.ts"],"names":[],"mappings":"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"}