Enable feature bit gated and optional attributes in diagnostic clusters (#9991)
* [TE6]:Enable feature bit gated and optional attributes in diagnostic clusters
* Update gen folders
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index 34dffd8..07e1ded 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -1,5 +1,5 @@
{
- "featureLevel": 54,
+ "featureLevel": 55,
"creator": "zap",
"keyValuePairs": [
{
@@ -2620,6 +2620,51 @@
"reportableChange": 0
},
{
+ "name": "UpTime",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000000000000000",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "TotalOperationalHours",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00000000",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "BootReasons",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
"name": "ClusterRevision",
"code": 65533,
"mfgCode": null,
@@ -2681,6 +2726,36 @@
"commands": [],
"attributes": [
{
+ "name": "CurrentHeapFree",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000000000000000",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "CurrentHeapUsed",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x0000000000000000",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
"name": "CurrentHeapHighWatermark",
"code": 3,
"mfgCode": null,
@@ -10776,5 +10851,6 @@
"endpointVersion": null,
"deviceIdentifier": null
}
- ]
+ ],
+ "log": []
}
\ No newline at end of file
diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
index 0bb91f1..448e447 100644
--- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
+++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
@@ -17728,6 +17728,119 @@
}
}
+JNI_METHOD(void, GeneralDiagnosticsCluster, readUpTimeAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ GeneralDiagnosticsCluster * cppCluster = reinterpret_cast<GeneralDiagnosticsCluster *>(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeUpTime(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, GeneralDiagnosticsCluster, readTotalOperationalHoursAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt32uAttributeCallback * onSuccess = new CHIPInt32uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ GeneralDiagnosticsCluster * cppCluster = reinterpret_cast<GeneralDiagnosticsCluster *>(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeTotalOperationalHours(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, GeneralDiagnosticsCluster, readBootReasonsAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt8uAttributeCallback * onSuccess = new CHIPInt8uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ GeneralDiagnosticsCluster * cppCluster = reinterpret_cast<GeneralDiagnosticsCluster *>(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeBootReasons(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
JNI_METHOD(void, GeneralDiagnosticsCluster, readClusterRevisionAttribute)
(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{
@@ -24444,6 +24557,82 @@
}
}
+JNI_METHOD(void, SoftwareDiagnosticsCluster, readCurrentHeapFreeAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ SoftwareDiagnosticsCluster * cppCluster = reinterpret_cast<SoftwareDiagnosticsCluster *>(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeCurrentHeapFree(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, SoftwareDiagnosticsCluster, readCurrentHeapUsedAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ SoftwareDiagnosticsCluster * cppCluster = reinterpret_cast<SoftwareDiagnosticsCluster *>(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeCurrentHeapUsed(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
JNI_METHOD(void, SoftwareDiagnosticsCluster, readCurrentHeapHighWatermarkAttribute)
(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
index 598b278..dd65bf9 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
@@ -2704,6 +2704,18 @@
readRebootCountAttribute(chipClusterPtr, callback);
}
+ public void readUpTimeAttribute(LongAttributeCallback callback) {
+ readUpTimeAttribute(chipClusterPtr, callback);
+ }
+
+ public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) {
+ readTotalOperationalHoursAttribute(chipClusterPtr, callback);
+ }
+
+ public void readBootReasonsAttribute(IntegerAttributeCallback callback) {
+ readBootReasonsAttribute(chipClusterPtr, callback);
+ }
+
public void readClusterRevisionAttribute(IntegerAttributeCallback callback) {
readClusterRevisionAttribute(chipClusterPtr, callback);
}
@@ -2714,6 +2726,14 @@
private native void readRebootCountAttribute(
long chipClusterPtr, IntegerAttributeCallback callback);
+ private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readTotalOperationalHoursAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readBootReasonsAttribute(
+ long chipClusterPtr, IntegerAttributeCallback callback);
+
private native void readClusterRevisionAttribute(
long chipClusterPtr, IntegerAttributeCallback callback);
}
@@ -4525,6 +4545,14 @@
private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback callback);
+ public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) {
+ readCurrentHeapFreeAttribute(chipClusterPtr, callback);
+ }
+
+ public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) {
+ readCurrentHeapUsedAttribute(chipClusterPtr, callback);
+ }
+
public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) {
readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback);
}
@@ -4533,6 +4561,12 @@
readClusterRevisionAttribute(chipClusterPtr, callback);
}
+ private native void readCurrentHeapFreeAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readCurrentHeapUsedAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
private native void readCurrentHeapHighWatermarkAttribute(
long chipClusterPtr, LongAttributeCallback callback);
diff --git a/src/controller/python/chip/clusters/CHIPClusters.cpp b/src/controller/python/chip/clusters/CHIPClusters.cpp
index 8c253b4..4c83d3e 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.cpp
+++ b/src/controller/python/chip/clusters/CHIPClusters.cpp
@@ -2948,6 +2948,37 @@
return cluster.ReadAttributeRebootCount(gInt16uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
}
+chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_UpTime(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeUpTime(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_TotalOperationalHours(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeTotalOperationalHours(gInt32uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel())
+ .AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_BootReasons(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeBootReasons(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
chip::ChipError::StorageType chip_ime_ReadAttribute_GeneralDiagnostics_ClusterRevision(chip::Controller::Device * device,
chip::EndpointId ZCLendpointId,
chip::GroupId /* ZCLgroupId */)
@@ -4644,6 +4675,26 @@
return cluster.ResetWatermarks(nullptr, nullptr).AsInteger();
}
+chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapFree(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::SoftwareDiagnosticsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeCurrentHeapFree(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapUsed(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::SoftwareDiagnosticsCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeCurrentHeapUsed(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
chip::ChipError::StorageType chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapHighWatermark(chip::Controller::Device * device,
chip::EndpointId ZCLendpointId,
chip::GroupId /* ZCLgroupId */)
diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py
index e1925aa..310bb67 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.py
+++ b/src/controller/python/chip/clusters/CHIPClusters.py
@@ -1552,6 +1552,21 @@
"attributeId": 0x00000001,
"type": "int",
},
+ 0x00000002: {
+ "attributeName": "UpTime",
+ "attributeId": 0x00000002,
+ "type": "int",
+ },
+ 0x00000003: {
+ "attributeName": "TotalOperationalHours",
+ "attributeId": 0x00000003,
+ "type": "int",
+ },
+ 0x00000004: {
+ "attributeName": "BootReasons",
+ "attributeId": 0x00000004,
+ "type": "int",
+ },
0x0000FFFD: {
"attributeName": "ClusterRevision",
"attributeId": 0x0000FFFD,
@@ -2671,6 +2686,16 @@
},
},
"attributes": {
+ 0x00000001: {
+ "attributeName": "CurrentHeapFree",
+ "attributeId": 0x00000001,
+ "type": "int",
+ },
+ 0x00000002: {
+ "attributeName": "CurrentHeapUsed",
+ "attributeId": 0x00000002,
+ "type": "int",
+ },
0x00000003: {
"attributeName": "CurrentHeapHighWatermark",
"attributeId": 0x00000003,
@@ -4920,6 +4945,12 @@
return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_NetworkInterfaces(device, ZCLendpoint, ZCLgroupid)
def ClusterGeneralDiagnostics_ReadAttributeRebootCount(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_RebootCount(device, ZCLendpoint, ZCLgroupid)
+ def ClusterGeneralDiagnostics_ReadAttributeUpTime(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_UpTime(device, ZCLendpoint, ZCLgroupid)
+ def ClusterGeneralDiagnostics_ReadAttributeTotalOperationalHours(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_TotalOperationalHours(device, ZCLendpoint, ZCLgroupid)
+ def ClusterGeneralDiagnostics_ReadAttributeBootReasons(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_BootReasons(device, ZCLendpoint, ZCLgroupid)
def ClusterGeneralDiagnostics_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_ClusterRevision(device, ZCLendpoint, ZCLgroupid)
def ClusterGroupKeyManagement_ReadAttributeGroups(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
@@ -5108,6 +5139,10 @@
return self._chipLib.chip_ime_ReadAttribute_Scenes_NameSupport(device, ZCLendpoint, ZCLgroupid)
def ClusterScenes_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_Scenes_ClusterRevision(device, ZCLendpoint, ZCLgroupid)
+ def ClusterSoftwareDiagnostics_ReadAttributeCurrentHeapFree(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapFree(device, ZCLendpoint, ZCLgroupid)
+ def ClusterSoftwareDiagnostics_ReadAttributeCurrentHeapUsed(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapUsed(device, ZCLendpoint, ZCLgroupid)
def ClusterSoftwareDiagnostics_ReadAttributeCurrentHeapHighWatermark(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapHighWatermark(device, ZCLendpoint, ZCLgroupid)
def ClusterSoftwareDiagnostics_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
@@ -6277,6 +6312,15 @@
# Cluster GeneralDiagnostics ReadAttribute RebootCount
self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_RebootCount.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_RebootCount.restype = ctypes.c_uint32
+ # Cluster GeneralDiagnostics ReadAttribute UpTime
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_UpTime.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_UpTime.restype = ctypes.c_uint32
+ # Cluster GeneralDiagnostics ReadAttribute TotalOperationalHours
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_TotalOperationalHours.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_TotalOperationalHours.restype = ctypes.c_uint32
+ # Cluster GeneralDiagnostics ReadAttribute BootReasons
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_BootReasons.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_BootReasons.restype = ctypes.c_uint32
# Cluster GeneralDiagnostics ReadAttribute ClusterRevision
self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_ReadAttribute_GeneralDiagnostics_ClusterRevision.restype = ctypes.c_uint32
@@ -6787,6 +6831,12 @@
# Cluster SoftwareDiagnostics Command ResetWatermarks
self._chipLib.chip_ime_AppendCommand_SoftwareDiagnostics_ResetWatermarks.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_AppendCommand_SoftwareDiagnostics_ResetWatermarks.restype = ctypes.c_uint32
+ # Cluster SoftwareDiagnostics ReadAttribute CurrentHeapFree
+ self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapFree.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapFree.restype = ctypes.c_uint32
+ # Cluster SoftwareDiagnostics ReadAttribute CurrentHeapUsed
+ self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapUsed.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapUsed.restype = ctypes.c_uint32
# Cluster SoftwareDiagnostics ReadAttribute CurrentHeapHighWatermark
self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapHighWatermark.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_ReadAttribute_SoftwareDiagnostics_CurrentHeapHighWatermark.restype = ctypes.c_uint32
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
index 6dbd4eb..2d79e01 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
@@ -777,6 +777,12 @@
- (void)readAttributeRebootCountWithResponseHandler:(ResponseHandler)responseHandler;
+- (void)readAttributeUpTimeWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeTotalOperationalHoursWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeBootReasonsWithResponseHandler:(ResponseHandler)responseHandler;
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler;
@end
@@ -1302,6 +1308,10 @@
- (void)resetWatermarks:(ResponseHandler)responseHandler;
+- (void)readAttributeCurrentHeapFreeWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeCurrentHeapUsedWithResponseHandler:(ResponseHandler)responseHandler;
+
- (void)readAttributeCurrentHeapHighWatermarkWithResponseHandler:(ResponseHandler)responseHandler;
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler;
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
index 8fa0bc0..5b253a1 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
@@ -2229,6 +2229,27 @@
});
}
+- (void)readAttributeUpTimeWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeUpTime(success, failure);
+ });
+}
+
+- (void)readAttributeTotalOperationalHoursWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt32uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeTotalOperationalHours(success, failure);
+ });
+}
+
+- (void)readAttributeBootReasonsWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeBootReasons(success, failure);
+ });
+}
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler
{
new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
@@ -3761,6 +3782,20 @@
});
}
+- (void)readAttributeCurrentHeapFreeWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeCurrentHeapFree(success, failure);
+ });
+}
+
+- (void)readAttributeCurrentHeapUsedWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeCurrentHeapUsed(success, failure);
+ });
+}
+
- (void)readAttributeCurrentHeapHighWatermarkWithResponseHandler:(ResponseHandler)responseHandler
{
new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
index f610d63..c805bbb 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
@@ -332,6 +332,9 @@
@interface CHIPTestGeneralDiagnostics : CHIPGeneralDiagnostics
- (void)writeAttributeRebootCountWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeUpTimeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeTotalOperationalHoursWithValue:(uint32_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeBootReasonsWithValue:(uint8_t)value responseHandler:(ResponseHandler)responseHandler;
- (void)writeAttributeClusterRevisionWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler;
@end
@@ -590,6 +593,8 @@
*/
@interface CHIPTestSoftwareDiagnostics : CHIPSoftwareDiagnostics
+- (void)writeAttributeCurrentHeapFreeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeCurrentHeapUsedWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
- (void)writeAttributeCurrentHeapHighWatermarkWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
- (void)writeAttributeClusterRevisionWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler;
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
index 619d185..e963eb6 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
@@ -1167,6 +1167,27 @@
});
}
+- (void)writeAttributeUpTimeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeUpTime(success, failure, value);
+ });
+}
+
+- (void)writeAttributeTotalOperationalHoursWithValue:(uint32_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeTotalOperationalHours(success, failure, value);
+ });
+}
+
+- (void)writeAttributeBootReasonsWithValue:(uint8_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeBootReasons(success, failure, value);
+ });
+}
+
- (void)writeAttributeClusterRevisionWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler
{
new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
@@ -1923,6 +1944,20 @@
return &_cppCluster;
}
+- (void)writeAttributeCurrentHeapFreeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeCurrentHeapFree(success, failure, value);
+ });
+}
+
+- (void)writeAttributeCurrentHeapUsedWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeCurrentHeapUsed(success, failure, value);
+ });
+}
+
- (void)writeAttributeCurrentHeapHighWatermarkWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
{
new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
index 9068f42..9a96c8e 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -9612,6 +9612,62 @@
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
+- (void)testSendClusterGeneralDiagnosticsReadAttributeUpTimeWithResponseHandler
+{
+ XCTestExpectation * expectation = [self expectationWithDescription:@"GeneralDiagnosticsReadAttributeUpTimeWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPGeneralDiagnostics * cluster = [[CHIPGeneralDiagnostics alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeUpTimeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"GeneralDiagnostics UpTime Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterGeneralDiagnosticsReadAttributeTotalOperationalHoursWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"GeneralDiagnosticsReadAttributeTotalOperationalHoursWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPGeneralDiagnostics * cluster = [[CHIPGeneralDiagnostics alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeTotalOperationalHoursWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"GeneralDiagnostics TotalOperationalHours Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterGeneralDiagnosticsReadAttributeBootReasonsWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"GeneralDiagnosticsReadAttributeBootReasonsWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPGeneralDiagnostics * cluster = [[CHIPGeneralDiagnostics alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeBootReasonsWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"GeneralDiagnostics BootReasons Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
- (void)testSendClusterGeneralDiagnosticsReadAttributeClusterRevisionWithResponseHandler
{
XCTestExpectation * expectation =
@@ -11293,6 +11349,44 @@
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
+- (void)testSendClusterSoftwareDiagnosticsReadAttributeCurrentHeapFreeWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"SoftwareDiagnosticsReadAttributeCurrentHeapFreeWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPSoftwareDiagnostics * cluster = [[CHIPSoftwareDiagnostics alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeCurrentHeapFreeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"SoftwareDiagnostics CurrentHeapFree Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterSoftwareDiagnosticsReadAttributeCurrentHeapUsedWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"SoftwareDiagnosticsReadAttributeCurrentHeapUsedWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPSoftwareDiagnostics * cluster = [[CHIPSoftwareDiagnostics alloc] initWithDevice:device endpoint:0 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeCurrentHeapUsedWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"SoftwareDiagnostics CurrentHeapUsed Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
- (void)testSendClusterSoftwareDiagnosticsReadAttributeCurrentHeapHighWatermarkWithResponseHandler
{
XCTestExpectation * expectation =
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
index cfdca72..1a3f734 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
@@ -10304,6 +10304,9 @@
| Attributes: | |
| * NetworkInterfaces | 0x0000 |
| * RebootCount | 0x0001 |
+| * UpTime | 0x0002 |
+| * TotalOperationalHours | 0x0003 |
+| * BootReasons | 0x0004 |
| * ClusterRevision | 0xFFFD |
\*----------------------------------------------------------------------------*/
@@ -10377,6 +10380,108 @@
};
/*
+ * Attribute UpTime
+ */
+class ReadGeneralDiagnosticsUpTime : public ModelCommand
+{
+public:
+ ReadGeneralDiagnosticsUpTime() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "up-time");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadGeneralDiagnosticsUpTime()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0033) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeUpTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<Int64uAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<Int64uAttributeCallback>(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute TotalOperationalHours
+ */
+class ReadGeneralDiagnosticsTotalOperationalHours : public ModelCommand
+{
+public:
+ ReadGeneralDiagnosticsTotalOperationalHours() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "total-operational-hours");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadGeneralDiagnosticsTotalOperationalHours()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0033) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeTotalOperationalHours(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<Int32uAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<Int32uAttributeCallback>(OnInt32uAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute BootReasons
+ */
+class ReadGeneralDiagnosticsBootReasons : public ModelCommand
+{
+public:
+ ReadGeneralDiagnosticsBootReasons() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "boot-reasons");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadGeneralDiagnosticsBootReasons()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0033) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::GeneralDiagnosticsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeBootReasons(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<Int8uAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<Int8uAttributeCallback>(OnInt8uAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
* Attribute ClusterRevision
*/
class ReadGeneralDiagnosticsClusterRevision : public ModelCommand
@@ -16373,6 +16478,8 @@
| * ResetWatermarks | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
+| * CurrentHeapFree | 0x0001 |
+| * CurrentHeapUsed | 0x0002 |
| * CurrentHeapHighWatermark | 0x0003 |
| * ClusterRevision | 0xFFFD |
\*----------------------------------------------------------------------------*/
@@ -16407,6 +16514,74 @@
};
/*
+ * Attribute CurrentHeapFree
+ */
+class ReadSoftwareDiagnosticsCurrentHeapFree : public ModelCommand
+{
+public:
+ ReadSoftwareDiagnosticsCurrentHeapFree() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "current-heap-free");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadSoftwareDiagnosticsCurrentHeapFree()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0034) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::SoftwareDiagnosticsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeCurrentHeapFree(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<Int64uAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<Int64uAttributeCallback>(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute CurrentHeapUsed
+ */
+class ReadSoftwareDiagnosticsCurrentHeapUsed : public ModelCommand
+{
+public:
+ ReadSoftwareDiagnosticsCurrentHeapUsed() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "current-heap-used");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadSoftwareDiagnosticsCurrentHeapUsed()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0034) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::SoftwareDiagnosticsCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeCurrentHeapUsed(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback<Int64uAttributeCallback> * onSuccessCallback =
+ new chip::Callback::Callback<Int64uAttributeCallback>(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback<DefaultFailureCallback> * onFailureCallback =
+ new chip::Callback::Callback<DefaultFailureCallback>(OnDefaultFailureResponse, this);
+};
+
+/*
* Attribute CurrentHeapHighWatermark
*/
class ReadSoftwareDiagnosticsCurrentHeapHighWatermark : public ModelCommand
@@ -24750,9 +24925,12 @@
const char * clusterName = "GeneralDiagnostics";
commands_list clusterCommands = {
- make_unique<ReadGeneralDiagnosticsNetworkInterfaces>(), //
- make_unique<ReadGeneralDiagnosticsRebootCount>(), //
- make_unique<ReadGeneralDiagnosticsClusterRevision>(), //
+ make_unique<ReadGeneralDiagnosticsNetworkInterfaces>(), //
+ make_unique<ReadGeneralDiagnosticsRebootCount>(), //
+ make_unique<ReadGeneralDiagnosticsUpTime>(), //
+ make_unique<ReadGeneralDiagnosticsTotalOperationalHours>(), //
+ make_unique<ReadGeneralDiagnosticsBootReasons>(), //
+ make_unique<ReadGeneralDiagnosticsClusterRevision>(), //
};
commands.Register(clusterName, clusterCommands);
@@ -25104,6 +25282,8 @@
commands_list clusterCommands = {
make_unique<SoftwareDiagnosticsResetWatermarks>(), //
+ make_unique<ReadSoftwareDiagnosticsCurrentHeapFree>(), //
+ make_unique<ReadSoftwareDiagnosticsCurrentHeapUsed>(), //
make_unique<ReadSoftwareDiagnosticsCurrentHeapHighWatermark>(), //
make_unique<ReadSoftwareDiagnosticsClusterRevision>(), //
};
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
index 9397ce9..320083b 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
@@ -5276,6 +5276,42 @@
BasicAttributeFilter<Int16uAttributeCallback>);
}
+CHIP_ERROR GeneralDiagnosticsCluster::ReadAttributeUpTime(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000002;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter<Int64uAttributeCallback>);
+}
+
+CHIP_ERROR GeneralDiagnosticsCluster::ReadAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000003;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter<Int32uAttributeCallback>);
+}
+
+CHIP_ERROR GeneralDiagnosticsCluster::ReadAttributeBootReasons(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000004;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter<Int8uAttributeCallback>);
+}
+
CHIP_ERROR GeneralDiagnosticsCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback)
{
@@ -9480,6 +9516,30 @@
}
// SoftwareDiagnostics Cluster Attributes
+CHIP_ERROR SoftwareDiagnosticsCluster::ReadAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000001;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter<Int64uAttributeCallback>);
+}
+
+CHIP_ERROR SoftwareDiagnosticsCluster::ReadAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000002;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter<Int64uAttributeCallback>);
+}
+
CHIP_ERROR SoftwareDiagnosticsCluster::ReadAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback)
{
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
index 8643318..5c465de 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
@@ -630,6 +630,10 @@
// Cluster Attributes
CHIP_ERROR ReadAttributeNetworkInterfaces(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeRebootCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeUpTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeBootReasons(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
};
@@ -1108,6 +1112,8 @@
CHIP_ERROR ResetWatermarks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
// Cluster Attributes
+ CHIP_ERROR ReadAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
diff --git a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
index 4c533e4..de062e1 100644
--- a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
@@ -2216,6 +2216,58 @@
return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
}
+CHIP_ERROR GeneralDiagnosticsClusterTest::WriteAttributeUpTime(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t upTime)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = GeneralDiagnostics::Attributes::Ids::UpTime;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, upTime));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR GeneralDiagnosticsClusterTest::WriteAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback,
+ uint32_t totalOperationalHours)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = GeneralDiagnostics::Attributes::Ids::TotalOperationalHours;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, totalOperationalHours));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR GeneralDiagnosticsClusterTest::WriteAttributeBootReasons(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint8_t bootReasons)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = GeneralDiagnostics::Attributes::Ids::BootReasons;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, bootReasons));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
CHIP_ERROR GeneralDiagnosticsClusterTest::WriteAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback,
uint16_t clusterRevision)
@@ -3425,6 +3477,42 @@
return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
}
+CHIP_ERROR SoftwareDiagnosticsClusterTest::WriteAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback,
+ uint64_t currentHeapFree)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = SoftwareDiagnostics::Attributes::Ids::CurrentHeapFree;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, currentHeapFree));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR SoftwareDiagnosticsClusterTest::WriteAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback,
+ uint64_t currentHeapUsed)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = SoftwareDiagnostics::Attributes::Ids::CurrentHeapUsed;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, currentHeapUsed));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
CHIP_ERROR SoftwareDiagnosticsClusterTest::WriteAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback,
uint64_t currentHeapHighWatermark)
diff --git a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
index 34596d2..21d9a30 100644
--- a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
+++ b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
@@ -437,6 +437,12 @@
CHIP_ERROR WriteAttributeRebootCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
uint16_t value);
+ CHIP_ERROR WriteAttributeUpTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributeTotalOperationalHours(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint32_t value);
+ CHIP_ERROR WriteAttributeBootReasons(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint8_t value);
CHIP_ERROR WriteAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
uint16_t value);
};
@@ -742,6 +748,10 @@
SoftwareDiagnosticsClusterTest() : SoftwareDiagnosticsCluster() {}
~SoftwareDiagnosticsClusterTest() {}
+ CHIP_ERROR WriteAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
CHIP_ERROR WriteAttributeCurrentHeapHighWatermark(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback, uint64_t value);
CHIP_ERROR WriteAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
