zigbee-herdsman-converters
Version:
Collection of device converters to be used with zigbee-herdsman
1,169 lines • 69.4 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 constants = __importStar(require("../lib/constants"));
const exposes = __importStar(require("../lib/exposes"));
const m = __importStar(require("../lib/modernExtend"));
const namron = __importStar(require("../lib/namron"));
const reporting = __importStar(require("../lib/reporting"));
const globalStore = __importStar(require("../lib/store"));
const tuya = __importStar(require("../lib/tuya"));
const utils = __importStar(require("../lib/utils"));
const ea = exposes.access;
const e = exposes.presets;
const sunricherManufacturer = { manufacturerCode: zigbee_herdsman_1.Zcl.ManufacturerCode.SHENZHEN_SUNRICHER_TECHNOLOGY_LTD };
const fzLocal = {
namron_panelheater: {
cluster: "hvacThermostat",
type: ["attributeReport", "readResponse"],
convert: (model, msg, publish, options, meta) => {
const result = {};
const data = msg.data;
if (data[0x1000] !== undefined) {
// OperateDisplayBrightnesss
result.display_brightnesss = data[0x1000];
}
if (data[0x1001] !== undefined) {
// DisplayAutoOffActivation
const lookup = { 0: "deactivated", 1: "activated" };
result.display_auto_off = utils.getFromLookup(data[0x1001], lookup);
}
if (data[0x1004] !== undefined) {
// PowerUpStatus
const lookup = { 0: "manual", 1: "last_state" };
result.power_up_status = utils.getFromLookup(data[0x1004], lookup);
}
if (data[0x1009] !== undefined) {
// WindowOpenCheck
const lookup = { 0: "enable", 1: "disable" };
result.window_open_check = utils.getFromLookup(data[0x1009], lookup);
}
if (data[0x100a] !== undefined) {
// Hysterersis
result.hysterersis = utils.precisionRound(data[0x100a], 2) / 10;
}
return result;
},
},
namron_thermostat2: {
cluster: "hvacThermostat",
type: ["attributeReport", "readResponse"],
options: [exposes.options.local_temperature_based_on_sensor()],
convert: (model, msg, publish, options, meta) => {
const runningModeStateMap = { 0: 0, 3: 2, 4: 5 };
// override mode "idle" - not a supported running mode
if (msg.data.runningMode === 0x10)
msg.data.runningMode = 0;
// map running *mode* to *state*, as that's what used
// in homeAssistant climate ui card (red background)
if (msg.data.runningMode !== undefined)
msg.data.runningState = runningModeStateMap[msg.data.runningMode];
return fz.thermostat.convert(model, msg, publish, options, meta); // as KeyValue;
},
},
};
const tzLocal = {
namron_panelheater: {
key: ["display_brightnesss", "display_auto_off", "power_up_status", "window_open_check", "hysterersis"],
convertSet: async (entity, key, value, meta) => {
if (key === "display_brightnesss") {
const payload = { 4096: { value: value, type: zigbee_herdsman_1.Zcl.DataType.ENUM8 } };
await entity.write("hvacThermostat", payload, sunricherManufacturer);
}
else if (key === "display_auto_off") {
const lookup = { deactivated: 0, activated: 1 };
const payload = { 4097: { value: utils.getFromLookup(value, lookup), type: zigbee_herdsman_1.Zcl.DataType.ENUM8 } };
await entity.write("hvacThermostat", payload, sunricherManufacturer);
}
else if (key === "power_up_status") {
const lookup = { manual: 0, last_state: 1 };
const payload = { 4100: { value: utils.getFromLookup(value, lookup), type: zigbee_herdsman_1.Zcl.DataType.ENUM8 } };
await entity.write("hvacThermostat", payload, sunricherManufacturer);
}
else if (key === "window_open_check") {
const lookup = { enable: 0, disable: 1 };
const payload = { 4105: { value: utils.getFromLookup(value, lookup), type: zigbee_herdsman_1.Zcl.DataType.ENUM8 } };
await entity.write("hvacThermostat", payload, sunricherManufacturer);
}
else if (key === "hysterersis") {
const payload = { 4106: { value: utils.toNumber(value, "hysterersis") * 10, type: 0x20 } };
await entity.write("hvacThermostat", payload, sunricherManufacturer);
}
},
convertGet: async (entity, key, meta) => {
switch (key) {
case "display_brightnesss":
await entity.read("hvacThermostat", [0x1000], sunricherManufacturer);
break;
case "display_auto_off":
await entity.read("hvacThermostat", [0x1001], sunricherManufacturer);
break;
case "power_up_status":
await entity.read("hvacThermostat", [0x1004], sunricherManufacturer);
break;
case "window_open_check":
await entity.read("hvacThermostat", [0x1009], sunricherManufacturer);
break;
case "hysterersis":
await entity.read("hvacThermostat", [0x100a], sunricherManufacturer);
break;
default: // Unknown key
throw new Error(`Unhandled key toZigbee.namron_panelheater.convertGet ${key}`);
}
},
},
};
exports.definitions = [
{
zigbeeModel: ["3308431"],
model: "3308431",
vendor: "Namron",
description: "Luna ceiling light",
extend: [m.light({ colorTemp: { range: [153, 370] } })],
},
{
zigbeeModel: ["3802967"],
model: "3802967",
vendor: "Namron",
description: "Led bulb 6w RGBW",
extend: [m.light({ colorTemp: { range: [153, 555] }, color: true })],
},
{
zigbeeModel: ["4512700"],
model: "4512700",
vendor: "Namron",
description: "Zigbee dimmer 400W",
ota: true,
extend: [m.light({ configureReporting: true })],
},
{
zigbeeModel: ["4512760"],
model: "4512760",
vendor: "Namron",
description: "Zigbee dimmer 400W",
ota: true,
extend: [m.light({ configureReporting: true })],
},
{
zigbeeModel: ["4512708"],
model: "4512708",
vendor: "Namron",
description: "Zigbee LED dimmer",
extend: [m.light({ configureReporting: true })],
},
{
zigbeeModel: ["4512766"],
model: "4512766",
vendor: "Namron",
description: "Zigbee smart plug 16A",
ota: true,
extend: [m.onOff(), m.electricityMeter()],
},
{
zigbeeModel: ["4512767"],
model: "4512767",
vendor: "Namron",
description: "Zigbee smart plug 16A",
ota: true,
extend: [m.onOff(), m.electricityMeter()],
},
{
zigbeeModel: ["1402767"],
model: "1402767",
vendor: "Namron",
description: "Zigbee LED dimmer",
extend: [m.light({ effect: false, configureReporting: true }), m.forcePowerSource({ powerSource: "Mains (single phase)" })],
meta: { disableDefaultResponse: true },
},
{
zigbeeModel: ["1402768"],
model: "1402768",
vendor: "Namron",
description: "Zigbee LED dimmer TW 250W",
extend: [m.light({ effect: false, configureReporting: true, colorTemp: { range: [250, 65279] } })],
},
{
zigbeeModel: ["4512733"],
model: "4512733",
vendor: "Namron",
description: "ZigBee dimmer 2-pol 400W",
extend: [m.light({ configureReporting: true })],
},
{
zigbeeModel: ["4512704"],
model: "4512704",
vendor: "Namron",
description: "Zigbee switch 400W",
extend: [m.onOff()],
ota: true,
},
{
zigbeeModel: ["1402755"],
model: "1402755",
vendor: "Namron",
description: "ZigBee LED dimmer",
extend: [m.light({ configureReporting: true })],
},
{
zigbeeModel: ["4512703"],
model: "4512703",
vendor: "Namron",
description: "Zigbee 4 channel switch K8 (white)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
exposes: [
e.battery(),
e.action([
"on_l1",
"off_l1",
"brightness_move_up_l1",
"brightness_move_down_l1",
"brightness_stop_l1",
"on_l2",
"off_l2",
"brightness_move_up_l2",
"brightness_move_down_l2",
"brightness_stop_l2",
"on_l3",
"off_l3",
"brightness_move_up_l3",
"brightness_move_down_l3",
"brightness_stop_l3",
"on_l4",
"off_l4",
"brightness_move_up_l4",
"brightness_move_down_l4",
"brightness_stop_l4",
]),
],
toZigbee: [],
meta: { multiEndpoint: true },
endpoint: (device) => {
return { l1: 1, l2: 2, l3: 3, l4: 4 };
},
ota: true,
},
{
zigbeeModel: ["4512721"],
model: "4512721",
vendor: "Namron",
description: "Zigbee 4 channel switch K8 (black)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
toZigbee: [],
meta: { multiEndpoint: true },
exposes: [
e.battery(),
e.action([
"on_l1",
"off_l1",
"brightness_move_up_l1",
"brightness_move_down_l1",
"brightness_stop_l1",
"on_l2",
"off_l2",
"brightness_move_up_l2",
"brightness_move_down_l2",
"brightness_stop_l2",
"on_l3",
"off_l3",
"brightness_move_up_l3",
"brightness_move_down_l3",
"brightness_stop_l3",
"on_l4",
"off_l4",
"brightness_move_up_l4",
"brightness_move_down_l4",
"brightness_stop_l4",
]),
],
endpoint: (device) => {
return { l1: 1, l2: 2, l3: 3, l4: 4 };
},
ota: true,
},
{
zigbeeModel: ["4512701"],
model: "4512701",
vendor: "Namron",
description: "Zigbee 1 channel switch K2 (White)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
exposes: [e.battery(), e.action(["on", "off", "brightness_move_up", "brightness_move_down", "brightness_stop"])],
toZigbee: [],
},
{
zigbeeModel: ["4512728"],
model: "4512728",
vendor: "Namron",
description: "Zigbee 1 channel switch K2 (Black)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
exposes: [e.battery(), e.action(["on", "off", "brightness_move_up", "brightness_move_down", "brightness_stop"])],
toZigbee: [],
},
{
zigbeeModel: ["1402769"],
model: "1402769",
vendor: "Namron",
description: "ZigBee LED dimmer",
extend: [m.light({ configureReporting: true }), m.forcePowerSource({ powerSource: "Mains (single phase)" })],
ota: true,
},
{
zigbeeModel: ["4512702"],
model: "4512702",
vendor: "Namron",
description: "Zigbee 1 channel switch K4",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop, fz.command_step],
exposes: [
e.battery(),
e.action(["on", "off", "brightness_move_up", "brightness_move_down", "brightness_stop", "brightness_step_up", "brightness_step_down"]),
],
toZigbee: [],
},
{
zigbeeModel: ["4512719"],
model: "4512719",
vendor: "Namron",
description: "Zigbee 2 channel switch K4 (white)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
meta: { multiEndpoint: true },
exposes: [
e.battery(),
e.action([
"on_l1",
"off_l1",
"brightness_move_up_l1",
"brightness_move_down_l1",
"brightness_stop_l1",
"on_l2",
"off_l2",
"brightness_move_up_l2",
"brightness_move_down_l2",
"brightness_stop_l2",
]),
],
toZigbee: [],
endpoint: (device) => {
return { l1: 1, l2: 2 };
},
ota: true,
},
{
fingerprint: [{ modelID: "DIM Lighting", manufacturerName: "Namron As" }],
model: "4512707",
vendor: "Namron",
description: "Zigbee LED-Controller",
extend: [m.light()],
},
{
zigbeeModel: ["4512726"],
model: "4512726",
vendor: "Namron",
description: "Zigbee 4 in 1 dimmer",
fromZigbee: [
fz.battery,
fz.command_on,
fz.command_off,
fz.command_move_to_level,
fz.command_move_to_color_temp,
fz.command_move_to_hue,
fz.ignore_genOta,
],
toZigbee: [],
exposes: [e.battery(), e.battery_voltage(), e.action(["on", "off", "brightness_move_to_level", "color_temperature_move", "move_to_hue"])],
meta: { battery: { dontDividePercentage: true } },
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
const binds = ["genBasic", "genPowerCfg", "genIdentify", "haDiagnostic", "genOta"];
await reporting.bind(endpoint, coordinatorEndpoint, binds);
await reporting.batteryPercentageRemaining(endpoint);
await reporting.batteryVoltage(endpoint);
},
ota: true,
},
{
zigbeeModel: ["4512729"],
model: "4512729",
vendor: "Namron",
description: "Zigbee 2 channel switch K4 (black)",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop],
meta: { multiEndpoint: true },
exposes: [
e.battery(),
e.action([
"on_l1",
"off_l1",
"brightness_move_up_l1",
"brightness_move_down_l1",
"brightness_stop_l1",
"on_l2",
"off_l2",
"brightness_move_up_l2",
"brightness_move_down_l2",
"brightness_stop_l2",
]),
],
toZigbee: [],
endpoint: (device) => {
return { l1: 1, l2: 2 };
},
ota: true,
},
{
zigbeeModel: ["4512706"],
model: "4512706",
vendor: "Namron",
description: "Remote control",
fromZigbee: [
fz.command_on,
fz.command_off,
fz.command_step,
fz.command_step_color_temperature,
fz.command_recall,
fz.command_move_to_color_temp,
fz.battery,
fz.command_move_to_hue,
],
exposes: [
e.battery(),
e.action([
"on",
"off",
"brightness_step_up",
"brightness_step_down",
"color_temperature_step_up",
"color_temperature_step_down",
"recall_*",
"color_temperature_move",
"move_to_hue_l1",
"move_to_hue_l2",
"move_to_hue_l3",
"move_to_hue_l4",
]),
],
toZigbee: [],
meta: { multiEndpoint: true },
endpoint: (device) => {
return { l1: 1, l2: 2, l3: 3, l4: 4 };
},
},
{
zigbeeModel: ["4512705"],
model: "4512705",
vendor: "Namron",
description: "Zigbee 4 channel remote control",
fromZigbee: [fz.command_on, fz.command_off, fz.battery, fz.command_move, fz.command_stop, fz.command_recall],
toZigbee: [],
ota: true,
exposes: [
e.battery(),
e.action([
"on_l1",
"off_l1",
"brightness_move_up_l1",
"brightness_move_down_l1",
"brightness_stop_l1",
"on_l2",
"off_l2",
"brightness_move_up_l2",
"brightness_move_down_l2",
"brightness_stop_l2",
"on_l3",
"off_l3",
"brightness_move_up_l3",
"brightness_move_down_l3",
"brightness_stop_l3",
"on_l4",
"off_l4",
"brightness_move_up_l4",
"brightness_move_down_l4",
"brightness_stop_l4",
"recall_*",
]),
],
meta: { multiEndpoint: true },
endpoint: (device) => {
return { l1: 1, l2: 2, l3: 3, l4: 4 };
},
},
{
zigbeeModel: ["3802960"],
model: "3802960",
vendor: "Namron",
description: "LED 9W DIM E27",
extend: [m.light()],
},
{
zigbeeModel: ["3802961"],
model: "3802961",
vendor: "Namron",
description: "LED 9W CCT E27",
extend: [m.light({ colorTemp: { range: [153, 370] } })],
},
{
zigbeeModel: ["3802962"],
model: "3802962",
vendor: "Namron",
description: "LED 9W RGBW E27",
extend: [m.light({ colorTemp: { range: undefined }, color: true, turnsOffAtBrightness1: true })],
},
{
zigbeeModel: ["3802963"],
model: "3802963",
vendor: "Namron",
description: "LED 5,3W DIM E14",
extend: [m.light()],
},
{
zigbeeModel: ["3802964"],
model: "3802964",
vendor: "Namron",
description: "LED 5,3W CCT E14",
extend: [m.light({ colorTemp: { range: undefined } })],
},
{
zigbeeModel: ["3802965"],
model: "3802965",
vendor: "Namron",
description: "LED 4,8W DIM GU10",
extend: [m.light()],
},
{
zigbeeModel: ["3802966"],
model: "3802966",
vendor: "Namron",
description: "LED 4.8W CCT GU10",
extend: [m.light({ colorTemp: { range: [153, 454] } })],
},
{
zigbeeModel: ["89665"],
model: "89665",
vendor: "Namron",
description: "LED Strip RGB+W (5m) IP20",
extend: [m.light({ colorTemp: { range: undefined }, color: true, turnsOffAtBrightness1: true })],
},
{
zigbeeModel: ["4512737", "4512738"],
model: "4512737/4512738",
vendor: "Namron",
description: "Touch thermostat",
fromZigbee: [fz.thermostat, fz.namron_thermostat, fz.metering, fz.electrical_measurement, fz.namron_hvac_user_interface],
toZigbee: [
tz.thermostat_occupied_heating_setpoint,
tz.thermostat_unoccupied_heating_setpoint,
tz.thermostat_occupancy,
tz.thermostat_local_temperature_calibration,
tz.thermostat_local_temperature,
tz.thermostat_outdoor_temperature,
tz.thermostat_system_mode,
tz.thermostat_control_sequence_of_operation,
tz.thermostat_running_state,
tz.namron_thermostat_child_lock,
tz.namron_thermostat,
],
exposes: [
e.local_temperature(),
e.numeric("outdoor_temperature", ea.STATE_GET).withUnit("°C").withDescription("Current temperature measured from the floor sensor"),
e
.climate()
.withSetpoint("occupied_heating_setpoint", 0, 40, 0.1)
.withLocalTemperature()
.withLocalTemperatureCalibration(-3, 3, 0.1)
.withSystemMode(["off", "auto", "dry", "heat"])
.withRunningState(["idle", "heat"]),
e.binary("away_mode", ea.ALL, "ON", "OFF").withDescription("Enable/disable away mode"),
e.binary("child_lock", ea.ALL, "LOCK", "UNLOCK").withDescription("Enables/disables physical input on the device"),
e.power(),
e.current(),
e.voltage(),
e.energy(),
e.enum("lcd_brightness", ea.ALL, ["low", "mid", "high"]).withDescription("OLED brightness when operating the buttons. Default: Medium."),
e.enum("button_vibration_level", ea.ALL, ["off", "low", "high"]).withDescription("Key beep volume and vibration level. Default: Low."),
e
.enum("floor_sensor_type", ea.ALL, ["10k", "15k", "50k", "100k", "12k"])
.withDescription("Type of the external floor sensor. Default: NTC 10K/25."),
e.enum("sensor", ea.ALL, ["air", "floor", "both"]).withDescription("The sensor used for heat control. Default: Room Sensor."),
e.enum("powerup_status", ea.ALL, ["default", "last_status"]).withDescription("The mode after a power reset. Default: Previous Mode."),
e
.numeric("floor_sensor_calibration", ea.ALL)
.withUnit("°C")
.withValueMin(-3)
.withValueMax(3)
.withValueStep(0.1)
.withDescription("The tempearatue calibration for the external floor sensor, between -3 and 3 in 0.1°C. Default: 0."),
e
.numeric("dry_time", ea.ALL)
.withUnit("min")
.withValueMin(5)
.withValueMax(100)
.withDescription("The duration of Dry Mode, between 5 and 100 minutes. Default: 5."),
e.enum("mode_after_dry", ea.ALL, ["off", "manual", "auto", "away"]).withDescription("The mode after Dry Mode. Default: Auto."),
e.enum("temperature_display", ea.ALL, ["room", "floor"]).withDescription("The temperature on the display. Default: Room Temperature."),
e
.numeric("window_open_check", ea.ALL)
.withUnit("°C")
.withValueMin(0)
.withValueMax(4)
.withValueStep(0.5)
.withDescription("The threshold to detect window open, between 1.5 and 4 in 0.5 °C. Default: 0 (disabled)."),
e
.numeric("hysterersis", ea.ALL)
.withUnit("°C")
.withValueMin(0.5)
.withValueMax(5)
.withValueStep(0.1)
.withDescription("Hysteresis setting, between 0.5 and 5 in 0.1 °C. Default: 0.5."),
e.enum("display_auto_off_enabled", ea.ALL, ["enabled", "disabled"]),
e
.numeric("alarm_airtemp_overvalue", ea.ALL)
.withUnit("°C")
.withValueMin(0)
.withValueMax(35)
.withDescription("Floor temperature over heating threshold, range is 0-35, unit is 1ºC, " +
"0 means this function is disabled, default value is 27."),
],
onEvent: (type, data, device, options) => {
const endpoint = device.getEndpoint(1);
if (type === "stop") {
clearInterval(globalStore.getValue(device, "time"));
globalStore.clearValue(device, "time");
}
else if (!globalStore.hasValue(device, "time")) {
const hours24 = 1000 * 60 * 60 * 24;
const interval = setInterval(async () => {
try {
// Device does not asks for the time with binding, therefore we write the time every 24 hours
const time = Math.round((new Date().getTime() - constants.OneJanuary2000) / 1000 + new Date().getTimezoneOffset() * -1 * 60);
const values = { time: time };
await endpoint.write("genTime", values);
}
catch {
/* Do nothing*/
}
}, hours24);
globalStore.putValue(device, "time", interval);
}
},
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
const binds = [
"genBasic",
"genIdentify",
"hvacThermostat",
"seMetering",
"haElectricalMeasurement",
"genAlarms",
"msOccupancySensing",
"genTime",
"hvacUserInterfaceCfg",
];
await reporting.bind(endpoint, coordinatorEndpoint, binds);
// standard ZCL attributes
await reporting.thermostatTemperature(endpoint, { min: 0, change: 50 });
await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
await reporting.thermostatUnoccupiedHeatingSetpoint(endpoint);
await reporting.thermostatKeypadLockMode(endpoint);
// Metering
await endpoint.read("haElectricalMeasurement", ["acVoltageMultiplier", "acVoltageDivisor", "acCurrentMultiplier"]);
await endpoint.read("haElectricalMeasurement", ["acCurrentDivisor"]);
await reporting.rmsVoltage(endpoint, { min: 10, change: 20 }); // Voltage - Min change of 2v
await reporting.rmsCurrent(endpoint, { min: 10, change: 10 }); // A - z2m displays only the first decimals, so change of 10 (0,01)
await reporting.activePower(endpoint, { min: 10, change: 15 }); // W - Min change of 1,5W
await reporting.currentSummDelivered(endpoint, { min: 300 }); // Report KWH every 5min
await reporting.readMeteringMultiplierDivisor(endpoint);
// OperateDisplayLcdBrightnesss
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1000, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// ButtonVibrationLevel
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1001, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// FloorSensorType
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1002, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// ControlType
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1003, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// PowerUpStatus
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1004, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// FloorSensorCalibration
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1005, type: 0x28 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: 0,
},
], sunricherManufacturer);
// DryTime
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1006, type: 0x20 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: 0,
},
], sunricherManufacturer);
// ModeAfterDry
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1007, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// TemperatureDisplay
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1008, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// WindowOpenCheck
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1009, type: 0x20 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: 0,
},
], sunricherManufacturer);
// Hysterersis
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x100a, type: 0x20 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: 0,
},
], sunricherManufacturer);
// DisplayAutoOffEnable
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x100b, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// AlarmAirTempOverValue
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x2001, type: 0x20 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: 0,
},
], sunricherManufacturer);
// Away Mode Set
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x2002, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// Trigger initial read
await endpoint.read("hvacThermostat", ["systemMode", "runningState", "occupiedHeatingSetpoint"]);
await endpoint.read("hvacThermostat", [0x1000, 0x1001, 0x1002, 0x1003], sunricherManufacturer);
await endpoint.read("hvacThermostat", [0x1004, 0x1005, 0x1006, 0x1007], sunricherManufacturer);
await endpoint.read("hvacThermostat", [0x1008, 0x1009, 0x100a, 0x100b], sunricherManufacturer);
await endpoint.read("hvacThermostat", [0x2001, 0x2002], sunricherManufacturer);
},
ota: true,
},
{
zigbeeModel: ["4512735"],
model: "4512735",
vendor: "Namron",
description: "Multiprise with 4 AC outlets and 2 USB super charging ports (16A)",
fromZigbee: [fz.on_off],
toZigbee: [tz.on_off],
exposes: [
e.switch().withEndpoint("l1"),
e.switch().withEndpoint("l2"),
e.switch().withEndpoint("l3"),
e.switch().withEndpoint("l4"),
e.switch().withEndpoint("l5"),
],
endpoint: (device) => {
return { l1: 1, l2: 2, l3: 3, l4: 4, l5: 5 };
},
meta: { multiEndpoint: true },
configure: async (device, coordinatorEndpoint) => {
for (const ID of [1, 2, 3, 4, 5]) {
const endpoint = device.getEndpoint(ID);
await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff"]);
}
device.powerSource = "Mains (single phase)";
device.save();
},
},
{
zigbeeModel: ["5401392", "5401396", "5401393", "5401397", "5401394", "5401398", "5401395", "5401399"],
model: "540139X",
vendor: "Namron",
description: "Panel heater 400/600/800/1000 W",
ota: true,
fromZigbee: [fz.thermostat, fz.metering, fz.electrical_measurement, fzLocal.namron_panelheater, fz.namron_hvac_user_interface],
toZigbee: [
tz.thermostat_occupied_heating_setpoint,
tz.thermostat_local_temperature_calibration,
tz.thermostat_system_mode,
tz.thermostat_running_state,
tz.thermostat_local_temperature,
tzLocal.namron_panelheater,
tz.namron_thermostat_child_lock,
],
exposes: [
e.power(),
e.current(),
e.voltage(),
e.energy(),
e
.climate()
.withSetpoint("occupied_heating_setpoint", 5, 35, 0.5)
.withLocalTemperature()
// Unit also supports Auto, but i haven't added support the scheduler yet
// so the function is not listed for now, as this doesn´t allow you the set the temperature
.withSystemMode(["off", "heat"])
.withLocalTemperatureCalibration(-3, 3, 0.1)
.withRunningState(["idle", "heat"]),
// Namron proprietary stuff
e
.binary("child_lock", ea.ALL, "LOCK", "UNLOCK")
.withDescription("Enables/disables physical input on the device"),
e
.numeric("hysterersis", ea.ALL)
.withUnit("°C")
.withValueMin(0.5)
.withValueMax(2)
.withValueStep(0.1)
.withDescription("Hysteresis setting, default: 0.5"),
e
.numeric("display_brightnesss", ea.ALL)
.withValueMin(1)
.withValueMax(7)
.withValueStep(1)
.withDescription("Adjust brightness of display values 1(Low)-7(High)"),
e.enum("display_auto_off", ea.ALL, ["deactivated", "activated"]).withDescription("Enable / Disable display auto off"),
e
.enum("power_up_status", ea.ALL, ["manual", "last_state"])
.withDescription("The mode after a power reset. Default: Previous Mode. See instructions for information about manual"),
e.enum("window_open_check", ea.ALL, ["enable", "disable"]).withDescription("Turn on/off window check mode"),
],
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
const binds = [
"genBasic",
"genIdentify",
"hvacThermostat",
"seMetering",
"haElectricalMeasurement",
"genAlarms",
"genTime",
"hvacUserInterfaceCfg",
];
// Reporting
// Metering
await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
await reporting.readMeteringMultiplierDivisor(endpoint);
await reporting.rmsVoltage(endpoint, { min: 10, change: 20 }); // Voltage - Min change of 2v
await reporting.rmsCurrent(endpoint, { min: 10, change: 10 }); // A - z2m displays only the first decimals, so change of 10 (0,01)
await reporting.activePower(endpoint, { min: 10, change: 15 }); // W - Min change of 1,5W
await reporting.currentSummDelivered(endpoint, { min: 300 }); // Report KWH every 5min
// Thermostat reporting
await reporting.thermostatTemperature(endpoint);
await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
await reporting.thermostatTemperature(endpoint);
await reporting.thermostatKeypadLockMode(endpoint);
// LocalTemp is spammy, reports 0.01C diff by default, min change is now 0.5C
await reporting.thermostatTemperature(endpoint, { min: 0, change: 50 });
// display_brightnesss
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1000, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// display_auto_off
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1001, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// power_up_status
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1004, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// window_open_check
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x1009, type: 0x30 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
// hysterersis
await endpoint.configureReporting("hvacThermostat", [
{
attribute: { ID: 0x100a, type: 0x20 },
minimumReportInterval: 0,
maximumReportInterval: constants.repInterval.HOUR,
reportableChange: null,
},
], sunricherManufacturer);
await endpoint.read("hvacThermostat", ["systemMode", "runningState", "occupiedHeatingSetpoint"]);
await endpoint.read("hvacUserInterfaceCfg", ["keypadLockout"]);
await endpoint.read("hvacThermostat", [0x1000, 0x1001, 0x1004, 0x1009, 0x100a], sunricherManufacturer);
await reporting.bind(endpoint, coordinatorEndpoint, binds);
},
},
{
zigbeeModel: ["3802968"],
model: "3802968",
vendor: "Namron",
description: "LED Filament Flex 5W CCT E27 Clear",
extend: [m.light({ colorTemp: { range: [153, 555] }, turnsOffAtBrightness1: true })],
},
{
zigbeeModel: ["4512749"],
model: "4512749",
vendor: "Namron",
description: "Thermostat outlet socket",
fromZigbee: [fz.metering, fz.electrical_measurement, fz.on_off, fz.temperature],
toZigbee: [tz.on_off, tz.power_on_behavior],
exposes: [e.temperature(), e.power(), e.current(), e.voltage(), e.switch(), e.power_on_behavior()],
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "haElectricalMeasurement", "msTemperatureMeasurement"]);
await endpoint.read("haElectricalMeasurement", ["acVoltageMultiplier", "acVoltageDivisor"]);
await endpoint.read("haElectricalMeasurement", ["acPowerMultiplier", "acPowerDivisor"]);
await endpoint.read("haElectricalMeasurement", ["acCurrentMultiplier", "acCurrentDivisor"]);
await reporting.onOff(endpoint);
await reporting.temperature(endpoint);
await reporting.rmsVoltage(endpoint);
await reporting.rmsCurrent(endpoint);
await reporting.activePower(endpoint);
},
},
{
zigbeeModel: ["4512749-N"],
model: "4512749-N",
vendor: "Namron",
description: "Thermostat outlet socket",
fromZigbee: [fz.metering, fz.electrical_measurement, fz.on_off, fz.temperature],
toZigbee: [tz.on_off, tz.power_on_behavior],
exposes: [e.temperature(), e.power(), e.current(), e.voltage(), e.switch(), e.power_on_behavior()],
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ["genOnOff", "haElectricalMeasurement", "msTemperatureMeasurement"]);
await endpoint.read("haElectricalMeasurement", ["acVoltageMultiplier", "acVoltageDivisor"]);
await endpoint.read("haElectricalMeasurement", ["acPowerMultiplier", "acPowerDivisor"]);
await endpoint.read("haElectricalMeasurement", ["acCurrentMultiplier", "acCurrentDivisor"]);
await reporting.onOff(endpoint);
await reporting.temperature(endpoint, { min: 10, change: 10 });
await reporting.rmsVoltage(endpoint, { min: 10, change: 20 }); // Voltage - Min change of 2v
await reporting.rmsCurrent(endpoint, { min: 10, change: 10 }); // A - z2m displays only the first decimals, so change of 10
await reporting.activePower(endpoint, { min: 10, change: 1 }); // W - Min change of 0,1W
},
},
{
zigbeeModel: ["4512747"],
model: "4512747",
vendor: "Namron",
description: "Curtain motor controller",
fromZigbee: [fz.cover_position_tilt],
toZigbee: [tz.cover_state, tz.cover_position_tilt],
exposes: [e.cover_position()],
configure: async (device, coordinatorEndpoint) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ["closuresWindowCovering"]);
await reporting.currentPositionLiftPercentage(endpoint);
},
},
{
zigbeeModel: ["4512758"],
model: "4512758",
vendor: "Namron",
description: "Zigbee thermostat 16A",
fromZigbee: [fzLocal.namron_thermostat2, fz.metering, fz.electrical_measurement, fz.namron_hvac_user_interface],
toZigbee: [
{
// map running *mode* to *state*, as that's what used
// in homeAssistant climate ui card (red background)
key: ["running_state"],
convertGet: async (entity, key, meta) => {
await entity.read("hvacThermostat", ["runningMode"]);
},
},
tz.thermostat_local_temperature,
tz.thermostat_min_heat_setpoint_limit,
tz.thermostat_max_heat_setpoint_limit,
// tz.thermostat_min_cool_setpoint_limit,
// tz.thermostat_max_cool_setpoint_limit,
// tz.thermostat_pi_heating_demand,
tz.thermostat_local_temperature_calibration,
// tz.thermostat_occupied_cooling_setpoint,
tz.thermostat_occupied_heating_setpoint,
tz.thermostat_control_sequence_of_operation,
tz.thermostat_system_mode,
tz.thermostat_running_mode,
tz.namron_thermostat_child_lock,
],
extend: [
m.onOff({ powerOnBehavior: false }),
m.electricityMeter({ voltage: false }),
m.binary({
name: "away_mode",
valueOn: ["ON", 1],
valueOff: ["OFF", 0],
cluster: "hvacThermostat",
attribute: { ID: 0x8001, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
description: "Enable or Disable Away/Anti-freeze mode",
}),
m.binary({
name: "window_open_check",
valueOn: ["ON", 1],
valueOff: ["OFF", 0],
cluster: "hvacThermostat",
attribute: { ID: 0x8000, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
description: "Enable or Disable open window detection",
entityCategory: "config",
}),
m.binary({
name: "window_open",
valueOn: ["ON", 1],
valueOff: ["OFF", 0],
cluster: "hvacThermostat",
attribute: { ID: 0x8002, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
description: "On if window is currently detected as open",
}),
m.numeric({
name: "backlight_level",
unit: "%",
valueMin: 0,
valueMax: 100,
valueStep: 10,
cluster: "hvacThermostat",
attribute: { ID: 0x8005, type: zigbee_herdsman_1.Zcl.DataType.UINT8 },
description: "Brightness of the display",
entityCategory: "config",
}),
m.binary({
name: "backlight_onoff",
valueOn: ["ON", 1],
valueOff: ["OFF", 0],
cluster: "hvacThermostat",
attribute: { ID: 0x8009, type: zigbee_herdsman_1.Zcl.DataType.BOOLEAN },
description: "Enable or Disable display light",
entityCategory: "config",
}),
m.enumLookup({
name: "sensor_mode",
lookup: { air: 0, floor: 1, both: 2, percent: 6 },
cluster: "hvacThermostat",
attribute: { ID: 0x8004, type: zigbee_herdsman_1.Zcl.DataType.ENUM8 },
description: "Select which sensor the thermostat uses to control the room",
entityCategory: "config",
}),
],
exposes: [
// FUTURE: could maybe translate to a common cooling/heating setpoint depending on the mode
// and state.. HomeAssistant climate widget doesn't play nice with two setpoints.
e
.climate()
.withLocalTemperature()
.withSetpoint("occupied_heating_setpoint", 0, 40, 0.5)
//.withSetpoint('occupied_cooling_setpoint', 0, 40, 0.5)
.withLocalTemperatureCalibration(-10, 10, 1)
//.withSystemMode(['off', 'auto', 'cool', 'heat'])
.withSystemMode(["off", "heat"])
//.withRunningMode(['off', 'cool','heat'])
.withRunningState(["idle", "cool", "heat"]),
//.withPiHeatingDemand()
e
.binary("child_lock", ea.ALL, "LOCK", "UNLOCK")
.withDescription("Enables/disables physical input on the device"),
],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEn