esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/prometheus/prometheus_handler.h

@@ -60,54 +60,72 @@ class PrometheusHandler : public AsyncWebHandler, public Component {
  protected:
   std::string relabel_id_(EntityBase *obj);
   std::string relabel_name_(EntityBase *obj);
+  void add_area_label_(AsyncResponseStream *stream, std::string &area);
+  void add_node_label_(AsyncResponseStream *stream, std::string &node);
+  void add_friendly_name_label_(AsyncResponseStream *stream, std::string &friendly_name);
 
 #ifdef USE_SENSOR
   /// Return the type for prometheus
   void sensor_type_(AsyncResponseStream *stream);
   /// Return the sensor state as prometheus data point
-  void sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj);
+  void sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj, std::string &area, std::string &node,
+                   std::string &friendly_name);
 #endif
 
 #ifdef USE_BINARY_SENSOR
   /// Return the type for prometheus
   void binary_sensor_type_(AsyncResponseStream *stream);
   /// Return the sensor state as prometheus data point
-  void binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj);
+  void binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj, std::string &area,
+                          std::string &node, std::string &friendly_name);
 #endif
 
 #ifdef USE_FAN
   /// Return the type for prometheus
   void fan_type_(AsyncResponseStream *stream);
   /// Return the sensor state as prometheus data point
-  void fan_row_(AsyncResponseStream *stream, fan::Fan *obj);
+  void fan_row_(AsyncResponseStream *stream, fan::Fan *obj, std::string &area, std::string &node,
+                std::string &friendly_name);
 #endif
 
 #ifdef USE_LIGHT
   /// Return the type for prometheus
   void light_type_(AsyncResponseStream *stream);
   /// Return the Light Values state as prometheus data point
-  void light_row_(AsyncResponseStream *stream, light::LightState *obj);
+  void light_row_(AsyncResponseStream *stream, light::LightState *obj, std::string &area, std::string &node,
+                  std::string &friendly_name);
 #endif
 
 #ifdef USE_COVER
   /// Return the type for prometheus
   void cover_type_(AsyncResponseStream *stream);
   /// Return the switch Values state as prometheus data point
-  void cover_row_(AsyncResponseStream *stream, cover::Cover *obj);
+  void cover_row_(AsyncResponseStream *stream, cover::Cover *obj, std::string &area, std::string &node,
+                  std::string &friendly_name);
 #endif
 
 #ifdef USE_SWITCH
   /// Return the type for prometheus
   void switch_type_(AsyncResponseStream *stream);
   /// Return the switch Values state as prometheus data point
-  void switch_row_(AsyncResponseStream *stream, switch_::Switch *obj);
+  void switch_row_(AsyncResponseStream *stream, switch_::Switch *obj, std::string &area, std::string &node,
+                   std::string &friendly_name);
 #endif
 
 #ifdef USE_LOCK
   /// Return the type for prometheus
   void lock_type_(AsyncResponseStream *stream);
   /// Return the lock Values state as prometheus data point
-  void lock_row_(AsyncResponseStream *stream, lock::Lock *obj);
+  void lock_row_(AsyncResponseStream *stream, lock::Lock *obj, std::string &area, std::string &node,
+                 std::string &friendly_name);
+#endif
+
+#ifdef USE_TEXT_SENSOR
+  /// Return the type for prometheus
+  void text_sensor_type_(AsyncResponseStream *stream);
+  /// Return the lock Values state as prometheus data point
+  void text_sensor_row_(AsyncResponseStream *stream, text_sensor::TextSensor *obj, std::string &area, std::string &node,
+                        std::string &friendly_name);
 #endif
 
   web_server_base::WebServerBase *base_;

esphome/components/qspi_amoled/display.py

@@ -1,143 +1,3 @@
-import esphome.codegen as cg
 import esphome.config_validation as cv
-from esphome import pins
-from esphome.components import (
-    spi,
-    display,
-)
-from esphome.const import (
-    CONF_RESET_PIN,
-    CONF_ID,
-    CONF_DIMENSIONS,
-    CONF_WIDTH,
-    CONF_HEIGHT,
-    CONF_LAMBDA,
-    CONF_BRIGHTNESS,
-    CONF_ENABLE_PIN,
-    CONF_MODEL,
-    CONF_OFFSET_HEIGHT,
-    CONF_OFFSET_WIDTH,
-    CONF_INVERT_COLORS,
-    CONF_MIRROR_X,
-    CONF_MIRROR_Y,
-    CONF_SWAP_XY,
-    CONF_COLOR_ORDER,
-    CONF_TRANSFORM,
-)
 
-DEPENDENCIES = ["spi"]
-
-qspi_amoled_ns = cg.esphome_ns.namespace("qspi_amoled")
-QSPI_AMOLED = qspi_amoled_ns.class_(
-    "QspiAmoLed", display.Display, display.DisplayBuffer, cg.Component, spi.SPIDevice
-)
-ColorOrder = display.display_ns.enum("ColorMode")
-Model = qspi_amoled_ns.enum("Model")
-
-MODELS = {"RM690B0": Model.RM690B0, "RM67162": Model.RM67162}
-
-COLOR_ORDERS = {
-    "RGB": ColorOrder.COLOR_ORDER_RGB,
-    "BGR": ColorOrder.COLOR_ORDER_BGR,
-}
-DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
-
-
-def validate_dimension(value):
-    value = cv.positive_int(value)
-    if value % 2 != 0:
-        raise cv.Invalid("Width/height/offset must be divisible by 2")
-    return value
-
-
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
-        cv.Schema(
-            {
-                cv.GenerateID(): cv.declare_id(QSPI_AMOLED),
-                cv.Required(CONF_MODEL): cv.enum(MODELS, upper=True),
-                cv.Required(CONF_DIMENSIONS): cv.Any(
-                    cv.dimensions,
-                    cv.Schema(
-                        {
-                            cv.Required(CONF_WIDTH): validate_dimension,
-                            cv.Required(CONF_HEIGHT): validate_dimension,
-                            cv.Optional(
-                                CONF_OFFSET_HEIGHT, default=0
-                            ): validate_dimension,
-                            cv.Optional(
-                                CONF_OFFSET_WIDTH, default=0
-                            ): validate_dimension,
-                        }
-                    ),
-                ),
-                cv.Optional(CONF_TRANSFORM): cv.Schema(
-                    {
-                        cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
-                        cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
-                        cv.Optional(CONF_SWAP_XY, default=False): cv.boolean,
-                    }
-                ),
-                cv.Optional(CONF_COLOR_ORDER, default="RGB"): cv.enum(
-                    COLOR_ORDERS, upper=True
-                ),
-                cv.Optional(CONF_INVERT_COLORS, default=False): cv.boolean,
-                cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
-                cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
-                cv.Optional(CONF_BRIGHTNESS, default=0xD0): cv.int_range(
-                    0, 0xFF, min_included=True, max_included=True
-                ),
-            }
-        ).extend(
-            spi.spi_device_schema(
-                cs_pin_required=False,
-                default_mode="MODE0",
-                default_data_rate=10e6,
-                quad=True,
-            )
-        )
-    ),
-    cv.only_with_esp_idf,
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await display.register_display(var, config)
-    await spi.register_spi_device(var, config)
-
-    cg.add(var.set_color_mode(config[CONF_COLOR_ORDER]))
-    cg.add(var.set_invert_colors(config[CONF_INVERT_COLORS]))
-    cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
-    cg.add(var.set_model(config[CONF_MODEL]))
-    if enable_pin := config.get(CONF_ENABLE_PIN):
-        enable = await cg.gpio_pin_expression(enable_pin)
-        cg.add(var.set_enable_pin(enable))
-
-    if reset_pin := config.get(CONF_RESET_PIN):
-        reset = await cg.gpio_pin_expression(reset_pin)
-        cg.add(var.set_reset_pin(reset))
-
-    if transform := config.get(CONF_TRANSFORM):
-        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
-        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
-        cg.add(var.set_swap_xy(transform[CONF_SWAP_XY]))
-
-    if CONF_DIMENSIONS in config:
-        dimensions = config[CONF_DIMENSIONS]
-        if isinstance(dimensions, dict):
-            cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
-            cg.add(
-                var.set_offsets(
-                    dimensions[CONF_OFFSET_WIDTH], dimensions[CONF_OFFSET_HEIGHT]
-                )
-            )
-        else:
-            (width, height) = dimensions
-            cg.add(var.set_dimensions(width, height))
-
-    if lamb := config.get(CONF_LAMBDA):
-        lambda_ = await cg.process_lambda(
-            lamb, [(display.DisplayRef, "it")], return_type=cg.void
-        )
-        cg.add(var.set_writer(lambda_))
+CONFIG_SCHEMA = cv.invalid("The qspi_amoled component has been renamed to qspi_dbi")

esphome/components/qspi_dbi/display.py

@@ -0,0 +1,185 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import display, spi
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_BRIGHTNESS,
+    CONF_COLOR_ORDER,
+    CONF_DIMENSIONS,
+    CONF_ENABLE_PIN,
+    CONF_HEIGHT,
+    CONF_ID,
+    CONF_INIT_SEQUENCE,
+    CONF_INVERT_COLORS,
+    CONF_LAMBDA,
+    CONF_MIRROR_X,
+    CONF_MIRROR_Y,
+    CONF_MODEL,
+    CONF_OFFSET_HEIGHT,
+    CONF_OFFSET_WIDTH,
+    CONF_RESET_PIN,
+    CONF_SWAP_XY,
+    CONF_TRANSFORM,
+    CONF_WIDTH,
+)
+from esphome.core import TimePeriod
+
+from .models import DriverChip
+
+DEPENDENCIES = ["spi"]
+
+qspi_dbi_ns = cg.esphome_ns.namespace("qspi_dbi")
+QSPI_DBI = qspi_dbi_ns.class_(
+    "QspiDbi", display.Display, display.DisplayBuffer, cg.Component, spi.SPIDevice
+)
+ColorOrder = display.display_ns.enum("ColorMode")
+Model = qspi_dbi_ns.enum("Model")
+
+COLOR_ORDERS = {
+    "RGB": ColorOrder.COLOR_ORDER_RGB,
+    "BGR": ColorOrder.COLOR_ORDER_BGR,
+}
+DATA_PIN_SCHEMA = pins.internal_gpio_output_pin_schema
+
+CONF_DRAW_FROM_ORIGIN = "draw_from_origin"
+DELAY_FLAG = 0xFF
+
+
+def validate_dimension(value):
+    value = cv.positive_int(value)
+    if value % 2 != 0:
+        raise cv.Invalid("Width/height/offset must be divisible by 2")
+    return value
+
+
+def map_sequence(value):
+    """
+    The format is a repeated sequence of [CMD, <data>] where <data> is s a sequence of bytes. The length is inferred
+    from the length of the sequence and should not be explicit.
+    A delay can be inserted by specifying "- delay N" where N is in ms
+    """
+    if isinstance(value, str) and value.lower().startswith("delay "):
+        value = value.lower()[6:]
+        delay = cv.All(
+            cv.positive_time_period_milliseconds,
+            cv.Range(TimePeriod(milliseconds=1), TimePeriod(milliseconds=255)),
+        )(value)
+        return [delay, DELAY_FLAG]
+    value = cv.Length(min=1, max=254)(value)
+    params = value[1:]
+    return [value[0], len(params)] + list(params)
+
+
+def _validate(config):
+    chip = DriverChip.chips[config[CONF_MODEL]]
+    if not chip.initsequence:
+        if CONF_INIT_SEQUENCE not in config:
+            raise cv.Invalid(f"{chip.name} model requires init_sequence")
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    display.FULL_DISPLAY_SCHEMA.extend(
+        cv.Schema(
+            {
+                cv.GenerateID(): cv.declare_id(QSPI_DBI),
+                cv.Required(CONF_MODEL): cv.one_of(
+                    *DriverChip.chips.keys(), upper=True
+                ),
+                cv.Optional(CONF_INIT_SEQUENCE): cv.ensure_list(map_sequence),
+                cv.Required(CONF_DIMENSIONS): cv.Any(
+                    cv.dimensions,
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_WIDTH): validate_dimension,
+                            cv.Required(CONF_HEIGHT): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_HEIGHT, default=0
+                            ): validate_dimension,
+                            cv.Optional(
+                                CONF_OFFSET_WIDTH, default=0
+                            ): validate_dimension,
+                        }
+                    ),
+                ),
+                cv.Optional(CONF_TRANSFORM): cv.Schema(
+                    {
+                        cv.Optional(CONF_MIRROR_X, default=False): cv.boolean,
+                        cv.Optional(CONF_MIRROR_Y, default=False): cv.boolean,
+                        cv.Optional(CONF_SWAP_XY, default=False): cv.boolean,
+                    }
+                ),
+                cv.Optional(CONF_COLOR_ORDER, default="RGB"): cv.enum(
+                    COLOR_ORDERS, upper=True
+                ),
+                cv.Optional(CONF_INVERT_COLORS, default=False): cv.boolean,
+                cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+                cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
+                cv.Optional(CONF_BRIGHTNESS, default=0xD0): cv.int_range(
+                    0, 0xFF, min_included=True, max_included=True
+                ),
+                cv.Optional(CONF_DRAW_FROM_ORIGIN, default=False): cv.boolean,
+            }
+        ).extend(
+            spi.spi_device_schema(
+                cs_pin_required=False,
+                default_mode="MODE0",
+                default_data_rate=10e6,
+                quad=True,
+            )
+        )
+    ),
+    cv.only_with_esp_idf,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await display.register_display(var, config)
+    await spi.register_spi_device(var, config)
+
+    chip = DriverChip.chips[config[CONF_MODEL]]
+    if chip.initsequence:
+        cg.add(var.add_init_sequence(chip.initsequence))
+    if init_sequences := config.get(CONF_INIT_SEQUENCE):
+        sequence = []
+        for seq in init_sequences:
+            sequence.extend(seq)
+        cg.add(var.add_init_sequence(sequence))
+
+    cg.add(var.set_color_mode(config[CONF_COLOR_ORDER]))
+    cg.add(var.set_invert_colors(config[CONF_INVERT_COLORS]))
+    cg.add(var.set_brightness(config[CONF_BRIGHTNESS]))
+    cg.add(var.set_model(config[CONF_MODEL]))
+    cg.add(var.set_draw_from_origin(config[CONF_DRAW_FROM_ORIGIN]))
+    if enable_pin := config.get(CONF_ENABLE_PIN):
+        enable = await cg.gpio_pin_expression(enable_pin)
+        cg.add(var.set_enable_pin(enable))
+
+    if reset_pin := config.get(CONF_RESET_PIN):
+        reset = await cg.gpio_pin_expression(reset_pin)
+        cg.add(var.set_reset_pin(reset))
+
+    if transform := config.get(CONF_TRANSFORM):
+        cg.add(var.set_mirror_x(transform[CONF_MIRROR_X]))
+        cg.add(var.set_mirror_y(transform[CONF_MIRROR_Y]))
+        cg.add(var.set_swap_xy(transform[CONF_SWAP_XY]))
+
+    if CONF_DIMENSIONS in config:
+        dimensions = config[CONF_DIMENSIONS]
+        if isinstance(dimensions, dict):
+            cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
+            cg.add(
+                var.set_offsets(
+                    dimensions[CONF_OFFSET_WIDTH], dimensions[CONF_OFFSET_HEIGHT]
+                )
+            )
+        else:
+            (width, height) = dimensions
+            cg.add(var.set_dimensions(width, height))
+
+    if lamb := config.get(CONF_LAMBDA):
+        lambda_ = await cg.process_lambda(
+            lamb, [(display.DisplayRef, "it")], return_type=cg.void
+        )
+        cg.add(var.set_writer(lambda_))

esphome/components/qspi_dbi/models.py

@@ -0,0 +1,64 @@
+# Commands
+SW_RESET_CMD = 0x01
+SLEEP_OUT = 0x11
+INVERT_OFF = 0x20
+INVERT_ON = 0x21
+ALL_ON = 0x23
+WRAM = 0x24
+MIPI = 0x26
+DISPLAY_OFF = 0x28
+DISPLAY_ON = 0x29
+RASET = 0x2B
+CASET = 0x2A
+WDATA = 0x2C
+TEON = 0x35
+MADCTL_CMD = 0x36
+PIXFMT = 0x3A
+BRIGHTNESS = 0x51
+SWIRE1 = 0x5A
+SWIRE2 = 0x5B
+PAGESEL = 0xFE
+
+
+class DriverChip:
+    chips = {}
+
+    def __init__(self, name: str):
+        name = name.upper()
+        self.name = name
+        self.chips[name] = self
+        self.initsequence = []
+
+    def cmd(self, c, *args):
+        """
+        Add a command sequence to the init sequence
+        :param c: The command (8 bit)
+        :param args: zero or more arguments (8 bit values)
+        """
+        self.initsequence.extend([c, len(args)] + list(args))
+
+    def delay(self, ms):
+        self.initsequence.extend([ms, 0xFF])
+
+
+chip = DriverChip("RM67162")
+chip.cmd(PIXFMT, 0x55)
+chip.cmd(BRIGHTNESS, 0)
+
+chip = DriverChip("RM690B0")
+chip.cmd(PAGESEL, 0x20)
+chip.cmd(MIPI, 0x0A)
+chip.cmd(WRAM, 0x80)
+chip.cmd(SWIRE1, 0x51)
+chip.cmd(SWIRE2, 0x2E)
+chip.cmd(PAGESEL, 0x00)
+chip.cmd(0xC2, 0x00)
+chip.delay(10)
+chip.cmd(TEON, 0x00)
+
+chip = DriverChip("AXS15231")
+chip.cmd(0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5A, 0xA5)
+chip.cmd(0xC1, 0x33)
+chip.cmd(0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
+
+DriverChip("Custom")