esphome 2025.4.1__py3-none-any.whl → 2025.5.0__py3-none-any.whl

esphome/components/feedback/cover.py

@@ -7,7 +7,6 @@ from esphome.const import (
     CONF_CLOSE_ACTION,
     CONF_CLOSE_DURATION,
     CONF_CLOSE_ENDSTOP,
-    CONF_ID,
     CONF_MAX_DURATION,
     CONF_OPEN_ACTION,
     CONF_OPEN_DURATION,
@@ -50,36 +49,43 @@ def validate_infer_endstop(config):
     return config
 
 
-CONFIG_FEEDBACK_COVER_BASE_SCHEMA = cover.COVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(FeedbackCover),
-        cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_OPEN_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_OPEN_OBSTACLE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
-        cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_CLOSE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_CLOSE_OBSTACLE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-        cv.Optional(CONF_MAX_DURATION): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
-        cv.Optional(CONF_ASSUMED_STATE): cv.boolean,
-        cv.Optional(
-            CONF_UPDATE_INTERVAL, "1000ms"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_INFER_ENDSTOP_FROM_MOVEMENT, False): cv.boolean,
-        cv.Optional(
-            CONF_DIRECTION_CHANGE_WAIT_TIME
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(
-            CONF_ACCELERATION_WAIT_TIME, "0s"
-        ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_OBSTACLE_ROLLBACK, default="10%"): cv.percentage,
-    },
-).extend(cv.COMPONENT_SCHEMA)
+CONFIG_FEEDBACK_COVER_BASE_SCHEMA = (
+    cover.cover_schema(FeedbackCover)
+    .extend(
+        {
+            cv.Required(CONF_STOP_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_OPEN_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_OPEN_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_OPEN_SENSOR): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_OPEN_OBSTACLE_SENSOR): cv.use_id(
+                binary_sensor.BinarySensor
+            ),
+            cv.Required(CONF_CLOSE_ACTION): automation.validate_automation(single=True),
+            cv.Required(CONF_CLOSE_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_CLOSE_ENDSTOP): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_CLOSE_SENSOR): cv.use_id(binary_sensor.BinarySensor),
+            cv.Optional(CONF_CLOSE_OBSTACLE_SENSOR): cv.use_id(
+                binary_sensor.BinarySensor
+            ),
+            cv.Optional(CONF_MAX_DURATION): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_HAS_BUILT_IN_ENDSTOP, default=False): cv.boolean,
+            cv.Optional(CONF_ASSUMED_STATE): cv.boolean,
+            cv.Optional(
+                CONF_UPDATE_INTERVAL, "1000ms"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_INFER_ENDSTOP_FROM_MOVEMENT, False): cv.boolean,
+            cv.Optional(
+                CONF_DIRECTION_CHANGE_WAIT_TIME
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(
+                CONF_ACCELERATION_WAIT_TIME, "0s"
+            ): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_OBSTACLE_ROLLBACK, default="10%"): cv.percentage,
+        },
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+)
 
 
 CONFIG_SCHEMA = cv.All(
@@ -90,9 +96,8 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await cover.new_cover(config)
     await cg.register_component(var, config)
-    await cover.register_cover(var, config)
 
     # STOP
     await automation.build_automation(

esphome/components/feedback/feedback_cover.cpp

@@ -1,6 +1,7 @@
 #include "feedback_cover.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace feedback {
@@ -220,7 +221,7 @@ void FeedbackCover::set_open_obstacle_sensor(binary_sensor::BinarySensor *open_o
 void FeedbackCover::loop() {
   if (this->current_operation == COVER_OPERATION_IDLE)
     return;
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
 
   // Recompute position every loop cycle
   this->recompute_position_();

esphome/components/fujitsu_general/climate.py

@@ -1,7 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import climate_ir
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
 
 AUTO_LOAD = ["climate_ir"]
 
@@ -10,13 +8,8 @@ FujitsuGeneralClimate = fujitsu_general_ns.class_(
     "FujitsuGeneralClimate", climate_ir.ClimateIR
 )
 
-CONFIG_SCHEMA = climate_ir.CLIMATE_IR_WITH_RECEIVER_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(FujitsuGeneralClimate),
-    }
-)
+CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(FujitsuGeneralClimate)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await climate_ir.register_climate_ir(var, config)
+    await climate_ir.new_climate_ir(config)

esphome/components/gcja5/gcja5.cpp

@@ -6,6 +6,7 @@
  */
 #include "gcja5.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include <cstring>
 
 namespace esphome {
@@ -16,7 +17,7 @@ static const char *const TAG = "gcja5";
 void GCJA5Component::setup() { ESP_LOGCONFIG(TAG, "Setting up gcja5..."); }
 
 void GCJA5Component::loop() {
-  const uint32_t now = millis();
+  const uint32_t now = App.get_loop_component_start_time();
   if (now - this->last_transmission_ >= 500) {
     // last transmission too long ago. Reset RX index.
     this->rx_message_.clear();

esphome/components/gpio/one_wire/gpio_one_wire.cpp

@@ -10,8 +10,10 @@ static const char *const TAG = "gpio.one_wire";
 void GPIOOneWireBus::setup() {
   ESP_LOGCONFIG(TAG, "Setting up 1-wire bus...");
   this->t_pin_->setup();
-  // clear bus with 480µs high, otherwise initial reset in search might fail
   this->t_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
+  // clear bus with 480µs high, otherwise initial reset in search might fail
+  this->pin_.digital_write(true);
+  this->pin_.pin_mode(gpio::FLAG_OUTPUT);
   delayMicroseconds(480);
   this->search();
 }
@@ -22,40 +24,49 @@ void GPIOOneWireBus::dump_config() {
   this->dump_devices_(TAG);
 }
 
-bool HOT IRAM_ATTR GPIOOneWireBus::reset() {
+int HOT IRAM_ATTR GPIOOneWireBus::reset_int() {
+  InterruptLock lock;
   // See reset here:
   // https://www.maximintegrated.com/en/design/technical-documents/app-notes/1/126.html
   // Wait for communication to clear (delay G)
-  pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
+  this->pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
   uint8_t retries = 125;
   do {
     if (--retries == 0)
-      return false;
+      return -1;
     delayMicroseconds(2);
-  } while (!pin_.digital_read());
+  } while (!this->pin_.digital_read());
 
-  bool r;
+  bool r = false;
 
   // Send 480µs LOW TX reset pulse (drive bus low, delay H)
-  pin_.pin_mode(gpio::FLAG_OUTPUT);
-  pin_.digital_write(false);
+  this->pin_.digital_write(false);
+  this->pin_.pin_mode(gpio::FLAG_OUTPUT);
   delayMicroseconds(480);
 
   // Release the bus, delay I
-  pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
-  delayMicroseconds(70);
+  this->pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
+  uint32_t start = micros();
+  delayMicroseconds(30);
+
+  while (micros() - start < 300) {
+    // sample bus, 0=device(s) present, 1=no device present
+    r = !this->pin_.digital_read();
+    if (r)
+      break;
+    delayMicroseconds(1);
+  }
 
-  // sample bus, 0=device(s) present, 1=no device present
-  r = !pin_.digital_read();
   // delay J
-  delayMicroseconds(410);
-  return r;
+  delayMicroseconds(start + 480 - micros());
+  this->pin_.digital_write(true);
+  this->pin_.pin_mode(gpio::FLAG_OUTPUT);
+  return r ? 1 : 0;
 }
 
 void HOT IRAM_ATTR GPIOOneWireBus::write_bit_(bool bit) {
   // drive bus low
-  pin_.pin_mode(gpio::FLAG_OUTPUT);
-  pin_.digital_write(false);
+  this->pin_.digital_write(false);
 
   // from datasheet:
   // write 0 low time: t_low0: min=60µs, max=120µs
@@ -64,72 +75,62 @@ void HOT IRAM_ATTR GPIOOneWireBus::write_bit_(bool bit) {
   // recovery time: t_rec: min=1µs
   // ds18b20 appears to read the bus after roughly 14µs
   uint32_t delay0 = bit ? 6 : 60;
-  uint32_t delay1 = bit ? 59 : 5;
+  uint32_t delay1 = bit ? 64 : 10;
 
   // delay A/C
   delayMicroseconds(delay0);
   // release bus
-  pin_.digital_write(true);
+  this->pin_.digital_write(true);
   // delay B/D
   delayMicroseconds(delay1);
 }
 
 bool HOT IRAM_ATTR GPIOOneWireBus::read_bit_() {
   // drive bus low
-  pin_.pin_mode(gpio::FLAG_OUTPUT);
-  pin_.digital_write(false);
+  this->pin_.digital_write(false);
 
-  // note: for reading we'll need very accurate timing, as the
-  // timing for the digital_read() is tight; according to the datasheet,
-  // we should read at the end of 16µs starting from the bus low
-  // typically, the ds18b20 pulls the line high after 11µs for a logical 1
-  // and 29µs for a logical 0
-
-  uint32_t start = micros();
-  // datasheet says >1µs
-  delayMicroseconds(2);
+  // datasheet says >= 1µs
+  delayMicroseconds(5);
 
   // release bus, delay E
-  pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
-
-  // measure from start value directly, to get best accurate timing no matter
-  // how long pin_mode/delayMicroseconds took
-  uint32_t now = micros();
-  if (now - start < 12)
-    delayMicroseconds(12 - (now - start));
+  this->pin_.pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
 
+  delayMicroseconds(8);
   // sample bus to read bit from peer
-  bool r = pin_.digital_read();
+  bool r = this->pin_.digital_read();
 
-  // read slot is at least 60µs; get as close to 60µs to spend less time with interrupts locked
-  now = micros();
-  if (now - start < 60)
-    delayMicroseconds(60 - (now - start));
+  // read slot is at least 60µs
+  delayMicroseconds(50);
 
+  this->pin_.digital_write(true);
+  this->pin_.pin_mode(gpio::FLAG_OUTPUT);
   return r;
 }
 
 void IRAM_ATTR GPIOOneWireBus::write8(uint8_t val) {
+  InterruptLock lock;
   for (uint8_t i = 0; i < 8; i++) {
     this->write_bit_(bool((1u << i) & val));
   }
 }
 
 void IRAM_ATTR GPIOOneWireBus::write64(uint64_t val) {
+  InterruptLock lock;
   for (uint8_t i = 0; i < 64; i++) {
     this->write_bit_(bool((1ULL << i) & val));
   }
 }
 
 uint8_t IRAM_ATTR GPIOOneWireBus::read8() {
+  InterruptLock lock;
   uint8_t ret = 0;
-  for (uint8_t i = 0; i < 8; i++) {
+  for (uint8_t i = 0; i < 8; i++)
     ret |= (uint8_t(this->read_bit_()) << i);
-  }
   return ret;
 }
 
 uint64_t IRAM_ATTR GPIOOneWireBus::read64() {
+  InterruptLock lock;
   uint64_t ret = 0;
   for (uint8_t i = 0; i < 8; i++) {
     ret |= (uint64_t(this->read_bit_()) << i);
@@ -144,6 +145,7 @@ void GPIOOneWireBus::reset_search() {
 }
 
 uint64_t IRAM_ATTR GPIOOneWireBus::search_int() {
+  InterruptLock lock;
   if (this->last_device_flag_)
     return 0u;
 

esphome/components/gpio/one_wire/gpio_one_wire.h

@@ -18,7 +18,6 @@ class GPIOOneWireBus : public one_wire::OneWireBus, public Component {
     this->pin_ = pin->to_isr();
   }
 
-  bool reset() override;
   void write8(uint8_t val) override;
   void write64(uint64_t val) override;
   uint8_t read8() override;
@@ -31,10 +30,12 @@ class GPIOOneWireBus : public one_wire::OneWireBus, public Component {
   bool last_device_flag_{false};
   uint64_t address_;
 
+  int reset_int() override;
   void reset_search() override;
   uint64_t search_int() override;
   void write_bit_(bool bit);
   bool read_bit_();
+  bool read_bit_(uint32_t *t);
 };
 
 }  // namespace gpio

esphome/components/gpio_expander/cached_gpio.h

@@ -8,30 +8,45 @@ namespace esphome {
 namespace gpio_expander {
 
 /// @brief A class to cache the read state of a GPIO expander.
+///        This class caches reads between GPIO Pins which are on the same bank.
+///        This means that for reading whole Port (ex. 8 pins) component needs only one
+///        I2C/SPI read per main loop call. It assumes, that one bit in byte identifies one GPIO pin
+///        Template parameters:
+///           T - Type which represents internal register. Could be uint8_t or uint16_t. Adjust to
+///               match size of your internal GPIO bank register.
+///           N - Number of pins
 template<typename T, T N> class CachedGpioExpander {
  public:
   bool digital_read(T pin) {
-    if (!this->read_cache_invalidated_[pin]) {
-      this->read_cache_invalidated_[pin] = true;
-      return this->digital_read_cache(pin);
+    uint8_t bank = pin / (sizeof(T) * BITS_PER_BYTE);
+    if (this->read_cache_invalidated_[bank]) {
+      this->read_cache_invalidated_[bank] = false;
+      if (!this->digital_read_hw(pin))
+        return false;
     }
-    return this->digital_read_hw(pin);
+    return this->digital_read_cache(pin);
   }
 
   void digital_write(T pin, bool value) { this->digital_write_hw(pin, value); }
 
  protected:
+  /// @brief Call component low level function to read GPIO state from device
   virtual bool digital_read_hw(T pin) = 0;
+  /// @brief Call component read function from internal cache.
   virtual bool digital_read_cache(T pin) = 0;
+  /// @brief Call component low level function to write GPIO state to device
   virtual void digital_write_hw(T pin, bool value) = 0;
+  const uint8_t cache_byte_size_ = N / (sizeof(T) * BITS_PER_BYTE);
 
+  /// @brief Invalidate cache. This function should be called in component loop().
   void reset_pin_cache_() {
-    for (T i = 0; i < N; i++) {
-      this->read_cache_invalidated_[i] = false;
+    for (T i = 0; i < this->cache_byte_size_; i++) {
+      this->read_cache_invalidated_[i] = true;
     }
   }
 
-  std::array<bool, N> read_cache_invalidated_{};
+  static const uint8_t BITS_PER_BYTE = 8;
+  std::array<bool, N / (sizeof(T) * BITS_PER_BYTE)> read_cache_invalidated_{};
 };
 
 }  // namespace gpio_expander

esphome/components/gps/__init__.py

@@ -9,22 +9,32 @@ from esphome.const import (
     CONF_LONGITUDE,
     CONF_SATELLITES,
     CONF_SPEED,
+    DEVICE_CLASS_SPEED,
     STATE_CLASS_MEASUREMENT,
     UNIT_DEGREES,
     UNIT_KILOMETER_PER_HOUR,
     UNIT_METER,
 )
 
+CONF_GPS_ID = "gps_id"
+CONF_HDOP = "hdop"
+
+ICON_ALTIMETER = "mdi:altimeter"
+ICON_COMPASS = "mdi:compass"
+ICON_LATITUDE = "mdi:latitude"
+ICON_LONGITUDE = "mdi:longitude"
+ICON_SATELLITE = "mdi:satellite-variant"
+ICON_SPEEDOMETER = "mdi:speedometer"
+
 DEPENDENCIES = ["uart"]
 AUTO_LOAD = ["sensor"]
 
-CODEOWNERS = ["@coogle"]
+CODEOWNERS = ["@coogle", "@ximex"]
 
 gps_ns = cg.esphome_ns.namespace("gps")
 GPS = gps_ns.class_("GPS", cg.Component, uart.UARTDevice)
 GPSListener = gps_ns.class_("GPSListener")
 
-CONF_GPS_ID = "gps_id"
 MULTI_CONF = True
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
@@ -32,28 +42,44 @@ CONFIG_SCHEMA = cv.All(
             cv.GenerateID(): cv.declare_id(GPS),
             cv.Optional(CONF_LATITUDE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_DEGREES,
+                icon=ICON_LATITUDE,
                 accuracy_decimals=6,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_LONGITUDE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_DEGREES,
+                icon=ICON_LONGITUDE,
                 accuracy_decimals=6,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_SPEED): sensor.sensor_schema(
                 unit_of_measurement=UNIT_KILOMETER_PER_HOUR,
-                accuracy_decimals=6,
+                icon=ICON_SPEEDOMETER,
+                accuracy_decimals=3,
+                device_class=DEVICE_CLASS_SPEED,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_COURSE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_DEGREES,
+                icon=ICON_COMPASS,
                 accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_ALTITUDE): sensor.sensor_schema(
                 unit_of_measurement=UNIT_METER,
-                accuracy_decimals=1,
+                icon=ICON_ALTIMETER,
+                accuracy_decimals=2,
+                state_class=STATE_CLASS_MEASUREMENT,
             ),
             cv.Optional(CONF_SATELLITES): sensor.sensor_schema(
+                icon=ICON_SATELLITE,
                 accuracy_decimals=0,
                 state_class=STATE_CLASS_MEASUREMENT,
             ),
+            cv.Optional(CONF_HDOP): sensor.sensor_schema(
+                accuracy_decimals=3,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
         }
     )
     .extend(cv.polling_component_schema("20s"))
@@ -68,29 +94,33 @@ async def to_code(config):
     await cg.register_component(var, config)
     await uart.register_uart_device(var, config)
 
-    if CONF_LATITUDE in config:
-        sens = await sensor.new_sensor(config[CONF_LATITUDE])
+    if latitude_config := config.get(CONF_LATITUDE):
+        sens = await sensor.new_sensor(latitude_config)
         cg.add(var.set_latitude_sensor(sens))
 
-    if CONF_LONGITUDE in config:
-        sens = await sensor.new_sensor(config[CONF_LONGITUDE])
+    if longitude_config := config.get(CONF_LONGITUDE):
+        sens = await sensor.new_sensor(longitude_config)
         cg.add(var.set_longitude_sensor(sens))
 
-    if CONF_SPEED in config:
-        sens = await sensor.new_sensor(config[CONF_SPEED])
+    if speed_config := config.get(CONF_SPEED):
+        sens = await sensor.new_sensor(speed_config)
         cg.add(var.set_speed_sensor(sens))
 
-    if CONF_COURSE in config:
-        sens = await sensor.new_sensor(config[CONF_COURSE])
+    if course_config := config.get(CONF_COURSE):
+        sens = await sensor.new_sensor(course_config)
         cg.add(var.set_course_sensor(sens))
 
-    if CONF_ALTITUDE in config:
-        sens = await sensor.new_sensor(config[CONF_ALTITUDE])
+    if altitude_config := config.get(CONF_ALTITUDE):
+        sens = await sensor.new_sensor(altitude_config)
         cg.add(var.set_altitude_sensor(sens))
 
-    if CONF_SATELLITES in config:
-        sens = await sensor.new_sensor(config[CONF_SATELLITES])
+    if satellites_config := config.get(CONF_SATELLITES):
+        sens = await sensor.new_sensor(satellites_config)
         cg.add(var.set_satellites_sensor(sens))
 
+    if hdop_config := config.get(CONF_HDOP):
+        sens = await sensor.new_sensor(hdop_config)
+        cg.add(var.set_hdop_sensor(sens))
+
     # https://platformio.org/lib/show/1655/TinyGPSPlus
-    cg.add_library("mikalhart/TinyGPSPlus", "1.0.2")
+    cg.add_library("mikalhart/TinyGPSPlus", "1.1.0")

esphome/components/gps/gps.cpp

@@ -10,6 +10,17 @@ static const char *const TAG = "gps";
 
 TinyGPSPlus &GPSListener::get_tiny_gps() { return this->parent_->get_tiny_gps(); }
 
+void GPS::dump_config() {
+  ESP_LOGCONFIG(TAG, "GPS:");
+  LOG_SENSOR("  ", "Latitude", this->latitude_sensor_);
+  LOG_SENSOR("  ", "Longitude", this->longitude_sensor_);
+  LOG_SENSOR("  ", "Speed", this->speed_sensor_);
+  LOG_SENSOR("  ", "Course", this->course_sensor_);
+  LOG_SENSOR("  ", "Altitude", this->altitude_sensor_);
+  LOG_SENSOR("  ", "Satellites", this->satellites_sensor_);
+  LOG_SENSOR("  ", "HDOP", this->hdop_sensor_);
+}
+
 void GPS::update() {
   if (this->latitude_sensor_ != nullptr)
     this->latitude_sensor_->publish_state(this->latitude_);
@@ -28,43 +39,51 @@ void GPS::update() {
 
   if (this->satellites_sensor_ != nullptr)
     this->satellites_sensor_->publish_state(this->satellites_);
+
+  if (this->hdop_sensor_ != nullptr)
+    this->hdop_sensor_->publish_state(this->hdop_);
 }
 
 void GPS::loop() {
-  while (this->available() && !this->has_time_) {
+  while (this->available() > 0 && !this->has_time_) {
     if (this->tiny_gps_.encode(this->read())) {
-      if (tiny_gps_.location.isUpdated()) {
-        this->latitude_ = tiny_gps_.location.lat();
-        this->longitude_ = tiny_gps_.location.lng();
+      if (this->tiny_gps_.location.isUpdated()) {
+        this->latitude_ = this->tiny_gps_.location.lat();
+        this->longitude_ = this->tiny_gps_.location.lng();
 
         ESP_LOGD(TAG, "Location:");
-        ESP_LOGD(TAG, "  Lat: %f", this->latitude_);
-        ESP_LOGD(TAG, "  Lon: %f", this->longitude_);
+        ESP_LOGD(TAG, "  Lat: %.6f °", this->latitude_);
+        ESP_LOGD(TAG, "  Lon: %.6f °", this->longitude_);
       }
 
-      if (tiny_gps_.speed.isUpdated()) {
-        this->speed_ = tiny_gps_.speed.kmph();
-        ESP_LOGD(TAG, "Speed:");
-        ESP_LOGD(TAG, "  %f km/h", this->speed_);
+      if (this->tiny_gps_.speed.isUpdated()) {
+        this->speed_ = this->tiny_gps_.speed.kmph();
+        ESP_LOGD(TAG, "Speed: %.3f km/h", this->speed_);
       }
-      if (tiny_gps_.course.isUpdated()) {
-        this->course_ = tiny_gps_.course.deg();
-        ESP_LOGD(TAG, "Course:");
-        ESP_LOGD(TAG, "  %f °", this->course_);
+
+      if (this->tiny_gps_.course.isUpdated()) {
+        this->course_ = this->tiny_gps_.course.deg();
+        ESP_LOGD(TAG, "Course: %.2f °", this->course_);
       }
-      if (tiny_gps_.altitude.isUpdated()) {
-        this->altitude_ = tiny_gps_.altitude.meters();
-        ESP_LOGD(TAG, "Altitude:");
-        ESP_LOGD(TAG, "  %f m", this->altitude_);
+
+      if (this->tiny_gps_.altitude.isUpdated()) {
+        this->altitude_ = this->tiny_gps_.altitude.meters();
+        ESP_LOGD(TAG, "Altitude: %.2f m", this->altitude_);
       }
-      if (tiny_gps_.satellites.isUpdated()) {
-        this->satellites_ = tiny_gps_.satellites.value();
-        ESP_LOGD(TAG, "Satellites:");
-        ESP_LOGD(TAG, "  %d", this->satellites_);
+
+      if (this->tiny_gps_.satellites.isUpdated()) {
+        this->satellites_ = this->tiny_gps_.satellites.value();
+        ESP_LOGD(TAG, "Satellites: %d", this->satellites_);
+      }
+
+      if (this->tiny_gps_.hdop.isUpdated()) {
+        this->hdop_ = this->tiny_gps_.hdop.hdop();
+        ESP_LOGD(TAG, "HDOP: %.3f", this->hdop_);
       }
 
-      for (auto *listener : this->listeners_)
+      for (auto *listener : this->listeners_) {
         listener->on_update(this->tiny_gps_);
+      }
     }
   }
 }