Beachte hier die type: diese müssen mit den Daten (Summary:) in deiner ICS übereinstimmen.

waste_collection_schedule:
  sources:
    - name: ics
      args:
        file: "www/muell.ics"
      customize:
        - type: Restabfall
          alias: Restabfall
          icon: mdi:trash-can
        - type: Papiertonne
          alias: Papiertonne
          icon: mdi:trash-can
        - type: Bioabfall
          alias: Bioabfall
          icon: mdi:trash-can
        - type: Plastikabfall
          alias: Plastikabfall
          icon: mdi:trash-can

  fetch_time: "04:00"
  day_switch_time: "10:00"

sensor: !include sensor.yaml

########################## Müllabfuhr ###########################

- platform: waste_collection_schedule
  name: Papierabfall_date
  value_template: '{{value.date.strftime("%d.%m.%Y")}}'
  types:
    - Papiertonne
- platform: waste_collection_schedule
  name: Papierabfall_collection
  value_template: "{{value.daysTo}}"
  types:
    - Papiertonne

- platform: waste_collection_schedule
  name: Restmuelltonne_date
  value_template: '{{value.date.strftime("%d.%m.%Y")}}'
  types:
    - Restabfall
- platform: waste_collection_schedule
  name: Restmuelltonne_collection
  value_template: "{{value.daysTo}}"
  types:
    - Restabfall

- platform: waste_collection_schedule
  name: Plastiktonne_date
  value_template: '{{value.date.strftime("%d.%m.%Y")}}'
  types:
    - Plastikabfall
- platform: waste_collection_schedule
  name: Plastikmuelltonne_collection
  value_template: "{{value.daysTo}}"
  types:
    - Plastikabfall

- platform: waste_collection_schedule
  name: Biotonne_date
  value_template: '{{value.date.strftime("%d.%m.%Y")}}'
  types:
    - Bioabfall
- platform: waste_collection_schedule
  name: Biotonne_collection
  value_template: "{{value.daysTo}}"
  types:
    - Bioabfall

- platform: waste_collection_schedule
  name: next_waste_collection_daysto
  details_format: upcoming
  value_template: '{{value.types|join(", ")}} in {{value.daysTo}} Tagen'

  #button-card#
- platform: waste_collection_schedule
  name: MyButtonCardSensor
  value_template: '{{value.types|join(", ")}}|{{value.daysTo}}|{{value.date.strftime("%d.%m.%Y")}}|{{value.date.strftime("%a")}}'

type: entities
entities:
  - entity: sensor.restmuelltonne_date
    style: |
      :host {
        color: grey;
      }      
    icon: mdi:delete-empty
    show_state: false
    type: custom:multiple-entity-row
    name: Restmüll
    secondary_info: false
    entities:
      - entity: sensor.restmuelltonne_collection
        name: Abholung in
        unit: Tage(n)
      - entity: sensor.restmuelltonne_date
        name: Datum
  - entity: sensor.biotonne_date
    style: |
      :host {
        color: brown;
      }  
    icon: mdi:bio
    show_state: false
    type: custom:multiple-entity-row
    name: Bio Müll
    secondary_info: false
    entities:
      - entity: sensor.biotonne_collection
        name: Abholung in
        unit: Tage(n)
      - entity: sensor.biotonne_date
        name: Datum
  - entity: sensor.papierabfall_date
    style: |
      :host {
        color: turquoise
      }  
    icon: mdi:tree
    show_state: false
    type: custom:multiple-entity-row
    name: Papiertonne
    secondary_info: false
    entities:
      - entity: sensor.papierabfall_collection
        name: Abholung in
        unit: Tage(n)
      - entity: sensor.papierabfall_date
        name: Datum
  - entity: sensor.plastiktonne_date
    style: |
      :host {
        color: yellow
      }  
    icon: mdi:recycle
    show_state: false
    type: custom:multiple-entity-row
    name: Plastik Sack
    secondary_info: false
    entities:
      - entity: sensor.plastikmuelltonne_collection
        name: Abholung in
        unit: Tage(n)
      - entity: sensor.plastiktonne_date
        name: Datum
  - entity: sensor.mybuttoncardsensor
    type: custom:button-card
    layout: icon_name_state2nd
    show_label: true
    label: |
      [[[
       var days_to = entity.state.split("|")[1]
       if (days_to == 0)
       { return "Heute" }
       else if (days_to == 1)
       { return "Morgen" }
       else
       { return "in " + days_to + " Tagen" }
      ]]]
    show_name: true
    name: |
      [[[
        return entity.state.split("|")[0]
      ]]]
    state:
      - color: red
        operator: template
        value: '[[[ return entity.state.split("|")[1] == 0 ]]]'
      - color: orange
        operator: template
        value: '[[[ return entity.state.split("|")[1] == 1 ]]]'
      - value: default
show_header_toggle: true

Hier meine Automation die mich per Push erinnert und zusätzlich per Alexa wenn wir zuhause sind.

alias: Benachrichtigung Müll Bio morgen
description: ""
trigger:
  - platform: time
    at: "21:01:00"
condition:
  - condition: state
    entity_id: sensor.biotonne_collection
    state: "1"
action:
  - service: notify.all_devices
    data:
      message: Biotonne raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Biotonne raus stellen!
mode: single

alias: Benachrichtigung Müll Biotonne
description: ""
trigger:
  - platform: time
    at: "07:00:00"
condition:
  - condition: state
    entity_id: sensor.biotonne_collection
    state: "0"
action:
  - service: notify.all_devices
    data:
      message: Biotonne raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Biotonne raus stellen!
mode: single

alias: Benachrichtigung Müll Rest morgen
description: ""
trigger:
  - platform: time
    at: "21:00:00"
condition:
  - condition: state
    entity_id: sensor.restmuelltonne_collection
    state: "1"
action:
  - service: notify.all_devices
    data:
      message: Restmüll raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Restmüll raus stellen!
mode: single

alias: Benachrichtigung Müll Restmüll
description: ""
trigger:
  - platform: time
    at: "07:00:00"
condition:
  - condition: state
    entity_id: sensor.restmuelltonne_collection
    state: "0"
action:
  - service: notify.all_devices
    data:
      message: Restmüll raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Restmüll raus stellen!
mode: single

alias: Benachrichtigung Müll Papier morgen
description: ""
trigger:
  - platform: time
    at: "21:00:00"
condition:
  - condition: state
    entity_id: sensor.papierabfall_collection
    state: "1"
action:
  - service: notify.all_devices
    data:
      message: Papiertonne raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Papiertonne raus stellen!
mode: single

alias: Benachrichtigung Müll Papier
description: ""
trigger:
  - platform: time
    at: "07:00:00"
condition:
  - condition: state
    entity_id: sensor.papierabfall_collection
    state: "0"
action:
  - service: notify.all_devices
    data:
      message: Papiertonne raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Papiertonne raus stellen!
mode: single

alias: Benachrichtigung Müll Plastik morgen
description: ""
trigger:
  - platform: time
    at: "21:00:00"
condition:
  - condition: state
    entity_id: sensor.plastikmuelltonne_collection
    state: "1"
action:
  - service: notify.all_devices
    data:
      message: Plastik raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Plastik raus stellen!
mode: single

alias: Benachrichtigung Müll Plastik
description: ""
trigger:
  - platform: time
    at: "07:00:00"
condition:
  - condition: state
    entity_id: sensor.plastikmuelltonne_collection
    state: "0"
action:
  - service: notify.all_devices
    data:
      message: Plastik raus stellen
      title: Müllabfuhr
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Plastik raus stellen!
mode: single

Erstellt euch eine iosactions.yaml und fügt folgenden Code in der configuration.yaml ein:

ios: !include iosactions.yaml

Mit folgendem Code könnt ihr Actions anlegen:

actions:
  - name: Garage                    # Name der Aktion - wichtig für die Automationen 
    background_color: "#000000"     # Hintergrundfarbe des Buttons auf der Watch
    label:
      text: "Garage"                # Text auf der Watch
      color: "#ffffff"              # Textfarbe auf der Watch
    icon:
      icon: garage                  # MDI Icon auf der Watch
      color: "#00fff5"              # Farbe des Icons

Mit folgender Automatisierung kannst du alle Actions in einer Automatisierung abbilden:

alias: Apple Watch
description: ""
trigger:
  - platform: event
    event_type: ios.action_fired
    event_data:
      actionName: Garage
    id: Garage
  - platform: event
    event_type: ios.action_fired
    event_data:
      actionName: PC
    id: PC
condition: []
action:
  - if:
      - condition: trigger
        id:
          - Garage
    then:
      - service: script.toggle
        data: {}
        target:
          entity_id: script.garage_taster
  - if:
      - condition: trigger
        id:
          - PC
    then:
      - service: light.toggle
        data: {}
        target:
          entity_id: light.ambiente_pc
mode: single

Du benötigst folgendes aus HACS:

• Mushroom
• Mushroom Templates

Der Button zum anzeigen bzw. löschen der Briefkastenmeldung:

type: custom:mushroom-entity-card
entity: input_boolean.post
tap_action:
  action: call-service
  service: input_boolean.turn_off
  data: {}
  target:
    entity_id: input_boolean.post
  confirmation:
    text: Briefkasten geleert?
secondary_info: last-updated
icon_color: yellow

Automation:

alias: Benachrichtigung Post
description: ""
trigger:
  - type: opened
    platform: device
    device_id: 0d645b52a4bb04f517b43aa47b037a07
    entity_id: binary_sensor.lumi_lumi_sensor_magnet_aq2_on_off
    domain: binary_sensor
condition:
  - condition: state
    entity_id: input_boolean.post
    state: "off"
action:
  - service: input_boolean.turn_on
    data: {}
    target:
      entity_id: input_boolean.post
  - if:
      - condition: state
        entity_id: group.presence_home
        state: home
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Die Post ist da!
    else:
      - service: notify.all_devices
        data:
          message: Post ist da!
          title: Briefkasten
mode: single

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

#include "esp_camera.h"
#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h" //disable brownout problems
#include "soc/rtc_cntl_reg.h"  //disable brownout problems
#include "esp_http_server.h"

//Replace with your network credentials
const char* ssid = "WLAN NAME";
const char* password = "WLAN PASSWORT";

#define PART_BOUNDARY "123456789000000000000987654321"

// This project was tested with the AI Thinker Model, M5STACK PSRAM Model and M5STACK WITHOUT PSRAM
#define CAMERA_MODEL_AI_THINKER
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WITHOUT_PSRAM

// Not tested with this model
//#define CAMERA_MODEL_WROVER_KIT

#if defined(CAMERA_MODEL_WROVER_KIT)
  #define PWDN_GPIO_NUM    -1
  #define RESET_GPIO_NUM   -1
  #define XCLK_GPIO_NUM    21
  #define SIOD_GPIO_NUM    26
  #define SIOC_GPIO_NUM    27
  
  #define Y9_GPIO_NUM      35
  #define Y8_GPIO_NUM      34
  #define Y7_GPIO_NUM      39
  #define Y6_GPIO_NUM      36
  #define Y5_GPIO_NUM      19
  #define Y4_GPIO_NUM      18
  #define Y3_GPIO_NUM       5
  #define Y2_GPIO_NUM       4
  #define VSYNC_GPIO_NUM   25
  #define HREF_GPIO_NUM    23
  #define PCLK_GPIO_NUM    22

#elif defined(CAMERA_MODEL_M5STACK_PSRAM)
  #define PWDN_GPIO_NUM     -1
  #define RESET_GPIO_NUM    15
  #define XCLK_GPIO_NUM     27
  #define SIOD_GPIO_NUM     25
  #define SIOC_GPIO_NUM     23
  
  #define Y9_GPIO_NUM       19
  #define Y8_GPIO_NUM       36
  #define Y7_GPIO_NUM       18
  #define Y6_GPIO_NUM       39
  #define Y5_GPIO_NUM        5
  #define Y4_GPIO_NUM       34
  #define Y3_GPIO_NUM       35
  #define Y2_GPIO_NUM       32
  #define VSYNC_GPIO_NUM    22
  #define HREF_GPIO_NUM     26
  #define PCLK_GPIO_NUM     21

#elif defined(CAMERA_MODEL_M5STACK_WITHOUT_PSRAM)
  #define PWDN_GPIO_NUM     -1
  #define RESET_GPIO_NUM    15
  #define XCLK_GPIO_NUM     27
  #define SIOD_GPIO_NUM     25
  #define SIOC_GPIO_NUM     23
  
  #define Y9_GPIO_NUM       19
  #define Y8_GPIO_NUM       36
  #define Y7_GPIO_NUM       18
  #define Y6_GPIO_NUM       39
  #define Y5_GPIO_NUM        5
  #define Y4_GPIO_NUM       34
  #define Y3_GPIO_NUM       35
  #define Y2_GPIO_NUM       17
  #define VSYNC_GPIO_NUM    22
  #define HREF_GPIO_NUM     26
  #define PCLK_GPIO_NUM     21

#elif defined(CAMERA_MODEL_AI_THINKER)
  #define PWDN_GPIO_NUM     32
  #define RESET_GPIO_NUM    -1
  #define XCLK_GPIO_NUM      0
  #define SIOD_GPIO_NUM     26
  #define SIOC_GPIO_NUM     27
  
  #define Y9_GPIO_NUM       35
  #define Y8_GPIO_NUM       34
  #define Y7_GPIO_NUM       39
  #define Y6_GPIO_NUM       36
  #define Y5_GPIO_NUM       21
  #define Y4_GPIO_NUM       19
  #define Y3_GPIO_NUM       18
  #define Y2_GPIO_NUM        5
  #define VSYNC_GPIO_NUM    25
  #define HREF_GPIO_NUM     23
  #define PCLK_GPIO_NUM     22
#else
  #error "Camera model not selected"
#endif

static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

httpd_handle_t stream_httpd = NULL;

static esp_err_t stream_handler(httpd_req_t *req){
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len = 0;
  uint8_t * _jpg_buf = NULL;
  char * part_buf[64];

  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if(res != ESP_OK){
    return res;
  }

  while(true){
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      res = ESP_FAIL;
    } else {
      if(fb->width > 400){
        if(fb->format != PIXFORMAT_JPEG){
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if(!jpeg_converted){
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        } else {
          _jpg_buf_len = fb->len;
          _jpg_buf = fb->buf;
        }
      }
    }
    if(res == ESP_OK){
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if(res == ESP_OK){
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if(fb){
      esp_camera_fb_return(fb);
      fb = NULL;
      _jpg_buf = NULL;
    } else if(_jpg_buf){
      free(_jpg_buf);
      _jpg_buf = NULL;
    }
    if(res != ESP_OK){
      break;
    }
    //Serial.printf("MJPG: %uB\n",(uint32_t)(_jpg_buf_len));
  }
  return res;
}

void startCameraServer(){
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = 80;

  httpd_uri_t index_uri = {
    .uri       = "/",
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };
  
  //Serial.printf("Starting web server on port: '%d'\n", config.server_port);
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &index_uri);
  }
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);
  Serial.setDebugOutput(false);
  
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG; 
  
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  // Wi-Fi connection
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  
  Serial.print("Camera Stream Ready! Go to: http://");
  Serial.print(WiFi.localIP());
  
  // Start streaming web server
  startCameraServer();
}

void loop() {
  delay(1);
}

Als alternative kann man auch ESP Home verwenden hier ist die Kamera aber nicht ganz so flüssig:

esphome:
  name: cam-1
  platform: ESP32
  board: esp32dev  

# Enable logging
logger:

# Enable Home Assistant API
api:
    reboot_timeout: 0s

ota:

web_server:
  port: 80

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp32-Cam Fallback Hotspot"
    password: "C3FOhAPFtouw"

captive_portal:

# Example configuration entry
esp32_camera:
  external_clock:
    pin: GPIO0
    frequency: 20MHz
  i2c_pins:
    sda: GPIO26
    scl: GPIO27
  data_pins: [GPIO5, GPIO18, GPIO19, GPIO21, GPIO36, GPIO39, GPIO34, GPIO35]
  vsync_pin: GPIO25
  href_pin: GPIO23
  pixel_clock_pin: GPIO22
  power_down_pin: GPIO32

  # Image settings
  name: Cam 1
# Flashlight
output:
  - platform: gpio
    pin: GPIO4
    id: gpio_4

## GPIO_4 is the flash light pin
light:
  - platform: binary
    output: gpio_4
    name: cam-1-flashlight

Bitte am Anfang noch 

esp8266:                       # diese Line sollte schon vorhanden sein
  board: esp01_1m              # diese ebenso
  restore_from_flash: true

preferences:
  flash_write_interval: 5min
  
  
  
api:
  services:
    - service: update_counter_pulses
      variables:
        counter_pulses: int
      then:
        - globals.set:
            id: pulses_sum
            value: !lambda 'return counter_pulses;'

diesen Code an die Standart Config anfügen:

globals:
  - id: pulses_sum
    type: int
    restore_value: yes
    initial_value: '8504'  # hier kann der Gaszählerstand initialisiert werden - letze Stelle weglassen

binary_sensor:
  - platform: gpio
    id: internal_pulse_counter
    pin:
      number: GPIO5
      mode: INPUT_PULLUP
    name: "Live-Impuls"
    filters:
      - delayed_on: 10ms
    on_press:
      then:
        - lambda: id(pulses_sum) += 1;

sensor:
  - platform: template
    name: "Gasverbrauch_ESP"
    device_class: gas
    unit_of_measurement: "m³"
    state_class: "total_increasing"
    icon: "mdi:fire"
    accuracy_decimals: 2
    lambda: |-
      return id(pulses_sum) * 0.01;

# Gaszähler, kommend von ESPHome, aufbereiten für Energy
- platform: template
  sensors:
    gasverbrauch:
      value_template:  >
          {% if states('sensor.gasverbrauch_esp') | float == 0 %}
            {{ states('sensor.gasverbrauch') }}
          {% else %}
            {{ states('sensor.gasverbrauch_esp') | float }}
          {% endif %}
      unit_of_measurement: m³
      device_class: gas
      attribute_templates:
        state_class: total_increasing

- sensor:
    - name: "Total Energy Use"
      unique_id: "Total_Energy_Use"
      device_class: energy
      state_class: total
      unit_of_measurement: "kWh"
      state: >
        {{ 
        states('sensor.hausverbrauch_channel_a_energy')| float(0) + 
        states('sensor.hausverbrauch_channel_b_energy')| float(0) +
        states('sensor.hausverbrauch_channel_c_energy')| float(0) 
        }}

- sensor:
    - name: "Total Energy Returned"
      unique_id: "Total_Energy_Returned"
      device_class: energy
      state_class: total
      unit_of_measurement: "kWh"
      state: >
        {{ 
        states('sensor.hausverbrauch_channel_a_energy_returned')| float(0) + 
        states('sensor.hausverbrauch_channel_b_energy_returned')| float(0) +
        states('sensor.hausverbrauch_channel_c_energy_returned')| float(0) 
        }}

- sensor:
    - name: PV Einspeisung
      unique_id: "pv_einspeisung"
      unit_of_measurement: "W"
      device_class: power
      state: "{{ states('sensor.total_power')|float if states('sensor.total_power') | int < 1 else 0 }}"

- sensor:
    - name: PV Einspeisung negiert
      unique_id: "pv_einspeisung_negiert"
      unit_of_measurement: "W"
      device_class: power
      state: "{{ states('sensor.pv_einspeisung')|float * -1 }}"

Dann lass uns einen Dummy Sensor in der template.yaml anlegen:

### DUMMY SENSOREN SHELLY3EM ###

- sensor:
    - name: "shellyem3_e89f6d85252d_channel_a_energy"   #hier musst du deinen alten Sensor anlegen
      device_class: energy
      state_class: total
      unit_of_measurement: "kWh"
      state: "0"

Integrationen:

• Better Thermostat
• Scheduler Component

Frontends:

• Better Thermostat UI
• Scheduler Card

Erstell dir eine groups.yaml 

group: !include groups.yaml

mit folgendem Code:

presence_home:
  name: family
  entities:
    - person.NAME1
    - person.NAME2

In der Template.yaml folgenden Code hinzufügen:

- sensors:
    temperatur_NAME_temperature:
      value_template: "{{ state_attr('climate.HEIZUNGSNAME', 'current_temperature') }}"
      friendly_name: Temperatur - NAME
      unit_of_measurement: '°C'
      device_class: temperature
      icon_template: mdi:thermometer

Premium Variante:

Netatmo Weather Station und Netatmo Zusatzmodule

kein Zigbee erforderlich

Günstige Variante:

Aqara Temperatur und Feuchtigkeitssensor

Zigbee wird benötigt

Hierzu können wir einen Sensor erstellen:

Sensor.yaml:

- platform: template
  sensors:
    absolute_humidity_outside_sensor:
      friendly_name: "Absolute Feuchte Aussen Sensor"
      unit_of_measurement: "g/m^3"
      icon_template: mdi:water-percent-alert
      value_template: "{{ 1000*e**(19.016-(4064.95/(float(states('sensor.*******_TEMPERATUR'))+236.25)))
                                      *100/(461.66*(float(states('sensor.*******_TEMPERATUR'))+273.15)) * 
                                                    float(states('sensor.*******_Luftfeuchtigkeit'))/100 | float }}"

    absolute_humidity_buero:
      friendly_name: "Absolute Feuchte RAUMNAME"
      unit_of_measurement: "g/m^3"
      icon_template: mdi:water-percent-alert
      value_template: "{{ 1000*e**(19.016-(4064.95/(float(states('sensor.*******_temperature_2'))+236.25)))
                                      *100/(461.66*(float(states('sensor.*******_temperature_2'))+273.15)) * 
                                                    float(states('sensor.*******_humidity_2'))/100 | float }}"

type: custom:mushroom-template-card
icon: mdi:window-shutter-auto
icon_color: |-
  {% if states('sensor.absolute_humidity_outside_sensor') | float <=
    states('sensor.absolute_humidity_schlafen') | float %} 
      green
  {% else %}
      red
  {% endif %}
primary: |-
  {% if states('sensor.absolute_humidity_outside_sensor') | float <=
     states('sensor.absolute_humidity_schlafen') | float %} 
      Lüften ok
  {% else %}
      Lüften sollte unterlassen werden
  {% endif %} 

type: custom:mushroom-chips-card
chips:
  - type: template
    icon: mdi:arrow-left
    tap_action:
      action: navigate
      navigation_path: /smartphone-1/0
  - type: entity
    entity: sensor.netatmo_mein_zuhause_weather_station_temperature
  - type: entity
    entity: sensor.lumi_lumi_weather_humidity
  - type: template
    icon: mdi:window-shutter-auto
    icon_color: |-
      {% if states('sensor.absolute_humidity_outside_sensor') | float <=
        states('sensor.absolute_humidity_wohnzimmer') | float %} 
          green
      {% else %}
          red
      {% endif %}
    content: |-
      {% if states('sensor.absolute_humidity_outside_sensor') | float <=
         states('sensor.absolute_humidity_wohnzimmer') | float %} 
          Lüften ok
      {% else %}
          Lüften sollte unterlassen werden
      {% endif %} 

alias: Benachrichtigung Lüften Bad
description: ""
trigger:
  - platform: state
    entity_id:
      - binary_sensor.fenster_bad_contact
    to: "on"
condition:
  - condition: numeric_state
    entity_id: sensor.absolute_humidity_bad
    below: sensor.absolute_humidity_outside_sensor
action:
  - service: notify.alexa_media
    data:
      message: >-
        ACHTUNG durch das Lüften erhöhst du die Luftfeuchtigkeit somit besteht
        Schimmelgefahr
      target:
        - media_player.badezimmer
      data:
        type: announce
mode: single

• öffne deinen Addon Store in Homeassistant
• starte das Addon und überprüfe das Protokoll

• behebe ggf. dort angezeigte Fehler

Hier kannst du mit einem Reverse Proxy wie z.B. Nginx Proxy Manager oder Cloudflare eine Subdomain mit Zertifikat erstellen und deinen BW damit aufrufen.

• Notiere dir deine Daten

DIESES PASSWORT WIRD DIR NICHT MEHR ANGEZEIGT DESHALB UNBEDINGT SICHER SPEICHERN

Jetzt öffnest du BW Admin (Bitwarden) über folgende Adresse:

http://[IPADRESSE-von-homeassistant]:7277/admin

 Hier musst du das Passwort was du dir im letzten Schritt gespeichert hast eingetragen:

Hier solltest du nun einmal alles durchgehen und deinen Wünschen entsprechend anpassen. Ich zeige dir hier was ich angepasst habe:

• Unter dem Reiter SMTP Email Settings habe ich einen Emailserver hinterlegt um 2FA zu nutzen
• Unter dem Reiter Email 2FA Settings die 2FA aktivieren 
• Unter dem Reiter General Settings habe ich "Allow new signups" deaktiviert nachdem alle Familienmitglieder sich ein Konto erstellt hatten.
• Unter dem Reiter General Settings noch meine Domain URL angepasst auf meinen im Cloudflare hinterlegte Subdomain

Die benötigten Bilder müssen im Homeassistant unter /config/www/images/plants gespeichert werden (nicht alle)

Link zum Cam integrieren:

rtsp://IP_ADRESSE:554/h264Preview_01_main

Video Resolution: 1440x1024

Frame Rate: 20

Als erstes solltest du dir bei Strava die API Daten besorgen hier zu gehst du über diesen Link zu Strava

Die Callback-Domain muss zwingend my.home-assistant.io lauten

Als Logo könnt ihr gern einfach folgende Datei verwenden:

Logo :)

Jetzt müsst ihr euch noch eine Repo in HACS hinzufügen:

https://github.com/craibo/ha_strava

und euch dann die Integration Strava 2.0 installieren.

Hier müsst ihr nun folgende Werte eintragen:

Stellt euch ein wieviele Aktivitäten gesynced werden sollen.

Eure Einheit könnt ihr hier auch anpassen - erfordert einen Restart:

Zum Schluss noch die GeoCode Api einbinden:

GeoCode Registrierung

aus HACS installieren und als Integration hinzufügen

aus HACS (Frontend) installieren und dann im Dashboard als Card hinzufügen.

Warnungen von Unwettern etc. greife ich über die Integration NINA ab hier braucht es keine gesonderte Installation aus HACS

Ich nutze hier die Platinum Weather Card mit folgender Config:

card_config_version: 8
entity_apparent_temp: sensor.easyweatherpro_v5_0_9_feels_like_temperature
entity_forecast_icon: weather.home
entity_humidity: sensor.easyweatherpro_v5_0_9_humidity
entity_pop: sensor.easyweatherpro_v5_0_9_rain_rate
entity_pos: sensor.easyweatherpro_v5_0_9_daily_rain_rate
entity_pressure: sensor.easyweatherpro_v5_0_9_absolute_pressure
entity_summary: weather.home
entity_sun: sun.sun
entity_temperature: sensor.easyweatherpro_v5_0_9_outdoor_temperature
entity_uv_alert_summary: sensor.easyweatherpro_v5_0_9_uv_index
entity_wind_bearing: sensor.easyweatherpro_v5_0_9_wind_direction
entity_wind_gust: sensor.easyweatherpro_v5_0_9_wind_gust
entity_wind_speed: sensor.easyweatherpro_v5_0_9_wind_speed
option_color_fire_danger: false
option_locale: de
option_pressure_decimals: 1
option_static_icons: true
option_time_format: 24hour
option_today_rainfall_decimals: true
section_order:
  - overview
  - extended
  - slots
  - daily_forecast
show_section_daily_forecast: false
show_section_extended: false
slot_l1: humidity
slot_l2: remove
slot_l3: wind
slot_l4: pressure
slot_l5: sun_next
slot_l6: remove
slot_l7: remove
slot_l8: remove
slot_r1: popforecast
slot_r2: remove
slot_r3: uv_summary
slot_r4: empty
slot_r5: sun_following
slot_r6: remove
slot_r7: remove
slot_r8: remove
type: custom:platinum-weather-card
view_layout:
  position: sidebar

• NodeRed

bitte bei der NodeRed Konfiguration ein Credential Secret vergeben 

• MQTT Broker

hier legt ihr noch einen Login an:

- username: mqtt_user
  password: 1234asdf

Vor dem Import müssen folgende Punkte in der unten zum Download angebotenen JSON mit "suchen&ersetzen" getauscht werden.

ich verwende hierzu Notepad+ und rufe diese Funktion mit Strg + F auf und wähle dort den Abschnitt ersetzen

{PRINTER_NAME}

 - keine Leerzeichen im Namen verwenden (Groß und Kleinschreibung beachten)

Nutzt ihr Bambu_X1C als Name kann meine Dashboard direkt verwendet werden

{PRINTER_IP}

zu finden auf dem Drucker unter Netzwerk

{PRINTER_SERIAL}

findet ihr im Drucker bei den Infos

{HA_MQTT_BROKER_HOST}

hier ist die IP Adresse vom MQTT Broker ohne Port zu hinterlegen 

solltet ihr Homeassistant OS nutzen mit dem Mosquitto Broker Addon ist es die IP vom Homeassistant wie das geht erfährst du HIER

Jetzt musst du diese Config noch in NodeRed importieren.

Jetzt drückt ihr noch auf Übernahme (deploy)

Jetzt sollte euer Flow etwa so aussehen:

sollte hier nicht verbunden stehen habt ihr ein MQTT Problem 

Vermutlich müsst ihr hier noch euren Login ergänzen.

Mit Doppelklick auf HomeAssistant In öffnet sich ein kleines Fenster wo ihr den Abschnitt Server findet. Dahinter ist ein kleiner Stift zum bearbeiten. Hier müsst ihr unter Sicherheit noch eure MQTT Login Daten eintragen.

Jetzt drückt ihr noch auf Übernahme (deploy)

 Benötigte Files:

x1c.png

ams.png

bitte unter config/www/ ablegen z.B. mit Studio Code Server im Homeassistant 

geht per drag&drop

Bitte noch per HACS folgendes Frontend herunterladen:

• card-mod
• hui-element
  
• Config Template Card
  
• Mushroom

und dann einfach den folgenden Code als manuelle Karte hinzufügen:

type: vertical-stack
cards:
  - type: picture-elements
    elements:
      - type: custom:config-template-card
        entities:
          - sensor.ams_0_bambu_x1c_tray_0
        element:
          type: state-icon
          entity: sensor.ams_0_bambu_x1c_tray_0
          icon: >-
            ${states['sensor.ams_0_bambu_x1c_tray_0'].state != 'Empty' ?
            'mdi:bullseye' : 'mdi:tray' }
        style:
          top: 28%
          left: 18%
          '--paper-item-icon-color': var(--tray_0_color)
          background-color: rgba(0,0,0,0.5)
          box-shadow: 0 0 5px 5px var(--tray_0_bg)
          border-radius: 50px
          '--mdc-icon-size': 2.4em
      - type: state-label
        entity: sensor.ams_0_bambu_x1c_tray_0
        attribute: type
        tap_action:
          action: none
        style:
          top: 77%
          left: 18%
          text-align: center
          font-size: 1em
          background-color: rgba(0,0,0,0.4)
          box-shadow: 0 0 5px 5px rgba(0, 0, 0, 0.4)
          border-radius: 50px
          pointer-events: none
      - type: custom:config-template-card
        entities:
          - sensor.ams_0_bambu_x1c_tray_1
        element:
          type: state-icon
          entity: sensor.ams_0_bambu_x1c_tray_1
          icon: >-
            ${states['sensor.ams_0_bambu_x1c_tray_1'].state != 'Empty' ?
            'mdi:bullseye' : 'mdi:tray' }
        style:
          top: 28%
          left: 39%
          '--paper-item-icon-color': var(--tray_1_color)
          background-color: rgba(0,0,0,0.5)
          box-shadow: 0 0 5px 5px  var(--tray_1_bg)
          border-radius: 50px
          '--mdc-icon-size': 2.4em
      - type: state-label
        entity: sensor.ams_0_bambu_x1c_tray_1
        attribute: type
        tap_action:
          action: none
        style:
          top: 77%
          left: 39%
          text-align: center
          font-size: 1em
          background-color: rgba(0,0,0,0.4)
          box-shadow: 0 0 5px 5px rgba(0, 0, 0, 0.4)
          border-radius: 50px
          pointer-events: none
      - type: custom:config-template-card
        entities:
          - sensor.ams_0_bambu_x1c_tray_2
        element:
          type: state-icon
          entity: sensor.ams_0_bambu_x1c_tray_2
          icon: >-
            ${states['sensor.ams_0_bambu_x1c_tray_2'].state != 'Empty' ?
            'mdi:bullseye' : 'mdi:tray' }
        style:
          top: 28%
          left: 61%
          '--paper-item-icon-color': var(--tray_2_color)
          background-color: rgba(0,0,0,0.5)
          box-shadow: 0 0 5px 5px  var(--tray_2_bg)
          border-radius: 50px
          '--mdc-icon-size': 2.4em
      - type: state-label
        entity: sensor.ams_0_bambu_x1c_tray_2
        attribute: type
        tap_action:
          action: none
        style:
          top: 77%
          left: 61%
          text-align: center
          font-size: 1em
          background-color: rgba(0,0,0,0.4)
          box-shadow: 0 0 5px 5px rgba(0, 0, 0, 0.4)
          border-radius: 50px
          pointer-events: none
      - type: custom:config-template-card
        entities:
          - sensor.ams_0_bambu_x1c_tray_3
        element:
          type: state-icon
          entity: sensor.ams_0_bambu_x1c_tray_3
          icon: >-
            ${states['sensor.ams_0_bambu_x1c_tray_3'].state != 'Empty' ?
            'mdi:bullseye' : 'mdi:tray' }
        style:
          top: 28%
          left: 83%
          '--paper-item-icon-color': var(--tray_3_color)
          background-color: rgba(0,0,0,0.5)
          box-shadow: 0 0 5px 5px var(--tray_3_bg)
          border-radius: 50px
          '--mdc-icon-size': 2.4em
      - type: state-label
        entity: sensor.ams_0_bambu_x1c_tray_3
        attribute: type
        tap_action:
          action: none
        style:
          top: 77%
          left: 83%
          text-align: center
          font-size: 1em
          background-color: rgba(0,0,0,0.4)
          box-shadow: 0 0 5px 5px rgba(0, 0, 0, 0.4)
          border-radius: 50px
          pointer-events: none
      - type: state-badge
        entity: sensor.ams_0_bambu_x1c_humidity
        style:
          top: 15%
          left: 29%
          color: transparent
      - type: state-badge
        entity: sensor.ams_0_bambu_x1c_temp
        style:
          top: 15%
          left: 72%
          color: transparent
    image: /local/ams.png
    style: |
      ha-card {
        background: none !important;
        border: none !important;
        --tray_0_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_0', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_0', 'color') }}; {% endif %}
        --tray_1_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_1', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_1', 'color') }}; {% endif %}
        --tray_2_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_2', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_2', 'color') }}; {% endif %}
        --tray_3_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_3', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_3', 'color') }}; {% endif %}
        --tray_0_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_0', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_1_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_1', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_2_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_2', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_3_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_3', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
      }
  - type: picture-elements
    elements:
      - type: state-badge
        entity: sensor.x1c_bambu_x1c_bed_temperature
        style:
          top: 75%
          left: 50%
          color: transparent
      - type: state-badge
        entity: sensor.x1c_bambu_x1c_nozzle_temperature
        style:
          top: 32%
          left: 50%
          color: transparent
      - type: state-badge
        entity: sensor.x1c_bambu_x1c_chamber_temperature
        style:
          top: 32%
          left: 80%
          color: transparent
      - type: state-icon
        entity: light.x1c_bambu_x1c_chamber_light
        tap_action:
          action: toggle
        style:
          top: 32%
          left: 12%
          transform: scale(1.5,1.5)
    image: /local/x1c.png
    style: |
      ha-card {
        background: none !important;
        border: none !important;
        --tray_0_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_0', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_0', 'color') }}; {% endif %}
        --tray_1_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_1', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_1', 'color') }}; {% endif %}
        --tray_2_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_2', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_2', 'color') }}; {% endif %}
        --tray_3_color: {% if is_state('sensor.ams_0_bambu_x1c_tray_3', 'Empty') %} grey; {% else %} {{
            state_attr('sensor.ams_0_bambu_x1c_tray_3', 'color') }}; {% endif %}
        --tray_0_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_0', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_1_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_1', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_2_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_2', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
        --tray_3_bg: {% if is_state_attr('sensor.ams_0_bambu_x1c_tray_3', 'id', state_attr('sensor.current_ams_filament_in_use', 'id')) %} rgba(255, 255, 126, 0.5); {% else %} rgba(0,0,0,0.5); {% endif %}
      }

type: vertical-stack
cards:
  - type: custom:mushroom-title-card
    title: ''
    subtitle: Print Details
    alignment: center
  - type: custom:mushroom-entity-card
    entity: sensor.x1c_bambu_x1c_stage
    name: Task
    icon: mdi:file-tree
  - type: horizontal-stack
    cards:
      - type: custom:mushroom-entity-card
        entity: sensor.x1c_bambu_x1c_print_progress
        name: Fortschritt
        icon: mdi:progress-clock
      - type: custom:mushroom-entity-card
        entity: sensor.x1c_bambu_x1c_subtask
        name: Druckobjekt
        icon: mdi:ufo
  - type: vertical-stack
    cards: []
  - type: custom:mushroom-entity-card
    entity: sensor.x1c_bambu_x1c_print_remaining_time
    name: Verbleibend
    icon: mdi:clock-time-eight

type: entities
entities:
  - entity: sensor.x1c_bambu_x1c_cooling_fan
    name: Bauteillüfter
  - entity: sensor.x1c_bambu_x1c_big_fan1
    name: Bauteil Zusatzlüfter
  - entity: sensor.x1c_bambu_x1c_big_fan2
    name: Gehäuse Lüfter
  - entity: sensor.x1c_bambu_x1c_heatbreak_fan
    name: Hotend Lüfter

Damit der Drucker sich nach dem Druck automatisch abschaltet könnt ihr folgende Automation nutzen:

alias: 3D Drucker automatische Abschaltung
description: ""
trigger:
  - platform: numeric_state
    entity_id: sensor.x1c_bambu_x1c_heatbreak_fan
    below: 1
condition: []
action:
  - service: switch.turn_off
    data: {}
    target:
      entity_id: switch.STECKDOSE-DRUCKER   # hier bitte den Switch der smarten Steckdose angeben
  - service: automation.turn_off
    data: {}
    target:
      entity_id: automation.3d_drucker_automatische_abschaltung
mode: single

ich habe mir hier zusätzlich einen Button gebaut welchen ich aktivieren und deaktivieren kann um diese Automation zu steuern.

type: custom:mushroom-template-card
primary: Abschaltung nach Druck
secondary: '{{ states(''sensor.x1c_bambu_x1c_print_remaining_time'') }} Minuten verbleibend'
icon: mdi:timer
icon_color: |-
  {% if is_state('automation.3d_drucker_automatische_abschaltung', 'on') %}
    yellow
  {% endif %}
tap_action:
  action: call-service
  service: automation.toggle
  data: {}
  target:
    entity_id: automation.3d_drucker_automatische_abschaltung

Du möchtest die smarte Steckdose an deinem Drucker nur ausschalten können wenn der Drucker abgekühlt und fertig ist?

Dazu erstellst du folgendes Script:

alias: 3D Drucker ausschalten
sequence:
  - if:
      - condition: numeric_state
        entity_id: sensor.x1c_bambu_x1c_heatbreak_fan
        above: 1
    then:
      - service: notify.alexa_media
        data:
          target:
            - media_player.buro
            - media_player.kuche
            - media_player.wohnzimmer
            - media_player.badezimmer
            - media_player.schlafzimmer
          data:
            type: announce
          message: Ausschalten nicht möglich wegen aktivem Druck
    else:
      - service: switch.toggle
        data: {}
        target:
          entity_id: switch.3d_drucker_on_off                       #hier musst du deine Steckdose angeben
      - service: button.press
        data: {}
        target:
          entity_id: button.x1c_bambu_x1c_reset_filter
mode: single

Jetzt musst du dir nur noch den Button dafür erstellen und dann bist du fertig!

type: custom:mushroom-entity-card
entity: switch.3d_drucker_on_off
icon: mdi:power
icon_color: yellow
layout: horizontal
name: X1 Carbon
secondary_info: none
tap_action:
  action: call-service
  service: script.3d_drucker_ausschalten
  data: {}
  target: {}

Als erstes legen wir einen Helfer für unseren Strompreis fest. Hierzu gehen wir auf Einstellungen - Geräte Dienste - Helfer:

Hier müssen wir folgende Config eintragen:

Schrittgröße:

0,0001

Maßeinheit:

EUR /kWh

Solltest du noch keine Template yaml haben legen wir diese jetzt an. Füge folgenden Code in der configuration.yaml ein:

template: !include template.yaml

das sollte dann in etwa so aussehen:

jetzt musst du noch die template.yaml als Datei im selben Ordner wie die configuration.yaml anlegen.

Als erstes saldieren wir die Werte unseres Zählers (in meinem Fall Shelly 3em pro):

- sensor:
    - name: "Power Total" 
      unique_id: power_total
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {{ 
        states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_a_active_power')|float(0) +
        states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_b_active_power')|float(0) +
        states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_c_active_power')|float(0) }}
      availability: >
        {{ 
          [ states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_a_active_power')|float(0) ,
            states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_b_active_power')|float(0) ,
            states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_c_active_power')|float(0) ] | map('is_number') | min }}

Du kannst hier auch mehrere Werte anfügen oder reduzieren. Hierfür musst du die Zeilen 9-11 und entsprechend 14-16 anpassen - hier ein kleines Beispiel solltest du nur einen Sensor haben:

- sensor:
    - name: "Power Total"
      unique_id: power_total
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {{ states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_a_active_power')|float(0) }}
      availability: >
        {{ 
          [ states('sensor.shellypro3em_XXXXXXXXXXXXXXXXX_phase_a_active_power')|float(0) ) ] | map('is_number') | min }}

Ich empfehle dir hier immer diesen Weg zu gehen weil du bei einem Wechsel der Zähleinheit einfach hier nur deinen Sensor anpassen musst und dein Energydashboard etc. einfach weiterläuft.

 Jetzt kommen wir zum Netzbezug und der Netzeinspeisung:

- sensor:
    - name: "Power vom Netz (Watt)" 
      unique_id: power_vom_netz
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {% if states('sensor.power_total') | float(0) >= 0 %}
            {{states('sensor.power_total') | float(0) | round (3) }}
        {% else %}
            {{(states ('0.0') | float(0)) |round(3) }}
        {% endif %}
      availability: >
        {{ 
          [ states('sensor.power_total') ] | map('is_number') | min }}

Solltest du eine PV Anlage verwenden müssen wir auch noch die Netzeinspeisung konfigurieren - falls du keine besitzt kannst du einfach zum Punkt Helfer weiterspringen.

- sensor:
    - name: "Power ins Netz (Watt)" 
      unique_id: power_ins_netz
      unit_of_measurement: W
      device_class: power
      state_class: measurement
      state: >
        {% if states('sensor.power_total') | float(0) < 0 %}
            {{(states('sensor.power_total') | float(0))*-1 | round (3) }}
        {% else %}
            {{(states ('0.0') | float(0)) |round(3) }}
        {% endif %}
      availability: >
        {{ 
          [ states('sensor.power_total') ] | map('is_number') | min }}

Als nächstes kommt noch die Eigenverbrauchs Berechnung hier musst du :

- sensor:
    - name: "PV Eigenverbrauch (Watt)" 
      unique_id: pv_eigenverbrauch_watt
      state_class: measurement
      icon: mdi:transmission-tower
      unit_of_measurement: W
      device_class: power
      state: >
        {% if states('sensor.power_total') | float(0) < 0 %}
            {{ ( (states('sensor.power_total') | float(0) ) + (states('sensor.SENSOR VON DEINER PV MESSUNG') | float(0) ) ) | round (3) }}
        {% else %}
            {{ states('sensor.SENSOR VON DEINER PV MESSUNG') | round (3) }}
        {% endif %}
      availability: >
        {{ 
          [ states('sensor.power_total'),
            states('sensor.switch_pv_power') ] | map('is_number') | min }}

- sensor: 
    - name: "PV Vorteil"
      unique_id: pv_vorteil
      unit_of_measurement: EUR/h
      state: >
        {{ states('sensor.pv_eigenverbrauch_watt')|float(0) * states('input_number.strompreis')|float(0)/1000 }}

Hier legen wir jeweils einen Integration - Riemann Summenintegralsensor an:

Netzverbrauch =

Netzeinspeisung =

Ersparnis = 

Hierzu gehen wir auf Einstellungen - Dashboards - Energie

jetzt werden bei dir folgende Fehler aufschlagen:

das ist soweit auch korrekt. Warte einfach bis die Sensoren einiges an Daten gesammelt haben (spätestens nach einer Stunde sollten die Fehler verschwunden sein)

Die Normalen Cards von Homeassistant findet ihr hier

Ich verwende noch zusätzlich die :

Power Flow Card Plus