Read basic cluster information during commissioning.

project-chip · Jan 27, 2022 · eb8b946 · eb8b946
1 parent 9e8f49a
commit eb8b946
Show file tree

Hide file tree

Showing 4 changed files with 92 additions and 6 deletions.
diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp
@@ -106,6 +106,12 @@ CommissioningStage AutoCommissioner::GetNextCommissioningStage(CommissioningStag
     switch (currentStage)
     {
     case CommissioningStage::kSecurePairing:
+        return CommissioningStage::kReadVendorId;
+    case CommissioningStage::kReadVendorId:
+        return CommissioningStage::kReadProductId;
+    case CommissioningStage::kReadProductId:
+        return CommissioningStage::kReadSoftwareVersion;
+    case CommissioningStage::kReadSoftwareVersion:
         return CommissioningStage::kGetPartsList;
     case CommissioningStage::kGetPartsList:
         return CommissioningStage::kCheckEndpointIsCommissionable;
@@ -274,6 +280,15 @@ CHIP_ERROR AutoCommissioner::CommissioningStepFinished(CHIP_ERROR err, Commissio
     {
         switch (report.stageCompleted)
         {
+        case CommissioningStage::kReadVendorId:
+            mVendorId = report.Get<BasicVendor>().vendorId;
+            break;
+        case CommissioningStage::kReadProductId:
+            mProductId = report.Get<BasicProduct>().productId;
+            break;
+        case CommissioningStage::kReadSoftwareVersion:
+            mSoftwareVersion = report.Get<BasicSoftware>().softwareVersion;
+            break;
         case CommissioningStage::kGetPartsList:
             mAllEndpoints = report.Get<EndpointParts>();
             break;

diff --git a/src/controller/AutoCommissioner.h b/src/controller/AutoCommissioner.h
@@ -60,6 +60,9 @@ class AutoCommissioner : public CommissioningDelegate
     EndpointParts mAllEndpoints;
     EndpointParts mNetworkEndpoints;
     EndpointId mEndpoint;
+    VendorId mVendorId;
+    uint16_t mProductId;
+    uint32_t mSoftwareVersion;
     // Memory space for the commisisoning parameters that come in as ByteSpans - the caller is not guaranteed to retain this memory
     uint8_t mSsid[CommissioningParameters::kMaxSsidLen];
     uint8_t mCredentials[CommissioningParameters::kMaxCredentialsLen];

diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
@@ -1632,12 +1632,34 @@ void DescriptorClusterServerCallback(void * context, const chip::app::DataModel:
     commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
 }
 
-void DescriptorClusterFailure(void * context, EmberAfStatus status)
+void BasicVendorCallback(void * context, VendorId vendorId)
 {
     DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
+    CommissioningDelegate::CommissioningReport report;
+    report.Set<BasicVendor>(vendorId);
+    commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
+}
 
-    // TODO: Do we have a function to convert from ember status to chip status?
-    commissioner->CommissioningStageComplete(CHIP_ERROR_INTERNAL);
+void BasicProductCallback(void * context, uint16_t productId)
+{
+    DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
+    CommissioningDelegate::CommissioningReport report;
+    report.Set<BasicProduct>(productId);
+    commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
+}
+
+void BasicSoftwareCallback(void * context, uint32_t softwareVersion)
+{
+    DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
+    CommissioningDelegate::CommissioningReport report;
+    report.Set<BasicSoftware>(softwareVersion);
+    commissioner->CommissioningStageComplete(CHIP_NO_ERROR, report);
+}
+
+void AttributeReadFailure(void * context, CHIP_ERROR status)
+{
+    DeviceCommissioner * commissioner = static_cast<DeviceCommissioner *>(context);
+    commissioner->CommissioningStageComplete(status);
 }
 
 void DeviceCommissioner::PerformCommissioningStep(DeviceProxy * proxy, CommissioningStage step, CommissioningParameters & params,
@@ -1658,20 +1680,45 @@ void DeviceCommissioner::PerformCommissioningStep(DeviceProxy * proxy, Commissio
 
     switch (step)
     {
+    case CommissioningStage::kReadVendorId: {
+        ChipLogProgress(Controller, "Reading vendor ID");
+        BasicCluster basic;
+        SetupCluster(basic, proxy, endpoint, timeout);
+        basic.ReadAttribute<chip::app::Clusters::Basic::Attributes::VendorID::TypeInfo>(this, BasicVendorCallback,
+                                                                                        AttributeReadFailure);
+    }
+    break;
+    case CommissioningStage::kReadProductId: {
+        ChipLogProgress(Controller, "Reading product ID");
+        BasicCluster basic;
+        SetupCluster(basic, proxy, endpoint, timeout);
+        basic.ReadAttribute<chip::app::Clusters::Basic::Attributes::ProductID::TypeInfo>(this, BasicProductCallback,
+                                                                                         AttributeReadFailure);
+    }
+    break;
+    case CommissioningStage::kReadSoftwareVersion: {
+        ChipLogProgress(Controller, "Reading software version");
+        BasicCluster basic;
+        SetupCluster(basic, proxy, endpoint, timeout);
+        basic.ReadAttribute<chip::app::Clusters::Basic::Attributes::SoftwareVersion::TypeInfo>(this, BasicSoftwareCallback,
+                                                                                               AttributeReadFailure);
+    }
+    break;
+
     case CommissioningStage::kGetPartsList: {
         ChipLogProgress(Controller, "Reading descriptor cluster parts list");
         DescriptorCluster desc;
         SetupCluster(desc, proxy, endpoint, timeout);
         desc.ReadAttribute<chip::app::Clusters::Descriptor::Attributes::PartsList::TypeInfo>(this, DescriptorClusterPartsCallback,
-                                                                                             DescriptorClusterFailure);
+                                                                                             AttributeReadFailure);
     }
     break;
     case CommissioningStage::kCheckEndpointIsCommissionable: {
         ChipLogProgress(Controller, "Reading descriptor cluster server list for endpoint %u", endpoint);
         DescriptorCluster desc;
         SetupCluster(desc, proxy, endpoint, timeout);
         desc.ReadAttribute<chip::app::Clusters::Descriptor::Attributes::ServerList::TypeInfo>(this, DescriptorClusterServerCallback,
-                                                                                              DescriptorClusterFailure);
+                                                                                              AttributeReadFailure);
     }
     break;
     case CommissioningStage::kArmFailsafe: {

diff --git a/src/controller/CommissioningDelegate.h b/src/controller/CommissioningDelegate.h
@@ -28,6 +28,9 @@ enum CommissioningStage : uint8_t
 {
     kError,
     kSecurePairing,
+    kReadVendorId,
+    kReadProductId,
+    kReadSoftwareVersion,
     kGetPartsList,
     kCheckEndpointIsCommissionable,
     kArmFailsafe,
@@ -251,12 +254,30 @@ struct EndpointCommissioningInfo
     bool hasNetworkCluster = false;
 };
 
+struct BasicVendor
+{
+    BasicVendor(VendorId id) : vendorId(id) {}
+    VendorId vendorId;
+};
+
+struct BasicProduct
+{
+    BasicProduct(uint16_t id) : productId(id) {}
+    uint16_t productId;
+};
+
+struct BasicSoftware
+{
+    BasicSoftware(uint32_t version) : softwareVersion(version) {}
+    uint32_t softwareVersion;
+};
+
 class CommissioningDelegate
 {
 public:
     virtual ~CommissioningDelegate(){};
     struct CommissioningReport : Variant<RequestedCertificate, AttestationResponse, NocChain, OperationalNodeFoundData,
-                                         EndpointParts, EndpointCommissioningInfo>
+                                         EndpointParts, EndpointCommissioningInfo, BasicVendor, BasicProduct, BasicSoftware>
     {
         CommissioningReport() : stageCompleted(CommissioningStage::kError) {}
         CommissioningStage stageCompleted;