diff --git a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter index be9b08eecf6c5d..a50e5855ba1113 100644 --- a/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter +++ b/examples/air-purifier-app/air-purifier-common/air-purifier-app.matter @@ -1656,6 +1656,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1764,6 +1765,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index be6f4c0622c94a..e0cfe5a7ad3f3a 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -5519,6 +5519,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5627,6 +5628,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter index e7c61c1c308a05..adaa874c48b2af 100644 --- a/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter +++ b/examples/all-clusters-minimal-app/all-clusters-common/all-clusters-minimal-app.matter @@ -3931,6 +3931,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -4039,6 +4040,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter index dfa25e487b78e9..e62c3ddd5415d8 100644 --- a/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter +++ b/examples/chef/devices/rootnode_airpurifier_airqualitysensor_temperaturesensor_humiditysensor_thermostat_56de3d5f45.matter @@ -1579,6 +1579,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1687,6 +1688,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter index 76eac769b14b2b..36c24a441fe7b7 100644 --- a/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter +++ b/examples/chef/devices/rootnode_heatingcoolingunit_ncdGai1E5a.matter @@ -1875,6 +1875,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1983,6 +1984,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter index ecd48d74867218..d677e0c903adba 100644 --- a/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter +++ b/examples/chef/devices/rootnode_heatpump_87ivjRAECh.matter @@ -2138,6 +2138,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2246,6 +2247,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter index bb4a46da845f29..318f52134f9096 100644 --- a/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter +++ b/examples/chef/devices/rootnode_roomairconditioner_9cf3607804.matter @@ -1519,6 +1519,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1627,6 +1628,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter index 549c98f930b62b..c5d5379c2dec7a 100644 --- a/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter +++ b/examples/chef/devices/rootnode_thermostat_bm3fb8dhYi.matter @@ -1739,6 +1739,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1847,6 +1848,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/placeholder/linux/apps/app1/config.matter b/examples/placeholder/linux/apps/app1/config.matter index 6bc47afef7015b..e87e8146544d10 100644 --- a/examples/placeholder/linux/apps/app1/config.matter +++ b/examples/placeholder/linux/apps/app1/config.matter @@ -5218,6 +5218,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5326,6 +5327,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; @@ -5573,6 +5615,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5681,6 +5724,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/placeholder/linux/apps/app2/config.matter b/examples/placeholder/linux/apps/app2/config.matter index 9b116eb8ba7780..49c12cde2a8f08 100644 --- a/examples/placeholder/linux/apps/app2/config.matter +++ b/examples/placeholder/linux/apps/app2/config.matter @@ -5175,6 +5175,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5283,6 +5284,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; @@ -5530,6 +5572,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -5638,6 +5681,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_br.matter b/examples/thermostat/nxp/zap/thermostat_matter_br.matter index 1ba87a1fbd58b5..ea9675edcc5e8a 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_br.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_br.matter @@ -1891,6 +1891,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1999,6 +2000,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter index af687b2ba11bcb..2a558d7ad9bd7f 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_thread.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_thread.matter @@ -1814,6 +1814,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1922,6 +1923,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter index 825a527c59b155..eab75a84860442 100644 --- a/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter +++ b/examples/thermostat/nxp/zap/thermostat_matter_wifi.matter @@ -1725,6 +1725,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -1833,6 +1834,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter index 96ed93bd8c07b9..5223ec2f76fd3a 100644 --- a/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter +++ b/examples/thermostat/qpg/zap/thermostaticRadiatorValve.matter @@ -1938,6 +1938,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2046,6 +2047,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/examples/thermostat/thermostat-common/thermostat.matter b/examples/thermostat/thermostat-common/thermostat.matter index 03428f294324cf..84b581797c4280 100644 --- a/examples/thermostat/thermostat-common/thermostat.matter +++ b/examples/thermostat/thermostat-common/thermostat.matter @@ -2118,6 +2118,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -2226,6 +2227,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index aa2707931f36d6..223c784442bae6 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -6818,6 +6818,7 @@ cluster Thermostat = 513 { kLocalTemperatureNotExposed = 0x40; kMatterScheduleConfiguration = 0x80; kPresets = 0x100; + kEvents = 0x200; } bitmap HVACSystemTypeBitmap : bitmap8 { @@ -6926,6 +6927,47 @@ cluster Thermostat = 513 { nullable temperature coolSetpoint = 2; } + info event SystemModeChange = 0 { + SystemModeEnum previousSystemMode = 0; + SystemModeEnum currentSystemMode = 1; + } + + info event LocalTemperatureChange = 1 { + temperature currentLocalTemperature = 0; + } + + info event OccupancyChange = 2 { + OccupancyBitmap previousOccupancy = 0; + OccupancyBitmap currentOccupancy = 1; + } + + info event SetpointChange = 3 { + SystemModeEnum systemMode = 0; + OccupancyBitmap occupancy = 1; + temperature previousSetpoint = 2; + temperature currentSetpoint = 3; + } + + info event RunningStateChange = 4 { + RelayStateBitmap previousRunningState = 0; + RelayStateBitmap currentRunningState = 1; + } + + info event RunningModeChange = 5 { + ThermostatRunningModeEnum previousRunningMode = 0; + ThermostatRunningModeEnum currentRunningMode = 1; + } + + info event ActiveScheduleChange = 6 { + octet_string previousScheduleHandle = 0; + octet_string currentScheduleHandle = 1; + } + + info event ActivePresetChange = 7 { + octet_string previousPresetHandle = 0; + octet_string currentPresetHandle = 1; + } + readonly attribute nullable temperature localTemperature = 0; readonly attribute optional nullable temperature outdoorTemperature = 1; readonly attribute optional OccupancyBitmap occupancy = 2; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java index 59892d05188b8a..6c00351773f4fd 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java @@ -5825,6 +5825,509 @@ public String toString() { return output.toString(); } } +public static class ThermostatClusterSystemModeChangeEvent { + public Integer previousSystemMode; + public Integer currentSystemMode; + private static final long PREVIOUS_SYSTEM_MODE_ID = 0L; + private static final long CURRENT_SYSTEM_MODE_ID = 1L; + + public ThermostatClusterSystemModeChangeEvent( + Integer previousSystemMode, + Integer currentSystemMode + ) { + this.previousSystemMode = previousSystemMode; + this.currentSystemMode = currentSystemMode; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_SYSTEM_MODE_ID, new UIntType(previousSystemMode))); + values.add(new StructElement(CURRENT_SYSTEM_MODE_ID, new UIntType(currentSystemMode))); + + return new StructType(values); + } + + public static ThermostatClusterSystemModeChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousSystemMode = null; + Integer currentSystemMode = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousSystemMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentSystemMode = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterSystemModeChangeEvent( + previousSystemMode, + currentSystemMode + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterSystemModeChangeEvent {\n"); + output.append("\tpreviousSystemMode: "); + output.append(previousSystemMode); + output.append("\n"); + output.append("\tcurrentSystemMode: "); + output.append(currentSystemMode); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterLocalTemperatureChangeEvent { + public Integer currentLocalTemperature; + private static final long CURRENT_LOCAL_TEMPERATURE_ID = 0L; + + public ThermostatClusterLocalTemperatureChangeEvent( + Integer currentLocalTemperature + ) { + this.currentLocalTemperature = currentLocalTemperature; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(CURRENT_LOCAL_TEMPERATURE_ID, new IntType(currentLocalTemperature))); + + return new StructType(values); + } + + public static ThermostatClusterLocalTemperatureChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer currentLocalTemperature = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == CURRENT_LOCAL_TEMPERATURE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + currentLocalTemperature = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterLocalTemperatureChangeEvent( + currentLocalTemperature + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterLocalTemperatureChangeEvent {\n"); + output.append("\tcurrentLocalTemperature: "); + output.append(currentLocalTemperature); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterOccupancyChangeEvent { + public Integer previousOccupancy; + public Integer currentOccupancy; + private static final long PREVIOUS_OCCUPANCY_ID = 0L; + private static final long CURRENT_OCCUPANCY_ID = 1L; + + public ThermostatClusterOccupancyChangeEvent( + Integer previousOccupancy, + Integer currentOccupancy + ) { + this.previousOccupancy = previousOccupancy; + this.currentOccupancy = currentOccupancy; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_OCCUPANCY_ID, new UIntType(previousOccupancy))); + values.add(new StructElement(CURRENT_OCCUPANCY_ID, new UIntType(currentOccupancy))); + + return new StructType(values); + } + + public static ThermostatClusterOccupancyChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousOccupancy = null; + Integer currentOccupancy = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousOccupancy = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentOccupancy = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterOccupancyChangeEvent( + previousOccupancy, + currentOccupancy + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterOccupancyChangeEvent {\n"); + output.append("\tpreviousOccupancy: "); + output.append(previousOccupancy); + output.append("\n"); + output.append("\tcurrentOccupancy: "); + output.append(currentOccupancy); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterSetpointChangeEvent { + public Integer systemMode; + public Integer occupancy; + public Integer previousSetpoint; + public Integer currentSetpoint; + private static final long SYSTEM_MODE_ID = 0L; + private static final long OCCUPANCY_ID = 1L; + private static final long PREVIOUS_SETPOINT_ID = 2L; + private static final long CURRENT_SETPOINT_ID = 3L; + + public ThermostatClusterSetpointChangeEvent( + Integer systemMode, + Integer occupancy, + Integer previousSetpoint, + Integer currentSetpoint + ) { + this.systemMode = systemMode; + this.occupancy = occupancy; + this.previousSetpoint = previousSetpoint; + this.currentSetpoint = currentSetpoint; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(SYSTEM_MODE_ID, new UIntType(systemMode))); + values.add(new StructElement(OCCUPANCY_ID, new UIntType(occupancy))); + values.add(new StructElement(PREVIOUS_SETPOINT_ID, new IntType(previousSetpoint))); + values.add(new StructElement(CURRENT_SETPOINT_ID, new IntType(currentSetpoint))); + + return new StructType(values); + } + + public static ThermostatClusterSetpointChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer systemMode = null; + Integer occupancy = null; + Integer previousSetpoint = null; + Integer currentSetpoint = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == SYSTEM_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + systemMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == OCCUPANCY_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + occupancy = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == PREVIOUS_SETPOINT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + previousSetpoint = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_SETPOINT_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.Int) { + IntType castingValue = element.value(IntType.class); + currentSetpoint = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterSetpointChangeEvent {\n"); + output.append("\tsystemMode: "); + output.append(systemMode); + output.append("\n"); + output.append("\toccupancy: "); + output.append(occupancy); + output.append("\n"); + output.append("\tpreviousSetpoint: "); + output.append(previousSetpoint); + output.append("\n"); + output.append("\tcurrentSetpoint: "); + output.append(currentSetpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterRunningStateChangeEvent { + public Integer previousRunningState; + public Integer currentRunningState; + private static final long PREVIOUS_RUNNING_STATE_ID = 0L; + private static final long CURRENT_RUNNING_STATE_ID = 1L; + + public ThermostatClusterRunningStateChangeEvent( + Integer previousRunningState, + Integer currentRunningState + ) { + this.previousRunningState = previousRunningState; + this.currentRunningState = currentRunningState; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_RUNNING_STATE_ID, new UIntType(previousRunningState))); + values.add(new StructElement(CURRENT_RUNNING_STATE_ID, new UIntType(currentRunningState))); + + return new StructType(values); + } + + public static ThermostatClusterRunningStateChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousRunningState = null; + Integer currentRunningState = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_RUNNING_STATE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousRunningState = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_RUNNING_STATE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentRunningState = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterRunningStateChangeEvent( + previousRunningState, + currentRunningState + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterRunningStateChangeEvent {\n"); + output.append("\tpreviousRunningState: "); + output.append(previousRunningState); + output.append("\n"); + output.append("\tcurrentRunningState: "); + output.append(currentRunningState); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterRunningModeChangeEvent { + public Integer previousRunningMode; + public Integer currentRunningMode; + private static final long PREVIOUS_RUNNING_MODE_ID = 0L; + private static final long CURRENT_RUNNING_MODE_ID = 1L; + + public ThermostatClusterRunningModeChangeEvent( + Integer previousRunningMode, + Integer currentRunningMode + ) { + this.previousRunningMode = previousRunningMode; + this.currentRunningMode = currentRunningMode; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_RUNNING_MODE_ID, new UIntType(previousRunningMode))); + values.add(new StructElement(CURRENT_RUNNING_MODE_ID, new UIntType(currentRunningMode))); + + return new StructType(values); + } + + public static ThermostatClusterRunningModeChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + Integer previousRunningMode = null; + Integer currentRunningMode = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_RUNNING_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + previousRunningMode = castingValue.value(Integer.class); + } + } else if (element.contextTagNum() == CURRENT_RUNNING_MODE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.UInt) { + UIntType castingValue = element.value(UIntType.class); + currentRunningMode = castingValue.value(Integer.class); + } + } + } + return new ThermostatClusterRunningModeChangeEvent( + previousRunningMode, + currentRunningMode + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterRunningModeChangeEvent {\n"); + output.append("\tpreviousRunningMode: "); + output.append(previousRunningMode); + output.append("\n"); + output.append("\tcurrentRunningMode: "); + output.append(currentRunningMode); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterActiveScheduleChangeEvent { + public byte[] previousScheduleHandle; + public byte[] currentScheduleHandle; + private static final long PREVIOUS_SCHEDULE_HANDLE_ID = 0L; + private static final long CURRENT_SCHEDULE_HANDLE_ID = 1L; + + public ThermostatClusterActiveScheduleChangeEvent( + byte[] previousScheduleHandle, + byte[] currentScheduleHandle + ) { + this.previousScheduleHandle = previousScheduleHandle; + this.currentScheduleHandle = currentScheduleHandle; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_SCHEDULE_HANDLE_ID, new ByteArrayType(previousScheduleHandle))); + values.add(new StructElement(CURRENT_SCHEDULE_HANDLE_ID, new ByteArrayType(currentScheduleHandle))); + + return new StructType(values); + } + + public static ThermostatClusterActiveScheduleChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + byte[] previousScheduleHandle = null; + byte[] currentScheduleHandle = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_SCHEDULE_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + previousScheduleHandle = castingValue.value(byte[].class); + } + } else if (element.contextTagNum() == CURRENT_SCHEDULE_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + currentScheduleHandle = castingValue.value(byte[].class); + } + } + } + return new ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterActiveScheduleChangeEvent {\n"); + output.append("\tpreviousScheduleHandle: "); + output.append(Arrays.toString(previousScheduleHandle)); + output.append("\n"); + output.append("\tcurrentScheduleHandle: "); + output.append(Arrays.toString(currentScheduleHandle)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} +public static class ThermostatClusterActivePresetChangeEvent { + public byte[] previousPresetHandle; + public byte[] currentPresetHandle; + private static final long PREVIOUS_PRESET_HANDLE_ID = 0L; + private static final long CURRENT_PRESET_HANDLE_ID = 1L; + + public ThermostatClusterActivePresetChangeEvent( + byte[] previousPresetHandle, + byte[] currentPresetHandle + ) { + this.previousPresetHandle = previousPresetHandle; + this.currentPresetHandle = currentPresetHandle; + } + + public StructType encodeTlv() { + ArrayList values = new ArrayList<>(); + values.add(new StructElement(PREVIOUS_PRESET_HANDLE_ID, new ByteArrayType(previousPresetHandle))); + values.add(new StructElement(CURRENT_PRESET_HANDLE_ID, new ByteArrayType(currentPresetHandle))); + + return new StructType(values); + } + + public static ThermostatClusterActivePresetChangeEvent decodeTlv(BaseTLVType tlvValue) { + if (tlvValue == null || tlvValue.type() != TLVType.Struct) { + return null; + } + byte[] previousPresetHandle = null; + byte[] currentPresetHandle = null; + for (StructElement element: ((StructType)tlvValue).value()) { + if (element.contextTagNum() == PREVIOUS_PRESET_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + previousPresetHandle = castingValue.value(byte[].class); + } + } else if (element.contextTagNum() == CURRENT_PRESET_HANDLE_ID) { + if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) { + ByteArrayType castingValue = element.value(ByteArrayType.class); + currentPresetHandle = castingValue.value(byte[].class); + } + } + } + return new ThermostatClusterActivePresetChangeEvent( + previousPresetHandle, + currentPresetHandle + ); + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThermostatClusterActivePresetChangeEvent {\n"); + output.append("\tpreviousPresetHandle: "); + output.append(Arrays.toString(previousPresetHandle)); + output.append("\n"); + output.append("\tcurrentPresetHandle: "); + output.append(Arrays.toString(currentPresetHandle)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} public static class OccupancySensingClusterOccupancyChangedEvent { public Integer occupancy; private static final long OCCUPANCY_ID = 0L; diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 86a43781fec889..39d948d114b7c2 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -11660,7 +11660,15 @@ public static Attribute value(long id) throws NoSuchFieldError { } } - public enum Event {; + public enum Event { + SystemModeChange(0L), + LocalTemperatureChange(1L), + OccupancyChange(2L), + SetpointChange(3L), + RunningStateChange(4L), + RunningModeChange(5L), + ActiveScheduleChange(6L), + ActivePresetChange(7L),; private final long id; Event(long id) { this.id = id; diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt new file mode 100644 index 00000000000000..3dbc04fac9e76d --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActivePresetChangeEvent( + val previousPresetHandle: ByteArray, + val currentPresetHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActivePresetChangeEvent {\n") + append("\tpreviousPresetHandle : $previousPresetHandle\n") + append("\tcurrentPresetHandle : $currentPresetHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_PRESET_HANDLE = 0 + private const val TAG_CURRENT_PRESET_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + val currentPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActivePresetChangeEvent(previousPresetHandle, currentPresetHandle) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt new file mode 100644 index 00000000000000..e20c472b84ec7e --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -0,0 +1,64 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActiveScheduleChangeEvent( + val previousScheduleHandle: ByteArray, + val currentScheduleHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActiveScheduleChangeEvent {\n") + append("\tpreviousScheduleHandle : $previousScheduleHandle\n") + append("\tcurrentScheduleHandle : $currentScheduleHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SCHEDULE_HANDLE = 0 + private const val TAG_CURRENT_SCHEDULE_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + val currentScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle, + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt new file mode 100644 index 00000000000000..63fc1ee7e67cd3 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt @@ -0,0 +1,53 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterLocalTemperatureChangeEvent(val currentLocalTemperature: Int) { + override fun toString(): String = buildString { + append("ThermostatClusterLocalTemperatureChangeEvent {\n") + append("\tcurrentLocalTemperature : $currentLocalTemperature\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE), currentLocalTemperature) + endStructure() + } + } + + companion object { + private const val TAG_CURRENT_LOCAL_TEMPERATURE = 0 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterLocalTemperatureChangeEvent { + tlvReader.enterStructure(tlvTag) + val currentLocalTemperature = + tlvReader.getInt(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE)) + + tlvReader.exitContainer() + + return ThermostatClusterLocalTemperatureChangeEvent(currentLocalTemperature) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt new file mode 100644 index 00000000000000..db1dd397cccda3 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterOccupancyChangeEvent( + val previousOccupancy: UInt, + val currentOccupancy: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterOccupancyChangeEvent {\n") + append("\tpreviousOccupancy : $previousOccupancy\n") + append("\tcurrentOccupancy : $currentOccupancy\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_OCCUPANCY = 0 + private const val TAG_CURRENT_OCCUPANCY = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val currentOccupancy = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) + + tlvReader.exitContainer() + + return ThermostatClusterOccupancyChangeEvent(previousOccupancy, currentOccupancy) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt new file mode 100644 index 00000000000000..1c0e3698dd2111 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningModeChangeEvent( + val previousRunningMode: UInt, + val currentRunningMode: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningModeChangeEvent {\n") + append("\tpreviousRunningMode : $previousRunningMode\n") + append("\tcurrentRunningMode : $currentRunningMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_MODE = 0 + private const val TAG_CURRENT_RUNNING_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val currentRunningMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningModeChangeEvent(previousRunningMode, currentRunningMode) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt new file mode 100644 index 00000000000000..eb3ce3277114ec --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningStateChangeEvent( + val previousRunningState: UInt, + val currentRunningState: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningStateChangeEvent {\n") + append("\tpreviousRunningState : $previousRunningState\n") + append("\tcurrentRunningState : $currentRunningState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_STATE = 0 + private const val TAG_CURRENT_RUNNING_STATE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val currentRunningState = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningStateChangeEvent(previousRunningState, currentRunningState) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt new file mode 100644 index 00000000000000..a6e62436e4b23c --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSetpointChangeEvent( + val systemMode: UInt, + val occupancy: UInt, + val previousSetpoint: Int, + val currentSetpoint: Int, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSetpointChangeEvent {\n") + append("\tsystemMode : $systemMode\n") + append("\toccupancy : $occupancy\n") + append("\tpreviousSetpoint : $previousSetpoint\n") + append("\tcurrentSetpoint : $currentSetpoint\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) + put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) + endStructure() + } + } + + companion object { + private const val TAG_SYSTEM_MODE = 0 + private const val TAG_OCCUPANCY = 1 + private const val TAG_PREVIOUS_SETPOINT = 2 + private const val TAG_CURRENT_SETPOINT = 3 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSetpointChangeEvent { + tlvReader.enterStructure(tlvTag) + val systemMode = tlvReader.getUInt(ContextSpecificTag(TAG_SYSTEM_MODE)) + val occupancy = tlvReader.getUInt(ContextSpecificTag(TAG_OCCUPANCY)) + val previousSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val currentSetpoint = tlvReader.getInt(ContextSpecificTag(TAG_CURRENT_SETPOINT)) + + tlvReader.exitContainer() + + return ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint, + ) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt new file mode 100644 index 00000000000000..38f2c727bfc6e7 --- /dev/null +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package chip.devicecontroller.cluster.eventstructs + +import chip.devicecontroller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSystemModeChangeEvent( + val previousSystemMode: UInt, + val currentSystemMode: UInt, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSystemModeChangeEvent {\n") + append("\tpreviousSystemMode : $previousSystemMode\n") + append("\tcurrentSystemMode : $currentSystemMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SYSTEM_MODE = 0 + private const val TAG_CURRENT_SYSTEM_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val currentSystemMode = tlvReader.getUInt(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterSystemModeChangeEvent(previousSystemMode, currentSystemMode) + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni index a4fcda9f9bfcc0..7ad0bc8201d8c7 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni +++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni @@ -254,6 +254,14 @@ eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/TargetNavigatorClusterTargetUpdatedEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt new file mode 100644 index 00000000000000..2040aa07f1c842 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt @@ -0,0 +1,61 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActivePresetChangeEvent( + val previousPresetHandle: ByteArray, + val currentPresetHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActivePresetChangeEvent {\n") + append("\tpreviousPresetHandle : $previousPresetHandle\n") + append("\tcurrentPresetHandle : $currentPresetHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE), previousPresetHandle) + put(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE), currentPresetHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_PRESET_HANDLE = 0 + private const val TAG_CURRENT_PRESET_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActivePresetChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_PRESET_HANDLE)) + val currentPresetHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_PRESET_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActivePresetChangeEvent(previousPresetHandle, currentPresetHandle) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt new file mode 100644 index 00000000000000..9664d5670d976c --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt @@ -0,0 +1,64 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterActiveScheduleChangeEvent( + val previousScheduleHandle: ByteArray, + val currentScheduleHandle: ByteArray, +) { + override fun toString(): String = buildString { + append("ThermostatClusterActiveScheduleChangeEvent {\n") + append("\tpreviousScheduleHandle : $previousScheduleHandle\n") + append("\tcurrentScheduleHandle : $currentScheduleHandle\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE), previousScheduleHandle) + put(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE), currentScheduleHandle) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SCHEDULE_HANDLE = 0 + private const val TAG_CURRENT_SCHEDULE_HANDLE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterActiveScheduleChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_PREVIOUS_SCHEDULE_HANDLE)) + val currentScheduleHandle = + tlvReader.getByteArray(ContextSpecificTag(TAG_CURRENT_SCHEDULE_HANDLE)) + + tlvReader.exitContainer() + + return ThermostatClusterActiveScheduleChangeEvent( + previousScheduleHandle, + currentScheduleHandle, + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt new file mode 100644 index 00000000000000..4d4216c17bfffe --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt @@ -0,0 +1,53 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterLocalTemperatureChangeEvent(val currentLocalTemperature: Short) { + override fun toString(): String = buildString { + append("ThermostatClusterLocalTemperatureChangeEvent {\n") + append("\tcurrentLocalTemperature : $currentLocalTemperature\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE), currentLocalTemperature) + endStructure() + } + } + + companion object { + private const val TAG_CURRENT_LOCAL_TEMPERATURE = 0 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterLocalTemperatureChangeEvent { + tlvReader.enterStructure(tlvTag) + val currentLocalTemperature = + tlvReader.getShort(ContextSpecificTag(TAG_CURRENT_LOCAL_TEMPERATURE)) + + tlvReader.exitContainer() + + return ThermostatClusterLocalTemperatureChangeEvent(currentLocalTemperature) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt new file mode 100644 index 00000000000000..5a92acb59d7d5b --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterOccupancyChangeEvent( + val previousOccupancy: UByte, + val currentOccupancy: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterOccupancyChangeEvent {\n") + append("\tpreviousOccupancy : $previousOccupancy\n") + append("\tcurrentOccupancy : $currentOccupancy\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY), previousOccupancy) + put(ContextSpecificTag(TAG_CURRENT_OCCUPANCY), currentOccupancy) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_OCCUPANCY = 0 + private const val TAG_CURRENT_OCCUPANCY = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterOccupancyChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_OCCUPANCY)) + val currentOccupancy = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_OCCUPANCY)) + + tlvReader.exitContainer() + + return ThermostatClusterOccupancyChangeEvent(previousOccupancy, currentOccupancy) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt new file mode 100644 index 00000000000000..df399793ee1cf2 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningModeChangeEvent( + val previousRunningMode: UByte, + val currentRunningMode: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningModeChangeEvent {\n") + append("\tpreviousRunningMode : $previousRunningMode\n") + append("\tcurrentRunningMode : $currentRunningMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE), previousRunningMode) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE), currentRunningMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_MODE = 0 + private const val TAG_CURRENT_RUNNING_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_RUNNING_MODE)) + val currentRunningMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_RUNNING_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningModeChangeEvent(previousRunningMode, currentRunningMode) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt new file mode 100644 index 00000000000000..1db9ca7e54c08c --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterRunningStateChangeEvent( + val previousRunningState: UShort, + val currentRunningState: UShort, +) { + override fun toString(): String = buildString { + append("ThermostatClusterRunningStateChangeEvent {\n") + append("\tpreviousRunningState : $previousRunningState\n") + append("\tcurrentRunningState : $currentRunningState\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE), previousRunningState) + put(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE), currentRunningState) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_RUNNING_STATE = 0 + private const val TAG_CURRENT_RUNNING_STATE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterRunningStateChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_PREVIOUS_RUNNING_STATE)) + val currentRunningState = tlvReader.getUShort(ContextSpecificTag(TAG_CURRENT_RUNNING_STATE)) + + tlvReader.exitContainer() + + return ThermostatClusterRunningStateChangeEvent(previousRunningState, currentRunningState) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt new file mode 100644 index 00000000000000..62b6588d51c47b --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt @@ -0,0 +1,74 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSetpointChangeEvent( + val systemMode: UByte, + val occupancy: UByte, + val previousSetpoint: Short, + val currentSetpoint: Short, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSetpointChangeEvent {\n") + append("\tsystemMode : $systemMode\n") + append("\toccupancy : $occupancy\n") + append("\tpreviousSetpoint : $previousSetpoint\n") + append("\tcurrentSetpoint : $currentSetpoint\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_SYSTEM_MODE), systemMode) + put(ContextSpecificTag(TAG_OCCUPANCY), occupancy) + put(ContextSpecificTag(TAG_PREVIOUS_SETPOINT), previousSetpoint) + put(ContextSpecificTag(TAG_CURRENT_SETPOINT), currentSetpoint) + endStructure() + } + } + + companion object { + private const val TAG_SYSTEM_MODE = 0 + private const val TAG_OCCUPANCY = 1 + private const val TAG_PREVIOUS_SETPOINT = 2 + private const val TAG_CURRENT_SETPOINT = 3 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSetpointChangeEvent { + tlvReader.enterStructure(tlvTag) + val systemMode = tlvReader.getUByte(ContextSpecificTag(TAG_SYSTEM_MODE)) + val occupancy = tlvReader.getUByte(ContextSpecificTag(TAG_OCCUPANCY)) + val previousSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_PREVIOUS_SETPOINT)) + val currentSetpoint = tlvReader.getShort(ContextSpecificTag(TAG_CURRENT_SETPOINT)) + + tlvReader.exitContainer() + + return ThermostatClusterSetpointChangeEvent( + systemMode, + occupancy, + previousSetpoint, + currentSetpoint, + ) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt new file mode 100644 index 00000000000000..16fa4aee72f482 --- /dev/null +++ b/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt @@ -0,0 +1,59 @@ +/* + * + * Copyright (c) 2023 Project CHIP Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package matter.controller.cluster.eventstructs + +import matter.controller.cluster.* +import matter.tlv.ContextSpecificTag +import matter.tlv.Tag +import matter.tlv.TlvReader +import matter.tlv.TlvWriter + +class ThermostatClusterSystemModeChangeEvent( + val previousSystemMode: UByte, + val currentSystemMode: UByte, +) { + override fun toString(): String = buildString { + append("ThermostatClusterSystemModeChangeEvent {\n") + append("\tpreviousSystemMode : $previousSystemMode\n") + append("\tcurrentSystemMode : $currentSystemMode\n") + append("}\n") + } + + fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) { + tlvWriter.apply { + startStructure(tlvTag) + put(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE), previousSystemMode) + put(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE), currentSystemMode) + endStructure() + } + } + + companion object { + private const val TAG_PREVIOUS_SYSTEM_MODE = 0 + private const val TAG_CURRENT_SYSTEM_MODE = 1 + + fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): ThermostatClusterSystemModeChangeEvent { + tlvReader.enterStructure(tlvTag) + val previousSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_PREVIOUS_SYSTEM_MODE)) + val currentSystemMode = tlvReader.getUByte(ContextSpecificTag(TAG_CURRENT_SYSTEM_MODE)) + + tlvReader.exitContainer() + + return ThermostatClusterSystemModeChangeEvent(previousSystemMode, currentSystemMode) + } + } +} diff --git a/src/controller/java/generated/java/matter/controller/cluster/files.gni b/src/controller/java/generated/java/matter/controller/cluster/files.gni index b09fc7b799e316..3a3dc217a602bf 100644 --- a/src/controller/java/generated/java/matter/controller/cluster/files.gni +++ b/src/controller/java/generated/java/matter/controller/cluster/files.gni @@ -254,6 +254,14 @@ matter_eventstructs_sources = [ "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SwitchClusterShortReleaseEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/SwitchClusterSwitchLatchedEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/TargetNavigatorClusterTargetUpdatedEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActivePresetChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterActiveScheduleChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterLocalTemperatureChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterOccupancyChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningModeChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterRunningStateChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSetpointChangeEvent.kt", + "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThermostatClusterSystemModeChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterConnectionStatusEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/ThreadNetworkDiagnosticsClusterNetworkFaultChangeEvent.kt", "${chip_root}/src/controller/java/generated/java/matter/controller/cluster/eventstructs/TimeSynchronizationClusterDSTStatusEvent.kt", diff --git a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp index fdb5c9fb6589f7..e480eb4faad027 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -7578,6 +7578,388 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & using namespace app::Clusters::Thermostat; switch (aPath.mEventId) { + case Events::SystemModeChange::Id: { + Events::SystemModeChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousSystemMode; + std::string value_previousSystemModeClassName = "java/lang/Integer"; + std::string value_previousSystemModeCtorSignature = "(I)V"; + jint jnivalue_previousSystemMode = static_cast(cppValue.previousSystemMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSystemModeClassName.c_str(), + value_previousSystemModeCtorSignature.c_str(), + jnivalue_previousSystemMode, value_previousSystemMode); + + jobject value_currentSystemMode; + std::string value_currentSystemModeClassName = "java/lang/Integer"; + std::string value_currentSystemModeCtorSignature = "(I)V"; + jint jnivalue_currentSystemMode = static_cast(cppValue.currentSystemMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentSystemModeClassName.c_str(), + value_currentSystemModeCtorSignature.c_str(), + jnivalue_currentSystemMode, value_currentSystemMode); + + jclass systemModeChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterSystemModeChangeEvent", systemModeChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterSystemModeChangeEvent"); + return nullptr; + } + + jmethodID systemModeChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, systemModeChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &systemModeChangeStructCtor); + if (err != CHIP_NO_ERROR || systemModeChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterSystemModeChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(systemModeChangeStructClass, systemModeChangeStructCtor, value_previousSystemMode, + value_currentSystemMode); + + return value; + } + case Events::LocalTemperatureChange::Id: { + Events::LocalTemperatureChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_currentLocalTemperature; + std::string value_currentLocalTemperatureClassName = "java/lang/Integer"; + std::string value_currentLocalTemperatureCtorSignature = "(I)V"; + jint jnivalue_currentLocalTemperature = static_cast(cppValue.currentLocalTemperature); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_currentLocalTemperatureClassName.c_str(), value_currentLocalTemperatureCtorSignature.c_str(), + jnivalue_currentLocalTemperature, value_currentLocalTemperature); + + jclass localTemperatureChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent", + localTemperatureChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent"); + return nullptr; + } + + jmethodID localTemperatureChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, localTemperatureChangeStructClass, "", + "(Ljava/lang/Integer;)V", &localTemperatureChangeStructCtor); + if (err != CHIP_NO_ERROR || localTemperatureChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterLocalTemperatureChangeEvent constructor"); + return nullptr; + } + + jobject value = + env->NewObject(localTemperatureChangeStructClass, localTemperatureChangeStructCtor, value_currentLocalTemperature); + + return value; + } + case Events::OccupancyChange::Id: { + Events::OccupancyChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousOccupancy; + std::string value_previousOccupancyClassName = "java/lang/Integer"; + std::string value_previousOccupancyCtorSignature = "(I)V"; + jint jnivalue_previousOccupancy = static_cast(cppValue.previousOccupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousOccupancyClassName.c_str(), + value_previousOccupancyCtorSignature.c_str(), + jnivalue_previousOccupancy, value_previousOccupancy); + + jobject value_currentOccupancy; + std::string value_currentOccupancyClassName = "java/lang/Integer"; + std::string value_currentOccupancyCtorSignature = "(I)V"; + jint jnivalue_currentOccupancy = static_cast(cppValue.currentOccupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentOccupancyClassName.c_str(), + value_currentOccupancyCtorSignature.c_str(), + jnivalue_currentOccupancy, value_currentOccupancy); + + jclass occupancyChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterOccupancyChangeEvent", occupancyChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterOccupancyChangeEvent"); + return nullptr; + } + + jmethodID occupancyChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod( + env, occupancyChangeStructClass, "", "(Ljava/lang/Integer;Ljava/lang/Integer;)V", &occupancyChangeStructCtor); + if (err != CHIP_NO_ERROR || occupancyChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterOccupancyChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(occupancyChangeStructClass, occupancyChangeStructCtor, value_previousOccupancy, + value_currentOccupancy); + + return value; + } + case Events::SetpointChange::Id: { + Events::SetpointChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_systemMode; + std::string value_systemModeClassName = "java/lang/Integer"; + std::string value_systemModeCtorSignature = "(I)V"; + jint jnivalue_systemMode = static_cast(cppValue.systemMode); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_systemModeClassName.c_str(), value_systemModeCtorSignature.c_str(), jnivalue_systemMode, value_systemMode); + + jobject value_occupancy; + std::string value_occupancyClassName = "java/lang/Integer"; + std::string value_occupancyCtorSignature = "(I)V"; + jint jnivalue_occupancy = static_cast(cppValue.occupancy.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject( + value_occupancyClassName.c_str(), value_occupancyCtorSignature.c_str(), jnivalue_occupancy, value_occupancy); + + jobject value_previousSetpoint; + std::string value_previousSetpointClassName = "java/lang/Integer"; + std::string value_previousSetpointCtorSignature = "(I)V"; + jint jnivalue_previousSetpoint = static_cast(cppValue.previousSetpoint); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousSetpointClassName.c_str(), + value_previousSetpointCtorSignature.c_str(), + jnivalue_previousSetpoint, value_previousSetpoint); + + jobject value_currentSetpoint; + std::string value_currentSetpointClassName = "java/lang/Integer"; + std::string value_currentSetpointCtorSignature = "(I)V"; + jint jnivalue_currentSetpoint = static_cast(cppValue.currentSetpoint); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentSetpointClassName.c_str(), + value_currentSetpointCtorSignature.c_str(), + jnivalue_currentSetpoint, value_currentSetpoint); + + jclass setpointChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterSetpointChangeEvent", setpointChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterSetpointChangeEvent"); + return nullptr; + } + + jmethodID setpointChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod( + env, setpointChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;Ljava/lang/Integer;)V", &setpointChangeStructCtor); + if (err != CHIP_NO_ERROR || setpointChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterSetpointChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(setpointChangeStructClass, setpointChangeStructCtor, value_systemMode, value_occupancy, + value_previousSetpoint, value_currentSetpoint); + + return value; + } + case Events::RunningStateChange::Id: { + Events::RunningStateChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousRunningState; + std::string value_previousRunningStateClassName = "java/lang/Integer"; + std::string value_previousRunningStateCtorSignature = "(I)V"; + jint jnivalue_previousRunningState = static_cast(cppValue.previousRunningState.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningStateClassName.c_str(), + value_previousRunningStateCtorSignature.c_str(), + jnivalue_previousRunningState, value_previousRunningState); + + jobject value_currentRunningState; + std::string value_currentRunningStateClassName = "java/lang/Integer"; + std::string value_currentRunningStateCtorSignature = "(I)V"; + jint jnivalue_currentRunningState = static_cast(cppValue.currentRunningState.Raw()); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentRunningStateClassName.c_str(), + value_currentRunningStateCtorSignature.c_str(), + jnivalue_currentRunningState, value_currentRunningState); + + jclass runningStateChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterRunningStateChangeEvent", + runningStateChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterRunningStateChangeEvent"); + return nullptr; + } + + jmethodID runningStateChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, runningStateChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &runningStateChangeStructCtor); + if (err != CHIP_NO_ERROR || runningStateChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterRunningStateChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(runningStateChangeStructClass, runningStateChangeStructCtor, value_previousRunningState, + value_currentRunningState); + + return value; + } + case Events::RunningModeChange::Id: { + Events::RunningModeChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousRunningMode; + std::string value_previousRunningModeClassName = "java/lang/Integer"; + std::string value_previousRunningModeCtorSignature = "(I)V"; + jint jnivalue_previousRunningMode = static_cast(cppValue.previousRunningMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_previousRunningModeClassName.c_str(), + value_previousRunningModeCtorSignature.c_str(), + jnivalue_previousRunningMode, value_previousRunningMode); + + jobject value_currentRunningMode; + std::string value_currentRunningModeClassName = "java/lang/Integer"; + std::string value_currentRunningModeCtorSignature = "(I)V"; + jint jnivalue_currentRunningMode = static_cast(cppValue.currentRunningMode); + chip::JniReferences::GetInstance().CreateBoxedObject(value_currentRunningModeClassName.c_str(), + value_currentRunningModeCtorSignature.c_str(), + jnivalue_currentRunningMode, value_currentRunningMode); + + jclass runningModeChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterRunningModeChangeEvent", + runningModeChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterRunningModeChangeEvent"); + return nullptr; + } + + jmethodID runningModeChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, runningModeChangeStructClass, "", + "(Ljava/lang/Integer;Ljava/lang/Integer;)V", + &runningModeChangeStructCtor); + if (err != CHIP_NO_ERROR || runningModeChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterRunningModeChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(runningModeChangeStructClass, runningModeChangeStructCtor, value_previousRunningMode, + value_currentRunningMode); + + return value; + } + case Events::ActiveScheduleChange::Id: { + Events::ActiveScheduleChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousScheduleHandle; + jbyteArray value_previousScheduleHandleByteArray = + env->NewByteArray(static_cast(cppValue.previousScheduleHandle.size())); + env->SetByteArrayRegion(value_previousScheduleHandleByteArray, 0, + static_cast(cppValue.previousScheduleHandle.size()), + reinterpret_cast(cppValue.previousScheduleHandle.data())); + value_previousScheduleHandle = value_previousScheduleHandleByteArray; + + jobject value_currentScheduleHandle; + jbyteArray value_currentScheduleHandleByteArray = + env->NewByteArray(static_cast(cppValue.currentScheduleHandle.size())); + env->SetByteArrayRegion(value_currentScheduleHandleByteArray, 0, + static_cast(cppValue.currentScheduleHandle.size()), + reinterpret_cast(cppValue.currentScheduleHandle.data())); + value_currentScheduleHandle = value_currentScheduleHandleByteArray; + + jclass activeScheduleChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent", + activeScheduleChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent"); + return nullptr; + } + + jmethodID activeScheduleChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, activeScheduleChangeStructClass, "", "([B[B)V", + &activeScheduleChangeStructCtor); + if (err != CHIP_NO_ERROR || activeScheduleChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActiveScheduleChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(activeScheduleChangeStructClass, activeScheduleChangeStructCtor, + value_previousScheduleHandle, value_currentScheduleHandle); + + return value; + } + case Events::ActivePresetChange::Id: { + Events::ActivePresetChange::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_previousPresetHandle; + jbyteArray value_previousPresetHandleByteArray = + env->NewByteArray(static_cast(cppValue.previousPresetHandle.size())); + env->SetByteArrayRegion(value_previousPresetHandleByteArray, 0, + static_cast(cppValue.previousPresetHandle.size()), + reinterpret_cast(cppValue.previousPresetHandle.data())); + value_previousPresetHandle = value_previousPresetHandleByteArray; + + jobject value_currentPresetHandle; + jbyteArray value_currentPresetHandleByteArray = + env->NewByteArray(static_cast(cppValue.currentPresetHandle.size())); + env->SetByteArrayRegion(value_currentPresetHandleByteArray, 0, static_cast(cppValue.currentPresetHandle.size()), + reinterpret_cast(cppValue.currentPresetHandle.data())); + value_currentPresetHandle = value_currentPresetHandleByteArray; + + jclass activePresetChangeStructClass; + err = chip::JniReferences::GetInstance().GetLocalClassRef( + env, "chip/devicecontroller/ChipEventStructs$ThermostatClusterActivePresetChangeEvent", + activePresetChangeStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$ThermostatClusterActivePresetChangeEvent"); + return nullptr; + } + + jmethodID activePresetChangeStructCtor; + err = chip::JniReferences::GetInstance().FindMethod(env, activePresetChangeStructClass, "", "([B[B)V", + &activePresetChangeStructCtor); + if (err != CHIP_NO_ERROR || activePresetChangeStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$ThermostatClusterActivePresetChangeEvent constructor"); + return nullptr; + } + + jobject value = env->NewObject(activePresetChangeStructClass, activePresetChangeStructCtor, value_previousPresetHandle, + value_currentPresetHandle); + + return value; + } default: *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; break; diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index b27196c7512fce..08d62d616fe07b 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -30696,6 +30696,7 @@ class Feature(IntFlag): kLocalTemperatureNotExposed = 0x40 kMatterScheduleConfiguration = 0x80 kPresets = 0x100 + kEvents = 0x200 class HVACSystemTypeBitmap(IntFlag): kCoolingStage = 0x3 @@ -32065,6 +32066,177 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: uint = 0 + class Events: + @dataclass + class SystemModeChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousSystemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), + ClusterObjectFieldDescriptor(Label="currentSystemMode", Tag=1, Type=Thermostat.Enums.SystemModeEnum), + ]) + + previousSystemMode: Thermostat.Enums.SystemModeEnum = 0 + currentSystemMode: Thermostat.Enums.SystemModeEnum = 0 + + @dataclass + class LocalTemperatureChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="currentLocalTemperature", Tag=0, Type=int), + ]) + + currentLocalTemperature: int = 0 + + @dataclass + class OccupancyChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousOccupancy", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="currentOccupancy", Tag=1, Type=uint), + ]) + + previousOccupancy: uint = 0 + currentOccupancy: uint = 0 + + @dataclass + class SetpointChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="systemMode", Tag=0, Type=Thermostat.Enums.SystemModeEnum), + ClusterObjectFieldDescriptor(Label="occupancy", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="previousSetpoint", Tag=2, Type=int), + ClusterObjectFieldDescriptor(Label="currentSetpoint", Tag=3, Type=int), + ]) + + systemMode: Thermostat.Enums.SystemModeEnum = 0 + occupancy: uint = 0 + previousSetpoint: int = 0 + currentSetpoint: int = 0 + + @dataclass + class RunningStateChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000004 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousRunningState", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="currentRunningState", Tag=1, Type=uint), + ]) + + previousRunningState: uint = 0 + currentRunningState: uint = 0 + + @dataclass + class RunningModeChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000005 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousRunningMode", Tag=0, Type=Thermostat.Enums.ThermostatRunningModeEnum), + ClusterObjectFieldDescriptor(Label="currentRunningMode", Tag=1, Type=Thermostat.Enums.ThermostatRunningModeEnum), + ]) + + previousRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 + currentRunningMode: Thermostat.Enums.ThermostatRunningModeEnum = 0 + + @dataclass + class ActiveScheduleChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000006 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousScheduleHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="currentScheduleHandle", Tag=1, Type=bytes), + ]) + + previousScheduleHandle: bytes = b"" + currentScheduleHandle: bytes = b"" + + @dataclass + class ActivePresetChange(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x00000201 + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000007 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="previousPresetHandle", Tag=0, Type=bytes), + ClusterObjectFieldDescriptor(Label="currentPresetHandle", Tag=1, Type=bytes), + ]) + + previousPresetHandle: bytes = b"" + currentPresetHandle: bytes = b"" + @dataclass class FanControl(Cluster): diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index 3b73ca8805a296..c76e57789bdf39 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -18837,6 +18837,7 @@ typedef NS_OPTIONS(uint32_t, MTRThermostatFeature) { MTRThermostatFeatureLocalTemperatureNotExposed MTR_AVAILABLE(ios(17.0), macos(14.0), watchos(10.0), tvos(17.0)) = 0x40, MTRThermostatFeatureMatterScheduleConfiguration MTR_PROVISIONALLY_AVAILABLE = 0x80, MTRThermostatFeaturePresets MTR_PROVISIONALLY_AVAILABLE = 0x100, + MTRThermostatFeatureEvents MTR_PROVISIONALLY_AVAILABLE = 0x200, } MTR_AVAILABLE(ios(16.1), macos(13.0), watchos(9.1), tvos(16.1)); typedef NS_OPTIONS(uint8_t, MTRThermostatHVACSystemTypeBitmap) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 95c91d9ab34423..0c462679acfa10 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -7486,6 +7486,18 @@ typedef NS_ENUM(uint32_t, MTREventIDType) { MTREventIDTypeClusterPumpConfigurationAndControlEventAirDetectionID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x0000000F, MTREventIDTypeClusterPumpConfigurationAndControlEventTurbineOperationID MTR_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) = 0x00000010, + // Cluster Thermostat deprecated event names + + // Cluster Thermostat events + MTREventIDTypeClusterThermostatEventSystemModeChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000000, + MTREventIDTypeClusterThermostatEventLocalTemperatureChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000001, + MTREventIDTypeClusterThermostatEventOccupancyChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000002, + MTREventIDTypeClusterThermostatEventSetpointChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000003, + MTREventIDTypeClusterThermostatEventRunningStateChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000004, + MTREventIDTypeClusterThermostatEventRunningModeChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000005, + MTREventIDTypeClusterThermostatEventActiveScheduleChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000006, + MTREventIDTypeClusterThermostatEventActivePresetChangeID MTR_PROVISIONALLY_AVAILABLE = 0x00000007, + // Cluster OccupancySensing deprecated event names // Cluster OccupancySensing events diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm index 9f8206f2e04d8f..a5e18292a0c600 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterNames.mm @@ -13874,6 +13874,39 @@ switch (eventID) { + // Cluster Thermostat events + case MTREventIDTypeClusterThermostatEventSystemModeChangeID: + result = @"SystemModeChange"; + break; + + case MTREventIDTypeClusterThermostatEventLocalTemperatureChangeID: + result = @"LocalTemperatureChange"; + break; + + case MTREventIDTypeClusterThermostatEventOccupancyChangeID: + result = @"OccupancyChange"; + break; + + case MTREventIDTypeClusterThermostatEventSetpointChangeID: + result = @"SetpointChange"; + break; + + case MTREventIDTypeClusterThermostatEventRunningStateChangeID: + result = @"RunningStateChange"; + break; + + case MTREventIDTypeClusterThermostatEventRunningModeChangeID: + result = @"RunningModeChange"; + break; + + case MTREventIDTypeClusterThermostatEventActiveScheduleChangeID: + result = @"ActiveScheduleChange"; + break; + + case MTREventIDTypeClusterThermostatEventActivePresetChangeID: + result = @"ActivePresetChange"; + break; + default: result = [NSString stringWithFormat:@"", eventID]; break; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 0a04add54fd1d3..6d1c7af0397f1c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -3926,6 +3926,187 @@ static id _Nullable DecodeEventPayloadForThermostatCluster(EventId aEventId, TLV { using namespace Clusters::Thermostat; switch (aEventId) { + case Events::SystemModeChange::Id: { + Events::SystemModeChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterSystemModeChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousSystemMode)]; + value.previousSystemMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.currentSystemMode)]; + value.currentSystemMode = memberValue; + } while (0); + + return value; + } + case Events::LocalTemperatureChange::Id: { + Events::LocalTemperatureChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterLocalTemperatureChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.currentLocalTemperature]; + value.currentLocalTemperature = memberValue; + } while (0); + + return value; + } + case Events::OccupancyChange::Id: { + Events::OccupancyChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterOccupancyChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.previousOccupancy.Raw()]; + value.previousOccupancy = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.currentOccupancy.Raw()]; + value.currentOccupancy = memberValue; + } while (0); + + return value; + } + case Events::SetpointChange::Id: { + Events::SetpointChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterSetpointChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.systemMode)]; + value.systemMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:cppValue.occupancy.Raw()]; + value.occupancy = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.previousSetpoint]; + value.previousSetpoint = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithShort:cppValue.currentSetpoint]; + value.currentSetpoint = memberValue; + } while (0); + + return value; + } + case Events::RunningStateChange::Id: { + Events::RunningStateChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterRunningStateChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedShort:cppValue.previousRunningState.Raw()]; + value.previousRunningState = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedShort:cppValue.currentRunningState.Raw()]; + value.currentRunningState = memberValue; + } while (0); + + return value; + } + case Events::RunningModeChange::Id: { + Events::RunningModeChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterRunningModeChangeEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.previousRunningMode)]; + value.previousRunningMode = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedChar:chip::to_underlying(cppValue.currentRunningMode)]; + value.currentRunningMode = memberValue; + } while (0); + + return value; + } + case Events::ActiveScheduleChange::Id: { + Events::ActiveScheduleChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterActiveScheduleChangeEvent new]; + + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.previousScheduleHandle); + value.previousScheduleHandle = memberValue; + } while (0); + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.currentScheduleHandle); + value.currentScheduleHandle = memberValue; + } while (0); + + return value; + } + case Events::ActivePresetChange::Id: { + Events::ActivePresetChange::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRThermostatClusterActivePresetChangeEvent new]; + + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.previousPresetHandle); + value.previousPresetHandle = memberValue; + } while (0); + do { + NSData * _Nonnull memberValue; + memberValue = AsData(cppValue.currentPresetHandle); + value.currentPresetHandle = memberValue; + } while (0); + + return value; + } default: { break; } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index f6e17d8bb4cfae..e06dd26652ecf6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -1766,6 +1766,55 @@ MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", @property (nonatomic, copy) NSNumber * _Nullable coolSetpoint MTR_DEPRECATED("Please use MTRThermostatClusterWeeklyScheduleTransitionStruct", ios(16.1, 17.4), macos(13.0, 14.4), watchos(9.1, 10.4), tvos(16.1, 17.4)); @end +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterSystemModeChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousSystemMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentSystemMode MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterLocalTemperatureChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull currentLocalTemperature MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterOccupancyChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousOccupancy MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentOccupancy MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterSetpointChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull systemMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull occupancy MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull previousSetpoint MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentSetpoint MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterRunningStateChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousRunningState MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentRunningState MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterRunningModeChangeEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull previousRunningMode MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull currentRunningMode MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterActiveScheduleChangeEvent : NSObject +@property (nonatomic, copy) NSData * _Nonnull previousScheduleHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nonnull currentScheduleHandle MTR_PROVISIONALLY_AVAILABLE; +@end + +MTR_PROVISIONALLY_AVAILABLE +@interface MTRThermostatClusterActivePresetChangeEvent : NSObject +@property (nonatomic, copy) NSData * _Nonnull previousPresetHandle MTR_PROVISIONALLY_AVAILABLE; +@property (nonatomic, copy) NSData * _Nonnull currentPresetHandle MTR_PROVISIONALLY_AVAILABLE; +@end + MTR_PROVISIONALLY_AVAILABLE @interface MTROccupancySensingClusterHoldTimeLimitsStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull holdTimeMin MTR_PROVISIONALLY_AVAILABLE; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index ddc22861202fc1..f738d3296a87ac 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -7486,6 +7486,249 @@ @implementation MTRThermostatClusterThermostatScheduleTransition : MTRThermostat @dynamic coolSetpoint; @end +@implementation MTRThermostatClusterSystemModeChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousSystemMode = @(0); + + _currentSystemMode = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterSystemModeChangeEvent alloc] init]; + + other.previousSystemMode = self.previousSystemMode; + other.currentSystemMode = self.currentSystemMode; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousSystemMode:%@; currentSystemMode:%@; >", NSStringFromClass([self class]), _previousSystemMode, _currentSystemMode]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterLocalTemperatureChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _currentLocalTemperature = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterLocalTemperatureChangeEvent alloc] init]; + + other.currentLocalTemperature = self.currentLocalTemperature; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: currentLocalTemperature:%@; >", NSStringFromClass([self class]), _currentLocalTemperature]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterOccupancyChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousOccupancy = @(0); + + _currentOccupancy = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterOccupancyChangeEvent alloc] init]; + + other.previousOccupancy = self.previousOccupancy; + other.currentOccupancy = self.currentOccupancy; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousOccupancy:%@; currentOccupancy:%@; >", NSStringFromClass([self class]), _previousOccupancy, _currentOccupancy]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterSetpointChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _systemMode = @(0); + + _occupancy = @(0); + + _previousSetpoint = @(0); + + _currentSetpoint = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterSetpointChangeEvent alloc] init]; + + other.systemMode = self.systemMode; + other.occupancy = self.occupancy; + other.previousSetpoint = self.previousSetpoint; + other.currentSetpoint = self.currentSetpoint; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: systemMode:%@; occupancy:%@; previousSetpoint:%@; currentSetpoint:%@; >", NSStringFromClass([self class]), _systemMode, _occupancy, _previousSetpoint, _currentSetpoint]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterRunningStateChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousRunningState = @(0); + + _currentRunningState = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterRunningStateChangeEvent alloc] init]; + + other.previousRunningState = self.previousRunningState; + other.currentRunningState = self.currentRunningState; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousRunningState:%@; currentRunningState:%@; >", NSStringFromClass([self class]), _previousRunningState, _currentRunningState]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterRunningModeChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousRunningMode = @(0); + + _currentRunningMode = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterRunningModeChangeEvent alloc] init]; + + other.previousRunningMode = self.previousRunningMode; + other.currentRunningMode = self.currentRunningMode; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousRunningMode:%@; currentRunningMode:%@; >", NSStringFromClass([self class]), _previousRunningMode, _currentRunningMode]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterActiveScheduleChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousScheduleHandle = [NSData data]; + + _currentScheduleHandle = [NSData data]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterActiveScheduleChangeEvent alloc] init]; + + other.previousScheduleHandle = self.previousScheduleHandle; + other.currentScheduleHandle = self.currentScheduleHandle; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousScheduleHandle:%@; currentScheduleHandle:%@; >", NSStringFromClass([self class]), [_previousScheduleHandle base64EncodedStringWithOptions:0], [_currentScheduleHandle base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +@end + +@implementation MTRThermostatClusterActivePresetChangeEvent +- (instancetype)init +{ + if (self = [super init]) { + + _previousPresetHandle = [NSData data]; + + _currentPresetHandle = [NSData data]; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRThermostatClusterActivePresetChangeEvent alloc] init]; + + other.previousPresetHandle = self.previousPresetHandle; + other.currentPresetHandle = self.currentPresetHandle; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: previousPresetHandle:%@; currentPresetHandle:%@; >", NSStringFromClass([self class]), [_previousPresetHandle base64EncodedStringWithOptions:0], [_currentPresetHandle base64EncodedStringWithOptions:0]]; + return descriptionString; +} + +@end + @implementation MTROccupancySensingClusterHoldTimeLimitsStruct - (instancetype)init { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index aae67302e404a0..1b4ee8270fcaf3 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -4292,6 +4292,7 @@ enum class Feature : uint32_t kLocalTemperatureNotExposed = 0x40, kMatterScheduleConfiguration = 0x80, kPresets = 0x100, + kEvents = 0x200, }; // Bitmap for HVACSystemTypeBitmap diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 4879ae5213c65d..29e590705efad0 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -21903,7 +21903,333 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre } } // namespace Attributes -namespace Events {} // namespace Events +namespace Events { +namespace SystemModeChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousSystemMode), previousSystemMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentSystemMode), currentSystemMode)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousSystemMode)) + { + err = DataModel::Decode(reader, previousSystemMode); + } + else if (__context_tag == to_underlying(Fields::kCurrentSystemMode)) + { + err = DataModel::Decode(reader, currentSystemMode); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SystemModeChange. +namespace LocalTemperatureChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentLocalTemperature), currentLocalTemperature)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kCurrentLocalTemperature)) + { + err = DataModel::Decode(reader, currentLocalTemperature); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace LocalTemperatureChange. +namespace OccupancyChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousOccupancy), previousOccupancy)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentOccupancy), currentOccupancy)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousOccupancy)) + { + err = DataModel::Decode(reader, previousOccupancy); + } + else if (__context_tag == to_underlying(Fields::kCurrentOccupancy)) + { + err = DataModel::Decode(reader, currentOccupancy); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace OccupancyChange. +namespace SetpointChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kSystemMode), systemMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kOccupancy), occupancy)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousSetpoint), previousSetpoint)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentSetpoint), currentSetpoint)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kSystemMode)) + { + err = DataModel::Decode(reader, systemMode); + } + else if (__context_tag == to_underlying(Fields::kOccupancy)) + { + err = DataModel::Decode(reader, occupancy); + } + else if (__context_tag == to_underlying(Fields::kPreviousSetpoint)) + { + err = DataModel::Decode(reader, previousSetpoint); + } + else if (__context_tag == to_underlying(Fields::kCurrentSetpoint)) + { + err = DataModel::Decode(reader, currentSetpoint); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace SetpointChange. +namespace RunningStateChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousRunningState), previousRunningState)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentRunningState), currentRunningState)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousRunningState)) + { + err = DataModel::Decode(reader, previousRunningState); + } + else if (__context_tag == to_underlying(Fields::kCurrentRunningState)) + { + err = DataModel::Decode(reader, currentRunningState); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace RunningStateChange. +namespace RunningModeChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousRunningMode), previousRunningMode)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentRunningMode), currentRunningMode)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousRunningMode)) + { + err = DataModel::Decode(reader, previousRunningMode); + } + else if (__context_tag == to_underlying(Fields::kCurrentRunningMode)) + { + err = DataModel::Decode(reader, currentRunningMode); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace RunningModeChange. +namespace ActiveScheduleChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousScheduleHandle), previousScheduleHandle)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentScheduleHandle), currentScheduleHandle)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousScheduleHandle)) + { + err = DataModel::Decode(reader, previousScheduleHandle); + } + else if (__context_tag == to_underlying(Fields::kCurrentScheduleHandle)) + { + err = DataModel::Decode(reader, currentScheduleHandle); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ActiveScheduleChange. +namespace ActivePresetChange { +CHIP_ERROR Type::Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(aWriter.StartContainer(aTag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kPreviousPresetHandle), previousPresetHandle)); + ReturnErrorOnFailure(DataModel::Encode(aWriter, TLV::ContextTag(Fields::kCurrentPresetHandle), currentPresetHandle)); + return aWriter.EndContainer(outer); +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + detail::StructDecodeIterator __iterator(reader); + while (true) + { + auto __element = __iterator.Next(); + if (std::holds_alternative(__element)) + { + return std::get(__element); + } + + CHIP_ERROR err = CHIP_NO_ERROR; + const uint8_t __context_tag = std::get(__element); + + if (__context_tag == to_underlying(Fields::kPreviousPresetHandle)) + { + err = DataModel::Decode(reader, previousPresetHandle); + } + else if (__context_tag == to_underlying(Fields::kCurrentPresetHandle)) + { + err = DataModel::Decode(reader, currentPresetHandle); + } + else + { + } + + ReturnErrorOnFailure(err); + } +} +} // namespace ActivePresetChange. +} // namespace Events } // namespace Thermostat namespace FanControl { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 2357a87dd9d9fa..543efdb2568a7b 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -30007,6 +30007,299 @@ struct TypeInfo }; }; } // namespace Attributes +namespace Events { +namespace SystemModeChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousSystemMode = 0, + kCurrentSystemMode = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SystemModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + SystemModeEnum previousSystemMode = static_cast(0); + SystemModeEnum currentSystemMode = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SystemModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + SystemModeEnum previousSystemMode = static_cast(0); + SystemModeEnum currentSystemMode = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace SystemModeChange +namespace LocalTemperatureChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kCurrentLocalTemperature = 0, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::LocalTemperatureChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + int16_t currentLocalTemperature = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::LocalTemperatureChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + int16_t currentLocalTemperature = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace LocalTemperatureChange +namespace OccupancyChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousOccupancy = 0, + kCurrentOccupancy = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::OccupancyChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask previousOccupancy = static_cast>(0); + chip::BitMask currentOccupancy = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::OccupancyChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::BitMask previousOccupancy = static_cast>(0); + chip::BitMask currentOccupancy = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace OccupancyChange +namespace SetpointChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kSystemMode = 0, + kOccupancy = 1, + kPreviousSetpoint = 2, + kCurrentSetpoint = 3, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SetpointChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + SystemModeEnum systemMode = static_cast(0); + chip::BitMask occupancy = static_cast>(0); + int16_t previousSetpoint = static_cast(0); + int16_t currentSetpoint = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::SetpointChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + SystemModeEnum systemMode = static_cast(0); + chip::BitMask occupancy = static_cast>(0); + int16_t previousSetpoint = static_cast(0); + int16_t currentSetpoint = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace SetpointChange +namespace RunningStateChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousRunningState = 0, + kCurrentRunningState = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningStateChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask previousRunningState = static_cast>(0); + chip::BitMask currentRunningState = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningStateChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::BitMask previousRunningState = static_cast>(0); + chip::BitMask currentRunningState = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace RunningStateChange +namespace RunningModeChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousRunningMode = 0, + kCurrentRunningMode = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + ThermostatRunningModeEnum previousRunningMode = static_cast(0); + ThermostatRunningModeEnum currentRunningMode = static_cast(0); + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::RunningModeChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + ThermostatRunningModeEnum previousRunningMode = static_cast(0); + ThermostatRunningModeEnum currentRunningMode = static_cast(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace RunningModeChange +namespace ActiveScheduleChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousScheduleHandle = 0, + kCurrentScheduleHandle = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActiveScheduleChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::ByteSpan previousScheduleHandle; + chip::ByteSpan currentScheduleHandle; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActiveScheduleChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::ByteSpan previousScheduleHandle; + chip::ByteSpan currentScheduleHandle; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ActiveScheduleChange +namespace ActivePresetChange { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kPreviousPresetHandle = 0, + kCurrentPresetHandle = 1, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActivePresetChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::ByteSpan previousPresetHandle; + chip::ByteSpan currentPresetHandle; + + CHIP_ERROR Encode(TLV::TLVWriter & aWriter, TLV::Tag aTag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::ActivePresetChange::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::Thermostat::Id; } + + chip::ByteSpan previousPresetHandle; + chip::ByteSpan currentPresetHandle; + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace ActivePresetChange +} // namespace Events } // namespace Thermostat namespace FanControl { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h index 818b5504b29e30..840d21897e57d5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h @@ -633,6 +633,44 @@ static constexpr EventId Id = 0x00000010; } // namespace Events } // namespace PumpConfigurationAndControl +namespace Thermostat { +namespace Events { + +namespace SystemModeChange { +static constexpr EventId Id = 0x00000000; +} // namespace SystemModeChange + +namespace LocalTemperatureChange { +static constexpr EventId Id = 0x00000001; +} // namespace LocalTemperatureChange + +namespace OccupancyChange { +static constexpr EventId Id = 0x00000002; +} // namespace OccupancyChange + +namespace SetpointChange { +static constexpr EventId Id = 0x00000003; +} // namespace SetpointChange + +namespace RunningStateChange { +static constexpr EventId Id = 0x00000004; +} // namespace RunningStateChange + +namespace RunningModeChange { +static constexpr EventId Id = 0x00000005; +} // namespace RunningModeChange + +namespace ActiveScheduleChange { +static constexpr EventId Id = 0x00000006; +} // namespace ActiveScheduleChange + +namespace ActivePresetChange { +static constexpr EventId Id = 0x00000007; +} // namespace ActivePresetChange + +} // namespace Events +} // namespace Thermostat + namespace OccupancySensing { namespace Events { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index b0c00980d3e42d..8039170e49bf02 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -9364,6 +9364,14 @@ class ServiceAreaSkipArea : public ClusterCommand | * ClusterRevision | 0xFFFD | |------------------------------------------------------------------------------| | Events: | | +| * SystemModeChange | 0x0000 | +| * LocalTemperatureChange | 0x0001 | +| * OccupancyChange | 0x0002 | +| * SetpointChange | 0x0003 | +| * RunningStateChange | 0x0004 | +| * RunningModeChange | 0x0005 | +| * ActiveScheduleChange | 0x0006 | +| * ActivePresetChange | 0x0007 | \*----------------------------------------------------------------------------*/ /* @@ -23420,8 +23428,24 @@ void registerClusterThermostat(Commands & commands, CredentialIssuerCommands * c // // Events // - make_unique(Id, credsIssuerConfig), // - make_unique(Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "system-mode-change", Events::SystemModeChange::Id, credsIssuerConfig), // + make_unique(Id, "local-temperature-change", Events::LocalTemperatureChange::Id, credsIssuerConfig), // + make_unique(Id, "occupancy-change", Events::OccupancyChange::Id, credsIssuerConfig), // + make_unique(Id, "setpoint-change", Events::SetpointChange::Id, credsIssuerConfig), // + make_unique(Id, "running-state-change", Events::RunningStateChange::Id, credsIssuerConfig), // + make_unique(Id, "running-mode-change", Events::RunningModeChange::Id, credsIssuerConfig), // + make_unique(Id, "active-schedule-change", Events::ActiveScheduleChange::Id, credsIssuerConfig), // + make_unique(Id, "active-preset-change", Events::ActivePresetChange::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "system-mode-change", Events::SystemModeChange::Id, credsIssuerConfig), // + make_unique(Id, "local-temperature-change", Events::LocalTemperatureChange::Id, credsIssuerConfig), // + make_unique(Id, "occupancy-change", Events::OccupancyChange::Id, credsIssuerConfig), // + make_unique(Id, "setpoint-change", Events::SetpointChange::Id, credsIssuerConfig), // + make_unique(Id, "running-state-change", Events::RunningStateChange::Id, credsIssuerConfig), // + make_unique(Id, "running-mode-change", Events::RunningModeChange::Id, credsIssuerConfig), // + make_unique(Id, "active-schedule-change", Events::ActiveScheduleChange::Id, credsIssuerConfig), // + make_unique(Id, "active-preset-change", Events::ActivePresetChange::Id, credsIssuerConfig), // }; commands.RegisterCluster(clusterName, clusterCommands); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index 9e44b001a17247..c7d68827b08a3d 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -8524,6 +8524,206 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::SystemModeChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousSystemMode", indent + 1, value.previousSystemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousSystemMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentSystemMode", indent + 1, value.currentSystemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentSystemMode'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::LocalTemperatureChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentLocalTemperature", indent + 1, value.currentLocalTemperature); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentLocalTemperature'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::OccupancyChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousOccupancy", indent + 1, value.previousOccupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousOccupancy'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentOccupancy", indent + 1, value.currentOccupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentOccupancy'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::SetpointChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("SystemMode", indent + 1, value.systemMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'SystemMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("Occupancy", indent + 1, value.occupancy); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Occupancy'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousSetpoint", indent + 1, value.previousSetpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousSetpoint'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentSetpoint", indent + 1, value.currentSetpoint); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentSetpoint'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::RunningStateChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousRunningState", indent + 1, value.previousRunningState); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousRunningState'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentRunningState", indent + 1, value.currentRunningState); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentRunningState'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::RunningModeChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousRunningMode", indent + 1, value.previousRunningMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousRunningMode'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentRunningMode", indent + 1, value.currentRunningMode); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentRunningMode'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::ActiveScheduleChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousScheduleHandle", indent + 1, value.previousScheduleHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousScheduleHandle'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentScheduleHandle", indent + 1, value.currentScheduleHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentScheduleHandle'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const Thermostat::Events::ActivePresetChange::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("PreviousPresetHandle", indent + 1, value.previousPresetHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'PreviousPresetHandle'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("CurrentPresetHandle", indent + 1, value.currentPresetHandle); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'CurrentPresetHandle'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const OccupancySensing::Events::OccupancyChanged::DecodableType & value) { @@ -21001,6 +21201,52 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip } break; } + case Thermostat::Id: { + switch (header.mPath.mEventId) + { + case Thermostat::Events::SystemModeChange::Id: { + chip::app::Clusters::Thermostat::Events::SystemModeChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SystemModeChange", 1, value); + } + case Thermostat::Events::LocalTemperatureChange::Id: { + chip::app::Clusters::Thermostat::Events::LocalTemperatureChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("LocalTemperatureChange", 1, value); + } + case Thermostat::Events::OccupancyChange::Id: { + chip::app::Clusters::Thermostat::Events::OccupancyChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("OccupancyChange", 1, value); + } + case Thermostat::Events::SetpointChange::Id: { + chip::app::Clusters::Thermostat::Events::SetpointChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("SetpointChange", 1, value); + } + case Thermostat::Events::RunningStateChange::Id: { + chip::app::Clusters::Thermostat::Events::RunningStateChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("RunningStateChange", 1, value); + } + case Thermostat::Events::RunningModeChange::Id: { + chip::app::Clusters::Thermostat::Events::RunningModeChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("RunningModeChange", 1, value); + } + case Thermostat::Events::ActiveScheduleChange::Id: { + chip::app::Clusters::Thermostat::Events::ActiveScheduleChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ActiveScheduleChange", 1, value); + } + case Thermostat::Events::ActivePresetChange::Id: { + chip::app::Clusters::Thermostat::Events::ActivePresetChange::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ActivePresetChange", 1, value); + } + } + break; + } case OccupancySensing::Id: { switch (header.mPath.mEventId) { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h index dd53dfabc6a6eb..aabc56b1b8f175 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -716,6 +716,22 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::PumpConfigurationAndControl::Events::AirDetection::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::PumpConfigurationAndControl::Events::TurbineOperation::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::SystemModeChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::LocalTemperatureChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::OccupancyChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::SetpointChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::RunningStateChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::RunningModeChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::ActiveScheduleChange::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::Thermostat::Events::ActivePresetChange::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::OccupancySensing::Events::OccupancyChanged::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index 5f6e87c76b7b03..c02c345edc7a6c 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -94900,6 +94900,14 @@ class SubscribeAttributePumpConfigurationAndControlClusterRevision : public Subs | * ClusterRevision | 0xFFFD | |------------------------------------------------------------------------------| | Events: | | +| * SystemModeChange | 0x0000 | +| * LocalTemperatureChange | 0x0001 | +| * OccupancyChange | 0x0002 | +| * SetpointChange | 0x0003 | +| * RunningStateChange | 0x0004 | +| * RunningModeChange | 0x0005 | +| * ActiveScheduleChange | 0x0006 | +| * ActivePresetChange | 0x0007 | \*----------------------------------------------------------------------------*/ /* @@ -177168,6 +177176,8 @@ void registerClusterThermostat(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(Id), // + make_unique(Id), // }; commands.RegisterCluster(clusterName, clusterCommands);