Zusammenfassung:

Welche Möglichkeiten gibt es eigene Hardware ins Smarthome zu integrieren?

Wir nehmen absichtlich etwas sehr Einfaches um das Prinzip zu zeigen. Der kleine Testaufbau zeigt ein Poti und eine LED am ESP32 WROOM
Mit dem Poti kann die Helligkeit der LED von 0 bis 100% gesteuert werden. Der Wert wird über USB gesendet.

void setup() {
  Serial.begin(9600);
}

void loop() {
  int x = analogRead(A0);
  analogWrite(14, x*255/4096);
  Serial.print(x*100/4095); Serial.println(" %");
  delay(100);
}

Variante 1:

Wenn sowieso schon ein ArduinoCode vorliegt, kann dieser erweitert werden um Daten per MQTT zu senden und zu empfangen. Ein MQTT-Broker ist bereits in IO-Broker oder Home Assistant integriert. Oder einfacher man hat schon funktionierende MQTT Programme und fügt nur Aktoren und Sensoren hinzu.
Programmiert wird über die Arduino IDE. Man muss dort folgendes installieren:

Unter Boardverwaltung

und unter Bibliotheken

#include <WiFi.h>
#include <PubSubClient.h>

// Anschlüsse
#define LEDPin 14
#define PotiPin A0
// Netzwerk- und MQTT-Broker-Informationen
const char* ssid = "HWR";
const char* password = "geheim";
const char* mqtt_server = "192.168.178.118";
const int mqtt_port = 1883; // Standardport für MQTT
const char* mqtt_user = "Stefan";
const char* mqtt_pass = "geheim";


// WiFi und MQTT-Client-Objekte
WiFiClient espClient;
PubSubClient client(espClient);

// Variablen
const int analogPin = A0; // Analoger Pin
char msgBuffer[50];
int SetWert = 0; // Globale Variable zum Speichern des empfangenen Werts

void setup() {
  Serial.begin(115200);
  
  // WLAN-Verbindung herstellen
  setup_wifi();
  
  // MQTT-Server konfigurieren
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WLAN verbunden");
  Serial.println("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Versuchen, eine Verbindung zum MQTT-Broker herzustellen
  while (!client.connected()) {
    Serial.print("Versuche, eine Verbindung zum MQTT-Broker herzustellen...");
    // Verbindung mit Benutzername und Passwort
    if (client.connect("ESP32Client", mqtt_user, mqtt_pass)) {
      Serial.println("Verbunden");
      // Abonnieren des "Poti/Set" Topics
      if (client.subscribe("Poti/Set")) {
        Serial.println("Erfolgreich für Poti/Set abonniert");
      } else {
        Serial.println("Abonnement fehlgeschlagen");
      }
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Versuche es in 5 Sekunden erneut");
      delay(5000);
    }
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  // Eingehende Nachrichten verarbeiten
  Serial.print("Nachricht angekommen [");
  Serial.print(topic);
  Serial.print("] ");
  
  // Payload in eine Zeichenkette umwandeln
  char payloadString[length + 1];
  for (int i = 0; i < length; i++) {
    payloadString[i] = (char)payload[i];
  }
  payloadString[length] = '\0'; // Nullterminierung der Zeichenkette

  Serial.println(payloadString);

  // Konvertieren der Zeichenkette in eine Integer-Variable
  SetWert = atoi(payloadString);
  Serial.print("Empfangener Wert als Integer: ");
  Serial.println(SetWert);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
   // Analogen Wert lesen
  int analogValue = analogRead(PotiPin)*100/4095;
  Serial.print("Analogwert: ");
  Serial.println(analogValue);

  // Wert in das "Poti/Wert" Topic senden
  snprintf(msgBuffer, 50, "%d", analogValue);
  client.publish("Poti/Wert", msgBuffer);
  
  analogWrite(LEDPin, SetWert*255/100);

  delay(2000); // Wartezeit zwischen den Messungen
}

 Im Home Assistant muss dann das in die configuration.yaml

mqtt:
  sensor:
    - unique_id: Poti_wert
      name: "Poti Wert"
      state_topic: "Poti/Wert"
      qos: 0
      unit_of_measurement: "%" 
      value_template: "{{ value | int }}"

automation:
  - alias: "Steuere Poti Set mit aktuellem Wert"
    trigger:
      - platform: state
        entity_id: sensor.poti_wert
    action:
      - service: mqtt.publish
        data:
          topic: "Poti/Set"
          payload: "{{ states('sensor.poti_wert') }}"

Variante 2:

Im Home Assistant - ESPHome Builder öffen - NEW DEVICE - CONTINUE - Name vergeben - NEXT - ESP32 wählen (für den WROOM) -***- INSTALL
- Manual Download - (warten) ... - Factory format - (Browser speichert die Datei vermutlich in Downloads - CLOSE
- im Browser die Seite "https://web.esphome.io/" öffnen - VERBINDEN - Schnittstelle wählen - VERBINDEN - INSTALL - Datei wählen - Öffnen - Installieren -
-***- Wenn ihr eure WLAN-Daten nicht in der "!secret" gespeichert habt, müsst ihr hier - SKIP - EDIT - SAVE - dann auf die 3Punkte - weiter mit INSTALL wie oben

 Hier mein Code für dieses Beispiel:

esphome:
  name: poti-led
  friendly_name: Poti_LED

esp32:
  board: esp32dev
  framework:
    type: arduino

# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: "WxoCSxgqmp23GzAy6woGnuZF6Q6Vo0WRbcUPCKch5vE="

ota:
  - platform: esphome
    password: "dab9f57ecaa1361c7fb2890c8a23c119"

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

  ap:
    ssid: "Display Fallback Hotspot"
    password: "OJeDHki1Wid9"

captive_portal:

# Analogen Sensor einrichten
sensor:
  - platform: adc
    pin: A0
    name: "Analog Input"
    id: analog_input
    update_interval: 1s
    unit_of_measurement: "%"
    filters:
      - lambda: |-
          // Konvertiere den Spannungswert (0 bis 1.07V) in Prozent (0 bis 100)
          // und wandle ihn in eine Ganzzahl um
          return (int)((x / 1.06) * 100.0);

# PWM-Ausgang einrichten
output:
  - platform: ledc  # PWM-Plattform für ESP32
    pin: GPIO14
    id: pwm_output

# Automatisierung zur Steuerung des PWM-Ausgangs
interval:
  - interval: 1s
    then:
      - lambda: |-
          // Normiere den Prozentsatz auf einen Bereich von 0.0 bis 1.0
          float pwm_value = (id(analog_input).state / 100.0);
          id(pwm_output).set_level(pwm_value);

Irgendwie sollte ESPHome nun das Gerät erkennen, hat bei mir aber noch nie funktioniert.
Auch ein Neustart von HA half bei mir nie.

Wenn man auf Geräte - Integrationen - ESPHome geht, kann man Geräte hinzufügen.
Hier muss man die IP-Adresse und den api key eingeben. Zu finden bei ESPHome Builder über LOGS bzw. EDIT des Gerätes.
Auch das geht nicht immer!
Einmal hat er sogar den korrekten api key abgelehnt. Als ich dann ein neues Gerät hinzugefügt und wieder gelöscht habe, erschien das Gerät plötzlich.
Keine Ahnung!

Übrigens ist mir aufgefallen: Beim Arduino-Programm nimmt der ADC die 3,3V Versorgungsspannung als Referenz.
Bei ESPHome nimmt er die interne Referenzspannungquelle von 1070mV. Daher muss man vor das Poti einen Widerstand vom 2,3fachen des Potiwertes schalten.
Bei meinem 10k Poti habe ich 22k genommen.

Variante 3:

Aufbau:

Es wird ein Programmiergerät benötigt siehe auch: Radarsensor

Über das Programm Firmwar-Config erstellen wir folgende Configuration und speichern diese:

Es wird nur ein Eingang und ein Ausgang benötigt.

Mit dem SmartRF Flash Programmer von TI programmieren wir den CC2530

Richtiges Flash File auswählen und starten.

Im Home Assistant Zigbee2MQTT anlernen aktivieren. Evtl einmal die Resettaste am Programmiergerät drücken. Das Gerät erscheint:

Man kann nun den Namen über das Bleistiftsymbol ändern:

Gegenüberstellung der Systeme

 
Mein Fazit:

• Batteriebetrieb: Wenn es um batteriebetriebene Geräte geht, ist Zigbee aufgrund seiner Energieeffizienz und der Fähigkeit, Mesh-Netzwerke zu bilden, eine ausgezeichnete Wahl.
• Nicht-Batteriebetrieb: Für nicht-batteriebetriebene Anwendungen würde ich ESPHome empfehlen. Besonders wegen der Zuverlässigkeit der Over-the-Air-Updates.
• Fairerweise muss ich erwähnen, dass ich mit Tasmota erst einmal ein Gerät umprogrammiert habe. Daher habe ich nur ein paar Dinge aus dem Netz zusammengetragen habe.