Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-11-21 22:48:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

Fix clang-tidy header filter (#2385)

Browse source 
* Fix clang-tidy header filter

* Allow private members

* Fix clang-tidy detections

* Run clang-format

* Fix remaining detections

* Fix graph

* Run clang-format
This commit is contained in:
Otto Winter 2021-09-24 18:02:28 +02:00 committed by GitHub
parent 52dd79691b
commit aec02afcdc
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
76 changed files with 404 additions and 367 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.clang-tidy
View file

@ -135,10 +135,14 @@ CheckOptions:
value: 'UPPER_CASE' value: 'UPPER_CASE'
- key: readability-identifier-naming.ParameterCase - key: readability-identifier-naming.ParameterCase
value: 'lower_case' value: 'lower_case'
- key: readability-identifier-naming.PrivateMemberPrefix - key: readability-identifier-naming.PrivateMemberCase
value: 'NO_PRIVATE_MEMBERS_ALWAYS_USE_PROTECTED' value: 'lower_case'
- key: readability-identifier-naming.PrivateMethodPrefix - key: readability-identifier-naming.PrivateMemberSuffix
value: 'NO_PRIVATE_METHODS_ALWAYS_USE_PROTECTED' value: '_'
- key: readability-identifier-naming.PrivateMethodCase
value: 'lower_case'
- key: readability-identifier-naming.PrivateMethodSuffix
value: '_'
- key: readability-identifier-naming.ClassMemberCase - key: readability-identifier-naming.ClassMemberCase
value: 'lower_case' value: 'lower_case'
- key: readability-identifier-naming.ClassMemberCase - key: readability-identifier-naming.ClassMemberCase

4
esphome/components/airthings_wave_plus/airthings_wave_plus.cpp
View file

@ -31,7 +31,7 @@ void AirthingsWavePlus::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt
break; break;
} }
this->handle_ = chr->handle; this->handle_ = chr->handle;
this->node_state = esp32_ble_tracker::ClientState::Established; this->node_state = esp32_ble_tracker::ClientState::ESTABLISHED;
request_read_values_(); request_read_values_();
break; break;
@ -99,7 +99,7 @@ bool AirthingsWavePlus::is_valid_co2_value_(uint16_t co2) { return 0 <= co2 && c
void AirthingsWavePlus::loop() {} void AirthingsWavePlus::loop() {}
void AirthingsWavePlus::update() { void AirthingsWavePlus::update() {
if (this->node_state != esp32_ble_tracker::ClientState::Established) { if (this->node_state != esp32_ble_tracker::ClientState::ESTABLISHED) {
if (!parent()->enabled) { if (!parent()->enabled) {
ESP_LOGW(TAG, "Reconnecting to device"); ESP_LOGW(TAG, "Reconnecting to device");
parent()->set_enabled(true); parent()->set_enabled(true);

6
esphome/components/am43/am43.cpp
View file

@ -31,7 +31,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
} }
case ESP_GATTC_DISCONNECT_EVT: { case ESP_GATTC_DISCONNECT_EVT: {
this->logged_in_ = false; this->logged_in_ = false;
this->node_state = espbt::ClientState::Idle; this->node_state = espbt::ClientState::IDLE;
if (this->battery_ != nullptr) if (this->battery_ != nullptr)
this->battery_->publish_state(NAN); this->battery_->publish_state(NAN);
if (this->illuminance_ != nullptr) if (this->illuminance_ != nullptr)
@ -54,7 +54,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
break; break;
} }
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
this->update(); this->update();
break; break;
} }
@ -93,7 +93,7 @@ void Am43::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_i
} }
void Am43::update() { void Am43::update() {
if (this->node_state != espbt::ClientState::Established) { if (this->node_state != espbt::ClientState::ESTABLISHED) {
ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str()); ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->parent_->address_str().c_str());
return; return;
} }

6
esphome/components/am43/cover/am43_cover.cpp
View file

@ -24,7 +24,7 @@ void Am43Component::setup() {
} }
void Am43Component::loop() { void Am43Component::loop() {
if (this->node_state == espbt::ClientState::Established && !this->logged_in_) { if (this->node_state == espbt::ClientState::ESTABLISHED && !this->logged_in_) {
auto packet = this->encoder_->get_send_pin_request(this->pin_); auto packet = this->encoder_->get_send_pin_request(this->pin_);
auto status = auto status =
esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length, esp_ble_gattc_write_char(this->parent_->gattc_if, this->parent_->conn_id, this->char_handle_, packet->length,
@ -46,7 +46,7 @@ CoverTraits Am43Component::get_traits() {
} }
void Am43Component::control(const CoverCall &call) { void Am43Component::control(const CoverCall &call) {
if (this->node_state != espbt::ClientState::Established) { if (this->node_state != espbt::ClientState::ESTABLISHED) {
ESP_LOGW(TAG, "[%s] Cannot send cover control, not connected", this->get_name().c_str()); ESP_LOGW(TAG, "[%s] Cannot send cover control, not connected", this->get_name().c_str());
return; return;
} }
@ -98,7 +98,7 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
break; break;
} }
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
break; break;
} }
case ESP_GATTC_NOTIFY_EVT: { case ESP_GATTC_NOTIFY_EVT: {

4
esphome/components/anova/anova.cpp
View file

@ -72,7 +72,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
break; break;
} }
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
this->current_request_ = 0; this->current_request_ = 0;
this->update(); this->update();
break; break;
@ -129,7 +129,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
void Anova::set_unit_of_measurement(const char *unit) { this->fahrenheit_ = !strncmp(unit, "f", 1); } void Anova::set_unit_of_measurement(const char *unit) { this->fahrenheit_ = !strncmp(unit, "f", 1); }
void Anova::update() { void Anova::update() {
if (this->node_state != espbt::ClientState::Established) if (this->node_state != espbt::ClientState::ESTABLISHED)
return; return;
if (this->current_request_ < 2) { if (this->current_request_ < 2) {

2
esphome/components/anova/anova.h
View file

@ -27,7 +27,7 @@ class Anova : public climate::Climate, public esphome::ble_client::BLEClientNode
esp_ble_gattc_cb_param_t *param) override; esp_ble_gattc_cb_param_t *param) override;
void dump_config() override; void dump_config() override;
float get_setup_priority() const override { return setup_priority::DATA; } float get_setup_priority() const override { return setup_priority::DATA; }
climate::ClimateTraits traits() { climate::ClimateTraits traits() override {
auto traits = climate::ClimateTraits(); auto traits = climate::ClimateTraits();
traits.set_supports_current_temperature(true); traits.set_supports_current_temperature(true);
traits.set_supports_heat_mode(true); traits.set_supports_heat_mode(true);

9
esphome/components/api/api_frame_helper.h
View file

@ -1,7 +1,8 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <vector>
#include <deque> #include <deque>
#include <utility>
#include <vector>
#include "esphome/core/defines.h" #include "esphome/core/defines.h"
@ -75,8 +76,8 @@ class APIFrameHelper {
class APINoiseFrameHelper : public APIFrameHelper { class APINoiseFrameHelper : public APIFrameHelper {
public: public:
APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, std::shared_ptr<APINoiseContext> ctx) APINoiseFrameHelper(std::unique_ptr<socket::Socket> socket, std::shared_ptr<APINoiseContext> ctx)
: socket_(std::move(socket)), ctx_(ctx) {} : socket_(std::move(socket)), ctx_(std::move(std::move(ctx))) {}
~APINoiseFrameHelper(); ~APINoiseFrameHelper() override;
APIError init() override; APIError init() override;
APIError loop() override; APIError loop() override;
APIError read_packet(ReadPacketBuffer *buffer) override; APIError read_packet(ReadPacketBuffer *buffer) override;
@ -136,7 +137,7 @@ class APINoiseFrameHelper : public APIFrameHelper {
class APIPlaintextFrameHelper : public APIFrameHelper { class APIPlaintextFrameHelper : public APIFrameHelper {
public: public:
APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : socket_(std::move(socket)) {} APIPlaintextFrameHelper(std::unique_ptr<socket::Socket> socket) : socket_(std::move(socket)) {}
~APIPlaintextFrameHelper() = default; ~APIPlaintextFrameHelper() override = default;
APIError init() override; APIError init() override;
APIError loop() override; APIError loop() override;
APIError read_packet(ReadPacketBuffer *buffer) override; APIError read_packet(ReadPacketBuffer *buffer) override;

2
esphome/components/api/api_noise_context.h
View file

@ -11,7 +11,7 @@ using psk_t = std::array<uint8_t, 32>;
class APINoiseContext { class APINoiseContext {
public: public:
void set_psk(psk_t psk) { psk_ = std::move(psk); } void set_psk(psk_t psk) { psk_ = psk; }
const psk_t &get_psk() const { return psk_; } const psk_t &get_psk() const { return psk_; }
protected: protected:

2
esphome/components/api/api_server.h
View file

@ -32,7 +32,7 @@ class APIServer : public Component, public Controller {
void set_reboot_timeout(uint32_t reboot_timeout); void set_reboot_timeout(uint32_t reboot_timeout);
#ifdef USE_API_NOISE #ifdef USE_API_NOISE
void set_noise_psk(psk_t psk) { noise_ctx_->set_psk(std::move(psk)); } void set_noise_psk(psk_t psk) { noise_ctx_->set_psk(psk); }
std::shared_ptr<APINoiseContext> get_noise_ctx() { return noise_ctx_; } std::shared_ptr<APINoiseContext> get_noise_ctx() { return noise_ctx_; }
#endif // USE_API_NOISE #endif // USE_API_NOISE

12
esphome/components/atc_mithermometer/atc_mithermometer.cpp
View file

@ -25,14 +25,14 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
bool success = false; bool success = false;
for (auto &service_data : device.get_service_datas()) { for (auto &service_data : device.get_service_datas()) {
auto res = parse_header(service_data); auto res = parse_header_(service_data);
if (!res.has_value()) { if (!res.has_value()) {
continue; continue;
} }
if (!(parse_message(service_data.data, *res))) { if (!(parse_message_(service_data.data, *res))) {
continue; continue;
} }
if (!(report_results(res, device.address_str()))) { if (!(report_results_(res, device.address_str()))) {
continue; continue;
} }
if (res->temperature.has_value() && this->temperature_ != nullptr) if (res->temperature.has_value() && this->temperature_ != nullptr)
@ -49,7 +49,7 @@ bool ATCMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &device
return success; return success;
} }
optional<ParseResult> ATCMiThermometer::parse_header(const esp32_ble_tracker::ServiceData &service_data) { optional<ParseResult> ATCMiThermometer::parse_header_(const esp32_ble_tracker::ServiceData &service_data) {
ParseResult result; ParseResult result;
if (!service_data.uuid.contains(0x1A, 0x18)) { if (!service_data.uuid.contains(0x1A, 0x18)) {
ESP_LOGVV(TAG, "parse_header(): no service data UUID magic bytes."); ESP_LOGVV(TAG, "parse_header(): no service data UUID magic bytes.");
@ -68,7 +68,7 @@ optional<ParseResult> ATCMiThermometer::parse_header(const esp32_ble_tracker::Se
return result; return result;
} }
bool ATCMiThermometer::parse_message(const std::vector<uint8_t> &message, ParseResult &result) { bool ATCMiThermometer::parse_message_(const std::vector<uint8_t> &message, ParseResult &result) {
// Byte 0-5 mac in correct order // Byte 0-5 mac in correct order
// Byte 6-7 Temperature in uint16 // Byte 6-7 Temperature in uint16
// Byte 8 Humidity in percent // Byte 8 Humidity in percent
@ -101,7 +101,7 @@ bool ATCMiThermometer::parse_message(const std::vector<uint8_t> &message, ParseR
return true; return true;
} }
bool ATCMiThermometer::report_results(const optional<ParseResult> &result, const std::string &address) { bool ATCMiThermometer::report_results_(const optional<ParseResult> &result, const std::string &address) {
if (!result.has_value()) { if (!result.has_value()) {
ESP_LOGVV(TAG, "report_results(): no results available."); ESP_LOGVV(TAG, "report_results(): no results available.");
return false; return false;

6
esphome/components/atc_mithermometer/atc_mithermometer.h
View file

@ -36,9 +36,9 @@ class ATCMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevice
sensor::Sensor *battery_level_{nullptr}; sensor::Sensor *battery_level_{nullptr};
sensor::Sensor *battery_voltage_{nullptr}; sensor::Sensor *battery_voltage_{nullptr};
optional<ParseResult> parse_header(const esp32_ble_tracker::ServiceData &service_data); optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
bool parse_message(const std::vector<uint8_t> &message, ParseResult &result); bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
bool report_results(const optional<ParseResult> &result, const std::string &address); bool report_results_(const optional<ParseResult> &result, const std::string &address);
}; };
} // namespace atc_mithermometer } // namespace atc_mithermometer

10
esphome/components/ble_client/automation.h
View file

@ -11,11 +11,12 @@ class BLEClientConnectTrigger : public Trigger<>, public BLEClientNode {
public: public:
explicit BLEClientConnectTrigger(BLEClient *parent) { parent->register_ble_node(this); } explicit BLEClientConnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
void loop() override {} void loop() override {}
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) { void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
esp_ble_gattc_cb_param_t *param) override {
if (event == ESP_GATTC_OPEN_EVT && param->open.status == ESP_GATT_OK) if (event == ESP_GATTC_OPEN_EVT && param->open.status == ESP_GATT_OK)
this->trigger(); this->trigger();
if (event == ESP_GATTC_SEARCH_CMPL_EVT) if (event == ESP_GATTC_SEARCH_CMPL_EVT)
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
} }
}; };
@ -23,11 +24,12 @@ class BLEClientDisconnectTrigger : public Trigger<>, public BLEClientNode {
public: public:
explicit BLEClientDisconnectTrigger(BLEClient *parent) { parent->register_ble_node(this); } explicit BLEClientDisconnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
void loop() override {} void loop() override {}
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) { void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
esp_ble_gattc_cb_param_t *param) override {
if (event == ESP_GATTC_DISCONNECT_EVT && memcmp(param->disconnect.remote_bda, this->parent_->remote_bda, 6) == 0) if (event == ESP_GATTC_DISCONNECT_EVT && memcmp(param->disconnect.remote_bda, this->parent_->remote_bda, 6) == 0)
this->trigger(); this->trigger();
if (event == ESP_GATTC_SEARCH_CMPL_EVT) if (event == ESP_GATTC_SEARCH_CMPL_EVT)
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
} }
}; };

28
esphome/components/ble_client/ble_client.cpp
View file

@ -17,12 +17,12 @@ void BLEClient::setup() {
ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret); ESP_LOGE(TAG, "gattc app register failed. app_id=%d code=%d", this->app_id, ret);
this->mark_failed(); this->mark_failed();
} }
this->set_states(espbt::ClientState::Idle); this->set_states_(espbt::ClientState::IDLE);
this->enabled = true; this->enabled = true;
} }
void BLEClient::loop() { void BLEClient::loop() {
if (this->state() == espbt::ClientState::Discovered) { if (this->state() == espbt::ClientState::DISCOVERED) {
this->connect(); this->connect();
} }
for (auto *node : this->nodes_) for (auto *node : this->nodes_)
@ -39,11 +39,11 @@ bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
return false; return false;
if (device.address_uint64() != this->address) if (device.address_uint64() != this->address)
return false; return false;
if (this->state() != espbt::ClientState::Idle) if (this->state() != espbt::ClientState::IDLE)
return false; return false;
ESP_LOGD(TAG, "Found device at MAC address [%s]", device.address_str().c_str()); ESP_LOGD(TAG, "Found device at MAC address [%s]", device.address_str().c_str());
this->set_states(espbt::ClientState::Discovered); this->set_states_(espbt::ClientState::DISCOVERED);
auto addr = device.address_uint64(); auto addr = device.address_uint64();
this->remote_bda[0] = (addr >> 40) & 0xFF; this->remote_bda[0] = (addr >> 40) & 0xFF;
@ -69,7 +69,7 @@ std::string BLEClient::address_str() const {
void BLEClient::set_enabled(bool enabled) { void BLEClient::set_enabled(bool enabled) {
if (enabled == this->enabled) if (enabled == this->enabled)
return; return;
if (!enabled && this->state() != espbt::ClientState::Idle) { if (!enabled && this->state() != espbt::ClientState::IDLE) {
ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str()); ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str().c_str());
auto ret = esp_ble_gattc_close(this->gattc_if, this->conn_id); auto ret = esp_ble_gattc_close(this->gattc_if, this->conn_id);
if (ret) { if (ret) {
@ -84,9 +84,9 @@ void BLEClient::connect() {
auto ret = esp_ble_gattc_open(this->gattc_if, this->remote_bda, BLE_ADDR_TYPE_PUBLIC, true); auto ret = esp_ble_gattc_open(this->gattc_if, this->remote_bda, BLE_ADDR_TYPE_PUBLIC, true);
if (ret) { if (ret) {
ESP_LOGW(TAG, "esp_ble_gattc_open error, address=%s status=%d", this->address_str().c_str(), ret); ESP_LOGW(TAG, "esp_ble_gattc_open error, address=%s status=%d", this->address_str().c_str(), ret);
this->set_states(espbt::ClientState::Idle); this->set_states_(espbt::ClientState::IDLE);
} else { } else {
this->set_states(espbt::ClientState::Connecting); this->set_states_(espbt::ClientState::CONNECTING);
} }
} }
@ -97,7 +97,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if) if (event != ESP_GATTC_REG_EVT && esp_gattc_if != ESP_GATT_IF_NONE && esp_gattc_if != this->gattc_if)
return; return;
bool all_established = this->all_nodes_established(); bool all_established = this->all_nodes_established_();
switch (event) { switch (event) {
case ESP_GATTC_REG_EVT: { case ESP_GATTC_REG_EVT: {
@ -113,7 +113,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
ESP_LOGV(TAG, "[%s] ESP_GATTC_OPEN_EVT", this->address_str().c_str()); ESP_LOGV(TAG, "[%s] ESP_GATTC_OPEN_EVT", this->address_str().c_str());
if (param->open.status != ESP_GATT_OK) { if (param->open.status != ESP_GATT_OK) {
ESP_LOGW(TAG, "connect to %s failed, status=%d", this->address_str().c_str(), param->open.status); ESP_LOGW(TAG, "connect to %s failed, status=%d", this->address_str().c_str(), param->open.status);
this->set_states(espbt::ClientState::Idle); this->set_states_(espbt::ClientState::IDLE);
break; break;
} }
this->conn_id = param->open.conn_id; this->conn_id = param->open.conn_id;
@ -126,7 +126,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
case ESP_GATTC_CFG_MTU_EVT: { case ESP_GATTC_CFG_MTU_EVT: {
if (param->cfg_mtu.status != ESP_GATT_OK) { if (param->cfg_mtu.status != ESP_GATT_OK) {
ESP_LOGW(TAG, "cfg_mtu to %s failed, status %d", this->address_str().c_str(), param->cfg_mtu.status); ESP_LOGW(TAG, "cfg_mtu to %s failed, status %d", this->address_str().c_str(), param->cfg_mtu.status);
this->set_states(espbt::ClientState::Idle); this->set_states_(espbt::ClientState::IDLE);
break; break;
} }
ESP_LOGV(TAG, "cfg_mtu status %d, mtu %d", param->cfg_mtu.status, param->cfg_mtu.mtu); ESP_LOGV(TAG, "cfg_mtu status %d, mtu %d", param->cfg_mtu.status, param->cfg_mtu.mtu);
@ -141,7 +141,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
for (auto &svc : this->services_) for (auto &svc : this->services_)
delete svc; // NOLINT(cppcoreguidelines-owning-memory) delete svc; // NOLINT(cppcoreguidelines-owning-memory)
this->services_.clear(); this->services_.clear();
this->set_states(espbt::ClientState::Idle); this->set_states_(espbt::ClientState::IDLE);
break; break;
} }
case ESP_GATTC_SEARCH_RES_EVT: { case ESP_GATTC_SEARCH_RES_EVT: {
@ -160,8 +160,8 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
ESP_LOGI(TAG, " start_handle: 0x%x end_handle: 0x%x", svc->start_handle, svc->end_handle); ESP_LOGI(TAG, " start_handle: 0x%x end_handle: 0x%x", svc->start_handle, svc->end_handle);
svc->parse_characteristics(); svc->parse_characteristics();
} }
this->set_states(espbt::ClientState::Connected); this->set_states_(espbt::ClientState::CONNECTED);
this->set_state(espbt::ClientState::Established); this->set_state(espbt::ClientState::ESTABLISHED);
break; break;
} }
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
@ -192,7 +192,7 @@ void BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
node->gattc_event_handler(event, esp_gattc_if, param); node->gattc_event_handler(event, esp_gattc_if, param);
// Delete characteristics after clients have used them to save RAM. // Delete characteristics after clients have used them to save RAM.
if (!all_established && this->all_nodes_established()) { if (!all_established && this->all_nodes_established_()) {
for (auto &svc : this->services_) for (auto &svc : this->services_)
delete svc; // NOLINT(cppcoreguidelines-owning-memory) delete svc; // NOLINT(cppcoreguidelines-owning-memory)
this->services_.clear(); this->services_.clear();

13
esphome/components/ble_client/ble_client.h
View file

@ -82,10 +82,11 @@ class BLEClient : public espbt::ESPBTClient, public Component {
void dump_config() override; void dump_config() override;
void loop() override; void loop() override;
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param); void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
esp_ble_gattc_cb_param_t *param) override;
bool parse_device(const espbt::ESPBTDevice &device) override; bool parse_device(const espbt::ESPBTDevice &device) override;
void on_scan_end() override {} void on_scan_end() override {}
void connect(); void connect() override;
void set_address(uint64_t address) { this->address = address; } void set_address(uint64_t address) { this->address = address; }
@ -116,16 +117,16 @@ class BLEClient : public espbt::ESPBTClient, public Component {
std::string address_str() const; std::string address_str() const;
protected: protected:
void set_states(espbt::ClientState st) { void set_states_(espbt::ClientState st) {
this->set_state(st); this->set_state(st);
for (auto &node : nodes_) for (auto &node : nodes_)
node->node_state = st; node->node_state = st;
} }
bool all_nodes_established() { bool all_nodes_established_() {
if (this->state() != espbt::ClientState::Established) if (this->state() != espbt::ClientState::ESTABLISHED)
return false; return false;
for (auto &node : nodes_) for (auto &node : nodes_)
if (node->node_state != espbt::ClientState::Established) if (node->node_state != espbt::ClientState::ESTABLISHED)
return false; return false;
return true; return true;
} }

5
esphome/components/ble_client/sensor/automation.h
View file

@ -11,10 +11,11 @@ namespace ble_client {
class BLESensorNotifyTrigger : public Trigger<float>, public BLESensor { class BLESensorNotifyTrigger : public Trigger<float>, public BLESensor {
public: public:
explicit BLESensorNotifyTrigger(BLESensor *sensor) { sensor_ = sensor; } explicit BLESensorNotifyTrigger(BLESensor *sensor) { sensor_ = sensor; }
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) { void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
esp_ble_gattc_cb_param_t *param) override {
switch (event) { switch (event) {
case ESP_GATTC_SEARCH_CMPL_EVT: { case ESP_GATTC_SEARCH_CMPL_EVT: {
this->sensor_->node_state = espbt::ClientState::Established; this->sensor_->node_state = espbt::ClientState::ESTABLISHED;
break; break;
} }
case ESP_GATTC_NOTIFY_EVT: { case ESP_GATTC_NOTIFY_EVT: {

12
esphome/components/ble_client/sensor/ble_sensor.cpp
View file

@ -71,7 +71,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
ESP_LOGW(TAG, "esp_ble_gattc_register_for_notify failed, status=%d", status); ESP_LOGW(TAG, "esp_ble_gattc_register_for_notify failed, status=%d", status);
} }
} else { } else {
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
} }
break; break;
} }
@ -84,7 +84,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
} }
if (param->read.handle == this->handle) { if (param->read.handle == this->handle) {
this->status_clear_warning(); this->status_clear_warning();
this->publish_state(this->parse_data(param->read.value, param->read.value_len)); this->publish_state(this->parse_data_(param->read.value, param->read.value_len));
} }
break; break;
} }
@ -93,11 +93,11 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
break; break;
ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(), ESP_LOGV(TAG, "[%s] ESP_GATTC_NOTIFY_EVT: handle=0x%x, value=0x%x", this->get_name().c_str(),
param->notify.handle, param->notify.value[0]); param->notify.handle, param->notify.value[0]);
this->publish_state(this->parse_data(param->notify.value, param->notify.value_len)); this->publish_state(this->parse_data_(param->notify.value, param->notify.value_len));
break; break;
} }
case ESP_GATTC_REG_FOR_NOTIFY_EVT: { case ESP_GATTC_REG_FOR_NOTIFY_EVT: {
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
break; break;
} }
default: default:
@ -105,7 +105,7 @@ void BLESensor::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
} }
} }
float BLESensor::parse_data(uint8_t *value, uint16_t value_len) { float BLESensor::parse_data_(uint8_t *value, uint16_t value_len) {
if (this->data_to_value_func_.has_value()) { if (this->data_to_value_func_.has_value()) {
std::vector<uint8_t> data(value, value + value_len); std::vector<uint8_t> data(value, value + value_len);
return (*this->data_to_value_func_)(data); return (*this->data_to_value_func_)(data);
@ -115,7 +115,7 @@ float BLESensor::parse_data(uint8_t *value, uint16_t value_len) {
} }
void BLESensor::update() { void BLESensor::update() {
if (this->node_state != espbt::ClientState::Established) { if (this->node_state != espbt::ClientState::ESTABLISHED) {
ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str()); ESP_LOGW(TAG, "[%s] Cannot poll, not connected", this->get_name().c_str());
return; return;
} }

4
esphome/components/ble_client/sensor/ble_sensor.h
View file

@ -32,13 +32,13 @@ class BLESensor : public sensor::Sensor, public PollingComponent, public BLEClie
void set_descr_uuid16(uint16_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); } void set_descr_uuid16(uint16_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); } void set_descr_uuid32(uint32_t uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); } void set_descr_uuid128(uint8_t *uuid) { this->descr_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
void set_data_to_value(data_to_value_t &&lambda_) { this->data_to_value_func_ = lambda_; } void set_data_to_value(data_to_value_t &&lambda) { this->data_to_value_func_ = lambda; }
void set_enable_notify(bool notify) { this->notify_ = notify; } void set_enable_notify(bool notify) { this->notify_ = notify; }
uint16_t handle; uint16_t handle;
protected: protected:
uint32_t hash_base() override; uint32_t hash_base() override;
float parse_data(uint8_t *value, uint16_t value_len); float parse_data_(uint8_t *value, uint16_t value_len);
optional<data_to_value_t> data_to_value_func_{}; optional<data_to_value_t> data_to_value_func_{};
bool notify_; bool notify_;
espbt::ESPBTUUID service_uuid_; espbt::ESPBTUUID service_uuid_;

4
esphome/components/ble_client/switch/ble_switch.cpp
View file

@ -21,10 +21,10 @@ void BLEClientSwitch::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
this->publish_state(this->parent_->enabled); this->publish_state(this->parent_->enabled);
break; break;
case ESP_GATTC_OPEN_EVT: case ESP_GATTC_OPEN_EVT:
this->node_state = espbt::ClientState::Established; this->node_state = espbt::ClientState::ESTABLISHED;
break; break;
case ESP_GATTC_DISCONNECT_EVT: case ESP_GATTC_DISCONNECT_EVT:
this->node_state = espbt::ClientState::Idle; this->node_state = espbt::ClientState::IDLE;
this->publish_state(this->parent_->enabled); this->publish_state(this->parent_->enabled);
break; break;
default: default:

4
esphome/components/ble_presence/ble_presence_device.h
View file

@ -93,8 +93,8 @@ class BLEPresenceDevice : public binary_sensor::BinarySensorInitiallyOff,
float get_setup_priority() const override { return setup_priority::DATA; } float get_setup_priority() const override { return setup_priority::DATA; }
protected: protected:
enum MATCH_TYPE { MATCH_BY_MAC_ADDRESS, MATCH_BY_SERVICE_UUID, MATCH_BY_IBEACON_UUID }; enum MatchType { MATCH_BY_MAC_ADDRESS, MATCH_BY_SERVICE_UUID, MATCH_BY_IBEACON_UUID };
MATCH_TYPE match_by_; MatchType match_by_;
bool found_{false}; bool found_{false};

2
esphome/components/ble_scanner/ble_scanner.h
View file

@ -15,7 +15,7 @@ namespace ble_scanner {
class BLEScanner : public text_sensor::TextSensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component { class BLEScanner : public text_sensor::TextSensor, public esp32_ble_tracker::ESPBTDeviceListener, public Component {
public: public:
bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override { bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override {
this->publish_state("{\"timestamp\":" + to_string(::time(NULL)) + this->publish_state("{\"timestamp\":" + to_string(::time(nullptr)) +
"," ","
"\"address\":\"" + "\"address\":\"" +
device.address_str() + device.address_str() +

18
esphome/components/daly_bms/daly_bms.cpp
View file

@ -26,25 +26,25 @@ void DalyBmsComponent::dump_config() {
} }
void DalyBmsComponent::update() { void DalyBmsComponent::update() {
this->request_data(DALY_REQUEST_BATTERY_LEVEL); this->request_data_(DALY_REQUEST_BATTERY_LEVEL);
this->request_data(DALY_REQUEST_MIN_MAX_VOLTAGE); this->request_data_(DALY_REQUEST_MIN_MAX_VOLTAGE);
this->request_data(DALY_REQUEST_MIN_MAX_TEMPERATURE); this->request_data_(DALY_REQUEST_MIN_MAX_TEMPERATURE);
this->request_data(DALY_REQUEST_MOS); this->request_data_(DALY_REQUEST_MOS);
this->request_data(DALY_REQUEST_STATUS); this->request_data_(DALY_REQUEST_STATUS);
this->request_data(DALY_REQUEST_TEMPERATURE); this->request_data_(DALY_REQUEST_TEMPERATURE);
std::vector<uint8_t> get_battery_level_data; std::vector<uint8_t> get_battery_level_data;
int available_data = this->available(); int available_data = this->available();
if (available_data >= DALY_FRAME_SIZE) { if (available_data >= DALY_FRAME_SIZE) {
get_battery_level_data.resize(available_data); get_battery_level_data.resize(available_data);
this->read_array(get_battery_level_data.data(), available_data); this->read_array(get_battery_level_data.data(), available_data);
this->decode_data(get_battery_level_data); this->decode_data_(get_battery_level_data);
} }
} }
float DalyBmsComponent::get_setup_priority() const { return setup_priority::DATA; } float DalyBmsComponent::get_setup_priority() const { return setup_priority::DATA; }
void DalyBmsComponent::request_data(uint8_t data_id) { void DalyBmsComponent::request_data_(uint8_t data_id) {
uint8_t request_message[DALY_FRAME_SIZE]; uint8_t request_message[DALY_FRAME_SIZE];
request_message[0] = 0xA5; // Start Flag request_message[0] = 0xA5; // Start Flag
@ -66,7 +66,7 @@ void DalyBmsComponent::request_data(uint8_t data_id) {
this->flush(); this->flush();
} }
void DalyBmsComponent::decode_data(std::vector<uint8_t> data) { void DalyBmsComponent::decode_data_(std::vector<uint8_t> data) {
auto it = data.begin(); auto it = data.begin();
while ((it = std::find(it, data.end(), 0xA5)) != data.end()) { while ((it = std::find(it, data.end(), 0xA5)) != data.end()) {

4
esphome/components/daly_bms/daly_bms.h
View file

@ -54,8 +54,8 @@ class DalyBmsComponent : public PollingComponent, public uart::UARTDevice {
float get_setup_priority() const override; float get_setup_priority() const override;
protected: protected:
void request_data(uint8_t data_id); void request_data_(uint8_t data_id);
void decode_data(std::vector<uint8_t> data); void decode_data_(std::vector<uint8_t> data);
sensor::Sensor *voltage_sensor_{nullptr}; sensor::Sensor *voltage_sensor_{nullptr};
sensor::Sensor *current_sensor_{nullptr}; sensor::Sensor *current_sensor_{nullptr};

2
esphome/components/esp32/gpio_arduino.cpp
View file

@ -21,7 +21,7 @@ ISRInternalGPIOPin ArduinoInternalGPIOPin::to_isr() const {
return ISRInternalGPIOPin((void *) arg); return ISRInternalGPIOPin((void *) arg);
} }
void ArduinoInternalGPIOPin::attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const { void ArduinoInternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const {
uint8_t arduino_mode = DISABLED; uint8_t arduino_mode = DISABLED;
switch (type) { switch (type) {
case gpio::INTERRUPT_RISING_EDGE: case gpio::INTERRUPT_RISING_EDGE:

2
esphome/components/esp32/gpio_arduino.h
View file

@ -23,7 +23,7 @@ class ArduinoInternalGPIOPin : public InternalGPIOPin {
bool is_inverted() const override { return inverted_; } bool is_inverted() const override { return inverted_; }
protected: protected:
void attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const override; void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
uint8_t pin_; uint8_t pin_;
bool inverted_; bool inverted_;

2
esphome/components/esp32/gpio_idf.cpp
View file

@ -8,7 +8,7 @@ namespace esp32 {
static const char *const TAG = "esp32"; static const char *const TAG = "esp32";
bool IDFInternalGPIOPin::isr_service_installed_ = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) bool IDFInternalGPIOPin::isr_service_installed = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
struct ISRPinArg { struct ISRPinArg {
gpio_num_t pin; gpio_num_t pin;

13
esphome/components/esp32/gpio_idf.h
View file

@ -21,7 +21,7 @@ class IDFInternalGPIOPin : public InternalGPIOPin {
void pin_mode(gpio::Flags flags) override { void pin_mode(gpio::Flags flags) override {
gpio_config_t conf{}; gpio_config_t conf{};
conf.pin_bit_mask = 1ULL << static_cast<uint32_t>(pin_); conf.pin_bit_mask = 1ULL << static_cast<uint32_t>(pin_);
conf.mode = flags_to_mode_(flags); conf.mode = flags_to_mode(flags);
conf.pull_up_en = flags & gpio::FLAG_PULLUP ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE; conf.pull_up_en = flags & gpio::FLAG_PULLUP ? GPIO_PULLUP_ENABLE : GPIO_PULLUP_DISABLE;
conf.pull_down_en = flags & gpio::FLAG_PULLDOWN ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE; conf.pull_down_en = flags & gpio::FLAG_PULLDOWN ? GPIO_PULLDOWN_ENABLE : GPIO_PULLDOWN_DISABLE;
conf.intr_type = GPIO_INTR_DISABLE; conf.intr_type = GPIO_INTR_DISABLE;
@ -36,7 +36,7 @@ class IDFInternalGPIOPin : public InternalGPIOPin {
bool is_inverted() const override { return inverted_; } bool is_inverted() const override { return inverted_; }
protected: protected:
static gpio_mode_t flags_to_mode_(gpio::Flags flags) { static gpio_mode_t flags_to_mode(gpio::Flags flags) {
flags = (gpio::Flags)(flags & ~(gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN)); flags = (gpio::Flags)(flags & ~(gpio::FLAG_PULLUP | gpio::FLAG_PULLDOWN));
if (flags == gpio::FLAG_NONE) { if (flags == gpio::FLAG_NONE) {
return GPIO_MODE_DISABLE; return GPIO_MODE_DISABLE;
@ -55,7 +55,7 @@ class IDFInternalGPIOPin : public InternalGPIOPin {
return GPIO_MODE_DISABLE; return GPIO_MODE_DISABLE;
} }
} }
void attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const override { void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override {
gpio_int_type_t idf_type = GPIO_INTR_ANYEDGE; gpio_int_type_t idf_type = GPIO_INTR_ANYEDGE;
switch (type) { switch (type) {
case gpio::INTERRUPT_RISING_EDGE: case gpio::INTERRUPT_RISING_EDGE:
@ -76,9 +76,9 @@ class IDFInternalGPIOPin : public InternalGPIOPin {
} }
gpio_set_intr_type(pin_, idf_type); gpio_set_intr_type(pin_, idf_type);
gpio_intr_enable(pin_); gpio_intr_enable(pin_);
if (!isr_service_installed_) { if (!isr_service_installed) {
gpio_install_isr_service(ESP_INTR_FLAG_LEVEL5); gpio_install_isr_service(ESP_INTR_FLAG_LEVEL5);
isr_service_installed_ = true; isr_service_installed = true;
} }
gpio_isr_handler_add(pin_, func, arg); gpio_isr_handler_add(pin_, func, arg);
} }
@ -87,7 +87,8 @@ class IDFInternalGPIOPin : public InternalGPIOPin {
bool inverted_; bool inverted_;
gpio_drive_cap_t drive_strength_; gpio_drive_cap_t drive_strength_;
gpio::Flags flags_; gpio::Flags flags_;
static bool isr_service_installed_; // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
static bool isr_service_installed;
}; };
} // namespace esp32 } // namespace esp32

2
esphome/components/esp32_ble/ble.h
View file

@ -19,6 +19,7 @@
namespace esphome { namespace esphome {
namespace esp32_ble { namespace esp32_ble {
// NOLINTNEXTLINE(modernize-use-using)
typedef struct { typedef struct {
void *peer_device; void *peer_device;
bool connected; bool connected;
@ -65,6 +66,7 @@ class ESP32BLE : public Component {
BLEAdvertising *advertising_; BLEAdvertising *advertising_;
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern ESP32BLE *global_ble; extern ESP32BLE *global_ble;
} // namespace esp32_ble } // namespace esp32_ble

26
esphome/components/esp32_ble/queue.h
View file

@ -28,33 +28,33 @@ namespace esp32_ble {
template<class T> class Queue { template<class T> class Queue {
public: public:
Queue() { m = xSemaphoreCreateMutex(); } Queue() { m_ = xSemaphoreCreateMutex(); }
void push(T *element) { void push(T *element) {
if (element == nullptr) if (element == nullptr)
return; return;
if (xSemaphoreTake(m, 5L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(m_, 5L / portTICK_PERIOD_MS)) {
q.push(element); q_.push(element);
xSemaphoreGive(m); xSemaphoreGive(m_);
} }
} }
T *pop() { T *pop() {
T *element = nullptr; T *element = nullptr;
if (xSemaphoreTake(m, 5L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(m_, 5L / portTICK_PERIOD_MS)) {
if (!q.empty()) { if (!q_.empty()) {
element = q.front(); element = q_.front();
q.pop(); q_.pop();
} }
xSemaphoreGive(m); xSemaphoreGive(m_);
} }
return element; return element;
} }
protected: protected:
std::queue<T *> q; std::queue<T *> q_;
SemaphoreHandle_t m; SemaphoreHandle_t m_;
}; };
// Received GAP, GATTC and GATTS events are only queued, and get processed in the main loop(). // Received GAP, GATTC and GATTS events are only queued, and get processed in the main loop().
@ -105,11 +105,13 @@ class BLEEvent {
}; };
union { union {
// NOLINTNEXTLINE(readability-identifier-naming)
struct gap_event { struct gap_event {
esp_gap_ble_cb_event_t gap_event; esp_gap_ble_cb_event_t gap_event;
esp_ble_gap_cb_param_t gap_param; esp_ble_gap_cb_param_t gap_param;
} gap; } gap;
// NOLINTNEXTLINE(readability-identifier-naming)
struct gattc_event { struct gattc_event {
esp_gattc_cb_event_t gattc_event; esp_gattc_cb_event_t gattc_event;
esp_gatt_if_t gattc_if; esp_gatt_if_t gattc_if;
@ -117,6 +119,7 @@ class BLEEvent {
uint8_t data[64]; uint8_t data[64];
} gattc; } gattc;
// NOLINTNEXTLINE(readability-identifier-naming)
struct gatts_event { struct gatts_event {
esp_gatts_cb_event_t gatts_event; esp_gatts_cb_event_t gatts_event;
esp_gatt_if_t gatts_if; esp_gatt_if_t gatts_if;
@ -124,6 +127,7 @@ class BLEEvent {
uint8_t data[64]; uint8_t data[64];
} gatts; } gatts;
} event_; } event_;
// NOLINTNEXTLINE(readability-identifier-naming)
enum ble_event_t : uint8_t { enum ble_event_t : uint8_t {
GAP, GAP,
GATTC, GATTC,

4
esphome/components/esp32_ble_beacon/esp32_ble_beacon.h
View file

@ -9,6 +9,7 @@
namespace esphome { namespace esphome {
namespace esp32_ble_beacon { namespace esp32_ble_beacon {
// NOLINTNEXTLINE(modernize-use-using)
typedef struct { typedef struct {
uint8_t flags[3]; uint8_t flags[3];
uint8_t length; uint8_t length;
@ -17,6 +18,7 @@ typedef struct {
uint16_t beacon_type; uint16_t beacon_type;
} __attribute__((packed)) esp_ble_ibeacon_head_t; } __attribute__((packed)) esp_ble_ibeacon_head_t;
// NOLINTNEXTLINE(modernize-use-using)
typedef struct { typedef struct {
uint8_t proximity_uuid[16]; uint8_t proximity_uuid[16];
uint16_t major; uint16_t major;
@ -24,6 +26,7 @@ typedef struct {
uint8_t measured_power; uint8_t measured_power;
} __attribute__((packed)) esp_ble_ibeacon_vendor_t; } __attribute__((packed)) esp_ble_ibeacon_vendor_t;
// NOLINTNEXTLINE(modernize-use-using)
typedef struct { typedef struct {
esp_ble_ibeacon_head_t ibeacon_head; esp_ble_ibeacon_head_t ibeacon_head;
esp_ble_ibeacon_vendor_t ibeacon_vendor; esp_ble_ibeacon_vendor_t ibeacon_vendor;
@ -50,6 +53,7 @@ class ESP32BLEBeacon : public Component {
uint16_t minor_{}; uint16_t minor_{};
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern ESP32BLEBeacon *global_esp32_ble_beacon; extern ESP32BLEBeacon *global_esp32_ble_beacon;
} // namespace esp32_ble_beacon } // namespace esp32_ble_beacon

4
esphome/components/esp32_ble_server/ble_characteristic.h
View file

@ -24,7 +24,7 @@ class BLEService;
class BLECharacteristic { class BLECharacteristic {
public: public:
BLECharacteristic(const ESPBTUUID uuid, uint32_t properties); BLECharacteristic(ESPBTUUID uuid, uint32_t properties);
void set_value(const uint8_t *data, size_t length); void set_value(const uint8_t *data, size_t length);
void set_value(std::vector<uint8_t> value); void set_value(std::vector<uint8_t> value);
@ -49,7 +49,7 @@ class BLECharacteristic {
void do_create(BLEService *service); void do_create(BLEService *service);
void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param); void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
void on_write(const std::function<void(const std::vector<uint8_t> &)> &&func) { this->on_write_ = std::move(func); } void on_write(const std::function<void(const std::vector<uint8_t> &)> &&func) { this->on_write_ = func; }
void add_descriptor(BLEDescriptor *descriptor); void add_descriptor(BLEDescriptor *descriptor);

1
esphome/components/esp32_ble_server/ble_server.h
View file

@ -87,6 +87,7 @@ class BLEServer : public Component {
} state_{INIT}; } state_{INIT};
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern BLEServer *global_ble_server; extern BLEServer *global_ble_server;
} // namespace esp32_ble_server } // namespace esp32_ble_server

38
esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp
View file

@ -50,29 +50,29 @@ void ESP32BLETracker::setup() {
return; return;
} }
global_esp32_ble_tracker->start_scan(true); global_esp32_ble_tracker->start_scan_(true);
} }
void ESP32BLETracker::loop() { void ESP32BLETracker::loop() {
BLEEvent *ble_event = this->ble_events_.pop(); BLEEvent *ble_event = this->ble_events_.pop();
while (ble_event != nullptr) { while (ble_event != nullptr) {
if (ble_event->type_) if (ble_event->type_)
this->real_gattc_event_handler(ble_event->event_.gattc.gattc_event, ble_event->event_.gattc.gattc_if, this->real_gattc_event_handler_(ble_event->event_.gattc.gattc_event, ble_event->event_.gattc.gattc_if,
&ble_event->event_.gattc.gattc_param); &ble_event->event_.gattc.gattc_param);
else else
this->real_gap_event_handler(ble_event->event_.gap.gap_event, &ble_event->event_.gap.gap_param); this->real_gap_event_handler_(ble_event->event_.gap.gap_event, &ble_event->event_.gap.gap_param);
delete ble_event; // NOLINT(cppcoreguidelines-owning-memory) delete ble_event; // NOLINT(cppcoreguidelines-owning-memory)
ble_event = this->ble_events_.pop(); ble_event = this->ble_events_.pop();
} }
bool connecting = false; bool connecting = false;
for (auto *client : this->clients_) { for (auto *client : this->clients_) {
if (client->state() == ClientState::Connecting || client->state() == ClientState::Discovered) if (client->state() == ClientState::CONNECTING || client->state() == ClientState::DISCOVERED)
connecting = true; connecting = true;
} }
if (!connecting && xSemaphoreTake(this->scan_end_lock_, 0L)) { if (!connecting && xSemaphoreTake(this->scan_end_lock_, 0L)) {
xSemaphoreGive(this->scan_end_lock_); xSemaphoreGive(this->scan_end_lock_);
global_esp32_ble_tracker->start_scan(false); global_esp32_ble_tracker->start_scan_(false);
} }
if (xSemaphoreTake(this->scan_result_lock_, 5L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(this->scan_result_lock_, 5L / portTICK_PERIOD_MS)) {
@ -94,7 +94,7 @@ void ESP32BLETracker::loop() {
for (auto *client : this->clients_) for (auto *client : this->clients_)
if (client->parse_device(device)) { if (client->parse_device(device)) {
found = true; found = true;
if (client->state() == ClientState::Discovered) { if (client->state() == ClientState::DISCOVERED) {
esp_ble_gap_stop_scanning(); esp_ble_gap_stop_scanning();
if (xSemaphoreTake(this->scan_end_lock_, 10L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(this->scan_end_lock_, 10L / portTICK_PERIOD_MS)) {
xSemaphoreGive(this->scan_end_lock_); xSemaphoreGive(this->scan_end_lock_);
@ -196,7 +196,7 @@ bool ESP32BLETracker::ble_setup() {
return true; return true;
} }
void ESP32BLETracker::start_scan(bool first) { void ESP32BLETracker::start_scan_(bool first) {
if (!xSemaphoreTake(this->scan_end_lock_, 0L)) { if (!xSemaphoreTake(this->scan_end_lock_, 0L)) {
ESP_LOGW(TAG, "Cannot start scan!"); ESP_LOGW(TAG, "Cannot start scan!");
return; return;
@ -233,38 +233,38 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
global_esp32_ble_tracker->ble_events_.push(gap_event); global_esp32_ble_tracker->ble_events_.push(gap_event);
} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks) } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
void ESP32BLETracker::real_gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) { void ESP32BLETracker::real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
switch (event) { switch (event) {
case ESP_GAP_BLE_SCAN_RESULT_EVT: case ESP_GAP_BLE_SCAN_RESULT_EVT:
global_esp32_ble_tracker->gap_scan_result(param->scan_rst); global_esp32_ble_tracker->gap_scan_result_(param->scan_rst);
break; break;
case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT: case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
global_esp32_ble_tracker->gap_scan_set_param_complete(param->scan_param_cmpl); global_esp32_ble_tracker->gap_scan_set_param_complete_(param->scan_param_cmpl);
break; break;
case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT: case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
global_esp32_ble_tracker->gap_scan_start_complete(param->scan_start_cmpl); global_esp32_ble_tracker->gap_scan_start_complete_(param->scan_start_cmpl);
break; break;
case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT: case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
global_esp32_ble_tracker->gap_scan_stop_complete(param->scan_stop_cmpl); global_esp32_ble_tracker->gap_scan_stop_complete_(param->scan_stop_cmpl);
break; break;
default: default:
break; break;
} }
} }
void ESP32BLETracker::gap_scan_set_param_complete(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) { void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
this->scan_set_param_failed_ = param.status; this->scan_set_param_failed_ = param.status;
} }
void ESP32BLETracker::gap_scan_start_complete(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) { void ESP32BLETracker::gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) {
this->scan_start_failed_ = param.status; this->scan_start_failed_ = param.status;
} }
void ESP32BLETracker::gap_scan_stop_complete(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param) { void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param) {
xSemaphoreGive(this->scan_end_lock_); xSemaphoreGive(this->scan_end_lock_);
} }
void ESP32BLETracker::gap_scan_result(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) { void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) { if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
if (xSemaphoreTake(this->scan_result_lock_, 0L)) { if (xSemaphoreTake(this->scan_result_lock_, 0L)) {
if (this->scan_result_index_ < 16) { if (this->scan_result_index_ < 16) {
@ -283,8 +283,8 @@ void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_i
global_esp32_ble_tracker->ble_events_.push(gattc_event); global_esp32_ble_tracker->ble_events_.push(gattc_event);
} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks) } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
void ESP32BLETracker::real_gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, void ESP32BLETracker::real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
esp_ble_gattc_cb_param_t *param) { esp_ble_gattc_cb_param_t *param) {
for (auto *client : global_esp32_ble_tracker->clients_) { for (auto *client : global_esp32_ble_tracker->clients_) {
client->gattc_event_handler(event, gattc_if, param); client->gattc_event_handler(event, gattc_if, param);
} }

25
esphome/components/esp32_ble_tracker/esp32_ble_tracker.h
View file

@ -135,15 +135,15 @@ class ESPBTDeviceListener {
enum class ClientState { enum class ClientState {
// Connection is idle, no device detected. // Connection is idle, no device detected.
Idle, IDLE,
// Device advertisement found. // Device advertisement found.
Discovered, DISCOVERED,
// Connection in progress. // Connection in progress.
Connecting, CONNECTING,
// Initial connection established. // Initial connection established.
Connected, CONNECTED,
// The client and sub-clients have completed setup. // The client and sub-clients have completed setup.
Established, ESTABLISHED,
}; };
class ESPBTClient : public ESPBTDeviceListener { class ESPBTClient : public ESPBTDeviceListener {
@ -185,23 +185,23 @@ class ESP32BLETracker : public Component {
/// The FreeRTOS task managing the bluetooth interface. /// The FreeRTOS task managing the bluetooth interface.
static bool ble_setup(); static bool ble_setup();
/// Start a single scan by setting up the parameters and doing some esp-idf calls. /// Start a single scan by setting up the parameters and doing some esp-idf calls.
void start_scan(bool first); void start_scan_(bool first);
/// Callback that will handle all GAP events and redistribute them to other callbacks. /// Callback that will handle all GAP events and redistribute them to other callbacks.
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param); static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
void real_gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param); void real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
/// Called when a `ESP_GAP_BLE_SCAN_RESULT_EVT` event is received. /// Called when a `ESP_GAP_BLE_SCAN_RESULT_EVT` event is received.
void gap_scan_result(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param); void gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param);
/// Called when a `ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT` event is received. /// Called when a `ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT` event is received.
void gap_scan_set_param_complete(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param); void gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param);
/// Called when a `ESP_GAP_BLE_SCAN_START_COMPLETE_EVT` event is received. /// Called when a `ESP_GAP_BLE_SCAN_START_COMPLETE_EVT` event is received.
void gap_scan_start_complete(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param); void gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param);
/// Called when a `ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT` event is received. /// Called when a `ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT` event is received.
void gap_scan_stop_complete(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param); void gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param);
int app_id_; int app_id_;
/// Callback that will handle all GATTC events and redistribute them to other callbacks. /// Callback that will handle all GATTC events and redistribute them to other callbacks.
static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param); static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
void real_gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param); void real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
/// Vector of addresses that have already been printed in print_bt_device_info /// Vector of addresses that have already been printed in print_bt_device_info
std::vector<uint64_t> already_discovered_; std::vector<uint64_t> already_discovered_;
@ -225,6 +225,7 @@ class ESP32BLETracker : public Component {
Queue<BLEEvent> ble_events_; Queue<BLEEvent> ble_events_;
}; };
// NOLINTNEXTLINE
extern ESP32BLETracker *global_esp32_ble_tracker; extern ESP32BLETracker *global_esp32_ble_tracker;
} // namespace esp32_ble_tracker } // namespace esp32_ble_tracker

26
esphome/components/esp32_ble_tracker/queue.h
View file

@ -26,33 +26,33 @@ namespace esp32_ble_tracker {
template<class T> class Queue { template<class T> class Queue {
public: public:
Queue() { m = xSemaphoreCreateMutex(); } Queue() { m_ = xSemaphoreCreateMutex(); }
void push(T *element) { void push(T *element) {
if (element == nullptr) if (element == nullptr)
return; return;
if (xSemaphoreTake(m, 5L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(m_, 5L / portTICK_PERIOD_MS)) {
q.push(element); q_.push(element);
xSemaphoreGive(m); xSemaphoreGive(m_);
} }
} }
T *pop() { T *pop() {
T *element = nullptr; T *element = nullptr;
if (xSemaphoreTake(m, 5L / portTICK_PERIOD_MS)) { if (xSemaphoreTake(m_, 5L / portTICK_PERIOD_MS)) {
if (!q.empty()) { if (!q_.empty()) {
element = q.front(); element = q_.front();
q.pop(); q_.pop();
} }
xSemaphoreGive(m); xSemaphoreGive(m_);
} }
return element; return element;
} }
protected: protected:
std::queue<T *> q; std::queue<T *> q_;
SemaphoreHandle_t m; SemaphoreHandle_t m_;
}; };
// Received GAP and GATTC events are only queued, and get processed in the main loop(). // Received GAP and GATTC events are only queued, and get processed in the main loop().
@ -87,12 +87,12 @@ class BLEEvent {
}; };
union { union {
struct gap_event { struct gap_event { // NOLINT(readability-identifier-naming)
esp_gap_ble_cb_event_t gap_event; esp_gap_ble_cb_event_t gap_event;
esp_ble_gap_cb_param_t gap_param; esp_ble_gap_cb_param_t gap_param;
} gap; } gap;
struct gattc_event { struct gattc_event { // NOLINT(readability-identifier-naming)
esp_gattc_cb_event_t gattc_event; esp_gattc_cb_event_t gattc_event;
esp_gatt_if_t gattc_if; esp_gatt_if_t gattc_if;
esp_ble_gattc_cb_param_t gattc_param; esp_ble_gattc_cb_param_t gattc_param;

1
esphome/components/esp32_camera/esp32_camera.h
View file

@ -106,6 +106,7 @@ class ESP32Camera : public Component, public Nameable {
uint32_t last_update_{0}; uint32_t last_update_{0};
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern ESP32Camera *global_esp32_camera; extern ESP32Camera *global_esp32_camera;
} // namespace esp32_camera } // namespace esp32_camera

4
esphome/components/esp32_improv/esp32_improv_component.cpp
View file

@ -126,7 +126,7 @@ void ESP32ImprovComponent::loop() {
std::string url = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome"; std::string url = "https://my.home-assistant.io/redirect/config_flow_start?domain=esphome";
std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, {url}); std::vector<uint8_t> data = improv::build_rpc_response(improv::WIFI_SETTINGS, {url});
this->send_response(data); this->send_response_(data);
this->set_timeout("end-service", 1000, [this] { this->set_timeout("end-service", 1000, [this] {
this->service_->stop(); this->service_->stop();
this->set_state_(improv::STATE_STOPPED); this->set_state_(improv::STATE_STOPPED);
@ -181,7 +181,7 @@ void ESP32ImprovComponent::set_error_(improv::Error error) {
} }
} }
void ESP32ImprovComponent::send_response(std::vector<uint8_t> &response) { void ESP32ImprovComponent::send_response_(std::vector<uint8_t> &response) {
this->rpc_response_->set_value(response); this->rpc_response_->set_value(response);
if (this->state_ != improv::STATE_STOPPED) if (this->state_ != improv::STATE_STOPPED)
this->rpc_response_->notify(); this->rpc_response_->notify();

3
esphome/components/esp32_improv/esp32_improv_component.h
View file

@ -63,12 +63,13 @@ class ESP32ImprovComponent : public Component, public BLEServiceComponent {
void set_state_(improv::State state); void set_state_(improv::State state);
void set_error_(improv::Error error); void set_error_(improv::Error error);
void send_response(std::vector<uint8_t> &response); void send_response_(std::vector<uint8_t> &response);
void process_incoming_data_(); void process_incoming_data_();
void on_wifi_connect_timeout_(); void on_wifi_connect_timeout_();
bool check_identify_(); bool check_identify_();
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern ESP32ImprovComponent *global_improv_component; extern ESP32ImprovComponent *global_improv_component;
} // namespace esp32_improv } // namespace esp32_improv

2
esphome/components/esp8266/gpio.cpp
View file

@ -20,7 +20,7 @@ ISRInternalGPIOPin ESP8266GPIOPin::to_isr() const {
return ISRInternalGPIOPin((void *) arg); return ISRInternalGPIOPin((void *) arg);
} }
void ESP8266GPIOPin::attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const { void ESP8266GPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const {
uint8_t arduino_mode = 0; uint8_t arduino_mode = 0;
switch (type) { switch (type) {
case gpio::INTERRUPT_RISING_EDGE: case gpio::INTERRUPT_RISING_EDGE:

2
esphome/components/esp8266/gpio.h
View file

@ -25,7 +25,7 @@ class ESP8266GPIOPin : public InternalGPIOPin {
bool is_inverted() const override { return inverted_; } bool is_inverted() const override { return inverted_; }
protected: protected:
void attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const override; void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
uint8_t pin_; uint8_t pin_;
bool inverted_; bool inverted_;

28
esphome/components/ethernet/ethernet_component.cpp
View file

@ -45,11 +45,11 @@ void EthernetComponent::setup() {
switch (this->type_) { switch (this->type_) {
case ETHERNET_TYPE_LAN8720: { case ETHERNET_TYPE_LAN8720: {
memcpy(&this->eth_config, &phy_lan8720_default_ethernet_config, sizeof(eth_config_t)); memcpy(&this->eth_config_, &phy_lan8720_default_ethernet_config, sizeof(eth_config_t));
break; break;
} }
case ETHERNET_TYPE_TLK110: { case ETHERNET_TYPE_TLK110: {
memcpy(&this->eth_config, &phy_tlk110_default_ethernet_config, sizeof(eth_config_t)); memcpy(&this->eth_config_, &phy_tlk110_default_ethernet_config, sizeof(eth_config_t));
break; break;
} }
default: { default: {
@ -58,20 +58,20 @@ void EthernetComponent::setup() {
} }
} }
this->eth_config.phy_addr = static_cast<eth_phy_base_t>(this->phy_addr_); this->eth_config_.phy_addr = static_cast<eth_phy_base_t>(this->phy_addr_);
this->eth_config.clock_mode = this->clk_mode_; this->eth_config_.clock_mode = this->clk_mode_;
this->eth_config.gpio_config = EthernetComponent::eth_phy_config_gpio_; this->eth_config_.gpio_config = EthernetComponent::eth_phy_config_gpio;
this->eth_config.tcpip_input = tcpip_adapter_eth_input; this->eth_config_.tcpip_input = tcpip_adapter_eth_input;
if (this->power_pin_ != nullptr) { if (this->power_pin_ != nullptr) {
this->orig_power_enable_fun_ = this->eth_config.phy_power_enable; this->orig_power_enable_fun_ = this->eth_config_.phy_power_enable;
this->eth_config.phy_power_enable = EthernetComponent::eth_phy_power_enable_; this->eth_config_.phy_power_enable = EthernetComponent::eth_phy_power_enable;
} }
tcpipInit(); tcpipInit();
esp_err_t err; esp_err_t err;
err = esp_eth_init(&this->eth_config); err = esp_eth_init(&this->eth_config_);
ESPHL_ERROR_CHECK(err, "ETH init error"); ESPHL_ERROR_CHECK(err, "ETH init error");
err = esp_eth_enable(); err = esp_eth_enable();
ESPHL_ERROR_CHECK(err, "ETH enable error"); ESPHL_ERROR_CHECK(err, "ETH enable error");
@ -209,11 +209,11 @@ void EthernetComponent::start_connect_() {
this->connect_begin_ = millis(); this->connect_begin_ = millis();
this->status_set_warning(); this->status_set_warning();
} }
void EthernetComponent::eth_phy_config_gpio_() { void EthernetComponent::eth_phy_config_gpio() {
phy_rmii_configure_data_interface_pins(); phy_rmii_configure_data_interface_pins();
phy_rmii_smi_configure_pins(global_eth_component->mdc_pin_, global_eth_component->mdio_pin_); phy_rmii_smi_configure_pins(global_eth_component->mdc_pin_, global_eth_component->mdio_pin_);
} }
void EthernetComponent::eth_phy_power_enable_(bool enable) { void EthernetComponent::eth_phy_power_enable(bool enable) {
global_eth_component->power_pin_->digital_write(enable); global_eth_component->power_pin_->digital_write(enable);
// power up takes some time, datasheet says max 300µs // power up takes some time, datasheet says max 300µs
delay(1); delay(1);
@ -242,9 +242,9 @@ void EthernetComponent::dump_connect_params_() {
uint8_t mac[6]; uint8_t mac[6];
esp_eth_get_mac(mac); esp_eth_get_mac(mac);
ESP_LOGCONFIG(TAG, " MAC Address: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); ESP_LOGCONFIG(TAG, " MAC Address: %02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
ESP_LOGCONFIG(TAG, " Is Full Duplex: %s", YESNO(this->eth_config.phy_get_duplex_mode())); ESP_LOGCONFIG(TAG, " Is Full Duplex: %s", YESNO(this->eth_config_.phy_get_duplex_mode()));
ESP_LOGCONFIG(TAG, " Link Up: %s", YESNO(this->eth_config.phy_check_link())); ESP_LOGCONFIG(TAG, " Link Up: %s", YESNO(this->eth_config_.phy_check_link()));
ESP_LOGCONFIG(TAG, " Link Speed: %u", this->eth_config.phy_get_speed_mode() ? 100 : 10); ESP_LOGCONFIG(TAG, " Link Speed: %u", this->eth_config_.phy_get_speed_mode() ? 100 : 10);
} }
void EthernetComponent::set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_addr; } void EthernetComponent::set_phy_addr(uint8_t phy_addr) { this->phy_addr_ = phy_addr; }
void EthernetComponent::set_power_pin(GPIOPin *power_pin) { this->power_pin_ = power_pin; } void EthernetComponent::set_power_pin(GPIOPin *power_pin) { this->power_pin_ = power_pin; }

7
esphome/components/ethernet/ethernet_component.h
View file

@ -60,8 +60,8 @@ class EthernetComponent : public Component {
void start_connect_(); void start_connect_();
void dump_connect_params_(); void dump_connect_params_();
static void eth_phy_config_gpio_(); static void eth_phy_config_gpio();
static void eth_phy_power_enable_(bool enable); static void eth_phy_power_enable(bool enable);
std::string use_address_; std::string use_address_;
uint8_t phy_addr_{0}; uint8_t phy_addr_{0};
@ -76,10 +76,11 @@ class EthernetComponent : public Component {
bool connected_{false}; bool connected_{false};
EthernetComponentState state_{EthernetComponentState::STOPPED}; EthernetComponentState state_{EthernetComponentState::STOPPED};
uint32_t connect_begin_; uint32_t connect_begin_;
eth_config_t eth_config; eth_config_t eth_config_;
eth_phy_power_enable_func orig_power_enable_fun_; eth_phy_power_enable_func orig_power_enable_fun_;
}; };
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern EthernetComponent *global_eth_component; extern EthernetComponent *global_eth_component;
} // namespace ethernet } // namespace ethernet

104
esphome/components/fastled_base/fastled_light.h
View file

@ -44,33 +44,33 @@ class FastLEDLightOutput : public light::AddressableLight {
CLEDController &add_leds(int num_leds) { CLEDController &add_leds(int num_leds) {
switch (CHIPSET) { switch (CHIPSET) {
case LPD8806: { case LPD8806: {
static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2801: { case WS2801: {
static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2803: { case WS2803: {
static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SM16716: { case SM16716: {
static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case P9813: { case P9813: {
static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case DOTSTAR: case DOTSTAR:
case APA102: { case APA102: {
static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SK9822: { case SK9822: {
static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> CONTROLLER; static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
} }
} }
@ -78,33 +78,33 @@ class FastLEDLightOutput : public light::AddressableLight {
template<ESPIChipsets CHIPSET, uint8_t DATA_PIN, uint8_t CLOCK_PIN> CLEDController &add_leds(int num_leds) { template<ESPIChipsets CHIPSET, uint8_t DATA_PIN, uint8_t CLOCK_PIN> CLEDController &add_leds(int num_leds) {
switch (CHIPSET) { switch (CHIPSET) {
case LPD8806: { case LPD8806: {
static LPD8806Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static LPD8806Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2801: { case WS2801: {
static WS2801Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static WS2801Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2803: { case WS2803: {
static WS2803Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static WS2803Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SM16716: { case SM16716: {
static SM16716Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static SM16716Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case P9813: { case P9813: {
static P9813Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static P9813Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case DOTSTAR: case DOTSTAR:
case APA102: { case APA102: {
static APA102Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static APA102Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SK9822: { case SK9822: {
static SK9822Controller<DATA_PIN, CLOCK_PIN> CONTROLLER; static SK9822Controller<DATA_PIN, CLOCK_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
} }
} }
@ -113,33 +113,33 @@ class FastLEDLightOutput : public light::AddressableLight {
CLEDController &add_leds(int num_leds) { CLEDController &add_leds(int num_leds) {
switch (CHIPSET) { switch (CHIPSET) {
case LPD8806: { case LPD8806: {
static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2801: { case WS2801: {
static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case WS2803: { case WS2803: {
static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SM16716: { case SM16716: {
static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case P9813: { case P9813: {
static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case DOTSTAR: case DOTSTAR:
case APA102: { case APA102: {
static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
case SK9822: { case SK9822: {
static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> CONTROLLER; static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
} }
} }
@ -147,30 +147,30 @@ class FastLEDLightOutput : public light::AddressableLight {
#ifdef FASTLED_HAS_CLOCKLESS #ifdef FASTLED_HAS_CLOCKLESS
template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER> template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER>
CLEDController &add_leds(int num_leds) { CLEDController &add_leds(int num_leds) {
static CHIPSET<DATA_PIN, RGB_ORDER> CONTROLLER; static CHIPSET<DATA_PIN, RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN> template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN>
CLEDController &add_leds(int num_leds) { CLEDController &add_leds(int num_leds) {
static CHIPSET<DATA_PIN, RGB> CONTROLLER; static CHIPSET<DATA_PIN, RGB> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
template<template<uint8_t DATA_PIN> class CHIPSET, uint8_t DATA_PIN> CLEDController &add_leds(int num_leds) { template<template<uint8_t DATA_PIN> class CHIPSET, uint8_t DATA_PIN> CLEDController &add_leds(int num_leds) {
static CHIPSET<DATA_PIN> CONTROLLER; static CHIPSET<DATA_PIN> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
#endif #endif
template<template<EOrder RGB_ORDER> class CHIPSET, EOrder RGB_ORDER> CLEDController &add_leds(int num_leds) { template<template<EOrder RGB_ORDER> class CHIPSET, EOrder RGB_ORDER> CLEDController &add_leds(int num_leds) {
static CHIPSET<RGB_ORDER> CONTROLLER; static CHIPSET<RGB_ORDER> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
template<template<EOrder RGB_ORDER> class CHIPSET> CLEDController &add_leds(int num_leds) { template<template<EOrder RGB_ORDER> class CHIPSET> CLEDController &add_leds(int num_leds) {
static CHIPSET<RGB> CONTROLLER; static CHIPSET<RGB> controller;
return add_leds(&CONTROLLER, num_leds); return add_leds(&controller, num_leds);
} }
#ifdef FASTLED_HAS_BLOCKLESS #ifdef FASTLED_HAS_BLOCKLESS

73
esphome/components/graph/graph.cpp
View file

@ -185,7 +185,7 @@ void GraphLegend::init(Graph *g) {
for (auto *trace : g->traces_) { for (auto *trace : g->traces_) {
std::string txtstr = trace->get_name(); std::string txtstr = trace->get_name();
int fw, fos, fbl, fh; int fw, fos, fbl, fh;
this->font_label->measure(txtstr.c_str(), &fw, &fos, &fbl, &fh); this->font_label_->measure(txtstr.c_str(), &fw, &fos, &fbl, &fh);
if (fw > txtw) if (fw > txtw)
txtw = fw; txtw = fw;
if (fh > txth) if (fh > txth)
@ -201,7 +201,7 @@ void GraphLegend::init(Graph *g) {
if (this->units_) { if (this->units_) {
valstr += trace->sensor_->get_unit_of_measurement(); valstr += trace->sensor_->get_unit_of_measurement();
} }
this->font_value->measure(valstr.c_str(), &fw, &fos, &fbl, &fh); this->font_value_->measure(valstr.c_str(), &fw, &fos, &fbl, &fh);
if (fw > valw) if (fw > valw)
valw = fw; valw = fw;
if (fh > valh) if (fh > valh)
@ -218,11 +218,11 @@ void GraphLegend::init(Graph *g) {
uint16_t h = this->height_; uint16_t h = this->height_;
DirectionType dir = this->direction_; DirectionType dir = this->direction_;
ValuePositionType valpos = this->values_; ValuePositionType valpos = this->values_;
if (!this->font_value) { if (!this->font_value_) {
valpos = VALUE_POSITION_TYPE_NONE; valpos = VALUE_POSITION_TYPE_NONE;
} }
// Line sample always goes below text for compactness // Line sample always goes below text for compactness
this->yl = txth + (txth / 4) + lt / 2; this->yl_ = txth + (txth / 4) + lt / 2;
if (dir == DIRECTION_TYPE_AUTO) { if (dir == DIRECTION_TYPE_AUTO) {
dir = DIRECTION_TYPE_HORIZONTAL; // as default dir = DIRECTION_TYPE_HORIZONTAL; // as default
@ -237,62 +237,62 @@ void GraphLegend::init(Graph *g) {
} }
if (valpos == VALUE_POSITION_TYPE_BELOW) { if (valpos == VALUE_POSITION_TYPE_BELOW) {
this->yv = txth + (txth / 4); this->yv_ = txth + (txth / 4);
if (this->lines_) if (this->lines_)
this->yv += txth / 4 + lt; this->yv_ += txth / 4 + lt;
} else if (valpos == VALUE_POSITION_TYPE_BESIDE) { } else if (valpos == VALUE_POSITION_TYPE_BESIDE) {
this->xv = (txtw + valw) / 2; this->xv_ = (txtw + valw) / 2;
} }
// If width or height is specified we divide evenly within, else we do tight-fit // If width or height is specified we divide evenly within, else we do tight-fit
if (w == 0) { if (w == 0) {
this->x0 = txtw / 2; this->x0_ = txtw / 2;
this->xs = txtw; this->xs_ = txtw;
if (valpos == VALUE_POSITION_TYPE_BELOW) { if (valpos == VALUE_POSITION_TYPE_BELOW) {
this->xs = std::max(txtw, valw); this->xs_ = std::max(txtw, valw);
; ;
this->x0 = this->xs / 2; this->x0_ = this->xs_ / 2;
} else if (valpos == VALUE_POSITION_TYPE_BESIDE) { } else if (valpos == VALUE_POSITION_TYPE_BESIDE) {
this->xs = txtw + valw; this->xs_ = txtw + valw;
} }
if (dir == DIRECTION_TYPE_VERTICAL) { if (dir == DIRECTION_TYPE_VERTICAL) {
this->width_ = this->xs; this->width_ = this->xs_;
} else { } else {
this->width_ = this->xs * n; this->width_ = this->xs_ * n;
} }
} else { } else {
this->xs = w / n; this->xs_ = w / n;
this->x0 = this->xs / 2; this->x0_ = this->xs_ / 2;
} }
if (h == 0) { if (h == 0) {
this->ys = txth; this->ys_ = txth;
if (valpos == VALUE_POSITION_TYPE_BELOW) { if (valpos == VALUE_POSITION_TYPE_BELOW) {
this->ys = txth + txth / 2 + valh; this->ys_ = txth + txth / 2 + valh;
if (this->lines_) { if (this->lines_) {
this->ys += lt; this->ys_ += lt;
} }
} else if (valpos == VALUE_POSITION_TYPE_BESIDE) { } else if (valpos == VALUE_POSITION_TYPE_BESIDE) {
if (this->lines_) { if (this->lines_) {
this->ys = std::max(txth + txth / 4 + lt + txth / 4, valh + valh / 4); this->ys_ = std::max(txth + txth / 4 + lt + txth / 4, valh + valh / 4);
} else { } else {
this->ys = std::max(txth + txth / 4, valh + valh / 4); this->ys_ = std::max(txth + txth / 4, valh + valh / 4);
} }
this->height_ = this->ys * n; this->height_ = this->ys_ * n;
} }
if (dir == DIRECTION_TYPE_HORIZONTAL) { if (dir == DIRECTION_TYPE_HORIZONTAL) {
this->height_ = this->ys; this->height_ = this->ys_;
} else { } else {
this->height_ = this->ys * n; this->height_ = this->ys_ * n;
} }
} else { } else {
this->ys = h / n; this->ys_ = h / n;
} }
if (dir == DIRECTION_TYPE_HORIZONTAL) { if (dir == DIRECTION_TYPE_HORIZONTAL) {
this->ys = 0; this->ys_ = 0;
} else { } else {
this->xs = 0; this->xs_ = 0;
} }
} }
@ -310,38 +310,39 @@ void Graph::draw_legend(display::DisplayBuffer *buff, uint16_t x_offset, uint16_
buff->vertical_line(x_offset + w - 1, y_offset, h, color); buff->vertical_line(x_offset + w - 1, y_offset, h, color);
} }
int x = x_offset + legend_->x0; int x = x_offset + legend_->x0_;
int y = y_offset; int y = y_offset;
for (auto *trace : traces_) { for (auto *trace : traces_) {
std::string txtstr = trace->get_name(); std::string txtstr = trace->get_name();
ESP_LOGV(TAG, " %s", txtstr.c_str()); ESP_LOGV(TAG, " %s", txtstr.c_str());
buff->printf(x, y, legend_->font_label, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", txtstr.c_str()); buff->printf(x, y, legend_->font_label_, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", txtstr.c_str());
if (legend_->lines_) { if (legend_->lines_) {
uint16_t thick = trace->get_line_thickness(); uint16_t thick = trace->get_line_thickness();
for (int16_t i = 0; i < legend_->x0 * 4 / 3; i++) { for (int16_t i = 0; i < legend_->x0_ * 4 / 3; i++) {
uint8_t b = (i % (thick * LineType::PATTERN_LENGTH)) / thick; uint8_t b = (i % (thick * LineType::PATTERN_LENGTH)) / thick;
if (((uint8_t) trace->get_line_type() & (1 << b)) == (1 << b)) { if (((uint8_t) trace->get_line_type() & (1 << b)) == (1 << b)) {
buff->vertical_line(x - legend_->x0 * 2 / 3 + i, y + legend_->yl - thick / 2, thick, trace->get_line_color()); buff->vertical_line(x - legend_->x0_ * 2 / 3 + i, y + legend_->yl_ - thick / 2, thick,
trace->get_line_color());
} }
} }
} }
if (legend_->values_ != VALUE_POSITION_TYPE_NONE) { if (legend_->values_ != VALUE_POSITION_TYPE_NONE) {
int xv = x + legend_->xv; int xv = x + legend_->xv_;
int yv = y + legend_->yv; int yv = y + legend_->yv_;
std::stringstream ss; std::stringstream ss;
ss << std::fixed << std::setprecision(trace->sensor_->get_accuracy_decimals()) << trace->sensor_->get_state(); ss << std::fixed << std::setprecision(trace->sensor_->get_accuracy_decimals()) << trace->sensor_->get_state();
std::string valstr = ss.str(); std::string valstr = ss.str();
if (legend_->units_) { if (legend_->units_) {
valstr += trace->sensor_->get_unit_of_measurement(); valstr += trace->sensor_->get_unit_of_measurement();
} }
buff->printf(xv, yv, legend_->font_value, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", valstr.c_str()); buff->printf(xv, yv, legend_->font_value_, trace->get_line_color(), TextAlign::TOP_CENTER, "%s", valstr.c_str());
ESP_LOGV(TAG, " value: %s", valstr.c_str()); ESP_LOGV(TAG, " value: %s", valstr.c_str());
} }
x += legend_->xs; x += legend_->xs_;
y += legend_->ys; y += legend_->ys_;
} }
} }

29
esphome/components/graph/graph.h
View file

@ -1,8 +1,9 @@
#pragma once #pragma once
#include <cstdint> #include "esphome/components/sensor/sensor.h"
#include "esphome/core/color.h" #include "esphome/core/color.h"
#include "esphome/core/component.h" #include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h" #include <cstdint>
#include <utility>
namespace esphome { namespace esphome {
@ -43,8 +44,8 @@ enum ValuePositionType {
class GraphLegend { class GraphLegend {
public: public:
void init(Graph *g); void init(Graph *g);
void set_name_font(display::Font *font) { this->font_label = font; } void set_name_font(display::Font *font) { this->font_label_ = font; }
void set_value_font(display::Font *font) { this->font_value = font; } void set_value_font(display::Font *font) { this->font_value_ = font; }
void set_width(uint32_t width) { this->width_ = width; } void set_width(uint32_t width) { this->width_ = width; }
void set_height(uint32_t height) { this->height_ = height; } void set_height(uint32_t height) { this->height_ = height; }
void set_border(bool val) { this->border_ = val; } void set_border(bool val) { this->border_ = val; }
@ -61,8 +62,8 @@ class GraphLegend {
ValuePositionType values_{VALUE_POSITION_TYPE_AUTO}; ValuePositionType values_{VALUE_POSITION_TYPE_AUTO};
bool units_{true}; bool units_{true};
DirectionType direction_{DIRECTION_TYPE_AUTO}; DirectionType direction_{DIRECTION_TYPE_AUTO};
display::Font *font_label{nullptr}; display::Font *font_label_{nullptr};
display::Font *font_value{nullptr}; display::Font *font_value_{nullptr};
// Calculated values // Calculated values
Graph *parent_{nullptr}; Graph *parent_{nullptr};
// (x0) (xs,ys) (xs,ys) // (x0) (xs,ys) (xs,ys)
@ -72,12 +73,12 @@ class GraphLegend {
// (0,yl)| \-> VALUE1+units // (0,yl)| \-> VALUE1+units
// v (top_center) // v (top_center)
// LINE_SAMPLE // LINE_SAMPLE
int x0{0}; // X-offset to centre of label text int x0_{0}; // X-offset to centre of label text
int xs{0}; // X spacing between labels int xs_{0}; // X spacing between labels
int ys{0}; // Y spacing between labels int ys_{0}; // Y spacing between labels
int yl{0}; // Y spacing from label to line sample int yl_{0}; // Y spacing from label to line sample
int xv{0}; // X distance between label to value text int xv_{0}; // X distance between label to value text
int yv{0}; // Y distance between label to value text int yv_{0}; // Y distance between label to value text
friend Graph; friend Graph;
}; };
@ -106,7 +107,7 @@ class HistoryData {
class GraphTrace { class GraphTrace {
public: public:
void init(Graph *g); void init(Graph *g);
void set_name(std::string name) { name_ = name; } void set_name(std::string name) { name_ = std::move(name); }
void set_sensor(sensor::Sensor *sensor) { sensor_ = sensor; } void set_sensor(sensor::Sensor *sensor) { sensor_ = sensor; }
uint8_t get_line_thickness() { return this->line_thickness_; } uint8_t get_line_thickness() { return this->line_thickness_; }
void set_line_thickness(uint8_t val) { this->line_thickness_ = val; } void set_line_thickness(uint8_t val) { this->line_thickness_ = val; }
@ -114,7 +115,7 @@ class GraphTrace {
void set_line_type(enum LineType val) { this->line_type_ = val; } void set_line_type(enum LineType val) { this->line_type_ = val; }
Color get_line_color() { return this->line_color_; } Color get_line_color() { return this->line_color_; }
void set_line_color(Color val) { this->line_color_ = val; } void set_line_color(Color val) { this->line_color_ = val; }
const std::string get_name(void) { return name_; } const std::string get_name() { return name_; }
const HistoryData *get_tracedata() { return &data_; } const HistoryData *get_tracedata() { return &data_; }
protected: protected:

4
esphome/components/i2c/i2c_bus_arduino.cpp
View file

@ -11,7 +11,7 @@ namespace i2c {
static const char *const TAG = "i2c.arduino"; static const char *const TAG = "i2c.arduino";
void ArduinoI2CBus::setup() { void ArduinoI2CBus::setup() {
recover(); recover_();
#ifdef USE_ESP32 #ifdef USE_ESP32
static uint8_t next_bus_num = 0; static uint8_t next_bus_num = 0;
if (next_bus_num == 0) if (next_bus_num == 0)
@ -92,7 +92,7 @@ ErrorCode ArduinoI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cn
return ERROR_UNKNOWN; return ERROR_UNKNOWN;
} }
void ArduinoI2CBus::recover() { void ArduinoI2CBus::recover_() {
// Perform I2C bus recovery, see // Perform I2C bus recovery, see
// https://www.analog.com/media/en/technical-documentation/application-notes/54305147357414AN686_0.pdf // https://www.analog.com/media/en/technical-documentation/application-notes/54305147357414AN686_0.pdf
// or see the linux kernel implementation, e.g. // or see the linux kernel implementation, e.g.

2
esphome/components/i2c/i2c_bus_arduino.h
View file

@ -23,7 +23,7 @@ class ArduinoI2CBus : public I2CBus, public Component {
void set_frequency(uint32_t frequency) { frequency_ = frequency; } void set_frequency(uint32_t frequency) { frequency_ = frequency; }
private: private:
void recover(); void recover_();
protected: protected:
TwoWire *wire_; TwoWire *wire_;

4
esphome/components/i2c/i2c_bus_esp_idf.cpp
View file

@ -14,7 +14,7 @@ void IDFI2CBus::setup() {
static i2c_port_t next_port = 0; static i2c_port_t next_port = 0;
port_ = next_port++; port_ = next_port++;
recover(); recover_();
i2c_config_t conf{}; i2c_config_t conf{};
memset(&conf, 0, sizeof(conf)); memset(&conf, 0, sizeof(conf));
@ -144,7 +144,7 @@ ErrorCode IDFI2CBus::writev(uint8_t address, WriteBuffer *buffers, size_t cnt) {
return ERROR_OK; return ERROR_OK;
} }
void IDFI2CBus::recover() { void IDFI2CBus::recover_() {
// Perform I2C bus recovery, see // Perform I2C bus recovery, see
// https://www.analog.com/media/en/technical-documentation/application-notes/54305147357414AN686_0.pdf // https://www.analog.com/media/en/technical-documentation/application-notes/54305147357414AN686_0.pdf
// or see the linux kernel implementation, e.g. // or see the linux kernel implementation, e.g.

2
esphome/components/i2c/i2c_bus_esp_idf.h
View file

@ -25,7 +25,7 @@ class IDFI2CBus : public I2CBus, public Component {
void set_frequency(uint32_t frequency) { frequency_ = frequency; } void set_frequency(uint32_t frequency) { frequency_ = frequency; }
private: private:
void recover(); void recover_();
protected: protected:
i2c_port_t port_; i2c_port_t port_;

4
esphome/components/inkbird_ibsth1_mini/inkbird_ibsth1_mini.cpp
View file

@ -8,7 +8,7 @@ namespace inkbird_ibsth1_mini {
static const char *const TAG = "inkbird_ibsth1_mini"; static const char *const TAG = "inkbird_ibsth1_mini";
void InkbirdIBSTH1_MINI::dump_config() { void InkbirdIbstH1Mini::dump_config() {
ESP_LOGCONFIG(TAG, "Inkbird IBS TH1 MINI"); ESP_LOGCONFIG(TAG, "Inkbird IBS TH1 MINI");
LOG_SENSOR(" ", "Temperature", this->temperature_); LOG_SENSOR(" ", "Temperature", this->temperature_);
LOG_SENSOR(" ", "External Temperature", this->external_temperature_); LOG_SENSOR(" ", "External Temperature", this->external_temperature_);
@ -16,7 +16,7 @@ void InkbirdIBSTH1_MINI::dump_config() {
LOG_SENSOR(" ", "Battery Level", this->battery_level_); LOG_SENSOR(" ", "Battery Level", this->battery_level_);
} }
bool InkbirdIBSTH1_MINI::parse_device(const esp32_ble_tracker::ESPBTDevice &device) { bool InkbirdIbstH1Mini::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
// The below is based on my research and reverse engineering of a single device // The below is based on my research and reverse engineering of a single device
// It is entirely possible that some of that may be inaccurate or incomplete // It is entirely possible that some of that may be inaccurate or incomplete

2
esphome/components/inkbird_ibsth1_mini/inkbird_ibsth1_mini.h
View file

@ -9,7 +9,7 @@
namespace esphome { namespace esphome {
namespace inkbird_ibsth1_mini { namespace inkbird_ibsth1_mini {
class InkbirdIBSTH1_MINI : public Component, public esp32_ble_tracker::ESPBTDeviceListener { class InkbirdIbstH1Mini : public Component, public esp32_ble_tracker::ESPBTDeviceListener {
public: public:
void set_address(uint64_t address) { address_ = address; } void set_address(uint64_t address) { address_ = address; }

6
esphome/components/inkbird_ibsth1_mini/sensor.py
View file

@ -21,14 +21,14 @@ DEPENDENCIES = ["esp32_ble_tracker"]
CONF_EXTERNAL_TEMPERATURE = "external_temperature" CONF_EXTERNAL_TEMPERATURE = "external_temperature"
inkbird_ibsth1_mini_ns = cg.esphome_ns.namespace("inkbird_ibsth1_mini") inkbird_ibsth1_mini_ns = cg.esphome_ns.namespace("inkbird_ibsth1_mini")
InkbirdUBSTH1_MINI = inkbird_ibsth1_mini_ns.class_( InkbirdIbstH1Mini = inkbird_ibsth1_mini_ns.class_(
"InkbirdIBSTH1_MINI", esp32_ble_tracker.ESPBTDeviceListener, cg.Component "InkbirdIbstH1Mini", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
) )
CONFIG_SCHEMA = ( CONFIG_SCHEMA = (
cv.Schema( cv.Schema(
{ {
cv.GenerateID(): cv.declare_id(InkbirdUBSTH1_MINI), cv.GenerateID(): cv.declare_id(InkbirdIbstH1Mini),
cv.Required(CONF_MAC_ADDRESS): cv.mac_address, cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema( cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS, unit_of_measurement=UNIT_CELSIUS,

1
esphome/components/ledc/ledc_output.h
View file

@ -10,6 +10,7 @@
namespace esphome { namespace esphome {
namespace ledc { namespace ledc {
// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
extern uint8_t next_ledc_channel; extern uint8_t next_ledc_channel;
class LEDCOutput : public output::FloatOutput, public Component { class LEDCOutput : public output::FloatOutput, public Component {

2
esphome/components/light/addressable_light.h
View file

@ -80,7 +80,7 @@ class AddressableLight : public LightOutput, public Component {
void mark_shown_() { void mark_shown_() {
#ifdef USE_POWER_SUPPLY #ifdef USE_POWER_SUPPLY
for (auto c : *this) { for (const auto &c : *this) {
if (c.get().is_on()) { if (c.get().is_on()) {
this->power_.request(); this->power_.request();
return; return;

2
esphome/components/light/addressable_light_wrapper.h
View file

@ -9,7 +9,7 @@ namespace light {
class AddressableLightWrapper : public light::AddressableLight { class AddressableLightWrapper : public light::AddressableLight {
public: public:
explicit AddressableLightWrapper(light::LightState *light_state) : light_state_(light_state) { explicit AddressableLightWrapper(light::LightState *light_state) : light_state_(light_state) {
this->wrapper_state_ = new uint8_t[5]; this->wrapper_state_ = new uint8_t[5]; // NOLINT(cppcoreguidelines-owning-memory)
} }
int32_t size() const override { return 1; } int32_t size() const override { return 1; }

2
esphome/components/light/esp_range_view.h
View file

@ -18,6 +18,7 @@ class ESPRangeView : public ESPColorSettable {
public: public:
ESPRangeView(AddressableLight *parent, int32_t begin, int32_t end) ESPRangeView(AddressableLight *parent, int32_t begin, int32_t end)
: parent_(parent), begin_(begin), end_(end < begin ? begin : end) {} : parent_(parent), begin_(begin), end_(end < begin ? begin : end) {}
ESPRangeView(const ESPRangeView &) = default;
int32_t size() const { return this->end_ - this->begin_; } int32_t size() const { return this->end_ - this->begin_; }
ESPColorView operator[](int32_t index) const; ESPColorView operator[](int32_t index) const;
@ -62,6 +63,7 @@ class ESPRangeView : public ESPColorSettable {
class ESPRangeIterator { class ESPRangeIterator {
public: public:
ESPRangeIterator(const ESPRangeView &range, int32_t i) : range_(range), i_(i) {} ESPRangeIterator(const ESPRangeView &range, int32_t i) : range_(range), i_(i) {}
ESPRangeIterator(const ESPRangeIterator &) = default;
ESPRangeIterator operator++() { ESPRangeIterator operator++() {
this->i_++; this->i_++;
return *this; return *this;

17
esphome/components/midea/appliance_base.h
View file

@ -31,9 +31,10 @@ class ApplianceBase : public Component, public uart::UARTDevice, public climate:
ApplianceBase() { ApplianceBase() {
this->base_.setStream(this); this->base_.setStream(this);
this->base_.addOnStateCallback(std::bind(&ApplianceBase::on_status_change, this)); this->base_.addOnStateCallback(std::bind(&ApplianceBase::on_status_change, this));
dudanov::midea::ApplianceBase::setLogger([](int level, const char *tag, int line, String format, va_list args) { dudanov::midea::ApplianceBase::setLogger(
esp_log_vprintf_(level, tag, line, format.c_str(), args); [](int level, const char *tag, int line, const String &format, va_list args) {
}); esp_log_vprintf_(level, tag, line, format.c_str(), args);
});
} }
bool can_proceed() override { bool can_proceed() override {
return this->base_.getAutoconfStatus() != dudanov::midea::AutoconfStatus::AUTOCONF_PROGRESS; return this->base_.getAutoconfStatus() != dudanov::midea::AutoconfStatus::AUTOCONF_PROGRESS;
@ -46,11 +47,11 @@ class ApplianceBase : public Component, public uart::UARTDevice, public climate:
void set_request_attempts(uint32_t attempts) { this->base_.setNumAttempts(attempts); } void set_request_attempts(uint32_t attempts) { this->base_.setNumAttempts(attempts); }
void set_beeper_feedback(bool state) { this->base_.setBeeper(state); } void set_beeper_feedback(bool state) { this->base_.setBeeper(state); }
void set_autoconf(bool value) { this->base_.setAutoconf(value); } void set_autoconf(bool value) { this->base_.setAutoconf(value); }
void set_supported_modes(std::set<ClimateMode> modes) { this->supported_modes_ = std::move(modes); } void set_supported_modes(const std::set<ClimateMode> &modes) { this->supported_modes_ = modes; }
void set_supported_swing_modes(std::set<ClimateSwingMode> modes) { this->supported_swing_modes_ = std::move(modes); } void set_supported_swing_modes(const std::set<ClimateSwingMode> &modes) { this->supported_swing_modes_ = modes; }
void set_supported_presets(std::set<ClimatePreset> presets) { this->supported_presets_ = std::move(presets); } void set_supported_presets(const std::set<ClimatePreset> &presets) { this->supported_presets_ = presets; }
void set_custom_presets(std::set<std::string> presets) { this->supported_custom_presets_ = std::move(presets); } void set_custom_presets(const std::set<std::string> &presets) { this->supported_custom_presets_ = presets; }
void set_custom_fan_modes(std::set<std::string> modes) { this->supported_custom_fan_modes_ = std::move(modes); } void set_custom_fan_modes(const std::set<std::string> &modes) { this->supported_custom_fan_modes_ = modes; }
virtual void on_status_change() = 0; virtual void on_status_change() = 0;
#ifdef USE_REMOTE_TRANSMITTER #ifdef USE_REMOTE_TRANSMITTER
void set_transmitter(remote_transmitter::RemoteTransmitterComponent *transmitter) { void set_transmitter(remote_transmitter::RemoteTransmitterComponent *transmitter) {

12
esphome/components/pvvx_mithermometer/pvvx_mithermometer.cpp
View file

@ -25,14 +25,14 @@ bool PVVXMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &devic
bool success = false; bool success = false;
for (auto &service_data : device.get_service_datas()) { for (auto &service_data : device.get_service_datas()) {
auto res = parse_header(service_data); auto res = parse_header_(service_data);
if (!res.has_value()) { if (!res.has_value()) {
continue; continue;
} }
if (!(parse_message(service_data.data, *res))) { if (!(parse_message_(service_data.data, *res))) {
continue; continue;
} }
if (!(report_results(res, device.address_str()))) { if (!(report_results_(res, device.address_str()))) {
continue; continue;
} }
if (res->temperature.has_value() && this->temperature_ != nullptr) if (res->temperature.has_value() && this->temperature_ != nullptr)
@ -49,7 +49,7 @@ bool PVVXMiThermometer::parse_device(const esp32_ble_tracker::ESPBTDevice &devic
return success; return success;
} }
optional<ParseResult> PVVXMiThermometer::parse_header(const esp32_ble_tracker::ServiceData &service_data) { optional<ParseResult> PVVXMiThermometer::parse_header_(const esp32_ble_tracker::ServiceData &service_data) {
ParseResult result; ParseResult result;
if (!service_data.uuid.contains(0x1A, 0x18)) { if (!service_data.uuid.contains(0x1A, 0x18)) {
ESP_LOGVV(TAG, "parse_header(): no service data UUID magic bytes."); ESP_LOGVV(TAG, "parse_header(): no service data UUID magic bytes.");
@ -68,7 +68,7 @@ optional<ParseResult> PVVXMiThermometer::parse_header(const esp32_ble_tracker::S
return result; return result;
} }
bool PVVXMiThermometer::parse_message(const std::vector<uint8_t> &message, ParseResult &result) { bool PVVXMiThermometer::parse_message_(const std::vector<uint8_t> &message, ParseResult &result) {
/* /*
All data little endian All data little endian
uint8_t size; // = 19 uint8_t size; // = 19
@ -109,7 +109,7 @@ bool PVVXMiThermometer::parse_message(const std::vector<uint8_t> &message, Parse
return true; return true;
} }
bool PVVXMiThermometer::report_results(const optional<ParseResult> &result, const std::string &address) { bool PVVXMiThermometer::report_results_(const optional<ParseResult> &result, const std::string &address) {
if (!result.has_value()) { if (!result.has_value()) {
ESP_LOGVV(TAG, "report_results(): no results available."); ESP_LOGVV(TAG, "report_results(): no results available.");
return false; return false;

6
esphome/components/pvvx_mithermometer/pvvx_mithermometer.h
View file

@ -36,9 +36,9 @@ class PVVXMiThermometer : public Component, public esp32_ble_tracker::ESPBTDevic
sensor::Sensor *battery_level_{nullptr}; sensor::Sensor *battery_level_{nullptr};
sensor::Sensor *battery_voltage_{nullptr}; sensor::Sensor *battery_voltage_{nullptr};
optional<ParseResult> parse_header(const esp32_ble_tracker::ServiceData &service_data); optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
bool parse_message(const std::vector<uint8_t> &message, ParseResult &result); bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
bool report_results(const optional<ParseResult> &result, const std::string &address); bool report_results_(const optional<ParseResult> &result, const std::string &address);
}; };
} // namespace pvvx_mithermometer } // namespace pvvx_mithermometer

2
esphome/components/remote_base/midea_protocol.h
View file

@ -92,7 +92,7 @@ using MideaDumper = RemoteReceiverDumper<MideaProtocol, MideaData>;
template<typename... Ts> class MideaAction : public RemoteTransmitterActionBase<Ts...> { template<typename... Ts> class MideaAction : public RemoteTransmitterActionBase<Ts...> {
TEMPLATABLE_VALUE(std::vector<uint8_t>, code) TEMPLATABLE_VALUE(std::vector<uint8_t>, code)
void set_code(std::vector<uint8_t> code) { code_ = code; } void set_code(const std::vector<uint8_t> &code) { code_ = code; }
void encode(RemoteTransmitData *dst, Ts... x) override { void encode(RemoteTransmitData *dst, Ts... x) override {
MideaData data = this->code_.value(x...); MideaData data = this->code_.value(x...);
data.finalize(); data.finalize();

4
esphome/components/remote_base/remote_base.h
View file

@ -161,11 +161,11 @@ class RemoteRMTChannel {
void set_clock_divider(uint8_t clock_divider) { this->clock_divider_ = clock_divider; } void set_clock_divider(uint8_t clock_divider) { this->clock_divider_ = clock_divider; }
protected: protected:
uint32_t from_microseconds(uint32_t us) { uint32_t from_microseconds_(uint32_t us) {
const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u; const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
return us * ticks_per_ten_us / 10; return us * ticks_per_ten_us / 10;
} }
uint32_t to_microseconds(uint32_t ticks) { uint32_t to_microseconds_(uint32_t ticks) {
const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u; const uint32_t ticks_per_ten_us = 80000000u / this->clock_divider_ / 100000u;
return (ticks * 10) / ticks_per_ten_us; return (ticks * 10) / ticks_per_ten_us;
} }

28
esphome/components/remote_receiver/remote_receiver_esp32.cpp
View file

@ -20,9 +20,9 @@ void RemoteReceiverComponent::setup() {
rmt.rx_config.filter_en = false; rmt.rx_config.filter_en = false;
} else { } else {
rmt.rx_config.filter_en = true; rmt.rx_config.filter_en = true;
rmt.rx_config.filter_ticks_thresh = this->from_microseconds(this->filter_us_); rmt.rx_config.filter_ticks_thresh = this->from_microseconds_(this->filter_us_);
} }
rmt.rx_config.idle_threshold = this->from_microseconds(this->idle_us_); rmt.rx_config.idle_threshold = this->from_microseconds_(this->idle_us_);
esp_err_t error = rmt_config(&rmt); esp_err_t error = rmt_config(&rmt);
if (error != ESP_OK) { if (error != ESP_OK) {
@ -90,14 +90,14 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t len) {
ESP_LOGVV(TAG, "START:"); ESP_LOGVV(TAG, "START:");
for (size_t i = 0; i < len; i++) { for (size_t i = 0; i < len; i++) {
if (item[i].level0) { if (item[i].level0) {
ESP_LOGVV(TAG, "%u A: ON %uus (%u ticks)", i, this->to_microseconds(item[i].duration0), item[i].duration0); ESP_LOGVV(TAG, "%u A: ON %uus (%u ticks)", i, this->to_microseconds_(item[i].duration0), item[i].duration0);
} else { } else {
ESP_LOGVV(TAG, "%u A: OFF %uus (%u ticks)", i, this->to_microseconds(item[i].duration0), item[i].duration0); ESP_LOGVV(TAG, "%u A: OFF %uus (%u ticks)", i, this->to_microseconds_(item[i].duration0), item[i].duration0);
} }
if (item[i].level1) { if (item[i].level1) {
ESP_LOGVV(TAG, "%u B: ON %uus (%u ticks)", i, this->to_microseconds(item[i].duration1), item[i].duration1); ESP_LOGVV(TAG, "%u B: ON %uus (%u ticks)", i, this->to_microseconds_(item[i].duration1), item[i].duration1);
} else { } else {
ESP_LOGVV(TAG, "%u B: OFF %uus (%u ticks)", i, this->to_microseconds(item[i].duration1), item[i].duration1); ESP_LOGVV(TAG, "%u B: OFF %uus (%u ticks)", i, this->to_microseconds_(item[i].duration1), item[i].duration1);
} }
} }
ESP_LOGVV(TAG, "\n"); ESP_LOGVV(TAG, "\n");
@ -111,16 +111,16 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t len) {
} else { } else {
if (prev_length > 0) { if (prev_length > 0) {
if (prev_level) { if (prev_level) {
this->temp_.push_back(this->to_microseconds(prev_length) * multiplier); this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
} else { } else {
this->temp_.push_back(-int32_t(this->to_microseconds(prev_length)) * multiplier); this->temp_.push_back(-int32_t(this->to_microseconds_(prev_length)) * multiplier);
} }
} }
prev_level = bool(item[i].level0); prev_level = bool(item[i].level0);
prev_length = item[i].duration0; prev_length = item[i].duration0;
} }
if (this->to_microseconds(prev_length) > this->idle_us_) { if (this->to_microseconds_(prev_length) > this->idle_us_) {
break; break;
} }
@ -131,24 +131,24 @@ void RemoteReceiverComponent::decode_rmt_(rmt_item32_t *item, size_t len) {
} else { } else {
if (prev_length > 0) { if (prev_length > 0) {
if (prev_level) { if (prev_level) {
this->temp_.push_back(this->to_microseconds(prev_length) * multiplier); this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
} else { } else {
this->temp_.push_back(-int32_t(this->to_microseconds(prev_length)) * multiplier); this->temp_.push_back(-int32_t(this->to_microseconds_(prev_length)) * multiplier);
} }
} }
prev_level = bool(item[i].level1); prev_level = bool(item[i].level1);
prev_length = item[i].duration1; prev_length = item[i].duration1;
} }
if (this->to_microseconds(prev_length) > this->idle_us_) { if (this->to_microseconds_(prev_length) > this->idle_us_) {
break; break;
} }
} }
if (prev_length > 0) { if (prev_length > 0) {
if (prev_level) { if (prev_level) {
this->temp_.push_back(this->to_microseconds(prev_length) * multiplier); this->temp_.push_back(this->to_microseconds_(prev_length) * multiplier);
} else { } else {
this->temp_.push_back(-int32_t(this->to_microseconds(prev_length)) * multiplier); this->temp_.push_back(-int32_t(this->to_microseconds_(prev_length)) * multiplier);
} }
} }
} }

2
esphome/components/remote_transmitter/remote_transmitter.h
View file

@ -35,7 +35,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
#endif #endif
#ifdef USE_ESP32 #ifdef USE_ESP32
void configure_rmt(); void configure_rmt_();
uint32_t current_carrier_frequency_{UINT32_MAX}; uint32_t current_carrier_frequency_{UINT32_MAX};
bool initialized_{false}; bool initialized_{false};

8
esphome/components/remote_transmitter/remote_transmitter_esp32.cpp
View file

@ -9,7 +9,7 @@ namespace remote_transmitter {
static const char *const TAG = "remote_transmitter"; static const char *const TAG = "remote_transmitter";
void RemoteTransmitterComponent::setup() { this->configure_rmt(); } void RemoteTransmitterComponent::setup() { this->configure_rmt_(); }
void RemoteTransmitterComponent::dump_config() { void RemoteTransmitterComponent::dump_config() {
ESP_LOGCONFIG(TAG, "Remote Transmitter..."); ESP_LOGCONFIG(TAG, "Remote Transmitter...");
@ -27,7 +27,7 @@ void RemoteTransmitterComponent::dump_config() {
} }
} }
void RemoteTransmitterComponent::configure_rmt() { void RemoteTransmitterComponent::configure_rmt_() {
rmt_config_t c{}; rmt_config_t c{};
this->config_rmt(c); this->config_rmt(c);
@ -77,7 +77,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
if (this->current_carrier_frequency_ != this->temp_.get_carrier_frequency()) { if (this->current_carrier_frequency_ != this->temp_.get_carrier_frequency()) {
this->current_carrier_frequency_ = this->temp_.get_carrier_frequency(); this->current_carrier_frequency_ = this->temp_.get_carrier_frequency();
this->configure_rmt(); this->configure_rmt_();
} }
this->rmt_temp_.clear(); this->rmt_temp_.clear();
@ -89,7 +89,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
bool level = val >= 0; bool level = val >= 0;
if (!level) if (!level)
val = -val; val = -val;
val = this->from_microseconds(static_cast<uint32_t>(val)); val = this->from_microseconds_(static_cast<uint32_t>(val));
do { do {
int32_t item = std::min(val, int32_t(32767)); int32_t item = std::min(val, int32_t(32767));

27
esphome/components/socket/headers.h
View file

@ -7,10 +7,10 @@
#ifdef USE_SOCKET_IMPL_LWIP_TCP #ifdef USE_SOCKET_IMPL_LWIP_TCP
#define LWIP_INTERNAL #define LWIP_INTERNAL
#include <sys/types.h>
#include "lwip/inet.h" #include "lwip/inet.h"
#include <stdint.h> #include <cerrno>
#include <errno.h> #include <cstdint>
#include <sys/types.h>
/* Address families. */ /* Address families. */
#define AF_UNSPEC 0 #define AF_UNSPEC 0
@ -45,9 +45,10 @@
#define SOL_SOCKET 0xfff /* options for socket level */ #define SOL_SOCKET 0xfff /* options for socket level */
typedef uint8_t sa_family_t; using sa_family_t = uint8_t;
typedef uint16_t in_port_t; using in_port_t = uint16_t;
// NOLINTNEXTLINE(readability-identifier-naming)
struct sockaddr_in { struct sockaddr_in {
uint8_t sin_len; uint8_t sin_len;
sa_family_t sin_family; sa_family_t sin_family;
@ -57,6 +58,7 @@ struct sockaddr_in {
char sin_zero[SIN_ZERO_LEN]; char sin_zero[SIN_ZERO_LEN];
}; };
// NOLINTNEXTLINE(readability-identifier-naming)
struct sockaddr_in6 { struct sockaddr_in6 {
uint8_t sin6_len; /* length of this structure */ uint8_t sin6_len; /* length of this structure */
sa_family_t sin6_family; /* AF_INET6 */ sa_family_t sin6_family; /* AF_INET6 */
@ -66,12 +68,14 @@ struct sockaddr_in6 {
uint32_t sin6_scope_id; /* Set of interfaces for scope */ uint32_t sin6_scope_id; /* Set of interfaces for scope */
}; };
// NOLINTNEXTLINE(readability-identifier-naming)
struct sockaddr { struct sockaddr {
uint8_t sa_len; uint8_t sa_len;
sa_family_t sa_family; sa_family_t sa_family;
char sa_data[14]; char sa_data[14];
}; };
// NOLINTNEXTLINE(readability-identifier-naming)
struct sockaddr_storage { struct sockaddr_storage {
uint8_t s2_len; uint8_t s2_len;
sa_family_t ss_family; sa_family_t ss_family;
@ -79,8 +83,9 @@ struct sockaddr_storage {
uint32_t s2_data2[3]; uint32_t s2_data2[3];
uint32_t s2_data3[3]; uint32_t s2_data3[3];
}; };
typedef uint32_t socklen_t; using socklen_t = uint32_t;
// NOLINTNEXTLINE(readability-identifier-naming)
struct iovec { struct iovec {
void *iov_base; void *iov_base;
size_t iov_len; size_t iov_len;
@ -106,13 +111,13 @@ struct iovec {
#ifdef USE_SOCKET_IMPL_BSD_SOCKETS #ifdef USE_SOCKET_IMPL_BSD_SOCKETS
#include <sys/types.h> #include <cstdint>
#include <sys/socket.h> #include <fcntl.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h> #include <sys/uio.h>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h>
#include <stdint.h>
#ifdef USE_ARDUINO #ifdef USE_ARDUINO
// arduino-esp32 declares a global var called INADDR_NONE which is replaced // arduino-esp32 declares a global var called INADDR_NONE which is replaced
@ -121,7 +126,7 @@ struct iovec {
#undef INADDR_NONE #undef INADDR_NONE
#endif #endif
// not defined for ESP32 // not defined for ESP32
typedef uint32_t socklen_t; using socklen_t = uint32_t;
#define ESPHOME_INADDR_ANY ((uint32_t) 0x00000000UL) #define ESPHOME_INADDR_ANY ((uint32_t) 0x00000000UL)
#define ESPHOME_INADDR_NONE ((uint32_t) 0xFFFFFFFFUL) #define ESPHOME_INADDR_NONE ((uint32_t) 0xFFFFFFFFUL)

2
esphome/components/t6615/t6615.h
View file

@ -35,7 +35,7 @@ class T6615Component : public PollingComponent, public uart::UARTDevice {
void send_ppm_command_(); void send_ppm_command_();
T6615Command command_ = T6615Command::NONE; T6615Command command_ = T6615Command::NONE;
unsigned long command_time_ = 0; uint32_t command_time_ = 0;
sensor::Sensor *co2_sensor_{nullptr}; sensor::Sensor *co2_sensor_{nullptr};
}; };

10
esphome/components/uart/uart_component_esp8266.cpp
View file

@ -13,7 +13,7 @@ namespace esphome {
namespace uart { namespace uart {
static const char *const TAG = "uart.arduino_esp8266"; static const char *const TAG = "uart.arduino_esp8266";
bool ESP8266UartComponent::serial0InUse = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables) bool ESP8266UartComponent::serial0_in_use = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
uint32_t ESP8266UartComponent::get_config() { uint32_t ESP8266UartComponent::get_config() {
uint32_t config = 0; uint32_t config = 0;
@ -55,7 +55,7 @@ void ESP8266UartComponent::setup() {
// is 1 we still want to use Serial. // is 1 we still want to use Serial.
SerialConfig config = static_cast<SerialConfig>(get_config()); SerialConfig config = static_cast<SerialConfig>(get_config());
if (!ESP8266UartComponent::serial0InUse && (tx_pin_ == nullptr || tx_pin_->get_pin() == 1) && if (!ESP8266UartComponent::serial0_in_use && (tx_pin_ == nullptr || tx_pin_->get_pin() == 1) &&
(rx_pin_ == nullptr || rx_pin_->get_pin() == 3) (rx_pin_ == nullptr || rx_pin_->get_pin() == 3)
#ifdef USE_LOGGER #ifdef USE_LOGGER
// we will use UART0 if logger isn't using it in swapped mode // we will use UART0 if logger isn't using it in swapped mode
@ -66,8 +66,8 @@ void ESP8266UartComponent::setup() {
this->hw_serial_ = &Serial; this->hw_serial_ = &Serial;
this->hw_serial_->begin(this->baud_rate_, config); this->hw_serial_->begin(this->baud_rate_, config);
this->hw_serial_->setRxBufferSize(this->rx_buffer_size_); this->hw_serial_->setRxBufferSize(this->rx_buffer_size_);
ESP8266UartComponent::serial0InUse = true; ESP8266UartComponent::serial0_in_use = true;
} else if (!ESP8266UartComponent::serial0InUse && (tx_pin_ == nullptr || tx_pin_->get_pin() == 15) && } else if (!ESP8266UartComponent::serial0_in_use && (tx_pin_ == nullptr || tx_pin_->get_pin() == 15) &&
(rx_pin_ == nullptr || rx_pin_->get_pin() == 13) (rx_pin_ == nullptr || rx_pin_->get_pin() == 13)
#ifdef USE_LOGGER #ifdef USE_LOGGER
// we will use UART0 swapped if logger isn't using it in regular mode // we will use UART0 swapped if logger isn't using it in regular mode
@ -79,7 +79,7 @@ void ESP8266UartComponent::setup() {
this->hw_serial_->begin(this->baud_rate_, config); this->hw_serial_->begin(this->baud_rate_, config);
this->hw_serial_->setRxBufferSize(this->rx_buffer_size_); this->hw_serial_->setRxBufferSize(this->rx_buffer_size_);
this->hw_serial_->swap(); this->hw_serial_->swap();
ESP8266UartComponent::serial0InUse = true; ESP8266UartComponent::serial0_in_use = true;
} else if ((tx_pin_ == nullptr || tx_pin_->get_pin() == 2) && (rx_pin_ == nullptr || rx_pin_->get_pin() == 8)) { } else if ((tx_pin_ == nullptr || tx_pin_->get_pin() == 2) && (rx_pin_ == nullptr || rx_pin_->get_pin() == 8)) {
this->hw_serial_ = &Serial1; this->hw_serial_ = &Serial1;
this->hw_serial_->begin(this->baud_rate_, config); this->hw_serial_->begin(this->baud_rate_, config);

2
esphome/components/uart/uart_component_esp8266.h
View file

@ -70,7 +70,7 @@ class ESP8266UartComponent : public UARTComponent, public Component {
ESP8266SoftwareSerial *sw_serial_{nullptr}; ESP8266SoftwareSerial *sw_serial_{nullptr};
private: private:
static bool serial0InUse; static bool serial0_in_use; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
}; };
} // namespace uart } // namespace uart

4
esphome/components/uart/uart_component_esp_idf.cpp
View file

@ -14,7 +14,7 @@ namespace esphome {
namespace uart { namespace uart {
static const char *const TAG = "uart.idf"; static const char *const TAG = "uart.idf";
uart_config_t IDFUARTComponent::get_config() { uart_config_t IDFUARTComponent::get_config_() {
uart_parity_t parity = UART_PARITY_DISABLE; uart_parity_t parity = UART_PARITY_DISABLE;
if (this->parity_ == UART_CONFIG_PARITY_EVEN) if (this->parity_ == UART_CONFIG_PARITY_EVEN)
parity = UART_PARITY_EVEN; parity = UART_PARITY_EVEN;
@ -70,7 +70,7 @@ void IDFUARTComponent::setup() {
xSemaphoreTake(this->lock_, portMAX_DELAY); xSemaphoreTake(this->lock_, portMAX_DELAY);
uart_config_t uart_config = this->get_config(); uart_config_t uart_config = this->get_config_();
esp_err_t err = uart_param_config(this->uart_num_, &uart_config); esp_err_t err = uart_param_config(this->uart_num_, &uart_config);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_LOGW(TAG, "uart_param_config failed: %s", esp_err_to_name(err)); ESP_LOGW(TAG, "uart_param_config failed: %s", esp_err_to_name(err));

2
esphome/components/uart/uart_component_esp_idf.h
View file

@ -26,7 +26,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
protected: protected:
void check_logger_conflict() override; void check_logger_conflict() override;
uart_port_t uart_num_; uart_port_t uart_num_;
uart_config_t get_config(); uart_config_t get_config_();
SemaphoreHandle_t lock_; SemaphoreHandle_t lock_;
bool has_peek_{false}; bool has_peek_{false};

2
esphome/components/wifi_info/wifi_info_text_sensor.h
View file

@ -13,7 +13,7 @@ class IPAddressWiFiInfo : public Component, public text_sensor::TextSensor {
auto ip = wifi::global_wifi_component->wifi_sta_ip(); auto ip = wifi::global_wifi_component->wifi_sta_ip();
if (ip != this->last_ip_) { if (ip != this->last_ip_) {
this->last_ip_ = ip; this->last_ip_ = ip;
this->publish_state(ip.str().c_str()); this->publish_state(ip.str());
} }
} }
float get_setup_priority() const override { return setup_priority::AFTER_WIFI; } float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }

20
esphome/components/xiaomi_miscale/xiaomi_miscale.cpp
View file

@ -23,16 +23,16 @@ bool XiaomiMiscale::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
bool success = false; bool success = false;
for (auto &service_data : device.get_service_datas()) { for (auto &service_data : device.get_service_datas()) {
auto res = parse_header(service_data); auto res = parse_header_(service_data);
if (!res.has_value()) { if (!res.has_value()) {
continue; continue;
} }
if (!(parse_message(service_data.data, *res))) { if (!(parse_message_(service_data.data, *res))) {
continue; continue;
} }
if (!(report_results(res, device.address_str()))) { if (!(report_results_(res, device.address_str()))) {
continue; continue;
} }
@ -49,7 +49,7 @@ bool XiaomiMiscale::parse_device(const esp32_ble_tracker::ESPBTDevice &device) {
return success; return success;
} }
optional<ParseResult> XiaomiMiscale::parse_header(const esp32_ble_tracker::ServiceData &service_data) { optional<ParseResult> XiaomiMiscale::parse_header_(const esp32_ble_tracker::ServiceData &service_data) {
ParseResult result; ParseResult result;
if (service_data.uuid == esp32_ble_tracker::ESPBTUUID::from_uint16(0x181D) && service_data.data.size() == 10) { if (service_data.uuid == esp32_ble_tracker::ESPBTUUID::from_uint16(0x181D) && service_data.data.size() == 10) {
result.version = 1; result.version = 1;
@ -65,15 +65,15 @@ optional<ParseResult> XiaomiMiscale::parse_header(const esp32_ble_tracker::Servi
return result; return result;
} }
bool XiaomiMiscale::parse_message(const std::vector<uint8_t> &message, ParseResult &result) { bool XiaomiMiscale::parse_message_(const std::vector<uint8_t> &message, ParseResult &result) {
if (result.version == 1) { if (result.version == 1) {
return parse_message_V1(message, result); return parse_message_v1_(message, result);
} else { } else {
return parse_message_V2(message, result); return parse_message_v2_(message, result);
} }
} }
bool XiaomiMiscale::parse_message_V1(const std::vector<uint8_t> &message, ParseResult &result) { bool XiaomiMiscale::parse_message_v1_(const std::vector<uint8_t> &message, ParseResult &result) {
// message size is checked in parse_header // message size is checked in parse_header
// 1-2 Weight (MISCALE 181D) // 1-2 Weight (MISCALE 181D)
// 3-4 Years (MISCALE 181D) // 3-4 Years (MISCALE 181D)
@ -97,7 +97,7 @@ bool XiaomiMiscale::parse_message_V1(const std::vector<uint8_t> &message, ParseR
return true; return true;
} }
bool XiaomiMiscale::parse_message_V2(const std::vector<uint8_t> &message, ParseResult &result) { bool XiaomiMiscale::parse_message_v2_(const std::vector<uint8_t> &message, ParseResult &result) {
// message size is checked in parse_header // message size is checked in parse_header
// 2-3 Years (MISCALE 2 181B) // 2-3 Years (MISCALE 2 181B)
// 4 month (MISCALE 2 181B) // 4 month (MISCALE 2 181B)
@ -138,7 +138,7 @@ bool XiaomiMiscale::parse_message_V2(const std::vector<uint8_t> &message, ParseR
return true; return true;
} }
bool XiaomiMiscale::report_results(const optional<ParseResult> &result, const std::string &address) { bool XiaomiMiscale::report_results_(const optional<ParseResult> &result, const std::string &address) {
if (!result.has_value()) { if (!result.has_value()) {
ESP_LOGVV(TAG, "report_results(): no results available."); ESP_LOGVV(TAG, "report_results(): no results available.");
return false; return false;

10
esphome/components/xiaomi_miscale/xiaomi_miscale.h
View file

@ -30,11 +30,11 @@ class XiaomiMiscale : public Component, public esp32_ble_tracker::ESPBTDeviceLis
sensor::Sensor *weight_{nullptr}; sensor::Sensor *weight_{nullptr};
sensor::Sensor *impedance_{nullptr}; sensor::Sensor *impedance_{nullptr};
optional<ParseResult> parse_header(const esp32_ble_tracker::ServiceData &service_data); optional<ParseResult> parse_header_(const esp32_ble_tracker::ServiceData &service_data);
bool parse_message(const std::vector<uint8_t> &message, ParseResult &result); bool parse_message_(const std::vector<uint8_t> &message, ParseResult &result);
bool parse_message_V1(const std::vector<uint8_t> &message, ParseResult &result); bool parse_message_v1_(const std::vector<uint8_t> &message, ParseResult &result);
bool parse_message_V2(const std::vector<uint8_t> &message, ParseResult &result); bool parse_message_v2_(const std::vector<uint8_t> &message, ParseResult &result);
bool report_results(const optional<ParseResult> &result, const std::string &address); bool report_results_(const optional<ParseResult> &result, const std::string &address);
}; };
} // namespace xiaomi_miscale } // namespace xiaomi_miscale

6
esphome/core/gpio.h
View file

@ -6,7 +6,7 @@ namespace esphome {
#define LOG_PIN(prefix, pin) \ #define LOG_PIN(prefix, pin) \
if ((pin) != nullptr) { \ if ((pin) != nullptr) { \
ESP_LOGCONFIG(TAG, prefix "%s", pin->dump_summary().c_str()); \ ESP_LOGCONFIG(TAG, prefix "%s", (pin)->dump_summary().c_str()); \
} }
// put GPIO flags in a namepsace to not pollute esphome namespace // put GPIO flags in a namepsace to not pollute esphome namespace
@ -78,7 +78,7 @@ class ISRInternalGPIOPin {
class InternalGPIOPin : public GPIOPin { class InternalGPIOPin : public GPIOPin {
public: public:
template<typename T> void attach_interrupt(void (*func)(T *), T *arg, gpio::InterruptType type) const { template<typename T> void attach_interrupt(void (*func)(T *), T *arg, gpio::InterruptType type) const {
this->attach_interrupt_(reinterpret_cast<void (*)(void *)>(func), arg, type); this->attach_interrupt(reinterpret_cast<void (*)(void *)>(func), arg, type);
} }
virtual void detach_interrupt() const = 0; virtual void detach_interrupt() const = 0;
@ -92,7 +92,7 @@ class InternalGPIOPin : public GPIOPin {
virtual bool is_inverted() const = 0; virtual bool is_inverted() const = 0;
protected: protected:
virtual void attach_interrupt_(void (*func)(void *), void *arg, gpio::InterruptType type) const = 0; virtual void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const = 0;
}; };
} // namespace esphome } // namespace esphome

2
esphome/core/hal.h
View file

@ -37,7 +37,7 @@ void yield();
uint32_t millis(); uint32_t millis();
uint32_t micros(); uint32_t micros();
void delay(uint32_t ms); void delay(uint32_t ms);
void delayMicroseconds(uint32_t us); void delayMicroseconds(uint32_t us); // NOLINT(readability-identifier-naming)
void __attribute__((noreturn)) arch_restart(); void __attribute__((noreturn)) arch_restart();
void arch_feed_wdt(); void arch_feed_wdt();
uint32_t arch_get_cpu_cycle_count(); uint32_t arch_get_cpu_cycle_count();

4
esphome/core/helpers.h
View file

@ -333,10 +333,10 @@ template<typename T> T *new_buffer(size_t length) {
if (psramFound()) { if (psramFound()) {
buffer = (T *) ps_malloc(length); buffer = (T *) ps_malloc(length);
} else { } else {
buffer = new T[length]; buffer = new T[length]; // NOLINT(cppcoreguidelines-owning-memory)
} }
#else #else
buffer = new T[length]; // NOLINT buffer = new T[length]; // NOLINT(cppcoreguidelines-owning-memory)
#endif #endif
return buffer; return buffer;

3
script/clang-tidy
View file

@ -17,7 +17,7 @@ import pexpect
sys.path.append(os.path.dirname(__file__)) sys.path.append(os.path.dirname(__file__))
from helpers import shlex_quote, get_output, filter_grep, \ from helpers import shlex_quote, get_output, filter_grep, \
build_all_include, temp_header_file, git_ls_files, filter_changed, load_idedata build_all_include, temp_header_file, git_ls_files, filter_changed, load_idedata, basepath
def clang_options(idedata): def clang_options(idedata):
@ -89,6 +89,7 @@ def run_tidy(args, options, tmpdir, queue, lock, failed_files):
invocation.append('-quiet') invocation.append('-quiet')
invocation.append(os.path.abspath(path)) invocation.append(os.path.abspath(path))
invocation.append(f"--header-filter={os.path.abspath(basepath)}/.*")
invocation.append('--') invocation.append('--')
invocation.extend(options) invocation.extend(options)
invocation_s = ' '.join(shlex_quote(x) for x in invocation) invocation_s = ' '.join(shlex_quote(x) for x in invocation)