Warum All-Inkl.com?

Bevor wir in die Technik einsteigen, ein kurzer persönlicher Einblick:
Ich bin seit fast 20 Jahren Kunde bei All-Inkl – und das aus gutem Grund. Der Hoster überzeugt mich seit Tag eins mit einer stabilen Erreichbarkeit, einem klar und einfach strukturierten KAS-Interface (Kundenadministrationssystem) und einem Support, der seinen Namen verdient: schnell, freundlich und kompetent – auch nachts oder am Wochenende.

 All-Inkl Partnerlink

Warum die Domain bei Namecheap?

Meine aktuelle Domain habe ich bei Namecheap registriert, da All-Inkl die gewünschte Domainendung nicht anbietet. Namecheap unterstützt eine breite Auswahl an Domain-TLDs, darunter viele exotische und neue Endungen, die bei deutschen Hostern (noch) nicht verfügbar sind.
Zudem sind die Preise dort durchaus attraktiv, was für künftige Projekte ebenfalls interessant sein könnte.

Schritt-für-Schritt: Namecheap-Domain bei All-Inkl nutzen

Du hast also deine Wunschdomain bei Namecheap gekauft und willst diese mit deinem All-Inkl-Webspace verbinden. So gehst du vor:

1. Nameserver von All-Inkl bei Namecheap eintragen

Damit deine Domain auf deinen Webspace bei All-Inkl zeigt, musst du die Nameserver ändern.

So geht’s:

1. Logge dich bei Namecheap.com ein.
2. Gehe zu „Domain List“ (linke Seitenleiste).
3. Klicke bei der betreffenden Domain auf „Manage“.
4. Im Reiter „Nameservers“ wählst du „Custom DNS“ aus.
5. Trage dort die Nameserver von All-Inkl ein: ns5.kasserver.com ns6.kasserver.com
6. Speichern – fertig!

Hinweis: Es kann bis zu 24 Stunden dauern, bis die Änderungen weltweit aktiv sind (DNS-Propagation).

2. Domain bei All-Inkl hinzufügen

Jetzt geht’s ins KAS (Kundenadminbereich) von All-Inkl:

1. Melde dich bei kas.all-inkl.com an.
2. Gehe zu „Domains“ → „Neue Domain anlegen“.
3. Gib deine bei Namecheap registrierte Domain ein (z. B. meineseite.de).
4. Wähle aus, ob du die Domain direkt auf dein Hauptverzeichnis zeigen lassen oder ein separates Verzeichnis anlegen willst (z. B. /meineseite/).
5. Abschicken – das war’s.

Sobald die DNS-Änderung wirksam ist, zeigt deine Domain auf deinen All-Inkl-Webspace.

3. Volle Kontrolle über die Domain bei All-Inkl

Mit der Umstellung der Nameserver liegt die technische Verwaltung der Domain vollständig bei All-Inkl. Das bedeutet konkret:

• Du kannst beliebig Subdomains anlegen (z. B. blog.deinedomain.xyz, shop.deinedomain.xyz).
• Du hast die Möglichkeit, eigene E-Mail-Adressen zu erstellen (z. B. kontakt@deinedomain.xyz).
• Auch Weiterleitungen, DNS-Einstellungen (z. B. für externe Dienste) und SSL-Zertifikate lassen sich zentral im KAS verwalten.

Damit fühlt sich die Domain im Alltag nicht „extern“ an – obwohl sie technisch weiterhin bei Namecheap registriert ist.

Fazit: Flexible Kombination – zuverlässig umgesetzt

Die Kombination einer bei Namecheap (oder bei einem anderen Anbieter) registrierten Domain mit einem Webhosting bei All-Inkl funktioniert problemlos und ist in wenigen Minuten eingerichtet. Auch wenn die Domainregistrierung bei einem anderen Anbieter erfolgt ist, lässt sich das Hosting durch die richtigen Nameserver-Einstellungen nahtlos nutzen.

Wer wie ich auf eine spezielle Domainendung angewiesen ist, die beim Webhoster nicht verfügbar ist, findet mit Anbietern wie Namecheap eine gute Ergänzung. Und: Ein Blick auf die Preise lohnt sich dort ebenfalls – vor allem bei ungewöhnlicheren TLDs.

Der Beitrag Namecheap-Domain mit All-Inkl-Webhosting verbinden erschien zuerst auf Sowas von Smart.

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.

31. März 2026 16:56

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.

31. März 2026 16:56

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!

31. März 2026 16:56

Der Beitrag Von Zigbee zu ESPHome: SmartHome Bett-Sensor mit dauerhafter Stromversorgung 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.

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.

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.

31. März 2026 16:56

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.

31. März 2026 16:56

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

31. März 2026 16:56

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

Einige Daten sind daher Hochrechnungen und geben nicht exakt den aktuellen Wert wieder. Abhilfe kann hier eine eigene Wetterstation schaffen.

2. April 2026 13:09

Mit Hilfe der Netatmo Wetterstationen können Daten wie Temperatur, Luftfeuchtigkeit, Regenmenge und Windgeschwindigkeit abgelesen werden. Weltweit gibt es in fast jeder Region Wetterstationen, die diese Daten liefern.

Ich zeige dir nun, wie du die Daten einfach auslesen und in deinen ioBroker integrieren kannst. Sodass du im ioBroker aktuelle Wetterdaten bekommst.

Als erstes installieren wir den Netatmo-Crawler Adapter und öffnen anschließend die Einstellungen des Adapters. Nun werden wir aufgefordert, die URL der Station einzugeben.

Dazu öffnen wir die Webseite: https://weathermap.netatmo.com

Auf dieser Karte werden alle Standorte der Netatmo Wetterstationen angezeigt, die netterweise ihre Daten öffentlich teilen.

Hier suchen wir uns nun eine Wetterstation, die möglichst nahe an unserem Standort ist, möglichst viele Werte anbietet und plausible Werte liefert.

Ich hatte zum Beispiel mal eine Station genommen, bei der ein Baum gefällt wurde. Dadurch war der Temperatursensor nicht mehr im Schatten, sondern in der Sonne. Hier sind mir unplausible Werte aufgefallen, sobald keine Wolken am Himmel zu sehen waren.

Haben wir eine Wetterstation gefunden, klicken wir auf Teilen -> Link kopieren. Dies ist bereits die URL, die wir nun im ioBroker in den Adapter Netatmo-Crawler einfügen.

Es können auch mehrere Stationen gecrawlt werden. Dazu muss jeder Link in eine eigene Zeile eingefügt werden.

Standardmäßig erhalten wir dann alle 20 Minuten neue Daten von der Wetterstation in unserer Umgebung.

Die Abrufhäufigkeit kann mit Hilfe des Cronejobs angepasst werden. Es wird jedoch empfohlen, die Standardeinstellung von 20 Minuten beizubehalten, da es sonst zu Problemen kommen kann. So erhältst du alle 20 Minuten im ioBroker aktuelle Wetterdaten.

2. April 2026 13:09

Der Beitrag ioBroker – Netatmo Wetterstation abgreifen für aktuelle, lokale Wetterdaten 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.

2. April 2026 13:09

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!

2. April 2026 13:09

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

Was mich auch wunderte war, dass die Zusammenfassung im Adapter Tab folgendes anzeigte:

Die Anzahl der ausgewählten Adapter entsprach der Anzahl der installierten Adapter. Außerdem war der Stern-Button („Nur installierte Adapter anzeigen“) nicht aktiv.

Als erstes habe ich folgendes versucht um den ioBroker Fehler zu beseitigen:

iobroker stop
iobroker fix
iobroker update
iobroker upgrade
iobroker start

Der iobroker fix, welcher ioBroker Fehler beheben kann, brachte leider kein Ergebnis. Ich habe dann einen weiteren Blick in die Einstellungen des ioBroker geworfen. Hier waren unter dem Reiter Repository keine Quellen mehr zu finden.

Eine manuelle Erstellung der Quellen für die Adapterinstallation konnte nicht gespeichert werden. Nach dem Speichern waren die Quellen sofort wieder verschwunden.

Was mir geholfen hat:

iobroker stop
iobroker setup first
iobroker start

iobroker repo list

Mit dem Befehl „iobroker setup first“ werden die Konfigurationen neu erstellt. Bestehende werden jedoch nicht überschrieben.

Nach dem Start des iobroker sind die Quellen wieder verfügbar und alle Adapter werden wieder gefunden. Der ioBroker Fehler wurde beseitigt. Im Terminal kann mit „iobroker repo List“ überprüft werden, welche Quellen der ioBroker abruft.

Der Beitrag ioBroker Fehler: Wenn keine Adapter mehr gefunden werden erschien zuerst auf Sowas von Smart.