From 0a5d65c954baa8bd7850f10e2dbf64cdff81085d Mon Sep 17 00:00:00 2001 From: Chris Beach Date: Wed, 2 Aug 2023 11:00:30 -0400 Subject: [PATCH 01/12] Add support for SmokeCO TC's in chip-all-clusters-app Address Issues: Fixes Cert blocker issues : 28193, 27747, 27746, 27742, 27731 --- examples/all-clusters-app/linux/BUILD.gn | 2 +- examples/all-clusters-app/linux/args.gni | 5 + examples/all-clusters-app/linux/smco-stub.cpp | 70 ++++++ examples/platform/linux/AppMain.cpp | 53 +++- examples/platform/linux/BUILD.gn | 8 + src/app/chip_data_model.gni | 10 +- .../SmokeCOTestEventTriggerDelegate.cpp | 228 ++++++++++++++++++ .../SmokeCOTestEventTriggerDelegate.h | 77 ++++++ src/platform/BUILD.gn | 4 + src/platform/Linux/args.gni | 1 + src/platform/device.gni | 1 + 11 files changed, 450 insertions(+), 9 deletions(-) create mode 100644 examples/all-clusters-app/linux/smco-stub.cpp create mode 100644 src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp create mode 100644 src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h diff --git a/examples/all-clusters-app/linux/BUILD.gn b/examples/all-clusters-app/linux/BUILD.gn index 766b482e5a4600..00c22247f4e5df 100644 --- a/examples/all-clusters-app/linux/BUILD.gn +++ b/examples/all-clusters-app/linux/BUILD.gn @@ -32,7 +32,7 @@ source_set("chip-all-clusters-common") { "${chip_root}/examples/all-clusters-app/all-clusters-common/src/operational-state-delegates.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/resource-monitoring-instances.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/rvc-modes.cpp", - "${chip_root}/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp", + "${chip_root}/examples/all-clusters-app/linux/smco-stub.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-temperature-levels.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/tcc-mode.cpp", diff --git a/examples/all-clusters-app/linux/args.gni b/examples/all-clusters-app/linux/args.gni index c4c9a18cec9cf5..8c392b290382ca 100644 --- a/examples/all-clusters-app/linux/args.gni +++ b/examples/all-clusters-app/linux/args.gni @@ -27,3 +27,8 @@ chip_project_config_include_dirs += [ "${chip_root}/config/standalone" ] matter_enable_tracing_support = true matter_log_json_payload_decode_full = true matter_log_json_payload_hex = true +chip_enable_smoke_co_alarm = true + +# Perfetto requires C++17 +cpp_standard = "gnu++17" + diff --git a/examples/all-clusters-app/linux/smco-stub.cpp b/examples/all-clusters-app/linux/smco-stub.cpp new file mode 100644 index 00000000000000..0780449918fccc --- /dev/null +++ b/examples/all-clusters-app/linux/smco-stub.cpp @@ -0,0 +1,70 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include <../../../src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h> +#include <../../../src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h> + +#include +#include +#include +#include + +#include // std::chrono::seconds +#include // std::cout +#include // std::thread, std::this_thread::sleep_for + +using namespace chip; +using namespace chip::app::Clusters; +using namespace chip::app::Clusters::SmokeCoAlarm; +using namespace chip::DeviceLayer; + +void TestModeTimeoutThread(int timeout) +{ + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self test running\033[0;37m"); + + std::this_thread::sleep_for(std::chrono::seconds(timeout)); + PlatformMgr().LockChipStack(); + SmokeCoAlarmServer::Instance().SetTestInProgress(1, false); + + SmokeCoAlarm::AlarmStateEnum currentBatteryState = SmokeCoAlarm::AlarmStateEnum::kNormal; + SmokeCoAlarm::EndOfServiceEnum currentEndOfService = SmokeCoAlarm::EndOfServiceEnum::kNormal; + SmokeCoAlarm::ExpressedStateEnum currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kNormal; + + SmokeCoAlarmServer::Instance().GetBatteryAlert(1, currentBatteryState); + SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(1, currentEndOfService); + + if (currentBatteryState != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kBatteryAlert; + if (currentEndOfService != SmokeCoAlarm::EndOfServiceEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kEndOfService; + SmokeCoAlarmServer::Instance().SetExpressedState(1, currentExpressedState); + + PlatformMgr().UnlockChipStack(); + + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self Test Timer Complete\033[0;37m"); +} + +bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(chip::EndpointId endpointId) +{ + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Starting Self Test Timer\033[0;37m"); + + SmokeCoAlarmServer::Instance().SetTestInProgress(1, true); + std::thread(TestModeTimeoutThread, 20).detach(); + return true; +} diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 22ff4d2db71cb6..b54a7eb9cfdc48 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -77,6 +77,10 @@ #endif #include +// #if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM +#include +// #endif + #include #include "AppMain.h" @@ -103,6 +107,11 @@ using namespace chip::app::Clusters; // Network comissioning implementation namespace { + +uint8_t sTestEventTriggerEnableKey[chip::TestEventTriggerDelegate::kEnableKeyLength] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, + 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, + 0xcc, 0xdd, 0xee, 0xff }; + // If secondaryNetworkCommissioningEndpoint has a value and both Thread and WiFi // are enabled, we put the WiFi network commissioning cluster on // secondaryNetworkCommissioningEndpoint. @@ -304,6 +313,7 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate public: /// NOTE: If you copy this, please use the reserved range FFFF_FFFF__xxxx for your trigger codes. static constexpr uint64_t kSampleTestEventTriggerAlwaysSuccess = static_cast(0xFFFF'FFFF'FFF1'0000ull); + static constexpr uint64_t kSampleTestEventsSmokeCO = static_cast(0xFFFF'FFFF'0000'fffful); SampleTestEventTriggerDelegate() { memset(&mEnableKey[0], 0, sizeof(mEnableKey)); } @@ -325,6 +335,13 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate return CopySpanToMutableSpan(enableKey, ourEnableKeySpan); } + CHIP_ERROR SetSmokeCODelegate(TestEventTriggerDelegate * scoDelegate) + { + VerifyOrReturnError(EnableKeyIsSet() == CHIP_NO_ERROR, CHIP_ERROR_INVALID_ARGUMENT); + mSmokeCODelegate = scoDelegate; + return CHIP_NO_ERROR; + } + bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override { return enableKey.data_equal(ByteSpan(mEnableKey)); } CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override @@ -338,14 +355,29 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate return CHIP_NO_ERROR; } + if (eventTrigger & kSampleTestEventsSmokeCO) + { + ChipLogProgress(Support, "Handling Resideo Smoke CO test event"); + return (mSmokeCODelegate != nullptr) ? mSmokeCODelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; + } + return (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; } private: uint8_t mEnableKey[TestEventTriggerDelegate::kEnableKeyLength]; - TestEventTriggerDelegate * mOtherDelegate = nullptr; + TestEventTriggerDelegate * mOtherDelegate = nullptr; + TestEventTriggerDelegate * mSmokeCODelegate = nullptr; + CHIP_ERROR EnableKeyIsSet() + { + for (size_t i = 0; i < TestEventTriggerDelegate::kEnableKeyLength; i++) + { + if (mEnableKey[i] != '\0') + return CHIP_NO_ERROR; + } + return CHIP_ERROR_INVALID_ARGUMENT; + }; }; - int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, const Optional secondaryNetworkCommissioningEndpoint) { @@ -519,14 +551,21 @@ void ChipLinuxAppMainLoop(AppMainLoopImplementation * impl) TestEventTriggerDelegate * otherDelegate = nullptr; #if CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR // We want to allow triggering OTA queries if OTA requestor is enabled - static OTATestEventTriggerDelegate otaTestEventTriggerDelegate{ ByteSpan( - LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey) }; + static OTATestEventTriggerDelegate otaTestEventTriggerDelegate{ chip::ByteSpan(sTestEventTriggerEnableKey) }; otherDelegate = &otaTestEventTriggerDelegate; #endif - // For general testing of TestEventTrigger, we have a common "core" event trigger delegate. + TestEventTriggerDelegate * SmokeCODelegate = nullptr; +#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM + + // We want to allow triggering OTA queries if OTA requestor is enabled + static SmokeCOTestEventTriggerDelegate smokeCOTestEventTriggerDelegate{ chip::ByteSpan(sTestEventTriggerEnableKey) }; + SmokeCODelegate = &smokeCOTestEventTriggerDelegate; +#endif + // For general testing of TestEventTrigger, we have a common "core" event trigger delegate. static SampleTestEventTriggerDelegate testEventTriggerDelegate; - VerifyOrDie(testEventTriggerDelegate.Init(ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), - otherDelegate) == CHIP_NO_ERROR); + VerifyOrDie(testEventTriggerDelegate.Init(chip::ByteSpan(sTestEventTriggerEnableKey), otherDelegate) == CHIP_NO_ERROR); + + testEventTriggerDelegate.SetSmokeCODelegate(SmokeCODelegate); initParams.testEventTriggerDelegate = &testEventTriggerDelegate; diff --git a/examples/platform/linux/BUILD.gn b/examples/platform/linux/BUILD.gn index 8427fe8aa80104..73a33238bf7117 100644 --- a/examples/platform/linux/BUILD.gn +++ b/examples/platform/linux/BUILD.gn @@ -29,6 +29,13 @@ source_set("ota-test-event-trigger") { ] } +source_set("sco-test-event-trigger") { + sources = [ + "${chip_root}/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h", + ] +} + + source_set("app-main") { defines = [ "ENABLE_TRACING=${matter_enable_tracing_support}" ] sources = [ @@ -56,6 +63,7 @@ source_set("app-main") { ] deps = [ ":ota-test-event-trigger", + ":sco-test-event-trigger", "${chip_root}/examples/providers:device_info_provider", "${chip_root}/src/app/server", ] diff --git a/src/app/chip_data_model.gni b/src/app/chip_data_model.gni index 1724d1048a304c..34e09c3041f652 100644 --- a/src/app/chip_data_model.gni +++ b/src/app/chip_data_model.gni @@ -288,7 +288,15 @@ template("chip_data_model") { "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.cpp", "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.h", ] - } else { + } + else if (cluster == "smoke-co-alarm-server") { + sources += [ + "${_app_root}/clusters/${cluster}/${cluster}.cpp", + "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.cpp", + "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.h", + ] + } + else { sources += [ "${_app_root}/clusters/${cluster}/${cluster}.cpp" ] } } diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp new file mode 100644 index 00000000000000..c0d558b1e77863 --- /dev/null +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -0,0 +1,228 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "SmokeCOTestEventTriggerDelegate.h" +#include "smoke-co-alarm-server.h" + +#include +#include +#include + +using namespace chip::app::Clusters; + +namespace chip { + +bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enableKey) const +{ + return !mEnableKey.empty() && mEnableKey.data_equal(enableKey); +} + +CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) +{ + switch (eventTrigger) + { + case trigger::ForceSmokeCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kCritical); + ExampleSetExpressedState(); + break; + case trigger::ForceSmokeWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kWarning); + ExampleSetExpressedState(); + break; + case trigger::ForceSmokeInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke interconnect (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, SmokeCoAlarm::AlarmStateEnum::kWarning); + ExampleSetExpressedState(); + break; + case trigger::ForceCOCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kCritical); + ExampleSetExpressedState(); + break; + case trigger::ForceCOWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kWarning); + ExampleSetExpressedState(); + break; + case trigger::ForceCOInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, SmokeCoAlarm::AlarmStateEnum::kWarning); + ExampleSetExpressedState(); + break; + case trigger::ForceSmokeContaminationHigh: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kCritical); + break; + case trigger::ForceSmokeContaminationLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kLow); + break; + case trigger::ForceSmokeSensitivityHigh: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force Smoke Sensistivity High\033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kHigh); + break; + case trigger::ForceSmokeSensitivityLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke Sensitivity low\033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kLow); + break; + case trigger::ForceMalfunction: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force malfunction\033[0;37m"); + SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, true); + ExampleSetExpressedState(); + break; + case trigger::ForceLowBatteryWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force low battery (warning)\033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kWarning); + ExampleSetExpressedState(); + break; + case trigger::ForceLowBatteryCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force low battery (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kCritical); + ExampleSetExpressedState(); + break; + case trigger::ForceCOEndOfLife: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co end-of-life\033[0;37m"); + SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, SmokeCoAlarm::EndOfServiceEnum::kExpired); + ExampleSetExpressedState(); + break; + case trigger::ForceSilence: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force silence\033[0;37m"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(1, SmokeCoAlarm::MuteStateEnum::kMuted); + break; + case trigger::ClearSmoke: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear smoke\033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kNormal); + ExampleSetExpressedState(); + break; + case trigger::ClearCO: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co\033[0;37m"); + ExampleSetExpressedState(); + SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kNormal); + break; + case trigger::ClearSmokeInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear smoke interconnect\033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, SmokeCoAlarm::AlarmStateEnum::kNormal); + ExampleSetExpressedState(); + break; + case trigger::ClearCOInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co interconnect\033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, SmokeCoAlarm::AlarmStateEnum::kNormal); + ExampleSetExpressedState(); + break; + case trigger::ClearMalfunction: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear malfunction\033[0;37m"); + SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, false); + ExampleSetExpressedState(); + break; + case trigger::ClearCOEndOfLife: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co end-of-life\033[0;37m"); + SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, SmokeCoAlarm::EndOfServiceEnum::kNormal); + ExampleSetExpressedState(); + break; + case trigger::ClearSilence: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear silence\033[0;37m"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(1, SmokeCoAlarm::MuteStateEnum::kNotMuted); + break; + case trigger::ClearBatteryLevelLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear low battery\033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kNormal); + ExampleSetExpressedState(); + break; + case trigger::ClearContamination: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kNormal); + break; + case trigger::ClearSensitivity: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear Smoke Sensitivity\033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kStandard); + break; + default: + ChipLogProgress(Support, " Unknown Smoke CO Event"); + return CHIP_ERROR_INVALID_ARGUMENT; + } + return CHIP_NO_ERROR; +} + +// For the Smoke CO example the following is the priority order for expressed alarms from Highest to lowest. +// Smoke Alarm +// Interconnect Smoke Alarm +// CO Alarm +// Interconneect CO alarm +// Hardware Fault +// Test In Progress +// End of Service +// Battery alert + +void SmokeCOTestEventTriggerDelegate::ExampleSetExpressedState(void) +{ + SmokeCoAlarm::ExpressedStateEnum currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kNormal; + SmokeCoAlarm::AlarmStateEnum currentBatteryState = SmokeCoAlarm::AlarmStateEnum::kNormal; + SmokeCoAlarm::AlarmStateEnum currentInterconnectSmokeAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; + ; + SmokeCoAlarm::AlarmStateEnum currentInterconnectCoAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; + ; + SmokeCoAlarm::AlarmStateEnum currentCoAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; + ; + SmokeCoAlarm::AlarmStateEnum currentSmokeAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; + ; + bool currentTestInProgress = false; + ; + SmokeCoAlarm::AlarmStateEnum currentHardwareFault = SmokeCoAlarm::AlarmStateEnum::kNormal; + ; + SmokeCoAlarm::EndOfServiceEnum currentEndOfService = SmokeCoAlarm::EndOfServiceEnum::kNormal; + + SmokeCoAlarmServer::Instance().GetBatteryAlert(1, currentBatteryState); + SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(1, currentEndOfService); + + SmokeCoAlarmServer::Instance().GetInterconnectSmokeAlarm(1, currentInterconnectSmokeAlarm); + SmokeCoAlarmServer::Instance().GetInterconnectCOAlarm(1, currentInterconnectCoAlarm); + SmokeCoAlarmServer::Instance().GetCOState(1, currentCoAlarm); + SmokeCoAlarmServer::Instance().GetSmokeState(1, currentSmokeAlarm); + SmokeCoAlarmServer::Instance().GetTestInProgress(1, currentTestInProgress); + + // This is written going lowest to highest priority + // If someone wanted to change the order it makes it easier + if (currentBatteryState != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kBatteryAlert; + if (currentEndOfService != SmokeCoAlarm::EndOfServiceEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kEndOfService; + if (currentTestInProgress != false) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kTesting; + if (currentHardwareFault != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kHardwareFault; + if (currentInterconnectCoAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kInterconnectCO; + if (currentCoAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kCOAlarm; + if (currentInterconnectSmokeAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kInterconnectSmoke; + if (currentSmokeAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) + currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kSmokeAlarm; + + SmokeCoAlarmServer::Instance().SetExpressedState(1, currentExpressedState); +} + +} // namespace chip + + + diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h new file mode 100644 index 00000000000000..c3d5a12b696b9d --- /dev/null +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h @@ -0,0 +1,77 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +namespace chip { +namespace trigger { + +// force alarm commands +const uint64_t ForceSmokeWarning = 0xffffffff00000090; +const uint64_t ForceSmokeInterconnect = 0xffffffff00000092; +const uint64_t ForceCOInterconnect = 0xffffffff00000094; +const uint64_t ForceSmokeContaminationHigh = 0xffffffff00000096; +const uint64_t ForceSmokeContaminationLow = 0xffffffff00000097; +const uint64_t ForceSmokeSensitivityHigh = 0xffffffff00000098; +const uint64_t ForceSmokeSensitivityLow = 0xffffffff00000099; +const uint64_t ForceSmokeCritical = 0xffffffff0000009c; + +const uint64_t ForceCOWarning = 0xffffffff00000091; +const uint64_t ForceCOCritical = 0xffffffff0000009d; + +const uint64_t ForceMalfunction = 0xffffffff00000093; + +const uint64_t ForceLowBatteryWarning = 0xffffffff00000095; +const uint64_t ForceLowBatteryCritical = 0xffffffff0000009e; + +const uint64_t ForceCOEndOfLife = 0xffffffff0000009a; +const uint64_t ForceSilence = 0xffffffff0000009b; + +// clear alarm commands +const uint64_t ClearSmoke = 0xffffffff000000a0; +const uint64_t ClearCO = 0xffffffff000000a1; +const uint64_t ClearSmokeInterconnect = 0xffffffff000000a2; +const uint64_t ClearMalfunction = 0xffffffff000000a3; +const uint64_t ClearCOInterconnect = 0xffffffff000000a4; +const uint64_t ClearBatteryLevelLow = 0xffffffff000000a5; +const uint64_t ClearContamination = 0xffffffff000000a6; +const uint64_t ClearSensitivity = 0xffffffff000000a8; + +const uint64_t ClearCOEndOfLife = 0xffffffff000000aa; +const uint64_t ClearSilence = 0xffffffff000000ab; +} // namespace trigger +class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate +{ +public: + explicit SmokeCOTestEventTriggerDelegate(const ByteSpan & enableKey) : mEnableKey(enableKey) {} + + bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override; + CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override; + CHIP_ERROR SetSmokeCODelegate(TestEventTriggerDelegate * scoDelegate); + // Highest level of Expressed state is Manufacturer specific. + // This is specifically written in support of certification test TC-2.6 + void ExampleSetExpressedState (void); + +private: + ByteSpan mEnableKey; + +}; + +} // namespace chip diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn index 04c4d522b5abe7..9f08edbd383676 100644 --- a/src/platform/BUILD.gn +++ b/src/platform/BUILD.gn @@ -137,6 +137,10 @@ if (chip_device_platform != "none" && chip_device_platform != "external") { defines += [ "CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR=1" ] } +# if (chip_enable_smoke_co_alarm) { +# defines += [ "CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM=1" ] +# } + if (chip_device_project_config_include != "") { defines += [ "CHIP_DEVICE_PROJECT_CONFIG_INCLUDE=${chip_device_project_config_include}" ] } diff --git a/src/platform/Linux/args.gni b/src/platform/Linux/args.gni index f9f97ee30d2c91..be2389fca6ad1c 100644 --- a/src/platform/Linux/args.gni +++ b/src/platform/Linux/args.gni @@ -13,3 +13,4 @@ # limitations under the License. chip_device_platform = "linux" +chip_enable_smoke_co_alarm = true \ No newline at end of file diff --git a/src/platform/device.gni b/src/platform/device.gni index b70b576644318e..32edea58c2bc15 100644 --- a/src/platform/device.gni +++ b/src/platform/device.gni @@ -81,6 +81,7 @@ declare_args() { # Enable OTA requestor support chip_enable_ota_requestor = false + chip_enable_smoke_co_alarm = false # Select DNS-SD implementation if (chip_device_platform == "linux" || chip_device_platform == "esp32" || From bdd3366ab4aacf95fcb2bbf150c756769bcf0705 Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 3 Aug 2023 14:12:08 +0800 Subject: [PATCH 02/12] Improve SmokeCO TC support in all-clusters-app --- examples/all-clusters-app/linux/BUILD.gn | 2 +- examples/all-clusters-app/linux/args.gni | 3 +- examples/all-clusters-app/linux/smco-stub.cpp | 6 +- examples/platform/linux/AppMain.cpp | 60 +-- examples/platform/linux/BUILD.gn | 17 +- src/app/chip_data_model.gni | 7 +- .../SmokeCOTestEventTriggerDelegate.cpp | 395 +++++++++--------- .../SmokeCOTestEventTriggerDelegate.h | 106 +++-- src/platform/BUILD.gn | 4 - src/platform/Linux/args.gni | 1 - src/platform/device.gni | 1 - 11 files changed, 308 insertions(+), 294 deletions(-) diff --git a/examples/all-clusters-app/linux/BUILD.gn b/examples/all-clusters-app/linux/BUILD.gn index 00c22247f4e5df..1d9696b5f04f60 100644 --- a/examples/all-clusters-app/linux/BUILD.gn +++ b/examples/all-clusters-app/linux/BUILD.gn @@ -32,10 +32,10 @@ source_set("chip-all-clusters-common") { "${chip_root}/examples/all-clusters-app/all-clusters-common/src/operational-state-delegates.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/resource-monitoring-instances.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/rvc-modes.cpp", - "${chip_root}/examples/all-clusters-app/linux/smco-stub.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-temperature-levels.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/tcc-mode.cpp", + "${chip_root}/examples/all-clusters-app/linux/smco-stub.cpp", "AllClustersCommandDelegate.cpp", "AppOptions.cpp", "WindowCoveringManager.cpp", diff --git a/examples/all-clusters-app/linux/args.gni b/examples/all-clusters-app/linux/args.gni index 8c392b290382ca..741af837361765 100644 --- a/examples/all-clusters-app/linux/args.gni +++ b/examples/all-clusters-app/linux/args.gni @@ -27,8 +27,7 @@ chip_project_config_include_dirs += [ "${chip_root}/config/standalone" ] matter_enable_tracing_support = true matter_log_json_payload_decode_full = true matter_log_json_payload_hex = true -chip_enable_smoke_co_alarm = true +chip_enable_smoke_co_trigger = true # Perfetto requires C++17 cpp_standard = "gnu++17" - diff --git a/examples/all-clusters-app/linux/smco-stub.cpp b/examples/all-clusters-app/linux/smco-stub.cpp index 0780449918fccc..f63139cd3b9086 100644 --- a/examples/all-clusters-app/linux/smco-stub.cpp +++ b/examples/all-clusters-app/linux/smco-stub.cpp @@ -17,8 +17,8 @@ #include -#include <../../../src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h> -#include <../../../src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h> +#include +#include #include #include @@ -48,7 +48,7 @@ void TestModeTimeoutThread(int timeout) SmokeCoAlarmServer::Instance().GetBatteryAlert(1, currentBatteryState); SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(1, currentEndOfService); - + if (currentBatteryState != SmokeCoAlarm::AlarmStateEnum::kNormal) currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kBatteryAlert; if (currentEndOfService != SmokeCoAlarm::EndOfServiceEnum::kNormal) diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index b54a7eb9cfdc48..9c8c05ebe90bab 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -75,11 +75,10 @@ #if CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR #include #endif -#include - -// #if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM +#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER #include -// #endif +#endif +#include #include @@ -107,11 +106,6 @@ using namespace chip::app::Clusters; // Network comissioning implementation namespace { - -uint8_t sTestEventTriggerEnableKey[chip::TestEventTriggerDelegate::kEnableKeyLength] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, - 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, - 0xcc, 0xdd, 0xee, 0xff }; - // If secondaryNetworkCommissioningEndpoint has a value and both Thread and WiFi // are enabled, we put the WiFi network commissioning cluster on // secondaryNetworkCommissioningEndpoint. @@ -313,7 +307,6 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate public: /// NOTE: If you copy this, please use the reserved range FFFF_FFFF__xxxx for your trigger codes. static constexpr uint64_t kSampleTestEventTriggerAlwaysSuccess = static_cast(0xFFFF'FFFF'FFF1'0000ull); - static constexpr uint64_t kSampleTestEventsSmokeCO = static_cast(0xFFFF'FFFF'0000'fffful); SampleTestEventTriggerDelegate() { memset(&mEnableKey[0], 0, sizeof(mEnableKey)); } @@ -335,13 +328,6 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate return CopySpanToMutableSpan(enableKey, ourEnableKeySpan); } - CHIP_ERROR SetSmokeCODelegate(TestEventTriggerDelegate * scoDelegate) - { - VerifyOrReturnError(EnableKeyIsSet() == CHIP_NO_ERROR, CHIP_ERROR_INVALID_ARGUMENT); - mSmokeCODelegate = scoDelegate; - return CHIP_NO_ERROR; - } - bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override { return enableKey.data_equal(ByteSpan(mEnableKey)); } CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override @@ -355,29 +341,14 @@ class SampleTestEventTriggerDelegate : public TestEventTriggerDelegate return CHIP_NO_ERROR; } - if (eventTrigger & kSampleTestEventsSmokeCO) - { - ChipLogProgress(Support, "Handling Resideo Smoke CO test event"); - return (mSmokeCODelegate != nullptr) ? mSmokeCODelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; - } - return (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; } private: uint8_t mEnableKey[TestEventTriggerDelegate::kEnableKeyLength]; - TestEventTriggerDelegate * mOtherDelegate = nullptr; - TestEventTriggerDelegate * mSmokeCODelegate = nullptr; - CHIP_ERROR EnableKeyIsSet() - { - for (size_t i = 0; i < TestEventTriggerDelegate::kEnableKeyLength; i++) - { - if (mEnableKey[i] != '\0') - return CHIP_NO_ERROR; - } - return CHIP_ERROR_INVALID_ARGUMENT; - }; + TestEventTriggerDelegate * mOtherDelegate = nullptr; }; + int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, const Optional secondaryNetworkCommissioningEndpoint) { @@ -551,21 +522,20 @@ void ChipLinuxAppMainLoop(AppMainLoopImplementation * impl) TestEventTriggerDelegate * otherDelegate = nullptr; #if CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR // We want to allow triggering OTA queries if OTA requestor is enabled - static OTATestEventTriggerDelegate otaTestEventTriggerDelegate{ chip::ByteSpan(sTestEventTriggerEnableKey) }; + static OTATestEventTriggerDelegate otaTestEventTriggerDelegate{ ByteSpan( + LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey) }; otherDelegate = &otaTestEventTriggerDelegate; #endif - TestEventTriggerDelegate * SmokeCODelegate = nullptr; -#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM - - // We want to allow triggering OTA queries if OTA requestor is enabled - static SmokeCOTestEventTriggerDelegate smokeCOTestEventTriggerDelegate{ chip::ByteSpan(sTestEventTriggerEnableKey) }; - SmokeCODelegate = &smokeCOTestEventTriggerDelegate; +#if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER + static SmokeCOTestEventTriggerDelegate smokeCOTestEventTriggerDelegate{ + ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), otherDelegate, 1 + }; + otherDelegate = &smokeCOTestEventTriggerDelegate; #endif - // For general testing of TestEventTrigger, we have a common "core" event trigger delegate. + // For general testing of TestEventTrigger, we have a common "core" event trigger delegate. static SampleTestEventTriggerDelegate testEventTriggerDelegate; - VerifyOrDie(testEventTriggerDelegate.Init(chip::ByteSpan(sTestEventTriggerEnableKey), otherDelegate) == CHIP_NO_ERROR); - - testEventTriggerDelegate.SetSmokeCODelegate(SmokeCODelegate); + VerifyOrDie(testEventTriggerDelegate.Init(ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), + otherDelegate) == CHIP_NO_ERROR); initParams.testEventTriggerDelegate = &testEventTriggerDelegate; diff --git a/examples/platform/linux/BUILD.gn b/examples/platform/linux/BUILD.gn index 73a33238bf7117..c57580414bb904 100644 --- a/examples/platform/linux/BUILD.gn +++ b/examples/platform/linux/BUILD.gn @@ -19,6 +19,10 @@ import("${chip_root}/src/lib/core/core.gni") import("${chip_root}/src/lib/lib.gni") import("${chip_root}/src/tracing/tracing_args.gni") +declare_args() { + chip_enable_smoke_co_trigger = false +} + config("app-main-config") { include_dirs = [ "." ] } @@ -29,13 +33,10 @@ source_set("ota-test-event-trigger") { ] } -source_set("sco-test-event-trigger") { - sources = [ - "${chip_root}/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h", - ] +source_set("smco-test-event-trigger") { + sources = [ "${chip_root}/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h" ] } - source_set("app-main") { defines = [ "ENABLE_TRACING=${matter_enable_tracing_support}" ] sources = [ @@ -63,7 +64,7 @@ source_set("app-main") { ] deps = [ ":ota-test-event-trigger", - ":sco-test-event-trigger", + ":smco-test-event-trigger", "${chip_root}/examples/providers:device_info_provider", "${chip_root}/src/app/server", ] @@ -93,6 +94,10 @@ source_set("app-main") { ] } + if (chip_enable_smoke_co_trigger) { + defines += [ "CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER=1" ] + } + public_configs = [ ":app-main-config" ] } diff --git a/src/app/chip_data_model.gni b/src/app/chip_data_model.gni index 34e09c3041f652..b1dea24055c1cd 100644 --- a/src/app/chip_data_model.gni +++ b/src/app/chip_data_model.gni @@ -288,15 +288,14 @@ template("chip_data_model") { "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.cpp", "${_app_root}/clusters/${cluster}/resource-monitoring-cluster-objects.h", ] - } - else if (cluster == "smoke-co-alarm-server") { + } else if (cluster == "smoke-co-alarm-server") { sources += [ "${_app_root}/clusters/${cluster}/${cluster}.cpp", + "${_app_root}/clusters/${cluster}/${cluster}.h", "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.cpp", "${_app_root}/clusters/${cluster}/SmokeCOTestEventTriggerDelegate.h", ] - } - else { + } else { sources += [ "${_app_root}/clusters/${cluster}/${cluster}.cpp" ] } } diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index c0d558b1e77863..b4e0f2f6fc724b 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -1,7 +1,6 @@ /* * - * Copyright (c) 2022 Project CHIP Authors - * All rights reserved. + * Copyright (c) 2023 Project CHIP Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,17 +15,13 @@ * limitations under the License. */ -#include -#include - #include "SmokeCOTestEventTriggerDelegate.h" -#include "smoke-co-alarm-server.h" + +#include #include -#include -#include -using namespace chip::app::Clusters; +using namespace chip::app::Clusters::SmokeCoAlarm; namespace chip { @@ -37,192 +32,220 @@ bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enable CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) { - switch (eventTrigger) + Trigger trigger = static_cast(eventTrigger); + + switch (trigger) { - case trigger::ForceSmokeCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kCritical); - ExampleSetExpressedState(); - break; - case trigger::ForceSmokeWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kWarning); - ExampleSetExpressedState(); - break; - case trigger::ForceSmokeInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke interconnect (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, SmokeCoAlarm::AlarmStateEnum::kWarning); - ExampleSetExpressedState(); - break; - case trigger::ForceCOCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kCritical); - ExampleSetExpressedState(); - break; - case trigger::ForceCOWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kWarning); - ExampleSetExpressedState(); - break; - case trigger::ForceCOInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, SmokeCoAlarm::AlarmStateEnum::kWarning); - ExampleSetExpressedState(); - break; - case trigger::ForceSmokeContaminationHigh: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kCritical); - break; - case trigger::ForceSmokeContaminationLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kLow); - break; - case trigger::ForceSmokeSensitivityHigh: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force Smoke Sensistivity High\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kHigh); - break; - case trigger::ForceSmokeSensitivityLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force smoke Sensitivity low\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kLow); - break; - case trigger::ForceMalfunction: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force malfunction\033[0;37m"); - SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, true); - ExampleSetExpressedState(); - break; - case trigger::ForceLowBatteryWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force low battery (warning)\033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kWarning); - ExampleSetExpressedState(); - break; - case trigger::ForceLowBatteryCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force low battery (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kCritical); - ExampleSetExpressedState(); - break; - case trigger::ForceCOEndOfLife: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force co end-of-life\033[0;37m"); - SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, SmokeCoAlarm::EndOfServiceEnum::kExpired); - ExampleSetExpressedState(); - break; - case trigger::ForceSilence: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force silence\033[0;37m"); - SmokeCoAlarmServer::Instance().SetDeviceMuted(1, SmokeCoAlarm::MuteStateEnum::kMuted); - break; - case trigger::ClearSmoke: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear smoke\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(1, SmokeCoAlarm::AlarmStateEnum::kNormal); - ExampleSetExpressedState(); - break; - case trigger::ClearCO: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co\033[0;37m"); - ExampleSetExpressedState(); - SmokeCoAlarmServer::Instance().SetCOState(1, SmokeCoAlarm::AlarmStateEnum::kNormal); - break; - case trigger::ClearSmokeInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear smoke interconnect\033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, SmokeCoAlarm::AlarmStateEnum::kNormal); - ExampleSetExpressedState(); - break; - case trigger::ClearCOInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co interconnect\033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, SmokeCoAlarm::AlarmStateEnum::kNormal); - ExampleSetExpressedState(); - break; - case trigger::ClearMalfunction: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear malfunction\033[0;37m"); - SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, false); - ExampleSetExpressedState(); - break; - case trigger::ClearCOEndOfLife: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear co end-of-life\033[0;37m"); - SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, SmokeCoAlarm::EndOfServiceEnum::kNormal); - ExampleSetExpressedState(); - break; - case trigger::ClearSilence: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear silence\033[0;37m"); - SmokeCoAlarmServer::Instance().SetDeviceMuted(1, SmokeCoAlarm::MuteStateEnum::kNotMuted); - break; - case trigger::ClearBatteryLevelLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => clear low battery\033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(1, SmokeCoAlarm::AlarmStateEnum::kNormal); - ExampleSetExpressedState(); - break; - case trigger::ClearContamination: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => force SmokeContamination (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(1, SmokeCoAlarm::ContaminationStateEnum::kNormal); - break; - case trigger::ClearSensitivity: + case Trigger::kForceSmokeCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kCritical); + SetExpressedState(); + break; + case Trigger::kForceSmokeWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kWarning); + SetExpressedState(); + break; + case Trigger::kForceSmokeInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kWarning); + SetExpressedState(); + break; + case Trigger::kForceCOCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kCritical); + SetExpressedState(); + break; + case Trigger::kForceCOWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kWarning); + SetExpressedState(); + break; + case Trigger::kForceCOInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kWarning); + SetExpressedState(); + break; + case Trigger::kForceSmokeContaminationHigh: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kCritical); + break; + case Trigger::kForceSmokeContaminationLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kLow); + break; + case Trigger::kForceSmokeSensitivityHigh: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke sensistivity (high) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kHigh); + break; + case Trigger::kForceSmokeSensitivityLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke sensitivity (low) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kLow); + break; + case Trigger::kForceMalfunction: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force malfunction\033[0;37m"); + SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, true); + SetExpressedState(); + break; + case Trigger::kForceLowBatteryWarning: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kWarning); + SetExpressedState(); + break; + case Trigger::kForceLowBatteryCritical: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (critical) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kCritical); + SetExpressedState(); + break; + case Trigger::kForceEndOfLife: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force end-of-life\033[0;37m"); + SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kExpired); + SetExpressedState(); + break; + case Trigger::kForceSilence: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force silence\033[0;37m"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(mEndpointId, MuteStateEnum::kMuted); + break; + case Trigger::kClearSmoke: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke\033[0;37m"); + SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kNormal); + SetExpressedState(); + break; + case Trigger::kClearCO: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO\033[0;37m"); + SetExpressedState(); + SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kNormal); + break; + case Trigger::kClearSmokeInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect\033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kNormal); + SetExpressedState(); + break; + case Trigger::kClearCOInterconnect: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect\033[0;37m"); + SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kNormal); + SetExpressedState(); + break; + case Trigger::kClearMalfunction: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear malfunction\033[0;37m"); + SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, false); + SetExpressedState(); + break; + case Trigger::kClearEndOfLife: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear end-of-life\033[0;37m"); + SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kNormal); + SetExpressedState(); + break; + case Trigger::kClearSilence: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear silence\033[0;37m"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(mEndpointId, MuteStateEnum::kNotMuted); + break; + case Trigger::kClearBatteryLevelLow: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear low battery\033[0;37m"); + SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kNormal); + SetExpressedState(); + break; + case Trigger::kClearContamination: + ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning) \033[0;37m"); + SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kNormal); + break; + case Trigger::kClearSensitivity: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear Smoke Sensitivity\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SmokeCoAlarm::SensitivityEnum::kStandard); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kStandard); break; default: - ChipLogProgress(Support, " Unknown Smoke CO Event"); - return CHIP_ERROR_INVALID_ARGUMENT; + ChipLogProgress(Support, " Unknown Smoke CO Event"); + + return (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; } + return CHIP_NO_ERROR; } -// For the Smoke CO example the following is the priority order for expressed alarms from Highest to lowest. -// Smoke Alarm -// Interconnect Smoke Alarm -// CO Alarm -// Interconneect CO alarm -// Hardware Fault -// Test In Progress -// End of Service -// Battery alert - -void SmokeCOTestEventTriggerDelegate::ExampleSetExpressedState(void) +void SmokeCOTestEventTriggerDelegate::SetExpressedState(void) { - SmokeCoAlarm::ExpressedStateEnum currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kNormal; - SmokeCoAlarm::AlarmStateEnum currentBatteryState = SmokeCoAlarm::AlarmStateEnum::kNormal; - SmokeCoAlarm::AlarmStateEnum currentInterconnectSmokeAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; - ; - SmokeCoAlarm::AlarmStateEnum currentInterconnectCoAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; - ; - SmokeCoAlarm::AlarmStateEnum currentCoAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; - ; - SmokeCoAlarm::AlarmStateEnum currentSmokeAlarm = SmokeCoAlarm::AlarmStateEnum::kNormal; - ; - bool currentTestInProgress = false; - ; - SmokeCoAlarm::AlarmStateEnum currentHardwareFault = SmokeCoAlarm::AlarmStateEnum::kNormal; - ; - SmokeCoAlarm::EndOfServiceEnum currentEndOfService = SmokeCoAlarm::EndOfServiceEnum::kNormal; - - SmokeCoAlarmServer::Instance().GetBatteryAlert(1, currentBatteryState); - SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(1, currentEndOfService); - - SmokeCoAlarmServer::Instance().GetInterconnectSmokeAlarm(1, currentInterconnectSmokeAlarm); - SmokeCoAlarmServer::Instance().GetInterconnectCOAlarm(1, currentInterconnectCoAlarm); - SmokeCoAlarmServer::Instance().GetCOState(1, currentCoAlarm); - SmokeCoAlarmServer::Instance().GetSmokeState(1, currentSmokeAlarm); - SmokeCoAlarmServer::Instance().GetTestInProgress(1, currentTestInProgress); - - // This is written going lowest to highest priority - // If someone wanted to change the order it makes it easier - if (currentBatteryState != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kBatteryAlert; - if (currentEndOfService != SmokeCoAlarm::EndOfServiceEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kEndOfService; - if (currentTestInProgress != false) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kTesting; - if (currentHardwareFault != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kHardwareFault; - if (currentInterconnectCoAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kInterconnectCO; - if (currentCoAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kCOAlarm; - if (currentInterconnectSmokeAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kInterconnectSmoke; - if (currentSmokeAlarm != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kSmokeAlarm; - - SmokeCoAlarmServer::Instance().SetExpressedState(1, currentExpressedState); -} - -} // namespace chip + ExpressedStateEnum currentExpressedState = ExpressedStateEnum::kNormal; + for (ExpressedStateEnum priority : priorityOrder) + { + switch (priority) + { + case ExpressedStateEnum::kSmokeAlarm: { + SmokeCoAlarmServer::Instance().GetSmokeState(mEndpointId, mCurrentSmokeAlarm); + if (mCurrentSmokeAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kSmokeAlarm; + } + } + break; + case ExpressedStateEnum::kCOAlarm: { + SmokeCoAlarmServer::Instance().GetCOState(mEndpointId, mCurrentCoAlarm); + if (mCurrentCoAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kCOAlarm; + } + } + break; + case ExpressedStateEnum::kBatteryAlert: { + SmokeCoAlarmServer::Instance().GetBatteryAlert(mEndpointId, mCurrentBatteryState); + if (mCurrentBatteryState != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kBatteryAlert; + } + } + break; + case ExpressedStateEnum::kTesting: { + SmokeCoAlarmServer::Instance().GetTestInProgress(mEndpointId, mCurrentTestInProgress); + if (mCurrentTestInProgress != false) + { + currentExpressedState = ExpressedStateEnum::kTesting; + } + } + break; + case ExpressedStateEnum::kHardwareFault: { + SmokeCoAlarmServer::Instance().GetHardwareFaultAlert(mEndpointId, mCurrentHardwareFault); + if (mCurrentHardwareFault != false) + { + currentExpressedState = ExpressedStateEnum::kHardwareFault; + } + } + break; + case ExpressedStateEnum::kEndOfService: { + SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(mEndpointId, mCurrentEndOfService); + if (mCurrentEndOfService != EndOfServiceEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kEndOfService; + } + } + break; + case ExpressedStateEnum::kInterconnectSmoke: { + SmokeCoAlarmServer::Instance().GetInterconnectSmokeAlarm(mEndpointId, mCurrentInterconnectSmokeAlarm); + if (mCurrentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kInterconnectSmoke; + } + } + break; + case ExpressedStateEnum::kInterconnectCO: { + SmokeCoAlarmServer::Instance().GetInterconnectCOAlarm(mEndpointId, mCurrentInterconnectCoAlarm); + if (mCurrentInterconnectCoAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kInterconnectCO; + } + } + break; + + default: + break; + } + + if (currentExpressedState != ExpressedStateEnum::kNormal) + { + break; + } + } + SmokeCoAlarmServer::Instance().SetExpressedState(mEndpointId, currentExpressedState); +} +} // namespace chip diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h index c3d5a12b696b9d..af23f212c67fd8 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h @@ -1,7 +1,6 @@ /* * - * Copyright (c) 2022 Project CHIP Authors - * All rights reserved. + * Copyright (c) 2023 Project CHIP Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,58 +19,83 @@ #include -namespace chip { -namespace trigger { - -// force alarm commands -const uint64_t ForceSmokeWarning = 0xffffffff00000090; -const uint64_t ForceSmokeInterconnect = 0xffffffff00000092; -const uint64_t ForceCOInterconnect = 0xffffffff00000094; -const uint64_t ForceSmokeContaminationHigh = 0xffffffff00000096; -const uint64_t ForceSmokeContaminationLow = 0xffffffff00000097; -const uint64_t ForceSmokeSensitivityHigh = 0xffffffff00000098; -const uint64_t ForceSmokeSensitivityLow = 0xffffffff00000099; -const uint64_t ForceSmokeCritical = 0xffffffff0000009c; - -const uint64_t ForceCOWarning = 0xffffffff00000091; -const uint64_t ForceCOCritical = 0xffffffff0000009d; +#include -const uint64_t ForceMalfunction = 0xffffffff00000093; - -const uint64_t ForceLowBatteryWarning = 0xffffffff00000095; -const uint64_t ForceLowBatteryCritical = 0xffffffff0000009e; - -const uint64_t ForceCOEndOfLife = 0xffffffff0000009a; -const uint64_t ForceSilence = 0xffffffff0000009b; +namespace chip { -// clear alarm commands -const uint64_t ClearSmoke = 0xffffffff000000a0; -const uint64_t ClearCO = 0xffffffff000000a1; -const uint64_t ClearSmokeInterconnect = 0xffffffff000000a2; -const uint64_t ClearMalfunction = 0xffffffff000000a3; -const uint64_t ClearCOInterconnect = 0xffffffff000000a4; -const uint64_t ClearBatteryLevelLow = 0xffffffff000000a5; -const uint64_t ClearContamination = 0xffffffff000000a6; -const uint64_t ClearSensitivity = 0xffffffff000000a8; +enum class Trigger : uint64_t +{ + // Force alarm commands + kForceSmokeWarning = 0xffffffff00000090, + kForceCOWarning = 0xffffffff00000091, + kForceSmokeInterconnect = 0xffffffff00000092, + kForceMalfunction = 0xffffffff00000093, + kForceCOInterconnect = 0xffffffff00000094, + kForceLowBatteryWarning = 0xffffffff00000095, + kForceSmokeContaminationHigh = 0xffffffff00000096, + kForceSmokeContaminationLow = 0xffffffff00000097, + kForceSmokeSensitivityHigh = 0xffffffff00000098, + kForceSmokeSensitivityLow = 0xffffffff00000099, + kForceEndOfLife = 0xffffffff0000009a, + kForceSilence = 0xffffffff0000009b, + kForceSmokeCritical = 0xffffffff0000009c, + kForceCOCritical = 0xffffffff0000009d, + kForceLowBatteryCritical = 0xffffffff0000009e, + // Clear alarm commands + kClearSmoke = 0xffffffff000000a0, + kClearCO = 0xffffffff000000a1, + kClearSmokeInterconnect = 0xffffffff000000a2, + kClearMalfunction = 0xffffffff000000a3, + kClearCOInterconnect = 0xffffffff000000a4, + kClearBatteryLevelLow = 0xffffffff000000a5, + kClearContamination = 0xffffffff000000a6, + kClearSensitivity = 0xffffffff000000a8, + kClearEndOfLife = 0xffffffff000000aa, + kClearSilence = 0xffffffff000000ab +}; -const uint64_t ClearCOEndOfLife = 0xffffffff000000aa; -const uint64_t ClearSilence = 0xffffffff000000ab; -} // namespace trigger class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate { public: - explicit SmokeCOTestEventTriggerDelegate(const ByteSpan & enableKey) : mEnableKey(enableKey) {} + explicit SmokeCOTestEventTriggerDelegate(const ByteSpan & enableKey, TestEventTriggerDelegate * otherDelegate, + EndpointId endpointId) : + mEnableKey(enableKey), + mOtherDelegate(otherDelegate), mEndpointId(endpointId) + {} bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override; CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override; - CHIP_ERROR SetSmokeCODelegate(TestEventTriggerDelegate * scoDelegate); - // Highest level of Expressed state is Manufacturer specific. - // This is specifically written in support of certification test TC-2.6 - void ExampleSetExpressedState (void); + + using ExpressedStateEnum = app::Clusters::SmokeCoAlarm::ExpressedStateEnum; + using AlarmStateEnum = app::Clusters::SmokeCoAlarm::AlarmStateEnum; + using EndOfServiceEnum = app::Clusters::SmokeCoAlarm::EndOfServiceEnum; + + /** + * @brief The priority order for expressed alarms from Highest to lowest. + */ + std::array priorityOrder = { ExpressedStateEnum::kSmokeAlarm, ExpressedStateEnum::kInterconnectSmoke, + ExpressedStateEnum::kCOAlarm, ExpressedStateEnum::kInterconnectCO, + ExpressedStateEnum::kHardwareFault, ExpressedStateEnum::kTesting, + ExpressedStateEnum::kEndOfService, ExpressedStateEnum::kBatteryAlert }; private: ByteSpan mEnableKey; + TestEventTriggerDelegate * mOtherDelegate; + EndpointId mEndpointId; + + AlarmStateEnum mCurrentSmokeAlarm; + AlarmStateEnum mCurrentInterconnectSmokeAlarm; + AlarmStateEnum mCurrentCoAlarm; + AlarmStateEnum mCurrentInterconnectCoAlarm; + AlarmStateEnum mCurrentBatteryState; + EndOfServiceEnum mCurrentEndOfService; + bool mCurrentTestInProgress; + bool mCurrentHardwareFault; + /** + * @brief Highest level of Expressed state is Manufacturer specific. + */ + void SetExpressedState(void); }; } // namespace chip diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn index 9f08edbd383676..04c4d522b5abe7 100644 --- a/src/platform/BUILD.gn +++ b/src/platform/BUILD.gn @@ -137,10 +137,6 @@ if (chip_device_platform != "none" && chip_device_platform != "external") { defines += [ "CHIP_DEVICE_CONFIG_ENABLE_OTA_REQUESTOR=1" ] } -# if (chip_enable_smoke_co_alarm) { -# defines += [ "CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_ALARM=1" ] -# } - if (chip_device_project_config_include != "") { defines += [ "CHIP_DEVICE_PROJECT_CONFIG_INCLUDE=${chip_device_project_config_include}" ] } diff --git a/src/platform/Linux/args.gni b/src/platform/Linux/args.gni index be2389fca6ad1c..f9f97ee30d2c91 100644 --- a/src/platform/Linux/args.gni +++ b/src/platform/Linux/args.gni @@ -13,4 +13,3 @@ # limitations under the License. chip_device_platform = "linux" -chip_enable_smoke_co_alarm = true \ No newline at end of file diff --git a/src/platform/device.gni b/src/platform/device.gni index 32edea58c2bc15..b70b576644318e 100644 --- a/src/platform/device.gni +++ b/src/platform/device.gni @@ -81,7 +81,6 @@ declare_args() { # Enable OTA requestor support chip_enable_ota_requestor = false - chip_enable_smoke_co_alarm = false # Select DNS-SD implementation if (chip_device_platform == "linux" || chip_device_platform == "esp32" || From 57ef7590a288ef958413fd3c4db56934c776c917 Mon Sep 17 00:00:00 2001 From: Hare Date: Mon, 7 Aug 2023 10:19:47 +0800 Subject: [PATCH 03/12] Move priority order to server --- examples/all-clusters-app/linux/smco-stub.cpp | 25 +-- .../SmokeCOTestEventTriggerDelegate.cpp | 162 +++++------------- .../SmokeCOTestEventTriggerDelegate.h | 26 --- .../smoke-co-alarm-server.cpp | 91 ++++++++++ .../smoke-co-alarm-server.h | 34 ++++ 5 files changed, 168 insertions(+), 170 deletions(-) diff --git a/examples/all-clusters-app/linux/smco-stub.cpp b/examples/all-clusters-app/linux/smco-stub.cpp index f63139cd3b9086..3b5acfd042fc8a 100644 --- a/examples/all-clusters-app/linux/smco-stub.cpp +++ b/examples/all-clusters-app/linux/smco-stub.cpp @@ -15,19 +15,12 @@ * limitations under the License. */ -#include - #include #include #include -#include -#include -#include -#include // std::chrono::seconds -#include // std::cout -#include // std::thread, std::this_thread::sleep_for +#include using namespace chip; using namespace chip::app::Clusters; @@ -39,22 +32,10 @@ void TestModeTimeoutThread(int timeout) ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self test running\033[0;37m"); std::this_thread::sleep_for(std::chrono::seconds(timeout)); + PlatformMgr().LockChipStack(); SmokeCoAlarmServer::Instance().SetTestInProgress(1, false); - - SmokeCoAlarm::AlarmStateEnum currentBatteryState = SmokeCoAlarm::AlarmStateEnum::kNormal; - SmokeCoAlarm::EndOfServiceEnum currentEndOfService = SmokeCoAlarm::EndOfServiceEnum::kNormal; - SmokeCoAlarm::ExpressedStateEnum currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kNormal; - - SmokeCoAlarmServer::Instance().GetBatteryAlert(1, currentBatteryState); - SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(1, currentEndOfService); - - if (currentBatteryState != SmokeCoAlarm::AlarmStateEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kBatteryAlert; - if (currentEndOfService != SmokeCoAlarm::EndOfServiceEnum::kNormal) - currentExpressedState = SmokeCoAlarm::ExpressedStateEnum::kEndOfService; - SmokeCoAlarmServer::Instance().SetExpressedState(1, currentExpressedState); - + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1); PlatformMgr().UnlockChipStack(); ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self Test Timer Complete\033[0;37m"); diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index b4e0f2f6fc724b..cc727c11eb2821 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -38,33 +38,35 @@ CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTri { case Trigger::kForceSmokeCritical: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kCritical); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceSmokeWarning: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kWarning); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceSmokeInterconnect: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kWarning); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kWarning), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceCOCritical: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kCritical); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceCOWarning: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kWarning); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceCOInterconnect: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kWarning); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kWarning), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceSmokeContaminationHigh: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical) \033[0;37m"); @@ -84,23 +86,24 @@ CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTri break; case Trigger::kForceMalfunction: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force malfunction\033[0;37m"); - SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, true); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, true), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceLowBatteryWarning: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kWarning); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceLowBatteryCritical: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kCritical); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceEndOfLife: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force end-of-life\033[0;37m"); - SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kExpired); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kExpired), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kForceSilence: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force silence\033[0;37m"); @@ -108,33 +111,36 @@ CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTri break; case Trigger::kClearSmoke: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kNormal); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearCO: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO\033[0;37m"); - SetExpressedState(); - SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kNormal); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearSmokeInterconnect: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect\033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kNormal); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kNormal), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearCOInterconnect: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect\033[0;37m"); - SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kNormal); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kNormal), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearMalfunction: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear malfunction\033[0;37m"); - SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, false); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, false), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearEndOfLife: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear end-of-life\033[0;37m"); - SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kNormal); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kNormal), + CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearSilence: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear silence\033[0;37m"); @@ -142,8 +148,8 @@ CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTri break; case Trigger::kClearBatteryLevelLow: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear low battery\033[0;37m"); - SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kNormal); - SetExpressedState(); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); break; case Trigger::kClearContamination: ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning) \033[0;37m"); @@ -154,98 +160,10 @@ CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTri SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kStandard); break; default: - ChipLogProgress(Support, " Unknown Smoke CO Event"); - return (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; } return CHIP_NO_ERROR; } -void SmokeCOTestEventTriggerDelegate::SetExpressedState(void) -{ - ExpressedStateEnum currentExpressedState = ExpressedStateEnum::kNormal; - - for (ExpressedStateEnum priority : priorityOrder) - { - switch (priority) - { - case ExpressedStateEnum::kSmokeAlarm: { - SmokeCoAlarmServer::Instance().GetSmokeState(mEndpointId, mCurrentSmokeAlarm); - if (mCurrentSmokeAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kSmokeAlarm; - } - } - break; - case ExpressedStateEnum::kCOAlarm: { - SmokeCoAlarmServer::Instance().GetCOState(mEndpointId, mCurrentCoAlarm); - if (mCurrentCoAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kCOAlarm; - } - } - break; - case ExpressedStateEnum::kBatteryAlert: { - SmokeCoAlarmServer::Instance().GetBatteryAlert(mEndpointId, mCurrentBatteryState); - if (mCurrentBatteryState != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kBatteryAlert; - } - } - break; - case ExpressedStateEnum::kTesting: { - SmokeCoAlarmServer::Instance().GetTestInProgress(mEndpointId, mCurrentTestInProgress); - if (mCurrentTestInProgress != false) - { - currentExpressedState = ExpressedStateEnum::kTesting; - } - } - break; - case ExpressedStateEnum::kHardwareFault: { - SmokeCoAlarmServer::Instance().GetHardwareFaultAlert(mEndpointId, mCurrentHardwareFault); - if (mCurrentHardwareFault != false) - { - currentExpressedState = ExpressedStateEnum::kHardwareFault; - } - } - break; - case ExpressedStateEnum::kEndOfService: { - SmokeCoAlarmServer::Instance().GetEndOfServiceAlert(mEndpointId, mCurrentEndOfService); - if (mCurrentEndOfService != EndOfServiceEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kEndOfService; - } - } - break; - case ExpressedStateEnum::kInterconnectSmoke: { - SmokeCoAlarmServer::Instance().GetInterconnectSmokeAlarm(mEndpointId, mCurrentInterconnectSmokeAlarm); - if (mCurrentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kInterconnectSmoke; - } - } - break; - case ExpressedStateEnum::kInterconnectCO: { - SmokeCoAlarmServer::Instance().GetInterconnectCOAlarm(mEndpointId, mCurrentInterconnectCoAlarm); - if (mCurrentInterconnectCoAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kInterconnectCO; - } - } - break; - - default: - break; - } - - if (currentExpressedState != ExpressedStateEnum::kNormal) - { - break; - } - } - - SmokeCoAlarmServer::Instance().SetExpressedState(mEndpointId, currentExpressedState); -} - } // namespace chip diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h index af23f212c67fd8..a6c7cefd7479aa 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h @@ -66,36 +66,10 @@ class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override; CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) override; - using ExpressedStateEnum = app::Clusters::SmokeCoAlarm::ExpressedStateEnum; - using AlarmStateEnum = app::Clusters::SmokeCoAlarm::AlarmStateEnum; - using EndOfServiceEnum = app::Clusters::SmokeCoAlarm::EndOfServiceEnum; - - /** - * @brief The priority order for expressed alarms from Highest to lowest. - */ - std::array priorityOrder = { ExpressedStateEnum::kSmokeAlarm, ExpressedStateEnum::kInterconnectSmoke, - ExpressedStateEnum::kCOAlarm, ExpressedStateEnum::kInterconnectCO, - ExpressedStateEnum::kHardwareFault, ExpressedStateEnum::kTesting, - ExpressedStateEnum::kEndOfService, ExpressedStateEnum::kBatteryAlert }; - private: ByteSpan mEnableKey; TestEventTriggerDelegate * mOtherDelegate; EndpointId mEndpointId; - - AlarmStateEnum mCurrentSmokeAlarm; - AlarmStateEnum mCurrentInterconnectSmokeAlarm; - AlarmStateEnum mCurrentCoAlarm; - AlarmStateEnum mCurrentInterconnectCoAlarm; - AlarmStateEnum mCurrentBatteryState; - EndOfServiceEnum mCurrentEndOfService; - bool mCurrentTestInProgress; - bool mCurrentHardwareFault; - - /** - * @brief Highest level of Expressed state is Manufacturer specific. - */ - void SetExpressedState(void); }; } // namespace chip diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index c5f109fac63a31..58111825308a81 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -72,6 +72,97 @@ bool SmokeCoAlarmServer::SetExpressedState(EndpointId endpointId, ExpressedState return success; } +bool SmokeCoAlarmServer::AutoSetExpressedState(EndpointId endpointId) +{ + ExpressedStateEnum currentExpressedState = ExpressedStateEnum::kNormal; + + for (ExpressedStateEnum priority : mPriorityOrder) + { + switch (priority) + { + case ExpressedStateEnum::kSmokeAlarm: { + VerifyOrReturnValue(GetSmokeState(endpointId, mCurrentSmokeAlarm), false); + if (mCurrentSmokeAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kSmokeAlarm; + } + } + break; + case ExpressedStateEnum::kCOAlarm: { + VerifyOrReturnValue(GetCOState(endpointId, mCurrentCoAlarm), false); + if (mCurrentCoAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kCOAlarm; + } + } + break; + case ExpressedStateEnum::kBatteryAlert: { + VerifyOrReturnValue(GetBatteryAlert(endpointId, mCurrentBatteryState), false); + if (mCurrentBatteryState != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kBatteryAlert; + } + } + break; + case ExpressedStateEnum::kTesting: { + VerifyOrReturnValue(GetTestInProgress(endpointId, mCurrentTestInProgress), false); + if (mCurrentTestInProgress != false) + { + currentExpressedState = ExpressedStateEnum::kTesting; + } + } + break; + case ExpressedStateEnum::kHardwareFault: { + VerifyOrReturnValue(GetHardwareFaultAlert(endpointId, mCurrentHardwareFault), false); + if (mCurrentHardwareFault != false) + { + currentExpressedState = ExpressedStateEnum::kHardwareFault; + } + } + break; + case ExpressedStateEnum::kEndOfService: { + VerifyOrReturnValue(GetEndOfServiceAlert(endpointId, mCurrentEndOfService), false); + if (mCurrentEndOfService != EndOfServiceEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kEndOfService; + } + } + break; + case ExpressedStateEnum::kInterconnectSmoke: { + VerifyOrReturnValue(GetInterconnectSmokeAlarm(endpointId, mCurrentInterconnectSmokeAlarm), false); + if (mCurrentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kInterconnectSmoke; + } + } + break; + case ExpressedStateEnum::kInterconnectCO: { + VerifyOrReturnValue(GetInterconnectCOAlarm(endpointId, mCurrentInterconnectCoAlarm), false); + if (mCurrentInterconnectCoAlarm != AlarmStateEnum::kNormal) + { + currentExpressedState = ExpressedStateEnum::kInterconnectCO; + } + } + break; + + default: + break; + } + + if (currentExpressedState != ExpressedStateEnum::kNormal) + { + break; + } + } + + return SetExpressedState(endpointId, currentExpressedState); +} + +void SmokeCoAlarmServer::SetPriorityOrder(std::array newPriorityOrder) +{ + mPriorityOrder = newPriorityOrder; +} + bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) { AlarmStateEnum smokeState; diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h index 529df2ed766807..ec9a470b6a57a2 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h @@ -38,6 +38,9 @@ class SmokeCoAlarmServer public: static SmokeCoAlarmServer & Instance(); + /* Expected byte size of the PriorityOrder */ + static constexpr size_t kPriorityOrderLength = 8; + using AlarmStateEnum = chip::app::Clusters::SmokeCoAlarm::AlarmStateEnum; using ContaminationStateEnum = chip::app::Clusters::SmokeCoAlarm::ContaminationStateEnum; using EndOfServiceEnum = chip::app::Clusters::SmokeCoAlarm::EndOfServiceEnum; @@ -61,6 +64,19 @@ class SmokeCoAlarmServer */ bool SetExpressedState(chip::EndpointId endpointId, ExpressedStateEnum newExpressedState); + /** + * @brief Set the highest level of Expressed State according to priorityOrder + * @param endpointId ID of the endpoint + * @return true on success, false on failure + */ + bool AutoSetExpressedState(chip::EndpointId endpointId); + + /** + * @brief Set priority order + * @param newPriorityOrder new priority order + */ + void SetPriorityOrder(std::array newPriorityOrder); + bool SetSmokeState(chip::EndpointId endpointId, AlarmStateEnum newSmokeState); bool SetCOState(chip::EndpointId endpointId, AlarmStateEnum newCOState); bool SetBatteryAlert(chip::EndpointId endpointId, AlarmStateEnum newBatteryAlert); @@ -148,6 +164,24 @@ class SmokeCoAlarmServer chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::DecodableType & commandData); + /** + * @brief The priority order of expressed state from highest to lowest + */ + std::array mPriorityOrder = { + ExpressedStateEnum::kSmokeAlarm, ExpressedStateEnum::kInterconnectSmoke, ExpressedStateEnum::kCOAlarm, + ExpressedStateEnum::kInterconnectCO, ExpressedStateEnum::kHardwareFault, ExpressedStateEnum::kTesting, + ExpressedStateEnum::kEndOfService, ExpressedStateEnum::kBatteryAlert + }; + + AlarmStateEnum mCurrentSmokeAlarm; + AlarmStateEnum mCurrentInterconnectSmokeAlarm; + AlarmStateEnum mCurrentCoAlarm; + AlarmStateEnum mCurrentInterconnectCoAlarm; + AlarmStateEnum mCurrentBatteryState; + EndOfServiceEnum mCurrentEndOfService; + bool mCurrentTestInProgress; + bool mCurrentHardwareFault; + static SmokeCoAlarmServer sInstance; }; From f9d27fe5fc251e842d2e77d94fa9180585569f33 Mon Sep 17 00:00:00 2001 From: Hare Date: Tue, 8 Aug 2023 13:51:41 +0800 Subject: [PATCH 04/12] Revision per review comments --- .../all-clusters-common/src/smco-stub.cpp | 172 +++++++++++++++++- examples/all-clusters-app/linux/BUILD.gn | 2 +- examples/all-clusters-app/linux/args.gni | 3 - examples/all-clusters-app/linux/smco-stub.cpp | 51 ------ examples/platform/linux/AppMain.cpp | 2 +- .../SmokeCOTestEventTriggerDelegate.cpp | 137 +------------- .../SmokeCOTestEventTriggerDelegate.h | 24 ++- .../smoke-co-alarm-server.cpp | 63 +++---- .../smoke-co-alarm-server.h | 30 +-- 9 files changed, 221 insertions(+), 263 deletions(-) delete mode 100644 examples/all-clusters-app/linux/smco-stub.cpp diff --git a/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp b/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp index 66f86e5b28ab99..6e6b7748f1f359 100644 --- a/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp @@ -15,9 +15,177 @@ * limitations under the License. */ -#include +#include +#include -bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(chip::EndpointId endpointId) +#include + +using namespace chip; +using namespace chip::app::Clusters::SmokeCoAlarm; +using namespace chip::DeviceLayer; + +namespace { + +constexpr const uint16_t kSelfTestingTimeout = 10; + +} // namespace + +static std::array sPriorityOrder = { + ExpressedStateEnum::kSmokeAlarm, ExpressedStateEnum::kInterconnectSmoke, ExpressedStateEnum::kCOAlarm, + ExpressedStateEnum::kInterconnectCO, ExpressedStateEnum::kHardwareFault, ExpressedStateEnum::kTesting, + ExpressedStateEnum::kEndOfService, ExpressedStateEnum::kBatteryAlert +}; + +void EndSelfTestingEventHandler(System::Layer * systemLayer, void * appState) +{ + SmokeCoAlarmServer::Instance().SetTestInProgress(1, false); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + + ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test complete"); +} + +void SelfTestingEventHandler() +{ + ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test running"); + + DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(kSelfTestingTimeout), EndSelfTestingEventHandler, nullptr); +} + +bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(EndpointId endpointId) { + SmokeCoAlarmServer::Instance().SetTestInProgress(1, true); + SelfTestingEventHandler(); + + return true; +} + +bool emberAfHandleEventTrigger(uint64_t eventTrigger) +{ + SmokeCOTrigger trigger = static_cast(eventTrigger); + + switch (trigger) + { + case SmokeCOTrigger::kForceSmokeCritical: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (critical)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kCritical), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceSmokeWarning: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (warning)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kWarning), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceSmokeInterconnect: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kWarning), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceCOCritical: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (critical)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kCritical), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceCOWarning: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kWarning), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceCOInterconnect: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kWarning), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceSmokeContaminationHigh: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical)"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kCritical); + break; + case SmokeCOTrigger::kForceSmokeContaminationLow: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (warning)"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kLow); + break; + case SmokeCOTrigger::kForceSmokeSensitivityHigh: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke sensistivity (high)"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kHigh); + break; + case SmokeCOTrigger::kForceSmokeSensitivityLow: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke sensitivity (low)"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kLow); + break; + case SmokeCOTrigger::kForceMalfunction: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force malfunction"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, true), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceLowBatteryWarning: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (warning)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kWarning), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceLowBatteryCritical: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (critical)"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kCritical), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceEndOfLife: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force end-of-life"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kExpired), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kForceSilence: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force silence"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(1, MuteStateEnum::kMuted); + break; + case SmokeCOTrigger::kClearSmoke: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearCO: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearSmokeInterconnect: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearCOInterconnect: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearMalfunction: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear malfunction"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, false), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearEndOfLife: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear end-of-life"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearSilence: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear silence"); + SmokeCoAlarmServer::Instance().SetDeviceMuted(1, MuteStateEnum::kNotMuted); + break; + case SmokeCOTrigger::kClearBatteryLevelLow: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear low battery"); + VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kNormal), true); + SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + break; + case SmokeCOTrigger::kClearContamination: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning)"); + SmokeCoAlarmServer::Instance().SetContaminationState(1, ContaminationStateEnum::kNormal); + break; + case SmokeCOTrigger::kClearSensitivity: + ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear Smoke Sensitivity"); + SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(1, SensitivityEnum::kStandard); + break; + default: + + return false; + } + return true; } diff --git a/examples/all-clusters-app/linux/BUILD.gn b/examples/all-clusters-app/linux/BUILD.gn index 1d9696b5f04f60..766b482e5a4600 100644 --- a/examples/all-clusters-app/linux/BUILD.gn +++ b/examples/all-clusters-app/linux/BUILD.gn @@ -32,10 +32,10 @@ source_set("chip-all-clusters-common") { "${chip_root}/examples/all-clusters-app/all-clusters-common/src/operational-state-delegates.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/resource-monitoring-instances.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/rvc-modes.cpp", + "${chip_root}/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-temperature-levels.cpp", "${chip_root}/examples/all-clusters-app/all-clusters-common/src/tcc-mode.cpp", - "${chip_root}/examples/all-clusters-app/linux/smco-stub.cpp", "AllClustersCommandDelegate.cpp", "AppOptions.cpp", "WindowCoveringManager.cpp", diff --git a/examples/all-clusters-app/linux/args.gni b/examples/all-clusters-app/linux/args.gni index 741af837361765..1bcd86f18843b8 100644 --- a/examples/all-clusters-app/linux/args.gni +++ b/examples/all-clusters-app/linux/args.gni @@ -28,6 +28,3 @@ matter_enable_tracing_support = true matter_log_json_payload_decode_full = true matter_log_json_payload_hex = true chip_enable_smoke_co_trigger = true - -# Perfetto requires C++17 -cpp_standard = "gnu++17" diff --git a/examples/all-clusters-app/linux/smco-stub.cpp b/examples/all-clusters-app/linux/smco-stub.cpp deleted file mode 100644 index 3b5acfd042fc8a..00000000000000 --- a/examples/all-clusters-app/linux/smco-stub.cpp +++ /dev/null @@ -1,51 +0,0 @@ -/* - * - * Copyright (c) 2023 Project CHIP Authors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include -#include - -#include - -#include - -using namespace chip; -using namespace chip::app::Clusters; -using namespace chip::app::Clusters::SmokeCoAlarm; -using namespace chip::DeviceLayer; - -void TestModeTimeoutThread(int timeout) -{ - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self test running\033[0;37m"); - - std::this_thread::sleep_for(std::chrono::seconds(timeout)); - - PlatformMgr().LockChipStack(); - SmokeCoAlarmServer::Instance().SetTestInProgress(1, false); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1); - PlatformMgr().UnlockChipStack(); - - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Self Test Timer Complete\033[0;37m"); -} - -bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(chip::EndpointId endpointId) -{ - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm] => Starting Self Test Timer\033[0;37m"); - - SmokeCoAlarmServer::Instance().SetTestInProgress(1, true); - std::thread(TestModeTimeoutThread, 20).detach(); - return true; -} diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 9c8c05ebe90bab..ea52a49e79634a 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -528,7 +528,7 @@ void ChipLinuxAppMainLoop(AppMainLoopImplementation * impl) #endif #if CHIP_DEVICE_CONFIG_ENABLE_SMOKE_CO_TRIGGER static SmokeCOTestEventTriggerDelegate smokeCOTestEventTriggerDelegate{ - ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), otherDelegate, 1 + ByteSpan(LinuxDeviceOptions::GetInstance().testEventTriggerEnableKey), otherDelegate }; otherDelegate = &smokeCOTestEventTriggerDelegate; #endif diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index cc727c11eb2821..b9af78e47f8d4c 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -17,10 +17,6 @@ #include "SmokeCOTestEventTriggerDelegate.h" -#include - -#include - using namespace chip::app::Clusters::SmokeCoAlarm; namespace chip { @@ -32,136 +28,9 @@ bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enable CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) { - Trigger trigger = static_cast(eventTrigger); - - switch (trigger) - { - case Trigger::kForceSmokeCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (critical) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceSmokeWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke (warning) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceSmokeInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kWarning), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceCOCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (critical) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceCOWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceCOInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force CO (warning) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kWarning), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceSmokeContaminationHigh: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kCritical); - break; - case Trigger::kForceSmokeContaminationLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kLow); - break; - case Trigger::kForceSmokeSensitivityHigh: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke sensistivity (high) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kHigh); - break; - case Trigger::kForceSmokeSensitivityLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force smoke sensitivity (low) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kLow); - break; - case Trigger::kForceMalfunction: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force malfunction\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, true), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceLowBatteryWarning: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (warning) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kWarning), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceLowBatteryCritical: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force low battery (critical) \033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kCritical), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceEndOfLife: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force end-of-life\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kExpired), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kForceSilence: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force silence\033[0;37m"); - SmokeCoAlarmServer::Instance().SetDeviceMuted(mEndpointId, MuteStateEnum::kMuted); - break; - case Trigger::kClearSmoke: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearCO: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearSmokeInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(mEndpointId, AlarmStateEnum::kNormal), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearCOInterconnect: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(mEndpointId, AlarmStateEnum::kNormal), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearMalfunction: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear malfunction\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(mEndpointId, false), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearEndOfLife: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear end-of-life\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(mEndpointId, EndOfServiceEnum::kNormal), - CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearSilence: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear silence\033[0;37m"); - SmokeCoAlarmServer::Instance().SetDeviceMuted(mEndpointId, MuteStateEnum::kNotMuted); - break; - case Trigger::kClearBatteryLevelLow: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear low battery\033[0;37m"); - VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(mEndpointId, AlarmStateEnum::kNormal), CHIP_NO_ERROR); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(mEndpointId); - break; - case Trigger::kClearContamination: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning) \033[0;37m"); - SmokeCoAlarmServer::Instance().SetContaminationState(mEndpointId, ContaminationStateEnum::kNormal); - break; - case Trigger::kClearSensitivity: - ChipLogProgress(Support, " \033[0;96m[Smoke-CO-Alarm-Test-Event] => Clear Smoke Sensitivity\033[0;37m"); - SmokeCoAlarmServer::Instance().SetSmokeSensitivityLevel(mEndpointId, SensitivityEnum::kStandard); - break; - default: - return (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT; - } + VerifyOrReturnValue(emberAfHandleEventTrigger(eventTrigger), + (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) + : CHIP_ERROR_INVALID_ARGUMENT); return CHIP_NO_ERROR; } diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h index a6c7cefd7479aa..110a40c13965d6 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h @@ -17,13 +17,12 @@ #pragma once -#include - #include +#include namespace chip { -enum class Trigger : uint64_t +enum class SmokeCOTrigger : uint64_t { // Force alarm commands kForceSmokeWarning = 0xffffffff00000090, @@ -57,10 +56,8 @@ enum class Trigger : uint64_t class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate { public: - explicit SmokeCOTestEventTriggerDelegate(const ByteSpan & enableKey, TestEventTriggerDelegate * otherDelegate, - EndpointId endpointId) : - mEnableKey(enableKey), - mOtherDelegate(otherDelegate), mEndpointId(endpointId) + explicit SmokeCOTestEventTriggerDelegate(const ByteSpan & enableKey, TestEventTriggerDelegate * otherDelegate) : + mEnableKey(enableKey), mOtherDelegate(otherDelegate) {} bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override; @@ -69,7 +66,18 @@ class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate private: ByteSpan mEnableKey; TestEventTriggerDelegate * mOtherDelegate; - EndpointId mEndpointId; }; } // namespace chip + +/** + * @brief User handler for handling the test event trigger + * + * @note If TestEventTrigger is enabled, it needs to be implemented in the app + * + * @param eventTrigger Event trigger to handle + * + * @retval true on success + * @retval false if error happened + */ +bool emberAfHandleEventTrigger(uint64_t eventTrigger); diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index 58111825308a81..c6988d56bcef62 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -22,23 +22,12 @@ */ #include "smoke-co-alarm-server.h" + #include -#include -#include #include -#include -#include -#include -#include - -#include -#include -#include -#include using namespace chip; using namespace chip::app; -using namespace chip::app::DataModel; using namespace chip::app::Clusters::SmokeCoAlarm; using chip::Protocols::InteractionModel::Status; @@ -72,73 +61,82 @@ bool SmokeCoAlarmServer::SetExpressedState(EndpointId endpointId, ExpressedState return success; } -bool SmokeCoAlarmServer::AutoSetExpressedState(EndpointId endpointId) +bool SmokeCoAlarmServer::AutoSetExpressedState(EndpointId endpointId, + std::array priorityOrder) { ExpressedStateEnum currentExpressedState = ExpressedStateEnum::kNormal; - for (ExpressedStateEnum priority : mPriorityOrder) + for (ExpressedStateEnum priority : priorityOrder) { switch (priority) { case ExpressedStateEnum::kSmokeAlarm: { - VerifyOrReturnValue(GetSmokeState(endpointId, mCurrentSmokeAlarm), false); - if (mCurrentSmokeAlarm != AlarmStateEnum::kNormal) + AlarmStateEnum currentSmokeAlarm; + VerifyOrReturnValue(GetSmokeState(endpointId, currentSmokeAlarm), false); + if (currentSmokeAlarm != AlarmStateEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kSmokeAlarm; } } break; case ExpressedStateEnum::kCOAlarm: { - VerifyOrReturnValue(GetCOState(endpointId, mCurrentCoAlarm), false); - if (mCurrentCoAlarm != AlarmStateEnum::kNormal) + AlarmStateEnum currentCoAlarm; + VerifyOrReturnValue(GetCOState(endpointId, currentCoAlarm), false); + if (currentCoAlarm != AlarmStateEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kCOAlarm; } } break; case ExpressedStateEnum::kBatteryAlert: { - VerifyOrReturnValue(GetBatteryAlert(endpointId, mCurrentBatteryState), false); - if (mCurrentBatteryState != AlarmStateEnum::kNormal) + AlarmStateEnum currentBatteryState; + VerifyOrReturnValue(GetBatteryAlert(endpointId, currentBatteryState), false); + if (currentBatteryState != AlarmStateEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kBatteryAlert; } } break; case ExpressedStateEnum::kTesting: { - VerifyOrReturnValue(GetTestInProgress(endpointId, mCurrentTestInProgress), false); - if (mCurrentTestInProgress != false) + bool currentTestInProgress; + VerifyOrReturnValue(GetTestInProgress(endpointId, currentTestInProgress), false); + if (currentTestInProgress != false) { currentExpressedState = ExpressedStateEnum::kTesting; } } break; case ExpressedStateEnum::kHardwareFault: { - VerifyOrReturnValue(GetHardwareFaultAlert(endpointId, mCurrentHardwareFault), false); - if (mCurrentHardwareFault != false) + bool currentHardwareFault; + VerifyOrReturnValue(GetHardwareFaultAlert(endpointId, currentHardwareFault), false); + if (currentHardwareFault != false) { currentExpressedState = ExpressedStateEnum::kHardwareFault; } } break; case ExpressedStateEnum::kEndOfService: { - VerifyOrReturnValue(GetEndOfServiceAlert(endpointId, mCurrentEndOfService), false); - if (mCurrentEndOfService != EndOfServiceEnum::kNormal) + EndOfServiceEnum currentEndOfService; + VerifyOrReturnValue(GetEndOfServiceAlert(endpointId, currentEndOfService), false); + if (currentEndOfService != EndOfServiceEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kEndOfService; } } break; case ExpressedStateEnum::kInterconnectSmoke: { - VerifyOrReturnValue(GetInterconnectSmokeAlarm(endpointId, mCurrentInterconnectSmokeAlarm), false); - if (mCurrentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) + AlarmStateEnum currentInterconnectSmokeAlarm; + VerifyOrReturnValue(GetInterconnectSmokeAlarm(endpointId, currentInterconnectSmokeAlarm), false); + if (currentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kInterconnectSmoke; } } break; case ExpressedStateEnum::kInterconnectCO: { - VerifyOrReturnValue(GetInterconnectCOAlarm(endpointId, mCurrentInterconnectCoAlarm), false); - if (mCurrentInterconnectCoAlarm != AlarmStateEnum::kNormal) + AlarmStateEnum currentInterconnectCOAlarm; + VerifyOrReturnValue(GetInterconnectCOAlarm(endpointId, currentInterconnectCOAlarm), false); + if (currentInterconnectCOAlarm != AlarmStateEnum::kNormal) { currentExpressedState = ExpressedStateEnum::kInterconnectCO; } @@ -158,11 +156,6 @@ bool SmokeCoAlarmServer::AutoSetExpressedState(EndpointId endpointId) return SetExpressedState(endpointId, currentExpressedState); } -void SmokeCoAlarmServer::SetPriorityOrder(std::array newPriorityOrder) -{ - mPriorityOrder = newPriorityOrder; -} - bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) { AlarmStateEnum smokeState; diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h index ec9a470b6a57a2..48d4191d99a956 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h @@ -25,10 +25,7 @@ #include #include -#include #include -#include -#include /** * @brief Smoke CO Alarm Server Plugin class @@ -67,15 +64,10 @@ class SmokeCoAlarmServer /** * @brief Set the highest level of Expressed State according to priorityOrder * @param endpointId ID of the endpoint + * @param priorityOrder Priority order of expressed state from highest to lowest * @return true on success, false on failure */ - bool AutoSetExpressedState(chip::EndpointId endpointId); - - /** - * @brief Set priority order - * @param newPriorityOrder new priority order - */ - void SetPriorityOrder(std::array newPriorityOrder); + bool AutoSetExpressedState(chip::EndpointId endpointId, std::array priorityOrder); bool SetSmokeState(chip::EndpointId endpointId, AlarmStateEnum newSmokeState); bool SetCOState(chip::EndpointId endpointId, AlarmStateEnum newCOState); @@ -164,24 +156,6 @@ class SmokeCoAlarmServer chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::DecodableType & commandData); - /** - * @brief The priority order of expressed state from highest to lowest - */ - std::array mPriorityOrder = { - ExpressedStateEnum::kSmokeAlarm, ExpressedStateEnum::kInterconnectSmoke, ExpressedStateEnum::kCOAlarm, - ExpressedStateEnum::kInterconnectCO, ExpressedStateEnum::kHardwareFault, ExpressedStateEnum::kTesting, - ExpressedStateEnum::kEndOfService, ExpressedStateEnum::kBatteryAlert - }; - - AlarmStateEnum mCurrentSmokeAlarm; - AlarmStateEnum mCurrentInterconnectSmokeAlarm; - AlarmStateEnum mCurrentCoAlarm; - AlarmStateEnum mCurrentInterconnectCoAlarm; - AlarmStateEnum mCurrentBatteryState; - EndOfServiceEnum mCurrentEndOfService; - bool mCurrentTestInProgress; - bool mCurrentHardwareFault; - static SmokeCoAlarmServer sInstance; }; From 50b45149552df8fe1e4f26562b5c392671092b77 Mon Sep 17 00:00:00 2001 From: Hare Date: Tue, 8 Aug 2023 14:28:55 +0800 Subject: [PATCH 05/12] Make smco-test-event-trigger public --- examples/platform/linux/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/platform/linux/BUILD.gn b/examples/platform/linux/BUILD.gn index c57580414bb904..44a96b12c00604 100644 --- a/examples/platform/linux/BUILD.gn +++ b/examples/platform/linux/BUILD.gn @@ -59,12 +59,12 @@ source_set("app-main") { ] public_deps = [ + ":smco-test-event-trigger", "${chip_root}/src/lib", "${chip_root}/src/platform/logging:force_stdio", ] deps = [ ":ota-test-event-trigger", - ":smco-test-event-trigger", "${chip_root}/examples/providers:device_info_provider", "${chip_root}/src/app/server", ] From 265feb33cd88040a9277ed061eabdf4c0de9538f Mon Sep 17 00:00:00 2001 From: Hare Date: Tue, 8 Aug 2023 19:47:37 +0800 Subject: [PATCH 06/12] Add deps to tizen --- examples/all-clusters-app/tizen/BUILD.gn | 1 + examples/all-clusters-minimal-app/tizen/BUILD.gn | 1 + 2 files changed, 2 insertions(+) diff --git a/examples/all-clusters-app/tizen/BUILD.gn b/examples/all-clusters-app/tizen/BUILD.gn index 484732400b64f1..8bf7f00152148f 100644 --- a/examples/all-clusters-app/tizen/BUILD.gn +++ b/examples/all-clusters-app/tizen/BUILD.gn @@ -34,6 +34,7 @@ source_set("chip-all-clusters-common") { deps = [ "${chip_root}/examples/all-clusters-app/all-clusters-common", + "${chip_root}/examples/platform/tizen:app-main", "${chip_root}/src/lib/shell:shell_core", ] diff --git a/examples/all-clusters-minimal-app/tizen/BUILD.gn b/examples/all-clusters-minimal-app/tizen/BUILD.gn index 5485fdd469d223..99f857e86303ea 100644 --- a/examples/all-clusters-minimal-app/tizen/BUILD.gn +++ b/examples/all-clusters-minimal-app/tizen/BUILD.gn @@ -31,6 +31,7 @@ source_set("chip-all-clusters-common") { deps = [ "${chip_root}/examples/all-clusters-minimal-app/all-clusters-common", + "${chip_root}/examples/platform/tizen:app-main", "${chip_root}/src/lib/shell:shell_core", ] From 229b35592862e02f3d3fbe3eaab14a78ede1ba93 Mon Sep 17 00:00:00 2001 From: Hare Date: Wed, 9 Aug 2023 10:05:45 +0800 Subject: [PATCH 07/12] Revision per review comments --- .../all-clusters-common/src/smco-stub.cpp | 52 ++++---- .../SmokeCOTestEventTriggerDelegate.cpp | 2 +- .../SmokeCOTestEventTriggerDelegate.h | 2 +- .../smoke-co-alarm-server.cpp | 114 +++++------------- .../smoke-co-alarm-server.h | 4 +- 5 files changed, 61 insertions(+), 113 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp b/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp index 6e6b7748f1f359..e6e18ab9edb32a 100644 --- a/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp +++ b/examples/all-clusters-app/all-clusters-common/src/smco-stub.cpp @@ -26,7 +26,7 @@ using namespace chip::DeviceLayer; namespace { -constexpr const uint16_t kSelfTestingTimeout = 10; +constexpr const uint16_t kSelfTestingTimeoutSec = 10; } // namespace @@ -39,27 +39,23 @@ static std::array void EndSelfTestingEventHandler(System::Layer * systemLayer, void * appState) { SmokeCoAlarmServer::Instance().SetTestInProgress(1, false); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test complete"); } -void SelfTestingEventHandler() -{ - ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test running"); - - DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(kSelfTestingTimeout), EndSelfTestingEventHandler, nullptr); -} - bool emberAfPluginSmokeCoAlarmSelfTestRequestCommand(EndpointId endpointId) { SmokeCoAlarmServer::Instance().SetTestInProgress(1, true); - SelfTestingEventHandler(); + + ChipLogProgress(Support, "[Smoke-CO-Alarm] => Self test running"); + + DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(kSelfTestingTimeoutSec), EndSelfTestingEventHandler, nullptr); return true; } -bool emberAfHandleEventTrigger(uint64_t eventTrigger) +bool HandleSmokeCOTestEventTrigger(uint64_t eventTrigger) { SmokeCOTrigger trigger = static_cast(eventTrigger); @@ -68,32 +64,32 @@ bool emberAfHandleEventTrigger(uint64_t eventTrigger) case SmokeCOTrigger::kForceSmokeCritical: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (critical)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kCritical), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceSmokeWarning: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke (warning)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kWarning), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceSmokeInterconnect: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke interconnect (warning)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kWarning), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceCOCritical: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (critical)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kCritical), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceCOWarning: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kWarning), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceCOInterconnect: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force CO (warning)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kWarning), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceSmokeContaminationHigh: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force smoke contamination (critical)"); @@ -114,22 +110,22 @@ bool emberAfHandleEventTrigger(uint64_t eventTrigger) case SmokeCOTrigger::kForceMalfunction: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force malfunction"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, true), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceLowBatteryWarning: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (warning)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kWarning), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceLowBatteryCritical: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force low battery (critical)"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kCritical), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceEndOfLife: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force end-of-life"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kExpired), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kForceSilence: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force silence"); @@ -138,32 +134,32 @@ bool emberAfHandleEventTrigger(uint64_t eventTrigger) case SmokeCOTrigger::kClearSmoke: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetSmokeState(1, AlarmStateEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearCO: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetCOState(1, AlarmStateEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearSmokeInterconnect: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear smoke interconnect"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectSmokeAlarm(1, AlarmStateEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearCOInterconnect: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear CO interconnect"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetInterconnectCOAlarm(1, AlarmStateEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearMalfunction: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear malfunction"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetHardwareFaultAlert(1, false), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearEndOfLife: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear end-of-life"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetEndOfServiceAlert(1, EndOfServiceEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearSilence: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear silence"); @@ -172,7 +168,7 @@ bool emberAfHandleEventTrigger(uint64_t eventTrigger) case SmokeCOTrigger::kClearBatteryLevelLow: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Clear low battery"); VerifyOrReturnValue(SmokeCoAlarmServer::Instance().SetBatteryAlert(1, AlarmStateEnum::kNormal), true); - SmokeCoAlarmServer::Instance().AutoSetExpressedState(1, sPriorityOrder); + SmokeCoAlarmServer::Instance().SetExpressedStateByPriority(1, sPriorityOrder); break; case SmokeCOTrigger::kClearContamination: ChipLogProgress(Support, "[Smoke-CO-Alarm-Test-Event] => Force SmokeContamination (warning)"); diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index b9af78e47f8d4c..e413ea0beec5fc 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -28,7 +28,7 @@ bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enable CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) { - VerifyOrReturnValue(emberAfHandleEventTrigger(eventTrigger), + VerifyOrReturnValue(HandleSmokeCOTestEventTrigger(eventTrigger), (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) : CHIP_ERROR_INVALID_ARGUMENT); diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h index 110a40c13965d6..599eb6ab2fc080 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.h @@ -80,4 +80,4 @@ class SmokeCOTestEventTriggerDelegate : public TestEventTriggerDelegate * @retval true on success * @retval false if error happened */ -bool emberAfHandleEventTrigger(uint64_t eventTrigger); +bool HandleSmokeCOTestEventTrigger(uint64_t eventTrigger); diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index c6988d56bcef62..f2dcae1332c462 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -61,99 +61,51 @@ bool SmokeCoAlarmServer::SetExpressedState(EndpointId endpointId, ExpressedState return success; } -bool SmokeCoAlarmServer::AutoSetExpressedState(EndpointId endpointId, - std::array priorityOrder) +void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId, + const std::array & priorityOrder) { - ExpressedStateEnum currentExpressedState = ExpressedStateEnum::kNormal; + AlarmStateEnum alarmState = AlarmStateEnum::kNormal; + EndOfServiceEnum endOfServiceState = EndOfServiceEnum::kNormal; + bool active = false; for (ExpressedStateEnum priority : priorityOrder) { switch (priority) { - case ExpressedStateEnum::kSmokeAlarm: { - AlarmStateEnum currentSmokeAlarm; - VerifyOrReturnValue(GetSmokeState(endpointId, currentSmokeAlarm), false); - if (currentSmokeAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kSmokeAlarm; - } - } - break; - case ExpressedStateEnum::kCOAlarm: { - AlarmStateEnum currentCoAlarm; - VerifyOrReturnValue(GetCOState(endpointId, currentCoAlarm), false); - if (currentCoAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kCOAlarm; - } - } - break; - case ExpressedStateEnum::kBatteryAlert: { - AlarmStateEnum currentBatteryState; - VerifyOrReturnValue(GetBatteryAlert(endpointId, currentBatteryState), false); - if (currentBatteryState != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kBatteryAlert; - } - } - break; - case ExpressedStateEnum::kTesting: { - bool currentTestInProgress; - VerifyOrReturnValue(GetTestInProgress(endpointId, currentTestInProgress), false); - if (currentTestInProgress != false) - { - currentExpressedState = ExpressedStateEnum::kTesting; - } - } - break; - case ExpressedStateEnum::kHardwareFault: { - bool currentHardwareFault; - VerifyOrReturnValue(GetHardwareFaultAlert(endpointId, currentHardwareFault), false); - if (currentHardwareFault != false) - { - currentExpressedState = ExpressedStateEnum::kHardwareFault; - } - } - break; - case ExpressedStateEnum::kEndOfService: { - EndOfServiceEnum currentEndOfService; - VerifyOrReturnValue(GetEndOfServiceAlert(endpointId, currentEndOfService), false); - if (currentEndOfService != EndOfServiceEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kEndOfService; - } - } - break; - case ExpressedStateEnum::kInterconnectSmoke: { - AlarmStateEnum currentInterconnectSmokeAlarm; - VerifyOrReturnValue(GetInterconnectSmokeAlarm(endpointId, currentInterconnectSmokeAlarm), false); - if (currentInterconnectSmokeAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kInterconnectSmoke; - } - } - break; - case ExpressedStateEnum::kInterconnectCO: { - AlarmStateEnum currentInterconnectCOAlarm; - VerifyOrReturnValue(GetInterconnectCOAlarm(endpointId, currentInterconnectCOAlarm), false); - if (currentInterconnectCOAlarm != AlarmStateEnum::kNormal) - { - currentExpressedState = ExpressedStateEnum::kInterconnectCO; - } - } - break; - + case ExpressedStateEnum::kSmokeAlarm: + VerifyOrReturn(GetSmokeState(endpointId, alarmState)); + break; + case ExpressedStateEnum::kCOAlarm: + VerifyOrReturn(GetCOState(endpointId, alarmState)); + break; + case ExpressedStateEnum::kBatteryAlert: + VerifyOrReturn(GetBatteryAlert(endpointId, alarmState)); + break; + case ExpressedStateEnum::kTesting: + VerifyOrReturn(GetTestInProgress(endpointId, active)); + break; + case ExpressedStateEnum::kHardwareFault: + VerifyOrReturn(GetHardwareFaultAlert(endpointId, active)); + break; + case ExpressedStateEnum::kEndOfService: + VerifyOrReturn(GetEndOfServiceAlert(endpointId, endOfServiceState)); + break; + case ExpressedStateEnum::kInterconnectSmoke: + VerifyOrReturn(GetInterconnectSmokeAlarm(endpointId, alarmState)); + break; + case ExpressedStateEnum::kInterconnectCO: + VerifyOrReturn(GetInterconnectCOAlarm(endpointId, alarmState)); + break; default: break; } - if (currentExpressedState != ExpressedStateEnum::kNormal) - { - break; - } + VerifyOrReturn(alarmState == AlarmStateEnum::kNormal, SetExpressedState(endpointId, priority)); + VerifyOrReturn(endOfServiceState == EndOfServiceEnum::kNormal, SetExpressedState(endpointId, priority)); + VerifyOrReturn(active == false, SetExpressedState(endpointId, priority)); } - return SetExpressedState(endpointId, currentExpressedState); + SetExpressedState(endpointId, ExpressedStateEnum::kNormal); } bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h index 48d4191d99a956..0df9583371b67a 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.h @@ -65,9 +65,9 @@ class SmokeCoAlarmServer * @brief Set the highest level of Expressed State according to priorityOrder * @param endpointId ID of the endpoint * @param priorityOrder Priority order of expressed state from highest to lowest - * @return true on success, false on failure */ - bool AutoSetExpressedState(chip::EndpointId endpointId, std::array priorityOrder); + void SetExpressedStateByPriority(chip::EndpointId endpointId, + const std::array & priorityOrder); bool SetSmokeState(chip::EndpointId endpointId, AlarmStateEnum newSmokeState); bool SetCOState(chip::EndpointId endpointId, AlarmStateEnum newCOState); From 25c27dac2839d591bd066f125e23acabbd390256 Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 10 Aug 2023 09:03:40 +0800 Subject: [PATCH 08/12] Add LogErrorOnFailure --- .../smoke-co-alarm-server/smoke-co-alarm-server.cpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index f2dcae1332c462..eb134736bfa9df 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -100,12 +100,14 @@ void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId, break; } - VerifyOrReturn(alarmState == AlarmStateEnum::kNormal, SetExpressedState(endpointId, priority)); - VerifyOrReturn(endOfServiceState == EndOfServiceEnum::kNormal, SetExpressedState(endpointId, priority)); - VerifyOrReturn(active == false, SetExpressedState(endpointId, priority)); + if ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active) + { + LogErrorOnFailure(SetExpressedState(endpointId, priority)); + return; + } } - SetExpressedState(endpointId, ExpressedStateEnum::kNormal); + LogErrorOnFailure(SetExpressedState(endpointId, ExpressedStateEnum::kNormal)); } bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) From d692eacd38cf30b4889353817fa6c1a3b98de441 Mon Sep 17 00:00:00 2001 From: EricZijian_Siter Date: Thu, 10 Aug 2023 09:05:53 +0800 Subject: [PATCH 09/12] Update src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp Co-authored-by: Boris Zbarsky --- .../SmokeCOTestEventTriggerDelegate.cpp | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index e413ea0beec5fc..20dc5817a6c9b4 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -28,11 +28,15 @@ bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enable CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) { - VerifyOrReturnValue(HandleSmokeCOTestEventTrigger(eventTrigger), - (mOtherDelegate != nullptr) ? mOtherDelegate->HandleEventTrigger(eventTrigger) - : CHIP_ERROR_INVALID_ARGUMENT); - - return CHIP_NO_ERROR; + if (HandleSmokeCOTestEventTrigger(eventTrigger)) + { + return CHIP_NO_ERROR; + } + if (mOtherDelegate != nullptr) + { + return mOtherDelegate->HandleEventTrigger(eventTrigger); + } + return CHIP_ERROR_INVALID_ARGUMENT; } } // namespace chip From d0af1ae6f1480027f972f66100a0d65c07efdeca Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 10 Aug 2023 09:14:16 +0800 Subject: [PATCH 10/12] Revert "Add LogErrorOnFailure" This reverts commit 25c27dac2839d591bd066f125e23acabbd390256. --- .../smoke-co-alarm-server/smoke-co-alarm-server.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index eb134736bfa9df..f2dcae1332c462 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -100,14 +100,12 @@ void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId, break; } - if ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active) - { - LogErrorOnFailure(SetExpressedState(endpointId, priority)); - return; - } + VerifyOrReturn(alarmState == AlarmStateEnum::kNormal, SetExpressedState(endpointId, priority)); + VerifyOrReturn(endOfServiceState == EndOfServiceEnum::kNormal, SetExpressedState(endpointId, priority)); + VerifyOrReturn(active == false, SetExpressedState(endpointId, priority)); } - LogErrorOnFailure(SetExpressedState(endpointId, ExpressedStateEnum::kNormal)); + SetExpressedState(endpointId, ExpressedStateEnum::kNormal); } bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) From a3568269036c23d663739e7455eda6bebe188745 Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 10 Aug 2023 09:19:38 +0800 Subject: [PATCH 11/12] Add ChipLogError --- .../SmokeCOTestEventTriggerDelegate.cpp | 4 ++-- .../smoke-co-alarm-server/smoke-co-alarm-server.cpp | 8 +++++++- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp index 20dc5817a6c9b4..597737b14bb768 100644 --- a/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp +++ b/src/app/clusters/smoke-co-alarm-server/SmokeCOTestEventTriggerDelegate.cpp @@ -28,11 +28,11 @@ bool SmokeCOTestEventTriggerDelegate::DoesEnableKeyMatch(const ByteSpan & enable CHIP_ERROR SmokeCOTestEventTriggerDelegate::HandleEventTrigger(uint64_t eventTrigger) { - if (HandleSmokeCOTestEventTrigger(eventTrigger)) + if (HandleSmokeCOTestEventTrigger(eventTrigger)) { return CHIP_NO_ERROR; } - if (mOtherDelegate != nullptr) + if (mOtherDelegate != nullptr) { return mOtherDelegate->HandleEventTrigger(eventTrigger); } diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index f2dcae1332c462..d250b5f8615bdb 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -103,9 +103,15 @@ void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId, VerifyOrReturn(alarmState == AlarmStateEnum::kNormal, SetExpressedState(endpointId, priority)); VerifyOrReturn(endOfServiceState == EndOfServiceEnum::kNormal, SetExpressedState(endpointId, priority)); VerifyOrReturn(active == false, SetExpressedState(endpointId, priority)); + + if ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active) + { + VerifyOrDo(SetExpressedState(endpointId, priority), ChipLogError(NotSpecified, "Set ExpressedState failed")); + return; + } } - SetExpressedState(endpointId, ExpressedStateEnum::kNormal); + VerifyOrDo(SetExpressedState(endpointId, ExpressedStateEnum::kNormal), ChipLogError(NotSpecified, "Set ExpressedState failed")); } bool SmokeCoAlarmServer::SetSmokeState(EndpointId endpointId, AlarmStateEnum newSmokeState) From 0f5eb47e78f8b6f8fa7c7e3bd16131d2cb349b85 Mon Sep 17 00:00:00 2001 From: Hare Date: Thu, 10 Aug 2023 09:31:53 +0800 Subject: [PATCH 12/12] Remove redundant code --- .../clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp index d250b5f8615bdb..19f1da4f8a8d76 100644 --- a/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp +++ b/src/app/clusters/smoke-co-alarm-server/smoke-co-alarm-server.cpp @@ -100,10 +100,6 @@ void SmokeCoAlarmServer::SetExpressedStateByPriority(EndpointId endpointId, break; } - VerifyOrReturn(alarmState == AlarmStateEnum::kNormal, SetExpressedState(endpointId, priority)); - VerifyOrReturn(endOfServiceState == EndOfServiceEnum::kNormal, SetExpressedState(endpointId, priority)); - VerifyOrReturn(active == false, SetExpressedState(endpointId, priority)); - if ((alarmState != AlarmStateEnum::kNormal) || (endOfServiceState != EndOfServiceEnum::kNormal) || active) { VerifyOrDo(SetExpressedState(endpointId, priority), ChipLogError(NotSpecified, "Set ExpressedState failed"));