[ICD] Add units to configs and variables (#29417)

* Add units to defines and variables

* restyle

* rename functions and remove comments

src/app/ReadHandler.cpp

@@ -45,7 +45,7 @@ using Status = Protocols::InteractionModel::Status;
 uint16_t ReadHandler::GetPublisherSelectedIntervalLimit()
 {
 #if CHIP_CONFIG_ENABLE_ICD_SERVER
- return static_cast<uint16_t>(IcdManagementServer::GetInstance().GetIdleModeInterval());
+ return static_cast<uint16_t>(IcdManagementServer::GetInstance().GetIdleModeIntervalSec());
 #else
  return kSubscriptionMaxIntervalPublisherLimit;
 #endif

src/app/clusters/icd-management-server/icd-management-server.cpp

@@ -89,17 +89,17 @@ CHIP_ERROR IcdManagementAttributeAccess::Read(const ConcreteReadAttributePath &
 
 CHIP_ERROR IcdManagementAttributeAccess::ReadIdleModeInterval(EndpointId endpoint, AttributeValueEncoder & encoder)
 {
- return encoder.Encode(IcdManagementServer::GetInstance().GetIdleModeInterval());
+ return encoder.Encode(IcdManagementServer::GetInstance().GetIdleModeIntervalSec());
 }
 
 CHIP_ERROR IcdManagementAttributeAccess::ReadActiveModeInterval(EndpointId endpoint, AttributeValueEncoder & encoder)
 {
- return encoder.Encode(IcdManagementServer::GetInstance().GetActiveModeInterval());
+ return encoder.Encode(IcdManagementServer::GetInstance().GetActiveModeIntervalMs());
 }
 
 CHIP_ERROR IcdManagementAttributeAccess::ReadActiveModeThreshold(EndpointId endpoint, AttributeValueEncoder & encoder)
 {
- return encoder.Encode(IcdManagementServer::GetInstance().GetActiveModeThreshold());
+ return encoder.Encode(IcdManagementServer::GetInstance().GetActiveModeThresholdMs());
 }
 
 CHIP_ERROR IcdManagementAttributeAccess::ReadRegisteredClients(EndpointId endpoint, AttributeValueEncoder & encoder)

src/app/icd/ICDManager.cpp

@@ -55,7 +55,7 @@ void ICDManager::Init(PersistentStorageDelegate * storage, FabricTable * fabricT
  mFabricTable = fabricTable;
  mStateObserver = stateObserver;
 
- uint32_t activeModeInterval = IcdManagementServer::GetInstance().GetActiveModeInterval();
+ uint32_t activeModeInterval = IcdManagementServer::GetInstance().GetActiveModeIntervalMs();
  VerifyOrDie(kFastPollingInterval.count() < activeModeInterval);
 
  UpdateIcdMode();
@@ -128,7 +128,7 @@ void ICDManager::UpdateOperationState(OperationalState state)
  if (state == OperationalState::IdleMode)
  {
  mOperationalState = OperationalState::IdleMode;
- uint32_t idleModeInterval = IcdManagementServer::GetInstance().GetIdleModeInterval();
+ uint32_t idleModeInterval = IcdManagementServer::GetInstance().GetIdleModeIntervalSec();
  DeviceLayer::SystemLayer().StartTimer(System::Clock::Seconds32(idleModeInterval), OnIdleModeDone, this);
 
  System::Clock::Milliseconds32 slowPollInterval = GetSlowPollingInterval();
@@ -156,7 +156,7 @@ void ICDManager::UpdateOperationState(OperationalState state)
  DeviceLayer::SystemLayer().CancelTimer(OnIdleModeDone, this);
 
  mOperationalState = OperationalState::ActiveMode;
- uint32_t activeModeInterval = IcdManagementServer::GetInstance().GetActiveModeInterval();
+ uint32_t activeModeInterval = IcdManagementServer::GetInstance().GetActiveModeIntervalMs();
  DeviceLayer::SystemLayer().StartTimer(System::Clock::Timeout(activeModeInterval), OnActiveModeDone, this);
  uint32_t activeModeJitterInterval =
  (activeModeInterval >= ICD_ACTIVE_TIME_JITTER_MS) ? activeModeInterval - ICD_ACTIVE_TIME_JITTER_MS : 0;
@@ -172,7 +172,7 @@ void ICDManager::UpdateOperationState(OperationalState state)
  }
  else
  {
- uint16_t activeModeThreshold = IcdManagementServer::GetInstance().GetActiveModeThreshold();
+ uint16_t activeModeThreshold = IcdManagementServer::GetInstance().GetActiveModeThresholdMs();
  DeviceLayer::SystemLayer().ExtendTimerTo(System::Clock::Timeout(activeModeThreshold), OnActiveModeDone, this);
  uint16_t activeModeJitterThreshold =
  (activeModeThreshold >= ICD_ACTIVE_TIME_JITTER_MS) ? activeModeThreshold - ICD_ACTIVE_TIME_JITTER_MS : 0;

src/app/icd/ICDStateObserver.h

@@ -17,7 +17,7 @@
 #pragma once
 
 #ifndef ICD_SLEEP_TIME_JITTER_MS
-#define ICD_SLEEP_TIME_JITTER_MS (CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL * 0.75)
+#define ICD_SLEEP_TIME_JITTER_MS (CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC * 0.75)
 #endif
 
 #ifndef ICD_ACTIVE_TIME_JITTER_MS

src/app/icd/IcdManagementServer.h

@@ -30,21 +30,11 @@ using chip::Protocols::InteractionModel::Status;
 class IcdManagementServer
 {
 public:
- void Init(uint32_t idle_interval, uint32_t active_interval, uint16_t active_threshold, uint32_t count,
- uint16_t fabric_clients_supported)
- {
- mIdleInterval = idle_interval;
- mActiveInterval = active_interval;
- mActiveThreshold = active_threshold;
- mIcdCounter = count;
- mFabricClientsSupported = fabric_clients_supported;
- }
+ uint32_t GetIdleModeIntervalSec() { return mIdleInterval_s; }
 
- uint32_t GetIdleModeInterval() { return mIdleInterval; }
+ uint32_t GetActiveModeIntervalMs() { return mActiveInterval_ms; }
 
- uint32_t GetActiveModeInterval() { return mActiveInterval; }
-
- uint16_t GetActiveModeThreshold() { return mActiveThreshold; }
+ uint16_t GetActiveModeThresholdMs() { return mActiveThreshold_ms; }
 
  uint32_t GetICDCounter() { return mIcdCounter; }
 
@@ -67,20 +57,21 @@ class IcdManagementServer
 
  static IcdManagementServer mInstance;
 
- static_assert((CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL) <= 64800,
+ static_assert((CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC) <= 64800,
  "Spec requires the IdleModeInterval to be equal or inferior to 64800s.");
- static_assert((CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL) >= 1, "Spec requires the IdleModeInterval to be equal or greater to 1s.");
- uint32_t mIdleInterval = CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL; // in seconds.
+ static_assert((CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC) >= 1,
+ "Spec requires the IdleModeInterval to be equal or greater to 1s.");
+ uint32_t mIdleInterval_s = CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC;
 
- static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL) <= (CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL * 1000),
+ static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS) <= (CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC * kMillisecondsPerSecond),
  "Spec requires the IdleModeInterval be equal or greater to the ActiveModeInterval.");
- static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL) >= 300,
+ static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS) >= 300,
  "Spec requires the ActiveModeThreshold to be equal or greater to 300ms");
- uint32_t mActiveInterval = CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL; // in milliseconds
+ uint32_t mActiveInterval_ms = CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS;
 
- static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD) >= 300,
+ static_assert((CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS) >= 300,
  "Spec requires the ActiveModeThreshold to be equal or greater to 300ms.");
- uint16_t mActiveThreshold = CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD; // in milliseconds
+ uint16_t mActiveThreshold_ms = CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS;
 
  uint32_t mIcdCounter = 0;
 

src/app/tests/TestICDManager.cpp

@@ -16,17 +16,17 @@
  * limitations under the License.
  */
 #include <app/EventManagement.h>
+#include <app/icd/ICDManager.h>
+#include <app/icd/ICDStateObserver.h>
+#include <app/icd/IcdManagementServer.h>
 #include <app/tests/AppTestContext.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
+#include <lib/support/TimeUtils.h>
 #include <lib/support/UnitTestContext.h>
 #include <lib/support/UnitTestRegistration.h>
 #include <nlunit-test.h>
 #include <system/SystemLayerImpl.h>
 
-#include <app/icd/ICDManager.h>
-#include <app/icd/ICDStateObserver.h>
-#include <app/icd/IcdManagementServer.h>
-
 using namespace chip;
 using namespace chip::app;
 using namespace chip::System;
@@ -114,20 +114,20 @@ class TestICDManager
 
  // After the init we should be in active mode
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() + 1);
  // Active mode interval expired, ICDManager transitioned to the IdleMode.
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
- AdvanceClockAndRunEventLoop(ctx, (IcdManagementServer::GetInstance().GetIdleModeInterval() * 1000) + 1);
+ AdvanceClockAndRunEventLoop(ctx, secondsToMilliseconds(IcdManagementServer::GetInstance().GetIdleModeIntervalSec()) + 1);
  // Idle mode interval expired, ICDManager transitioned to the ActiveMode.
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
 
  // Events updating the Operation to Active mode can extend the current active mode time by 1 Active mode threshold.
  // Kick an active Threshold just before the end of the Active interval and validate that the active mode is extended.
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() - 1);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() - 1);
  ctx->mICDManager.UpdateOperationState(ICDManager::OperationalState::ActiveMode);
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThreshold() / 2);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThresholdMs() / 2);
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThreshold());
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeThresholdMs());
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
  }
 
@@ -139,7 +139,7 @@ class TestICDManager
  ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kCommissioningWindowOpen, true);
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
  // Advance time so active mode interval expires.
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() + 1);
  // Requirement flag still set. We stay in active mode
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
 
@@ -153,20 +153,20 @@ class TestICDManager
 
  // Advance time, but by less than the active mode interval and remove the requirement.
  // We should stay in active mode.
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() / 2);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() / 2);
  ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kFailSafeArmed, false);
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
 
  // Advance time again, The activemode interval is completed.
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() + 1);
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::IdleMode);
 
  // Set two requirements
  ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kExpectingMsgResponse, true);
  ctx->mICDManager.SetKeepActiveModeRequirements(ICDManager::KeepActiveFlags::kAwaitingMsgAck, true);
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
  // advance time so the active mode interval expires.
- AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeInterval() + 1);
+ AdvanceClockAndRunEventLoop(ctx, IcdManagementServer::GetInstance().GetActiveModeIntervalMs() + 1);
  // A requirement flag is still set. We stay in active mode.
  NL_TEST_ASSERT(aSuite, ctx->mICDManager.mOperationalState == ICDManager::OperationalState::ActiveMode);
 

src/lib/core/CHIPConfig.h

@@ -1498,30 +1498,30 @@ extern const char CHIP_NON_PRODUCTION_MARKER[];
 #endif
 
 /**
- * @def CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
+ * @def CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
  *
  * @brief Default value for the ICD Management cluster IdleModeInterval attribute, in seconds
  */
-#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL 2
+#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
+#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC 2
 #endif
 
 /**
- * @def CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
+ * @def CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
  *
  * @brief Default value for the ICD Management cluster ActiveModeInterval attribute, in milliseconds
  */
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL 300
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS 300
 #endif
 
 /**
- * @def CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
+ * @def CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
  *
  * @brief Default value for the ICD Management cluster ActiveModeThreshold attribute, in milliseconds
  */
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD 300
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS 300
 #endif
 
 /**

src/messaging/ReliableMessageProtocolConfig.cpp

@@ -75,7 +75,7 @@ Optional<ReliableMessageProtocolConfig> GetLocalMRPConfig()
  // which the device can be at sleep and not be able to receive any messages).
  config.mIdleRetransTimeout += app::ICDManager::GetSlowPollingInterval();
  config.mActiveRetransTimeout += app::ICDManager::GetFastPollingInterval();
- config.mActiveThresholdTime = System::Clock::Milliseconds16(IcdManagementServer::GetInstance().GetActiveModeThreshold());
+ config.mActiveThresholdTime = System::Clock::Milliseconds16(IcdManagementServer::GetInstance().GetActiveModeThresholdMs());
 #endif
 
 #if CONFIG_BUILD_FOR_HOST_UNIT_TEST

src/platform/nrfconnect/CHIPPlatformConfig.h

@@ -112,23 +112,23 @@
 #endif // CHIP_ENABLE_OPENTHREAD
 #endif // CHIP_CONFIG_MRP_LOCAL_IDLE_RETRY_INTERVAL
 
-#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
+#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
 #ifdef CONFIG_CHIP_ICD_IDLE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL CONFIG_CHIP_ICD_IDLE_MODE_INTERVAL
+#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC CONFIG_CHIP_ICD_IDLE_MODE_INTERVAL
 #endif // CONFIG_CHIP_ICD_IDLE_MODE_INTERVAL
-#endif // CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
+#endif // CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
 
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
 #ifdef CONFIG_CHIP_ICD_ACTIVE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL CONFIG_CHIP_ICD_ACTIVE_MODE_INTERVAL
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS CONFIG_CHIP_ICD_ACTIVE_MODE_INTERVAL
 #endif // CONFIG_CHIP_ICD_ACTIVE_MODE_INTERVAL
-#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
 
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
 #ifdef CONFIG_CHIP_ICD_ACTIVE_MODE_THRESHOLD
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD CONFIG_CHIP_ICD_ACTIVE_MODE_THRESHOLD
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS CONFIG_CHIP_ICD_ACTIVE_MODE_THRESHOLD
 #endif // CONFIG_CHIP_ICD_ACTIVE_MODE_THRESHOLD
-#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
 
 #ifndef CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC
 #ifdef CONFIG_CHIP_ICD_CLIENTS_PER_FABRIC

src/platform/silabs/CHIPPlatformConfig.h

@@ -94,17 +94,17 @@
 
 #ifdef SL_ICD_ENABLED
 
-#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL SL_IDLE_MODE_INTERVAL
-#endif // CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL
+#ifndef CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
+#define CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC SL_IDLE_MODE_INTERVAL
+#endif // CHIP_CONFIG_ICD_IDLE_MODE_INTERVAL_SEC
 
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL SL_ACTIVE_MODE_INTERVAL
-#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS SL_ACTIVE_MODE_INTERVAL
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_INTERVAL_MS
 
-#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
-#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD SL_ACTIVE_MODE_THRESHOLD
-#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD
+#ifndef CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
+#define CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS SL_ACTIVE_MODE_THRESHOLD
+#endif // CHIP_CONFIG_ICD_ACTIVE_MODE_THRESHOLD_MS
 
 #ifndef CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC
 #define CHIP_CONFIG_ICD_CLIENTS_SUPPORTED_PER_FABRIC SL_ICD_SUPPORTED_CLIENTS_PER_FABRIC