mclimate-payload-helper 1.2.1 → 1.2.3

package/src/decoders/commandsReadingHelper.ts

@@ -198,6 +198,68 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 					}
 				}
 				break
+			case '0a':
+				{
+					try {
+						let data;
+						if (deviceType === DeviceType.MelissaLorawan) {
+							command_len = 4;
+							let recordedIrCodeSize = (parseInt(commands[i + 1], 16) << 8) | parseInt(commands[i + 2], 16)
+							let bytesSent = `${commands[i + 3]}${commands[i + 4]}`
+							data = { recordedIrInfo: { recordedIrCodeSize, bytesSent } }
+							Object.assign(resultToPass, { ...resultToPass }, { ...data })
+						}
+					} catch (e) {
+						throw new CustomError({
+							message: `Failed to process command '0a'`,
+							hexData,
+							command,
+							deviceType,
+							originalError: e as Error,
+						})
+					}
+				}
+				break;
+			case '0b':
+				{
+					try {
+						let data;
+						if (deviceType === DeviceType.MelissaLorawan) {
+							// First byte after command indicates how many bytes follow
+							const bytesCount = parseInt(commands[i + 1], 16);
+							command_len = 1 + bytesCount; // 1 for bytesCount + the actual bytes
+
+							// Next two bytes are buffer offset
+							const bufferOffsetMSB = parseInt(commands[i + 2], 16);
+							const bufferOffsetLSB = parseInt(commands[i + 3], 16);
+							const address = (bufferOffsetMSB << 8) | bufferOffsetLSB;
+
+							// The rest is IR code data
+							let irCodeDataString = '';
+							for (let j = 4; j < 4 + bytesCount - 2; j++) { // -2 to account for the offset bytes
+								irCodeDataString += commands[i + j];
+							}
+
+							data = { 
+								irCodeData: {
+									bytesCount: bytesCount - 2,
+									address,
+									data: irCodeDataString
+								}
+							};
+							Object.assign(resultToPass, { ...resultToPass }, { ...data });
+						}
+					} catch (e) {
+						throw new CustomError({
+							message: `Failed to process command '0b'`,
+							hexData,
+							command,
+							deviceType,
+							originalError: e as Error,
+						})
+					}
+				}
+				break;
 			case '0e':
 				{
 					try {
@@ -1588,10 +1650,24 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 				{
 					try {
 						let data
-						command_len = 3
-						let state = parseInt(commands[i + 1], 16)
-						let time = (parseInt(commands[i + 2], 16) << 8) | parseInt(commands[i + 3], 16)
-						data = { relayTimerInSeconds: { state, time } }
+						if (deviceType === DeviceType.Vicki) {
+							command_len = 2;
+							let notificationByte = parseInt(commands[i + 1], 16);
+							// Extract notification flags from bits
+							let temperatureRestoredAfterManualBoost = !!(notificationByte & 0x01);  // Bit 0
+							let temperatureChangedByHeatingSchedule = !!(notificationByte & 0x02);   // Bit 1
+							data = {
+								notifications: {
+									temperatureRestoredAfterManualBoost: temperatureRestoredAfterManualBoost,
+									temperatureChangedByHeatingSchedule: temperatureChangedByHeatingSchedule
+								}
+							};
+						}else{
+							command_len = 3
+							let state = parseInt(commands[i + 1], 16)
+							let time = (parseInt(commands[i + 2], 16) << 8) | parseInt(commands[i + 3], 16)
+							data = { relayTimerInSeconds: { state, time } }
+						}
 						Object.assign(resultToPass, { ...resultToPass }, { ...data })
 					} catch (e) {
 						throw new CustomError({
@@ -1656,6 +1732,9 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 						if (deviceType === DeviceType.FanCoilThermostat) {
 							command_len = 1
 							data = { fanSpeedNotOccupied: parseInt(commands[i + 1], 16) }
+						}else{
+							command_len = 1
+							data = { manualChangeRelayState: parseInt(commands[i + 1], 16) }
 						}
 						Object.assign(resultToPass, { ...resultToPass }, { ...data })
 					} catch (e) {
@@ -1701,6 +1780,11 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 							data = {
 								overheatingEvents: { events: parseInt(commands[i + 1], 16), temperature: parseInt(commands[i + 2], 16) },
 							}
+						} else if (deviceType === DeviceType.Vicki) {
+							command_len = 1;
+							let offsetByte = parseInt(commands[i + 1], 16);
+							let offsetHours = (offsetByte & 0x80) ? (offsetByte - 256) : offsetByte;
+							data = { deviceTimeZone: offsetHours };
 						}
 						Object.assign(resultToPass, { ...resultToPass }, { ...data })
 					} catch (e) {
@@ -1754,6 +1838,10 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 									current: (parseInt(commands[i + 2], 16) << 8) | parseInt(commands[i + 3], 16),
 								},
 							}
+						}else{
+							command_len = 1;
+							let timeValue = parseInt(commands[i + 1], 16);
+							data = { autoSetpointRestoreStatus: timeValue === 0 ? 0 : timeValue * 10 };
 						}
 						Object.assign(resultToPass, { ...resultToPass }, { ...data })
 					} catch (e) {
@@ -1893,6 +1981,9 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 						if (deviceType === DeviceType.FanCoilThermostat) {
 							command_len = 1
 							data = { frostProtectionStatus: parseInt(commands[i + 1], 16) }
+						}else{
+							command_len = 1;
+							data = { timeRequestByMACcommand: parseInt(commands[i + 1], 16) };
 						}
 						Object.assign(resultToPass, { ...resultToPass }, { ...data })
 					} catch (e) {
@@ -2307,23 +2398,6 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 					}
 				}
 				break
-			case '58': {
-				command_len = 1;
-				let notificationByte = parseInt(commands[i + 1], 16);
-
-				// Extract notification flags from bits
-				let temperatureRestoredAfterManualBoost = !!(notificationByte & 0x01);  // Bit 0
-				let temperatureChangedByHeatingSchedule = !!(notificationByte & 0x02);   // Bit 1
-
-				let data = {
-					notifications: {
-						temperatureRestoredAfterManualBoost: temperatureRestoredAfterManualBoost,
-						temperatureChangedByHeatingSchedule: temperatureChangedByHeatingSchedule
-					}
-				};
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
-			}
-				break;
 			case '5a':
 				{
 					try {
@@ -2441,24 +2515,6 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 					}
 				}
 				break
-			case '5d':
-				{
-					try {
-						command_len = 1
-						let data = { manualChangeRelayState: parseInt(commands[i + 1], 16) }
-
-						Object.assign(resultToPass, { ...resultToPass }, { ...data })
-					} catch (e) {
-						throw new CustomError({
-							message: `Failed to process command '5d'`,
-							hexData,
-							command,
-							deviceType,
-							originalError: e as Error,
-						})
-					}
-				}
-				break
 			case '5e':
 				{
 					try {
@@ -2487,116 +2543,142 @@ export const commandsReadingHelper = (hexData: string, payloadLength: number, de
 						})
 					}
 				}
-				break
-			case '60': {
-				command_len = 1;
-				let offsetByte = parseInt(commands[i + 1], 16);
-				let offsetHours = (offsetByte & 0x80) ? (offsetByte - 256) : offsetByte;
-				let data = { deviceTimeZone: offsetHours };
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
-			}
 				break;
-			case '62': {
-				command_len = 1;
-				let timeValue = parseInt(commands[i + 1], 16);
-				let data = { autoSetpointRestoreStatus: timeValue === 0 ? 0 : timeValue * 10 };
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
-			}
-				break;
-
 			case '64': {
-				command_len = 1;
-				let ledDurationValue = parseInt(commands[i + 1], 16);
-				let durationInSeconds = ledDurationValue / 2; // As per the docs, value is divided by 2 to get seconds
+				try {
+					command_len = 1;
+					let ledDurationValue = parseInt(commands[i + 1], 16);
+					let durationInSeconds = ledDurationValue / 2; // As per the docs, value is divided by 2 to get seconds
 
-				let data = {
-					ledIndicationDuration: durationInSeconds
-				};
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
+					let data = {
+						ledIndicationDuration: durationInSeconds
+					};
+					Object.assign(resultToPass, { ...resultToPass }, { ...data })
+				} catch (e) {
+					throw new CustomError({
+						message: `Failed to process command '64'`,
+						hexData,
+						command,
+						deviceType,
+						originalError: e as Error,
+					})
+				}
 			}
 				break;
-
 			case '66': {
-				command_len = 2;
+				try {
+					command_len = 2;
 
-				let tempHigh = parseInt(commands[i + 1], 16);
-				let tempLow = parseInt(commands[i + 2], 16);
-				let targetTemp = (tempHigh << 8) | tempLow;
-				let data = {
-					offlineTargetTemperature: targetTemp === 0 ? 0 : targetTemp / 10
-				};
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
+					let tempHigh = parseInt(commands[i + 1], 16);
+					let tempLow = parseInt(commands[i + 2], 16);
+					let targetTemp = (tempHigh << 8) | tempLow;
+					let data = {
+						offlineTargetTemperature: targetTemp === 0 ? 0 : targetTemp / 10
+					};
+					Object.assign(resultToPass, { ...resultToPass }, { ...data })
+				} catch (e) {
+					throw new CustomError({
+						message: `Failed to process command '66'`,
+						hexData,
+						command,
+						deviceType,
+						originalError: e as Error,
+					})
+				}
 			}
 				break;
 			case '68': {
-				command_len = 1;
-				let data = { internalAlgoTemporaryState: parseInt(commands[i + 1], 16) === 0 ? true : false };
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
+				try {
+					command_len = 1;
+					let data = { internalAlgoTemporaryState: parseInt(commands[i + 1], 16) === 0 ? true : false };
+					Object.assign(resultToPass, { ...resultToPass }, { ...data })
+				} catch (e) {
+					throw new CustomError({
+						message: `Failed to process command '68'`,
+						hexData,
+						command,
+						deviceType,
+						originalError: e as Error,
+					})
+				}
 			}
 				break;
 			case '6a': {
-				command_len = 12;
-				let temperatureLevels: { [key: string]: number } = {};
+				try {
+					command_len = 12;
+					let temperatureLevels: { [key: string]: number } = {};
 
-				// Process 6 scale levels (0-5), each with a 2-byte temperature value
-				for (let level = 0; level < 6; level++) {
-					let tempHighByte = parseInt(commands[i + 1 + (level * 2)], 16);
-					let tempLowByte = parseInt(commands[i + 2 + (level * 2)], 16);
-					let tempValue = (tempHighByte << 8) | tempLowByte;
+					// Process 6 scale levels (0-5), each with a 2-byte temperature value
+					for (let level = 0; level < 6; level++) {
+						let tempHighByte = parseInt(commands[i + 1 + (level * 2)], 16);
+						let tempLowByte = parseInt(commands[i + 2 + (level * 2)], 16);
+						let tempValue = (tempHighByte << 8) | tempLowByte;
 
-					// The temperature values are pre-multiplied by 10
-					temperatureLevels['level' + level] = tempValue / 10;
-				}
+						// The temperature values are pre-multiplied by 10
+						temperatureLevels['level' + level] = tempValue / 10;
+					}
 
-				let data = {
-					temperatureLevels: temperatureLevels
-				};
+					let data = {
+						temperatureLevels: temperatureLevels
+					};
 
-				Object.assign(resultToPass, { ...resultToPass }, { ...data })
+					Object.assign(resultToPass, { ...resultToPass }, { ...data })
+				} catch (e) {
+					throw new CustomError({
+						message: `Failed to process command '6a'`,
+						hexData,
+						command,
+						deviceType,
+						originalError: e as Error,
+					})
+				}
 			}
 				break;
 			case '6c': {
-				command_len = 4;
-				let eventsHighByte = parseInt(commands[i + 2], 16);   // Events 19-16
-				let eventsMidByte = parseInt(commands[i + 3], 16);    // Events 15-8
-				let eventsLowByte = parseInt(commands[i + 4], 16);    // Events 7-0
+				try {
+					command_len = 4;
+					let eventsHighByte = parseInt(commands[i + 2], 16);   // Events 19-16
+					let eventsMidByte = parseInt(commands[i + 3], 16);    // Events 15-8
+					let eventsLowByte = parseInt(commands[i + 4], 16);    // Events 7-0
 
-				// Create a more structured and readable format for heating events
-				let heatingEventStates: { [key: string]: boolean } = {};
+					// Create a more structured and readable format for heating events
+					let heatingEventStates: { [key: string]: boolean } = {};
 
-				// Process all 20 events (0-19) in a single loop
-				for (let eventIdx = 0; eventIdx < 20; eventIdx++) {
-					// Calculate which bit to check
-					let bitPosition;
-					if (eventIdx >= 16) {
-						// Events 16-19 in high byte
-						bitPosition = eventIdx - 16;
-						heatingEventStates[eventIdx] = !!(eventsHighByte & (1 << bitPosition));
-					} else if (eventIdx >= 8) {
-						// Events 8-15 in mid byte
-						bitPosition = eventIdx - 8;
-						heatingEventStates[eventIdx] = !!(eventsMidByte & (1 << bitPosition));
-					} else {
-						// Events 0-7 in low byte
-						bitPosition = eventIdx;
-						heatingEventStates[eventIdx] = !!(eventsLowByte & (1 << bitPosition));
+					// Process all 20 events (0-19) in a single loop
+					for (let eventIdx = 0; eventIdx < 20; eventIdx++) {
+						// Calculate which bit to check
+						let bitPosition;
+						if (eventIdx >= 16) {
+							// Events 16-19 in high byte
+							bitPosition = eventIdx - 16;
+							heatingEventStates[eventIdx] = !!(eventsHighByte & (1 << bitPosition));
+						} else if (eventIdx >= 8) {
+							// Events 8-15 in mid byte
+							bitPosition = eventIdx - 8;
+							heatingEventStates[eventIdx] = !!(eventsMidByte & (1 << bitPosition));
+						} else {
+							// Events 0-7 in low byte
+							bitPosition = eventIdx;
+							heatingEventStates[eventIdx] = !!(eventsLowByte & (1 << bitPosition));
+						}
 					}
-				}
 
-				let data = {
-					heatingEventStates: heatingEventStates
-				};
+					let data = {
+						heatingEventStates: heatingEventStates
+					};
 
-				Object.assign(resultToPass, { ...resultToPass }, { ...data });
-				break;
-			}
-			case '6e': {
-				command_len = 1;
-				let data = { timeRequestByMACcommand: parseInt(commands[i + 1], 16) };
-				Object.assign(resultToPass, { ...resultToPass }, { ...data });
+					Object.assign(resultToPass, { ...resultToPass }, { ...data });
+				} catch (e) {
+					throw new CustomError({
+						message: `Failed to process command '6c'`,
+						hexData,
+						command,
+						deviceType,
+						originalError: e as Error,
+					})
+				}
 				break;
 			}
-
 			case '9b':
 				{
 					try {

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/encoders/CommandBuilder.ts

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

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/index.ts

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

package/src/encoders/types/schemas.ts

@@ -1377,6 +1377,22 @@ 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
+	>
+}
 /* --------------------------------------- EXPORT ALL SCHEMA GROUPS --------------------------------------- */
 export const DeviceCommandSchemas = {
 	GeneralCommandSchemas,
@@ -1402,4 +1418,5 @@ export const DeviceCommandSchemas = {
 	Relay16DryCommandSchemas,
 	HTPirLiteCommandSchemas,
 	Co2PirLiteCommandSchemas,
+	MelissaCommandSchemas,
 }

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'),
+		)
+	})
+})