🏗 Merge C++ into python codebase (#504)

## Description: Move esphome-core codebase into esphome (and a bunch of other refactors). See https://github.com/esphome/feature-requests/issues/97 Yes this is a shit ton of work and no there's no way to automate it :( But it will be worth it 👍 Progress: - Core support (file copy etc): 80% - Base Abstractions (light, switch): ~50% - Integrations: ~10% - Working? Yes, (but only with ported components). Other refactors: - Moves all codegen related stuff into a single class: `esphome.codegen` (imported as `cg`) - Rework coroutine syntax - Move from `component/platform.py` to `domain/component.py` structure as with HA - Move all defaults out of C++ and into config validation. - Remove `make_...` helpers from Application class. Reason: Merge conflicts with every single new integration. - Pointer Variables are stored globally instead of locally in setup(). Reason: stack size limit. Future work: - Rework const.py - Move all `CONF_...` into a conf class (usage `conf.UPDATE_INTERVAL` vs `CONF_UPDATE_INTERVAL`). Reason: Less convoluted import block - Enable loading from `custom_components` folder. **Related issue (if applicable):** https://github.com/esphome/feature-requests/issues/97 **Pull request in [esphome-docs](https://github.com/esphome/esphome-docs) with documentation (if applicable):** esphome/esphome-docs#<esphome-docs PR number goes here> ## Checklist: - [ ] The code change is tested and works locally. - [ ] Tests have been added to verify that the new code works (under `tests/` folder). If user exposed functionality or configuration variables are added/changed: - [ ] Documentation added/updated in [esphomedocs](https://github.com/OttoWinter/esphomedocs).
2026-06-03 19:38:30 +02:00 · 2019-04-17 12:06:00 +02:00
parent 049807e3ab
commit 6682c43dfa
817 changed files with 54156 additions and 10830 deletions
@@ -0,0 +1,194 @@
+#include "esphome/components/dht/dht.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace dht {
+
+static const char *TAG = "dht";
+
+DHT::DHT(const std::string &temperature_name, const std::string &humidity_name, GPIOPin *pin, uint32_t update_interval)
+    : PollingComponent(update_interval),
+      pin_(pin),
+      temperature_sensor_(new sensor::Sensor(temperature_name)),
+      humidity_sensor_(new sensor::Sensor(humidity_name)) {}
+
+void DHT::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up DHT...");
+  this->pin_->digital_write(true);
+  this->pin_->setup();
+  this->pin_->digital_write(true);
+}
+void DHT::dump_config() {
+  ESP_LOGCONFIG(TAG, "DHT:");
+  LOG_PIN("  Pin: ", this->pin_);
+  if (this->is_auto_detect_) {
+    ESP_LOGCONFIG(TAG, "  Auto-detected model: %s", this->model_ == DHT_MODEL_DHT11 ? "DHT11" : "DHT22");
+  } else if (this->model_ == DHT_MODEL_DHT11) {
+    ESP_LOGCONFIG(TAG, "  Model: DHT11");
+  } else {
+    ESP_LOGCONFIG(TAG, "  Model: DHT22 (or equivalent)");
+  }
+
+  LOG_UPDATE_INTERVAL(this);
+
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
+}
+
+void DHT::update() {
+  float temperature, humidity;
+  bool error;
+  if (this->model_ == DHT_MODEL_AUTO_DETECT) {
+    this->model_ = DHT_MODEL_DHT22;
+    error = this->read_sensor_(&temperature, &humidity, false);
+    if (error) {
+      this->model_ = DHT_MODEL_DHT11;
+      return;
+    }
+  } else {
+    error = this->read_sensor_(&temperature, &humidity, true);
+  }
+
+  if (error) {
+    ESP_LOGD(TAG, "Got Temperature=%.1f°C Humidity=%.1f%%", temperature, humidity);
+
+    this->temperature_sensor_->publish_state(temperature);
+    this->humidity_sensor_->publish_state(humidity);
+    this->status_clear_warning();
+  } else {
+    const char *str = "";
+    if (this->is_auto_detect_) {
+      str = " and consider manually specifying the DHT model using the model option";
+    }
+    ESP_LOGW(TAG, "Invalid readings! Please check your wiring (pull-up resistor, pin number)%s.", str);
+    this->status_set_warning();
+  }
+}
+
+float DHT::get_setup_priority() const { return setup_priority::DATA; }
+void DHT::set_dht_model(DHTModel model) {
+  this->model_ = model;
+  this->is_auto_detect_ = model == DHT_MODEL_AUTO_DETECT;
+}
+sensor::Sensor *DHT::get_temperature_sensor() const { return this->temperature_sensor_; }
+sensor::Sensor *DHT::get_humidity_sensor() const { return this->humidity_sensor_; }
+bool HOT DHT::read_sensor_(float *temperature, float *humidity, bool report_errors) {
+  *humidity = NAN;
+  *temperature = NAN;
+
+  disable_interrupts();
+  this->pin_->digital_write(false);
+  this->pin_->pin_mode(OUTPUT);
+  this->pin_->digital_write(false);
+
+  if (this->model_ == DHT_MODEL_DHT11) {
+    delayMicroseconds(18000);
+  } else if (this->model_ == DHT_MODEL_SI7021) {
+    delayMicroseconds(500);
+    this->pin_->digital_write(true);
+    delayMicroseconds(40);
+  } else {
+    delayMicroseconds(800);
+  }
+  this->pin_->pin_mode(INPUT_PULLUP);
+  delayMicroseconds(40);
+
+  uint8_t data[5] = {0, 0, 0, 0, 0};
+  uint8_t bit = 7;
+  uint8_t byte = 0;
+
+  for (int8_t i = -1; i < 40; i++) {
+    uint32_t start_time = micros();
+
+    // Wait for rising edge
+    while (!this->pin_->digital_read()) {
+      if (micros() - start_time > 90) {
+        enable_interrupts();
+        if (report_errors) {
+          if (i < 0) {
+            ESP_LOGW(TAG, "Waiting for DHT communication to clear failed!");
+          } else {
+            ESP_LOGW(TAG, "Rising edge for bit %d failed!", i);
+          }
+        }
+        return false;
+      }
+    }
+
+    start_time = micros();
+    uint32_t end_time = start_time;
+
+    // Wait for falling edge
+    while (this->pin_->digital_read()) {
+      if ((end_time = micros()) - start_time > 90) {
+        enable_interrupts();
+        if (report_errors) {
+          if (i < 0) {
+            ESP_LOGW(TAG, "Requesting data from DHT failed!");
+          } else {
+            ESP_LOGW(TAG, "Falling edge for bit %d failed!", i);
+          }
+        }
+        return false;
+      }
+    }
+
+    if (i < 0)
+      continue;
+
+    if (end_time - start_time >= 40) {
+      data[byte] |= 1 << bit;
+    }
+    if (bit == 0) {
+      bit = 7;
+      byte++;
+    } else
+      bit--;
+  }
+  enable_interrupts();
+
+  ESP_LOGVV(TAG,
+            "Data: Hum=0b" BYTE_TO_BINARY_PATTERN BYTE_TO_BINARY_PATTERN
+            ", Temp=0b" BYTE_TO_BINARY_PATTERN BYTE_TO_BINARY_PATTERN ", Checksum=0b" BYTE_TO_BINARY_PATTERN,
+            BYTE_TO_BINARY(data[0]), BYTE_TO_BINARY(data[1]), BYTE_TO_BINARY(data[2]), BYTE_TO_BINARY(data[3]),
+            BYTE_TO_BINARY(data[4]));
+
+  uint8_t checksum_a = data[0] + data[1] + data[2] + data[3];
+  // On the DHT11, two algorithms for the checksum seem to be used, either the one from the DHT22,
+  // or just using bytes 0 and 2
+  uint8_t checksum_b = this->model_ == DHT_MODEL_DHT11 ? (data[0] + data[2]) : checksum_a;
+
+  if (checksum_a != data[4] && checksum_b != data[4]) {
+    if (report_errors) {
+      ESP_LOGE(TAG, "Checksum invalid: %u!=%u", checksum_a, data[4]);
+    }
+    return false;
+  }
+
+  if (this->model_ == DHT_MODEL_DHT11) {
+    *humidity = data[0];
+    *temperature = data[2];
+  } else {
+    uint16_t raw_humidity = (uint16_t(data[0] & 0xFF) << 8) | (data[1] & 0xFF);
+    uint16_t raw_temperature = (uint16_t(data[2] & 0xFF) << 8) | (data[3] & 0xFF);
+    *humidity = raw_humidity * 0.1f;
+
+    if ((raw_temperature & 0x8000) != 0)
+      raw_temperature = ~(raw_temperature & 0x7FFF);
+
+    *temperature = int16_t(raw_temperature) * 0.1f;
+  }
+
+  if (*temperature == 0.0f && (*humidity == 1.0f || *humidity == 2.0f)) {
+    if (report_errors) {
+      ESP_LOGE(TAG, "DHT reports invalid data. Is the update interval too high or the sensor damaged?");
+    }
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace dht
+}  // namespace esphome
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome {
+namespace dht {
+
+enum DHTModel {
+  DHT_MODEL_AUTO_DETECT = 0,
+  DHT_MODEL_DHT11,
+  DHT_MODEL_DHT22,
+  DHT_MODEL_AM2302,
+  DHT_MODEL_RHT03,
+  DHT_MODEL_SI7021
+};
+
+/// Component for reading temperature/humidity measurements from DHT11/DHT22 sensors.
+class DHT : public PollingComponent {
+ public:
+  /** Construct a DHTComponent.
+   *
+   * @param pin The pin which DHT sensor is connected to.
+   * @param update_interval The interval in ms the sensor should be checked.
+   */
+  DHT(const std::string &temperature_name, const std::string &humidity_name, GPIOPin *pin, uint32_t update_interval);
+
+  /** Manually select the DHT model.
+   *
+   * Valid values are:
+   *
+   *  - DHT_MODEL_AUTO_DETECT (default)
+   *  - DHT_MODEL_DHT11
+   *  - DHT_MODEL_DHT22
+   *  - DHT_MODEL_AM2302
+   *  - DHT_MODEL_RHT03
+   *  - DHT_MODEL_SI7021
+   *
+   * @param model The DHT model.
+   */
+  void set_dht_model(DHTModel model);
+
+  // ========== INTERNAL METHODS ==========
+  // (In most use cases you won't need these)
+  sensor::Sensor *get_temperature_sensor() const;
+  sensor::Sensor *get_humidity_sensor() const;
+
+  /// Set up the pins and check connection.
+  void setup() override;
+  void dump_config() override;
+  /// Update sensor values and push them to the frontend.
+  void update() override;
+  /// HARDWARE_LATE setup priority.
+  float get_setup_priority() const override;
+
+ protected:
+  bool read_sensor_(float *temperature, float *humidity, bool report_errors);
+
+  GPIOPin *pin_;
+  DHTModel model_{DHT_MODEL_AUTO_DETECT};
+  bool is_auto_detect_{false};
+  sensor::Sensor *temperature_sensor_;
+  sensor::Sensor *humidity_sensor_;
+};
+
+}  // namespace dht
+}  // namespace esphome
@@ -0,0 +1,50 @@
+from esphome.components import sensor
+import esphome.config_validation as cv
+import esphome.codegen as cg
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, \
+    CONF_PIN, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL, CONF_ACCURACY_DECIMALS, CONF_ICON, \
+    ICON_THERMOMETER, CONF_UNIT_OF_MEASUREMENT, UNIT_CELSIUS, ICON_WATER_PERCENT, UNIT_PERCENT
+from esphome.cpp_helpers import gpio_pin_expression
+from esphome.pins import gpio_input_pullup_pin_schema
+
+dht_ns = cg.esphome_ns.namespace('dht')
+DHTModel = dht_ns.enum('DHTModel')
+DHT_MODELS = {
+    'AUTO_DETECT': DHTModel.DHT_MODEL_AUTO_DETECT,
+    'DHT11': DHTModel.DHT_MODEL_DHT11,
+    'DHT22': DHTModel.DHT_MODEL_DHT22,
+    'AM2302': DHTModel.DHT_MODEL_AM2302,
+    'RHT03': DHTModel.DHT_MODEL_RHT03,
+    'SI7021': DHTModel.DHT_MODEL_SI7021,
+}
+DHT = dht_ns.class_('DHT', cg.PollingComponent)
+
+CONFIG_SCHEMA = cv.Schema({
+    cv.GenerateID(): cv.declare_variable_id(DHT),
+    cv.Required(CONF_PIN): gpio_input_pullup_pin_schema,
+    cv.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.Optional(CONF_ACCURACY_DECIMALS, default=1): sensor.accuracy_decimals,
+        cv.Optional(CONF_ICON, default=ICON_THERMOMETER): sensor.icon,
+        cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_CELSIUS): sensor.unit_of_measurement,
+    })),
+    cv.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.Optional(CONF_ACCURACY_DECIMALS, default=0): sensor.accuracy_decimals,
+        cv.Optional(CONF_ICON, default=ICON_WATER_PERCENT): sensor.icon,
+        cv.Optional(CONF_UNIT_OF_MEASUREMENT, default=UNIT_PERCENT): sensor.unit_of_measurement,
+    })),
+    cv.Optional(CONF_MODEL, default='auto detect'): cv.one_of(*DHT_MODELS, upper=True, space='_'),
+    cv.Optional(CONF_UPDATE_INTERVAL, default='60s'): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA)
+
+
+def to_code(config):
+    pin = yield gpio_pin_expression(config[CONF_PIN])
+    rhs = DHT.new(config[CONF_TEMPERATURE][CONF_NAME],
+                  config[CONF_HUMIDITY][CONF_NAME],
+                  pin, config[CONF_UPDATE_INTERVAL])
+    dht = cg.Pvariable(config[CONF_ID], rhs)
+    yield cg.register_component(dht, config)
+    yield sensor.register_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    yield sensor.register_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+
+    cg.add(dht.set_dht_model(DHT_MODELS[config[CONF_MODEL]]))