github/esphome
2
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2026-10-10 05:23:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

[core] Use numeric scheduler ids instead of string names (ESP32 2/2) (#20381)

Browse Source
This commit is contained in:
J. Nick Koston
2026-10-09 07:09:04 -10:00
committed by GitHub
parent d9b9ce2909
commit 466081acc1
6 changed files with 54 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
esphome/components/speaker/media_player/speaker_media_player.cpp
+18 -12
View File
@@ -52,6 +52,11 @@ static const UBaseType_t ANNOUNCEMENT_PIPELINE_TASK_PRIORITY = 1;
ESPHOME_LOG_TAG(TAG, "speaker_media_player");
static constexpr uint32_t UNPAUSE_MEDIA_INTERVAL_ID = 0;
static constexpr uint32_t NEXT_ANNOUNCEMENT_TIMEOUT_ID = 1;
static constexpr uint32_t NEXT_MEDIA_TIMEOUT_ID = 2;
static constexpr uint32_t UNPAUSE_ANNOUNCEMENT_INTERVAL_ID = 3;
void SpeakerMediaPlayer::setup() {
#ifdef USE_SPEAKER_MEDIA_PLAYER_ON_OFF
state = media_player::MEDIA_PLAYER_STATE_OFF;
@@ -112,13 +117,13 @@ void SpeakerMediaPlayer::set_playlist_delay_ms(AudioPipelineType pipeline_type,
void SpeakerMediaPlayer::stop_and_unpause_media_() {
this->media_pipeline_->stop();
this->unpause_media_remaining_ = 3;
this->set_interval("unpause_med", 50, [this]() {
this->set_interval(UNPAUSE_MEDIA_INTERVAL_ID, 50, [this]() {
if (this->media_pipeline_state_ == AudioPipelineState::STOPPED) {
this->cancel_interval("unpause_med");
this->cancel_interval(UNPAUSE_MEDIA_INTERVAL_ID);
this->media_pipeline_->set_pause_state(false);
this->is_paused_ = false;
} else if (--this->unpause_media_remaining_ == 0) {
this->cancel_interval("unpause_med");
this->cancel_interval(UNPAUSE_MEDIA_INTERVAL_ID);
}
});
}
@@ -152,7 +157,7 @@ void SpeakerMediaPlayer::watch_media_commands_() {
if (this->single_pipeline_() || (media_command.announce.has_value() && media_command.announce.value())) {
if (!enqueue) {
// Ensure the loaded next item doesn't start playing, clear the queue, start the file, and unpause
this->cancel_timeout("next_ann");
this->cancel_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID);
this->announcement_playlist_.clear();
this->announcement_item_failed_ = false;
if (media_command.file.has_value()) {
@@ -166,7 +171,7 @@ void SpeakerMediaPlayer::watch_media_commands_() {
} else {
if (!enqueue) {
// Ensure the loaded next item doesn't start playing, clear the queue, start the file, and unpause
this->cancel_timeout("next_media");
this->cancel_timeout(NEXT_MEDIA_TIMEOUT_ID);
this->media_playlist_.clear();
this->media_item_failed_ = false;
if (this->is_paused_) {
@@ -236,23 +241,23 @@ void SpeakerMediaPlayer::watch_media_commands_() {
if (this->single_pipeline_() || (media_command.announce.has_value() && media_command.announce.value())) {
#endif
if (this->announcement_pipeline_ != nullptr) {
this->cancel_timeout("next_ann");
this->cancel_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID);
this->announcement_playlist_.clear();
this->announcement_item_failed_ = false;
this->announcement_pipeline_->stop();
this->unpause_announcement_remaining_ = 3;
this->set_interval("unpause_ann", 50, [this]() {
this->set_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID, 50, [this]() {
if (this->announcement_pipeline_state_ == AudioPipelineState::STOPPED) {
this->cancel_interval("unpause_ann");
this->cancel_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID);
this->announcement_pipeline_->set_pause_state(false);
} else if (--this->unpause_announcement_remaining_ == 0) {
this->cancel_interval("unpause_ann");
this->cancel_interval(UNPAUSE_ANNOUNCEMENT_INTERVAL_ID);
}
});
}
} else {
if (this->media_pipeline_ != nullptr) {
this->cancel_timeout("next_media");
this->cancel_timeout(NEXT_MEDIA_TIMEOUT_ID);
this->media_playlist_.clear();
this->media_item_failed_ = false;
this->stop_and_unpause_media_();
@@ -408,7 +413,8 @@ void SpeakerMediaPlayer::loop() {
this->announcement_pipeline_->set_pause_state(true);
// Internally unpause the pipeline after the delay between playlist items. Announcements do not follow the
// media player's pause state.
this->set_timeout("next_ann", timeout_ms, [this]() { this->announcement_pipeline_->set_pause_state(false); });
this->set_timeout(NEXT_ANNOUNCEMENT_TIMEOUT_ID, timeout_ms,
[this]() { this->announcement_pipeline_->set_pause_state(false); });
}
}
} else {
@@ -454,7 +460,7 @@ void SpeakerMediaPlayer::loop() {
this->media_pipeline_->set_pause_state(true);
// Internally unpause the pipeline after the delay between playlist items, if the media player state is
// not paused.
this->set_timeout("next_media", timeout_ms,
this->set_timeout(NEXT_MEDIA_TIMEOUT_ID, timeout_ms,
[this]() { this->media_pipeline_->set_pause_state(this->is_paused_); });
}
}
esphome/components/voice_assistant/voice_assistant.cpp
+16 -11
View File
@@ -14,6 +14,11 @@ namespace esphome::voice_assistant {
ESPHOME_LOG_TAG(TAG, "voice_assistant");
static constexpr uint32_t RESET_CONVERSATION_TIMEOUT_ID = 0;
static constexpr uint32_t PLAYBACK_TIMEOUT_ID = 1;
static constexpr uint32_t SPEAKER_IDLE_TIMEOUT_ID = 2;
static constexpr uint32_t TIMER_TICK_INTERVAL_ID = 3;
#ifdef SAMPLE_RATE_HZ
#undef SAMPLE_RATE_HZ
#endif
@@ -370,7 +375,7 @@ void VoiceAssistant::loop() {
break;
}
this->set_state_(State::STARTING_PIPELINE);
this->set_timeout("reset-conversation_id", this->conversation_timeout_,
this->set_timeout(RESET_CONVERSATION_TIMEOUT_ID, this->conversation_timeout_,
[this]() { this->reset_conversation_id(); });
break;
}
@@ -460,10 +465,10 @@ void VoiceAssistant::loop() {
if (this->speaker_bytes_received_ > RECEIVE_SIZE * 4 || end_of_stream)
this->write_speaker_();
if (this->wait_for_stream_end_) {
this->cancel_timeout("playing");
this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
if (end_of_stream) {
ESP_LOGD(TAG, "End of audio stream received");
this->cancel_timeout("speaker-timeout");
this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
}
break; // We dont want to timeout here as the STREAM_END event will take care of that.
@@ -477,7 +482,7 @@ void VoiceAssistant::loop() {
if (this->media_player_response_state_ == MediaPlayerResponseState::FINISHED) {
this->media_player_response_state_ = MediaPlayerResponseState::IDLE;
this->cancel_timeout("playing");
this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
ESP_LOGD(TAG, "Announcement finished playing");
this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
@@ -507,8 +512,8 @@ void VoiceAssistant::loop() {
}
ESP_LOGD(TAG, "Speaker has finished outputting all audio");
this->speaker_->stop();
this->cancel_timeout("speaker-timeout");
this->cancel_timeout("playing");
this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
this->cancel_timeout(PLAYBACK_TIMEOUT_ID);
this->clear_buffers_();
@@ -540,7 +545,7 @@ void VoiceAssistant::write_speaker_() {
memmove(this->speaker_buffer_, this->speaker_buffer_ + written, this->speaker_buffer_size_ - written);
this->speaker_buffer_size_ -= written;
this->speaker_buffer_index_ -= written;
this->set_timeout("speaker-timeout", 5000, [this]() { this->speaker_->stop(); });
this->set_timeout(SPEAKER_IDLE_TIMEOUT_ID, 5000, [this]() { this->speaker_->stop(); });
} else {
ESP_LOGV(TAG, "Speaker buffer full, trying again next loop");
}
@@ -755,8 +760,8 @@ void VoiceAssistant::signal_stop_() {
}
void VoiceAssistant::start_playback_timeout_() {
this->set_timeout("playing", 2000, [this]() {
this->cancel_timeout("speaker-timeout");
this->set_timeout(PLAYBACK_TIMEOUT_ID, 2000, [this]() {
this->cancel_timeout(SPEAKER_IDLE_TIMEOUT_ID);
this->set_state_(State::RESPONSE_FINISHED, State::RESPONSE_FINISHED);
if (this->api_client_ == nullptr)
@@ -1046,10 +1051,10 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
}
if (this->timers_.empty()) {
this->cancel_interval("timer-event");
this->cancel_interval(TIMER_TICK_INTERVAL_ID);
this->timer_tick_running_ = false;
} else if (!this->timer_tick_running_) {
this->set_interval("timer-event", 1000, [this]() { this->timer_tick_(); });
this->set_interval(TIMER_TICK_INTERVAL_ID, 1000, [this]() { this->timer_tick_(); });
this->timer_tick_running_ = true;
}
}
esphome/components/xiaomi_mue4094rt/xiaomi_mue4094rt.cpp
+3 -1
View File
@@ -5,6 +5,8 @@ namespace esphome::xiaomi_mue4094rt {
ESPHOME_LOG_TAG(TAG, "xiaomi_mue4094rt");
static constexpr uint32_t MOTION_TIMEOUT_ID = 0;
void XiaomiMUE4094RT::dump_config() {
ESP_LOGCONFIG(TAG, "Xiaomi MUE4094RT");
LOG_BINARY_SENSOR(" ", "Motion", this);
@@ -40,7 +42,7 @@ bool XiaomiMUE4094RT::parse_device(const ble_device_base::ESPBTDevice &device) {
}
if (res->has_motion.has_value()) {
this->publish_state(*res->has_motion);
this->set_timeout("motion_timeout", timeout_, [this]() { this->publish_state(false); });
this->set_timeout(MOTION_TIMEOUT_ID, timeout_, [this]() { this->publish_state(false); });
}
success = true;
}
esphome/components/xiaomi_rtcgq02lm/xiaomi_rtcgq02lm.cpp
+5 -2
View File
@@ -6,6 +6,9 @@ namespace esphome::xiaomi_rtcgq02lm {
ESPHOME_LOG_TAG(TAG, "xiaomi_rtcgq02lm");
static constexpr uint32_t MOTION_TIMEOUT_ID = 0;
static constexpr uint32_t BUTTON_TIMEOUT_ID = 1;
static constexpr size_t RTCGQ02LM_BINDKEY_SIZE = 16;
void XiaomiRTCGQ02LM::dump_config() {
@@ -55,13 +58,13 @@ bool XiaomiRTCGQ02LM::parse_device(const ble_device_base::ESPBTDevice &device) {
#ifdef USE_BINARY_SENSOR
if (res->has_motion.has_value() && this->motion_ != nullptr) {
this->motion_->publish_state(*res->has_motion);
this->set_timeout("motion_timeout", this->motion_timeout_, [this]() { this->motion_->publish_state(false); });
this->set_timeout(MOTION_TIMEOUT_ID, this->motion_timeout_, [this]() { this->motion_->publish_state(false); });
}
if (res->is_light.has_value() && this->light_ != nullptr)
this->light_->publish_state(*res->is_light);
if (res->button_press.has_value() && this->button_ != nullptr) {
this->button_->publish_state(*res->button_press);
this->set_timeout("button_timeout", this->button_timeout_, [this]() { this->button_->publish_state(false); });
this->set_timeout(BUTTON_TIMEOUT_ID, this->button_timeout_, [this]() { this->button_->publish_state(false); });
}
#endif
#ifdef USE_SENSOR
esphome/components/zigbee/time/zigbee_time_esp32.cpp
+5 -2
View File
@@ -7,6 +7,9 @@ namespace esphome::zigbee {
ESPHOME_LOG_TAG(TAG, "zigbee.time");
static constexpr uint32_t REGISTER_RETRY_TIMEOUT_ID = 0;
static constexpr uint32_t SYNC_RETRY_TIMEOUT_ID = 1;
// This time standard is the number of
// seconds since 0 hrs 0 mins 0 sec on 1st January 2000 UTC (Universal Coordinated Time).
constexpr time_t EPOCH_2000 = 946684800;
@@ -29,7 +32,7 @@ void ZigbeeTime::register_zb_time_() {
};
ezb_err_t ret;
if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
this->set_timeout("zb_time_register", 100, [this]() { this->register_zb_time_(); });
this->set_timeout(REGISTER_RETRY_TIMEOUT_ID, 100, [this]() { this->register_zb_time_(); });
return;
}
ret = ezb_zcl_time_server_interface_register(this->endpoint_, time_interface);
@@ -69,7 +72,7 @@ void ZigbeeTime::update() {
ESP_LOGW(TAG, "Could not acquire Zigbee lock to synchronize time, will retry maximum 3 times");
}
if (this->retry_count_ < 3) {
this->set_timeout("zb_time_sync", 100, [this]() { this->update(); });
this->set_timeout(SYNC_RETRY_TIMEOUT_ID, 100, [this]() { this->update(); });
this->retry_count_++;
} else {
ESP_LOGW(TAG, "Could not acquire Zigbee lock to synchronize time");
esphome/components/zigbee/zigbee_esp32.cpp
+7 -4
View File
@@ -19,6 +19,8 @@ namespace esphome::zigbee {
ESPHOME_LOG_TAG(TAG, "zigbee");
static constexpr uint32_t COMMISSIONING_RETRY_TIMEOUT_ID = 0;
static ZigbeeComponent *global_zigbee = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
uint8_t *get_zcl_string(const char *str, uint8_t max_size, bool use_max_size) {
@@ -49,7 +51,8 @@ void ZigbeeComponent::factory_reset() {
void ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(ezb_bdb_comm_mode_mask_t mode) {
if (!esp_zigbee_lock_acquire(10 / portTICK_PERIOD_MS)) {
global_zigbee->set_timeout("zb_init", 100, [mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 100,
[mode]() { ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(mode); });
App.wake_loop_threadsafe();
return;
}
@@ -86,7 +89,7 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
}
} else {
ESP_LOGW(TAG, "The %s failed with status(0x%02x), please retry", ezb_app_signal_to_string(signal_type), status);
global_zigbee->set_timeout("zb_init", 1000, []() {
global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_INITIALIZATION);
});
App.wake_loop_threadsafe();
@@ -107,11 +110,11 @@ bool ZigbeeComponent::app_signal_handler(const ezb_app_signal_t *app_signal) {
ESP_LOGD(TAG, "Failed to join network with status(0x%02x)", status);
if (steering_retry_count < 10) {
steering_retry_count++;
global_zigbee->set_timeout("zb_init", 1000, []() {
global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 1000, []() {
ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
});
} else {
global_zigbee->set_timeout("zb_init", 600 * 1000, []() {
global_zigbee->set_timeout(COMMISSIONING_RETRY_TIMEOUT_ID, 600 * 1000, []() {
ZigbeeComponent::esp_zigbee_alarm_bdb_commissioning(EZB_BDB_MODE_NETWORK_STEERING);
});
}