zigbee-herdsman-converters
Version:
Collection of device converters to be used with zigbee-herdsman
982 lines (980 loc) • 48.3 kB
JavaScript
const exposes = require('../lib/exposes');
const fz = {...require('../converters/fromZigbee'), legacy: require('../lib/legacy').fromZigbee};
const tz = require('../converters/toZigbee');
const globalStore = require('../lib/store');
const ota = require('../lib/ota');
const tuya = require('../lib/tuya');
const reporting = require('../lib/reporting');
const extend = require('../lib/extend');
const e = exposes.presets;
const ea = exposes.access;
module.exports = [
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_bq5c8xfe'}],
model: 'TS0601_temperature_humidity_sensor',
vendor: 'Tuya',
description: 'Temperature & humidity sensor',
fromZigbee: [fz.tuya_temperature_humidity_sensor],
toZigbee: [],
exposes: [e.temperature(), e.humidity(), e.battery()],
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_8ygsuhe1'}],
model: 'TS0601_air_quality_sensor',
vendor: 'Tuya',
description: 'Air quality sensor',
fromZigbee: [fz.tuya_air_quality],
toZigbee: [],
exposes: [e.temperature(), e.humidity(), e.co2(), e.voc(), e.formaldehyd()],
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_ggev5fsl'}],
model: 'TS0601_gas_sensor',
vendor: 'TuYa',
description: 'gas sensor',
fromZigbee: [fz.tuya_gas],
toZigbee: [],
exposes: [e.gas()],
},
{
fingerprint: [{modelID: 'TS0001', manufacturerName: '_TZ3000_hktqahrq'}, {manufacturerName: '_TZ3000_hktqahrq'}],
model: 'WHD02',
vendor: 'TuYa',
description: 'Wall switch module',
toZigbee: extend.switch().toZigbee.concat([tz.moes_power_on_behavior]),
fromZigbee: extend.switch().fromZigbee.concat([fz.moes_power_on_behavior]),
exposes: extend.switch().exposes.concat([exposes.enum('power_on_behavior', ea.ALL, ['off', 'previous', 'on'])
.withDescription('Controls the behaviour when the device is powered on')]),
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
},
},
{
fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_mvn6jl7x'},
{modelID: 'TS011F', manufacturerName: '_TZ3000_raviyuvk'}, {modelID: 'TS011F', manufacturerName: '_TYZB01_hlla45kx'}],
model: 'TS011F_2_gang_wall',
vendor: 'TuYa',
description: '2 gang wall outlet',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2')],
endpoint: (device) => {
return {'l1': 1, 'l2': 2};
},
meta: {multiEndpoint: true},
},
{
fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_rk2yzt0u'},
{modelID: 'TS0001', manufacturerName: '_TZ3000_o4cjetlm'}, {manufacturerName: '_TZ3000_o4cjetlm'}],
model: 'ZN231392',
vendor: 'TuYa',
description: 'Smart water/gas valve',
extend: extend.switch(),
},
{
fingerprint: [{modelID: 'TS0505B', manufacturerName: '_TZ3000_qqjaziws'},
{modelID: 'TS0505B', manufacturerName: '_TZ3000_jtmhndw2'}],
model: 'TS0505B',
vendor: 'TuYa',
description: 'Zigbee smart mini led strip controller 5V/12V/24V RGB+CCT',
extend: extend.light_onoff_brightness_colortemp_color(),
meta: {applyRedFix: true, enhancedHue: false},
},
{
fingerprint: [{modelID: 'TS0503B', manufacturerName: '_TZ3000_i8l0nqdu'}],
model: 'TS0503B',
vendor: 'TuYa',
description: 'Zigbee smart mini led strip controller 5V/12V/24V RGB',
extend: extend.light_onoff_brightness_color(),
// Requires red fix: https://github.com/Koenkk/zigbee2mqtt/issues/5962#issue-796462106
meta: {applyRedFix: true, enhancedHue: false},
},
{
fingerprint: [{modelID: 'TS0504B', manufacturerName: '_TZ3000_ukuvyhaa'}],
model: 'TS0504B',
vendor: 'TuYa',
description: 'Zigbee smart mini led strip controller 5V/12V/24V RGBW',
extend: extend.light_onoff_brightness_color(),
meta: {applyRedFix: true},
},
{
fingerprint: [{modelID: 'TS0501B', manufacturerName: '_TZ3000_4whigl8i'}],
model: 'TS0501B',
description: 'Zigbee smart mini led strip controller single color',
vendor: 'TuYa',
extend: extend.light_onoff_brightness(),
},
{
fingerprint: [{modelID: 'TS0202', manufacturerName: '_TYZB01_ef5xlc9q'},
{modelID: 'TS0202', manufacturerName: '_TYZB01_vwqnz1sn'},
{modelID: 'TS0202', manufacturerName: '_TYZB01_2b8f6cio'}],
model: 'TS0202',
vendor: 'TuYa',
description: 'Motion sensor',
fromZigbee: [fz.ias_occupancy_alarm_1, fz.battery, fz.ignore_basic_report],
toZigbee: [],
exposes: [e.occupancy(), e.battery_low(), e.tamper(), e.battery()],
},
{
fingerprint: [{modelID: 'TS0207', manufacturerName: '_TZ3000_m0vaazab'},
{modelID: 'TS0207', manufacturerName: '_TZ3000_ufttklsz'}],
model: 'TS0207_repeater',
vendor: 'TuYa',
description: 'Repeater',
fromZigbee: [fz.linkquality_from_basic],
toZigbee: [],
exposes: [],
},
{
fingerprint: [{modelID: 'TS0101', manufacturerName: '_TYZB01_ijihzffk'}],
model: 'TS0101',
vendor: 'TuYa',
description: 'Zigbee Socket',
whiteLabel: [{vendor: 'Larkkey', model: 'PS080'}],
extend: extend.switch(),
meta: {disableDefaultResponse: true},
},
{
fingerprint: [{modelID: 'TS0108', manufacturerName: '_TYZB01_7yidyqxd'}],
model: 'TS0108',
vendor: 'TuYa',
description: 'Socket with 2 USB',
whiteLabel: [{vendor: 'Larkkey', model: 'PS580'}],
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2')],
endpoint: (device) => {
return {'l1': 1, 'l2': 7};
},
meta: {multiEndpoint: true, disableDefaultResponse: true},
configure: async (device, coordinatorEndpoint) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(7), coordinatorEndpoint, ['genOnOff']);
},
},
{
fingerprint: [
{modelID: 'TS0601', manufacturerName: '_TZE200_whpb9yts'},
{modelID: 'TS0601', manufacturerName: '_TZE200_ebwgzdqq'},
{modelID: 'TS0601', manufacturerName: '_TZE200_9i9dt8is'},
{modelID: 'TS0601', manufacturerName: '_TZE200_dfxkcots'},
],
model: 'TS0601_dimmer',
vendor: 'TuYa',
description: 'Zigbee smart dimmer',
fromZigbee: [fz.tuya_dimmer, fz.ignore_basic_report],
toZigbee: [tz.tuya_dimmer_state, tz.tuya_dimmer_level],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
},
exposes: [e.light_brightness().setAccess('state', ea.STATE_SET).setAccess('brightness', ea.STATE_SET)],
whiteLabel: [
{vendor: 'Larkkey', model: 'ZSTY-SM-1DMZG-EU'},
{vendor: 'Earda', model: 'EDM-1ZAA-EU'},
{vendor: 'Earda', model: 'EDM-1ZAB-EU'},
{vendor: 'Earda', model: 'EDM-1ZBA-EU'},
],
},
{
fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_oiymh3qu'}],
model: 'TS011F_socket_module',
vendor: 'TuYa',
description: 'Socket module',
extend: extend.switch(),
whiteLabel: [{vendor: 'LoraTap', model: 'RR400ZB'}],
},
{
fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_wxtp7c5y'}],
model: 'TS011F_wall_outlet',
vendor: 'TuYa',
description: 'In-wall outlet',
extend: extend.switch(),
whiteLabel: [{vendor: 'Teekar', model: 'SWP86-01OG'}],
},
{
zigbeeModel: ['TS130F'],
model: 'TS130F',
vendor: 'TuYa',
description: 'Curtain/blind switch',
fromZigbee: [fz.cover_position_tilt, fz.tuya_backlight_mode, fz.tuya_cover_options],
toZigbee: [tz.cover_state, tz.cover_position_tilt, tz.tuya_cover_calibration, tz.tuya_cover_reversal, tz.tuya_backlight_mode],
whiteLabel: [{vendor: 'LoraTap', model: 'SC400'}],
exposes: [e.cover_position(), exposes.enum('moving', ea.STATE, ['UP', 'STOP', 'DOWN']),
exposes.binary('calibration', ea.ALL, 'ON', 'OFF'),
exposes.enum('backlight_mode', ea.ALL, ['LOW', 'MEDIUM', 'HIGH']),
exposes.binary('motor_reversal', ea.ALL, 'ON', 'OFF')],
},
{
zigbeeModel: ['qnazj70', 'kjintbl'],
fingerprint: [
{modelID: 'TS0601', manufacturerName: '_TZE200_wunufsil'},
{modelID: 'TS0601', manufacturerName: '_TZE200_vhy3iakz'},
{modelID: 'TS0601', manufacturerName: '_TZE200_oisqyl4o'},
{modelID: 'TS0601', manufacturerName: '_TZ3000_uim07oem'},
],
model: 'TS0601_switch',
vendor: 'TuYa',
description: '1, 2, 3 or 4 gang switch',
exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET), e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET)],
fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
toZigbee: [tz.tuya_switch_state],
meta: {multiEndpoint: true},
whiteLabel: [
{vendor: 'Norklmes', model: 'MKS-CM-W5'},
{vendor: 'Somgoms', model: 'ZSQB-SMB-ZB'},
{vendor: 'Moes', model: 'WS-EUB1-ZG'},
{vendor: 'AVATTO', model: 'ZGB-WS-EU'},
],
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
if (device.getEndpoint(3)) await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
if (device.getEndpoint(4)) await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
},
endpoint: (device) => {
// Endpoint selection is made in tuya_switch_state
return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1};
},
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_aqnazj70'}],
model: 'TS0601_switch_4_gang',
vendor: 'TuYa',
description: '4 gang switch',
exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l4').setAccess('state', ea.STATE_SET)],
fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
toZigbee: [tz.tuya_switch_state],
meta: {multiEndpoint: true},
endpoint: (device) => {
// Endpoint selection is made in tuya_switch_state
return {'l1': 1, 'l2': 1, 'l3': 1, 'l4': 1};
},
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_nkjintbl'}],
model: 'TS0601_switch_2_gang',
vendor: 'TuYa',
description: '2 gang switch',
exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET)],
fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
toZigbee: [tz.tuya_switch_state],
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
if (device.getEndpoint(2)) await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
},
endpoint: (device) => {
// Endpoint selection is made in tuya_switch_state
return {'l1': 1, 'l2': 1};
},
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_kyfqmmyl'}],
model: 'TS0601_switch_3_gang',
vendor: 'TuYa',
description: '3 gang switch',
exposes: [e.switch().withEndpoint('l1').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l2').setAccess('state', ea.STATE_SET),
e.switch().withEndpoint('l3').setAccess('state', ea.STATE_SET)],
fromZigbee: [fz.ignore_basic_report, fz.tuya_switch],
toZigbee: [tz.tuya_switch_state],
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
},
endpoint: (device) => {
// Endpoint selection is made in tuya_switch_state
return {'l1': 1, 'l2': 1, 'l3': 1};
},
},
{
fingerprint: [{modelID: 'TS0215A', manufacturerName: '_TZ3000_4fsgukof'},
{modelID: 'TS0215A', manufacturerName: '_TZ3000_wr2ucaj9'}],
model: 'TS0215A_sos',
vendor: 'TuYa',
description: 'SOS button',
fromZigbee: [fz.command_emergency, fz.battery],
exposes: [e.battery(), e.action(['emergency'])],
toZigbee: [],
},
{
fingerprint: [{modelID: 'TS0215A', manufacturerName: '_TZ3000_p6ju8myv'},
{modelID: 'TS0215A', manufacturerName: '_TZ3000_fsiepnrh'}],
model: 'TS0215A_remote',
vendor: 'TuYa',
description: 'Security remote control',
fromZigbee: [fz.command_arm, fz.command_emergency, fz.battery],
exposes: [e.battery(), e.action(['disarm', 'arm_day_zones', 'arm_night_zones', 'arm_all_zones', 'exit_delay', 'emergency'])],
toZigbee: [],
whiteLabel: [{vendor: 'Woox', model: 'R7054'}, {vendor: 'Nedis', model: 'ZBRC10WT'}],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg', 'genTime', 'genBasic', 'ssIasAce', 'ssIasZone']);
},
},
{
fingerprint: [{modelID: 'TS0503A', manufacturerName: '_TZ3000_obacbukl'}],
model: 'TS0503A',
vendor: 'TuYa',
description: 'Led strip controller',
extend: extend.light_onoff_brightness_color(),
},
{
zigbeeModel: ['TS0503A'],
model: 'TYZS1L',
vendor: 'TuYa',
description: 'Led strip controller HSB',
exposes: [e.light_colorhs()],
fromZigbee: [fz.on_off, fz.tuya_led_controller],
toZigbee: [tz.tuya_led_controller, tz.ignore_transition, tz.ignore_rate],
},
{
zigbeeModel: ['TS0502A'],
model: 'TS0502A',
vendor: 'TuYa',
description: 'Light controller',
extend: extend.light_onoff_brightness_colortemp(),
},
{
fingerprint: [{modelID: 'TS0504A', manufacturerName: '_TZ3000_nzbm4ad4'}],
model: 'TS0504A',
vendor: 'TuYa',
description: 'RGBW LED controller',
extend: extend.light_onoff_brightness_colortemp_color(),
},
{
fingerprint: [{modelID: 'TS0505A', manufacturerName: '_TZ3000_sosdczdl'}],
model: 'TS0505A_led',
vendor: 'TuYa',
description: 'RGB+CCT LED',
toZigbee: [tz.on_off, tz.tuya_led_control],
fromZigbee: [fz.on_off, fz.tuya_led_controller, fz.brightness, fz.ignore_basic_report],
exposes: [e.light_brightness_colortemp_colorhs().removeFeature('color_temp_startup')],
},
{
zigbeeModel: ['TS0505A'],
model: 'TS0505A',
vendor: 'TuYa',
description: 'RGB+CCT light controller',
extend: extend.light_onoff_brightness_colortemp_color(),
},
{
fingerprint: [
{type: 'EndDevice', manufacturerID: 4098, endpoints: [{ID: 1, inputClusters: [], outputClusters: []}]},
{manufacturerName: '_TZ2000_a476raq2'},
],
zigbeeModel: ['TS0201', 'SNTZ003'],
model: 'TS0201',
vendor: 'TuYa',
description: 'Temperature & humidity sensor with display',
fromZigbee: [fz.battery, fz.temperature, fz.humidity],
toZigbee: [],
exposes: [e.battery(), e.temperature(), e.humidity(), e.battery_voltage()],
},
{
zigbeeModel: ['TS0041'],
model: 'TS0041',
vendor: 'TuYa',
description: 'Wireless switch with 1 button',
whiteLabel: [{vendor: 'Smart9', model: 'S9TSZGB'}, {vendor: 'Lonsonho', model: 'TS0041'}],
exposes: [e.battery(), e.action(['single', 'double', 'hold'])],
fromZigbee: [fz.tuya_on_off_action, fz.battery],
toZigbee: [],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
try {
await reporting.batteryPercentageRemaining(endpoint);
} catch (error) {/* Fails for some: https://github.com/Koenkk/zigbee2mqtt/issues/6313 */}
},
},
{
zigbeeModel: ['TS0042'],
model: 'TS0042',
vendor: 'TuYa',
description: 'Wireless switch with 2 buttons',
whiteLabel: [{vendor: 'Smart9', model: 'S9TSZGB'}, {vendor: 'Lonsonho', model: 'TS0042'}],
exposes: [e.battery(), e.action(['1_single', '1_double', '1_hold', '2_single', '2_double', '2_hold'])],
fromZigbee: [fz.tuya_on_off_action, fz.battery],
toZigbee: [],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
await reporting.batteryPercentageRemaining(endpoint);
},
},
{
zigbeeModel: ['TS0043'],
model: 'TS0043',
vendor: 'TuYa',
description: 'Wireless switch with 3 buttons',
whiteLabel: [{vendor: 'Smart9', model: 'S9TSZGB'}, {vendor: 'Lonsonho', model: 'TS0043'}, {vendor: 'LoraTap', model: 'SS600ZB'}],
exposes: [e.battery(),
e.action(['1_single', '1_double', '1_hold', '2_single', '2_double', '2_hold', '3_single', '3_double', '3_hold'])],
fromZigbee: [fz.tuya_on_off_action, fz.battery],
toZigbee: [],
},
{
zigbeeModel: ['TS0044'],
model: 'TS0044',
vendor: 'TuYa',
description: 'Wireless switch with 4 buttons',
whiteLabel: [{vendor: 'Lonsonho', model: 'TS0044'}, {vendor: 'Haozee', model: 'ESW-OZAA-EU'}],
fromZigbee: [fz.tuya_on_off_action, fz.battery],
exposes: [e.battery(), e.action(['1_single', '1_double', '1_hold', '2_single', '2_double', '2_hold',
'3_single', '3_double', '3_hold', '4_single', '4_double', '4_hold'])],
toZigbee: [],
},
{
zigbeeModel: ['TS0001'],
model: 'TS0001',
vendor: 'TuYa',
description: '1 gang switch',
extend: extend.switch(),
whiteLabel: [{vendor: 'CR Smart Home', model: 'TS0001', description: 'Valve control'}, {vendor: 'Lonsonho', model: 'X701'},
{vendor: 'Bandi', model: 'BDS03G1'}],
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
},
},
{
zigbeeModel: ['TS0002'],
model: 'TS0002',
vendor: 'TuYa',
description: '2 gang switch',
whiteLabel: [{vendor: 'Zemismart', model: 'ZM-CSW002-D_switch'}, {vendor: 'Lonsonho', model: 'X702'}],
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2')],
endpoint: (device) => {
return {'l1': 1, 'l2': 2};
},
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
},
},
{
zigbeeModel: [
'owvfni3\u0000', 'owvfni3', 'u1rkty3', 'aabybja', // Curtain motors
'mcdj3aq', 'mcdj3aq\u0000', // Tubular motors
],
fingerprint: [
// Curtain motors:
{modelID: 'TS0601', manufacturerName: '_TZE200_5zbp6j0u'},
{modelID: 'TS0601', manufacturerName: '_TZE200_nkoabg8w'},
{modelID: 'TS0601', manufacturerName: '_TZE200_xuzcvlku'},
{modelID: 'TS0601', manufacturerName: '_TZE200_4vobcgd3'},
{modelID: 'TS0601', manufacturerName: '_TZE200_nogaemzt'},
{modelID: 'TS0601', manufacturerName: '_TZE200_pk0sfzvr'},
{modelID: 'TS0601', manufacturerName: '_TZE200_fdtjuw7u'},
{modelID: 'TS0601', manufacturerName: '_TZE200_zpzndjez'},
{modelID: 'TS0601', manufacturerName: '_TZE200_wmcdj3aq'},
{modelID: 'TS0601', manufacturerName: '_TZE200_cowvfni3'},
{modelID: 'TS0601', manufacturerName: '_TZE200_rddyvrci'},
{modelID: 'TS0601', manufacturerName: '_TZE200_nueqqe6k'},
{modelID: 'zo2pocs\u0000', manufacturerName: '_TYST11_fzo2pocs'},
// Roller blinds:
{modelID: 'TS0601', manufacturerName: '_TZE200_sbordckq'},
{modelID: 'TS0601', manufacturerName: '_TZE200_fctwhugx'},
{modelID: 'TS0601', manufacturerName: '_TZE200_zah67ekd'},
// Window pushers:
{modelID: 'TS0601', manufacturerName: '_TZE200_g5wdnuow'},
// Tubular motors:
{modelID: 'TS0601', manufacturerName: '_TZE200_fzo2pocs'},
{modelID: 'TS0601', manufacturerName: '_TZE200_5sbebbzs'},
],
model: 'TS0601_cover',
vendor: 'TuYa',
description: 'Curtain motor/roller blind motor/window pusher/tubular motor',
whiteLabel: [
{vendor: 'Yushun', model: 'YS-MT750'},
{vendor: 'Zemismart', model: 'ZM79E-DT'},
{vendor: 'Binthen', model: 'BCM100D'},
{vendor: 'Binthen', model: 'CV01A'},
{vendor: 'Zemismart', model: 'M515EGB'},
{vendor: 'Tuya', model: 'M515EGZT'},
{vendor: 'TuYa', model: 'DT82LEMA-1.2N'},
{vendor: 'Moes', model: 'AM43-0.45/40-ES-EB'},
{vendor: 'Larkkey', model: 'ZSTY-SM-1SRZG-EU'},
{vendor: 'Zemismart', model: 'ZM25TQ', description: 'Tubular motor'},
{vendor: 'Zemismart', model: 'AM43', description: 'Roller blind motor'},
{vendor: 'Zemismart', model: 'M2805EGBZTN', description: 'Tubular motor'},
],
fromZigbee: [fz.tuya_cover, fz.ignore_basic_report],
toZigbee: [tz.tuya_cover_control, tz.tuya_cover_options],
exposes: [
e.cover_position().setAccess('position', ea.STATE_SET),
exposes.composite('options', 'options')
.withFeature(exposes.numeric('motor_speed', ea.STATE_SET)
.withValueMin(0)
.withValueMax(255)
.withDescription('Motor speed'))],
},
{
zigbeeModel: ['kud7u2l'],
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_ckud7u2l'}, {modelID: 'TS0601', manufacturerName: '_TZE200_ywdxldoj'},
{modelID: 'TS0601', manufacturerName: '_TZE200_cwnjrr72'}],
model: 'TS0601_thermostat',
vendor: 'TuYa',
description: 'Radiator valve with thermostat',
whiteLabel: [{vendor: 'Moes', model: 'HY368'}, {vendor: 'Moes', model: 'HY369RT'}, {vendor: 'SHOJZJ', model: '378RT'}],
meta: {tuyaThermostatPreset: tuya.thermostatPresets, tuyaThermostatSystemMode: tuya.thermostatSystemModes3},
ota: ota.zigbeeOTA,
onEvent: tuya.onEventSetLocalTime,
fromZigbee: [fz.tuya_thermostat, fz.ignore_basic_report, fz.ignore_tuya_set_time],
toZigbee: [tz.tuya_thermostat_child_lock, tz.tuya_thermostat_window_detection, tz.tuya_thermostat_valve_detection,
tz.tuya_thermostat_current_heating_setpoint, tz.tuya_thermostat_auto_lock,
tz.tuya_thermostat_calibration, tz.tuya_thermostat_min_temp, tz.tuya_thermostat_max_temp,
tz.tuya_thermostat_boost_time, tz.tuya_thermostat_comfort_temp, tz.tuya_thermostat_eco_temp,
tz.tuya_thermostat_force_to_mode, tz.tuya_thermostat_force, tz.tuya_thermostat_preset, tz.tuya_thermostat_away_mode,
tz.tuya_thermostat_window_detect, tz.tuya_thermostat_schedule, tz.tuya_thermostat_week, tz.tuya_thermostat_away_preset],
exposes: [
e.child_lock(), e.window_detection(), e.battery_low(), e.valve_detection(), e.position(),
exposes.climate().withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
.withLocalTemperature(ea.STATE).withSystemMode(['heat', 'auto', 'off'], ea.STATE_SET)
.withLocalTemperatureCalibration(ea.STATE_SET)
.withAwayMode().withPreset(['schedule', 'manual', 'boost', 'complex', 'comfort', 'eco']),
e.auto_lock(), e.away_mode(), e.away_preset_days(), e.boost_time(), e.comfort_temperature(), e.eco_temperature(), e.force(),
e.max_temperature(), e.min_temperature(), e.week(), e.away_preset_temperature()],
},
{
fingerprint: [{modelID: 'v90ladg\u0000', manufacturerName: '_TYST11_wv90ladg'}],
model: 'HT-08',
vendor: 'ETOP',
description: 'Wall-mount thermostat',
fromZigbee: [fz.legacy.tuya_thermostat_weekly_schedule, fz.etop_thermostat, fz.ignore_basic_report, fz.ignore_tuya_set_time],
toZigbee: [tz.etop_thermostat_system_mode, tz.etop_thermostat_away_mode, tz.tuya_thermostat_child_lock,
tz.tuya_thermostat_current_heating_setpoint, tz.tuya_thermostat_weekly_schedule],
onEvent: tuya.onEventSetTime,
meta: {
thermostat: {
weeklyScheduleMaxTransitions: 4,
weeklyScheduleSupportedModes: [1], // bits: 0-heat present, 1-cool present (dec: 1-heat,2-cool,3-heat+cool)
weeklyScheduleFirstDayDpId: tuya.dataPoints.schedule,
},
},
exposes: [e.child_lock(), exposes.climate().withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
.withLocalTemperature(ea.STATE)
.withSystemMode(['off', 'heat', 'auto'], ea.STATE_SET).withRunningState(['idle', 'heat'], ea.STATE)
.withAwayMode()],
},
{
fingerprint: [{modelID: 'dpplnsn\u0000', manufacturerName: '_TYST11_2dpplnsn'}],
model: 'HT-10',
vendor: 'ETOP',
description: 'Radiator valve',
fromZigbee: [fz.legacy.tuya_thermostat_weekly_schedule, fz.etop_thermostat, fz.ignore_basic_report, fz.ignore_tuya_set_time],
toZigbee: [tz.etop_thermostat_system_mode, tz.etop_thermostat_away_mode, tz.tuya_thermostat_child_lock,
tz.tuya_thermostat_current_heating_setpoint, tz.tuya_thermostat_weekly_schedule],
onEvent: tuya.onEventSetTime,
meta: {
timeout: 20000, // TRV wakes up every 10sec
thermostat: {
weeklyScheduleMaxTransitions: 4,
weeklyScheduleSupportedModes: [1], // bits: 0-heat present, 1-cool present (dec: 1-heat,2-cool,3-heat+cool)
weeklyScheduleFirstDayDpId: tuya.dataPoints.schedule,
},
},
exposes: [
e.battery_low(), e.child_lock(), exposes.climate()
.withSetpoint('current_heating_setpoint', 5, 35, 0.5, ea.STATE_SET)
.withLocalTemperature(ea.STATE).withAwayMode()
.withSystemMode(['off', 'heat', 'auto'], ea.STATE_SET).withRunningState(['idle', 'heat'], ea.STATE),
],
},
{
zigbeeModel: ['TS0121'],
model: 'TS0121_plug',
description: '10A UK or 16A EU smart plug',
whiteLabel: [{vendor: 'BlitzWolf', model: 'BW-SHP13'}],
vendor: 'TuYa',
fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, fz.tuya_switch_power_outage_memory],
toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
endpoint.saveClusterAttributeKeyValue('seMetering', {divisor: 100, multiplier: 1});
endpoint.saveClusterAttributeKeyValue('haElectricalMeasurement', {
acVoltageMultiplier: 1, acVoltageDivisor: 1, acCurrentMultiplier: 1, acCurrentDivisor: 1000, acPowerMultiplier: 1,
acPowerDivisor: 1,
});
},
// This device doesn't support reporting correctly.
// https://github.com/Koenkk/zigbee-herdsman-converters/pull/1270
exposes: [e.switch(), e.power(), e.current(), e.voltage().withAccess(ea.STATE),
e.energy(), exposes.enum('power_outage_memory', ea.STATE_SET, ['on', 'off', 'restore'])
.withDescription('Recover state after power outage')],
onEvent: (type, data, device, options) => {
const endpoint = device.getEndpoint(1);
if (type === 'stop') {
clearInterval(globalStore.getValue(device, 'interval'));
globalStore.clearValue(device, 'interval');
} else if (!globalStore.hasValue(device, 'interval')) {
const seconds = options && options.measurement_poll_interval ? options.measurement_poll_interval : 60;
const interval = setInterval(async () => {
try {
await endpoint.read('haElectricalMeasurement', ['rmsVoltage', 'rmsCurrent', 'activePower']);
} catch (error) {/* Do nothing*/}
}, seconds*1000);
globalStore.putValue(device, 'interval', interval);
}
},
},
{
fingerprint: [{modelID: 'TS011F', manufacturerName: '_TZ3000_cphmq0q7'}],
model: 'TS011F_plug',
description: 'Smart EU plug',
vendor: 'TuYa',
fromZigbee: [fz.on_off, fz.electrical_measurement, fz.metering, fz.ignore_basic_report, fz.tuya_switch_power_outage_memory],
toZigbee: [tz.on_off, tz.tuya_switch_power_outage_memory],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'haElectricalMeasurement']);
await reporting.rmsVoltage(endpoint);
await reporting.rmsCurrent(endpoint);
await reporting.activePower(endpoint);
await reporting.readEletricalMeasurementMultiplierDivisors(endpoint);
},
exposes: [e.switch(), e.power(), e.current(), e.voltage().withAccess(ea.STATE),
e.energy(), exposes.enum('power_outage_memory', ea.STATE_SET, ['on', 'off', 'restore'])
.withDescription('Recover state after power outage')],
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_byzdayie'}],
model: 'TS0601_din',
vendor: 'TuYa',
description: 'Zigbee smart energy meter DDS238-2 Zigbee',
fromZigbee: [fz.tuya_dinrail_switch],
toZigbee: [tz.tuya_switch_state],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
},
exposes: [e.switch().setAccess('state', ea.STATE_SET), e.voltage(), e.power(), e.current(), e.energy()],
},
{
zigbeeModel: ['RH3001'],
fingerprint: [{type: 'EndDevice', manufacturerID: 4098, applicationVersion: 66, endpoints: [
{ID: 1, profileID: 260, deviceID: 1026, inputClusters: [0, 10, 1, 1280], outputClusters: [25]},
]}],
model: 'SNTZ007',
vendor: 'TuYa',
description: 'Rechargeable Zigbee contact sensor',
fromZigbee: [fz.ias_contact_alarm_1, fz.battery, fz.ignore_basic_report, fz.ignore_time_read],
toZigbee: [],
exposes: [e.contact(), e.battery_low(), e.tamper(), e.battery()],
whiteLabel: [{vendor: 'BlitzWolf', model: 'BW-IS2'}],
},
{
zigbeeModel: ['RH3040'],
model: 'RH3040',
vendor: 'TuYa',
description: 'PIR sensor',
fromZigbee: [fz.battery, fz.ignore_basic_report, fz.ias_occupancy_alarm_1],
toZigbee: [],
whiteLabel: [{vendor: 'Samotech', model: 'SM301Z'}],
exposes: [e.battery(), e.occupancy(), e.battery_low(), e.tamper()],
},
{
zigbeeModel: ['TS0115'],
model: 'TS0115',
vendor: 'TuYa',
description: 'Multiprise with 4 AC outlets and 2 USB super charging ports (10A or 16A)',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5')],
whiteLabel: [{vendor: 'UseeLink', model: 'SM-SO306E/K/M'}],
endpoint: (device) => {
return {l1: 1, l2: 2, l3: 3, l4: 4, l5: 7};
},
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(7), coordinatorEndpoint, ['genOnOff']);
},
},
{
zigbeeModel: ['RH3052'],
model: 'TT001ZAV20',
vendor: 'TuYa',
description: 'Temperature & humidity sensor',
fromZigbee: [fz.humidity, fz.temperature, fz.battery],
toZigbee: [],
exposes: [e.humidity(), e.temperature(), e.battery()],
},
{
zigbeeModel: ['TS0011'],
model: 'TS0011',
vendor: 'TuYa',
description: 'Smart light switch - 1 gang',
extend: extend.switch(),
whiteLabel: [{vendor: 'Vrey', model: 'VR-X712U-0013'}, {vendor: 'TUYATEC', model: 'GDKES-01TZXD'},
{vendor: 'Lonsonho', model: 'QS-Zigbee-S05-L', description: '1 gang smart switch module without neutral wire'}],
configure: async (device, coordinatorEndpoint, logger) => {
// Reports itself as battery which is not correct: https://github.com/Koenkk/zigbee2mqtt/issues/6190
device.powerSource = 'Mains (single phase)';
device.save();
},
},
{
zigbeeModel: ['TS0012'],
model: 'TS0012',
vendor: 'TuYa',
description: 'Smart light switch - 2 gang',
whiteLabel: [{vendor: 'Vrey', model: 'VR-X712U-0013'}, {vendor: 'TUYATEC', model: 'GDKES-02TZXD'},
{vendor: 'Earda', model: 'ESW-2ZAA-EU'}],
extend: extend.switch(),
exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('right')],
endpoint: (device) => {
return {'left': 1, 'right': 2};
},
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
device.powerSource = 'Mains (single phase)';
device.save();
},
},
{
zigbeeModel: ['TS0013'],
model: 'TS0013',
vendor: 'TuYa',
description: 'Smart light switch - 3 gang without neutral wire',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('left'), e.switch().withEndpoint('center'), e.switch().withEndpoint('right')],
endpoint: (device) => {
return {'left': 1, 'center': 2, 'right': 3};
},
whiteLabel: [{vendor: 'TUYATEC', model: 'GDKES-03TZXD'}],
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
try {
for (const ID of [1, 2, 3]) {
const endpoint = device.getEndpoint(ID);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
}
} catch (e) {
// Fails for some: https://github.com/Koenkk/zigbee2mqtt/issues/4872
}
device.powerSource = 'Mains (single phase)';
device.save();
},
},
{
fingerprint: [{modelID: 'TS0014', manufacturerName: '_TZ3000_jr2atpww'}, {modelID: 'TS0014', manufacturerName: '_TYZB01_dvakyzhd'},
{modelID: 'TS0014', manufacturerName: '_TZ3210_w3hl6rao'}, {modelID: 'TS0014', manufacturerName: '_TYZB01_bagt1e4o'},
{modelID: 'TS0014', manufacturerName: '_TZ3000_r0pmi2p3'}],
model: 'TS0014',
vendor: 'TuYa',
description: 'Smart light switch - 4 gang without neutral wire',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
e.switch().withEndpoint('l4')],
endpoint: (device) => {
return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4};
},
whiteLabel: [{vendor: 'TUYATEC', model: 'GDKES-04TZXD'}, {vendor: 'Vizo', model: 'VZ-222S'},
{vendor: 'MakeGood', model: 'MG-ZG04W/B/G'}],
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
try {
for (const ID of [1, 2, 3, 4]) {
const endpoint = device.getEndpoint(ID);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff']);
}
} catch (e) {
// Fails for some: https://github.com/Koenkk/zigbee2mqtt/issues/4872
}
device.powerSource = 'Mains (single phase)';
device.save();
},
},
{
zigbeeModel: ['gq8b1uv'],
model: 'gq8b1uv',
vendor: 'TuYa',
description: 'Zigbee smart dimmer',
fromZigbee: [fz.tuya_dimmer, fz.ignore_basic_report],
toZigbee: [tz.tuya_dimmer_state, tz.tuya_dimmer_level],
exposes: [e.light_brightness().setAccess('state', ea.STATE_SET).setAccess('brightness', ea.STATE_SET)],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genOnOff', 'genLevelCtrl']);
},
},
{
zigbeeModel: ['HY0017'],
model: 'U86KCJ-ZP',
vendor: 'TuYa',
description: 'Smart 6 key scene wall switch',
fromZigbee: [fz.scenes_recall_scene_65029],
exposes: [e.action(['scene_1', 'scene_2', 'scene_3', 'scene_4', 'scene_5', 'scene_6'])],
toZigbee: [],
},
{
zigbeeModel: ['q9mpfhw'],
model: 'SNTZ009',
vendor: 'TuYa',
description: 'Water leak sensor',
fromZigbee: [fz.tuya_water_leak, fz.ignore_basic_report],
exposes: [e.water_leak()],
toZigbee: [],
},
{
zigbeeModel: ['TS0004'],
model: 'TS0004',
vendor: 'TuYa',
description: 'Smart light switch - 4 gang with neutral wire',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
e.switch().withEndpoint('l4')],
endpoint: (device) => {
return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4};
},
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
},
},
{
fingerprint: [{modelID: 'TS0006', manufacturerName: '_TYZB01_ltundz9m'}],
model: 'TS0006',
vendor: 'TuYa',
description: '6 gang switch module with neutral wire',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
e.switch().withEndpoint('l4'), e.switch().withEndpoint('l5'), e.switch().withEndpoint('l6')],
endpoint: (device) => {
return {'l1': 1, 'l2': 2, 'l3': 3, 'l4': 4, 'l5': 5, 'l6': 6};
},
meta: {multiEndpoint: true},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(5), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(6), coordinatorEndpoint, ['genOnOff']);
},
},
{
zigbeeModel: ['HY0080'],
model: 'U86KWF-ZPSJ',
vendor: 'TuYa',
description: 'Environment controller',
fromZigbee: [fz.legacy.thermostat_att_report, fz.fan],
toZigbee: [tz.factory_reset, tz.thermostat_local_temperature, tz.thermostat_local_temperature_calibration,
tz.thermostat_occupancy, tz.thermostat_occupied_heating_setpoint, tz.thermostat_unoccupied_heating_setpoint,
tz.thermostat_occupied_cooling_setpoint, tz.thermostat_unoccupied_cooling_setpoint,
tz.thermostat_setpoint_raise_lower, tz.thermostat_remote_sensing,
tz.thermostat_control_sequence_of_operation, tz.thermostat_system_mode, tz.thermostat_weekly_schedule,
tz.thermostat_clear_weekly_schedule, tz.thermostat_relay_status_log,
tz.thermostat_temperature_setpoint_hold, tz.thermostat_temperature_setpoint_hold_duration, tz.fan_mode],
exposes: [exposes.climate().withSetpoint('occupied_heating_setpoint', 5, 30, 0.5).withLocalTemperature()
.withSystemMode(['off', 'auto', 'heat'], ea.ALL)
.withRunningState(['idle', 'heat', 'cool'], ea.STATE)
.withLocalTemperatureCalibration(ea.ALL).withPiHeatingDemand()],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(9);
await reporting.bind(endpoint, coordinatorEndpoint, ['hvacThermostat', 'hvacFanCtrl']);
await reporting.thermostatTemperature(endpoint);
await reporting.thermostatSystemMode(endpoint);
await reporting.thermostatOccupiedHeatingSetpoint(endpoint);
await reporting.thermostatUnoccupiedHeatingSetpoint(endpoint);
await reporting.thermostatOccupiedCoolingSetpoint(endpoint);
await reporting.thermostatUnoccupiedCoolingSetpoint(endpoint);
await reporting.fanMode(endpoint);
},
},
{
zigbeeModel: ['6dfgetq'],
model: 'D3-DPWK-TY',
vendor: 'TuYa',
description: 'HVAC controller',
exposes: [exposes.climate().withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET)
.withLocalTemperature(ea.STATE)
.withSystemMode(['off', 'auto', 'heat'], ea.STATE_SET)
.withRunningState(['idle', 'heat', 'cool'], ea.STATE)],
fromZigbee: [fz.tuya_thermostat, fz.ignore_basic_report, fz.tuya_dimmer],
meta: {tuyaThermostatSystemMode: tuya.thermostatSystemModes2, tuyaThermostatPreset: tuya.thermostatPresets},
toZigbee: [tz.tuya_thermostat_current_heating_setpoint, tz.tuya_thermostat_system_mode,
tz.tuya_thermostat_fan_mode, tz.tuya_dimmer_state],
},
{
zigbeeModel: ['E220-KR4N0Z0-HA'],
model: 'E220-KR4N0Z0-HA',
vendor: 'TuYa',
description: 'Multiprise with 4 AC outlets and 2 USB super charging ports (16A)',
extend: extend.switch(),
exposes: [e.switch().withEndpoint('l1'), e.switch().withEndpoint('l2'), e.switch().withEndpoint('l3'),
e.switch().withEndpoint('l4')],
whiteLabel: [{vendor: 'LEELKI', model: 'WP33-EU'}],
meta: {multiEndpoint: true},
endpoint: (device) => {
return {l1: 1, l2: 2, l3: 3, l4: 4};
},
configure: async (device, coordinatorEndpoint, logger) => {
await reporting.bind(device.getEndpoint(1), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(2), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(3), coordinatorEndpoint, ['genOnOff']);
await reporting.bind(device.getEndpoint(4), coordinatorEndpoint, ['genOnOff']);
},
},
{
zigbeeModel: ['TS0216'],
model: 'TS0216',
vendor: 'TuYa',
description: 'Sound and flash siren',
fromZigbee: [fz.ts0216_siren, fz.battery],
exposes: [e.battery(), exposes.binary('alarm', ea.STATE_SET, true, false),
exposes.numeric('volume', ea.ALL).withValueMin(0).withValueMax(100).withDescription('Volume of siren')],
toZigbee: [tz.ts0216_alarm, tz.ts0216_duration, tz.ts0216_volume],
configure: async (device, coordinatorEndpoint, logger) => {
const endpoint = device.getEndpoint(1);
await reporting.bind(endpoint, coordinatorEndpoint, ['genPowerCfg']);
},
},
{
fingerprint: [{modelID: 'TS0601', manufacturerName: '_TZE200_znzs7yaw'}],
model: 'HY08WE',
vendor: 'TuYa',
description: 'Wall-mount thermostat',
fromZigbee: [fz.hy_thermostat, fz.ignore_basic_report, fz.hy_set_time_request],
toZigbee: [tz.hy_thermostat],
exposes: [exposes.climate().withSetpoint('current_heating_setpoint', 5, 30, 0.5, ea.STATE_SET)
.withLocalTemperature(ea.STATE)
.withSystemMode(['off', 'auto', 'heat'], ea.STATE_SET).withRunningState(['idle', 'heat'], ea.STATE)],
},
{
fingerprint: [{modelID: 'TS0222', manufacturerName: '_TYZB01_4mdqxxnn'}],
model: 'TS0222',
vendor: 'TuYa',
description: 'Light intensity sensor',
fromZigbee: [fz.battery, fz.illuminance],
toZigbee: [],
exposes: [e.battery(), e.illuminance(), e.illuminance_lux()],
},
{
fingerprint: [{modelID: 'TS0210', manufacturerName: '_TYZB01_3zv6oleo'}],
model: 'TS0210',
vendor: 'TuYa',
description: 'Vibration sensor',
fromZigbee: [fz.battery, fz.ias_vibration_alarm_1_with_timeout],
toZigbee: [tz.TS0210_sensitivity],
exposes: [e.battery(), e.vibration(), exposes.enum('sensitivity', exposes.access.STATE_SET, ['low', 'medium', 'high'])],
},
];