mclimate-payload-helper 1.2.2 → 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/melissaLorawanPayloadParser.ts

@@ -1,28 +1,31 @@
 import { commandsReadingHelper } from '@/decoders/commandsReadingHelper'
-import { DeviceType, RelayKeepAliveData } from '@/decoders/payloadParsers/types'
+import { DeviceType } from '@/decoders/payloadParsers/types'
 import { byteArrayParser } from '@/helpers'
 import { CustomError } from '@/utils'
 
+interface MelissaKeepAliveData {
+	sensorTemperature?: number
+	relativeHumidity?: number
+	isIrCodeRecordingRequested?: boolean
+}
 export const melissaLorawanPayloadParser = (hexData: string) => {
 	let deviceData = {}
 
 	try {
 		const handleKeepAliveData = (bytes: number[]) => {
-			let keepaliveData: RelayKeepAliveData = {}
-
-			// Internal temperature sensor
-			const isNegative = (bytes[1] & 0x80) !== 0; // Check the 7th bit for the sign
-			let temperature = bytes[1] & 0x7F; // Mask out the 7th bit to get the temperature value
-			keepaliveData.internalTemperature = isNegative ? -temperature : temperature;
-
-			// Energy data
-			keepaliveData.energy = ((bytes[2] << 24) | (bytes[3] << 16) | (bytes[4] << 8) | bytes[5]) / 1000
+			let keepaliveData: MelissaKeepAliveData = {}
+			// Internal temperature sensor data from bytes 1-2 (16 bits)
+			// According to the screenshot: t[°C] = (T[15:0] - 400) / 10
+			const rawTemperature = (bytes[1] << 8) | bytes[2];
+			keepaliveData.sensorTemperature = Number(((rawTemperature - 400) / 10).toFixed(2));
 
-			// Power data
-			keepaliveData.power = (bytes[6] << 8) | bytes[7]
+			// Relative Humidity from byte 3
+			// According to the screenshot: RH[%] = (XX * 100) / 256
+			keepaliveData.relativeHumidity = Number(((bytes[3] * 100) / 256).toFixed(2));
 
-			// AC voltage
-			keepaliveData.acVoltage = bytes[8]
+			// Device status information (byte 4)
+			// Bit 7 indicates if IR code recording is requested (1) or not (0)
+			keepaliveData.isIrCodeRecordingRequested = ((bytes[4] & 0x80) !== 0);
 
 			Object.assign(deviceData, { ...deviceData }, { ...keepaliveData })
 		}
@@ -35,7 +38,7 @@ export const melissaLorawanPayloadParser = (hexData: string) => {
 				handleKeepAliveData(byteArray)
 			} else {
 				// parse command answers
-				let data = commandsReadingHelper(hexData, 18, DeviceType.MelissaLorawan)
+				let data = commandsReadingHelper(hexData, 10, DeviceType.MelissaLorawan)
 				if (!data) return
 				const shouldKeepAlive = data.hasOwnProperty('decodeKeepalive') ? true : false
 				if ('decodeKeepalive' in data) {
@@ -46,7 +49,7 @@ export const melissaLorawanPayloadParser = (hexData: string) => {
 
 				// get only keepalive from device response
 				if (shouldKeepAlive) {
-					let keepaliveData = hexData.slice(-18)
+					let keepaliveData = hexData.slice(-10)
 					let dataToPass = byteArrayParser(keepaliveData)
 					if (!dataToPass) return
 					handleKeepAliveData(dataToPass)

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

@@ -19,6 +19,8 @@ import {
 	Relay16DryCommands,
 	HTPirLiteCommands,
 	Co2PirLiteCommands,
+	MelissaCommands,
+	MultiSensorCommands,
 } from '@/encoders'
 
 import { CustomError, toCamelCase } from '@/utils'
@@ -48,6 +50,8 @@ export class CommandBuilder {
 			relay_16_dry: Relay16DryCommands,
 			ht_pir_lite: HTPirLiteCommands,
 			co2_pir_lite: Co2PirLiteCommands,
+			melissa_lorawan: MelissaCommands,
+			multisensor: MultiSensorCommands,
 		}
 	}
 

package/src/encoders/MelissaCommands.ts

@@ -0,0 +1,33 @@
+import { GeneralCommands, BaseCommand } from '@/encoders'
+import { applyMixins, decToHex, CustomError } from '@/utils'
+import { DeviceCommandSchemas, MelissaCommandTypes } from './types'
+import { ZodError,  } from 'zod'
+
+
+export class MelissaCommands extends GeneralCommands {
+
+
+	static setIrCodeRecording(params: MelissaCommandTypes.SetIrCodeRecordingParams) {
+			try {
+				DeviceCommandSchemas.MelissaCommandSchemas.setIrCodeRecording.parse(params)
+				const { time } = params
+				return new BaseCommand('SetIrCodeRecording', 0x09, decToHex(time))
+			} catch (e) {
+				if (e instanceof ZodError) {
+					throw new CustomError({
+						message: 'Zod validation error during SetIrCodeRecording execution',
+						command: 'SetIrCodeRecording',
+						originalError: e,
+					})
+				} else {
+					throw new CustomError({
+						message: 'Error during SetIrCodeRecording execution',
+						command: 'SetIrCodeRecording',
+						originalError: e as Error,
+					})
+				}
+			}
+		}
+}
+applyMixins(MelissaCommands, [
+])

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

@@ -24,4 +24,6 @@ export * from './ButtonCommands'
 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 {
@@ -1377,6 +1377,74 @@ export namespace Co2PirLiteCommandTypes {
 	>
 	export type RestartDeviceParams = z.infer<typeof Co2PirLiteCommandSchemas.restartDevice>
 }
+
+/* --------------------------------------- Melissa --------------------------------------- */
+const MelissaCommandSchemas = {
+	...GeneralCommandSchemas,
+	setIrCodeRecording: z.object({
+		time: z.number().min(0).max(255),
+	}),
+}
+
+export namespace MelissaCommandTypes {
+	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,
@@ -1402,4 +1470,6 @@ export const DeviceCommandSchemas = {
 	Relay16DryCommandSchemas,
 	HTPirLiteCommandSchemas,
 	Co2PirLiteCommandSchemas,
+	MelissaCommandSchemas,
+	MultiSensorCommandSchemas,
 }

package/src/test/payloadDecoders.test.ts

@@ -824,23 +824,42 @@ describe('ADS payload decoder', () => {
 })
 describe('Melissa payload decoder', () => {
 	test('simple keepalive', () => {
-		expect(uplinkPayloadParser('010031010A1D0218A4', DeviceType.MelissaLorawan)).toStrictEqual({
-			internalTemperature: 0,
-			energy: 822151.709,
-			power: 536,
-			acVoltage: 164
-		})
+		expect(uplinkPayloadParser('01027E4600', DeviceType.MelissaLorawan)).toStrictEqual({
+			sensorTemperature: 23.8,
+			relativeHumidity: 27.34,
+			isIrCodeRecordingRequested: false
+		  })
 		
 	})
 	test('keepalive with response of preloaded code', () => {
-		expect(uplinkPayloadParser('060042010031010A1D0218A4', DeviceType.MelissaLorawan)).toStrictEqual({
-			internalTemperature: 0,
-			energy: 822151.709,
-			power: 536,
-			acVoltage: 164,
+		expect(uplinkPayloadParser('06004201027E4600', DeviceType.MelissaLorawan)).toStrictEqual({
+			sensorTemperature: 23.8,
+			relativeHumidity: 27.34,
+			isIrCodeRecordingRequested: false,
 			preloadedCode: { codeAddress: 66, codeAddressRaw: '0042' }
 		})
 	})
+	test('keepalive with response of recorded code', () => {
+		expect(uplinkPayloadParser('0a0020002001027E4600', DeviceType.MelissaLorawan)).toStrictEqual({
+			sensorTemperature: 23.8,
+			relativeHumidity: 27.34,
+			isIrCodeRecordingRequested: false,
+			recordedIrInfo: { recordedIrCodeSize: 32, bytesSent: '0020' }
+		})
+	})
+	test('keepalive with response of transfered code', () => {
+		expect(uplinkPayloadParser('0b2200000063320612062e062e000606000508120004040008080005180008081100050c01027E4600', DeviceType.MelissaLorawan)).toStrictEqual({
+			sensorTemperature: 23.8,
+			relativeHumidity: 27.34,
+			isIrCodeRecordingRequested: false,
+			irCodeData: {
+				bytesCount: 32,
+				address: 0,
+				data: "0063320612062e062e000606000508120004040008080005180008081100050c"
+			}
+		})
+	})
+
 })
 describe('CO2PirLite payload decoder', () => {
 	test('simple keepalive', () => {

package/src/test/payloadEncoders.test.ts

@@ -816,3 +816,11 @@ describe('HT PIR Lite Commands payload encoder', () => {
 		expect(commandBuilder.build('RestartDevice')).toStrictEqual(new BaseCommand('RestartDevice', 0xa5))
 	})
 })
+describe('Melissa Commands payload encoder', () => {
+	const commandBuilder = new CommandBuilder('melissa_lorawan')
+	test('Set IR Code Recording ', () => {
+		expect(commandBuilder.build('SetIrCodeRecording', { time: 15 })).toStrictEqual(
+			new BaseCommand('SetIrCodeRecording', 0x09, '0F'),
+		)
+	})
+})