Obwohl Zigbee eine fantastische Lösung ist, bin ich in der Praxis auf ein Problem gestoßen: Die Batterien des Zigbee-Bett-Sensors gehen schnell leer, besonders bei häufigem Einsatz als Schlafsensor. Daher habe ich mich entschlossen, auf eine Lösung mit permanenter Stromversorgung zu setzen. In diesem Tutorial zeige ich dir, wie du mithilfe von ESPHome und einem ESP8266 einen Bett-Schlafsensor realisieren kannst, der zuverlässig läuft und nicht von Batterien abhängig ist.

Warum ein Wechsel von Zigbee zu ESPHome?

Zigbee ist praktisch, weil es ein robustes Funkprotokoll ist und wenig Strom verbraucht. Jedoch ist gerade bei Sensoren, die über längere Zeiträume Daten liefern sollen, die Batterie ein Schwachpunkt. Vor allem, wenn der Sensor regelmäßig einen Status übertragen muss, um den Zustand zu überwachen, entlädt sich die Batterie schnell.

ESPHome bietet hier eine ideale Lösung. Es läuft auf kleinen, kostengünstigen Mikrocontrollern wie dem ESP8266 und unterstützt MQTT oder direkte Integrationen in ioBroker oder Home Assistant. Durch den Betrieb über eine konstante Stromquelle entfällt das Problem des Batterieverschleißes, und der Sensor ist immer online.

Was brauchst du für die neue Lösung?

Für den Wechsel von Zigbee auf eine ESPHome-Lösung benötigst du folgende Komponenten:

• ESP8266 (z.B. Wemos D1 Mini): Dies ist ein kleines, WLAN-fähiges Mikrocontroller-Board, das perfekt für ESPHome-Anwendungen geeignet ist.
• Alarmmatte oder druckempfindlicher Sensor: Eine Matte oder ein Sensor, der erkennt, ob jemand auf dem Bett liegt.
• USB-Netzteil: Um den ESP8266 dauerhaft mit Strom zu versorgen.
• ESPHome: Zum Flashen und Konfigurieren des ESP8266.

Schritt 1: Alarmmatte statt Zigbee-Drucksensor

In meinem früheren Artikel habe ich einen Zigbee-Drucksensor verwendet, um zu erkennen, ob jemand auf dem Bett liegt. Diese Funktion übernimmt nun eine Alarmmatte oder ein druckempfindlicher Sensor, den du einfach unter die Matratze oder den Topper legst. Die Alarmmatte wird über den GPIO-Pin des ESP8266 angeschlossen und registriert Druckveränderungen, sobald sich jemand ins Bett legt.

11. März 2026 15:46

Schritt 2: ESP8266 mit ESPHome flashen

Damit der ESP8266 die Daten der Alarmmatte auswerten und an dein Smart Home senden kann, musst du ihn mit ESPHome flashen und konfigurieren. Hier eine grobe Anleitung:

1. ESPHome installieren: Wenn du ESPHome noch nicht installiert hast, kannst du dies einfach über Home Assistant oder ioBroker tun.Falls du Home Assistant nutzt, findest du ESPHome als Add-on im offiziellen Add-on-Store. Bei ioBroker installierst du das ESPHome-Plugin direkt über die Adapterverwaltung.
2. ESP8266 flashen: Verbinde deinen ESP8266 (z.B. Wemos D1 Mini) über USB mit deinem Computer und flashe ESPHome mit den richtigen WLAN-Einstellungen.
3. MQTT einrichten: Richte MQTT ein, damit der ESP8266 über das WLAN mit deinem Smart Home kommunizieren kann.

11. März 2026 15:46

Schritt 3: Die Alarmmatte an den ESP8266 anschließen

Nun verbindest du die Alarmmatte mit dem ESP8266:

• GPIO-Pin D5 wird mit einem der beiden Drähte der Alarmmatte für Bewohner 1 verbunden.
• GPIO-Pin D6 wird mit einem der beiden Drähte der Alarmmatte für Bewohner 2 verbunden.
• Der zweite Draht der Matte (für beide Bewohner) kommt an Ground (GND) des ESP8266.

Hierdurch kann der ESP8266 den Zustand der Matte überwachen und feststellen, ob jemand im Bett liegt.

Schritt 4: ESPHome Konfiguration für den Schlafsensor

Der ESP8266 wird nun so konfiguriert, dass er den Status der Alarmmatte überwacht und per MQTT an ioBroker oder Home Assistant sendet. Hier ist die angepasste Konfiguration, die sowohl Bewohner1 als auch Bewohner2 berücksichtigt:

esphome:
  name: bett_status
  platform: ESP8266
  board: d1_mini

wifi:
  ssid: "Dein_WLAN_SSID"
  password: "Dein_WLAN_PASSWORT"  # Platzhalter für dein WLAN-Passwort

  # Optional: statische IP konfigurieren
  # manual_ip:
  #   static_ip: 192.168.1.XX
  #   gateway: 192.168.1.1
  #   subnet: 255.255.255.0

  # Fallback hotspot (wird aktiviert, wenn keine WLAN-Verbindung möglich ist)
  ap:
    ssid: "Bett Status Fallback Hotspot"
    password: "Dein_Fallback_Hotspot_Passwort"  # Platzhalter für dein Fallback-Hotspot-Passwort

mqtt:
  broker: "192.168.XXX.XXX"  # IP oder Hostname deines MQTT-Brokers
  # username: ""     # Optional: MQTT-Benutzername
  # password: ""     # Optional: MQTT-Passwort

# Logging aktivieren
logger:

# Aktivierung des OTA (Over the Air Updates)
ota:

# GPIO Pins für die Taster (D1 Mini: D5 und D6)
binary_sensor:
  - platform: gpio
    id: button_bewohner1
    pin:
      number: D5
      mode: INPUT_PULLUP
      inverted: true
    name: "Bett Bewohner1"
    filters:
      - delayed_on: 1s  # 1 Sekunde Timeout nach Tasterdruck
      - delayed_off: 1s
    on_press:
      - mqtt.publish:
          topic: "bett/bewohner1"
          payload: "true"
    on_release:
      - mqtt.publish:
          topic: "bett/bewohner1"
          payload: "false"

  - platform: gpio
    id: button_bewohner2
    pin:
      number: D6
      mode: INPUT_PULLUP
      inverted: true
    name: "Bett Bewohner2"
    filters:
      - delayed_on: 1s  # 1 Sekunde Timeout nach Tasterdruck
      - delayed_off: 1s
    on_press:
      - mqtt.publish:
          topic: "bett/bewohner2"
          payload: "true"
    on_release:
      - mqtt.publish:
          topic: "bett/bewohner2"
          payload: "false"

Schritt 5: Automatisierungen in ioBroker oder Home Assistant einrichten

Nun, da der Sensor betriebsbereit ist, kannst du in deinem Smart Home verschiedene Automatisierungen festlegen, die auf dem Status der Sensoren basieren. So kannst du etwa Lichter ausschalten, die Nachtbeleuchtung einschalten oder die Temperatur der Heizung auf Nachtbetrieb umstellen, sobald jemand im Bett liegt.

Fazit: Zuverlässiger Schlafsensor mit konstanter Stromversorgung

Die Umstellung von Zigbee auf ESPHome bietet eine stabile und langfristig wartungsfreie Lösung für die Schlafüberwachung. Anstatt ständig Batterien zu wechseln, hast du mit dem ESP8266 und der Alarmmatte eine zuverlässige Methode, um dein Smart Home genau dann in den „Schlafmodus“ zu versetzen, wenn es nötig ist.

Dank der Integration in ioBroker oder Home Assistant kannst du zahlreiche Automatisierungen umsetzen, von der Lichtsteuerung bis hin zur Temperaturregelung. Die Umstellung mag anfangs etwas aufwändiger erscheinen, lohnt sich jedoch durch den hohen Komfortgewinn und die Vermeidung häufiger Batteriewechsel.

Wenn du mehr über die ursprüngliche Zigbee-Lösung erfahren möchtest, schau dir gerne meinen Artikel „EinfacheModifikation zum Zigbee-Drucksensor“ an.

Mit dieser Anleitung kannst du deinen eigenen Schlafsensor mit konstanter Stromversorgung umsetzen und dein Smart Home auf einfache Weise erweitern. Viel Erfolg beim Nachbauen!

11. März 2026 15:46

Der Beitrag Von Zigbee zu ESPHome: SmartHome Bett-Sensor mit dauerhafter Stromversorgung erschien zuerst auf Sowas von Smart.

Ein Smarthome braucht so viele Daten wie möglich. Nachdem mein Smarthome mit Bewegungsmeldern in jedem Raum ausgestattet war, konnte ich das Licht beim Betreten des Raumes automatisieren.

Allerdings stand ich schnell vor einem Problem bzw. im Dunkeln. Der Bewegungsmelder erkennt nicht, wenn sich eine Person im Raum befindet, aber z.B. still auf dem Sofa sitzt. Das Licht ging aus – ich saß im dunklen. Hier hilft ein LD2410 mmWave Präsenzmelder!

Wie das Wort schon sagt, reagiert dieser nicht auf Bewegungen, sondern meldet die Anwesenheit im Raum. Dies erschreckend genau. Auf mehrere Meter entfernen wird sogar ein Atmen erkannt.

Diese Aufgabe lösen wir mit einem mmWave-Radarsensor.

Was ist ein mmWave Präsenzmelder

Ein mmWave-Sensor sendet elektromagnetische Wellen im Millimeterwellenbereich aus, die von Objekten in der Umgebung reflektiert oder gestreut werden. Der Sensor empfängt die reflektierten oder gestreuten Wellen und analysiert ihre Eigenschaften wie Laufzeit, Phasenverschiebung und Intensität.

Basierend auf diesen Eigenschaften werden Informationen über die Umgebung, wie Entfernung, Geschwindigkeit, Richtung und Größe von Objekten, gewonnen. Die Laufzeit der Wellen ermöglicht die Messung der Entfernung von Objekten, während die Phasenverschiebung die Messung der Geschwindigkeit ermöglicht.

Die Intensität der reflektierten oder gestreuten Wellen gibt Aufschluss über die Größe oder Beschaffenheit von Objekten. Zusammen ermöglicht die Analyse dieser Welleneigenschaften dem mmWave-Sensor präzise Erfassung und Detektion von Objekten und Informationen über die Umgebung.

Neben der vorgestellten Selbstbaulösung gibt es z.B. das Fertigprodukt Aqara FP1. Eine selbstgebaute Variante hat zum einen den Preisvorteil (ca. 10€). Zum anderen kann diese einfach per MQTT in das Smathome System eingebunden werden.

Was wird benötigt für einen mmWave Präsenzmelder

• Wemos D1 Mini: Ein günstiger, aber leistungsstarker ESP8266-basierter Mikrocontroller
• HLK-LD2410-Modul: ein mmWave Sensor der besonders günstig ist
• Kabel: Zum Verbinden der Komponenten.
• USB-Kabel: Zum Flashen der Firmware auf den Wemos D1 Mini.
• Lötkolben / Lötzinn / Seitenschneider
• Optional: Jumper-Kabel
• Optional: Ein 3D gedrucktes Gehäuse

Schritt 1 – Hardware

Als erstes wird die Platine HLK-LD2410 mit dem Wemos D1 Mini verbunden. Das Herzstück des mmWave Präsenzmelder. Beim Kauf des Moduls empfiehlt es sich, die Platine mit angelöteten Pins zu bestellen.

Der Sensor ist erstaunlich klein. Mit einem Lochabstand von nur 1,27 mm wird es eine knifflige Angelegenheit, die Kabel anzulöten.

1. Verbinde den VCC-Pin des HLK-LD2410-Moduls mit dem 5V-Pin des Wemos D1 Mini.
2. Verbinde den GND-Pin des HLK-LD2410-Moduls mit dem GND-Pin des Wemos D1 Mini.
3. Verbinde den RX-Pin des HLK-LD2410-Moduls mit dem TX-Pin des Wemos D1 Mini.
4. Verbinde den TX-Pin des HLK-LD2410-Moduls mit dem RX-Pin des Wemos D1 Mini.
5. Verbinde den OUT-Pin des HLK-LD2410-Moduls mit dem D1-Pin des Wemos D1 Mini.

Stelle sicher, dass du die Verbindungen fest und korrekt machst, um eine zuverlässige Kommunikation zwischen den Komponenten sicherzustellen.

Schritt 2 – yaml erstellen

Als nächstes erstellen wir die Firmware für den Wemos. Hier wecken wir den mmWave Präsenzmelder zum leben. Da wir ESPHome verwenden, müssen wir eine yaml-Datei erstellen. Hier kürzen wir ab. Denn im ioBroker Forum bin ich auf einen Beitrag gestoßen, wo ein User das Script bereits erstellt hat.

Neben dem Script wird noch die uart_read_line_sensor_ld2410v3.h benötigt. Diese muss im ioBroker in den Pfad /opt/iobroker/iobroker-data/esphome.0 kopiert werden.

Nachdem dies geschehen ist, öffnen wir ESPHome. Danach erstellen wir eine Standard ESP-Home yaml, welcher nachher auf den mmWave Präsenzmelder gespielt wird.

Anschließend wird dem Sensor ein Name gegeben.

Hier wählen wir ESP8266 für einen Wemos d1 mini.

Bearbeiten und Ersetzen des Codes

Nun editieren wir diese und ersetzen den Code mit dem aus dem ioBroker Beitrag:

esphome:
 name: ld2410m3d1
 includes:
   - uart_read_line_sensor_ld2410v3.h
 on_boot:
    priority: -100
    then:
     - script.execute: get_config


esp8266:
     board: esp01_1m


# Enable logging
logger:
 baud_rate: 0
 logs:
   sensor: INFO # DEBUG level with uart_target_output = overload!
   binary_sensor: INFO
   text_sensor: INFO

# Enable Home Assistant API
api:

ota:
 

wifi:
 ssid: "yyyyyyyyy1"
 password: "xxxxxxxxxxxxxx2"
 use_address: 192.168.178.67



substitutions:
 device_name: dev-sensor

mqtt:
 broker: 192.168.178.59
 port: 1506
 topic_prefix: ld2410motion/motion3
 
 
web_server:
 port: 80
 version: 2
 include_internal: true
 ota: false

captive_portal:

uart:
 id: uart_bus
 tx_pin:
   number: GPIO1
 rx_pin: 
   number: GPIO3
 baud_rate: 256000
 parity: NONE
 stop_bits: 1

switch:
 - platform: safe_mode
   name: use_safe_mode
   
 - platform: template
   name: configmode
   id: configmode
   optimistic: true
   # assumed_state: false
   turn_on_action:
     # - switch.turn_off: engineering_mode
     - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(true);'
     - delay: 100ms
     - script.execute: clear_targets
   turn_off_action:
     - lambda: 'static_cast<LD2410 *>(ld2410)->setConfigMode(false);'

 - platform: template
   name: show_target_stats
   id: show_stats
   optimistic: true
   internal: true
   turn_off_action:
     - script.execute: clear_targets

text_sensor:
 - platform: template
   name: uptime_human_readable
   id: uptime_human_readable
   icon: mdi:clock-start
   update_interval: 60s

sensor:
 - platform: uptime
   name: uptime_sensor
   id: uptime_sensor
   update_interval: 60s
   internal: true
   on_raw_value:
     then:
       - text_sensor.template.publish:
           id: uptime_human_readable
           state: !lambda |-
                     int seconds = round(id(uptime_sensor).raw_state);
                     int days = seconds / (24 * 3600);
                     seconds = seconds % (24 * 3600);
                     int hours = seconds / 3600;
                     seconds = seconds % 3600;
                     int minutes = seconds /  60;
                     seconds = seconds % 60;
                     return (
                       (days ? to_string(days)+":" : "00:") +
                       (hours ? to_string(hours)+":" : "00:") +
                       (minutes ? to_string(minutes)+":" : "00:") +
                       (to_string(seconds))
                     ).c_str();

 - platform: custom # currently crashes ESP32
   lambda: |-
     auto uart_component = static_cast<LD2410 *>(ld2410);
     //return {uart_component->movingTargetDistance,uart_component->movingTargetEnergy,uart_component->stillTargetDistance,uart_component->stillTargetEnergy,uart_component->detectDistance};
     return {};
   sensors:
   
 - platform: template
   name: movingTargetDistance
   id: movingTargetDistance
   unit_of_measurement: "cm"
   accuracy_decimals: 0
   internal: true
   
 - platform: template
   name: movingTargetEnergy
   id: movingTargetEnergy
   unit_of_measurement: "%"
   accuracy_decimals: 0
   internal: true
   
 - platform: template
   name: stillTargetDistance
   id: stillTargetDistance
   unit_of_measurement: "cm"
   accuracy_decimals: 0
   internal: true
   
 - platform: template
   name: stillTargetEnergy
   id: stillTargetEnergy
   unit_of_measurement: "%"
   accuracy_decimals: 0
   internal: true
   
 - platform: template
   name: detectDistance
   id: detectDistance
   unit_of_measurement: "cm"
   accuracy_decimals: 0
   internal: true
   
custom_component:
 - lambda: |-
     return {new LD2410(id(uart_bus))};
   components:
     - id: ld2410
     
binary_sensor:
 - platform: gpio
   name: mmwave_presence_ld2410
   id: mmwave_presence_ld2410
   pin: GPIO5
   device_class: motion
   on_state:
     then:
       - if: 
           condition: 
             - binary_sensor.is_off: mmwave_presence_ld2410
           then: 
             - delay: 150ms
             - script.execute: clear_targets

number:  
 - platform: template
   name: configMaxDistance
   id: maxconfigDistance
   unit_of_measurement: "M"
   min_value: 0.75
   max_value: 6
   step: 0.75
   update_interval: never
   optimistic: true
   set_action:
     - switch.turn_on: configmode
     - delay: 50ms
     - lambda: |-
         auto uart_component = static_cast<LD2410 *>(ld2410);
         uart_component->setMaxDistancesAndNoneDuration(x/0.75,x/0.75,id(noneDuration).state);
     - delay: 50ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
     - delay: 50ms
     - switch.turn_off: configmode

 - platform: template
   name: "sensitivity_threshold_(%)"
   id: allSensitivity
   min_value: 10
   max_value: 100
   step: 5
   mode: box
   update_interval: never
   optimistic: true
   set_action:
     - switch.turn_on: configmode
     - delay: 50ms
     - lambda: |-
         auto uart_component = static_cast<LD2410 *>(ld2410);
         uart_component->setAllSensitivity(x);
     - delay: 50ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
     - delay: 50ms
     - switch.turn_off: configmode
     
 - platform: template
   name: "motion_hold_(sec)"
   id: noneDuration
   min_value: 0
   # max_value: 32767
   max_value: 900
   step: 1
   mode: box
   update_interval: never
   optimistic: true
   set_action:
     - switch.turn_on: configmode
     - delay: 50ms
     - lambda: |-
         auto uart_component = static_cast<LD2410 *>(ld2410);
         uart_component->setMaxDistancesAndNoneDuration(id(maxconfigDistance).state, id(maxconfigDistance).state, x);
     - delay: 50ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
     - delay: 50ms
     - switch.turn_off: configmode
button:
 - platform: restart
   name: "reset/restart_ESP/MCU"
   entity_category: diagnostic
   on_press:
     - switch.turn_on: configmode
     - delay: 50ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->factoryReset();'
     - delay: 150ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->reboot();'
     - delay: 150ms

script:
 - id: get_config
   then:
     - switch.turn_on: configmode
     - delay: 500ms
     - lambda: 'static_cast<LD2410 *>(ld2410)->queryParameters();'
     - delay: 500ms
     - switch.turn_off: configmode
     
 - id: clear_targets
   then:
     - lambda: |-
         //id(hasTarget).publish_state(0);
         //id(hasMovingTarget).publish_state(0);
         //id(hasStillTarget).publish_state(0);
         id(movingTargetDistance).publish_state(0);
         id(movingTargetEnergy).publish_state(0);
         id(stillTargetDistance).publish_state(0);
         id(stillTargetEnergy).publish_state(0);
         id(detectDistance).publish_state(0);

Hier müssen wir noch folgende Änderungen vornehmen:

wifi:
 ssid: "yyyyyyyyy1"
 password: "xxxxxxxxxxxxxx2"
 use_address: 192.168.178.67

Hier müssen die WLAN-Zugangsdaten eingegeben werden. Soll der Sensor eine feste IP erhalten, so kann diese hier eingetragen werden. Falls keine vergeben werden soll, muss die Zeile gelöscht werden.

mqtt:
 broker: 192.168.178.59
 port: 1506
 topic_prefix: ld2410motion/motion3

Hier werden die Zugangsdaten für die MQTT-Verbindung festgelegt. Die IP des MQTT Brokers und der Port müssen angegeben werden. Im Topic geben wir an, in welchem Kanal der Sensor seine Werte ablegen soll.

Schritt 3 – Konfigurieren des mmWave Präsenzmelder

Jetzt können wir den Wemos flashen. Wir speichern die Datei und gehen auf „Install“ jetzt wählen wir mit welcher Methode wir flashen wollen. Ich bevorzuge es die Datei herunterzuladen und mit dem ESPHome-Flasher zu flashen.

Sobald der Flashvorgang abgeschlossen ist, sollte der Sensor mit dem WLAN und dem MQTT Broker kommunizieren.

Über die <<ip-adresse:80>> kann die Webkonfiguration geöffnet werden.

Hier können wir die Empfindlichkeit, die Entfernung und die Zeit einstellen, nach der der mmWave Präsenzmelder wieder den Wert „off“ ausgibt.

Hier hilft nur ausprobieren. Platziere den Sensor an der Stelle, an der er später sein soll. Dann stelle die Werte so ein, dass der Sensor die Anwesenheit erkennt.

Nun kontrollieren wir noch, ob die Werte über MQTT ankommen. Dazu gehen wir im ioBroker in die Objekte und öffnen den MQTT Adapter.

Optional kann der mmWave Präsenzmelder auch in einem 3D gedruckten Gehäuse untergebracht werden. Mir hat dieses Gehäuse sehr gut gefallen, da der Sensor so noch leicht in seiner Position verstellt werden kann.

Beispiele für Automationen

• Beim Verlassen des Raumes wird das Licht ausgeschaltet.
• Beim Betreten des Arbeitszimmers an Werktagen morgens werden Monitore, Drucker und der Heimarbeitsplatz-Computer eingeschaltet. Beim Verlassen des Raumes werden die Minitore ausgeschaltet, um Energie zu sparen.

Der Beitrag Hausgemachter mmWave-Präsenzmelder HLK-LD2410 erschien zuerst auf Sowas von Smart.

Was benötigt wird für einen Zigbee Drucksensor

• Lötkolben / Lötzinn / Seitenschneider
• Dünner Schlitzschraubendreher
• 2-adriges Kabel
• Zigbee Fenster-/Türkontakt
• Universeller Autositz-Drucksensor
• Optional Bohrer
• 10-15 Minuten Zeit

Bei dieser Anleitung wird der Sensor geöffnet. Hierdurch kann dieser beschädigt werden.

Vorhandenen Tür/Fenster-Sensor auseinander bauen mit Zigbee Drucksensor

Zunächst muss der eigentliche Zigbee Fenster-/Türkontakt zerlegt werden. Im Grunde müssen wir den vorhandenen Reed-Kontakt gegen den Zigbee Drucksensor austauschen.

Hierzu nehmen wir als Beispiel den Tuya Fensterkontakt. Dieser wird mithilfe eines dünnen Schlitzschraubendrehers geöffnet. An den jeweiligen Seiten befinden sich kleine Plastiknasen. (Achtung bitte breche diese nicht ab, da sonst ggf. das Gehäuse nicht mehr fest aufliegt)

Reed-Kontakt entfernen

Anschließend entnehmen wir die Platine. Auf an der Seite sehen wir in dem Glasröhrchen den Reedschalter. Dieser löst aus, sobald ein Magnet in die Nähe kommt. Dies wird mithilfe zweier Metallplatten die den Kontakt schließen gelöst. 

Der Reed-Kontakt wird mit dem Lötkolbens entfernt. (Achtung der Reed-Kontakt besteht aus einem Glaszylinder dieser kann brechen). Für unseren modifizierten Zigbee Drucksensor benötigen wir nun diesen Kontakt nicht mehr und tauschen diesen mit dem Drucksensor aus.

Drucksensor anlöten

Jetzt nehmen wir uns ein 2-Adriges Kabel und isolieren die Enden mithilfe eines Seitenschneiders ab. An den Kontaktflächen des Reed-Kontakts löten wir nun das Kabel an. Sollte die Länge des Kabels vom Drucksensor bereits ausreichen, kann der Sensor auch direkt angelötet werden. Stelle ggf. sicher, dass das Kabel nicht abgerissen werden kann. Hier kann zum Beispiel eine Zugentlastung durch einen Knoten im Kabel im Gehäuse dienen.

Kabel herausführen

Fast geschafft! Um das Kabel sauber aus dem Gehäuse herauszuführen, habe ich mich entschlossen eine kleine Bohrung in das Gehäuse zu setzen. Anschließend kann der Tür-/Fensterkontakt wieder zusammen montiert werden.

Zigbee Drucksensor anlernen

Jetzt kann der Fensterkontakt in das SmartHome-System angelernt werden. Sobald Druck auf den Autositz-Drucksensor ausgeübt wird, wird der Kontakt geschlossen und der Sensor meldet dies an die SmartHome-Zentrale. 

Beispiele für Automationen

Der Beitrag Tutorial: Zigbee Tür/-Fensterkontakt in ein Zigbee Drucksensor umbauen erschien zuerst auf Sowas von Smart.

Hierfür gibt es zwei Möglichkeiten. Zum einen verfügt der Switchbot-Hub über eine API-Schnittstelle, über die die Geräte eingebunden werden können. Hier laufen die Anfragen leider nicht lokal und es ist immer eine Cloudanbindung notwendig.

Wer mich kennt weiß, dass ich Cloudanbindungen gerne vermeide. Zu oft gibt es Änderungen, Verbindungsprobleme oder die Cloud wird sogar abgeschaltet. Die Überschritt verspricht ja eine Lösung, welche lokal läuft. Welche ist das nun?

Das ganze Projekt heißt SwitchBot-MQTT-BLE-ESP32 von devWaves auf Github. Hier kann man sich quasi einen eigenen Switchbot-Hub auf Basis des ESP32 bauen, die von jedem mit etwas technischem Verständnis umgesetzt werden kann.

Allerdings kann es auch Nachteile geben. Manchmal muss die Verbindung zwischen dem ESP32 Mikrocontroller und den SwitchBot Geräten länger aufgebaut werden, was zu Verzögerungen führen kann. Dadurch kann es 10-20 Sekunden dauern, bis die SwitchBot-Geräte die gewünschte Aktion ausführen. Dies tritt bei mir ab und zu auf. Woran dies liegt konnte ich noch nicht identifizieren.

Nichtsdestotrotz ist das SwitchBot-MQTT-BLE-ESP32-Projekt eine interessante Alternative zum Hub von SwitchBot, die mehr Flexibilität bietet. Durch die Verwendung von MQTT und BLE wird eine schnelle und sichere Verbindung zwischen den Geräten hergestellt, die von jedem mit etwas technischem Verständnis implementiert werden kann.

11. März 2026 15:46

Switchbot lokal – Was wir benötigen

• ESP32 – Board, welches mit dem Skript die Kommunikation durchführt
• Switchbot-Gerät – In diesem Beispiel Switchbot-Curtains
• MQTT Broker – Nachrichtenprotokoll im SmartHome-Netzwerk
• Arduino IDE – Zum flashen des ESP32
• Github-Projekt – SwitchBot-MQTT-BLE-ESP32

Schritt 1 – Vorbereitung

Als erstes laden wir uns das Github-Projekt herunter. Als nächstes, wenn noch nicht vorhanden, das Programm Arduino IDE. Mit diesem Programm können wir den Code anpassen und auf dem ESP flashen.

Zuerst laden wir das Github-Projekt herunter. Danach, falls noch nicht vorhanden, das Programm Arduino IDE. Mit diesem Programm können wir den Code anpassen und auf das ESP flashen.

Schritt 2 – Board- und Bibilothekverwaltung

Nun können wir im heruntergeladenen Projekt im Ordner „Arduino IDE Files“ die Datei „SwitchBot-BLE2MQTT-ESP32.ino“ öffnen. Danach müssen wir einige Pakete in der Arduino IDE installieren

Um mit dem ESP32 sprechen zu können, fügen wir zunächst in den Einstellungen unter „Zusätzliche Boardverwalter-URLs“ folgende URL ein und bestätigen mit OK:

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

Wenn bereits ein Eintrag vorhanden ist, kann der neue Eintrag nach einem Komma erfolgen.

Anschließend installieren wir das ESP32 Board

Sobald dies geschehen ist, gehen wir zur Bibliotheksverwaltung und installieren die folgenden Bibliotheken:

NimBLE-Arduino library (Tested working with version 1.4.0)

EspMQTTClient library (Tested working with version 1.13.3)

ArduinoJson library (Tested working with version 6.19.4)

CRC32 library (by Christopher Baker) (Tested working with version 2.0.0)

ArduinoQueue library (Tested working with version 1.2.5)

Schritt 3 – Anpassung am Code

Super! Alle Vorbereitungen sind abgeschlossen. Jetzt können wir den Code anpassen:

Wlan

/* Wifi Settings */
static const char* host = "esp32";                          //  Unique name for ESP32. The name detected by your router and MQTT. If you are using more then 1 ESPs to control different switchbots be sure to use unique hostnames. Host is the MQTT Client name and is used in MQTT topics
static const char* ssid = "WLAN-NAME";                           //  WIFI SSID
static const char* password = "WLAN-PASSWORT";                   //  WIFI Password

Hier gibst du deinen Wlan-Namen und dein Wlan-Passwort ein.

MQTT

/* MQTT Settings */
/* MQTT Client name is set to WIFI host from Wifi Settings*/
static const char* mqtt_host = "MQTT-BROKER-IP";                       //  MQTT Broker server ip
static const char* mqtt_user = "MQTT-USERNAME";                         //  MQTT Broker username. If empty or NULL, no authentication will be used
static const char* mqtt_pass = "MQTT-PASSWORT";                         //  MQTT Broker password
static const int mqtt_port = 1883;                                  //  MQTT Port
static const std::string mqtt_main_topic = "esp-switchbot";             //  MQTT main topic

In diesem Segment wird der MQTT Broker eingetragen. Falls dieser mit einem Passwort versehen ist, kann dieses ebenfalls angepasst werden. Achte darauf, dass der richtige Port angegeben ist, da sonst keine Verbindung aufgebaut werden kann.

Im Bereich Topic kann der Pfad angegeben werden, in dem der ESP senden soll. Dieser kann im Zweifelsfall wie voreingestellt belassen werden.

Mac-Adressen

/* Switchbot Curtain Settings */
static const int curtainClosedPosition = 10; // When 2 curtains are controlled (left -> right and right -> left) it's possible one of the curtains pushes one of the switchbots more open. Change this value to set a position where a curtain is still considered closed
static std::map allCurtains = {
{ "curtainone", "C1:39:13:XX:XX:XX" },
{ "curtaintwo", "CD:A6:17:XX:XX:XX" }

Nun müssen wir dem ESP noch mitteilen, auf welche Bluetooth-Geräte es hören soll. Dazu müssen wir die MAC Adresse der Switchbot Produkte angeben.

Wenn du sie nicht kennst, kannst du sie in der Switchbot App nachschauen:

Anschließend wird der Code entsprechend angepasst.

In diesem Beispiel füge ich meine Switchbot-Curtains unter „Switchbot Curtain Settings“ hinzu.

Solltest du ein Switchbot-Switch verwenden musst du die Mac-Adressen in dem Bereich „Switchbot Bot Settings“ eingeben.

Bei Bedarf kann in der Switchbot App noch ein Gerätepasswort eingegeben werden. So kann verhindert werden, dass Externe deine Geräte steuern können. Dies muss ggf. im Bereich Passwort hinterlegt werden -Switchbot lokal.

11. März 2026 15:46

Schritt 4 – ESP32 flashen

Sind alle Einstellungen vorgenommen, kann der Code auf das ESP32 geflasht werden. Dazu wird das ESP mit einem Micro-USB-Kabel an den Computer angeschlossen. Anschließend wählen wir unter Werkzeuge die richtigen Einstellungen des Boards aus.

Diese erfahrt ihr von dem Händler, bei dem ihr das ESP32 gekauft habt.

Anschließend kann der Code mit dem Button Hochladen übertragen werden.

Tritt während des Flashens ein Problem auf, wird dies auf der Konsole angezeigt. Mit Hilfe der Fehlercodes und einer Suchmaschine kann das Problem schnell identifiziert und behoben werden.

Schritt 5 – Daten werden per MQTT übertragen

Wenn der Flashvorgang erfolgreich war, sollte sich der ESP32 nun mit dem SwitchBot-MQTT-BLE-ESP32 in das Netzwerk einwählen. Wenn die IP im Browser geöffnet ist, kann hier ein Update für die Zukunft eingespielt werden.

In deiner Smarthome Zentrale sollte das ESP nun die Daten des Switchbot gerätes ausgeben. (In meinem Fall im Ordner MQTT im ioBroker im angegebenen Topic)

Mit dem Objekt state können die Vorhänge entweder mit einer Zahl (Prozentsatz) oder mit CLOSE bzw. OPEN bewegt werden Switchbot lokal.

Beispiele für Automationen

• Vorhänge werden mit dem Switchbot-Curtain je nach Anwesenheit und Helligkeitswert geschlossen
• Mit einem Switchbot-Switch lässt sich die Haustür öffnen nach dem erkannten klingen öffnen, indem der Bot auf die Öffnungstaste drückt

11. März 2026 15:46

Der Beitrag So gehts: Switchbot lokal und ohne Hub per MQTT steuern erschien zuerst auf Sowas von Smart.

Soll die Lampe also automatisiert für einen kürzeren Zeitraum von z.B. 50 Sekunden ausgeschaltet werden, steht man für kurze Zeit im Dunkeln, bis die Lampe wieder angeht.

11. März 2026 08:01

Was bewirkt der Hack?

Ein kleiner Hack am Xiaomi Aqara Bewegungsmelder kann hier Abhilfe schaffen. Durch einen kleinen Eingriff lässt sich die Aktualisierungsfrequenz erhöhen. Nämlich auf 5 Sekunden. Das heißt, nachdem der Sensor eine Bewegung erkannt hat, setzt er diese nach 5 Sekunden wieder auf falsch. Nun sucht der Bewegungsmelder erneut nach einer Bewegung. Im obigen Beispiel bleibt das Licht also an. Problem gelöst.

Schritt 1 – Batterie entfernen

Batteriefach durch Drehen öffnen und Batterie entnehmen.

Schritt 2 – Aqara Bewegungsmelder öffnen

Zuerst müssen wir den Aqara Bewegungsmelder öffnen. Dieser kann mit einem Schraubendreher aufgehebelt werden. Die roten Kreise zeigen die Haltezungen.

Schritt 3 – Platine entnehmen

Die Platine herausnehmen. Diese ist nur eingesteckt und kann herausgezogen werden.

Schritt 4 – Aqara Bewegungsmelder löten

Nun kommt der kleine Hack um den Aqara Bewegungsmelder zu modifizieren. Hierzu muss nur der Kontakt TP4 mit dem unteren Schaltkontakt gedrückt werden. Dazu nimmst du am besten einfach ein kleines Stück Draht als Brücke. Achte darauf, dass du mit dem Draht keine anderen Punkte berührst.

Es gibt verschiedene Versionen von der Platine. Daher können hier Optische unterschiede sein. Die Punkte sollten jedoch auch bei dir vorzufinden sein.

Schritt 5 – Montieren

Alles fertig? Nun kann der Aqara Bewegungsmelder in umgekehrter Reihenfolge wieder zusammengebaut werden.

Schritt 6 – Einbinden ins SmartHome

Anschließend können wir die Timeout-Zeit („occupancy_timeout“) im ioBroker für den Sensor ändern. Der Bewegungsmelder kann nun mit der höchsten Frequenz von 5 Sekunden abgefragt werden.

Nach meinen Erfahrungen hat diese Änderung keinen großen Einfluss auf die Batterielebensdauer.

Der Beitrag Hack: Aqara Bewegungsmelder Aktualisierungsfrequenz erhöhen erschien zuerst auf Sowas von Smart.

So war es mir wichtig die Verbräuche zu verfolgen, automatisiert zu dokumentieren und mir täglich die Verbräuche zur Verfügung zu stellen.

Als erstes habe ich versucht, die Impulse des Gaszählers auszuwerten. Dies ist möglich, da jeder moderne Gaszähler bei jeder Umdrehung einen magnetischen Impuls abgibt.

Ich testete dies mit einem Zigbee-Fensterkontakt. Dieser erwies sich im Betrieb als zuverlässig. Das Problem war jedoch, dass die Impulse verloren gingen, wenn die Smarthome-Zentrale offline war (z.B. bei einem Backup oder einem Stromausfall). Dadurch driftete der tatsächliche Zählerstand vom gespeicherten Zählerstand ab.

Daher suchte ich nach einer Möglichkeit, diese Impulse mit einem ESP zu trocknen. Sollte die Smarthome Zentrale die gesendeten Werte nicht annehmen, würden diese gespeichert werden. Aber auch das hat sich in der Praxis als nicht zuverlässig erwiesen.

11. März 2026 08:01

Deshalb zeige ich jetzt den besten und sichersten Weg. Wir ignorieren die Impulse und erfassen den Zählerstand direkt mit einer Kamera. Das aufgenommene Foto wird analysiert und per KI ausgelesen und in Zahlen umgewandelt.

AI-on-the-edge-device -Smarter Gas

Das Programm von jomjol auf Github läuft auf einem ESP mit einem Kameramodul.

Was wird benötigt

ESP32 mit Kamera-Modul (Ich hatte ein paar ESP ausprobiert. Nur mit diesem hatte ich keine Probleme)

USB-Adapter oder FTTI-Adapter (vorzugsweise die USB-Adapter Platine)

Jumper-Kabel (wenn der FTTI-Adapter verwendet wird)

5V-Netzteil (Zur Stromversorgung)

Micro SD-Karte

3D-Gehäuse

Installation

Im Laufe der Zeit ist es den Entwicklern gelungen, die Installation zu vereinfachen. So muss man den ESP32 nur noch richtig verkabeln oder sich diesen Schritt mit einem USB-Modul erleichtern. Der ESP32 muss dann nur noch auf das Modul gesteckt werden und kann sofort mit dem Flashen beginnen.

Da ich dieses Modul nicht habe, habe ich es mit einem FTTI-Adapter verkabelt.

Nun wechseln wir in den Chrome Browser. Dort rufen wir die Webseite zum Online-Flasher auf und verbinden der ESP32 mit dem Computer.

Nun kann der Button Connect ausgeführt werden. Nach erfolgreicher Verbindung beginnt die Installation.

Hardware vorbereiten

Zuerst müssen wir die Kamera scharf stellen. Das ist der riskanteste Teil. Denn die Kameras der ESP-Module haben einen kleinen Klebepunkt, der den Fokusring an der Kamera fixiert.

Da die Kamera von Haus aus auf größere Entfernungen eingestellt ist, müssen wir diesen Klebepunkt vorsichtig! mit einem scharfen Messer entfernen. Danach können wir den Fokus der Kamera in die Nähe verschieben. Die genaue Einstellung nehmen wir später vor.

SD-Karte vorbereiten

Da das Programm noch weitere Daten benötigt, laden wir die Datei AI-on-the-edge-device__manual-setup__vXXXXXX.zip von Github herunter.

Im heruntergeladenen Ordner befindet sich die Datei sd-card.zip. Diese wird nun auf eine Micro-SD-Karte kopiert. Anschließend müssen die Wlan-Daten in die wlan.ini eingetragen werden.

ssid = "DEINE-SSID"
password = "DEIN-PASSWORD"

ESP an dem Gaszähler montieren

Dafür habe ich mir viele 3D-gedruckte Gehäuse angeschaut. Leider hat mich keines überzeugt, da sich der Gaszähler bei mir in einer kleinen Nische in der Wohnung befindet, wo auch der Staubsauger und andere Reinigungsutensilien stehen. Die Gehäuse sind zu groß, da der ESP frontal auf den Zähler schaut. Durch Zufall bin ich auf dieses Gehäuse gestoßen. Es ist viel kompakter und der ESP kann auf der Oberseite montiert werden, da innen ein Spiegel aufgeklebt ist, der um die Ecke schaut.

Ich habe das Gehäuse in weiß gedruckt. Auf dem ESP32 befindet sich ein Blitz, der ausgelöst wird, wenn der Zählerstand fotografiert wird. Dies scheint durch das weiße Gehäuse durch. Da ich es schon bedruckt hatte, habe ich es von innen mit schwarzer Farbe besprüht.

So leuchtet das Gehäuse nicht mehr im Dunkeln und der Kontrast ist besser.

Einrichtung

Sobald der EPS32 mit Strom versorgt wird, kann mit der Konfiguration über die IP-Adresse begonnen werden. Dabei ist es wichtig, dass der EPS32 fest mit dem Gaszähler verbunden ist und sich nicht mehr bewegen kann.

Referenzbild

Die Installationsschritte sind einfach und mit Erklärungen versehen. Der erste Schritt ist die Erstellung eines Referenzbildes. Dazu wählen wir „Create New Reference“. Mit den jeweiligen Punkten „Mirror Image“, „Pre-Rotate Angle“, „Bringhtness“ und „LEDIntensity“ kann das Bild gerade ausgerichtet und im Kontrast verstärkt werden.

Referenzpunkte

Anschließend fragt das AI-on-the-edge-Gerät nach Referenzpunkten. Anhand dieser Referenzpunkte wird das aufgenommene Bild ausgerichtet. Hier empfehle ich zwei Punkte zu nehmen, die entweder am oberen und unteren Rand oder schräg versetzt liegen. In meinem Beispiel nehme ich die Zahl 2019 und auf der rechten Seite die m3.

Über die Select Reference Auswahl kann zwischen den Punkten gewählt werden. Vergessen Sie nicht, dies mit dem Update Button zu bestätigen und zu speichern.

Digitale Werte

Im nächsten Schritt erstellen wir die einzelnen Bereiche der zu lesenden Zahlen. Zuerst wählen wir die erste Zahl aus. Dazu muss sich die Zahl vollständig in dem kleinen Kästchen befinden. Nimm dir dafür viel Zeit. Je genauer, desto besser.

Weitere Zahlen können über „Neue ROI“ erstellt werden. Wenn die Zahlen nicht perfekt aneinander liegen, deaktiviere die Checkbox Synchronize. So kannst du die Zahlen einzeln in Größe und Position verschieben.

Analoge Werte

Im nächsten Schritt können noch analoge Zähler (z.B. auf Wasseruhren) angelegt werden. Da mein Gaszähler dies nicht hat, wähle ich diese nicht aus.

Nach diesem Schritt startet der ESP32 neu.

Konfiguration überprüfen

Jetzt heißt es warten. In der Standardkonfiguration erstellt das Programm alle 5 Minuten ein neues Bild und analysiert es. Warte lieber ein paar Minuten länger. Dein Zählerstand sollte nun erkannt und in Text (Zahlen) umgewandelt werden. Sollte dies nicht der Fall sein, kann die Konfiguration über den Reiter Settings nochmals angepasst werden.

Weitere Einstellungen

Im letzten Schritt gehen wir nun auf Settings > Configuartion.

Den Punkt Decimal Shift stelle ich auf „-2“, da ich zwei Nachkommastellen auslesen möchte (dig5 und dig6).

Im Bereich MQTT trage ich meinen MQTT-Broker und ggf. die Anmeldedaten ein.

Integration im ioBroker

Nach einem Neustart von AI-on-the-edge-device überträgt dieser tolle Helfer alle 5 Minuten die Werte per MQTT an meinen ioBroker. Zuverlässig und immer genau. Für mich also die beste Lösung, um einen Wasser- oder Gaszähler auszulesen!

11. März 2026 08:01

Der Beitrag Smarter Gas-/Wasserzähler – Künstliche Intelligenz macht es möglich erschien zuerst auf Sowas von Smart.

Was ist AdGuard Home?

AdGuard Home ist wie ein magischer Schild, der dich vor allem Unheil schützt, das im Internet auf dich lauert. Es funktioniert wie ein DNS-Server und blockiert alle nervigen Werbeanzeigen und bösartigen Inhalte, bevor sie dein Gerät erreichen. So kannst du endlich das Internet genießen, ohne von Werbung erschlagen zu werden!

Die Superkräfte von AdGuard Home:

• Adieu Werbung: Der Werbeblocker schießt den nervigen Werbebannern den Kopf weg und schickt sie in die ewigen Jagdgründe! Jetzt kannst du auf deinen Lieblingsseiten surfen, ohne von Pop-ups und Bannern gestört zu werden.
• Sicherheitskraft: Dieser Superheld ist nicht nur stark gegen Werbung, sondern auch gegen fiese Tracker und Malware. Deine Privatsphäre ist in den besten Händen und du kannst unbesorgt im Internet surfen.
• Familienfreundlich: Ein echter Familienmensch! Du kannst eine Kindersicherung einrichten, um die lieben Kleinen vor ungeeigneten Inhalten zu schützen. So können sich Mama und Papa entspannen, während die Kinder sicher surfen.
• Einfach individuell: Wie ein Chamäleon – es passt sich deinen Bedürfnissen an. Du kannst Blacklists, Whitelists und Filterregeln erstellen, um das Internet nach deinem Geschmack zu gestalten.

Super einfach zu installieren

Du musst kein Computer-Genie sein, um AdGuard Home zu installieren. Egal, ob du ein Linux-Fan, ein virtueller Zauberer oder ein Docker-Tüftler bist, er findet immer einen Weg zu dir!

Schritt 1: Voraussetzungen prüfen

Stelle sicher, dass dein System die Mindestanforderungen für AdGuard Home erfüllt. Es ist mit den meisten Linux-Systemen, virtuellen Maschinen und Docker-Containern kompatibel. Prüfe auch, ob du über die notwendigen Rechte verfügst, um die Installation durchzuführen.

Schritt 2: Installation ausführen

Öffne die Kommandozeile deines Systems und führe folgenden Befehl aus, um die Installation zu starten:

curl -s -S -L https://raw.githubusercontent.com/AdguardTeam/AdGuardHome/master/scripts/install.sh | sh -s -- -v

Dieser Befehl lädt das Installationsskript von AdGuard Home herunter und führt es aus. Die notwendigen Dateien und Abhängigkeiten werden automatisch heruntergeladen und installiert.

Schritt 3: Router-Einstellungen anpassen

Damit AdGuard Home auf allen Geräten in deinem Netzwerk funktioniert, musst du die DNS-Einstellungen deines Routers anpassen. Logge dich in das Webinterface deines Routers ein und weise die IP-Adresse deines AdGuard Home-Servers als DNS-Server für das gesamte Netzwerk zu. Alternative kannst du auch manuell den DNS-Sever auf jedem Device selbst setzen.

Schritt 4: Weboberfläche und Einrichtung

Nach erfolgreicher Installation erreichst du das AdGuard Home Webinterface unter folgender IP-Adresse:

http://[IP-Adresse-deines-Servers]:3000

Hier kannst du die Einstellungen anpassen, Filterregeln erstellen und die Kindersicherung konfigurieren.

 

Ein Held für das gesamte Netzwerk

AdGuard Home schützt das gesamte Netzwerk – eine wahrhaft altruistische Lösung! Mit seiner beeindruckenden Fähigkeit, alle Geräte im Netzwerk zu schützen, ist AdGuard Home der zuverlässige Wächter, der lästige Werbung und bösartige Inhalte fernhält. Durch eine einfache Anpassung der DNS-Einstellungen deines Routers wird AdGuard Home aktiviert und entfaltet seine schützenden Kräfte, um jedes Mitglied deines Netzwerks vor den lästigen Unannehmlichkeiten des Internets zu bewahren.

AdGuard Home ist nicht irgendein Werbeblocker, sondern ein echter Held für das gesamte Netzwerk. Egal ob du einen Computer, ein Smartphone, ein Tablet oder einen Smart-TV verwendest, er ist bereit, alle Geräte in deinem Netzwerk zu schützen. Es spielt keine Rolle, wie viele Geräte du in dein Netzwerk integriert hast; er ist der zuverlässige Wächter, der das gesamte Netzwerk umfassend schützt!

AdGuard Home – dein treuer Begleiter

Dieser Webeblocker ist nicht nur ein Held, sondern auch dein treuer Begleiter bei deinen Abenteuern im Internet! Die benutzerfreundliche Web-Oberfläche macht die Anpassung zum Kinderspiel und du behältst stets die Kontrolle über dein Internet-Erlebnis. Von der Konfiguration der Filterregeln bis zur Aktivierung der Kindersicherung – AdGuard Home begleitet dich auf Schritt und Tritt und bietet dir eine maßgeschneiderte Lösung für deine individuellen Bedürfnisse.

Egal, ob du ein Technik-Profi oder ein Anfänger bist, der Werbeblocker steht dir mit seiner einfachen, aber leistungsstarken Benutzeroberfläche zur Seite. Es ist der zuverlässige Partner, mit dem du das Internet nach deinen Wünschen gestalten kannst. Du hast immer einen zuverlässigen Begleiter an deiner Seite, der dich vor den Herausforderungen des digitalen Dschungels schützt.

Fazit: AdGuard Home – Der Champion für dein Internet-Abenteuer!

Mit AdGuard Home ist dein Internet-Abenteuer sicher und werbefrei. Keine lästige Werbung, keine Sorgen – nur ungetrübtes Surfvergnügen. Egal ob du ein Technik-Profi oder ein Anfänger bist, AdGuard Home ist der ultimative Champion für ein angenehmes Online-Erlebnis. Entdecke das Internet ohne Werbebelästigung und gönne dir entspanntes Surfen mit AdGuard Home – dem treuen Helden für dein gesamtes Netzwerk! Vertraue AdGuard Home und lass es dich bei deinem Internet-Abenteuer begleiten – immer bereit, dich vor den Herausforderungen des digitalen Dschungels zu schützen. Mit AdGuard Home hast du einen wahren Superhelden gefunden, der dein gesamtes Netzwerk schützt und dir ein sorgenfreies Surfen ermöglicht!

Der Beitrag AdGuard Home – Der ultimative Superheld für werbefreies Surfen! erschien zuerst auf Sowas von Smart.