feat: support Z-Wave Long Range

packages/cc/src/cc/Security2CC.ts

@@ -94,13 +94,19 @@ function getAuthenticationData(
 	commandLength: number,
 	unencryptedPayload: Buffer,
 ): Buffer {
-	const ret = Buffer.allocUnsafe(8 + unencryptedPayload.length);
-	ret[0] = sendingNodeId;
-	ret[1] = destination;
-	ret.writeUInt32BE(homeId, 2);
-	ret.writeUInt16BE(commandLength, 6);
+	const nodeIdSize = (sendingNodeId < 256 && destination < 256) ? 1 : 2;
+	const ret = Buffer.allocUnsafe(2*nodeIdSize + 6 + unencryptedPayload.length);
+	let offset = 0;
+	ret.writeUIntBE(sendingNodeId, offset, nodeIdSize);
+	offset += nodeIdSize;
+	ret.writeUIntBE(destination, offset, nodeIdSize);
+	offset += nodeIdSize;
+	ret.writeUInt32BE(homeId, offset);
+	offset += 4;
+	ret.writeUInt16BE(commandLength, offset);
+	offset += 2;
 	// This includes the sequence number and all unencrypted extensions
-	unencryptedPayload.copy(ret, 8, 0);
+	unencryptedPayload.copy(ret, offset, 0);
 	return ret;
 }
 

packages/core/src/capabilities/CommandClasses.ts

@@ -130,6 +130,7 @@ export enum CommandClasses {
 	"Z-Wave Plus Info" = 0x5e,
 	// Internal CC which is not used directly by applications
 	"Z-Wave Protocol" = 0x01,
+	"Z-Wave Long Range" = 0x04,
 }
 
 export function getCCName(cc: number): string {

packages/core/src/capabilities/NodeInfo.ts

@@ -215,34 +215,49 @@
 export function parseNodeProtocolInfo(
 	buffer: Buffer,
 	offset: number,
+	isLongRange: boolean = false,
 ): NodeProtocolInfo {
 	validatePayload(buffer.length >= offset + 3);
 
 	const isListening = !!(buffer[offset] & 0b10_000_000);
-	const isRouting = !!(buffer[offset] & 0b01_000_000);
+	let isRouting = false;
+	if (!isLongRange) {
+		isRouting = !!(buffer[offset] & 0b01_000_000);
+	}
 
 	const supportedDataRates: DataRate[] = [];
-	const maxSpeed = buffer[offset] & 0b00_011_000;
-	const speedExtension = buffer[offset + 2] & 0b111;
-	if (maxSpeed & 0b00_010_000) {
-		supportedDataRates.push(40000);
-	}
-	if (maxSpeed & 0b00_001_000) {
-		supportedDataRates.push(9600);
-	}
-	if (speedExtension & 0b001) {
-		supportedDataRates.push(100000);
-	}
-	if (supportedDataRates.length === 0) {
-		supportedDataRates.push(9600);
+	if (isLongRange) {
+		const speedExtension = buffer[offset + 2] & 0b111;
+		if (speedExtension & 0b010) {
+			supportedDataRates.push(100000);
+		}
+	} else {
+		const maxSpeed = buffer[offset] & 0b00_011_000;
+		const speedExtension = buffer[offset + 2] & 0b111;
+		if (maxSpeed & 0b00_010_000) {
+			supportedDataRates.push(40000);
+		}
+		if (maxSpeed & 0b00_001_000) {
+			supportedDataRates.push(9600);
+		}
+		if (speedExtension & 0b001) {
+			supportedDataRates.push(100000);
+		}
+		if (supportedDataRates.length === 0) {
+			supportedDataRates.push(9600);
+		}
 	}
 
-	const protocolVersion = buffer[offset] & 0b111;
+	// BUGBUG: what's the correct protocol version here for long range?
+	const protocolVersion = isLongRange
+		? 0
+		: buffer[offset] & 0b111;
 
 	const capability = buffer[offset + 1];
-	const optionalFunctionality = !!(capability & 0b1000_0000);
+	const optionalFunctionality = (!isLongRange)
+		&& !!(capability & 0b1000_0000);
 	let isFrequentListening: FLiRS;
-	switch (capability & 0b0110_0000) {
+	switch (capability & (isLongRange ? 0b0100_0000 : 0b0110_0000)) {
 		case 0b0100_0000:
 			isFrequentListening = "1000ms";
 			break;
@@ -252,21 +267,29 @@
 		default:
 			isFrequentListening = false;
 	}
-	const supportsBeaming = !!(capability & 0b0001_0000);
+	const supportsBeaming = (!isLongRange) && !!(capability & 0b0001_0000);
 
 	let nodeType: NodeType;
-	switch (capability & 0b1010) {
-		case 0b1000:
+
+	switch (
+		isLongRange
+			? (0b1_0000_0000 | (capability & 0b0010))
+			: (capability && 0b1010)
+	) {
+		case 0b0_0000_1000:
+		case 0b1_0000_0000:
 			nodeType = NodeType["End Node"];
 			break;
-		case 0b0010:
+		case 0b0_0000_0010:
+		case 0b1_0000_0010:
 		default:
+			// BUGBUG: is Controller correct for default && isLongRange?
 			nodeType = NodeType.Controller;
 			break;
 	}
 
-	const hasSpecificDeviceClass = !!(capability & 0b100);
-	const supportsSecurity = !!(capability & 0b1);
+	const hasSpecificDeviceClass = isLongRange || !!(capability & 0b100);
+	const supportsSecurity = isLongRange || !!(capability & 0b1);
 
 	return {
 		isListening,
@@ -282,39 +305,61 @@
 	};
 }
 
-export function encodeNodeProtocolInfo(info: NodeProtocolInfo): Buffer {
+export function encodeNodeProtocolInfo(
+	info: NodeProtocolInfo,
+	isLongRange: boolean = false,
+): Buffer {
 	const ret = Buffer.alloc(3, 0);
 	// Byte 0 and 2
 	if (info.isListening) ret[0] |= 0b10_000_000;
-	if (info.isRouting) ret[0] |= 0b01_000_000;
-	if (info.supportedDataRates.includes(40000)) ret[0] |= 0b00_010_000;
-	if (info.supportedDataRates.includes(9600)) ret[0] |= 0b00_001_000;
-	if (info.supportedDataRates.includes(100000)) ret[2] |= 0b001;
-	ret[0] |= info.protocolVersion & 0b111;
+	if (isLongRange) {
+		if (info.supportedDataRates.includes(100000)) ret[2] |= 0b010;
+	} else {
+		if (info.isRouting) ret[0] |= 0b01_000_000;
+		if (info.supportedDataRates.includes(40000)) ret[0] |= 0b00_010_000;
+		if (info.supportedDataRates.includes(9600)) ret[0] |= 0b00_001_000;
+		if (info.supportedDataRates.includes(100000)) ret[2] |= 0b001;
+		ret[0] |= info.protocolVersion & 0b111;
+	}
 
 	// Byte 1
-	if (info.optionalFunctionality) ret[1] |= 0b1000_0000;
+	if (!isLongRange) {
+		if (info.optionalFunctionality) ret[1] |= 0b1000_0000;
+	}
 	if (info.isFrequentListening === "1000ms") ret[1] |= 0b0100_0000;
-	else if (info.isFrequentListening === "250ms") ret[1] |= 0b0010_0000;
+	else if (!isLongRange && info.isFrequentListening === "250ms") {
+		ret[1] |= 0b0010_0000;
+	}
+
+	if (!isLongRange) {
+		if (info.supportsBeaming) ret[1] |= 0b0001_0000;
+		if (info.supportsSecurity) ret[1] |= 0b1;
+	}
 
-	if (info.supportsBeaming) ret[1] |= 0b0001_0000;
-	if (info.supportsSecurity) ret[1] |= 0b1;
-	if (info.nodeType === NodeType["End Node"]) ret[1] |= 0b1000;
-	else ret[1] |= 0b0010; // Controller
+	if (info.nodeType === NodeType["End Node"]) {
+		if (!isLongRange) ret[1] |= 0b1000;
+	} else ret[1] |= 0b0010; // Controller
 
-	if (info.hasSpecificDeviceClass) ret[1] |= 0b100;
+	if (!isLongRange && info.hasSpecificDeviceClass) ret[1] |= 0b100;
 
 	return ret;
 }
 
-export function parseNodeProtocolInfoAndDeviceClass(buffer: Buffer): {
+export function parseNodeProtocolInfoAndDeviceClass(
+	buffer: Buffer,
+	isLongRange: boolean = false,
+): {
 	info: NodeProtocolInfoAndDeviceClass;
 	bytesRead: number;
 } {
 	validatePayload(buffer.length >= 5);
-	const protocolInfo = parseNodeProtocolInfo(buffer, 0);
+	const protocolInfo = parseNodeProtocolInfo(buffer, 0, isLongRange);
 	let offset = 3;
-	const basic = buffer[offset++];
+	// BUGBUG: 4.3.2.1.1.14 says this is omitted if the Controller field is set to 0, yet we always parse it?
+	let basic = 0x100; // BUGBUG: is there an assume one here, or...?
+	if (!isLongRange) {
+		basic = buffer[offset++];
+	}
 	const generic = buffer[offset++];
 	let specific = 0;
 	if (protocolInfo.hasSpecificDeviceClass) {
@@ -334,36 +379,64 @@
 
 export function encodeNodeProtocolInfoAndDeviceClass(
 	info: NodeProtocolInfoAndDeviceClass,
+	isLongRange: boolean = false,
 ): Buffer {
-	return Buffer.concat([
-		encodeNodeProtocolInfo({ ...info, hasSpecificDeviceClass: true }),
-		Buffer.from([
+	const deviceClasses = isLongRange
+		? Buffer.from([
+			info.genericDeviceClass,
+			info.specificDeviceClass,
+		])
+		: Buffer.from([
 			info.basicDeviceClass,
 			info.genericDeviceClass,
 			info.specificDeviceClass,
-		]),
+		]);
+	return Buffer.concat([
+		encodeNodeProtocolInfo({ ...info, hasSpecificDeviceClass: true }),
+		deviceClasses,
 	]);
 }
 
 export function parseNodeInformationFrame(
 	buffer: Buffer,
+	isLongRange: boolean = false,
 ): NodeInformationFrame {
-	const { info, bytesRead: offset } = parseNodeProtocolInfoAndDeviceClass(
+	let { info, bytesRead: offset } = parseNodeProtocolInfoAndDeviceClass(
 		buffer,
+		isLongRange,
 	);
-	const supportedCCs = parseCCList(buffer.subarray(offset)).supportedCCs;
+	var ccListLength;
+	if (isLongRange) {
+		ccListLength = buffer[offset];
+		offset += 1;
+	} else {
+		ccListLength = buffer.length - offset;
+	}
+	const supportedCCs =
+		parseCCList(buffer.subarray(offset, ccListLength)).supportedCCs;
 
 	return {
 		...info,
 		supportedCCs,
 	};
 }
 
-export function encodeNodeInformationFrame(info: NodeInformationFrame): Buffer {
-	return Buffer.concat([
-		encodeNodeProtocolInfoAndDeviceClass(info),
-		encodeCCList(info.supportedCCs, []),
-	]);
+export function encodeNodeInformationFrame(
+	info: NodeInformationFrame,
+	isLongRange: boolean = false,
+): Buffer {
+	const protocolInfo = encodeNodeProtocolInfoAndDeviceClass(info, isLongRange);
+	const ccList = 	encodeCCList(info.supportedCCs, []);
+
+	var buffers = [protocolInfo]
+	if (isLongRange) {
+		const ccListLength = Buffer.allocUnsafe(1);
+		ccListLength[0] = ccList.length;
+		buffers.concat(ccListLength);
+	}
+	buffers.concat(ccList);
+
+	return Buffer.concat(buffers);
 }
 
 export function parseNodeID(

packages/core/src/capabilities/Protocols.ts

@@ -19,7 +19,7 @@ export function zwaveDataRateToString(rate: ZWaveDataRate): string {
 			return "40 kbit/s";
 		case ZWaveDataRate["100k"]:
 			return "100 kbit/s";
-	}
+		}
 	return `Unknown (${num2hex(rate)})`;
 }
 

packages/core/src/consts/index.ts

@@ -10,6 +10,12 @@ export const NODE_ID_MAX = MAX_NODES;
 /** The number of bytes in a node bit mask */
 export const NUM_NODEMASK_BYTES = MAX_NODES / 8;
 
+/** The number of node ids in a long range "segment" (GetLongRangeNodes response) */
+export const NUM_LR_NODES_PER_SEGMENT = 128;
+
+/** The number of bytes in a long range node bit mask segment */
+export const NUM_LR_NODEMASK_SEGMENT_BYTES = NUM_LR_NODES_PER_SEGMENT / 8;
+
 export enum NodeIDType {
 	Short = 0x01,
 	Long = 0x02,

packages/core/src/values/Primitive.ts

@@ -1,4 +1,8 @@
-import { MAX_NODES, NUM_NODEMASK_BYTES } from "../consts";
+import {
+	MAX_NODES,
+	NUM_LR_NODES_PER_SEGMENT,
+	NUM_NODEMASK_BYTES,
+} from "../consts";
 import { ZWaveError, ZWaveErrorCodes } from "../error/ZWaveError";
 import {
 	getBitMaskWidth,
@@ -231,15 +235,17 @@ export function encodeFloatWithScale(
 }
 
 /** Parses a bit mask into a numeric array */
-export function parseBitMask(mask: Buffer, startValue: number = 1): number[] {
-	const numBits = mask.length * 8;
-
+export function parseBitMask(
+	mask: Buffer,
+	startValue: number = 1,
+	numBits: number = mask.length * 8,
+): number[] {
 	const ret: number[] = [];
-	for (let index = 1; index <= numBits; index++) {
-		const byteNum = (index - 1) >>> 3; // id / 8
-		const bitNum = (index - 1) % 8;
+	for (let index = 0; index < numBits; index++) {
+		const byteNum = index >>> 3; // id / 8
+		const bitNum = index % 8;
 		if ((mask[byteNum] & (2 ** bitNum)) !== 0) {
-			ret.push(index + startValue - 1);
+			ret.push(index + startValue);
 		}
 	}
 	return ret;
@@ -266,10 +272,28 @@ export function parseNodeBitMask(mask: Buffer): number[] {
 	return parseBitMask(mask.subarray(0, NUM_NODEMASK_BYTES));
 }
 
+export function parseLongRangeNodeBitMask(
+	mask: Buffer,
+	startValue: number,
+): number[] {
+	return parseBitMask(mask, startValue);
+}
+
 export function encodeNodeBitMask(nodeIDs: readonly number[]): Buffer {
 	return encodeBitMask(nodeIDs, MAX_NODES);
 }
 
+export function encodeLongRangeNodeBitMask(
+	nodeIDs: readonly number[],
+	startValue: number,
+): Buffer {
+	return encodeBitMask(
+		nodeIDs,
+		startValue + NUM_LR_NODES_PER_SEGMENT - 1,
+		startValue,
+	);
+}
+
 /**
  * Parses a partial value from a "full" value. Example:
  * ```txt