zigbee-herdsman-converters
Version:
Collection of device converters to be used with zigbee-herdsman
784 lines • 32.6 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.definitions = void 0;
const zigbee_herdsman_1 = require("zigbee-herdsman");
const fz = __importStar(require("../converters/fromZigbee"));
const tz = __importStar(require("../converters/toZigbee"));
const exposes = __importStar(require("../lib/exposes"));
const logger_1 = require("../lib/logger");
const m = __importStar(require("../lib/modernExtend"));
const reporting = __importStar(require("../lib/reporting"));
const utils_1 = require("../lib/utils");
const NS = "zhc:yale";
const e = exposes.presets;
const ea = exposes.access;
const lockExtend = (meta = {}, lockStateOptions = null, binds = ["closuresDoorLock", "genPowerCfg"]) => {
return {
fromZigbee: [
fz.lock,
fz.battery,
fz.lock_operation_event,
fz.lock_programming_event,
fz.lock_pin_code_response,
fz.lock_user_status_response,
],
toZigbee: [tz.lock, tz.pincode_lock, tz.lock_userstatus, tz.lock_auto_relock_time, tz.lock_sound_volume],
meta: { pinCodeCount: 250, ...meta },
exposes: [
e.lock(),
e.battery(),
e.pincode(),
e.lock_action(),
e.lock_action_source_name(),
e.lock_action_user(),
e.auto_relock_time().withValueMin(0).withValueMax(3600),
e.sound_volume(),
e.battery_low(),
],
configure: [
async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, binds);
if (lockStateOptions !== false) {
await reporting.lockState(endpoint, lockStateOptions);
}
await reporting.batteryPercentageRemaining(endpoint);
try {
await reporting.batteryAlarmState(endpoint);
}
catch {
// Fails for some: https://github.com/Koenkk/zigbee-herdsman-converters/pull/5414
}
},
],
isModernExtend: true,
};
};
const yaleExtend = {
addManuSpecificAssaDoorLockCluster: () => m.deviceAddCustomCluster("manuSpecificAssaDoorLock", {
name: "manuSpecificAssaDoorLock",
ID: 0xfc00,
attributes: {
autoLockTime: { name: "autoLockTime", ID: 0x0012, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
wrongCodeAttempts: { name: "wrongCodeAttempts", ID: 0x0013, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
shutdownTime: { name: "shutdownTime", ID: 0x0014, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
batteryLevel: { name: "batteryLevel", ID: 0x0015, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
insideEscutcheonLED: { name: "insideEscutcheonLED", ID: 0x0016, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
volume: { name: "volume", ID: 0x0017, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
lockMode: { name: "lockMode", ID: 0x0018, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
language: { name: "language", ID: 0x0019, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
allCodesLockout: { name: "allCodesLockout", ID: 0x001a, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
oneTouchLocking: { name: "oneTouchLocking", ID: 0x001b, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
privacyButtonSetting: { name: "privacyButtonSetting", ID: 0x001c, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN, write: true },
/* enableLogging: {ID: 0x0020, type: Zcl.DataType.BOOLEAN, write: true},*/ // marked in C4 driver as not supported
numberLogRecordsSupported: { name: "numberLogRecordsSupported", ID: 0x0021, type: zigbee_herdsman_1.Zcl.DataType.UINT16, write: true, max: 0xffff },
numberPinsSupported: { name: "numberPinsSupported", ID: 0x0030, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
numberScheduleSlotsPerUser: { name: "numberScheduleSlotsPerUser", ID: 0x0040, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
alarmMask: { name: "alarmMask", ID: 0x0050, type: zigbee_herdsman_1.Zcl.DataType.UINT8, write: true, max: 0xff },
},
commands: {
getLockStatus: { name: "getLockStatus", ID: 0x10, response: 0, parameters: [] },
getBatteryLevel: { name: "getBatteryLevel", ID: 0x12, parameters: [] },
setRFLockoutTime: { name: "setRFLockoutTime", ID: 0x13, parameters: [] },
/* getLogRecord: {ID: 0x20,
parameters: [],
},*/ // marked in C4 driver as not supported
userCodeSet: {
name: "userCodeSet",
ID: 0x30,
parameters: [
// bit pack ("bbb", slot, status, pinLength) .. pin
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
userCodeGet: {
name: "userCodeGet",
ID: 0x31,
parameters: [
// bit pack ("b", slot)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
userCodeClear: {
name: "userCodeClear",
ID: 0x32,
parameters: [
// bit pack ("b", slot)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
clearAllUserCodes: { name: "clearAllUserCodes", ID: 0x33, parameters: [] },
setUserCodeStatus: { name: "setUserCodeStatus", ID: 0x34, parameters: [] },
getUserCodeStatus: { name: "getUserCodeStatus", ID: 0x35, parameters: [] },
getLastUserIdEntered: { name: "getLastUserIdEntered", ID: 0x36, parameters: [] },
userAdded: { name: "userAdded", ID: 0x37, parameters: [] },
userDeleted: { name: "userDeleted", ID: 0x38, parameters: [] },
setScheduleSlot: {
name: "setScheduleSlot",
ID: 0x40,
parameters: [
// bit pack ("bbbbbbb", 0, slot, weeklyScheduleNumber, startHour, startMinute, hours, minutes)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
getScheduleSlot: {
name: "getScheduleSlot",
ID: 0x41,
parameters: [
// bit pack ("bb", slot, userId)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
setScheduleSlotStatus: {
name: "setScheduleSlotStatus",
ID: 0x42,
parameters: [
// bit pack ("bbb", 0, slot, status)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
reflash: {
name: "reflash",
ID: 0x60,
response: 1,
parameters: [
// bit pack ("bI", version, length)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
reflashData: {
name: "reflashData",
ID: 0x61,
response: 2,
parameters: [
// bit pack ("IH", segmentId - 1, length) .. string sub (data, start, finish)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
reflashStatus: {
name: "reflashStatus",
ID: 0x62,
response: 3,
parameters: [
// bit pack ("bI", reflashStatusParameter, 0x00)
{ name: "payload", type: zigbee_herdsman_1.Zcl.DataType.CHAR_STR },
],
},
getReflashLock: { name: "getReflashLock", ID: 0x90, parameters: [] },
getHistory: { name: "getHistory", ID: 0xa0, parameters: [] },
getLogin: { name: "getLogin", ID: 0xa1, parameters: [] },
getUser: { name: "getUser", ID: 0xa2, parameters: [] },
getUsers: { name: "getUsers", ID: 0xa3, parameters: [] },
getMandatoryAttributes: { name: "getMandatoryAttributes", ID: 0xb0, parameters: [] },
readAttribute: { name: "readAttribute", ID: 0xb1, parameters: [] },
writeAttribute: { name: "writeAttribute", ID: 0xb2, parameters: [] },
configureReporting: { name: "configureReporting", ID: 0xb3, parameters: [] },
getBasicClusterAttributes: { name: "getBasicClusterAttributes", ID: 0xb4, parameters: [] },
},
commandsResponse: {
getLockStatusRsp: { name: "getLockStatusRsp", ID: 0x00, parameters: [{ name: "status", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
reflashRsp: { name: "reflashRsp", ID: 0x01, parameters: [{ name: "status", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
reflashDataRsp: { name: "reflashDataRsp", ID: 0x02, parameters: [{ name: "status", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
reflashStatusRsp: { name: "reflashStatusRsp", ID: 0x03, parameters: [{ name: "status", type: zigbee_herdsman_1.Zcl.DataType.UINT8, max: 0xff }] },
/* boltStateRsp: {ID: 4,
parameters: [
{name: 'state', type: Zcl.DataType.UINT8, max: 0xff},
],
},*/ // C4 driver has this response yet there is no command - maybe a non-specific cluster response?
/* lockStatusReportRsp: {ID: 5,
parameters: [
{name: 'status', type: Zcl.DataType.UINT8, max: 0xff},
],
},*/ // C4 driver has this response yet there is no command - maybe a non-specific cluster response?
/* handleStateRsp: {ID: 6,
parameters: [
{name: 'state', type: Zcl.DataType.UINT8, max: 0xff},
],
},*/ // C4 driver has this response yet there is no command - maybe a non-specific cluster response?
/* userStatusRsp: {ID: 7,
parameters: [
{name: 'status', type: Zcl.DataType.UINT8, max: 0xff},
],
},*/ // C4 driver has this response yet there is no command - maybe a non-specific cluster response?
},
}),
};
const fzLocal = {
c4_alarm: {
cluster: "genAlarms",
type: ["commandAlarm"],
convert: async (model, msg, publish, options, meta) => {
let result = {};
if (msg.data.clusterid === 64512) {
const alarmcode = msg.data.alarmcode;
const lookup = {
9: { state: "UNLOCKED", lock_state: "not_fully_locked", alarm: "deadbolt_jammed" },
18: { action: "keypad_lock", state: "LOCKED", lock_state: "locked" },
19: { action: "keypad_unlock", state: "UNLOCKED", lock_state: "unlocked" },
21: { action: "manual_lock_key_or_thumbturn", state: "LOCKED", lock_state: "locked" },
22: { action: "manual_unlock_key_or_thumbturn", state: "UNLOCKED", lock_state: "unlocked" },
24: { action: "lock_module", state: "LOCKED", lock_state: "locked" },
25: { action: "unlock_module", state: "UNLOCKED", lock_state: "unlocked" },
27: { action: "auto_lock", state: "LOCKED", lock_state: "locked" },
32: { action: "manual_lock_touch", state: "LOCKED", lock_state: "locked" },
48: { alarm: "lock_reset_to_factory_defaults" },
112: { alarm: "master_code_changed" },
113: { alarm: "duplicate_pin_code_error" },
128: { alarm: "battery_replaced", battery_low: false },
129: { alarm: "handing_cycle_completed_right" },
130: { alarm: "rf_module_power_cycled" },
131: { alarm: "handing_cycle_completed_left" },
161: { alarm: "tamper_alarm_keypad_attempts", tamper: true },
162: { alarm: "tamper_alarm_front_escutcheon", tamper: true },
167: { alarm: "tamper_alarm_low_battery", tamper: true, battery_low: true },
168: { alarm: "tamper_alarm_critical_battery", tamper: true, battery_low: true },
169: { alarm: "low_battery", battery_low: true },
};
result = (0, utils_1.getFromLookup)(alarmcode, lookup);
// reset tamper and battery_low values as these will not self clear and will also be re-reported by device
if (!("tamper" in result)) {
result.tamper = false;
}
if (!("battery_low" in result)) {
result.battery_low = false;
}
}
// We need to read the lock attributes as these are not reported by the device
try {
await msg.endpoint.read("manuSpecificAssaDoorLock", ["batteryLevel"]);
}
catch {
logger_1.logger.warning("Failed to read lock attributes", NS);
}
return result;
},
},
c4_assa_lock_attribute: {
cluster: "manuSpecificAssaDoorLock",
type: ["readResponse"],
convert: (model, msg, publish, options, meta) => {
const data = msg.data;
const result = {};
if (data.autoLockTime) {
const lookup = {
0: "off",
30: "30seconds",
60: "60seconds",
120: "2minutes",
180: "3minutes",
};
result.auto_lock_time = (0, utils_1.getFromLookup)(data.autoLockTime, lookup);
}
if (data.wrongCodeAttempts) {
result.wrong_code_attempts = data.wrongCodeAttempts;
}
if (data.shutdownTime) {
result.shutdown_time = data.shutdownTime;
}
if (data.batteryLevel) {
result.battery = data.batteryLevel;
result.battery_low = data.batteryLevel <= 15;
}
if (data.insideEscutcheonLED) {
result.inside_escutcheon_led = data.insideEscutcheonLED === 1;
}
if (data.volume) {
const lookup = {
1: "silent",
2: "low",
3: "high",
};
result.volume = (0, utils_1.getFromLookup)(data.volume, lookup);
}
if (data.lockMode) {
const lookup = {
0: "normal",
1: "vacation",
2: "privacy",
};
result.lock_mode = (0, utils_1.getFromLookup)(data.lockMode, lookup);
}
if (data.language) {
const lookup = {
1: "english",
2: "spanish",
3: "french",
};
result.lock_mode = (0, utils_1.getFromLookup)(data.language, lookup);
}
if (data.allCodesLockout) {
result.all_codes_lockout = data.allCodesLockout;
}
if (data.oneTouchLocking) {
result.one_touch_locking = data.oneTouchLocking;
}
if (data.privacyButtonSetting) {
result.privacy_button = data.privacyButtonSetting;
}
if (data.numberLogRecordsSupported) {
result.number_log_records_supported = data.numberLogRecordsSupported;
}
if (data.numberPinsSupported) {
result.number_pins_supported = data.numberPinsSupported;
}
if (data.numberScheduleSlotsPerUser) {
result.number_schedule_slots_per_user = data.numberScheduleSlotsPerUser;
}
if (data.alarmMask) {
result.alarm_mask = data.alarmMask;
}
return result;
},
},
c4_lock_operation_event: {
cluster: "genAlarms",
type: ["commandAlarm"],
convert: async (model, msg, publish, options, meta) => {
let result = {};
if (msg.data.clusterid === 64512) {
const alarmcode = msg.data.alarmcode;
const lookup = {
9: { action: "error_jammed", state: "UNLOCK", lock_state: "not_fully_locked" },
21: { action: "manual_lock", state: "LOCK", lock_state: "locked" },
22: { action: "manual_unlock", state: "UNLOCK", lock_state: "unlocked" },
24: { action: "lock", state: "LOCK", lock_state: "locked" },
25: { action: "unlock", state: "UNLOCK", lock_state: "unlocked" },
27: { action: "auto_lock", state: "LOCK", lock_state: "locked" },
};
if (!(alarmcode in lookup)) {
result.action = "unknown";
logger_1.logger.warning(`Unrecognized Operation Event (${alarmcode})`, NS);
// We need to read the lock state as the alarm code is unknown
try {
await msg.endpoint.read("closuresDoorLock", ["lockState"]);
}
catch {
logger_1.logger.warning("Failed to read lock state", NS);
}
}
else {
result = (0, utils_1.getFromLookup)(alarmcode, lookup);
}
}
return result;
},
},
ymc_action: {
cluster: "closuresDoorLock",
type: ["raw"],
convert: (model, msg, publish, options, meta) => {
const actionLookup = {
0: "password_unlock",
1: "unlock",
2: "auto_lock",
3: "rfid_unlock",
4: "fingerprint_unlock",
5: "unlock_failure_invalid_pin_or_id",
6: "unlock_failure_invalid_schedule",
7: "one_touch_lock",
8: "key_lock",
9: "key_unlock",
10: "auto_lock",
11: "schedule_lock",
12: "schedule_unlock",
13: "manual_lock",
14: "manual_unlock",
15: "non_access_user_operational_event",
};
const sourceLookup = {
0: "keypad",
1: "rf",
2: "manual",
3: "rfid",
4: "manual",
5: "keypad",
6: "keypad",
7: "manual",
8: "manual",
9: "manual",
10: "manual",
11: "rf",
12: "rf",
13: "manual",
14: "manual",
15: "keypad",
};
const lockActions = [2, 7, 8, 10, 11, 13];
const unlockActions = [0, 1, 3, 4, 9, 12, 14];
const actionCode = msg.data[3];
const result = {
action: actionLookup[actionCode] ?? "unknown",
action_source_name: sourceLookup[actionCode] ?? null,
action_source_user: msg.data[5],
};
if (lockActions.includes(actionCode)) {
result.state = "LOCK";
result.lock_state = "locked";
}
else if (unlockActions.includes(actionCode)) {
result.state = "UNLOCK";
result.lock_state = "unlocked";
}
return result;
},
},
};
const tzLocal = {
auto_lock_time: {
key: ["auto_lock_time"],
convertSet: async (entity, key, value, meta) => {
const lookup = {
off: 0,
"30seconds": 30,
"60seconds": 60,
"2minutes": 120,
"3minutes": 180,
};
await entity.write("manuSpecificAssaDoorLock", { autoLockTime: (0, utils_1.getFromLookup)(value, lookup) }, { disableDefaultResponse: true });
return { state: { auto_lock_time: value } };
},
convertGet: async (entity, key, meta) => {
await entity.read("manuSpecificAssaDoorLock", ["autoLockTime"]);
},
},
volume: {
key: ["volume"],
convertSet: async (entity, key, value, meta) => {
const lookup = {
silent: 1,
low: 2,
high: 3,
};
await entity.write("manuSpecificAssaDoorLock", { volume: (0, utils_1.getFromLookup)(value, lookup) }, { disableDefaultResponse: true });
return { state: { volume: value } };
},
convertGet: async (entity, key, meta) => {
await entity.read("manuSpecificAssaDoorLock", ["volume"]);
},
},
};
exports.definitions = [
{
zigbeeModel: ["YRD446 BLE TSDB"],
model: "YRD426NRSC",
vendor: "Yale",
description: "Assure lock",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRL256 TS"],
model: "YRL256 TS",
vendor: "Yale",
description: "Assure lock",
extend: [m.battery(), m.lock({ pinCodeCount: 250 })],
},
{
zigbeeModel: ["YRD226 TSDB", "YRD226L TSDB"],
model: "YRD226HA2619",
vendor: "Yale",
description: "Assure lock",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD256 TSDB", "YRD256L TSDB"],
model: "YRD256HA20BP",
vendor: "Yale",
description: "Assure lock SL",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD256-TSDB"],
model: "YAYRD256HA2619",
vendor: "Yale",
description: "Assure lock SL",
fromZigbee: [fzLocal.c4_lock_operation_event],
extend: [lockExtend({}, false)],
},
{
zigbeeModel: ["YRD652 TSDB", "YRD652L TSDB"],
model: "YRD652HA20BP",
vendor: "Yale",
description: "Assure lock SL",
extend: [lockExtend()],
},
{
zigbeeModel: ["0600000001"],
model: "YMF30",
vendor: "Yale",
description: "Digital lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["iZBModule01", "0700000001"],
model: "YMF40/YDM4109+/YDF40",
vendor: "Yale",
description: "Real living lock / Intelligent biometric digital lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRD210 PB DB"],
model: "YRD210-HA-605",
vendor: "Yale",
description: "Real living keyless push button deadbolt lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRL220 TS LL"],
// The zigbee module card indicate that the module will work on YRD 221 and YRD 221RL also
model: "YRL-220L",
vendor: "Yale",
description: "Real living keyless leveler lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRD226/246 TSDB"],
model: "YRD226/246 TSDB",
vendor: "Yale",
description: "Assure lock",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD220/240 TSDB"],
model: "YRD220/YRD221",
vendor: "Yale",
description: "Lockwood keyless push button deadbolt lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRD246 TSDB"],
model: "YRD246HA20BP",
vendor: "Yale",
description: "Assure lock key free deadbolt with Zigbee",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRM476 TS BLE"],
model: "YRM476",
vendor: "Yale",
description: "Assure lock",
extend: [m.battery(), m.lock({ pinCodeCount: 250 })],
},
{
zigbeeModel: ["YRD216 PBDB"],
model: "YRD216-HA2-619",
vendor: "Yale",
description: "Real living keyless push button deadbolt lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["YRL226L TS"],
model: "YRL226L TS",
vendor: "Yale",
description: "Assure lock SL",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRL226 TS"],
model: "YRL226 TS",
vendor: "Yale",
description: "Assure lock SL",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD410 TS", "YRD410 PB"],
model: "YRD410-BLE",
vendor: "Yale",
description: "Assure lock 2",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD420 TS"],
model: "YRD420-BLE",
vendor: "Yale",
description: "Assure lock 2",
extend: [lockExtend()],
},
{
zigbeeModel: ["YMC420", "YMC 420", "YMC420 W", "YMC 420 W"],
model: "YMC420-W",
vendor: "Yale",
description: "Digital Lock YMC 420 W",
fromZigbee: [fzLocal.ymc_action],
extend: [lockExtend()],
exposes: [
e.action([
"password_unlock",
"unlock",
"auto_lock",
"rfid_unlock",
"fingerprint_unlock",
"unlock_failure_invalid_pin_or_id",
"unlock_failure_invalid_schedule",
"one_touch_lock",
"key_lock",
"key_unlock",
"schedule_lock",
"schedule_unlock",
"manual_lock",
"manual_unlock",
"non_access_user_operational_event",
]),
],
},
{
zigbeeModel: ["YDM60"],
model: "YDM60",
vendor: "Yale",
description: "Digital lock",
fromZigbee: [fzLocal.ymc_action],
extend: [lockExtend()],
exposes: [
e.action([
"password_unlock",
"unlock",
"auto_lock",
"rfid_unlock",
"fingerprint_unlock",
"unlock_failure_invalid_pin_or_id",
"unlock_failure_invalid_schedule",
"one_touch_lock",
"key_lock",
"key_unlock",
"schedule_lock",
"schedule_unlock",
"manual_lock",
"manual_unlock",
"non_access_user_operational_event",
]),
],
},
{
zigbeeModel: ["SOLIS01"],
model: "SOLIS01",
vendor: "Yale",
description: "Solis digital lock",
fromZigbee: [fzLocal.ymc_action],
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD430 TS", "YRD430 PB"],
model: "YRD430-BLE",
vendor: "Yale",
description: "Assure lock 2",
extend: [lockExtend()],
},
{
zigbeeModel: ["YRD450 TS", "YRD450-F TS"],
model: "YRD450-BLE",
vendor: "Yale",
description: "Assure lock 2",
extend: [lockExtend()],
},
{
zigbeeModel: ["LIA"],
model: "LIA",
vendor: "Yale",
description: "Digital Lock Lia",
extend: [lockExtend()],
},
{
// Appears to be a slightly rebranded Assure lock SL
// Just with Lockwood | Assa Abloy branding instead of Yale
// Appears to have been part of a deal with Telstra, hence the T-Lock name
zigbeeModel: ["YDD-D4F0 TSDB"],
model: "YDD-D4F0-TSDB",
vendor: "Yale",
description: "Lockwood T-Lock",
extend: [lockExtend()],
},
{
zigbeeModel: ["c700000202", "06ffff2029"],
model: "YDF40",
vendor: "Yale",
description: "Real living lock / Intelligent biometric digital lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } }, { max: 900 }, ["closuresDoorLock"])],
},
{
zigbeeModel: ["06ffff2027", "06e01d220c"],
model: "YMF40A RL",
vendor: "Yale",
description: "Real living lock / Intelligent biometric digital lock",
extend: [lockExtend({ battery: { dontDividePercentage: true } })],
},
{
zigbeeModel: ["06e0152204"],
model: "YMI70A",
vendor: "Yale",
description: "Biometric digital lock",
extend: [m.battery(), m.lock({ pinCodeCount: 100 })],
},
{
fingerprint: [
{
type: "EndDevice",
manufacturerName: "Yale",
manufacturerID: 43690,
powerSource: "Battery",
endpoints: [
{ ID: 1, profileID: 260, deviceID: 10, inputClusters: [0, 9, 10, 257, 64512, 1], outputClusters: [] },
{ ID: 196, profileID: 260, deviceID: 10, inputClusters: [1], outputClusters: [] },
],
},
],
model: "ZYA-C4-MOD-S",
vendor: "Yale",
description: "Control4 module for Yale KeyFree/Keyless/Doorman/Assure/nexTouch locks",
extend: [yaleExtend.addManuSpecificAssaDoorLockCluster()],
fromZigbee: [fz.lock, fzLocal.c4_alarm, fzLocal.c4_assa_lock_attribute],
toZigbee: [tz.lock, tzLocal.auto_lock_time, tzLocal.volume],
exposes: [
e.lock(),
e.lock_action(),
e.battery(),
e.battery_low(),
e.enum("auto_lock_time", ea.ALL, ["off", "30seconds", "60seconds", "2minutes", "3minutes"]),
e.enum("volume", ea.ALL, ["silent", "low", "high"]),
],
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
await endpoint.read("closuresDoorLock", ["lockState"]);
await endpoint.read("manuSpecificAssaDoorLock", [
"autoLockTime",
"wrongCodeAttempts",
"shutdownTime",
"batteryLevel",
"volume",
]);
await reporting.bind(endpoint, coordinatorEndpoint, ["manuSpecificAssaDoorLock"]);
},
},
];
//# sourceMappingURL=yale.js.map