Adressable LED Strip and many more changes.

config/automations.yaml

   action:
     service: switch.turn_off
     entity_id: switch.subwoofer    
+- alias: "Porch Animation Speed"
+  initial_state: True
+  hide_entity: True
+  trigger:
+    - platform: state
+      entity_id: input_number.porch_animation_speed
+  action:
+    - service: mqtt.publish
+      data_template:
+        topic: "bruh/porch/set"
+        payload: '{"transition":{{ trigger.to_state.state | int }}}'

config/configuration.yaml

 frontend:
   themes: !include midnight.yaml
 
+#logger:
+#  default: critical
+#  logs:
+#    homeassistant.components.http.ban: warning
+  
 # Enables configuration UI
 config:
 
+octoprint:
+  host: 192.168.1.163
+  port: 5000
+  api_key: 4C627EC30E884B1D9B65A7058FC67925
+
 weather:
   - platform: openweathermap
     name: Weather
 
 map:
 
+ffmpeg:
+  ffmpeg_bin: /usr/bin/ffmpeg
+
 camera:
-  - platform: local_file
-    name: Webcam
-    file_path: /var/lib/motion/lastsnap.jpg
+   - platform: ffmpeg
+     ffmpeg_bin: /usr/bin/ffmpeg
+     name: Webcam
+     input: -i /dev/video0
+     extra_arguments: -f video4linux2
 
 homekit:
   filter:
 
 history:
 
+input_number:
+  porch_animation_speed:
+    name: LED Strip Animation Speed
+    initial: 150
+    min: 1
+    max: 150
+    step: 10
+
 device_tracker:
   - platform: fritz
+    host: 192.168.2.1
     new_device_defaults:
       track_new_devices: False
       hide_if_away: False
   password: Mindabew1
 
 sensor:
+  - platform: cpuspeed
   - platform: dht
     sensor: DHT22
     pin: 18
       - temperature
       - humidity
   - platform: fritzbox_callmonitor
+    host: 192.168.2.1
     name: Phone
     username: homeassistant
     password: !secret fritz_password
     refresh: 60
   humidity:
     name: Humidity
+    refresh: 60
     entities:
       - sensor.dht_sensor_humidity
     hours_to_show: 12
+  octoprint:
+    name: OctoPrint
+    refresh: 1
+    entities:
+      - sensor.octoprint_actual_bed_temp
+      - sensor.octoprint_actual_tool0_temp
+      - sensor.octoprint_target_bed_temp
+      - sensor.octoprint_target_tool0_temp
+    hours_to_show: 1
+  
   
+
 lock:
   - platform: template
     name: Schloss
         turn_off:
           service: switch.turn_off
           entity_id: switch.lightrelay
+  - platform: mqtt_json
+    name: "WS2812B Strip"
+    state_topic: "bruh/porch"
+    command_topic: "bruh/porch/set"
+    effect: true
+    effect_list:
+      - bpm
+      - candy cane  
+      - confetti  
+      - cyclon rainbow  
+      - dots  
+      - fire  
+      - glitter  
+      - juggle  
+      - lightning
+      - noise  
+      - police all  
+      - police one  
+      - rainbow  
+      - rainbow with glitter  
+      - ripple  
+      - sinelon  
+      - solid  
+      - twinkle  
+    brightness: true
+    flash: true
+    rgb: true
+    optimistic: false
+    qos: 0
 
 switch:
   - platform: wake_on_lan
   turn_on_hdmi: 'echo vcgencmd display_power 1 | ssh pi@192.168.1.179'
   turn_off_hdmi: 'echo vcgencmd display_power 0 | ssh pi@192.168.1.179'
 
-      
 api:
 
 alexa:
         - automation
         - group
       exclude_entities:
+        - sensor.octoprint_target_bed_temp
+        - sensor.octoprint_target_tool0_temp
         - switch.coverdirection
         - switch.coverenable
         - switch.lightrelay
 http:
   api_password: !secret http_password
   base_url: https://home.rutschmann.tech
+  server_port: 443
+  ssl_profile: intermediate
+  ssl_certificate: /config/ssl/fullchain.pem
+  ssl_key: /config/ssl/privkey.pem
 
 ifttt:
   key: !secret webhooks_key

config/customize.yaml

   hidden: true
 binary_sensor.pir:
   friendly_name: Movement
+sensor.octoprint_actual_bed_temp:
+  friendly_name: Bed Temperature
+sensor.octoprint_actual_tool0_temp:
+  friendly_name: Hotend Temperature
+sensor.octoprint_target_bed_temp:
+  friendly_name: Target Bed Temperature
+sensor.octoprint_target_tool0_temp:
+  friendly_name: Target Hotend Temperature
+sensor.dht_sensor_temperature:
+  friendly_name: Temperature

config/groups.yaml

     entities:
       - sensor.dht_sensor_temperature
       - sensor.dht_sensor_humidity
+      - binary_sensor.pir
+      - binary_sensor.door
+      - weather.weather
       - history_graph.humidity
       - history_graph.temperature
+      - history_graph.octoprint
       - group.switches
       - group.all_automations
       - group.lights
       - switch.anet
       - switch.subwoofer
       - switch.desktop
+      - light.hdmi
 
 lights:
     name: Lights

config/known_devices.yaml

   name: b827eb023229
   picture:
   track: false
+
+9060f1190d31:
+  hide_if_away: false
+  icon:
+  mac: 90:60:F1:19:0D:31
+  name: 9060f1190d31
+  picture:
+  track: false
+
+b49d0b5f53ed:
+  hide_if_away: false
+  icon:
+  mac: B4:9D:0B:5F:53:ED
+  name: b49d0b5f53ed
+  picture:
+  track: false
+
+18fe3498a0b0:
+  hide_if_away: false
+  icon:
+  mac: 18:FE:34:98:A0:B0
+  name: 18fe3498a0b0
+  picture:
+  track: false

config/ui-lovelace.yaml

 title: Tannenhof
 
+resources:
+  - url: /local/gauge-card.js?v=1
+    type: js
+
 views:
     # View tab title.
   - title: Josh's Room
     cards:
       - id: 698b0d61c8d64ee9a0b762080adbd009  # Automatically created id
         type: weather-forecast
-        entity: weather.openweathermap
+        entity: weather.weather
       - id: b900d5426e5d465bb4b5d92e590da361  # Automatically created id
         type: entities
         title: Joshs Room
           - cover.blinds
           - media_player.spotify
         # The markdown card will render markdown text.
-      - id: 84fa7b0ae50d4c6fa2a7cea147859cb0  # Automatically created id
-        type: markdown
-        title: Lovelace
-        content: >
-          Welcome to your **Lovelace UI**.
+      - type: custom:gauge-card
+        title: Temperature
+        entity: sensor.dht_sensor_temperature
+        min: -20
+        max: 35
+      - type: custom:gauge-card
+        title: Printer Hotend
+        entity: sensor.octoprint_actual_tool0_temp
+        severity:
+          red: 50
+          green: 0
+          amber: 40

config/www/gauge-card.js

+class GaugeCard extends HTMLElement {
+  constructor() {
+    super();
+    this.attachShadow({ mode: 'open' });
+  }
+  setConfig(config) {
+    if (!config.entity) {
+      throw new Error('Please define an entity');
+    }
+
+    const root = this.shadowRoot;
+    if (root.lastChild) root.removeChild(root.lastChild);
+
+    const cardConfig = Object.assign({}, config);
+    if (!cardConfig.scale) cardConfig.scale = "50px";
+    if (!cardConfig.min) cardConfig.min = 0;
+    if (!cardConfig.max) cardConfig.max = 100;
+
+    const entityParts = this._splitEntityAndAttribute(cardConfig.entity);
+    cardConfig.entity = entityParts.entity;
+    if (entityParts.attribute) cardConfig.attribute = entityParts.attribute;
+
+    const card = document.createElement('ha-card');
+    const shadow = card.attachShadow({ mode: 'open' });
+    const content = document.createElement('div');
+    const style = document.createElement('style');
+    style.textContent = `
+      ha-card {
+        --base-unit: ${cardConfig.scale};
+        height: calc(var(--base-unit)*3);
+        position: relative;
+      }
+      .container{
+        width: calc(var(--base-unit) * 4);
+        height: calc(var(--base-unit) * 2);
+        position: absolute;
+        top: calc(var(--base-unit)*1.5);
+        left: 50%;
+        overflow: hidden;
+        text-align: center;
+        transform: translate(-50%, -50%);
+      }
+      .gauge-a{
+        z-index: 1;
+        position: absolute;
+        background-color: var(--primary-background-color);
+        width: calc(var(--base-unit) * 4);
+        height: calc(var(--base-unit) * 2);
+        top: 0%;
+        border-radius:calc(var(--base-unit) * 2.5) calc(var(--base-unit) * 2.5) 0px 0px ;
+      }
+      .gauge-b{
+        z-index: 3;
+        position: absolute;
+        background-color: var(--paper-card-background-color);
+        width: calc(var(--base-unit) * 2.5);
+        height: calc(var(--base-unit) * 1.25);
+        top: calc(var(--base-unit) * 0.75);
+        margin-left: calc(var(--base-unit) * 0.75);
+        margin-right: auto;
+        border-radius: calc(var(--base-unit) * 2.5) calc(var(--base-unit) * 2.5) 0px 0px ;
+      }
+      .gauge-c{
+        z-index: 2;
+        position: absolute;
+        background-color: var(--label-badge-yellow);
+        width: calc(var(--base-unit) * 4);
+        height: calc(var(--base-unit) * 2);
+        top: calc(var(--base-unit) * 2);
+        margin-left: auto;
+        margin-right: auto;
+        border-radius: 0px 0px calc(var(--base-unit) * 2) calc(var(--base-unit) * 2) ;
+        transform-origin: center top;
+        transition: all 1.3s ease-in-out;
+      }
+      .gauge-data{
+        z-index: 4;
+        color: var(--primary-text-color);
+        line-height: calc(var(--base-unit) * 0.3);
+        position: absolute;
+        width: calc(var(--base-unit) * 4);
+        height: calc(var(--base-unit) * 2.1);
+        top: calc(var(--base-unit) * 1.2);
+        margin-left: auto;
+        margin-right: auto;
+        transition: all 1s ease-out;
+      }
+      .gauge-data #percent{
+        font-size: calc(var(--base-unit) * 0.55);
+      }
+      .gauge-data #title{
+        padding-top: calc(var(--base-unit) * 0.15);
+        font-size: calc(var(--base-unit) * 0.30);
+      }
+    `;
+    content.innerHTML = `
+      <div class="container">
+        <div class="gauge-a"></div>
+        <div class="gauge-b"></div>
+        <div class="gauge-c" id="gauge"></div>
+        <div class="gauge-data"><div id="percent"></div><div id="title"></div></div>
+      </div>
+    `;
+    card.appendChild(content);
+    card.appendChild(style);
+    card.addEventListener('click', event => {
+      this._fire('hass-more-info', { entityId: cardConfig.entity });
+    });
+    root.appendChild(card);
+    this._config = cardConfig;
+  }
+
+  _splitEntityAndAttribute(entity) {
+      let parts = entity.split('.');
+      if (parts.length < 3) {
+          return { entity: entity };
+      }
+
+      return { attribute: parts.pop(), entity: parts.join('.') };
+  }
+
+  _fire(type, detail, options) {
+    const node = this.shadowRoot;
+    options = options || {};
+    detail = (detail === null || detail === undefined) ? {} : detail;
+    const event = new Event(type, {
+      bubbles: options.bubbles === undefined ? true : options.bubbles,
+      cancelable: Boolean(options.cancelable),
+      composed: options.composed === undefined ? true : options.composed
+    });
+    event.detail = detail;
+    node.dispatchEvent(event);
+    return event;
+  }
+
+  _translateTurn(value, config) {
+    return 5 * (value - config.min) / (config.max - config.min)
+  }
+
+  _computeSeverity(stateValue, sections) {
+    let numberValue = Number(stateValue);
+    const severityMap = {
+      red: "var(--label-badge-red)",
+      green: "var(--label-badge-green)",
+      amber: "var(--label-badge-yellow)",
+      normal: "var(--label-badge-blue)",
+    }
+    if (!sections) return severityMap["normal"];
+    let sortable = [];
+    for (let severity in sections) {
+      sortable.push([severity, sections[severity]]);
+    }
+    sortable.sort((a, b) => { return a[1] - b[1] });
+
+    if (numberValue >= sortable[0][1] && numberValue < sortable[1][1]) {
+      return severityMap[sortable[0][0]]
+    }
+    if (numberValue >= sortable[1][1] && numberValue < sortable[2][1]) {
+      return severityMap[sortable[1][0]]
+    }
+    if (numberValue >= sortable[2][1]) {
+      return severityMap[sortable[2][0]]
+    }
+    return severityMap["normal"];
+  }
+
+  _getEntityStateValue(entity, attribute) {
+    if (!attribute) {
+      return entity.state;
+    }
+
+    return entity.attributes[attribute];
+  }
+
+  set hass(hass) {
+    const config = this._config;
+    const entityState = this._getEntityStateValue(hass.states[config.entity], config.attribute);
+    let measurement = "";
+    if (config.measurement == null)
+      measurement = hass.states[config.entity].attributes.unit_of_measurement;
+    else
+      measurement = config.measurement;
+
+    const root = this.shadowRoot;
+    if (entityState !== this._entityState) {
+      root.getElementById("percent").textContent = `${entityState} ${measurement}`;
+      root.getElementById("title").textContent = config.title;
+      const turn = this._translateTurn(entityState, config) / 10;
+      root.getElementById("gauge").style.transform = `rotate(${turn}turn)`;
+      root.getElementById("gauge").style.backgroundColor = this._computeSeverity(entityState, config.severity);
+      this._entityState = entityState;
+    }
+    root.lastChild.hass = hass;
+  }
+
+  getCardSize() {
+    return 1;
+  }
+}
+
+customElements.define('gauge-card', GaugeCard);

docker-compose.yml

     container_name: home-assistant
     image: homeassistant/raspberrypi3-homeassistant
     restart: always
+    devices:
+      - /dev/video0:/dev/video0
     volumes:
       - ./config:/config
       - ./keys:/root/.ssh/
       - /etc/localtime:/etc/localtime:ro
-      - /var/lib/motion:/var/lib/motion
       - /dev/mem:/dev/mem
     restart: always
     privileged: true