diff --git a/drivers/SmartThings/zigbee-window-treatment/fingerprints.yml b/drivers/SmartThings/zigbee-window-treatment/fingerprints.yml index 021d59d2d4..46c4fb1385 100644 --- a/drivers/SmartThings/zigbee-window-treatment/fingerprints.yml +++ b/drivers/SmartThings/zigbee-window-treatment/fingerprints.yml @@ -153,7 +153,11 @@ zigbeeManufacturer: manufacturer: Sombra Shades model: SOMBRA/Z-M deviceProfileName: window-treatment-powerSource - + - id: "_TZE200_cirjrpxe/TS0301" + deviceLabel: Zemismart Roller Shade Motor + manufacturer: _TZE200_cirjrpxe + model: TS0301 + deviceProfileName: window-treatment-battery zigbeeGeneric: - id: "genericShade" deviceLabel: Zigbee Window Treatment diff --git a/drivers/SmartThings/zigbee-window-treatment/src/init.lua b/drivers/SmartThings/zigbee-window-treatment/src/init.lua index b58c20a5be..d31cce8086 100644 --- a/drivers/SmartThings/zigbee-window-treatment/src/init.lua +++ b/drivers/SmartThings/zigbee-window-treatment/src/init.lua @@ -34,6 +34,7 @@ local zigbee_window_treatment_driver_template = { capabilities.windowShadePreset, capabilities.windowShadeLevel, capabilities.statelessWindowShadeLevelStep, + capabilities.refresh, capabilities.powerSource, capabilities.battery }, diff --git a/drivers/SmartThings/zigbee-window-treatment/src/sub_drivers.lua b/drivers/SmartThings/zigbee-window-treatment/src/sub_drivers.lua index 3353c87fd4..dda7e513fe 100644 --- a/drivers/SmartThings/zigbee-window-treatment/src/sub_drivers.lua +++ b/drivers/SmartThings/zigbee-window-treatment/src/sub_drivers.lua @@ -3,6 +3,7 @@ local lazy_load_if_possible = require "lazy_load_subdriver" local sub_drivers = { + lazy_load_if_possible("zemismart"), lazy_load_if_possible("vimar"), lazy_load_if_possible("aqara"), lazy_load_if_possible("feibit"), diff --git a/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment.lua b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment.lua index 30bc6bfa5c..f94c2bca8e 100644 --- a/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment.lua +++ b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment.lua @@ -26,6 +26,17 @@ end test.set_test_init_function(test_init) +test.register_coroutine_test( + "Driver switched accepts the window treatment profile with refresh", + function() + test.socket.device_lifecycle:__queue_receive({ mock_device.id, "driverSwitched" }) + mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" }) + end, + { + min_api_version = 14 + } +) + test.register_coroutine_test( "State transnsition from opening to partially open", function() diff --git a/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart.lua b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart.lua new file mode 100644 index 0000000000..5ba27cedf2 --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart.lua @@ -0,0 +1,299 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local test = require "integration_test" +local z_utils = require "integration_test.zigbee_test_utils" +local capabilities = require "st.capabilities" +local clusters = require "st.zigbee.zcl.clusters" +local battery_defaults = require "st.zigbee.defaults.battery_defaults" +local can_handle = require "zemismart.can_handle" +local helpers = require "test.zemismart_feedback_test_utils" + +local device = helpers.create() +local battery_device = helpers.create("window-treatment-battery.yml") +local fresh_device, fresh_fingerprint = helpers.create_from_fingerprint() +local shade = capabilities.windowShade.windowShade +helpers.set_test_init(device) + +local function expect_position(level, state) + helpers.expect_event(capabilities.windowShadeLevel.shadeLevel(level)) + helpers.expect_event(state) +end + +local function report_then_settle(level, movement) + helpers.report(level) + expect_position(level, movement) + test.wait_for_events() + helpers.expect_event(shade.partially_open()) + helpers.advance(2) +end + +test.register_coroutine_test("Shared fingerprint handles both existing profiles without matching unrelated devices", function() + assert(can_handle(nil, nil, device)) + for _, pair in ipairs({ { "different", "TS0301" }, { "_TZE200_cirjrpxe", "different" } }) do + assert(not can_handle(nil, nil, { + get_manufacturer = function() return pair[1] end, + get_model = function() return pair[2] end, + })) + end +end) + +for _, entry in ipairs({ { "non-battery", device }, { "battery", battery_device } }) do + test.register_coroutine_test("Driver switch accepts the " .. entry[1] .. " profile", function() + assert(can_handle(nil, nil, entry[2])) + test.socket.device_lifecycle:__queue_receive({ entry[2].id, "driverSwitched" }) + entry[2]:expect_metadata_update({ provisioning_state = "PROVISIONED" }) + end, { test_init = function() helpers.initialize_device(entry[2]) end }) +end + +test.register_coroutine_test("Non-battery profile ignores unsupported battery reports", function() + for _, attr in ipairs({ clusters.PowerConfiguration.attributes.BatteryVoltage, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining }) do + test.socket.zigbee:__queue_receive({ device.id, attr:build_test_attr_report(device, 100) }) + test.wait_for_events() + end + assert(device:get_latest_state("main", "battery", "battery") == nil) +end) + +test.register_coroutine_test("Battery profile retains standard percentage and voltage reports", function() + test.socket.zigbee:__queue_receive({ battery_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:build_test_attr_report(battery_device, 150) }) + helpers.expect_event(capabilities.battery.battery(75), battery_device) + test.wait_for_events() + battery_device:set_field(battery_defaults.DEVICE_MIN_VOLTAGE_KEY, 2.0) + battery_device:set_field(battery_defaults.DEVICE_MAX_VOLTAGE_KEY, 3.0) + test.socket.zigbee:__queue_receive({ battery_device.id, + clusters.PowerConfiguration.attributes.BatteryVoltage:build_test_attr_report(battery_device, 25) }) + helpers.expect_event(capabilities.battery.battery(50), battery_device) +end, { test_init = function() helpers.initialize_device(battery_device) end }) + +test.register_coroutine_test("Configuration and refresh preserve standard position reporting", function() + test.socket.device_lifecycle:__queue_receive({ device.id, "doConfigure" }) + test.socket.zigbee:__set_channel_ordering("relaxed") + helpers.expect_read() + test.socket.zigbee:__expect_send({ device.id, + z_utils.build_bind_request(device, z_utils.mock_hub_eui, clusters.WindowCovering.ID) }) + test.socket.zigbee:__expect_send({ device.id, + clusters.WindowCovering.attributes.CurrentPositionLiftPercentage:configure_reporting(device, 0, 600, 1) }) + device:expect_metadata_update({ provisioning_state = "PROVISIONED" }) + test.wait_for_events() + helpers.command("refresh", "refresh") + helpers.expect_read() +end) + +test.register_coroutine_test("Added announces supported commands without manufacturing Unknown", function() + test.socket.device_lifecycle:__queue_receive({ device.id, "added" }) + helpers.expect_event(capabilities.windowShade.supportedWindowShadeCommands( + { "open", "close", "pause" }, { visibility = { displayed = false } })) +end) + +test.register_coroutine_test("Preset storage and movement retain standard semantics", function() + helpers.seed(43) + helpers.command("windowShadePreset", "setPresetPosition", { 40 }) + helpers.expect_event(capabilities.windowShadePreset.position(40)) + test.wait_for_events() + helpers.command("windowShadePreset", "presetPosition") + helpers.expect_motion("GoToLiftPercentage", 40) + test.wait_for_events() + assert(device:get_latest_state("main", "windowShadeLevel", "shadeLevel") == 43) + report_then_settle(40, shade.closing()) +end) + +test.register_coroutine_test("Absolute control does not optimistically change reported position", function() + helpers.seed(43) + helpers.command("windowShadeLevel", "setShadeLevel", { 75 }) + helpers.expect_motion("GoToLiftPercentage", 75) + test.wait_for_events() + assert(device:get_latest_state("main", "windowShadeLevel", "shadeLevel") == 43) + report_then_settle(75, shade.opening()) +end) + +test.register_coroutine_test("Absolute movement ends the prior relative-step sequence", function() + helpers.seed(50) + helpers.step(10, 60) + report_then_settle(60, shade.opening()) + helpers.command("windowShadeLevel", "setShadeLevel", { 50 }) + helpers.expect_motion("GoToLiftPercentage", 50) + test.wait_for_events() + report_then_settle(50, shade.closing()) + helpers.step(-10, 40) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Rapid relative steps accumulate despite intermediate reports", function() + helpers.seed(50) + helpers.step(10, 60) + helpers.report(52) + expect_position(52, shade.opening()) + test.wait_for_events() + helpers.step(-5, 55) + helpers.step(15, 70) +end, { min_api_version = 15 }) + +for _, action in ipairs({ + { "windowShade", "open", "UpOrOpen" }, + { "windowShade", "close", "DownOrClose" }, + { "windowShade", "pause", "Stop" }, + { "windowShadePreset", "presetPosition", "GoToLiftPercentage", 50 }, +}) do + test.register_coroutine_test(action[2] .. " clears the previous step target without changing position", function() + helpers.seed(51) + helpers.step(10, 61) + helpers.command(action[1], action[2]) + helpers.expect_motion(action[3], action[4]) + test.wait_for_events() + helpers.step(-10, 41) + end, { min_api_version = 15 }) +end + +test.register_coroutine_test("Refresh and preset setting preserve rapid step accumulation", function() + helpers.seed(50) + helpers.step(10, 60) + helpers.command("refresh", "refresh") + helpers.expect_read() + test.wait_for_events() + helpers.command("windowShadePreset", "setPresetPosition", { 40 }) + helpers.expect_event(capabilities.windowShadePreset.position(40)) + test.wait_for_events() + helpers.step(-5, 55) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Expired step accumulation starts from the latest real position", function() + helpers.seed(50) + helpers.step(10, 60) + helpers.advance(16) + helpers.step(-5, 45) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Interrupted step timeout cannot clear a newer step sequence", function() + helpers.seed(50) + local callbacks, restore = helpers.capture_callbacks() + helpers.step(10, 60) + restore() + helpers.advance(5) + helpers.command("windowShade", "pause") + helpers.expect_motion("Stop") + test.wait_for_events() + helpers.step(-10, 40) + callbacks[1].callback() + test.wait_for_events() + helpers.advance(11) + helpers.step(5, 45) +end, { min_api_version = 15 }) + +for _, entry in ipairs({ { 95, 10, 100 }, { 5, -10, 0 } }) do + test.register_coroutine_test("Relative step clamps at endpoint " .. entry[3], function() + helpers.seed(entry[1]) + helpers.step(entry[2], entry[3]) + end, { min_api_version = 15 }) +end + +test.register_coroutine_test("Zero step sends nothing from an ordinary static position", function() + helpers.seed(43) + helpers.command("statelessWindowShadeLevelStep", "stepShadeLevel", { 0 }) + test.wait_for_events() + assert(device:get_latest_state("main", "windowShadeLevel", "shadeLevel") == 43) +end) + +test.register_coroutine_test("Zero step leaves an active relative sequence intact", function() + helpers.seed(50) + helpers.step(10, 60) + helpers.command("statelessWindowShadeLevelStep", "stepShadeLevel", { 0 }) + test.wait_for_events() + helpers.step(-5, 55) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Failed step injection does not contaminate the next real command", function() + helpers.seed(50) + local handler = (require "zemismart").capability_handlers.statelessWindowShadeLevelStep.stepShadeLevel + local ok, err = pcall(handler, { + inject_capability_command = function() error("simulated dispatch failure") end, + }, device, { component = "main", args = { stepSize = 10 } }) + assert(not ok and string.find(err, "simulated dispatch failure", 1, true)) + helpers.step(-5, 45) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Removed device cannot be touched by a queued step callback", function() + helpers.seed(50) + local callbacks, restore = helpers.capture_callbacks() + helpers.step(10, 60) + restore() + test.socket.device_lifecycle:__queue_receive({ device.id, "removed" }) + test.wait_for_events() + for _, entry in ipairs(callbacks) do + local ok, err = pcall(entry.callback) + assert(ok, "callback touched deleted device: " .. tostring(err)) + end + helpers.advance(16) +end, { min_api_version = 15 }) + + +-- These devices come from the real package fingerprint, not a hard-coded test profile. +-- Hub/cloud selection and physical onboarding remain separate acceptance checks. +local function fresh_init() + helpers.initialize_device(fresh_device) +end + +test.register_coroutine_test("Package fingerprint selects one compatible profile with all shade capabilities", function() + assert(fresh_fingerprint.deviceProfileName == "window-treatment-battery") + assert(not string.find(fresh_fingerprint.deviceLabel, "ZM25Z", 1, true), "shared identity must not claim a unique SKU") + assert(can_handle(nil, nil, fresh_device)) + for _, id in ipairs({ "windowShade", "windowShadePreset", "windowShadeLevel", "statelessWindowShadeLevelStep", + "battery", "firmwareUpdate", "refresh" }) do + assert(fresh_device:supports_capability_by_id(id), "selected profile missing " .. id) + end +end, { test_init = fresh_init }) + +test.register_coroutine_test("Fingerprint-selected profile configures shade and battery reporting", function() + test.socket.device_lifecycle:__queue_receive({ fresh_device.id, "doConfigure" }) + test.socket.zigbee:__set_channel_ordering("relaxed") + helpers.expect_read(fresh_device) + test.socket.zigbee:__expect_send({ fresh_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:read(fresh_device) }) + for _, cluster in ipairs({ clusters.WindowCovering, clusters.PowerConfiguration }) do + test.socket.zigbee:__expect_send({ fresh_device.id, + z_utils.build_bind_request(fresh_device, z_utils.mock_hub_eui, cluster.ID) }) + end + test.socket.zigbee:__expect_send({ fresh_device.id, + clusters.WindowCovering.attributes.CurrentPositionLiftPercentage:configure_reporting(fresh_device, 0, 600, 1) }) + test.socket.zigbee:__expect_send({ fresh_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:configure_reporting(fresh_device, 30, 21600, 1) }) + fresh_device:expect_metadata_update({ provisioning_state = "PROVISIONED" }) +end, { test_init = fresh_init }) + +test.register_coroutine_test("Fingerprint-selected refresh reads position and battery and preserves real responses", function() + helpers.command("refresh", "refresh", nil, fresh_device) + test.socket.zigbee:__set_channel_ordering("relaxed") + helpers.expect_read(fresh_device) + test.socket.zigbee:__expect_send({ fresh_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:read(fresh_device) }) + test.wait_for_events() + helpers.response(43, fresh_device) + helpers.expect_static(43, fresh_device) + test.wait_for_events() + test.socket.zigbee:__queue_receive({ fresh_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:build_test_read_attr_response(fresh_device, 200) }) + helpers.expect_event(capabilities.battery.battery(100), fresh_device) + test.wait_for_events() + test.socket.zigbee:__queue_receive({ fresh_device.id, + clusters.PowerConfiguration.attributes.BatteryPercentageRemaining:build_test_attr_report(fresh_device, 150) }) + helpers.expect_event(capabilities.battery.battery(75), fresh_device) +end, { test_init = fresh_init }) + +test.register_coroutine_test("Fingerprint-selected profile keeps preset and relative control after Unknown", function() + helpers.seed(43, fresh_device) + helpers.report(0xFF, fresh_device) + helpers.expect_event(shade.unknown(), fresh_device) + test.wait_for_events() + helpers.command("windowShadePreset", "setPresetPosition", { 50 }, fresh_device) + helpers.expect_event(capabilities.windowShadePreset.position(50), fresh_device) + test.wait_for_events() + helpers.command("windowShadePreset", "presetPosition", nil, fresh_device) + helpers.expect_motion("GoToLiftPercentage", 50, fresh_device) + test.wait_for_events() + helpers.response(50, fresh_device) + helpers.expect_static(50, fresh_device) + test.wait_for_events() + helpers.step(-10, 40, fresh_device) +end, { test_init = fresh_init, min_api_version = 15 }) + +test.run_registered_tests() diff --git a/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart_recovery.lua b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart_recovery.lua new file mode 100644 index 0000000000..d759495403 --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/test/test_zigbee_window_treatment_zemismart_recovery.lua @@ -0,0 +1,408 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local test = require "integration_test" +local capabilities = require "st.capabilities" +local clusters = require "st.zigbee.zcl.clusters" +local helpers = require "test.zemismart_feedback_test_utils" +local device = helpers.create() +local battery_device = helpers.create("window-treatment-battery.yml") +local shade = capabilities.windowShade.windowShade +helpers.set_test_init(device) + +local function assert_position(level, state) + assert(device:get_latest_state("main", "windowShadeLevel", "shadeLevel") == level) + assert(device:get_latest_state("main", "windowShade", "windowShade") == state) +end + +local function expect_position(level, state) + helpers.expect_event(capabilities.windowShadeLevel.shadeLevel(level)) + helpers.expect_event(state) +end + +local function unknown() + helpers.report(0xFF) + helpers.expect_event(shade.unknown()) + test.wait_for_events() +end + +local function suspect_zero() + helpers.report(0) + helpers.expect_read() + test.wait_for_events() +end + +test.register_coroutine_test("Startup initializes metadata without a read or Unknown", function() + test.wait_for_events() + assert(device:get_latest_state("main", "windowShade", "windowShade") == nil) + assert(device:get_latest_state("main", "windowShadeLevel", "shadeLevel") == nil) + helpers.advance(35) +end) + +test.register_coroutine_test("Driver restart preserves a known static position without Zigbee traffic", function() + helpers.seed(43) + test.socket.device_lifecycle:__queue_receive({ device.id, "init" }) + test.wait_for_events() + helpers.advance(35) + assert_position(43, "partially open") +end) + +for _, level in ipairs({ 0, 43, 100 }) do + test.register_coroutine_test("First static read publishes position " .. level .. " without invented motion", function() + helpers.seed(level) + end) +end + +for _, action in ipairs({ + { "windowShade", "open", "UpOrOpen" }, + { "windowShade", "close", "DownOrClose" }, + { "windowShade", "pause", "Stop" }, + { "windowShadeLevel", "setShadeLevel", "GoToLiftPercentage", 75, { 75 } }, + { "windowShadePreset", "presetPosition", "GoToLiftPercentage", 50 }, +}) do + test.register_coroutine_test("Unknown never blocks " .. action[2] .. " and same-value feedback restores state", function() + helpers.seed(43) + unknown() + helpers.command(action[1], action[2], action[5]) + helpers.expect_motion(action[3], action[4]) + test.wait_for_events() + assert_position(43, "unknown") + helpers.report(43) + helpers.expect_static(43) + test.wait_for_events() + assert_position(43, "partially open") + end) +end + +test.register_coroutine_test("Unknown never blocks a relative step from the last real position", function() + helpers.seed(43) + unknown() + helpers.step(10, 53) + assert_position(43, "unknown") + helpers.response(43) + helpers.expect_static(43) +end, { min_api_version = 15 }) + +test.register_coroutine_test("Zero step in Unknown sends no command or read", function() + unknown() + helpers.command("statelessWindowShadeLevelStep", "stepShadeLevel", { 0 }) + test.wait_for_events() +end) + +for _, level in ipairs({ 43, 77, 100 }) do + test.register_coroutine_test("Transient zero corrected by a read retains position " .. level, function() + helpers.seed(level) + suspect_zero() + helpers.response(level) + test.wait_for_events() + helpers.advance(3) + assert_position(level, level == 100 and "open" or "partially open") + end) +end + +test.register_coroutine_test("Transient zero corrected by an equal report does not invent reopening", function() + helpers.seed(43) + suspect_zero() + helpers.report(43) + test.wait_for_events() + helpers.advance(3) + assert_position(43, "partially open") +end) + +test.register_coroutine_test("Different nonzero correction retains genuine remote closing direction", function() + helpers.seed(43) + suspect_zero() + helpers.report(42) + expect_position(42, shade.closing()) + test.wait_for_events() + helpers.expect_event(shade.partially_open()) + helpers.advance(2) + assert_position(42, "partially open") +end) + +test.register_coroutine_test("Read-confirmed zero is a real closed position", function() + helpers.seed(43) + suspect_zero() + helpers.response(0) + helpers.expect_static(0) + test.wait_for_events() + helpers.advance(3) + assert_position(0, "closed") +end) + +test.register_coroutine_test("Unanswered zero publishes the real report once at the bounded deadline", function() + helpers.seed(43) + suspect_zero() + helpers.advance(1) + assert_position(43, "partially open") + helpers.expect_static(0) + helpers.advance(1) + helpers.advance(3) + assert_position(0, "closed") +end) + +test.register_coroutine_test("Repeated zero reports neither repeat the read nor extend the deadline", function() + helpers.seed(43) + suspect_zero() + helpers.advance(1) + helpers.report(0) + test.wait_for_events() + helpers.expect_static(0) + helpers.advance(1) + assert_position(0, "closed") +end) + +test.register_coroutine_test("New movement immediately cancels an outstanding zero without replay", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + suspect_zero() + restore() + helpers.command("windowShade", "open") + helpers.expect_motion("UpOrOpen") + test.wait_for_events() + callbacks[1].callback() + helpers.advance(3) + assert_position(43, "partially open") +end) + +test.register_coroutine_test("Fresh close sends immediately even when its zero report awaits verification", function() + helpers.seed(43) + helpers.command("windowShade", "close") + helpers.expect_motion("DownOrClose") + test.wait_for_events() + suspect_zero() + helpers.response(0) + helpers.expect_static(0) +end) + +test.register_coroutine_test("Normal motion and final endpoint do not emit Unknown", function() + helpers.seed(43) + helpers.report(42) + expect_position(42, shade.closing()) + test.wait_for_events() + helpers.report(0) + helpers.expect_static(0) + test.wait_for_events() + helpers.advance(3) + assert_position(0, "closed") +end) + +test.register_coroutine_test("Open endpoint and pause retain their normal state behavior", function() + helpers.seed(43) + helpers.command("windowShade", "open") + helpers.expect_motion("UpOrOpen") + test.wait_for_events() + helpers.report(100) + helpers.expect_static(100) + test.wait_for_events() + helpers.command("windowShade", "pause") + helpers.expect_motion("Stop") + test.wait_for_events() + helpers.advance(3) + assert_position(100, "open") +end) + +test.register_coroutine_test("Unavailable position cancels the pending zero and same valid value restores state", function() + helpers.seed(43) + suspect_zero() + unknown() + helpers.advance(3) + assert_position(43, "unknown") + helpers.response(43) + helpers.expect_static(43) +end) + +test.register_coroutine_test("Unknown recovery with zero accepts a valid read without control gating", function() + helpers.seed(43) + unknown() + helpers.response(0) + helpers.expect_static(0) +end) + +test.register_coroutine_test("Unknown accepts a valid zero report immediately without buffering", function() + helpers.seed(43) + unknown() + helpers.report(0) + helpers.expect_static(0) + test.wait_for_events() + assert_position(0, "closed") + helpers.advance(3) +end) + +test.register_coroutine_test("Invalid feedback cancels the normal partial-state timer", function() + helpers.seed(43) + helpers.report(44) + expect_position(44, shade.opening()) + test.wait_for_events() + unknown() + helpers.advance(3) + assert_position(44, "unknown") +end) + +test.register_coroutine_test("Read position changes continue to report ordinary motion", function() + helpers.seed(43) + helpers.response(50) + expect_position(50, shade.opening()) + test.wait_for_events() + helpers.expect_event(shade.partially_open()) + helpers.advance(2) +end) + +test.register_coroutine_test("A cancelled zero callback cannot overwrite a corrected position", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + suspect_zero() + restore() + helpers.response(43) + test.wait_for_events() + callbacks[1].callback() + helpers.advance(3) + assert_position(43, "partially open") +end) + +test.register_coroutine_test("Removal invalidates a queued zero callback before SDK deletion", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + suspect_zero() + restore() + test.socket.device_lifecycle:__queue_receive({ device.id, "removed" }) + test.wait_for_events() + for _, entry in ipairs(callbacks) do + local ok, err = pcall(entry.callback) + assert(ok, "callback touched deleted device: " .. tostring(err)) + end + helpers.advance(3) +end) + +test.register_coroutine_test("Existing battery profile uses the same narrow recovery without command gates", function() + helpers.seed(43, battery_device) + helpers.report(0, battery_device) + helpers.expect_read(battery_device) + test.wait_for_events() + helpers.response(43, battery_device) + test.wait_for_events() + helpers.command("windowShade", "close", nil, battery_device) + helpers.expect_motion("DownOrClose", nil, battery_device) +end, { test_init = function() helpers.initialize_device(battery_device) end }) + + +for _, action in ipairs({ + { "windowShade", "close", "DownOrClose" }, + { "windowShade", "pause", "Stop" }, + { "windowShadeLevel", "setShadeLevel", "GoToLiftPercentage", 75, { 75 } }, + { "windowShadePreset", "presetPosition", "GoToLiftPercentage", 50 }, +}) do + test.register_coroutine_test("Pending zero cannot delay " .. action[2] .. " or publish after it", function() + helpers.seed(43) + suspect_zero() + helpers.command(action[1], action[2], action[5]) + helpers.expect_motion(action[3], action[4]) + test.wait_for_events() + helpers.advance(3) + assert_position(43, "partially open") + end) +end + +test.register_coroutine_test("Pending zero cannot delay an immediate relative step", function() + helpers.seed(43) + suspect_zero() + helpers.step(10, 53) + helpers.advance(3) + assert_position(43, "partially open") +end, { min_api_version = 15 }) + +test.register_coroutine_test("First zero report is accepted without a speculative recovery read", function() + helpers.report(0) + helpers.expect_static(0) + test.wait_for_events() + helpers.advance(3) + assert_position(0, "closed") +end) + +test.register_coroutine_test("Repeated legitimate closed report is stable and sends no read", function() + helpers.seed(0) + helpers.report(0) + test.wait_for_events() + helpers.advance(3) + assert_position(0, "closed") +end) + +test.register_coroutine_test("An out-of-range position never becomes an invalid capability percentage", function() + helpers.seed(43) + helpers.report(101) + helpers.expect_event(shade.unknown()) + test.wait_for_events() + assert_position(43, "unknown") +end) + +test.register_coroutine_test("Already queued partial callback cannot overwrite Unknown or its recovery", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + helpers.report(44) + expect_position(44, shade.opening()) + test.wait_for_events() + restore() + unknown() + callbacks[1].callback() + test.wait_for_events() + assert_position(44, "unknown") + helpers.response(44) + helpers.expect_static(44) + test.wait_for_events() + callbacks[1].callback() + helpers.advance(3) + assert_position(44, "partially open") +end) + +test.register_coroutine_test("Already queued partial callback cannot overwrite a later endpoint", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + helpers.report(44) + expect_position(44, shade.opening()) + test.wait_for_events() + restore() + helpers.report(100) + helpers.expect_static(100) + test.wait_for_events() + callbacks[1].callback() + helpers.advance(3) + assert_position(100, "open") +end) + +test.register_coroutine_test("Removed device cannot be touched by a queued partial callback", function() + helpers.seed(43) + local callbacks, restore = helpers.capture_callbacks() + helpers.report(44) + expect_position(44, shade.opening()) + test.wait_for_events() + restore() + test.socket.device_lifecycle:__queue_receive({ device.id, "removed" }) + test.wait_for_events() + for _, entry in ipairs(callbacks) do + local ok, err = pcall(entry.callback) + assert(ok, "partial callback touched deleted device: " .. tostring(err)) + end + helpers.advance(3) +end) + +test.register_coroutine_test("Failed anomaly read keeps a bounded real report and leaves commands available", function() + helpers.seed(43) + local position = clusters.WindowCovering.attributes.CurrentPositionLiftPercentage + local handler = (require "zemismart.position_recovery").position_handler + local callbacks, restore = helpers.capture_callbacks() + local original_send = device.send_to_component + device.send_to_component = function() error("simulated read send failure") end + local ok, err = pcall(handler, {}, device, { value = 0 }, position:build_test_attr_report(device, 0)) + device.send_to_component = original_send + restore() + assert(not ok and string.find(err, "simulated read send failure", 1, true)) + helpers.expect_static(0) + callbacks[1].callback() + test.wait_for_events() + helpers.command("windowShade", "open") + helpers.expect_motion("UpOrOpen") + test.wait_for_events() + assert_position(0, "closed") +end) + +test.run_registered_tests() diff --git a/drivers/SmartThings/zigbee-window-treatment/src/test/zemismart_feedback_test_utils.lua b/drivers/SmartThings/zigbee-window-treatment/src/test/zemismart_feedback_test_utils.lua new file mode 100644 index 0000000000..ab0e951b26 --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/test/zemismart_feedback_test_utils.lua @@ -0,0 +1,152 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local test = require "integration_test" +local t_utils = require "integration_test.utils" +local z_utils = require "integration_test.zigbee_test_utils" +local capabilities = require "st.capabilities" +local clusters = require "st.zigbee.zcl.clusters" +local path = require "path" +local yaml = require "yaml" + +local helpers = {} +local position = clusters.WindowCovering.attributes.CurrentPositionLiftPercentage + +-- Use the requested delays: unqueued SDK mock timers never fire and hide expiry bugs. +local create_oneshot = test.timer.create_oneshot +test.timer.create_oneshot = function(seconds) + if #test.timer.__oneshot_timers == 0 then + test.timer.__create_and_queue_test_time_advance_timer(seconds, "oneshot") + end + return create_oneshot(seconds) +end + +local function target(device) + return assert(device or helpers.device, "create a feedback test device first") +end + +function helpers.create(profile) + local device = test.mock_device.build_test_zigbee_device({ + profile = t_utils.get_profile_definition(profile or "window-treatment-profile.yml"), + zigbee_endpoints = { + [1] = { + id = 1, manufacturer = "_TZE200_cirjrpxe", model = "TS0301", + server_clusters = { 0x0000, 0x0001, 0x0003, 0x0004, 0x0005, 0x0102, 0xEF00 }, + client_clusters = { 0x0019 }, + }, + }, + }) + helpers.device = helpers.device or device + return device +end + +-- Resolve the package's actual mapping; this checks packaging inputs, not cloud pairing. +function helpers.create_from_fingerprint() + local caller_path = path.Path(debug.getinfo(1, "S").source:sub(2)) + local src_path = caller_path:get_dir_pos("src") and caller_path:to_dir("src") or path.Path("") + local file = assert(io.open(src_path:parent():append("fingerprints.yml"):to_string())) + local contents = file:read("a") + file:close() + -- The SDK YAML reader stops at empty separator lines in this simple mapping file. + contents = contents:gsub("\n[ \t]*\n", "\n") + local fingerprints = yaml.eval(contents) + local selected + for _, fingerprint in ipairs(fingerprints.zigbeeManufacturer) do + if fingerprint.manufacturer == "_TZE200_cirjrpxe" and fingerprint.model == "TS0301" then + assert(selected == nil, "ambiguous manufacturer/model mapping") + selected = fingerprint + end + end + assert(selected, "shared Zemismart fingerprint missing from the package") + return helpers.create(selected.deviceProfileName .. ".yml"), selected +end + +function helpers.expect_event(event, device) + device = target(device) + test.socket.capability:__expect_send(device:generate_test_message("main", event)) +end + +function helpers.expect_read(device) + device = target(device) + test.socket.zigbee:__expect_send({ device.id, position:read(device) }) +end + +function helpers.expect_motion(command, argument, device) + device = target(device) + local message = argument ~= nil and clusters.WindowCovering.server.commands[command](device, argument) + or clusters.WindowCovering.server.commands[command](device) + test.socket.zigbee:__expect_send({ device.id, message }) +end + +function helpers.command(capability, name, args, device) + device = target(device) + test.socket.capability:__queue_receive({ device.id, { + capability = capability, component = "main", command = name, args = args or {}, + } }) +end + +function helpers.response(level, device) + device = target(device) + test.socket.zigbee:__queue_receive({ device.id, position:build_test_read_attr_response(device, level) }) +end + +function helpers.report(level, device) + device = target(device) + test.socket.zigbee:__queue_receive({ device.id, position:build_test_attr_report(device, level) }) +end + +function helpers.expect_static(level, device) + helpers.expect_event(capabilities.windowShadeLevel.shadeLevel(level), device) + local shade = capabilities.windowShade.windowShade + helpers.expect_event(level == 0 and shade.closed() + or level == 100 and shade.open() or shade.partially_open(), device) +end + +function helpers.initialize_device(device) + device = target(device) + helpers.device = device + test.mock_device.add_test_device(device) + helpers.expect_event(capabilities.windowShadePreset.supportedCommands( + { "presetPosition", "setPresetPosition" }, { visibility = { displayed = false } }), device) + helpers.expect_event(capabilities.windowShadePreset.position( + 50, { visibility = { displayed = false } }), device) +end + +function helpers.set_test_init(device) + device = target(device) + z_utils.prepare_zigbee_env_info() + local init = function() helpers.initialize_device(device) end + test.set_test_init_function(init) + return init +end + +function helpers.advance(seconds) + test.mock_time.advance_time(seconds) + test.wait_for_events() +end + +-- Establish state through a real protocol response, not an implementation-private field. +function helpers.seed(level, device) + helpers.response(level, device) + helpers.expect_static(level, device) + test.wait_for_events() +end + +function helpers.step(step, level, device) + helpers.command("statelessWindowShadeLevelStep", "stepShadeLevel", { step }, device) + helpers.expect_motion("GoToLiftPercentage", level, device) + test.wait_for_events() +end + +function helpers.capture_callbacks(device) + device = target(device) + local original = device.thread.call_with_delay + local callbacks = {} + device.thread.call_with_delay = function(thread, seconds, callback, ...) + callbacks[#callbacks + 1] = { seconds = seconds, callback = callback } + return original(thread, seconds, callback, ...) + end + return callbacks, function() device.thread.call_with_delay = original end +end + +return helpers diff --git a/drivers/SmartThings/zigbee-window-treatment/src/window_shade_utils.lua b/drivers/SmartThings/zigbee-window-treatment/src/window_shade_utils.lua index fd07648021..cd650adef5 100644 --- a/drivers/SmartThings/zigbee-window-treatment/src/window_shade_utils.lua +++ b/drivers/SmartThings/zigbee-window-treatment/src/window_shade_utils.lua @@ -18,6 +18,19 @@ local LATEST_TARGET_LEVEL = "_latestTargetLevel" local TARGET_LEVEL_TIME_OUT_SECONDS = 15 -- Field name for the timer that clears LATEST_TARGET_LEVEL after timeout local TARGET_LEVEL_TIME_OUT = "_targetLevelTimeOut" +local TARGET_LEVEL_GENERATION = "_targetLevelGeneration" + +utils.clear_step_target = function(device) + local generation = device:get_field(TARGET_LEVEL_GENERATION) + if generation then generation.active = false end + device:set_field(TARGET_LEVEL_GENERATION, nil) + local timer = device:get_field(TARGET_LEVEL_TIME_OUT) + if timer then + pcall(device.thread.cancel_timer, device.thread, timer) + end + device:set_field(TARGET_LEVEL_TIME_OUT, nil) + device:set_field(LATEST_TARGET_LEVEL, nil) +end utils.get_preset_level = function(device, component) local level = device:get_latest_state(component, "windowShadePreset", "position") or @@ -54,11 +67,20 @@ utils.step_shade_level_handler = function(driver, device, command) -- Cancel any previous timer and set a 15 second timeout timer to ensure LATEST_TARGET_LEVEL is cleared -- This is to prevent the stateless step from accumulating indefinitely, while ensuring that a single -- "scroll" action can accumulate multiple steps within a short time frame + local previous_generation = device:get_field(TARGET_LEVEL_GENERATION) + if previous_generation then previous_generation.active = false end if device:get_field(TARGET_LEVEL_TIME_OUT) then - device.thread:cancel_timer(device:get_field(TARGET_LEVEL_TIME_OUT)) + pcall(device.thread.cancel_timer, device.thread, device:get_field(TARGET_LEVEL_TIME_OUT)) end + local generation = { active = true } + device:set_field(TARGET_LEVEL_GENERATION, generation) local timer = device.thread:call_with_delay(TARGET_LEVEL_TIME_OUT_SECONDS, function(d) + if not generation.active then return end + if device:get_field(TARGET_LEVEL_GENERATION) ~= generation then return end + generation.active = false + device:set_field(TARGET_LEVEL_GENERATION, nil) device:set_field(LATEST_TARGET_LEVEL, nil) + device:set_field(TARGET_LEVEL_TIME_OUT, nil) end) device:set_field(TARGET_LEVEL_TIME_OUT, timer) device:set_field(LATEST_TARGET_LEVEL, new_target_level) diff --git a/drivers/SmartThings/zigbee-window-treatment/src/zemismart/can_handle.lua b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/can_handle.lua new file mode 100644 index 0000000000..5caa9f5859 --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/can_handle.lua @@ -0,0 +1,11 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local function can_handle(opts, driver, device) + if device:get_manufacturer() == "_TZE200_cirjrpxe" and device:get_model() == "TS0301" then + return true, require("zemismart") + end + return false +end + +return can_handle diff --git a/drivers/SmartThings/zigbee-window-treatment/src/zemismart/init.lua b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/init.lua new file mode 100644 index 0000000000..be92d1bb99 --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/init.lua @@ -0,0 +1,91 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local PowerConfiguration = (require "st.zigbee.zcl.clusters").PowerConfiguration +local WindowCovering = (require "st.zigbee.zcl.clusters").WindowCovering +local capabilities = require "st.capabilities" +local battery_defaults = require "st.zigbee.defaults.battery_defaults" +local shade_defaults = require "st.zigbee.defaults.windowShade_defaults" +local level_defaults = require "st.zigbee.defaults.windowShadeLevel_defaults" +local shade_utils = require "window_shade_utils" +local position_recovery = require "zemismart.position_recovery" + +local STEP_DISPATCH = "_zemismartStepDispatch" + +local function clear_step_target_before(handler) + return function(driver, device, command) + position_recovery.cancel(device) + if not device:get_field(STEP_DISPATCH) then + shade_utils.clear_step_target(device) + end + return handler(driver, device, command) + end +end + +local function step_shade_level_handler(driver, device, command) + if (command.args.stepSize or 0) == 0 then return end + -- The injected setShadeLevel is part of this step sequence, not an absolute override. + local previous_dispatch = device:get_field(STEP_DISPATCH) + device:set_field(STEP_DISPATCH, true) + local ok, result = pcall(shade_utils.step_shade_level_handler, driver, device, command) + device:set_field(STEP_DISPATCH, previous_dispatch) + if not ok then + shade_utils.clear_step_target(device) + error(result) + end +end + +local function battery_handler(handler) + return function(driver, device, value, zb_rx) + if device:supports_capability_by_id(capabilities.battery.ID) then + return handler(driver, device, value, zb_rx) + end + end +end + +return { + NAME = "Zemismart window treatment", + capability_handlers = { + [capabilities.windowShade.ID] = { + [capabilities.windowShade.commands.open.NAME] = clear_step_target_before( + shade_defaults.capability_handlers[capabilities.windowShade.commands.open.NAME]), + [capabilities.windowShade.commands.close.NAME] = clear_step_target_before( + shade_defaults.capability_handlers[capabilities.windowShade.commands.close.NAME]), + [capabilities.windowShade.commands.pause.NAME] = clear_step_target_before( + shade_defaults.capability_handlers[capabilities.windowShade.commands.pause.NAME]), + }, + [capabilities.windowShadeLevel.ID] = { + [capabilities.windowShadeLevel.commands.setShadeLevel.NAME] = clear_step_target_before( + level_defaults.window_shade_level_cmd), + }, + [capabilities.windowShadePreset.ID] = { + [capabilities.windowShadePreset.commands.presetPosition.NAME] = clear_step_target_before( + shade_utils.window_shade_preset_cmd), + }, + [capabilities.statelessWindowShadeLevelStep.ID] = { + [capabilities.statelessWindowShadeLevelStep.commands.stepShadeLevel.NAME] = + step_shade_level_handler, + }, + }, + zigbee_handlers = { + attr = { + [PowerConfiguration.ID] = { + [PowerConfiguration.attributes.BatteryVoltage.ID] = + battery_handler(battery_defaults.battery_volt_attr_handler), + [PowerConfiguration.attributes.BatteryPercentageRemaining.ID] = + battery_handler(battery_defaults.battery_perc_attr_handler), + }, + [WindowCovering.ID] = { + [WindowCovering.attributes.CurrentPositionLiftPercentage.ID] = + position_recovery.position_handler, + }, + }, + }, + lifecycle_handlers = { + removed = function(_, device) + position_recovery.removed(device) + shade_utils.clear_step_target(device) + end, + }, + can_handle = require("zemismart.can_handle"), +} diff --git a/drivers/SmartThings/zigbee-window-treatment/src/zemismart/position_recovery.lua b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/position_recovery.lua new file mode 100644 index 0000000000..4ea141222e --- /dev/null +++ b/drivers/SmartThings/zigbee-window-treatment/src/zemismart/position_recovery.lua @@ -0,0 +1,120 @@ +-- Copyright 2026 SmartThings, Inc. +-- Licensed under the Apache License, Version 2.0 + +local capabilities = require "st.capabilities" +local WindowCovering = (require "st.zigbee.zcl.clusters").WindowCovering +local zcl_commands = require "st.zigbee.zcl.global_commands" +local recovery = {} +local PENDING_ZERO = "_zemismartPendingZero" +local PARTIAL_TIMER = "_zemismartPartial" +-- Bound the delay for a genuine remote close when the corrective read has no reply. +local ZERO_CHECK_SECONDS = 2 + +function recovery.cancel(device) + local pending = device:get_field(PENDING_ZERO) + device:set_field(PENDING_ZERO, nil) + if pending then + pending.active = false + if pending.timer then pcall(device.thread.cancel_timer, device.thread, pending.timer) end + end +end + +local function cancel_partial_timer(device) + local pending = device:get_field(PARTIAL_TIMER) + device:set_field(PARTIAL_TIMER, nil) + if pending then + pending.active = false + if pending.timer then pcall(device.thread.cancel_timer, device.thread, pending.timer) end + end +end + +local function publish_static(device, component, level) + cancel_partial_timer(device) + device:emit_component_event(component, capabilities.windowShadeLevel.shadeLevel(level)) + local shade = capabilities.windowShade.windowShade + device:emit_component_event(component, + level == 0 and shade.closed() or level == 100 and shade.open() or shade.partially_open()) +end + +local function position_handler(_, device, value, zb_rx) + local component = { id = device:get_component_id_for_endpoint(zb_rx.address_header.src_endpoint.value) } + local level = value.value + local previous = device:get_latest_state(component.id, "windowShadeLevel", "shadeLevel") + if level == previous then return end + cancel_partial_timer(device) + if level == 0 or level == 100 then + publish_static(device, component, level) + return + end + -- Use the standard shade position-delta and two-second settling behavior. + device:emit_component_event(component, capabilities.windowShadeLevel.shadeLevel(level)) + local shade = capabilities.windowShade.windowShade + device:emit_component_event(component, + level > (previous or 0) and shade.opening() or shade.closing()) + local pending = { active = true } + device:set_field(PARTIAL_TIMER, pending) + pending.timer = device.thread:call_with_delay(2, function() + -- Timer cancellation cannot retract a callback already queued on the device thread. + if not pending.active then return end + pending.active = false + device:set_field(PARTIAL_TIMER, nil) + device:emit_component_event(component, shade.partially_open()) + end) +end + +function recovery.removed(device) + recovery.cancel(device) + cancel_partial_timer(device) +end + + +function recovery.position_handler(driver, device, value, zb_rx) + local component = { id = device:get_component_id_for_endpoint(zb_rx.address_header.src_endpoint.value) } + local level = value.value + local last_level = device:get_latest_state(component.id, "windowShadeLevel", "shadeLevel") + local state = device:get_latest_state(component.id, "windowShade", "windowShade") + local command_id = zb_rx.body.zcl_header.cmd.value + local is_read = command_id == zcl_commands.ReadAttributeResponse.ID + local pending = device:get_field(PENDING_ZERO) + + if level > 100 then + recovery.cancel(device) + cancel_partial_timer(device) + device:emit_component_event(component, capabilities.windowShade.windowShade.unknown()) + return + end + + if pending then + -- Repeated zero reports neither extend the window nor send additional reads. + if not is_read and level == 0 then return end + recovery.cancel(device) + elseif command_id == zcl_commands.ReportAttribute.ID and level == 0 + and last_level ~= nil and last_level > 0 + and state ~= "opening" and state ~= "closing" and state ~= "unknown" then + -- This firmware can report zero at power restoration while the motor is stationary. + -- Keep the previous state for one read; do not infer movement from the transient zero. + pending = { active = true } + device:set_field(PENDING_ZERO, pending) + pending.timer = device.thread:call_with_delay(ZERO_CHECK_SECONDS, function() + if not pending.active then return end + if device:get_field(PENDING_ZERO) ~= pending then return end + pending.active = false + device:set_field(PENDING_ZERO, nil) + -- Without a correction, retain the actual report (including a real remote close). + position_handler(driver, device, value, zb_rx) + end) + device:send_to_component(component.id, + WindowCovering.attributes.CurrentPositionLiftPercentage:read(device)) + return + end + + if state == "unknown" or (is_read and last_level == nil) then + -- One valid static value restores Unknown, including an unchanged cached level. + publish_static(device, component, level) + else + -- A changed nonzero correction still uses the original level to infer direction. + position_handler(driver, device, value, zb_rx) + end +end + +return recovery