Skip to content

Commit 519df4d

Browse files
dhrishidhrishi
committed
Merge branch 'device/microwave-oven' into 'main'
[Delegate] Add microwave oven device type See merge request app-frameworks/esp-matter!737
2 parents f28cc57 + 9f72937 commit 519df4d

16 files changed

+452
-2
lines changed

‎SUPPORTED_DEVICE_TYPES.md

+1
Original file line numberDiff line numberDiff line change
@@ -70,3 +70,4 @@ i. Appliance
7070
7. Cook Surface
7171
8. Cooktop
7272
9. Energy Evse
73+
10. Microwave Oven

‎components/esp_matter/esp_matter_attribute.cpp

+50
Original file line numberDiff line numberDiff line change
@@ -4565,5 +4565,55 @@ attribute_t *create_session_energy_discharged(cluster_t *cluster, nullable<int64
45654565
} /* attribute */
45664566
} /* energy_evse */
45674567

4568+
namespace microwave_oven_control {
4569+
namespace attribute {
4570+
attribute_t *create_cook_time(cluster_t *cluster, uint32_t value)
4571+
{
4572+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::CookTime::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint32(value));
4573+
}
4574+
4575+
attribute_t *create_max_cook_time(cluster_t *cluster, uint32_t value)
4576+
{
4577+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::MaxCookTime::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint32(value));
4578+
}
4579+
4580+
attribute_t *create_power_setting(cluster_t *cluster, uint8_t value)
4581+
{
4582+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::PowerSetting::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint8(value));
4583+
}
4584+
4585+
attribute_t *create_min_power(cluster_t *cluster, uint8_t value)
4586+
{
4587+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::MinPower::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint8(value));
4588+
}
4589+
4590+
attribute_t *create_max_power(cluster_t *cluster, uint8_t value)
4591+
{
4592+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::MaxPower::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint8(value));
4593+
}
4594+
4595+
attribute_t *create_power_step(cluster_t *cluster, uint8_t value)
4596+
{
4597+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::PowerStep::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint8(value));
4598+
}
4599+
4600+
attribute_t *create_supported_watts(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count)
4601+
{
4602+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::SupportedWatts::Id, ATTRIBUTE_FLAG_NONE, esp_matter_array(value, length, count));
4603+
}
4604+
4605+
attribute_t *create_selected_watt_index(cluster_t *cluster, uint8_t value)
4606+
{
4607+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::SelectedWattIndex::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint8(value));
4608+
}
4609+
4610+
attribute_t *create_watt_rating(cluster_t *cluster, uint16_t value)
4611+
{
4612+
return esp_matter::attribute::create(cluster, MicrowaveOvenControl::Attributes::WattRating::Id, ATTRIBUTE_FLAG_NONE, esp_matter_uint16(value));
4613+
}
4614+
4615+
} /* attribute */
4616+
} /* microwave_oven_control */
4617+
45684618
} /* cluster */
45694619
} /* esp_matter */

‎components/esp_matter/esp_matter_attribute.h

+14
Original file line numberDiff line numberDiff line change
@@ -1040,5 +1040,19 @@ attribute_t *create_session_energy_discharged(cluster_t *cluster, nullable<int64
10401040
} /* attribute */
10411041
} /* energy_evse */
10421042

1043+
namespace microwave_oven_control {
1044+
namespace attribute {
1045+
attribute_t *create_cook_time(cluster_t *cluster, uint32_t value);
1046+
attribute_t *create_max_cook_time(cluster_t *cluster, uint32_t value);
1047+
attribute_t *create_power_setting(cluster_t *cluster, uint8_t value);
1048+
attribute_t *create_min_power(cluster_t *cluster, uint8_t value);
1049+
attribute_t *create_max_power(cluster_t *cluster, uint8_t value);
1050+
attribute_t *create_power_step(cluster_t *cluster, uint8_t value);
1051+
attribute_t *create_supported_watts(cluster_t *cluster, uint8_t *value, uint16_t length, uint16_t count);
1052+
attribute_t *create_selected_watt_index(cluster_t *cluster, uint8_t value);
1053+
attribute_t *create_watt_rating(cluster_t *cluster, uint16_t value);
1054+
} /* attribute */
1055+
} /* microwave_oven_control */
1056+
10431057
} /* cluster */
10441058
} /* esp_matter */

‎components/esp_matter/esp_matter_cluster.cpp

+91
Original file line numberDiff line numberDiff line change
@@ -2202,6 +2202,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
22022202
}
22032203

22042204
if (flags & CLUSTER_FLAG_SERVER) {
2205+
if (config -> delegate != nullptr) {
2206+
static const auto delegate_init_cb = OperationalStateDelegateInitCB;
2207+
set_delegate_and_init_callback(cluster, delegate_init_cb, config->delegate);
2208+
}
22052209
add_function_list(cluster, function_list, function_flags);
22062210
}
22072211
if (flags & CLUSTER_FLAG_CLIENT) {
@@ -3440,6 +3444,93 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
34403444
}
34413445
} /* rvc_clean_mode */
34423446

3447+
namespace microwave_oven_mode {
3448+
const function_generic_t *function_list = NULL;
3449+
const int function_flags = CLUSTER_FLAG_NONE;
3450+
3451+
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags)
3452+
{
3453+
cluster_t *cluster = cluster::create(endpoint, MicrowaveOvenMode::Id, flags);
3454+
if (!cluster) {
3455+
ESP_LOGE(TAG, "Could not create cluster");
3456+
return NULL;
3457+
}
3458+
3459+
if (flags & CLUSTER_FLAG_SERVER) {
3460+
if (config -> delegate != nullptr) {
3461+
static const auto delegate_init_cb = MicrowaveOvenModeDelegateInitCB;
3462+
set_delegate_and_init_callback(cluster, delegate_init_cb, config->delegate);
3463+
}
3464+
add_function_list(cluster, function_list, function_flags);
3465+
3466+
/* Attributes managed internally */
3467+
global::attribute::create_feature_map(cluster, 0);
3468+
global::attribute::create_event_list(cluster, NULL, 0, 0);
3469+
mode_base::attribute::create_supported_modes(cluster, NULL, 0, 0);
3470+
3471+
/* Attributes not managed internally */
3472+
if (config) {
3473+
global::attribute::create_cluster_revision(cluster, config->cluster_revision);
3474+
mode_base::attribute::create_current_mode(cluster, config->current_mode);
3475+
} else {
3476+
ESP_LOGE(TAG, "Config is NULL. Cannot add some attributes.");
3477+
}
3478+
}
3479+
3480+
return cluster;
3481+
}
3482+
} /* microwave_oven_mode */
3483+
3484+
namespace microwave_oven_control {
3485+
const function_generic_t *function_list = NULL;
3486+
const int function_flags = CLUSTER_FLAG_NONE;
3487+
3488+
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features)
3489+
{
3490+
cluster_t *cluster = cluster::create(endpoint, MicrowaveOvenControl::Id, flags);
3491+
if (!cluster) {
3492+
ESP_LOGE(TAG, "Could not create cluster");
3493+
return NULL;
3494+
}
3495+
3496+
if (flags & CLUSTER_FLAG_SERVER) {
3497+
if (config -> delegate != nullptr) {
3498+
static const auto delegate_init_cb = MicrowaveOvenControlDelegateInitCB;
3499+
set_delegate_and_init_callback(cluster, delegate_init_cb, config->delegate);
3500+
}
3501+
add_function_list(cluster, function_list, function_flags);
3502+
3503+
/* Attributes managed internally */
3504+
global::attribute::create_feature_map(cluster, 0);
3505+
global::attribute::create_event_list(cluster, NULL, 0, 0);
3506+
microwave_oven_control::attribute::create_cook_time(cluster, 0);
3507+
microwave_oven_control::attribute::create_max_cook_time(cluster, 0);
3508+
3509+
/* Attributes not managed internally */
3510+
if (config) {
3511+
global::attribute::create_cluster_revision(cluster, config->cluster_revision);
3512+
} else {
3513+
ESP_LOGE(TAG, "Config is NULL. Cannot add some attributes.");
3514+
}
3515+
}
3516+
3517+
/* Commands */
3518+
command::create_set_cooking_parameters(cluster);
3519+
3520+
if (features & feature::power_as_number::get_id()) {
3521+
feature::power_as_number::add(cluster);
3522+
}
3523+
if (features & feature::power_in_watts::get_id()) {
3524+
feature::power_in_watts::add(cluster);
3525+
}
3526+
if (features & feature::power_number_limits::get_id()) {
3527+
feature::power_number_limits::add(cluster);
3528+
}
3529+
3530+
return cluster;
3531+
}
3532+
} /* microwave_oven_control */
3533+
34433534
namespace rvc_operational_state {
34443535
const function_generic_t *function_list = NULL;
34453536
const int function_flags = CLUSTER_FLAG_NONE;

‎components/esp_matter/esp_matter_cluster.h

+23-1
Original file line numberDiff line numberDiff line change
@@ -535,7 +535,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
535535
namespace operational_state {
536536
typedef struct config {
537537
uint16_t cluster_revision;
538-
config() : cluster_revision(1) {}
538+
void *delegate;
539+
config() : cluster_revision(1), delegate(nullptr) {}
539540
} config_t;
540541

541542
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
@@ -841,6 +842,27 @@ typedef struct config {
841842
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
842843
} /* rvc_clean_mode */
843844

845+
namespace microwave_oven_mode {
846+
typedef struct config {
847+
uint16_t cluster_revision;
848+
uint8_t current_mode;
849+
void *delegate;
850+
config() : cluster_revision(1), current_mode(0), delegate(nullptr) {}
851+
} config_t;
852+
853+
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags);
854+
} /* microwave_oven_mode */
855+
856+
namespace microwave_oven_control {
857+
typedef struct config {
858+
uint16_t cluster_revision;
859+
void *delegate;
860+
config() : cluster_revision(1), delegate(nullptr) {}
861+
} config_t;
862+
863+
cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags, uint32_t features);
864+
} /* microwave_oven_control */
865+
844866
namespace rvc_operational_state {
845867
typedef struct config {
846868
uint16_t cluster_revision;

‎components/esp_matter/esp_matter_command.cpp

+15
Original file line numberDiff line numberDiff line change
@@ -2764,6 +2764,21 @@ command_t *create_get_targets_response(cluster_t *cluster)
27642764
} /* command */
27652765
} /* energy_evse */
27662766

2767+
namespace microwave_oven_control {
2768+
namespace command {
2769+
command_t *create_set_cooking_parameters(cluster_t *cluster)
2770+
{
2771+
return esp_matter::command::create(cluster, MicrowaveOvenControl::Commands::SetCookingParameters::Id, COMMAND_FLAG_ACCEPTED, NULL);
2772+
}
2773+
2774+
command_t *create_add_more_time(cluster_t *cluster)
2775+
{
2776+
return esp_matter::command::create(cluster, MicrowaveOvenControl::Commands::AddMoreTime::Id, COMMAND_FLAG_ACCEPTED, NULL);
2777+
}
2778+
2779+
} /* command */
2780+
} /* microwave_oven_control */
2781+
27672782
} /* cluster */
27682783
} /* esp_matter */
27692784

‎components/esp_matter/esp_matter_command.h

+7
Original file line numberDiff line numberDiff line change
@@ -390,5 +390,12 @@ command_t *create_get_targets_response(cluster_t *cluster);
390390
} /* command */
391391
} /* energy_evse */
392392

393+
namespace microwave_oven_control {
394+
namespace command {
395+
command_t *create_set_cooking_parameters(cluster_t *cluster);
396+
command_t *create_add_more_time(cluster_t *cluster);
397+
} /* command */
398+
} /* microwave_oven_control */
399+
393400
} /* cluster */
394401
} /* esp_matter */

‎components/esp_matter/esp_matter_delegate_callbacks.cpp

+48
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@
1818
#include <esp_matter_core.h>
1919
#include <app/clusters/mode-base-server/mode-base-server.h>
2020
#include <app/clusters/energy-evse-server/energy-evse-server.h>
21+
#include <app/clusters/microwave-oven-control-server/microwave-oven-control-server.h>
22+
#include <app/clusters/operational-state-server/operational-state-server.h>
2123

2224
using namespace chip::app::Clusters;
2325
namespace esp_matter {
@@ -81,6 +83,11 @@ void EnergyEvseModeDelegateInitCB(void *delegate, uint16_t endpoint_id)
8183
InitModeDelegate(delegate, endpoint_id, EnergyEvseMode::Id);
8284
}
8385

86+
void MicrowaveOvenModeDelegateInitCB(void *delegate, uint16_t endpoint_id)
87+
{
88+
InitModeDelegate(delegate, endpoint_id, MicrowaveOvenMode::Id);
89+
}
90+
8491
void EnergyEvseDelegateInitCB(void *delegate, uint16_t endpoint_id)
8592
{
8693
if(delegate == nullptr)
@@ -95,6 +102,47 @@ void EnergyEvseDelegateInitCB(void *delegate, uint16_t endpoint_id)
95102
energyEvseInstance->Init();
96103
}
97104

105+
void MicrowaveOvenControlDelegateInitCB(void *delegate, uint16_t endpoint_id)
106+
{
107+
// Get delegates of MicrowaveOvenMode and OperationalState clusters.
108+
node_t *node = node::get();
109+
endpoint_t *endpoint = endpoint::get(node, endpoint_id);
110+
cluster_t *cluster = cluster::get(endpoint, MicrowaveOvenMode::Id);
111+
ModeBase::Delegate *microwave_oven_mode_delegate = static_cast<ModeBase::Delegate*>(get_delegate_impl(cluster));
112+
cluster = cluster::get(endpoint, OperationalState::Id);
113+
OperationalState::Delegate *operational_state_delegate = static_cast<OperationalState::Delegate*>(get_delegate_impl(cluster));
114+
if(delegate == nullptr || microwave_oven_mode_delegate == nullptr || operational_state_delegate == nullptr)
115+
{
116+
return;
117+
}
118+
// Create instances of clusters.
119+
static ModeBase::Instance * microwaveOvenModeInstance = nullptr;
120+
static OperationalState::Instance * operationalStateInstance = nullptr;
121+
static MicrowaveOvenControl::Instance * microwaveOvenControlInstance = nullptr;
122+
MicrowaveOvenControl::Delegate *microwave_oven_control_delegate = static_cast<MicrowaveOvenControl::Delegate*>(delegate);
123+
uint32_t feature_map = get_feature_map_value(endpoint_id, MicrowaveOvenMode::Id);
124+
125+
microwaveOvenModeInstance = new ModeBase::Instance(microwave_oven_mode_delegate, endpoint_id, MicrowaveOvenMode::Id, feature_map);
126+
operationalStateInstance = new OperationalState::Instance(operational_state_delegate, endpoint_id);
127+
128+
feature_map = get_feature_map_value(endpoint_id, MicrowaveOvenControl::Id);
129+
microwaveOvenControlInstance = new MicrowaveOvenControl::Instance(microwave_oven_control_delegate, endpoint_id, MicrowaveOvenControl::Id, feature_map,
130+
*operationalStateInstance, *microwaveOvenModeInstance);
131+
microwaveOvenControlInstance->Init();
132+
}
133+
134+
void OperationalStateDelegateInitCB(void *delegate, uint16_t endpoint_id)
135+
{
136+
if(delegate == nullptr)
137+
{
138+
return;
139+
}
140+
static OperationalState::Instance * operationalStateInstance = nullptr;
141+
OperationalState::Delegate *operational_state_delegate = static_cast<OperationalState::Delegate*>(delegate);
142+
operationalStateInstance = new OperationalState::Instance(operational_state_delegate, endpoint_id);
143+
operationalStateInstance->Init();
144+
}
145+
98146
} // namespace delegate_cb
99147

100148
} // namespace cluster

‎components/esp_matter/esp_matter_delegate_callbacks.h

+3
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,9 @@ void RvcRunModeDelegateInitCB(void *delegate, uint16_t endpoint_id);
2424
void RvcCleanModeDelegateInitCB(void *delegate, uint16_t endpoint_id);
2525
void EnergyEvseModeDelegateInitCB(void *delegate, uint16_t endpoint_id);
2626
void EnergyEvseDelegateInitCB(void *delegate, uint16_t endpoint_id);
27+
void MicrowaveOvenModeDelegateInitCB(void *delegate, uint16_t endpoint_id);
28+
void MicrowaveOvenControlDelegateInitCB(void *delegate, uint16_t endpoint_id);
29+
void OperationalStateDelegateInitCB(void *delegate, uint16_t endpoint_id);
2730
} // namespace delegate_cb
2831

2932
} // namespace cluster

‎components/esp_matter/esp_matter_endpoint.cpp

+40
Original file line numberDiff line numberDiff line change
@@ -1791,6 +1791,46 @@ esp_err_t add(endpoint_t *endpoint, config_t *config)
17911791
}
17921792
} /* energy_evse */
17931793

1794+
namespace microwave_oven {
1795+
uint32_t get_device_type_id()
1796+
{
1797+
return ESP_MATTER_MICROWAVE_OVEN_DEVICE_TYPE_ID;
1798+
}
1799+
1800+
uint8_t get_device_type_version()
1801+
{
1802+
return ESP_MATTER_MICROWAVE_OVEN_DEVICE_TYPE_VERSION;
1803+
}
1804+
1805+
endpoint_t *create(node_t *node, config_t *config, uint8_t flags, void *priv_data)
1806+
{
1807+
endpoint_t *endpoint = endpoint::create(node, flags, priv_data);
1808+
add(endpoint, config);
1809+
return endpoint;
1810+
}
1811+
1812+
esp_err_t add(endpoint_t *endpoint, config_t *config)
1813+
{
1814+
if (!endpoint) {
1815+
ESP_LOGE(TAG, "Endpoint cannot be NULL");
1816+
return ESP_ERR_INVALID_ARG;
1817+
}
1818+
esp_err_t err = add_device_type(endpoint, get_device_type_id(), get_device_type_version());
1819+
if (err != ESP_OK) {
1820+
ESP_LOGE(TAG, "Failed to add device type id:%" PRIu32 ",err: %d", get_device_type_id(), err);
1821+
return err;
1822+
}
1823+
1824+
descriptor::create(endpoint, &(config->descriptor), CLUSTER_FLAG_SERVER);
1825+
cluster_t *cluster = operational_state::create(endpoint, &(config->operational_state), CLUSTER_FLAG_SERVER);
1826+
operational_state::attribute::create_countdown_time(cluster, 0);
1827+
microwave_oven_mode::create(endpoint, &(config->microwave_oven_mode), CLUSTER_FLAG_SERVER);
1828+
microwave_oven_control::create(endpoint, &(config->microwave_oven_control), CLUSTER_FLAG_SERVER, ESP_MATTER_NONE_FEATURE_ID);
1829+
1830+
return ESP_OK;
1831+
}
1832+
} /* microwave_oven */
1833+
17941834
} /* endpoint */
17951835

17961836
namespace node {

0 commit comments

Comments
 (0)