ESP 32 mit Siemens Logo über LAN und W-Lan verbinden

schütze

Details: Kategorie: schützschaltungen; Erstellt: 17. Oktober 2026; Zugriffe: 10

Netzwerk-Grundlage: Die LOGO! benötigt eine feste IP-Adresse.
Verbindung einrichten: In LOGO!Soft unter Ethernet-Verbindungen eine neue Serververbindung (Modbus) hinzufügen.
Port & Berechtigungen: Der Port muss auf den Modbus-Standard 502 eingestellt sein. Der Haken bei "Alle Verbindungsanfragen Serverseite annehmen" zwingend setzen, damit der ESP32 zugreifen darf.
Datenübertragungstabelle: Diese bleibt im Dialogfeld komplett leer. Die LOGO! ordnet als Server ihren internen VM-Speicher (Variablenspeicher) automatisch den Modbus-Standardadressen zu (z. B. V0.0 = Coil 0).
Signale empfangen (ESP32 schaltet LOGO!): Im Schaltplan einen Netzwerkeingang (NI) platzieren, in den Eigenschaften auf Lokaler VM stellen und die Adresse V0.0 (entspricht Modbus Coil 0) zuweisen. Dieser Baustein wird direkt mit dem gewünschten Hardware-Ausgang (z. B. Q1) verbunden.
Signale senden (LOGO! meldet an ESP32): Im Schaltplan einen Netzwerkausgang (NQ) platzieren, auf Lokaler VM stellen und die Adresse V0.1 (entspricht Modbus Coil 1) zuweisen. Ein Hardware-Eingang (z. B. I1) wird direkt an diesen NQ angeschlossen.
Betrieb: Das Programm auf die Steuerung laden und die LOGO! in den RUN-Modus versetzen, damit sie auf Anfragen lauscht.

ESP32 (Client-Rolle / Aktiver Controller)

Netzwerk-Grundlage: Der ESP32 baut eine WLAN-Verbindung auf und bekommt eine feste IP (hier: 192.168.0.222). In deiner LogicKiste übernimmt das der bestehende Web-Dashboard-Block im Hintergrund.
Bibliothek & Setup: Die Bibliothek <ModbusIP_ESP8266.h> (von A. Emelianov) wird eingebunden. Im setup() wird das Modbus-Objekt per mb.client() als aktiver Master deklariert, der das Netzwerk steuert.
Verbindungsaufbau (Loop): Im loop() wird durchgehend mb.task() aufgerufen, um Modbus-Prozesse abzuarbeiten. Eine if-Abfrage prüft, ob die Verbindung zur LOGO! (logoIP) steht, und baut sie bei Bedarf über Port 502 automatisch neu auf (mb.connect(logoIP, 502)).
Schreiben (Taster → LOGO!): Der ESP32 wertet den Zustand des Tasters über eine Flankenerkennung aus (um das Netzwerk nicht mit Daten zu fluten). Ändert sich der Zustand, sendet der Befehl mb.writeCoil(logoIP, 0, state) den Wert an Coil 0. Das schaltet verzögerungsfrei den zugeordneten Netzwerkeingang (V0.0) in der LOGO!.
Lesen (LOGO! → LED): Der ESP32 ruft zyklisch (z. B. alle 100 ms) den Befehl mb.readCoil(logoIP, 1, &logoM2State, 1, cbReadLogo) auf, um Coil 1 (V0.1) der LOGO! abzufragen. Die Bibliothek speichert das Ergebnis (true/false) automatisch in der Variablen logoM2State.
Hardware schalten: Der ESP32 nutzt den Wert aus logoM2State, um über digitalWrite(LED_PIN, logoM2State) die physische LED passend zum Eingangssignal der LOGO! ein- oder auszuschalten.

Um dir nun die passenden Blöcke und C++ Generatoren für LogicKiste zu schreiben: Soll ich den Code exakt auf die in deinem ESP-Sketch verwendete Bibliothek (ModbusIP_ESP8266.h) zuschneiden und möchtest du für die LOGO-Adressen (V0.0 etc.) lieber ein direktes Texteingabefeld oder zwei getrennte Zahlenfelder für Byte und Bit?

Der ESP Code

// Generiert von LogicKiste ESP32
#include <Arduino.h>

#include <WiFi.h>
#include "KK_WebDashboard.h"
#include <ModbusIP_ESP8266.h>

const char* WEB_LAYOUT = "[]";

// --- Modbus & Hardware Konfiguration ---
IPAddress logoIP(192, 168, 0, 90); // IP der LOGO!
ModbusIP mb;

const int BUTTON_PIN = 25; // Pin für den Taster
const int LED_PIN = 27;    // Pin für die LED

// Variablen zum Merken der Zustände
bool lastButtonState = false;     // Speichert den letzten Tasterzustand, um nur bei Änderung zu senden
bool logoM2State = false;         // Hier speichert Modbus den empfangenen Zustand der LOGO! (V0.1)
unsigned long lastModbusRead = 0; // Timer für die zyklische Modbus-Abfrage

// Callback-Funktion: Wird aufgerufen, sobald die Modbus-Abfrage abgeschlossen ist
bool cbReadLogo(Modbus::ResultCode event, uint16_t transactionId, void* data) {
  // Die Bibliothek schreibt das Ergebnis (true/false) automatisch in "logoM2State",
  // da wir die Variable unten per Referenz (&) übergeben. Hier müssen wir nichts tun.
  return true;
}

void setup() {
  Serial.begin(115200);

  // --- Hardware Setup ---
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW); // LED am Start sicherheitshalber ausschalten

  // --- Netzwerk (WLAN) von LogicKiste ---
  WiFi.mode(WIFI_STA);
  WiFi.persistent(false);
  WiFi.setSleep(false);           // kein Modem-Sleep: niedrige Latenz
  WiFi.setAutoReconnect(true);    // nach Router-Neustart selbst wieder verbinden
  IPAddress kk_local_ip(192, 168, 0, 222);
  IPAddress kk_gw_ip(192, 168, 0, 1);
  IPAddress kk_subnet(255, 255, 255, 0);
  WiFi.config(kk_local_ip, kk_gw_ip, kk_subnet, kk_gw_ip);   
  WiFi.begin("ssid", "passwort");
  { 
    uint32_t kk_t0 = millis();
    while (WiFi.status() != WL_CONNECTED && millis() - kk_t0 < 15000) { delay(100); }
  }
  configTzTime("CET-1CEST,M3.5.0,M10.5.0/3", "pool.ntp.org");

  // --- Web-Dashboard starten (WebSocket) ---
  KK_Dashboard.begin(80, WEB_LAYOUT, []() -> String {
    return "{}";
  }, [](String kk_name, String kk_val) {
    (void)kk_name; (void)kk_val;
  });

  // --- Modbus Client starten ---
  mb.client();
  Serial.println("\nSetup abgeschlossen. ESP32 läuft.");
}

void loop() {
  // LogicKiste und Modbus Hintergrundaufgaben pflegen
  KK_Dashboard.poll();
  mb.task(); 
  delay(1);  

  unsigned long currentMillis = millis();

  // Verbindung zur LOGO! aufbauen und bei Abbruch neu verbinden
  if (WiFi.status() == WL_CONNECTED && !mb.isConnected(logoIP)) {
    mb.connect(logoIP, 502);
  }

  // ================================================================
  // 1. TASTER AUSWERTEN UND AN LOGO SENDEN (Coil 0 / V0.0)
  // ================================================================
  // Da der Taster an INPUT_PULLUP hängt, bedeutet ein LOW-Signal "gedrückt".
  // Wir wandeln das in eine einfache true/false Logik um:
  bool isPressed = (digitalRead(BUTTON_PIN) == LOW); 
  
  // Nur über das Netzwerk senden, wenn sich der Zustand geändert hat (Flankenauswertung)
  // Das verhindert, dass der ESP das WLAN mit 1000 Befehlen pro Sekunde blockiert.
  if (isPressed != lastButtonState) {
    if (isPressed) {
      Serial.println("Taster gedrückt -> Sende HIGH an LOGO! (V0.0)");
      mb.writeCoil(logoIP, 0, true);  // HIGH an LOGO senden
    } else {
      Serial.println("Taster losgelassen -> Sende LOW an LOGO! (V0.0)");
      mb.writeCoil(logoIP, 0, false); // LOW an LOGO senden
    }
    lastButtonState = isPressed; // Neuen Zustand für den nächsten Durchlauf merken
  }

  // ================================================================
  // 2. SIGNAL VON LOGO LESEN UND SCHALTEN (Coil 1 / V0.1)
  // ================================================================
  // Wir fragen den Zustand der LOGO alle 100 Millisekunden ab (Polling)
  if (mb.isConnected(logoIP) && (currentMillis - lastModbusRead >= 100)) {
    lastModbusRead = currentMillis;
    // Lese 1 Coil ab Adresse 1 (V0.1), speichere in &logoM2State, rufe cbReadLogo auf
    mb.readCoil(logoIP, 1, &logoM2State, 1, cbReadLogo);
  }

  // LED stur nach dem Zustand schalten, den die LOGO gemeldet hat
  if (logoM2State == true) {
    digitalWrite(LED_PIN, HIGH); // LED an, wenn LOGO HIGH sendet
  } else {
    digitalWrite(LED_PIN, LOW);  // LED aus, wenn LOGO LOW sendet
  }
}

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen.

logickiste

Blockly für Arduino: Grafische Programmierung als echtes C++ Werkzeug
für deine eigenen, kreativen Projekte und Ideen auf hohem Niveau.

https://www.logickiste.de/

blockly for arduino