mclimate-payload-helper 1.2.7 → 1.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mclimate-payload-helper",
-	"version": "1.2.7",
+	"version": "1.2.8",
 	"description": "Mclimate payload helper",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/decoders/commandsReadingHelper.ts

@@ -1162,6 +1162,23 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 					}
 				}
 				break
+			case '37':
+				{
+					try {
+						command_len = 1
+						const data = { pirSensorState: parseInt(commands[i + 1], 16) }
+						Object.assign(resultToPass, { ...resultToPass }, { ...data })
+					} catch (e) {
+						throw new CustomError({
+							message: `Failed to process command '37'`,
+							hexData,
+							command,
+							deviceType,
+							originalError: e as Error,
+						})
+					}
+				}
+				break
 			case '38':
 				{
 					try {
@@ -1179,6 +1196,23 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 					}
 				}
 				break
+			case '39':
+				{
+					try {
+						command_len = 2
+						const data = {  occupancyTimeout: (parseInt(commands[i + 1], 16) << 8) | parseInt(commands[i + 2], 16)}
+						Object.assign(resultToPass, { ...resultToPass }, { ...data })
+					} catch (e) {
+						throw new CustomError({
+							message: `Failed to process command '39'`,
+							hexData,
+							command,
+							deviceType,
+							originalError: e as Error,
+						})
+					}
+				}
+				break
 			case '3a':
 				{
 					try {

package/src/decoders/payloadParsers/co2PirLitePayloadParser.ts

@@ -8,6 +8,7 @@ interface CO2PirLiteData {
 	relativeHumidity?: number
 	batteryVoltage?: number
 	CO2?: number
+	pirTriggerCount?: number
 	pir?: boolean
 }
 
@@ -17,33 +18,37 @@ export const co2PirLitePayloadParser = (hexData: string) => {
 	try {
 		const handleKeepAliveData = (bytes: number[]) => {
 			const keepaliveData: CO2PirLiteData = {}
-			// Bytes 1-2: Internal temperature sensor data
-			// Formula: t[°C] = (T[15:0]-400)/10
-			const tempMsb = bytes[1] // bits 15:8
-			const tempLsb = bytes[2] // bits 7:0
-			const rawTemperature = (tempMsb << 8) | tempLsb
-			keepaliveData.sensorTemperature = Number(((rawTemperature - 400) / 10).toFixed(2))
+
+			// Byte 1 bit 2: PIR flag
+			keepaliveData.pir = ((bytes[1] & 0x04) >> 2) === 1
+
+			// Byte 1 (bits 1:0) and Byte 2: Internal temperature sensor data
+			// Formula: t[°C] = (T[9:0] - 400) / 10
+			// Extract bits 1:0 from byte 1 for the higher bits (bits 9:8)
+			const tempHighBits = (bytes[1] & 0x03) << 8
+			// Use all bits from byte 2 for the lower bits (bits 7:0)
+			const tempLowBits = bytes[2]
+			// Combine to get the full 10-bit temperature value
+			const tempValue = tempHighBits | tempLowBits
+			keepaliveData.sensorTemperature = Number(((tempValue - 400) / 10).toFixed(2))
 
 			// Byte 3: Relative Humidity data
-			// Formula: RH[%] = (XX*100)/256
+			// Formula: RH[%] = (XX * 100) / 256
 			keepaliveData.relativeHumidity = Number(((bytes[3] * 100) / 256).toFixed(2))
 
-			// Bytes 4-5: Device battery voltage data
-			// Battery voltage [mV]
-			const batteryMsb = bytes[4] // bits 15:8
-			const batteryLsb = bytes[5] // bits 7:0
-			keepaliveData.batteryVoltage = Number((((batteryMsb << 8) | batteryLsb) / 1000).toFixed(2))
+			// Byte 4: Device battery voltage data
+			// Battery voltage [mV] = ((XX * 2200) / 255) + 1600
+			keepaliveData.batteryVoltage = Number(((((bytes[4] * 2200) / 255) + 1600) / 1000).toFixed(2))
 
-			// CO2 calculation from data 6 and 7
-			const co2Low = bytes[6] // Lower byte of CO2
-			const co2High = (bytes[7] & 0xf8) >> 3 // Mask the upper 5 bits and shift them right
-			keepaliveData.CO2 = (co2High << 8) | co2Low // Shift co2High left by 8 bits and combine with co2Low
+			// Bytes 5-6: CO2 value in ppm
+			// Byte 5: CO2 value lower bits [7:0]
+			// Byte 6 bits 7:3: CO2 value higher bits [12:8]
+			const co2LowBits = bytes[5]
+			const co2HighBits = ((bytes[6] & 0xF8) >> 3) << 8 // Mask upper 5 bits, shift right by 3 to get bits in position, then shift left by 8
+			keepaliveData.CO2 = co2HighBits | co2LowBits
 
-			// Byte 8: PIR sensor status (only bit 0 is used)
-			// 0 - No motion detected
-			// 1 - Motion detected
-			const pirValue = bytes[8] & 0x01 // Extract only the last bit
-			keepaliveData.pir = pirValue === 1
+			// Byte 7: PIR trigger count
+			keepaliveData.pirTriggerCount = bytes[7]
 			Object.assign(deviceData, { ...deviceData }, { ...keepaliveData })
 		}
 
@@ -52,7 +57,7 @@ export const co2PirLitePayloadParser = (hexData: string) => {
 			if (!byteArray) return
 
 			// Route the message based on the command byte
-			if (byteArray[0] == 1) {
+			if (byteArray[0] == 81) {
 				// This is a keepalive message
 				handleKeepAliveData(byteArray)
 			} else {
@@ -69,7 +74,7 @@ export const co2PirLitePayloadParser = (hexData: string) => {
 				// Handle the remaining keepalive data if present
 				if (shouldKeepAlive) {
 					// Extract the last 9 bytes which contain keepalive data for CO2-PIR-Lite
-					const keepaliveData = hexData.slice(-18) // 9 bytes = 18 hex chars
+					const keepaliveData = hexData.slice(-16) // 8 bytes = 16 hex chars
 					const dataToPass = byteArrayParser(keepaliveData)
 					if (!dataToPass) return
 					handleKeepAliveData(dataToPass)

package/src/decoders/payloadParsers/htPirLitePayloadParser.ts

@@ -7,6 +7,7 @@ interface HTPirLiteData {
 	sensorTemperature?: number
 	relativeHumidity?: number
 	batteryVoltage?: number
+	pirTriggerCount?: number
 	pir?: boolean
 }
 
@@ -17,28 +18,29 @@ export const htPirLitePayloadParser = (hexData: string) => {
 		const handleKeepAliveData = (bytes: number[]) => {
 			const keepaliveData: HTPirLiteData = {}
 
-			// Bytes 1-2: Internal temperature sensor data
-			// Formula: t[°C] = (T[15:0]-400)/10
-			const tempMsb = bytes[1] // bits 15:8
-			const tempLsb = bytes[2] // bits 7:0
-			const rawTemperature = (tempMsb << 8) | tempLsb
-			keepaliveData.sensorTemperature = Number(((rawTemperature - 400) / 10).toFixed(2))
+			// Byte 1 bit 2: Occupied flag
+			keepaliveData.pir = ((bytes[1] & 0x04) >> 2) === 1
+
+			// Byte 1 (bits 1:0) and Byte 2: Internal temperature sensor data
+			// Formula: t[°C] = (T[9:0] - 400) / 10
+			// Extract bits 1:0 from byte 1 for the higher bits (bits 9:8)
+			const tempHighBits = (bytes[1] & 0x03) << 8
+			// Use all bits from byte 2 for the lower bits (bits 7:0)
+			const tempLowBits = bytes[2]
+			// Combine to get the full 10-bit temperature value
+			const tempValue = tempHighBits | tempLowBits
+			keepaliveData.sensorTemperature = Number(((tempValue - 400) / 10).toFixed(2))
 
 			// Byte 3: Relative Humidity data
-			// Formula: RH[%] = (XX*100)/256
+			// Formula: RH[%] = (XX * 100) / 256
 			keepaliveData.relativeHumidity = Number(((bytes[3] * 100) / 256).toFixed(2))
 
-			// Bytes 4-5: Device battery voltage data
-			// Battery voltage [mV]
-			const batteryMsb = bytes[4] // bits 15:8
-			const batteryLsb = bytes[5] // bits 7:0
-			keepaliveData.batteryVoltage = Number((((batteryMsb << 8) | batteryLsb) / 1000).toFixed(2))
+			// Byte 4: Device battery voltage data
+			// Battery voltage [mV] = ((XX * 2200) / 255) + 1600
+			keepaliveData.batteryVoltage = Number(((((bytes[4] * 2200) / 255) + 1600) / 1000).toFixed(2))
 
-			// Byte 6: PIR sensor status (only bit 0 is used, other bits are reserved)
-			// 0 - No motion detected
-			// 1 - Motion detected
-			const pirValue = bytes[6] & 0x01 // Extract only the last bit
-			keepaliveData.pir = pirValue === 1
+			// Byte 5: PIR trigger count
+			keepaliveData.pirTriggerCount = bytes[5]
 
 			Object.assign(deviceData, { ...deviceData }, { ...keepaliveData })
 		}
@@ -48,7 +50,7 @@ export const htPirLitePayloadParser = (hexData: string) => {
 			if (!byteArray) return
 
 			// Route the message based on the command byte
-			if (byteArray[0] == 1) {
+			if (byteArray[0] == 81) {
 				// This is a keepalive message
 				handleKeepAliveData(byteArray)
 			} else {
@@ -64,8 +66,8 @@ export const htPirLitePayloadParser = (hexData: string) => {
 
 				// Handle the remaining keepalive data if present
 				if (shouldKeepAlive) {
-					// Extract the last 7 bytes which contain keepalive data for HT-PIR-Lite
-					const keepaliveData = hexData.slice(-14) // 7 bytes = 14 hex chars
+					// Extract the last 6 bytes which contain keepalive data for HT-PIR-Lite
+					const keepaliveData = hexData.slice(-12) // 6 bytes = 12 hex chars
 					const dataToPass = byteArrayParser(keepaliveData)
 					if (!dataToPass) return
 					handleKeepAliveData(dataToPass)

package/src/encoders/Co2PirLiteCommands.ts

@@ -1,4 +1,4 @@
-import { GeneralCommands, PIRCommands, CO2SensorCommands } from '@/encoders'
+import { GeneralCommands, CO2SensorCommands } from '@/encoders'
 import { applyMixins, delMethods } from '@/utils'
 import { Co2PirLiteCommandTypes, DeviceCommandSchemas } from '@/encoders/types'
 import { BaseCommand } from '@/encoders'
@@ -7,30 +7,84 @@ import { CustomError } from '@/utils'
 import { decToHex } from '@/utils'
 
 export class Co2PirLiteCommands extends GeneralCommands {
-	static setUplinkSendingOnButtonPress(params: Co2PirLiteCommandTypes.SetUplinkSendingOnButtonPressParams) {
+		static setPIRSensorState(params: Co2PirLiteCommandTypes.SetPIRSensorStateParams) {
 		try {
-			DeviceCommandSchemas.Co2PirLiteCommandSchemas.setUplinkSendingOnButtonPress.parse(params)
-			const { value } = params
-			return new BaseCommand('SetUplinkSendingOnButtonPress', 0x2e, decToHex(value))
+			DeviceCommandSchemas.Co2PirLiteCommandSchemas.setPIRSensorState.parse(params)
+			const { state } = params
+			return new BaseCommand('SetPIRSensorState', 0x36, decToHex(state))
 		} catch (e) {
 			if (e instanceof ZodError) {
 				throw new CustomError({
-					message: 'Zod validation error during SetUplinkSendingOnButtonPress execution',
-					command: 'SetUplinkSendingOnButtonPress',
+					message: 'Zod validation error during SetPIRSensorState execution',
+					command: 'SetPIRSensorState',
 					originalError: e,
 				})
 			} else {
 				throw new CustomError({
-					message: 'Error during SetUplinkSendingOnButtonPress execution',
-					command: 'SetUplinkSendingOnButtonPress',
+					message: 'Error during SetPIRSensorState execution',
+					command: 'SetPIRSensorState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+	static getPIRSensorState() {
+		return new BaseCommand('GetPIRSensorState', 0x37)
+	}
+	static setPIRSensorSensitivity(params: Co2PirLiteCommandTypes.SetPIRSensorSensitivityParams) {
+		try {
+			DeviceCommandSchemas.Co2PirLiteCommandSchemas.setPIRSensorSensitivity.parse(params)
+			const { sensitivity } = params
+			return new BaseCommand('SetPIRSensorSensitivity', 0x3e, decToHex(sensitivity))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetPIRSensorSensitivity execution',
+					command: 'SetPIRSensorSensitivity',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetPIRSensorSensitivity execution',
+					command: 'SetPIRSensorSensitivity',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getPIRSensorSensitivity() {
+		return new BaseCommand('GetPIRSensorSensitivity', 0x3f)
+	}
+
+	static setOccupancyTimeout(params: Co2PirLiteCommandTypes.SetOccupancyTimeoutParams) {
+		try {
+			DeviceCommandSchemas.Co2PirLiteCommandSchemas.setOccupancyTimeout.parse(params)
+			const { timeout } = params
+			// Convert timeout to two bytes (high byte and low byte)
+			const highByte = (timeout >> 8) & 0xFF
+			const lowByte = timeout & 0xFF
+			
+			return new BaseCommand('SetOccupancyTimeout', 0x38, decToHex(highByte) + decToHex(lowByte))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetOccupancyTimeout execution',
+					command: 'SetOccupancyTimeout',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetOccupancyTimeout execution',
+					command: 'SetOccupancyTimeout',
 					originalError: e as Error,
 				})
 			}
 		}
 	}
 
-	static getUplinkSendingOnButtonPress() {
-		return new BaseCommand('GetUplinkSendingOnButtonPress', 0x2f)
+	static getOccupancyTimeout() {
+		return new BaseCommand('GetOccupancyTimeout', 0x39)
 	}
 
 	static restartDevice() {
@@ -38,11 +92,9 @@ export class Co2PirLiteCommands extends GeneralCommands {
 	}
 }
 
-applyMixins(Co2PirLiteCommands, [GeneralCommands, PIRCommands, CO2SensorCommands])
+applyMixins(Co2PirLiteCommands, [GeneralCommands, CO2SensorCommands])
 
 delMethods(Co2PirLiteCommands, [
-	'setPIRInitPeriod',
-	'getPIRInitPeriod',
 	'setNotifyPeriod',
 	'getNotifyPeriod',
 	'setBuzzerNotification',

package/src/encoders/HTPirLiteCommands.ts

@@ -1,36 +1,90 @@
 import { GeneralCommands, PIRCommands } from '@/encoders'
 import { applyMixins, delMethods } from '@/utils'
-import { HTPirLiteCommandTypes, DeviceCommandSchemas } from '@/encoders/types'
+import { HTPirLiteCommandTypes, DeviceCommandSchemas, PIRCommandTypes } from '@/encoders/types'
 import { BaseCommand } from '@/encoders'
 import { ZodError } from 'zod'
 import { CustomError } from '@/utils'
 import { decToHex } from '@/utils'
 
 export class HTPirLiteCommands extends GeneralCommands {
-	static setUplinkSendingOnButtonPress(params: HTPirLiteCommandTypes.SetUplinkSendingOnButtonPressParams) {
+		static setPIRSensorState(params: HTPirLiteCommandTypes.SetPIRSensorStateParams) {
 		try {
-			DeviceCommandSchemas.HTPirLiteCommandSchemas.setUplinkSendingOnButtonPress.parse(params)
-			const { value } = params
-			return new BaseCommand('SetUplinkSendingOnButtonPress', 0x2e, decToHex(value))
+			DeviceCommandSchemas.HTPirLiteCommandSchemas.setPIRSensorState.parse(params)
+			const { state } = params
+			return new BaseCommand('SetPIRSensorState', 0x36, decToHex(state))
 		} catch (e) {
 			if (e instanceof ZodError) {
 				throw new CustomError({
-					message: 'Zod validation error during SetUplinkSendingOnButtonPress execution',
-					command: 'SetUplinkSendingOnButtonPress',
+					message: 'Zod validation error during SetPIRSensorState execution',
+					command: 'SetPIRSensorState',
 					originalError: e,
 				})
 			} else {
 				throw new CustomError({
-					message: 'Error during SetUplinkSendingOnButtonPress execution',
-					command: 'SetUplinkSendingOnButtonPress',
+					message: 'Error during SetPIRSensorState execution',
+					command: 'SetPIRSensorState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+	static getPIRSensorState() {
+		return new BaseCommand('GetPIRSensorState', 0x37)
+	}
+	static setPIRSensorSensitivity(params: HTPirLiteCommandTypes.SetPIRSensorSensitivityParams) {
+		try {
+			DeviceCommandSchemas.HTPirLiteCommandSchemas.setPIRSensorSensitivity.parse(params)
+			const { sensitivity } = params
+			return new BaseCommand('SetPIRSensorSensitivity', 0x3e, decToHex(sensitivity))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetPIRSensorSensitivity execution',
+					command: 'SetPIRSensorSensitivity',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetPIRSensorSensitivity execution',
+					command: 'SetPIRSensorSensitivity',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getPIRSensorSensitivity() {
+		return new BaseCommand('GetPIRSensorSensitivity', 0x3f)
+	}
+
+	static setOccupancyTimeout(params: HTPirLiteCommandTypes.SetOccupancyTimeoutParams) {
+		try {
+			DeviceCommandSchemas.HTPirLiteCommandSchemas.setOccupancyTimeout.parse(params)
+			const { timeout } = params
+			// Convert timeout to two bytes (high byte and low byte)
+			const highByte = (timeout >> 8) & 0xFF
+			const lowByte = timeout & 0xFF
+			
+			return new BaseCommand('SetOccupancyTimeout', 0x38, decToHex(highByte) + decToHex(lowByte))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetOccupancyTimeout execution',
+					command: 'SetOccupancyTimeout',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetOccupancyTimeout execution',
+					command: 'SetOccupancyTimeout',
 					originalError: e as Error,
 				})
 			}
 		}
 	}
 
-	static getUplinkSendingOnButtonPress() {
-		return new BaseCommand('GetUplinkSendingOnButtonPress', 0x2f)
+	static getOccupancyTimeout() {
+		return new BaseCommand('GetOccupancyTimeout', 0x39)
 	}
 
 	static restartDevice() {
@@ -38,6 +92,6 @@ export class HTPirLiteCommands extends GeneralCommands {
 	}
 }
 
-applyMixins(HTPirLiteCommands, [GeneralCommands, PIRCommands])
+applyMixins(HTPirLiteCommands, [GeneralCommands])
 
-delMethods(HTPirLiteCommands, ['setPIRInitPeriod', 'getPIRInitPeriod'])
+delMethods(HTPirLiteCommands, [])

package/src/encoders/types/schemas.ts

@@ -193,6 +193,20 @@ export const ButtonEnums = {
 	} satisfies NumberEnum<1 | 2 | 3>,
 } as const
 
+export const HTPirLiteEnums = {
+	setPIRSensorState: {
+		0: 'Disabled',
+		1: 'Enabled',
+	} satisfies NumberEnum<0 | 1>,
+} as const
+
+export const Co2PirLiteEnums = {
+	setPIRSensorState: {
+		0: 'Disabled',
+		1: 'Enabled',
+	} satisfies NumberEnum<0 | 1>,
+} as const
+
 /* ---------------------------------------GENERAL COMMANDS--------------------------------------- */
 
 const GeneralCommandSchemas = {
@@ -457,7 +471,7 @@ const VickiCommandSchemas = {
 		eventIndex: z.number().int().min(0).max(19),
 		startHour: z.number().int().min(0).max(23),
 		startMinute: z.number().int().min(0).max(59),
-		targetTemperature: z.number().min(0.1).max(30.0).multipleOf(0.1),
+		targetTemperature: z.number().min(5.0).max(30.0).multipleOf(0.1),
 		daysActive: z.object({
 			monday: z.boolean(),
 			tuesday: z.boolean(),
@@ -1325,28 +1339,52 @@ export namespace ButtonCommandTypes {
 /* --------------------------------------- HT PIR LITE COMMANDS --------------------------------------- */
 const HTPirLiteCommandSchemas = {
 	...GeneralCommandSchemas,
-	...PIRCommandSchemas,
 	setUplinkSendingOnButtonPress: z.object({
 		value: z.number().min(0).max(1),
 	}),
 	getUplinkSendingOnButtonPress: z.object({}),
 	restartDevice: z.object({}),
+	setPIRSensorState: z.object({
+		state: z.number().min(0).max(1), // 0: disabled, 1: enabled
+	}),
+	getPIRSensorState: z.object({}),
+	setPIRSensorSensitivity: z.object({
+		sensitivity: z.number().min(12).max(255),
+	}),
+	getPIRSensorSensitivity: z.object({}),
+	setOccupancyTimeout: z.object({
+		timeout: z.number().min(15).max(65535), // in seconds, between 15 and 65535
+	}),
+	getOccupancyTimeout: z.object({}),
 }
 
 export namespace HTPirLiteCommandTypes {
 	export type SetUplinkSendingOnButtonPressParams = z.infer<typeof HTPirLiteCommandSchemas.setUplinkSendingOnButtonPress>
 	export type GetUplinkSendingOnButtonPressParams = z.infer<typeof HTPirLiteCommandSchemas.getUplinkSendingOnButtonPress>
 	export type RestartDeviceParams = z.infer<typeof HTPirLiteCommandSchemas.restartDevice>
+	export type SetPIRSensorStateParams = z.infer<typeof HTPirLiteCommandSchemas.setPIRSensorState>
+	export type GetPIRSensorStateParams = z.infer<typeof HTPirLiteCommandSchemas.getPIRSensorState>
+	export type SetPIRSensorSensitivityParams = z.infer<typeof HTPirLiteCommandSchemas.setPIRSensorSensitivity>
+	export type GetPIRSensorSensitivityParams = z.infer<typeof HTPirLiteCommandSchemas.getPIRSensorSensitivity>
+	export type SetOccupancyTimeoutParams = z.infer<typeof HTPirLiteCommandSchemas.setOccupancyTimeout>
+	export type GetOccupancyTimeoutParams = z.infer<typeof HTPirLiteCommandSchemas.getOccupancyTimeout>
 }
 
 /* --------------------------------------- CO2 PIR LITE COMMANDS --------------------------------------- */
 const Co2PirLiteCommandSchemas = {
 	...GeneralCommandSchemas,
-	...PIRCommandSchemas,
-	setUplinkSendingOnButtonPress: z.object({
-		value: z.number().min(0).max(1),
+	setPIRSensorState: z.object({
+		state: z.number().min(0).max(1), // 0: disabled, 1: enabled
 	}),
-	getUplinkSendingOnButtonPress: z.object({}),
+	getPIRSensorState: z.object({}),
+	setPIRSensorSensitivity: z.object({
+		sensitivity: z.number().min(12).max(255),
+	}),
+	getPIRSensorSensitivity: z.object({}),
+	setOccupancyTimeout: z.object({
+		timeout: z.number().min(15).max(65535), // in seconds, between 15 and 65535
+	}),
+	getOccupancyTimeout: z.object({}),
 	restartDevice: z.object({}),
 	setCo2BoundaryLevels: z.object({
 		good_medium: z.number().min(0).max(1500),
@@ -1370,12 +1408,12 @@ const Co2PirLiteCommandSchemas = {
 }
 
 export namespace Co2PirLiteCommandTypes {
-	export type SetUplinkSendingOnButtonPressParams = z.infer<
-		typeof Co2PirLiteCommandSchemas.setUplinkSendingOnButtonPress
-	>
-	export type GetUplinkSendingOnButtonPressParams = z.infer<
-		typeof Co2PirLiteCommandSchemas.getUplinkSendingOnButtonPress
-	>
+	export type SetPIRSensorStateParams = z.infer<typeof Co2PirLiteCommandSchemas.setPIRSensorState>
+	export type GetPIRSensorStateParams = z.infer<typeof Co2PirLiteCommandSchemas.getPIRSensorState>
+	export type SetPIRSensorSensitivityParams = z.infer<typeof Co2PirLiteCommandSchemas.setPIRSensorSensitivity>
+	export type GetPIRSensorSensitivityParams = z.infer<typeof Co2PirLiteCommandSchemas.getPIRSensorSensitivity>
+	export type SetOccupancyTimeoutParams = z.infer<typeof Co2PirLiteCommandSchemas.setOccupancyTimeout>
+	export type GetOccupancyTimeoutParams = z.infer<typeof Co2PirLiteCommandSchemas.getOccupancyTimeout>
 	export type RestartDeviceParams = z.infer<typeof Co2PirLiteCommandSchemas.restartDevice>
 }
 

package/src/test/payloadDecoders.test.ts

@@ -776,12 +776,6 @@ describe('ASPM payload decoder', () => {
 		})
 	})
 	test('all settings (relay)', () => {
-		console.log(
-			uplinkPayloadParser(
-				'041312120A19781B001D02181F5F46210113FA2310250E605F00011C034A241805D9E7195201',
-				DeviceType.Relay16,
-			),
-		)
 		expect(
 			uplinkPayloadParser(
 				'041312120A19781B001D02181F5F46210113FA2310250E605F00011C034A241805D9E7195201',
@@ -884,41 +878,47 @@ describe('Melissa payload decoder', () => {
 })
 describe('CO2PirLite payload decoder', () => {
 	test('simple keepalive', () => {
-		expect(uplinkPayloadParser('0102A67F0D70D31000', DeviceType.CO2PirLite)).toStrictEqual({
-			CO2: 723,
-			pir: false,
-			sensorTemperature: 27.8,
-			relativeHumidity: 49.61,
-			batteryVoltage: 3.44,
+		expect(uplinkPayloadParser('8106797EDA4718F1', DeviceType.CO2PirLite)).toStrictEqual({
+			pir: true,
+			sensorTemperature: 23.3,
+			relativeHumidity: 49.22,
+			batteryVoltage: 3.48,
+			CO2: 839,
+			pirTriggerCount: 241
 		})
 	})
 	test('keepalive with response of preloaded code', () => {
-		expect(uplinkPayloadParser('120A0102A67F0D70D31000', DeviceType.CO2PirLite)).toStrictEqual({
-			CO2: 723,
-			pir: false,
-			sensorTemperature: 27.8,
-			relativeHumidity: 49.61,
-			batteryVoltage: 3.44,
+		expect(uplinkPayloadParser('39003C120A8102797BD95A1800', DeviceType.CO2PirLite)).toStrictEqual({
+			occupancyTimeout: 60,
 			keepAliveTime: 10,
+			pir: false,
+			sensorTemperature: 23.3,
+			relativeHumidity: 48.05,
+			batteryVoltage: 3.47,
+			CO2: 858,
+			pirTriggerCount: 0
 		})
 	})
 })
 describe('HTPirLite payload decoder', () => {
 	test('simple keepalive', () => {
-		expect(uplinkPayloadParser('010288800A4500', DeviceType.HTPirLite)).toStrictEqual({
+		expect(uplinkPayloadParser('8102797DE201', DeviceType.HTPirLite)).toStrictEqual({
 			pir: false,
-			sensorTemperature: 24.8,
-			relativeHumidity: 50,
-			batteryVoltage: 2.63,
+			sensorTemperature: 23.3,
+			relativeHumidity: 48.83,
+			batteryVoltage: 3.55,
+			pirTriggerCount: 1,
 		})
 	})
 	test('keepalive with response of preloaded code', () => {
-		expect(uplinkPayloadParser('120A010288800A4500', DeviceType.HTPirLite)).toStrictEqual({
+		expect(uplinkPayloadParser('39003C120A8102797DE201', DeviceType.HTPirLite)).toStrictEqual({
 			pir: false,
-			sensorTemperature: 24.8,
-			relativeHumidity: 50,
-			batteryVoltage: 2.63,
+			sensorTemperature: 23.3,
+			relativeHumidity: 48.83,
+			batteryVoltage: 3.55,
+			pirTriggerCount: 1,
 			keepAliveTime: 10,
+			occupancyTimeout: 60,
 		})
 	})
 })