mclimate-payload-helper 1.2.3 → 1.2.4

package/src/decoders/payloadParsers/index.ts

@@ -19,4 +19,4 @@ export * from './relay16DryPayloadParser'
 export * from './melissaLorawanPayloadParser'
 export * from './co2PirLitePayloadParser'
 export * from './htPirLitePayloadParser'
-
+export * from './multisensorPayloadParser'

package/src/decoders/payloadParsers/multisensorPayloadParser.ts

@@ -0,0 +1,97 @@
+import { commandsReadingHelper } from '@/decoders'
+import { CustomError } from '@/utils'
+import { DeviceType } from '@/decoders/payloadParsers/types'
+import { byteArrayParser } from '@/helpers'
+
+// Multisensor payload parser (uplink). Structure mirrors other parsers in this folder.
+export const multisensorPayloadParser = (hexData: string) => {
+    let deviceData: any = {}
+
+    try {
+        if (!hexData) return
+
+        const bytes = byteArrayParser(hexData)
+        if (!bytes || !bytes.length) return
+
+        const toHex = (arr: number[]) => arr.map((b) => ('0' + b.toString(16)).slice(-2)).join('')
+
+        const handleKeepAliveData = (barr: number[]) => {
+            // Decode according to provided example indexing
+            const b = (i: number, d = 0) => (typeof barr[i] === 'number' ? barr[i] : d)
+
+            // Byte 1..14 mapping per example
+            const deltaTMinC = b(1) / 10
+            const deltaTMaxC = b(2) / 10
+            const avgTempC = Number((b(3) / 10).toFixed(1))
+            const relativeHumidity = b(4)
+            // Pressure: matches example (A8 -> 956.94): scale = 390
+            const pressureMbar = Number(((b(5) * 390) / 255 + 700).toFixed(2))
+            const staticAQI = Number(((b(6) * 500) / 255).toFixed(2))
+            // eCO2: matches example (06 -> 508.23): scale = 4600
+            const eCO2ppm = Number((((b(7) * 4600) / 255) + 400).toFixed(2))
+            const tvocRaw = ((b(8) & 0xff) << 8) | (b(9) & 0xff)
+            const tvocPpbApprox = tvocRaw
+            const lightLux = Math.round((b(10) * 1000) / 255)
+            const noiseDb = b(11)
+            const pirTriggerCount = b(12)
+            const deviceVoltageMv = Math.round((b(13) * 2200) / 255 + 1600)
+            const deviceVoltage = Number((deviceVoltageMv / 1000).toFixed(2))
+            const powerSourceRaw = b(14)
+            const powerSource = powerSourceRaw === 1 ? 'USB' : 'Battery'
+
+            const keepaliveData = {
+                type: 'keep_alive',
+                deltaTMinC,
+                deltaTMaxC,
+                avgTempC,
+                relativeHumidity,
+                pressureMbar,
+                staticAQI,
+                eCO2ppm,
+                tvocRaw,
+                tvocPpbApprox,
+                lightLux,
+                noiseDb,
+                pirTriggerCount,
+                deviceVoltageMv,
+                deviceVoltage,
+                powerSourceRaw,
+                powerSource,
+                raw: toHex(barr),
+            }
+            Object.assign(deviceData, { ...deviceData }, { ...keepaliveData })
+        }
+
+        if (hexData.slice(0, 2).toLowerCase() === '82') {
+            // keep-alive packet
+            handleKeepAliveData(bytes)
+        } else {
+            // parse command answers via helper
+            const data = commandsReadingHelper(hexData, 30, DeviceType.MultiSensor)
+            if (!data) return
+
+            const shouldKeepAlive = data.hasOwnProperty('decodeKeepalive') ? true : false
+            if ('decodeKeepalive' in data) {
+                delete (data as any).decodeKeepalive
+            }
+
+            Object.assign(deviceData, { ...deviceData }, { ...data })
+
+            // If device response includes keepalive, decode last 15 bytes (30 hex chars)
+            if (shouldKeepAlive) {
+                const keepaliveHex = hexData.slice(-30)
+                const keepaliveBytes = byteArrayParser(keepaliveHex)
+                if (keepaliveBytes) handleKeepAliveData(keepaliveBytes)
+            }
+        }
+
+        return deviceData
+    } catch (e) {
+        throw new CustomError({
+            message: `Unhandled data`,
+            hexData: hexData,
+            deviceType: 'multisensor',
+            originalError: e as Error,
+        })
+    }
+}

package/src/decoders/payloadParsers/types/allDevices.ts

@@ -19,4 +19,5 @@ export enum DeviceType {
 	MelissaLorawan = 'melissa_lorawan',
 	CO2PirLite = 'co2_pir_lite',
 	HTPirLite = 'ht_pir_lite',
+	MultiSensor = 'multisensor',
 }

package/src/encoders/CommandBuilder.ts

@@ -20,6 +20,7 @@ import {
 	HTPirLiteCommands,
 	Co2PirLiteCommands,
 	MelissaCommands,
+	MultiSensorCommands,
 } from '@/encoders'
 
 import { CustomError, toCamelCase } from '@/utils'
@@ -50,6 +51,7 @@ export class CommandBuilder {
 			ht_pir_lite: HTPirLiteCommands,
 			co2_pir_lite: Co2PirLiteCommands,
 			melissa_lorawan: MelissaCommands,
+			multisensor: MultiSensorCommands,
 		}
 	}
 

package/src/encoders/MultiSensorCommands.ts

@@ -0,0 +1,253 @@
+import { BaseCommand, GeneralCommands } from '@/encoders'
+import { ZodError } from 'zod'
+import { CustomError, decToHex, dec2hex } from '@/utils'
+import { MultiSensorCommandTypes, DeviceCommandSchemas } from '@/encoders/types'
+
+export class MultiSensorCommands extends GeneralCommands {
+	static setLightState(params: MultiSensorCommandTypes.SetLightStateParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setLightState.parse(params)
+			const { enabled } = params
+			const enabledValue = enabled ? 1 : 0
+			return new BaseCommand('SetLightState', 0x1e, decToHex(enabledValue))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetLightState execution',
+					command: 'SetLightState',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetLightState execution',
+					command: 'SetLightState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getLightState() {
+		return new BaseCommand('GetLightState', 0x1f)
+	}
+
+	static setHallState(params: MultiSensorCommandTypes.SetHallStateParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setHallState.parse(params)
+			const { enabled } = params
+			const enabledValue = enabled ? 1 : 0
+			return new BaseCommand('SetHallState', 0x20, decToHex(enabledValue))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetHallState execution',
+					command: 'SetHallState',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetHallState execution',
+					command: 'SetHallState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getHallState() {
+		return new BaseCommand('GetHallState', 0x21)
+	}
+
+	static setHallBlindPeriod(params: MultiSensorCommandTypes.SetHallBlindPeriodParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setHallBlindPeriod.parse(params)
+			const { period } = params
+			return new BaseCommand('SetHallBlindPeriod', 0x22, dec2hex(period))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetHallBlindPeriod execution',
+					command: 'SetHallBlindPeriod',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetHallBlindPeriod execution',
+					command: 'SetHallBlindPeriod',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getHallBlindPeriod() {
+		return new BaseCommand('GetHallBlindPeriod', 0x23)
+	}
+
+	static setMicrophoneState(params: MultiSensorCommandTypes.SetMicrophoneStateParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setMicrophoneState.parse(params)
+			const { enabled } = params
+			const enabledValue = enabled ? 1 : 0
+			return new BaseCommand('SetMicrophoneState', 0x24, decToHex(enabledValue))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetMicrophoneState execution',
+					command: 'SetMicrophoneState',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetMicrophoneState execution',
+					command: 'SetMicrophoneState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getMicrophoneState() {
+		return new BaseCommand('GetMicrophoneState', 0x25)
+	}
+
+	static setMicrophoneSamplingPeriod(params: MultiSensorCommandTypes.SetMicrophoneSamplingPeriodParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setMicrophoneSamplingPeriod.parse(params)
+			const { period } = params
+			return new BaseCommand('SetMicrophoneSamplingPeriod', 0x26, dec2hex(period))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetMicrophoneSamplingPeriod execution',
+					command: 'SetMicrophoneSamplingPeriod',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetMicrophoneSamplingPeriod execution',
+					command: 'SetMicrophoneSamplingPeriod',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getMicrophoneSamplingPeriod() {
+		return new BaseCommand('GetMicrophoneSamplingPeriod', 0x27)
+	}
+
+	static setGasState(params: MultiSensorCommandTypes.SetGasStateParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setGasState.parse(params)
+			const { enabled } = params
+			const enabledValue = enabled ? 1 : 0
+			return new BaseCommand('SetGasState', 0x28, decToHex(enabledValue))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetGasState execution',
+					command: 'SetGasState',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetGasState execution',
+					command: 'SetGasState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getGasState() {
+		return new BaseCommand('GetGasState', 0x29)
+	}
+
+	static setGasMeasurementPeriod(params: MultiSensorCommandTypes.SetGasMeasurementPeriodParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setGasMeasurementPeriod.parse(params)
+			const { minutes } = params
+			return new BaseCommand('SetGasMeasurementPeriod', 0x2a, decToHex(minutes))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetGasMeasurementPeriod execution',
+					command: 'SetGasMeasurementPeriod',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetGasMeasurementPeriod execution',
+					command: 'SetGasMeasurementPeriod',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getGasMeasurementPeriod() {
+		return new BaseCommand('GetGasMeasurementPeriod', 0x2b)
+	}
+
+	static setPirState(params: MultiSensorCommandTypes.SetPirStateParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setPirState.parse(params)
+			const { enabled } = params
+			const enabledValue = enabled ? 1 : 0
+			return new BaseCommand('SetPirState', 0x2c, decToHex(enabledValue))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetPirState execution',
+					command: 'SetPirState',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetPirState execution',
+					command: 'SetPirState',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getPirState() {
+		return new BaseCommand('GetPirState', 0x2d)
+	}
+
+	static setPirActiveReportingPeriod(params: MultiSensorCommandTypes.SetPirActiveReportingPeriodParams) {
+		try {
+			DeviceCommandSchemas.MultiSensorCommandSchemas.setPirActiveReportingPeriod.parse(params)
+			const { time } = params
+			return new BaseCommand('SetPirActiveReportingPeriod', 0x2e, dec2hex(time))
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new CustomError({
+					message: 'Zod validation error during SetPirActiveReportingPeriod execution',
+					command: 'SetPirActiveReportingPeriod',
+					originalError: e,
+				})
+			} else {
+				throw new CustomError({
+					message: 'Error during SetPirActiveReportingPeriod execution',
+					command: 'SetPirActiveReportingPeriod',
+					originalError: e as Error,
+				})
+			}
+		}
+	}
+
+	static getPirActiveReportingPeriod() {
+		return new BaseCommand('GetPirActiveReportingPeriod', 0x2f)
+	}
+
+	static getRegion() {
+		return new BaseCommand('GetRegion', 0xa4)
+	}
+
+	static restart() {
+		return new BaseCommand('Restart', 0xa5)
+	}
+}

package/src/encoders/index.ts

@@ -25,4 +25,5 @@ export * from './Relay16DryCommands'
 export * from './HTPirLiteCommands'
 export * from './Co2PirLiteCommands'
 export * from './MelissaCommands'
+export * from './MultiSensorCommands'
 

package/src/encoders/types/schemas.ts

@@ -493,7 +493,7 @@ const VickiCommandSchemas = {
 		targetTemperature: z.union([
 			z.literal(0), // To disable the feature
 			z.number().min(5).max(30).multipleOf(0.1), // Temperature range 5.0-30.0°C with 0.1°C increments
-		])
+		]),
 	}),
 	setInternalAlgoTemporaryState: z.object({
 		enabled: z.boolean(), // true = enable algorithm (00), false = disable algorithm temporarily (01)
@@ -504,11 +504,11 @@ const VickiCommandSchemas = {
 		scaleLevel2: z.number().min(5).max(30).multipleOf(0.1),
 		scaleLevel3: z.number().min(5).max(30).multipleOf(0.1),
 		scaleLevel4: z.number().min(5).max(30).multipleOf(0.1),
-		scaleLevel5: z.number().min(5).max(30).multipleOf(0.1)
+		scaleLevel5: z.number().min(5).max(30).multipleOf(0.1),
 	}),
 	setLedIndicationDuration: z.object({
-		duration: z.number().min(0.5).max(20).multipleOf(0.5) // Duration in range [0.5:20] with 0.5s resolution
-	})
+		duration: z.number().min(0.5).max(20).multipleOf(0.5), // Duration in range [0.5:20] with 0.5s resolution
+	}),
 }
 
 export namespace VickiCommandTypes {
@@ -1378,8 +1378,6 @@ export namespace Co2PirLiteCommandTypes {
 	export type RestartDeviceParams = z.infer<typeof Co2PirLiteCommandSchemas.restartDevice>
 }
 
-
-
 /* --------------------------------------- Melissa --------------------------------------- */
 const MelissaCommandSchemas = {
 	...GeneralCommandSchemas,
@@ -1389,10 +1387,64 @@ const MelissaCommandSchemas = {
 }
 
 export namespace MelissaCommandTypes {
-	export type SetIrCodeRecordingParams = z.infer<
-		typeof MelissaCommandSchemas.setIrCodeRecording
-	>
+	export type SetIrCodeRecordingParams = z.infer<typeof MelissaCommandSchemas.setIrCodeRecording>
 }
+
+/* --------------------------------------- MULTISENSOR COMMANDS --------------------------------------- */
+const MultiSensorCommandSchemas = {
+	...GeneralCommandSchemas,
+	setLightState: z.object({
+		enabled: z.boolean(),
+	}),
+	getLightState: z.object({}),
+	setHallState: z.object({
+		enabled: z.boolean(),
+	}),
+	getHallState: z.object({}),
+	setHallBlindPeriod: z.object({
+		period: z.number().min(0).max(65535),
+	}),
+	getHallBlindPeriod: z.object({}),
+	setMicrophoneState: z.object({
+		enabled: z.boolean(),
+	}),
+	getMicrophoneState: z.object({}),
+	setMicrophoneSamplingPeriod: z.object({
+		period: z.number().min(0).max(65535),
+	}),
+	getMicrophoneSamplingPeriod: z.object({}),
+	setGasState: z.object({
+		enabled: z.boolean(),
+	}),
+	getGasState: z.object({}),
+	setGasMeasurementPeriod: z.object({
+		minutes: z.number().min(0).max(255),
+	}),
+	getGasMeasurementPeriod: z.object({}),
+	setPirState: z.object({
+		enabled: z.boolean(),
+	}),
+	getPirState: z.object({}),
+	setPirActiveReportingPeriod: z.object({
+		time: z.number().min(0).max(65535),
+	}),
+	getPirActiveReportingPeriod: z.object({}),
+	getRegion: z.object({}),
+	restart: z.object({}),
+}
+
+export namespace MultiSensorCommandTypes {
+	export type SetLightStateParams = z.infer<typeof MultiSensorCommandSchemas.setLightState>
+	export type SetHallStateParams = z.infer<typeof MultiSensorCommandSchemas.setHallState>
+	export type SetHallBlindPeriodParams = z.infer<typeof MultiSensorCommandSchemas.setHallBlindPeriod>
+	export type SetMicrophoneStateParams = z.infer<typeof MultiSensorCommandSchemas.setMicrophoneState>
+	export type SetMicrophoneSamplingPeriodParams = z.infer<typeof MultiSensorCommandSchemas.setMicrophoneSamplingPeriod>
+	export type SetGasStateParams = z.infer<typeof MultiSensorCommandSchemas.setGasState>
+	export type SetGasMeasurementPeriodParams = z.infer<typeof MultiSensorCommandSchemas.setGasMeasurementPeriod>
+	export type SetPirStateParams = z.infer<typeof MultiSensorCommandSchemas.setPirState>
+	export type SetPirActiveReportingPeriodParams = z.infer<typeof MultiSensorCommandSchemas.setPirActiveReportingPeriod>
+}
+
 /* --------------------------------------- EXPORT ALL SCHEMA GROUPS --------------------------------------- */
 export const DeviceCommandSchemas = {
 	GeneralCommandSchemas,
@@ -1419,4 +1471,5 @@ export const DeviceCommandSchemas = {
 	HTPirLiteCommandSchemas,
 	Co2PirLiteCommandSchemas,
 	MelissaCommandSchemas,
+	MultiSensorCommandSchemas,
 }