[ICD] Add units to configs and variables

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