From db0e64557642efc4d15b671d40abd914a99e67b2 Mon Sep 17 00:00:00 2001 From: WanqQixiang Date: Tue, 6 Jun 2023 12:17:05 +0800 Subject: [PATCH] esp_matter: fix event_list reading issue --- components/esp_matter/esp_matter_cluster.cpp | 22 + components/esp_matter/esp_matter_core.cpp | 170 +++++++ components/esp_matter/esp_matter_core.h | 63 +++ components/esp_matter/esp_matter_event.cpp | 501 ++++++++++++++++--- components/esp_matter/esp_matter_event.h | 135 ++++- 5 files changed, 813 insertions(+), 78 deletions(-) diff --git a/components/esp_matter/esp_matter_cluster.cpp b/components/esp_matter/esp_matter_cluster.cpp index fcb26e546..6f28621e5 100644 --- a/components/esp_matter/esp_matter_cluster.cpp +++ b/components/esp_matter/esp_matter_cluster.cpp @@ -122,6 +122,9 @@ cluster_t *create(endpoint_t *endpoint, uint8_t flags) attribute::create_endpoint_lists(cluster, NULL, 0, 0); } + event::create_action_failed(cluster); + event::create_state_changed(cluster); + return cluster; } } /* actions */ @@ -154,6 +157,9 @@ cluster_t *create(endpoint_t *endpoint, uint8_t flags) global::attribute::create_feature_map(cluster, 0); } + event::create_access_control_entry_changed(cluster); + event::create_access_control_extension_changed(cluster); + return cluster; } } /* access_control */ @@ -201,6 +207,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_start_up(cluster); + return cluster; } } /* basic_information */ @@ -315,6 +323,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_download_error(cluster); + event::create_state_transition(cluster); + event::create_version_applied(cluster); + /* Commands */ command::create_announce_ota_provider(cluster); @@ -452,6 +464,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_boot_reason(cluster); + command::create_test_event_trigger(cluster); return cluster; @@ -711,6 +725,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_time_failure(cluster); + return cluster; } } /* time_synchronization */ @@ -745,6 +761,8 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_reachable_changed(cluster); + return cluster; } } /* bridged_device_basic_information */ @@ -1263,6 +1281,10 @@ cluster_t *create(endpoint_t *endpoint, config_t *config, uint8_t flags) } } + event::create_door_lock_alarm(cluster); + event::create_lock_operation(cluster); + event::create_lock_operation_error(cluster); + /* Commands */ command::create_lock_door(cluster); command::create_unlock_door(cluster); diff --git a/components/esp_matter/esp_matter_core.cpp b/components/esp_matter/esp_matter_core.cpp index fb550dee7..2b5d0bf61 100644 --- a/components/esp_matter/esp_matter_core.cpp +++ b/components/esp_matter/esp_matter_core.cpp @@ -45,6 +45,7 @@ using chip::CommandId; using chip::DataVersion; +using chip::EventId; using chip::kInvalidAttributeId; using chip::kInvalidCommandId; using chip::kInvalidClusterId; @@ -157,6 +158,11 @@ typedef struct _command { struct _command *next; } _command_t; +typedef struct _event { + uint32_t event_id; + struct _event *next; +} _event_t; + typedef struct _cluster { uint32_t cluster_id; uint16_t endpoint_id; @@ -165,6 +171,7 @@ typedef struct _cluster { cluster::plugin_server_init_callback_t plugin_server_init_callback; _attribute_t *attribute_list; _command_t *command_list; + _event_t *event_list; struct _cluster *next; } _cluster_t; @@ -263,6 +270,18 @@ static int get_count(_command_t *current, int command_flag) } } /* command */ +namespace event { +static int get_count(_event_t *current) +{ + int count = 0; + while (current) { + count++; + current = current->next; + } + return count; +} +} + namespace attribute { extern esp_err_t get_data_from_attr_val(esp_matter_attr_val_t *val, EmberAfAttributeType *attribute_type, @@ -457,6 +476,10 @@ static esp_err_t disable(endpoint_t *endpoint) if (endpoint_type->cluster[cluster_index].generatedCommandList) { esp_matter_mem_free((void *)endpoint_type->cluster[cluster_index].generatedCommandList); } + /* Free events */ + if (endpoint_type->cluster[cluster_index].eventList) { + esp_matter_mem_free((void *)endpoint_type->cluster[cluster_index].eventList); + } } esp_matter_mem_free((void *)endpoint_type->cluster); @@ -547,6 +570,10 @@ esp_err_t enable(endpoint_t *endpoint) int command_count = 0; int command_index = 0; int command_flag = COMMAND_FLAG_NONE; + EventId *event_ids = NULL; + _event_t *event = NULL; + int event_count = 0; + int event_index = 0; int endpoint_index = 0; matter_clusters = (EmberAfCluster *)esp_matter_mem_calloc(1, cluster_count * sizeof(EmberAfCluster)); @@ -634,6 +661,25 @@ esp_err_t enable(endpoint_t *endpoint) generated_command_ids[command_index] = kInvalidCommandId; } + /* Event */ + event = cluster->event_list; + event_count = event::get_count(event); + if (event_count > 0) { + event_index = 0; + event_ids = (EventId *)esp_matter_mem_calloc(1, (event_count + 1) * sizeof(EventId)); + if (!event_ids) { + ESP_LOGE(TAG, "Couldn't allocate event_ids"); + err = ESP_ERR_NO_MEM; + break; + } + while (event) { + event_ids[event_index] = event->event_id; + event_index++; + event = event->next; + } + event_ids[event_index] = chip::kInvalidEventId; + } + /* Fill up the cluster */ matter_clusters[cluster_index].clusterId = cluster->cluster_id; matter_clusters[cluster_index].attributes = matter_attributes; @@ -642,6 +688,8 @@ esp_err_t enable(endpoint_t *endpoint) matter_clusters[cluster_index].functions = (EmberAfGenericClusterFunction *)cluster->function_list; matter_clusters[cluster_index].acceptedCommandList = accepted_command_ids; matter_clusters[cluster_index].generatedCommandList = generated_command_ids; + matter_clusters[cluster_index].eventList = event_ids; + matter_clusters[cluster_index].eventCount = event_count; /* Get next cluster */ endpoint_type->endpointSize += matter_clusters[cluster_index].clusterSize; @@ -652,6 +700,7 @@ esp_err_t enable(endpoint_t *endpoint) matter_attributes = NULL; accepted_command_ids = NULL; generated_command_ids = NULL; + event_ids = NULL; } if (err != ESP_OK) { goto cleanup; @@ -692,6 +741,9 @@ cleanup: if (accepted_command_ids) { esp_matter_mem_free(accepted_command_ids); } + if (event_ids) { + esp_matter_mem_free(event_ids); + } if (matter_attributes) { esp_matter_mem_free(matter_attributes); } @@ -708,6 +760,10 @@ cleanup: if (matter_clusters[cluster_index].generatedCommandList) { esp_matter_mem_free((void *)matter_clusters[cluster_index].generatedCommandList); } + /* Free events */ + if (matter_clusters[cluster_index].eventList) { + esp_matter_mem_free((void *)matter_clusters[cluster_index].eventList); + } } esp_matter_mem_free(matter_clusters); } @@ -1710,6 +1766,112 @@ uint16_t get_flags(command_t *command) } /* command */ +namespace event { + +event_t *create(cluster_t *cluster, uint32_t event_id) +{ + /* Find */ + if (!cluster) { + ESP_LOGE(TAG, "Cluster cannot be NULL"); + return NULL; + } + _cluster_t *current_cluster = (_cluster_t *)cluster; + event_t *existing_event = get(cluster, event_id); + if (existing_event) { + ESP_LOGW(TAG, "Event 0x%08" PRIX32 " on cluster 0x%08" PRIX32 " already exists. Not creating again.", event_id, + current_cluster->cluster_id); + return existing_event; + } + + /* Allocate */ + _event_t *event = (_event_t *)esp_matter_mem_calloc(1, sizeof(_event_t)); + if (!event) { + ESP_LOGE(TAG, "Couldn't allocate _event_t"); + return NULL; + } + + /* Set */ + event->event_id = event_id; + + /* Add */ + _event_t *previous_event = NULL; + _event_t *current_event = current_cluster->event_list; + while (current_event) { + previous_event = current_event; + current_event = current_event->next; + } + if (previous_event == NULL) { + current_cluster->event_list = event; + } else { + previous_event->next = event; + } + + return (event_t *)event; +} + +static esp_err_t destroy(event_t *event) +{ + if (!event) { + ESP_LOGE(TAG, "Event cannot be NULL"); + return ESP_ERR_INVALID_ARG; + } + _event_t *current_event = (_event_t *)event; + + /* Free */ + esp_matter_mem_free(current_event); + return ESP_OK; +} + +event_t *get(cluster_t *cluster, uint32_t event_id) +{ + if (!cluster) { + ESP_LOGE(TAG, "Cluster cannot be NULL"); + return NULL; + } + _cluster_t *current_cluster = (_cluster_t *)cluster; + _event_t *current_event = (_event_t *)current_cluster->event_list; + while (current_event) { + if (current_event->event_id == event_id) { + break; + } + current_event = current_event->next; + } + return (event_t *)current_event; +} + +event_t *get_first(cluster_t *cluster) +{ + if (!cluster) { + ESP_LOGE(TAG, "Cluster cannot be NULL"); + return NULL; + } + _cluster_t *current_cluster = (_cluster_t *)cluster; + return (event_t *)current_cluster->event_list; +} + +event_t *get_next(event_t *event) +{ + if (!event) { + ESP_LOGE(TAG, "Event cannot be NULL"); + return NULL; + } + _event_t *current_event = (_event_t *)event; + return (event_t *)current_event->next; +} + +uint32_t get_id(event_t *event) +{ + if (!event) { + ESP_LOGE(TAG, "Event cannot be NULL"); + return NULL; + } + _event_t *current_event = (_event_t *)event; + return current_event->event_id; +} + +} /* event */ + + namespace cluster { cluster_t *create(endpoint_t *endpoint, uint32_t cluster_id, uint8_t flags) @@ -1800,6 +1962,14 @@ static esp_err_t destroy(cluster_t *cluster) attribute = next_attribute; } + /* Parse and delete all events */ + _event_t *event = current_cluster->event_list; + while (event) { + _event_t *next_event = event->next; + event::destroy((event_t *)event); + event = next_event; + } + /* Free */ esp_matter_mem_free(current_cluster); return ESP_OK; diff --git a/components/esp_matter/esp_matter_core.h b/components/esp_matter/esp_matter_core.h index 2101c79e6..fd36a23a0 100644 --- a/components/esp_matter/esp_matter_core.h +++ b/components/esp_matter/esp_matter_core.h @@ -38,6 +38,8 @@ typedef handle_t cluster_t; typedef handle_t attribute_t; /** Command handle */ typedef handle_t command_t; +/** Event handle */ +typedef handle_t event_t; /** Event callback * @@ -709,6 +711,67 @@ uint16_t get_flags(command_t *command); } /* command */ +namespace event { + +/** Create event + * + * This will create a new event and add it to the cluster. + * + * @param[in] cluster Cluster handle. + * @param[in] event_id Event ID for the event. + * + * @return Event handle on success. + * @return NULL in case of failure. + */ +event_t *create(cluster_t *cluster, uint32_t event_id); + +/** Get event + * + * Get the event present on the cluster. + * + * @param[in] cluster Cluster handle. + * @param[in] event_id Event ID for the command. + * + * @return Event handle on success. + * @return NULL in case of failure. + */ +event_t *get(cluster_t *cluster, uint32_t event_id); + +/** Get first event + * + * Get the first event present on the cluster. + * + * @param[in] cluster Cluster handle. + * + * @return Event handle on success. + * @return NULL in case of failure. + */ +event_t *get_first(cluster_t *cluster); + +/** Get next event + * + * Get the next event present on the cluster. + * + * @param[in] event Event handle. + * + * @return Event handle on success. + * @return NULL in case of failure. + */ +event_t *get_next(event_t *event); + +/** Get event ID + * + * Get the event ID for the event. + * + * @param[in] event Event handle. + * + * @return Event ID on success. + * @return Invalid Event ID (0xFFFF'FFFF) in case of failure. + */ +uint32_t get_id(event_t *event); + +} /* event */ + /* Client APIs */ namespace client { diff --git a/components/esp_matter/esp_matter_event.cpp b/components/esp_matter/esp_matter_event.cpp index dcbc3144f..57566b071 100644 --- a/components/esp_matter/esp_matter_event.cpp +++ b/components/esp_matter/esp_matter_event.cpp @@ -18,17 +18,253 @@ #include #include - -using chip::DeviceLayer::DeviceControlServer; using chip::EndpointId; +using chip::DeviceLayer::DeviceControlServer; using namespace chip::app::Clusters; namespace esp_matter { namespace cluster { +namespace access_control { +namespace event { +event_t *create_access_control_entry_changed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, AccessControl::Events::AccessControlEntryChanged::Id); +} + +event_t *create_access_control_extension_changed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, AccessControl::Events::AccessControlExtensionChanged::Id); +} + +esp_err_t send_state_changed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state) +{ + /* Not implemented */ + return ESP_OK; +} + +esp_err_t send_action_failed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state, + uint8_t error) +{ + /* Not implemented */ + return ESP_OK; +} + +} // namespace event +} // namespace access_control + +namespace actions { +namespace event { +event_t *create_state_changed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Actions::Events::StateChanged::Id); +} + +event_t *create_action_failed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Actions::Events::ActionFailed::Id); +} + +} // namespace event +} // namespace actions + +namespace basic_information { +namespace event { +event_t *create_start_up(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BasicInformation::Events::StartUp::Id); +} + +event_t *create_shut_down(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BasicInformation::Events::ShutDown::Id); +} + +event_t *create_leave(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BasicInformation::Events::Leave::Id); +} + +event_t *create_reachable_changed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BasicInformation::Events::ReachableChanged::Id); +} + +} // namespace event +} // namespace basic_information + +namespace ota_requestor { +namespace event { +event_t *create_state_transition(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::StateTransition::Id); +} + +event_t *create_version_applied(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::VersionApplied::Id); +} + +event_t *create_download_error(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, OtaSoftwareUpdateRequestor::Events::DownloadError::Id); +} + +} // namespace event +} // namespace ota_requestor + +namespace general_diagnostics { +namespace event { +event_t *create_hardware_fault_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, GeneralDiagnostics::Events::HardwareFaultChange::Id); +} + +event_t *create_radio_fault_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, GeneralDiagnostics::Events::RadioFaultChange::Id); +} + +event_t *create_network_fault_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, GeneralDiagnostics::Events::NetworkFaultChange::Id); +} + +event_t *create_boot_reason(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, GeneralDiagnostics::Events::BootReason::Id); +} + +} // namespace event +} // namespace general_diagnostics + +namespace diagnostics_network_wifi { +namespace event { +event_t *create_disconnection(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::Disconnection::Id); +} + +event_t *create_association_failure(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::AssociationFailure::Id); +} + +event_t *create_connection_status(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, WiFiNetworkDiagnostics::Events::ConnectionStatus::Id); +} + +} // namespace event +} // namespace diagnostics_network_wifi + +namespace diagnostics_network_thread { +namespace event { +event_t *create_connection_status(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, ThreadNetworkDiagnostics::Events::ConnectionStatus::Id); +} + +event_t *create_network_fault_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, ThreadNetworkDiagnostics::Events::NetworkFaultChange::Id); +} + +} // namespace event +} // namespace diagnostics_network_thread + +namespace software_diagnostics { +namespace event { +event_t *create_software_fault(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, SoftwareDiagnostics::Events::SoftwareFault::Id); +} +} // namespace event +} // namespace software_diagnostics + +namespace time_synchronization { +namespace event { +event_t *create_dst_table_empty(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, TimeSynchronization::Events::DSTTableEmpty::Id); +} + +event_t *create_dst_status(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, TimeSynchronization::Events::DSTStatus::Id); +} + +event_t *create_time_zone_status(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, TimeSynchronization::Events::TimeZoneStatus::Id); +} + +event_t *create_time_failure(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, TimeSynchronization::Events::TimeFailure::Id); +} + +event_t *create_missing_trusted_time_source(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, TimeSynchronization::Events::MissingTrustedTimeSource::Id); +} + +} // namespace event +} // namespace time_synchronization + +namespace bridged_device_basic_information { +namespace event { + +event_t *create_start_up(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::StartUp::Id); +} + +event_t *create_shut_down(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::ShutDown::Id); +} + +event_t *create_leave(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::Leave::Id); +} + +event_t *create_reachable_changed(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BridgedDeviceBasicInformation::Events::ReachableChanged::Id); +} + +} // namespace event +} // namespace bridged_device_basic_information namespace door_lock { namespace event { +event_t *create_door_lock_alarm(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, DoorLock::Events::DoorLockAlarm::Id); +} + +event_t *create_door_state_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, DoorLock::Events::DoorStateChange::Id); +} + +event_t *create_lock_operation(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, DoorLock::Events::LockOperation::Id); +} + +event_t *create_lock_operation_error(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, DoorLock::Events::LockOperationError::Id); +} + +event_t *create_lock_user_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, DoorLock::Events::LockUserChange::Id); +} + esp_err_t send_door_lock_alarm() { /* Not implemented */ @@ -59,13 +295,195 @@ esp_err_t send_lock_user_change() return ESP_OK; } -} /* event */ -} /* door_lock */ +} // namespace event +} // namespace door_lock + +namespace switch_cluster { +namespace event { + +event_t *create_switch_latched(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::SwitchLatched::Id); +} + +event_t *create_initial_press(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::InitialPress::Id); +} + +event_t *create_long_press(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::LongPress::Id); +} + +event_t *create_short_release(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::ShortRelease::Id); +} + +event_t *create_long_release(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::LongRelease::Id); +} + +event_t *create_multi_press_ongoing(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::MultiPressOngoing::Id); +} + +event_t *create_multi_press_complete(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, Switch::Events::MultiPressComplete::Id); +} + +esp_err_t send_switch_latched(EndpointId endpoint, uint8_t new_position) +{ + SwitchServer::Instance().OnSwitchLatch(endpoint, new_position); + return ESP_OK; +} + +esp_err_t send_initial_press(EndpointId endpoint, uint8_t new_position) +{ + SwitchServer::Instance().OnInitialPress(endpoint, new_position); + return ESP_OK; +} + +esp_err_t send_long_press(EndpointId endpoint, uint8_t new_position) +{ + SwitchServer::Instance().OnLongPress(endpoint, new_position); + return ESP_OK; +} + +esp_err_t send_short_release(EndpointId endpoint, uint8_t previous_position) +{ + SwitchServer::Instance().OnShortRelease(endpoint, previous_position); + return ESP_OK; +} + +esp_err_t send_long_release(EndpointId endpoint, uint8_t previous_position) +{ + SwitchServer::Instance().OnLongRelease(endpoint, previous_position); + return ESP_OK; +} + +esp_err_t send_multi_press_ongoing(EndpointId endpoint, uint8_t new_position, uint8_t count) +{ + SwitchServer::Instance().OnMultiPressOngoing(endpoint, new_position, count); + return ESP_OK; +} + +esp_err_t send_multi_press_complete(EndpointId endpoint, uint8_t new_position, uint8_t count) +{ + SwitchServer::Instance().OnMultiPressComplete(endpoint, new_position, count); + return ESP_OK; +} + +} // namespace event +} // namespace switch_cluster + +namespace boolean_state { +namespace event { + +event_t *create_state_change(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, BooleanState::Events::StateChange::Id); +} + +} // namespace event +} // namespace boolean_state namespace pump_configuration_and_control { namespace event { -esp_err_t send_supply_voltage_low() +event_t *create_supply_voltage_low(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SupplyVoltageLow::Id); +} + +event_t *create_supply_voltage_high(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SupplyVoltageHigh::Id); +} + +event_t *create_power_missing_phase(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PowerMissingPhase::Id); +} + +event_t *create_system_pressure_low(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SystemPressureLow::Id); +} + +event_t *create_system_pressure_high(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SystemPressureHigh::Id); +} + +event_t *create_dry_running(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::DryRunning::Id); +} + +event_t *create_motor_temperature_high(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::MotorTemperatureHigh::Id); +} + +event_t *create_pump_motor_fatal_failure(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PumpMotorFatalFailure::Id); +} + +event_t *create_electronic_temperature_high(cluster_t *cluster) +{ + return + esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicTemperatureHigh::Id); +} + +event_t *create_pump_blocked(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::PumpBlocked::Id); +} + +event_t *create_sensor_failure(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::SensorFailure::Id); +} + +event_t *create_electronic_non_fatal_failure(cluster_t *cluster) +{ + return + esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicNonFatalFailure::Id); +} + +event_t *create_electronic_fatal_failure(cluster_t *cluster) +{ + return + esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::ElectronicFatalFailure::Id); +} + +event_t *create_general_fault(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::GeneralFault::Id); +} + +event_t *create_leakage(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::Leakage::Id); +} + +event_t *create_air_detection(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::AirDetection::Id); +} + +event_t *create_turbine_operation(cluster_t *cluster) +{ + return esp_matter::event::create(cluster, PumpConfigurationAndControl::Events::TurbineOperation::Id); +} + +esp_err_t *send_supply_voltage_low() { /* Not implemented */ return ESP_OK; @@ -167,73 +585,8 @@ esp_err_t send_turbine_operation() return ESP_OK; } -} /* event */ -} /* pump_configuration_and_control */ +} // namespace event +} // namespace pump_configuration_and_control -namespace actions { -namespace event { -esp_err_t send_state_changed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state) -{ - /* Not implemented */ - return ESP_OK; -} - -esp_err_t send_action_failed(EndpointId endpoint, uint16_t action_id, uint32_t invoke_id, uint8_t action_state, - uint8_t error) -{ - /* Not implemented */ - return ESP_OK; -} -} /* event */ -} /* actions */ - -namespace switch_cluster { -namespace event { - -esp_err_t send_switch_latched(EndpointId endpoint, uint8_t new_position) -{ - SwitchServer::Instance().OnSwitchLatch(endpoint, new_position); - return ESP_OK; -} - -esp_err_t send_initial_press(EndpointId endpoint, uint8_t new_position) -{ - SwitchServer::Instance().OnInitialPress(endpoint, new_position); - return ESP_OK; -} - -esp_err_t send_long_press(EndpointId endpoint, uint8_t new_position) -{ - SwitchServer::Instance().OnLongPress(endpoint, new_position); - return ESP_OK; -} - -esp_err_t send_short_release(EndpointId endpoint, uint8_t previous_position) -{ - SwitchServer::Instance().OnShortRelease(endpoint, previous_position); - return ESP_OK; -} - -esp_err_t send_long_release(EndpointId endpoint, uint8_t previous_position) -{ - SwitchServer::Instance().OnLongRelease(endpoint, previous_position); - return ESP_OK; -} - -esp_err_t send_multi_press_ongoing(EndpointId endpoint, uint8_t new_position, uint8_t count) -{ - SwitchServer::Instance().OnMultiPressOngoing(endpoint, new_position, count); - return ESP_OK; -} - -esp_err_t send_multi_press_complete(EndpointId endpoint, uint8_t new_position, uint8_t count) -{ - SwitchServer::Instance().OnMultiPressComplete(endpoint, new_position, count); - return ESP_OK; -} - -} /* event */ -} /* switch_cluster */ - -} /* cluster */ -} /* esp_matter */ +} // namespace cluster +} // namespace esp_matter diff --git a/components/esp_matter/esp_matter_event.h b/components/esp_matter/esp_matter_event.h index 0ba8851ad..463f27fb5 100644 --- a/components/esp_matter/esp_matter_event.h +++ b/components/esp_matter/esp_matter_event.h @@ -15,6 +15,7 @@ #pragma once #include +#include #include namespace esp_matter { @@ -25,8 +26,106 @@ namespace cluster { * If some standard event is not present here, it can be added. */ +namespace access_control { +namespace event { +event_t *create_access_control_entry_changed(cluster_t *cluster); +event_t *create_access_control_extension_changed(cluster_t *cluster); +} // namespace event +} // namespace access_control + +namespace actions { +namespace event { +event_t *create_state_changed(cluster_t *cluster); +event_t *create_action_failed(cluster_t *cluster); +} // namespace event +} // namespace actions + +namespace basic_information { +namespace event { +event_t *create_start_up(cluster_t *cluster); +event_t *create_shut_down(cluster_t *cluster); +event_t *create_leave(cluster_t *cluster); +event_t *create_reachable_changed(cluster_t *cluster); +} // namespace event +} // namespace basic_information + +namespace ota_requestor { +namespace event { +event_t *create_state_transition(cluster_t *cluster); +event_t *create_version_applied(cluster_t *cluster); +event_t *create_download_error(cluster_t *cluster); +} // namespace event +} // namespace ota_requestor + +namespace general_diagnostics { +namespace event { +event_t *create_hardware_fault_change(cluster_t *cluster); +event_t *create_radio_fault_change(cluster_t *cluster); +event_t *create_network_fault_change(cluster_t *cluster); +event_t *create_boot_reason(cluster_t *cluster); +} // namespace event +} // namespace general_diagnostics + +namespace diagnostics_network_wifi { +namespace event { +event_t *create_disconnection(cluster_t *cluster); +event_t *create_association_failure(cluster_t *cluster); +event_t *create_connection_status(cluster_t *cluster); +} // namespace event +} // namespace diagnostics_network_wifi + +namespace diagnostics_network_thread { +namespace event { +event_t *create_connection_status(cluster_t *cluster); +event_t *create_network_fault_change(cluster_t *cluster); +} // namespace event +} // namespace diagnostics_network_thread + +namespace software_diagnostics { +namespace event { +event_t *create_software_fault(cluster_t *cluster); +} // namespace event +} // namespace software_diagnostics + +namespace time_synchronization { +namespace event { +event_t *create_dst_table_empty(cluster_t *cluster); +event_t *create_dst_status(cluster_t *cluster); +event_t *create_time_zone_status(cluster_t *cluster); +event_t *create_time_failure(cluster_t *cluster); +event_t *create_missing_trusted_time_source(cluster_t *cluster); +} // namespace event +} // namespace time_synchronization + +namespace bridged_device_basic_information { +namespace event { +event_t *create_start_up(cluster_t *cluster); +event_t *create_shut_down(cluster_t *cluster); +event_t *create_leave(cluster_t *cluster); +event_t *create_reachable_changed(cluster_t *cluster); +} // namespace event +} // namespace bridged_device_basic_information + +namespace door_lock { +namespace event { +event_t *create_door_lock_alarm(cluster_t *cluster); +event_t *create_door_state_change(cluster_t *cluster); +event_t *create_lock_operation(cluster_t *cluster); +event_t *create_lock_operation_error(cluster_t *cluster); +event_t *create_lock_user_change(cluster_t *cluster); +} // namespace event +} // namespace door_lock + namespace switch_cluster { namespace event { +event_t *create_switch_latched(cluster_t *cluster); +event_t *create_initial_press(cluster_t *cluster); +event_t *create_long_press(cluster_t *cluster); +event_t *create_short_release(cluster_t *cluster); +event_t *create_long_release(cluster_t *cluster); +event_t *create_multi_press_ongoing(cluster_t *cluster); +event_t *create_multi_press_complete(cluster_t *cluster); + esp_err_t send_switch_latched(chip::EndpointId endpoint, uint8_t new_position); esp_err_t send_initial_press(chip::EndpointId endpoint, uint8_t new_position); esp_err_t send_long_press(chip::EndpointId endpoint, uint8_t new_position); @@ -34,8 +133,36 @@ esp_err_t send_short_release(chip::EndpointId endpoint, uint8_t previous_positio esp_err_t send_long_release(chip::EndpointId endpoint, uint8_t previous_position); esp_err_t send_multi_press_ongoing(chip::EndpointId endpoint, uint8_t new_position, uint8_t count); esp_err_t send_multi_press_complete(chip::EndpointId endpoint, uint8_t new_position, uint8_t count); -} /* event */ -} /* switch_cluster */ +} // namespace event +} // namespace switch_cluster -} /* cluster */ -} /* esp_matter */ +namespace boolean_state { +namespace event { +event_t *create_state_change(cluster_t *cluster); +} +} // namespace boolean_state + +namespace pump_configuration_and_control { +namespace event { +event_t *create_supply_voltage_low(cluster_t *cluster); +event_t *create_supply_voltage_high(cluster_t *cluster); +event_t *create_power_missing_phase(cluster_t *cluster); +event_t *create_system_pressure_low(cluster_t *cluster); +event_t *create_system_pressure_high(cluster_t *cluster); +event_t *create_dry_running(cluster_t *cluster); +event_t *create_motor_temperature_high(cluster_t *cluster); +event_t *create_pump_motor_fatal_failure(cluster_t *cluster); +event_t *create_electronic_temperature_high(cluster_t *cluster); +event_t *create_pump_blocked(cluster_t *cluster); +event_t *create_sensor_failure(cluster_t *cluster); +event_t *create_electronic_non_fatal_failure(cluster_t *cluster); +event_t *create_electronic_fatal_failure(cluster_t *cluster); +event_t *create_general_fault(cluster_t *cluster); +event_t *create_leakage(cluster_t *cluster); +event_t *create_air_detection(cluster_t *cluster); +event_t *create_turbine_operation(cluster_t *cluster); +} // namespace event +} // namespace pump_configuration_and_control + +} // namespace cluster +} // namespace esp_matter