Set ICD Active/Idle Mode duration to linux cmdline

Author: erwinpan1

examples/chef/chef.py

@@ -326,12 +326,6 @@ def main() -> int:
                       action="store_true", dest="do_interact")
     parser.add_option("-I", "--enable_icd", help="enable ICD (Intermittently Connected Device)",
                       action="store_true", default=False)
-    parser.add_option("", "--icd_idle_duration_sec", type=int,
-                      help="ICD idle mode duration (seconds). Default is 60", metavar="ICD_IDLE_SEC", default=60)
-    parser.add_option("", "--icd_active_duration_ms", type=int,
-                      help="ICD active mode duration (milliseconds). Default is 10000", metavar="ICD_ACTIVE_DURATION_MS", default=10000)
-    parser.add_option("", "--icd_active_threshold_ms", type=int,
-                      help="ICD idle mode threshold (milliseconds). Default is 5000", metavar="ICD_ACTIVE_THRESHOLD_MS", default=5000)
     parser.add_option("-m", "--menuconfig", help="runs menuconfig on platforms that support it",
                       action="store_true", dest="do_menuconfig")
     parser.add_option("-z", "--zap", help="runs zap to generate data model & interaction model artifacts",
@@ -878,18 +872,13 @@ def main() -> int:
                 linux_args.append("chip_inet_config_enable_ipv4=true")
             else:
                 linux_args.append("chip_inet_config_enable_ipv4=false")
-            
-            flush_print("{options.icd_idle_duration_sec}")
 
             if options.enable_icd:
                 linux_args.append("chip_enable_icd_server = true")
                 linux_args.append("chip_subscription_timeout_resumption = true")
                 linux_args.append("chip_icd_report_on_active_mode = true")
                 linux_args.append("chip_enable_icd_lit = true")
                 linux_args.append("chip_enable_icd_dsls = true")
-                linux_args.append(f'chip_config_icd_idle_mode_duration_sec = {options.icd_idle_duration_sec}')
-                linux_args.append(f'chip_config_icd_active_mode_duration_ms = {options.icd_active_duration_ms}')
-                linux_args.append(f'chip_config_icd_active_mode_threshold_ms = {options.icd_active_threshold_ms}')
 
             if sw_ver_string:
                 linux_args.append(

examples/chef/devices/rootnode_contactsensor_ed3b19ec55.matter examples/chef/devices/icd_rootnode_contactsensor_ed3b19ec55.matter

@@ -213,10 +213,10 @@ enum TestGlobalEnum : enum8 {
 }
 
 enum ThreeLevelAutoEnum : enum8 {
-  kLow = 0;
-  kMedium = 1;
-  kHigh = 2;
-  kAutomatic = 3;
+  kAuto = 0;
+  kLow = 1;
+  kMedium = 2;
+  kHigh = 3;
 }
 
 bitmap TestGlobalBitmap : bitmap32 {
@@ -1443,12 +1443,14 @@ cluster OperationalCredentials = 62 {
     fabric_id fabricID = 3;
     node_id nodeID = 4;
     char_string<32> label = 5;
+    optional octet_string<85> vidVerificationStatement = 6;
     fabric_idx fabricIndex = 254;
   }
 
   fabric_scoped struct NOCStruct {
-    fabric_sensitive octet_string noc = 1;
-    nullable fabric_sensitive octet_string icac = 2;
+    octet_string noc = 1;
+    nullable octet_string icac = 2;
+    optional octet_string vvsc = 3;
     fabric_idx fabricIndex = 254;
   }
 
@@ -1523,6 +1525,23 @@ cluster OperationalCredentials = 62 {
     octet_string rootCACertificate = 0;
   }
 
+  request struct SetVidVerificationStatementRequest {
+    optional vendor_id vendorID = 0;
+    optional octet_string vidVerificationStatement = 1;
+    optional octet_string vvsc = 2;
+  }
+
+  request struct SignVidVerificationRequestRequest {
+    fabric_idx fabricIndex = 0;
+    octet_string<32> clientChallenge = 1;
+  }
+
+  response struct SignVidVerificationResponse = 14 {
+    fabric_idx fabricIndex = 0;
+    int8u fabricBindingVersion = 1;
+    octet_string signature = 2;
+  }
+
   /** Sender is requesting attestation information from the receiver. */
   command access(invoke: administer) AttestationRequest(AttestationRequestRequest): AttestationResponse = 0;
   /** Sender is requesting a device attestation certificate from the receiver. */
@@ -1539,6 +1558,10 @@ cluster OperationalCredentials = 62 {
   command access(invoke: administer) RemoveFabric(RemoveFabricRequest): NOCResponse = 10;
   /** This command SHALL add a Trusted Root CA Certificate, provided as its CHIP Certificate representation. */
   command access(invoke: administer) AddTrustedRootCertificate(AddTrustedRootCertificateRequest): DefaultSuccess = 11;
+  /** This command SHALL be used to update any of the accessing fabric's associated VendorID, VidVerificatioNStatement or VVSC (Vendor Verification Signing Certificate). */
+  fabric command access(invoke: administer) SetVidVerificationStatement(SetVidVerificationStatementRequest): DefaultSuccess = 12;
+  /** This command SHALL be used to request that the server authenticate the fabric associated with the FabricIndex given. */
+  command access(invoke: administer) SignVidVerificationRequest(SignVidVerificationRequestRequest): SignVidVerificationResponse = 13;
 }
 
 /** The Group Key Management Cluster is the mechanism by which group keys are managed. */

examples/chef/devices/rootnode_contactsensor_ed3b19ec55.zap examples/chef/devices/icd_rootnode_contactsensor_ed3b19ec55.zap

@@ -35,4 +35,3 @@
 
 // Enable subscriptions synchronization
 #define CHIP_CONFIG_SYNCHRONOUS_REPORTS_ENABLED 1
-

examples/chef/linux/include/CHIPProjectAppConfig.h

@@ -30,10 +30,15 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 
 #if CHIP_CONFIG_ENABLE_ICD_CIP
+// Wake up periodically to send Check-in message since Linux application doesn't have physical button
 void notifyIcdActive(System::Layer * layer, void *)
 {
     ICDNotifier::GetInstance().NotifyNetworkActivityNotification();
-    DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(CHIP_CONFIG_ICD_IDLE_MODE_DURATION_SEC*1000), notifyIcdActive, nullptr);
+
+    ChipLogDetail(Shell, "Periodic wakeup to notify ICD active");
+    DeviceLayer::SystemLayer().StartTimer(
+        chip::System::Clock::Milliseconds32(LinuxDeviceOptions::GetInstance().icdPeriodicWakeupDurationMs), notifyIcdActive,
+        nullptr);
 }
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP
 
@@ -58,7 +63,8 @@ int main(int argc, char * argv[])
 #endif
 
 #if CHIP_CONFIG_ENABLE_ICD_CIP
-    DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(CHIP_CONFIG_ICD_IDLE_MODE_DURATION_SEC*1000), notifyIcdActive, nullptr);
+    // Send notification right away after init
+    DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(0), notifyIcdActive, nullptr);
 #endif // CHIP_CONFIG_ENABLE_ICD_CIP
 
     ChipLinuxAppMainLoop();

examples/chef/linux/main.cpp

@@ -267,6 +267,7 @@ void InitNetworkCommissioning()
 #endif // CHIP_APP_MAIN_HAS_ETHERNET_DRIVER
     }
 }
+
 } // anonymous namespace
 
 #if defined(ENABLE_CHIP_SHELL)
@@ -526,6 +527,11 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions,
     }
 #endif // CHIP_ENABLE_OPENTHREAD
 
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    Server::GetInstance().GetICDManager().SetModeDurations(LinuxDeviceOptions::GetInstance().icdActiveModeDurationMs,
+                                                           LinuxDeviceOptions::GetInstance().icdIdleModeDurationMs);
+#endif // CHIP_CONFIG_ENABLE_ICD_SERVER
+
 exit:
     if (err != CHIP_NO_ERROR)
     {

examples/platform/linux/AppMain.cpp

@@ -28,6 +28,7 @@
 #include <crypto/CHIPCryptoPAL.h>
 #include <json/json.h>
 #include <lib/core/CHIPError.h>
+#include <lib/core/CHIPConfig.h>
 #include <lib/support/Base64.h>
 #include <lib/support/BytesToHex.h>
 #include <lib/support/CHIPMemString.h>
@@ -132,6 +133,11 @@ enum
     kDeviceOption_TermsAndConditions_Version,
     kDeviceOption_TermsAndConditions_Required,
 #endif
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    kDeviceOption_icdActiveModeDurationMs,
+    kDeviceOption_icdIdleModeDuration,
+    kDeviceOption_icdPeriodicWakeupDurationMs,
+#endif // CHIP_ENABLE_ICD_SERVER
 };
 
 constexpr unsigned kAppUsageLength = 64;
@@ -212,6 +218,11 @@ OptionDef sDeviceOptionDefs[] = {
     { "tc-version", kArgumentRequired, kDeviceOption_TermsAndConditions_Version },
     { "tc-required", kArgumentRequired, kDeviceOption_TermsAndConditions_Required },
 #endif
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    { "icdActiveModeDurationMs", kArgumentRequired, kDeviceOption_icdActiveModeDurationMs },
+    { "icdIdleModeDuration", kArgumentRequired, kDeviceOption_icdIdleModeDuration },
+    { "icdPeriodicWakeupDurationMs", kArgumentRequired, kDeviceOption_icdPeriodicWakeupDurationMs },
+#endif // CHIP_ENABLE_ICD_SERVER
     {}
 };
 
@@ -383,8 +394,21 @@ const char * sDeviceOptionHelp =
     "  --faults <fault-string,...>\n"
     "       Inject specified fault(s) at runtime.\n"
 #endif
-    "   --dac_provider <filepath>\n"
+    "  --dac_provider <filepath>\n"
     "       A json file with data used by the example dac provider to validate device attestation procedure.\n"
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    "  --icdActiveModeDurationMs <icdActiveModeDurationMs>\n"
+    "       Sets the ICD active mode threshold (in milliseconds). (Default: 300) \n"
+    "       This defines the how long the the server typically will stay in active mode after \n"
+    "       initial transition out of idle mode.\n"
+    "  --icdIdleModeDuration <icdIdleModeDuration>\n"
+    "       Sets the ICD idle mode durations (in seconds). (Default: 300) \n"
+    "       This defines the how long the ICD server can stay in idle mode.\n"
+    "  --icdPeriodicWakeupDurationMs <icdPeriodicWakupDurationMs>\n"
+    "       Sets the ICD periodic wakeup (in milliseconds). (Default: 6000)\n"
+    "       This is for testing purpose on Linux which defines the internal to wakeup periodically to send \n"
+    "       Check-In messages since Linux application doesn't have a physical button to trigger wakeup\n"
+#endif
     "\n";
 
 #if CHIP_CONFIG_USE_ACCESS_RESTRICTIONS
@@ -774,6 +798,38 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier,
         LinuxDeviceOptions::GetInstance().tcRequired.SetValue(static_cast<uint16_t>(atoi(aValue)));
         break;
     }
+#endif
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    case kDeviceOption_icdActiveModeDurationMs: {
+        uint32_t value = static_cast<uint32_t>(strtoul(aValue, nullptr, 0));
+        if (value < 1)
+        {
+            PrintArgError("%s: invalid value specified for icdActiveModeDurationMs: %s\n", aProgram, aValue);
+            retval = false;
+        }
+        else
+        {
+            LinuxDeviceOptions::GetInstance().icdActiveModeDurationMs.SetValue(chip::System::Clock::Milliseconds32(value));
+        }
+        break;
+    }
+    case kDeviceOption_icdIdleModeDuration: {
+        uint32_t value = static_cast<uint32_t>(strtoul(aValue, nullptr, 0));
+        if ((value < 1) || (value > 86400))
+        {
+            PrintArgError("%s: invalid value specified for icdIdleModeDuration: %s\n", aProgram, aValue);
+            retval = false;
+        }
+        else
+        {
+            // Covert from seconds to mini seconds
+            LinuxDeviceOptions::GetInstance().icdIdleModeDurationMs.SetValue(chip::System::Clock::Milliseconds32(value * 1000));
+        }
+        break;
+    }
+    case kDeviceOption_icdPeriodicWakeupDurationMs:
+        LinuxDeviceOptions::GetInstance().icdPeriodicWakeupDurationMs = static_cast<uint32_t>(atoi(aValue));
+        break;
 #endif
     default:
         PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName);

examples/platform/linux/Options.cpp

@@ -35,6 +35,7 @@
 #include <lib/core/Optional.h>
 #include <lib/support/CHIPArgParser.hpp>
 #include <platform/CHIPDeviceConfig.h>
+#include <platform/CHIPDeviceLayer.h>
 #include <setup_payload/SetupPayload.h>
 
 #include <credentials/DeviceAttestationCredsProvider.h>
@@ -96,6 +97,11 @@ struct LinuxDeviceOptions
 #if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED
     chip::Optional<uint16_t> tcVersion;
     chip::Optional<uint16_t> tcRequired;
+#endif
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    chip::Optional<chip::System::Clock::Milliseconds32> icdActiveModeDurationMs;
+    chip::Optional<chip::System::Clock::Milliseconds32> icdIdleModeDurationMs;
+    uint32_t icdPeriodicWakeupDurationMs = 60000;
 #endif
     static LinuxDeviceOptions & GetInstance();
 };