UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[Waly_de]

@ralla66 also ich hab mir beim Prototypen keine Gedanken über den Pegel gemacht und die Eingänge einfach verbunden. Das funktioniert seither 24/7 ohne Probleme.

Benutzt habe ich das Teil: MCP2515 CAN Bus Shield
und diesen ESP32: ESP32 D1 Mini NodeMCU

Allerdings möchte ich zur Sicherheit demnächst dieses Teil hier nutzen:
SN65HVD230 CAN-Bus-Modul Kommunikationsmodul

Liegt schon hier. Muss ich nur Zeit für finden.
Aber das MCP2515 rennt wie gesagt, daher hab ich keine Not ;-)

verkabelt habe ich so:

MCP2515       D1 MINI ESP32
----------------------------
INT     >     --
SCK     >     IO18 (CLK)
MOSI    >     I023 (MISO)
MISO    >     IO19 (MOSI)
CS      >     IO5 (CS)
GND     >     GND
VCC     >     VCC (5V)

Hier der Sketch auf dem ESP:

#include <Arduino.h>
#include <mcp2515.h>
#include <WiFi.h>
#include <ArduinoOTA.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
const char* ssid = "xxxxxxxx";     // Ersetze mit deinem WiFi-Namen
const char* password = "xxxxxxxxx";  // Ersetze mit deinem WiFi-Passwort

const char* mqtt_server = "192.168.xxx.xxx";  // Dein MQTT Broker Server
const int mqtt_port = 1884;
const char* mqtt_user = "xxxxxx";
const char* mqtt_password = "xxxxxxxx";
const char* mqtt_topic = "cansniffer";

WiFiClient espClient;
PubSubClient client(espClient);
MCP2515 mcp2515(5); // Der CS-Pin muss entsprechend deiner Schaltung angepasst werden.

// Diese Funktion wird aufgerufen, wenn eine Nachricht auf einem abonnierten Thema ankommt
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.println("Callback aufgerufen: " + String(topic));
  char canSendTopic[64];
  snprintf(canSendTopic, sizeof(canSendTopic), "%s/canRawGesendet", mqtt_topic);

  String topicString = String(topic);
  // Überprüfe, ob das Topic stimmt
  if (topicString.equals(String(mqtt_topic) + "/canSend")) {
      // Konvertiere payload in einen String zur Verarbeitung
      String payloadString;
      for (int i = 0; i < length; i++) {
        payloadString += (char)payload[i];
      }
      if (length == 0 || payloadString == "0" || payloadString == "OK" || payloadString == "INIT" ) {
        Serial.println("Leere Nachricht ");
        return;
      }
      // Parse die JSON-Nachricht
      StaticJsonDocument<200> doc;
      DeserializationError error = deserializeJson(doc, payloadString);
      if (error || !doc.is<JsonObject>()) {
        Serial.println("Fehler beim Parsen von JSON");
        client.publish(canSendTopic, ("JSON PARS ERROR: " + payloadString).c_str());
        return;
      }
      String tempDataString = doc["Data"].as<String>(); // Konvertiert den Wert zu einem String
      tempDataString.replace(" ", ""); // Entfernt alle Leerzeichen
      doc["Data"] = tempDataString.c_str(); // Speichert den geänderten Wert zurück im JSON-Objekt

      // Extrahiere ID und Daten aus dem JSON
      const char* idString = doc["ID"];
      const char* dataString = doc["Data"];

      // Umwandeln der ID in einen Integer
      uint16_t id = strtol(idString, NULL, 16);

      // Umwandeln des Datenstrings in ein Byte-Array
      uint8_t data[8];
      size_t dataLength = strlen(dataString) / 2;
      for (size_t i = 0; i < dataLength; i++) {
        char byteString[] = {dataString[i*2], dataString[i*2 + 1], 0};
        data[i] = strtol(byteString, NULL, 16);
      }

      // Erstelle CAN-Nachricht und sende sie
      can_frame canMsg;
      canMsg.can_id = id;
      canMsg.can_dlc = dataLength;
      memcpy(canMsg.data, data, dataLength);

      // Erstelle einen String, um die Hex-Darstellung zu speichern
      char msgString[35]; // Länge = Anzahl der Bytes * 2 (für Hex) + 1 (für '\0')

      // Konvertiere jeden Byte der Daten in einen Hex-String
      for (int i = 0; i < canMsg.can_dlc; i++) {
        sprintf(&msgString[i * 2], "%02X", canMsg.data[i]);
      }

      // Sende CAN-Nachricht
      if (mcp2515.sendMessage(&canMsg) != MCP2515::ERROR_OK) {
        Serial.println("Fehler beim Senden der CAN-Nachricht");
        client.loop();
        delay(100);
        client.publish(canSendTopic, "SEND ERROR");
      }else{
        // Gib den Hex-String aus
         Serial.print("Raw CAN Data: ");
         Serial.println(msgString);
         client.publish(canSendTopic, msgString); // Sende die Daten zum MQTT-Broker
         client.loop();
         Serial.println("Erfolgreich gesendet");
         client.publish(topicString.c_str(), "OK",false);
      }
  }else{
    Serial.println("Falsches Topic");
    return;
  }

}

void setup() {
  // Initialisiere die serielle Kommunikation
  Serial.begin(115200);
  pinMode(2, OUTPUT); // Setze GPIO 26 als Ausgang für die LED

  // Warte auf die serielle Verbindung, falls nötig
  while (!Serial) {
    ; // warte auf die Verbindung der seriellen Schnittstelle
  }
  // Verbinde mit WiFi-Netzwerk
  WiFi.begin(ssid, password);
  Serial.print("Verbinde mit WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi verbunden!");
  Serial.print("IP-Adresse: ");
  Serial.println(WiFi.localIP());

  connectMQTT();
    
  // Initialisiere den MCP2515 CAN Controller
  mcp2515.reset();
  mcp2515.setBitrate(CAN_20KBPS, MCP_8MHZ);
  // Setze die Masken und Filter
  mcp2515.setFilterMask(MCP2515::MASK0, true, 0x000); // Maske 0 auf 0 setzen (alle Nachrichten akzeptieren)
  mcp2515.setFilterMask(MCP2515::MASK1, true, 0x000); // Maske 1 auf 0 setzen (alle Nachrichten akzeptieren)

  // Setze alle Filter auf 0, um alle Nachrichten zu akzeptieren
  //for (int filter = 0; filter < 6; filter++) {
    //mcp2515.setFilter((MCP2515::RXF)filter, true, 0x000);
  //}
  mcp2515.setNormalMode();

  Serial.println("CAN-Bus Monitor gestartet!");
  // Starte OTA
  ArduinoOTA.setHostname("esp32-ota");
  ArduinoOTA.setPassword("XXXXXXXX");
  
  ArduinoOTA.onStart([]() {
    String type;
    if (ArduinoOTA.getCommand() == U_FLASH) {
      type = "sketch";
    } else { // U_SPIFFS
      type = "filesystem";
    }
    // Hinweis: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
    Serial.println("Start updating " + type);
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nEnd");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.onError([](ota_error_t error) {
    Serial.printf("Error[%u]: ", error);
    if (error == OTA_AUTH_ERROR) {
      Serial.println("Auth Failed");
    } else if (error == OTA_BEGIN_ERROR) {
      Serial.println("Begin Failed");
    } else if (error == OTA_CONNECT_ERROR) {
      Serial.println("Connect Failed");
    } else if (error == OTA_RECEIVE_ERROR) {
      Serial.println("Receive Failed");
    } else if (error == OTA_END_ERROR) {
      Serial.println("End Failed");
    }
  });
  ArduinoOTA.begin();
}

void loop() {
  static unsigned long lastMillis = 0;
  char aliveTopic[64];
  char timestampString[32]; // Genug Platz für die Darstellung des Zeitstempels
  connectMQTT();

  // Sende alle 5 Sekunden eine Nachricht an das Thema "alive"
  if (millis() - lastMillis > 5000) {
    lastMillis = millis();
    snprintf(aliveTopic, sizeof(aliveTopic), "%s/alive", mqtt_topic); // Kombiniere das Hauptthema mit "/alive"
    snprintf(timestampString, sizeof(timestampString), "%lu", millis()); // Konvertiere den Zeitstempel in einen String
    client.publish(aliveTopic, timestampString); // Sende das Zeichen "!" an das Unterthema "alive"
    Serial.println("Alive-Nachricht gesendet!");
    digitalWrite(2, HIGH);   // LED einschalten
    delay(10);               // Kurz warten
    digitalWrite(2, LOW);    // LED ausschalten
    Serial.println(timestampString);
  }

  can_frame canMsg;
  if (mcp2515.readMessage(&canMsg) == MCP2515::ERROR_OK) {
    digitalWrite(2, HIGH);   // LED einschalten
    delay(100);               // Kurz warten
    digitalWrite(2, LOW);    // LED ausschalten
    char msgString[128]; // Ein Array, um die Daten zu speichern
    sprintf(msgString, "{\"ID\": \"0x%03X\", \"Len\": \"%1d\", \"Data\": \"", canMsg.can_id, canMsg.can_dlc);
    for (int i = 0; i < canMsg.can_dlc; i++) {
      sprintf(msgString + strlen(msgString), "%02X ", canMsg.data[i]);
    }
    sprintf(msgString + strlen(msgString)-1, "\"}");
    snprintf(aliveTopic, sizeof(aliveTopic), "%s/pload", mqtt_topic); // Kombiniere das Hauptthema mit "/alive"
    client.publish(aliveTopic, msgString); // Sende die Daten zum MQTT-Broker
    Serial.println(msgString);
  }
  
  // Kurze Verzögerung, um den CAN-Bus nicht zu überlasten
  //Serial.print(".");
  delay(10);
  ArduinoOTA.handle();
  client.loop();
}

void connectMQTT(){
  // Verbinde mit MQTT Broker
  while (!client.connected()) {
    client.setServer(mqtt_server, mqtt_port);
    Serial.print("Verbinde mit MQTT...");
    if (client.connect("CAN_MQTT_Client", mqtt_user, mqtt_password)) {
      Serial.println("verbunden");
      // Setze MQTT-Callback-Funktion
      client.setCallback(callback);
      // Erstelle das Topic für das Senden von CAN-Nachrichten
      char canSendTopic[64];
      snprintf(canSendTopic, sizeof(canSendTopic), "%s/canSend", mqtt_topic);
      client.publish(canSendTopic, "INIT"); // Sende die Daten zum MQTT-Broker
      delay(200);
      Serial.print("Abonniere Topic: ");
      Serial.println(canSendTopic);
      if (client.subscribe(canSendTopic)) {
        Serial.println("Abonnement erfolgreich!");
      } else {
        Serial.println("Abonnement fehlgeschlagen!");
      }
      delay(200);
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" Versuche es erneut in 5 Sekunden");
      delay(5000);
    }
  }
};

Das ist im Grunde alles... Hab sogar OTA eingebaut und kann die Firmware jeder Zeit per Wlan flashen, wenn ich daran arbeite.

Im IoBroker verarbeite ich dann die RAW Daten.

[Ralla66]

@waly_de

Danke,
hab mal den SN65HVD230 bestellt, muß noch meinen Speicher per Can auslesen.
ESP32 liegt noch hier.
Wäre nett wenn man das einrichten vom SN zusammen testen kann.

[Waly_de]

@ralla66 sagte in CAN-BUS Interface ESP32 > MQTT und Stiebel Eltron WP steuern:

Wäre nett wenn man das einrichten vom SN zusammen testen kann.

Klar, sag bescheid, wenn Du das Teil hast. Ich werde die Tage mal nach den passenden Bibliotheken
suchen.

[Waly_de]

@ralla66 Zwischererkenntnis: Meine WP hat einen Can-Speed von 20kbps. Das kann ein normaler ESP32 mit dem SN65HVD230 von Haus aus nicht. Ist ihm zu langsam ;-) Dazu brauchst du mindestens einen ESP32-S3.
Damit konnte ich zumindest schon mal bei einem ersten Test ein paar Daten auslesen.
Ich tendiere aber dazu bei mir lieber den MCP2515 zu behalten. Da der aktiv mit eigenem Taktgeber arbeitet, hat der mit keiner Geschwindigkeit Probleme.
Wenn Dein Bus schneller ist... Kein Problem.

[Ralla66]

@waly_de sagte in CAN-BUS Interface ESP32 > MQTT und Stiebel Eltron WP steuern:

MCP2515

der sollte noch in der Schublade liegen von alten Pic / Atmel Projekten.
Muss erst mal wieder ins Thema kommen, lange her :-)
Im OpenDtu on Battery Projekt ist ja der SN65 mit eingebunden worden.
Das wird kein SPI sein da default RX PIN 27, TX PIN 26.
Dann bestelle ich mal einen ESP32-S3 .
Nachtrag 16:30
SN65 ist da, suche jetzt mal eine Routine --->

Peak Usb Interface zum sniffen / senden läuft jetzt.

[Waly_de]

@ralla66 ah, sieht gut aus..

bei mir läuft es auch .. ich hatte einen LILYGO T-Display ESP32-S3 rumliegen und bin in den Codingwahn verfallen ;-) Läuft prima.

• Displayausgabe der Telegramme
• WifiManager zum Konfigurieren von Wlan und MQTT-Zugang
• Einstellbarer Bus-Speed
• Senden und Empfangen von Telegrammen per MQTT

Leider ist der Sketch dadurch etwas komplexer geworden ;-) Aber heißer Scheiß :-)
Jetzt noch ein Gehäuse dafür drucken und ich hab die perfekte Universal Can-Anbindung.

Ein Link mit nem Video von dem Teil im Einsatz ...

[dossidr]

@waly_de Hey Waly..... Vielen Dank für den bereitgestellten sketch... läuft 100%. Jetzt kann ich endlich auf einen ESP umsatteln... Seither hatte ich dafür einen Raspberry im Einsatz..... Als nächstes folgt die Umrechnung von HEX2DEC im Node RED..... VG dossidr

[dossidr]

@waly_de @waly_de Hallo Waly_de: Ich habe Deinen hier veröffentlichten Code an einer Gas Therme im Einsatz. Vielen Dank dafür. Dort greife ich direkt den CAN via MCP2515 mit 10 kBaud ab. Funktioniert. Daten kommen im Node Red an.... Nun habe ich eine Frage.... Wie kann ich innerhalb Node Red nun auf die jeweilige ID schauen und den darin enthaltenen Data (Value) abgreifen? Dein Code ist ja ein reiner Router welcher nicht explizit auf Basis der ID ein eigenes payload pro ID erstellt. Was ich übrigens super finde. Nur wie gesagt, habe ich das Problem den ankommenden Stream am Node Red zu splitten in die einzelnen ID's ergo dem dazugehörigen Daten. Ich habe es mit change versucht aber bin gescheitert..... Vg Denny

gelöst

[Waly_de]

@dossidr Wie viel weißt Du denn über den Aufbau der CAN-Telegramme?
Mit Node Red kann ich Dir leider garnicht helfen. Damit habe ich noch nie gearbeitet.
Ich werte die Telegramme mit einem IoBroker Script (JavaScript) aus und schreibe die Daten dekodiert in States (Objekte) bzw. lese diese aus und erzeuge daraus Telegramme.
Allerdings hab ich auch eine ziemlich gute Beschreibung des Telegrammaufbaus und der Parameter.

[dtopic]

Hi, habe genau das für meine Stiebel Eltron WPL18 e gesucht. Finde die ISG web auch zu teuer. Nutze auch IoBroker. Bin zwar noch ein Anfänger und hätte zwei drei Fragen.

1. Wo hast du es genau an der WP Manager angeschlossen
2. Ich habe bisher mqtt nicht genutzt, welchen Adapter nutzt du im IoBroker
3. Habe diesen Chip ESP32 Wroom32 herumliegen. Ist das der selbe, den du beschrieben hast?

Sorry, bin komplett Anfänger, würde mich aber gern dran versuchen.

Grüße Daniel

[Waly_de]

@dtopic sagte in CAN-BUS Interface ESP32 > MQTT und Stiebel Eltron WP steuern:

Hi, habe genau das für meine Stiebel Eltron WPL18 e gesucht. Finde die ISG web auch zu teuer. Nutze auch IoBroker. Bin zwar noch ein Anfänger und hätte zwei drei Fragen.

Grundsätzlich sollte diese Pumpe die gleiche Sprache sprechen wie meine. Das ist schon mal gut :-)

1. Wo hast du es genau an der WP Manager angeschlossen

Das ist gleich unter der Abdeckung. An den Klemmen steht glaube ich (H+) (H-)
Dort ist bei mir die Fernbedienungseinheit angeschlossen, die im Wohnbereich hängt.

2. Ich habe bisher mqtt nicht genutzt, welchen Adapter nutzt du im IoBroker

den MQTT-Adapter... (MQTT Broker/Client)

3. Habe diesen Chip ESP32 Wroom32 herumliegen. Ist das der selbe, den du beschrieben hast?

Ja, im Eingangsbeitrag mit dem MCP2515 CAN Bus Shield
hat funtioniert.
Allerdings bin ich ja später zu dem LILYGO T-Display ESP32-S3 umgestiegen.
Vor allem wegen des Displays und weil er mit dem kleinen SN65HVD230 Adapter funktioniert.

Sorry, bin komplett Anfänger, würde mich aber gern dran versuchen.

Viel Erfolg! Wenn Du willst, ich habe hier noch den Prototyp mit LILYGO T-Display ESP32-S3 liegen. Den könnte ich Dir sogar noch in ein Gehäuse packen, wie meinen produktiven:

Bei Interesse PM bitte

Gruß,
Markus

[dtopic]

@waly_de

Habe dir geschrieben, komm nur an ein der beiden heran. Welche von den beiden meinst du?

[Waly_de]

@dtopic rechts der sieht so aus wie meiner.

[dtopic]

@waly_de

Habe dir via pm geschrieben.
Nutzt du dann im IoBroker dann zur Verarbeitung der Daten blocky? Oder wie machst du dann die Überschussladung PV (Pufferbefeuerung) wenn Strom zur Verfügung steht.

[Waly_de]

@dtopic noch steht meine pv nicht komplett. Aber ja, der Plan ist die Speicher Temperatur bei Überschuss ein paar grad zu erhöhen. Das werde ich per JavaScript regeln.

[Waly_de]

das hab ich mit den Daten die ich Auslese gebaut… und man kann auch fast jeden Wert schreiben.


Video mit allen Datenpunkten die bei meiner Stieble WP auslesbar (schreibbar) sind

[dossidr]

@waly_de Hy waly_de

Ich habe Deinen Code angepasst. Die Delay habe ich alle entfernt. Die benötigt man nicht, da der ESP selbst die Interrupt handelt.... Die Umsetzung in Node Red habe ich jetzt auch am laufen. Ich hole jede ID einzeln aus dem Datenstream heraus, welcher via MQTT vom CAN Bus kommt.... Ich werde das Script mal testen in einem "großen J1939" Netzwerk. Wenn das zuverlässig funktioniert ist das ein super CAN 2 MQTT Router.... Einziges Problem ist.... Sobald der MCP2515 einen Nachrichtenwechsel innerhalb einer ID von FFC7 auf 0017 z.B hat, dann hängt sich der MCP oder der Code auf.... Ich habe es noch nicht wirklich herausgefunden.... Dazu werde ich einen gesonderten Aufbau machen....

[Waly_de]

@dossidr das sieht ja super aus... Glückwunsch! Dann drücke ich die Daumen dass du den Fehler findest.

Was mir als mögliches Problem einfällt:
Ist die Telegrammlänge variabel und passt nicht in den Buffer? (Buffer vergrößern)
Es ist vielleicht ein Delay(10) im Loop nötig für die Stabilität (Meine dazu was gelesen zu haben)

Mein ESPs3 mit dem SN65HVD230 CAN-Bus-Modul Kommunikationsmodul läuft jetzt seit vielen Wochen ohne ein Problem... Ist definitiv eine perfekte CAN-MQTT Brücke :sunglasses:

[dtopic]

@waly_de

[Leitwolf]

@waly_de Hallo Waly,

das hört sich sehr gut an. Hatte das ganze vor 2 Jahren auch ins Auge gefasst und dann aus zeitlichen Gründen wieder verworfen. Die HW liegt hier rum und wartet seither. Hab jetzt mal versucht deinen sketch ans laufen zu bringen und bin beim compilieren hängen geblieben

***Arduino: 1.8.19 (Linux), Board: "DOIT ESP32 DEVKIT V1, 80MHz, 921600, Info, Disabled"

test_can:22:18: error: invalid conversion from 'int' to 'spi_device_t**' [-fpermissive]
MCP2515 mcp2515(5); // Der CS-Pin muss entsprechend deiner Schaltung angepasst werden.***

Komme da nicht mehr weiter. Vielleicht haste ne Minute :male-detective:

Gruss Harald