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

[Toller Tenya]

@hugo1217 Ich habe eine Tecalor TTF 5 Eco Sole WP- Baugleich mit Stiebel Elton
Die Steuerung ist ein WPMiW

Ich habe nun CAN Speed von 5-100kbps ausprobiert aber es kommt nichts an außer dem Alive

Starte ich das Script im IOBroker mit Scan für 0x180 werden auch vermeintlich die CAN Telegramme versendet aber ohne Antwort.

Noch Ideen was ich überprüfen könnte?

Mein Sketch:

Spoiler

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

const char* mqtt_server = "192.168.1.154";  // Dein MQTT Broker Server
const int mqtt_port = 1884;
const char* mqtt_user = "iobrokermqtt";
const char* mqtt_password = "XXXX";
const char* mqtt_topic = "TTF";

void(* resetFunc) (void) = 0;

// Timer declare
hw_timer_t * timer = NULL;
volatile SemaphoreHandle_t timerSemaphore;
portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
volatile uint32_t isrCounter = 0;
volatile uint32_t lastIsrAt = 0;

void ARDUINO_ISR_ATTR onTimer(){
 // Increment the counter and set the time of ISR
 portENTER_CRITICAL_ISR(&timerMux);
 isrCounter = isrCounter + 1;
 lastIsrAt = millis();
 portEXIT_CRITICAL_ISR(&timerMux);
 // Give a semaphore that we can check in the loop
 xSemaphoreGiveFromISR(timerSemaphore, NULL);
 // It is safe to use digitalRead/Write here if you want to toggle an output
}

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[128];  //War vorher 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[10];
   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");

     // Initialisiere den MCP2515 CAN Controller neu
     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();
   } 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() {
 // Timer Setup
 timerSemaphore = xSemaphoreCreateBinary();  // Create semaphore to inform us when the timer has fired
 timer = timerBegin(1000000); // Set timer frequency to 1Mhz = 1µs
 timerAttachInterrupt(timer, &onTimer); // Attach onTimer function to our timer.
 timerAlarm(timer, 1000000, true, 0);  // Set alarm to call onTimer function every second (value in microseconds). Repeat the alarm (third parameter) with unlimited count = 0 (fourth parameter).

 // 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");   //Hier das Passowrd für OTA setzen

 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();


 if (xSemaphoreTake(timerSemaphore, 0) == pdTRUE){
   uint32_t isrCount = 0, isrTime = 0;
   // Read the interrupt count and time
   portENTER_CRITICAL(&timerMux);
   isrCount = isrCounter;
   isrTime = lastIsrAt;
   portEXIT_CRITICAL(&timerMux);
   // Print it
   Serial.print("onTimer no. ");
   Serial.print(isrCount);
   Serial.print(" at ");
   Serial.print(isrTime);
   Serial.println(" ms");
   if (isrTime > 1000 * 60 * 60 * 12) {
     resetFunc(); 
   }
 }

 // 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);
   }
 }
};

Mein Javascript

Spoiler

const DEBUG = true
let filePath = '/opt/iobroker/iobroker-data/ElsterTable.inc';
let elsterJsObject = convertToJsObject(filePath);
const CanScnifferId = "mqtt.0.TTF"
//const CanScnifferId = "mqtt.0.TTF.303"
let scanAllElsterIdsTimerVar, scanAllStatestimerVar, scanShortStatestimerVar
let GlobscanAllElsterIds = {
   lastPosition: 0,
   lastkey: "0",
 //  geraet: 0x0180
}
// Das muss einmal pro Zieladresse ausgeführt werden um zu scannen welche Datenpunke abfragbar sind
// Jeweils einmal pro Adresse 
scanAllElsterIds(0x0180,0)
let GlobscanAllStates = {
   lastPosition: 0,
   lastkey: "0",
   intervall: 10 * 60 * 1000,
}
scanAllStates()
// Die Hier angegebenen Datenpunkte werden in einem unter Intervall angegebenen Intervall in Millisekunden regelmäßig aktiv abgefragt
let GlobshortScan = {
   lastPosition: 0,
   lastkey: "0",
   intervall: 30000,
   iDs: [
    //   { geraet: 0x0180, elsterName: "WPVORLAUFIST" },
    //   { geraet: 0x0180, elsterName: "RUECKLAUFISTTEMP" },
   //    { geraet: 0x0180, elsterName: "MASCHINENDRUCK" },
   //    { geraet: 0x0301, elsterName: "VORLAUFSOLLTEMP" },
   //    { geraet: 0x0180, elsterName: "PUFFERSOLL" },
   ]
}

scanShortStates()

on({ id: CanScnifferId + '.pload', change: "ne" }, function (obj) {
   if (DEBUG || false) log(obj.state.val)
   const telegramObj = parseCanTelegram(JSON.parse(obj.state.val))
   if (Number(telegramObj.elsterIndex) == Number(GlobscanAllElsterIds.lastkey)) {
       //log("gleich")
       //log(Number(telegramObj.elsterIndex) + " - " + Number(GlobscanAllElsterIds.lastkey))
       clearTimeout(scanAllElsterIdsTimerVar)
       scanAllElsterIds(GlobscanAllElsterIds.geraet, GlobscanAllElsterIds.lastPosition + 1)
   }
   if (Number(telegramObj.elsterIndex) == Number(GlobscanAllStates.lastkey)) {
       //log("gleich")
       //log(Number(telegramObj.elsterIndex) + " - " + Number(GlobscanAllElsterIds.lastkey))
       clearTimeout(scanAllStatestimerVar)
       scanAllStates(GlobscanAllStates.lastPosition + 1)
   }
   if (Number(telegramObj.elsterIndex) == Number(GlobshortScan.lastkey)) {
       //log("gleich")
       //log(Number(telegramObj.elsterIndex) + " - " + Number(GlobscanAllElsterIds.lastkey))
       clearTimeout(scanShortStatestimerVar)
       scanShortStates(GlobshortScan.lastPosition + 1)
   }
   //evaluateMessages(JSON.parse(obj.state.val))
   //log(JSON.stringify(telegramObj));
   //writeLog(JSON.stringify(telegramObj)), 'CanLog.csv').catch(error => console.error(JSON.stringify(error)));
});
function convertToJsObject(filePath) {
   // In einer echten JavaScript-Umgebung müsste hier die fs-Bibliothek verwendet werden,
   // um die Datei zu lesen. Der folgende Code ist eine vereinfachte Darstellung.
   const fs = require('fs');
   let elsterTable = {};
   // Lies die Datei synchron, dies ist in einem realen Szenario zu vermeiden
   let fileContent = fs.readFileSync(filePath, 'utf-8');
   let lines = fileContent.split('\n');
   lines.forEach((line) => {
       // Ignorieren von Kommentaren und leeren Zeilen
       if (line.startsWith('//') || line.trim() === '' || line.startsWith('{') || line.startsWith('}')) {
           return;
       }
       // Entfernen von Anführungszeichen und geschweiften Klammern, dann Aufspaltung der Zeile in Teile
       let parts = line.replace('{', '').replace('}', '').replace(/"/g, '').trim().split(',');
       parts = parts.map(part => part.trim()).filter(part => part);

       // Überprüfen, ob die Zeile drei Teile enthält: Name, Index und Typ
       if (parts.length === 3) {
           let [name, index, type_] = parts;
           try {
               // Versuche, den Index von Hex zu Dezimal zu konvertieren
               let indexKey = parseInt(index, 16);
               // Hinzufügen zum JavaScript-Objekt
               elsterTable[indexKey] = { "name": name, "type": type_ };
           } catch (error) {
               // Wenn der Index nicht in einen Integer umgewandelt werden kann, ignorieren wir diese Zeile
               console.error('Konvertierungsfehler:', error);
           }
       }
   });
   return elsterTable;
}
// Das ElsterTable-Objekt, das zuvor erstellt wurde
let elsterTable = elsterJsObject

// Funktion zum Konvertieren der Hex-Daten in lesbare Werte
function convertData(hexString) {
   let bytes = [];
   for (let i = 0; i < hexString.length; i += 2) {
       bytes.push(parseInt(hexString.substr(i, 2), 16));
   }
   let rawValue = (bytes[1] << 8) | bytes[2]; // Korrigierte Byte-Position
   return rawValue / 10; // Annahme: Der Wert ist durch 10 zu teilen
}
// Funktion zum Auswerten der Nachrichten
function evaluateMessages(message) {
   //messages.forEach((message) => {
   let id = message.ID;
   let data = message.Data.replace(/\s/g, "");

   // Der Index ist das dritte Byte in der Nachricht, hier als Hex-String
   let indexHex = data.substr(4, 2);
   log(indexHex)
   let index = parseInt(indexHex, 16);
   let valueHEX = data.substr(6, 4);
   let value = parseInt(valueHEX, 16)
   log("Index:" + index)
   log("Data:" + data)
   log("Value Hex:" + valueHEX)
   log("Value Dezi:" + value)
   // Hole den Eintrag aus dem ElsterTable
   let entry = elsterTable[index];
   if (entry) {
       log(`Gerät: ${id}, Parameter: ${entry.name}, Wert: ${value / 10}`);
   } else {
       log(`Unbekannter Index: ${indexHex}. Message: ${message}`);
   }
}
function parseMessage(str) {
   // Zerlege den String in Teile und extrahiere relevante Teile
   const parts = str.trim().split(/\s+/);
   const idPart = parts[1].substring(2); // Entferne '0x'
   const dataPart = parts.slice(4).join('').replace("Data:", ""); // Entferne 'Data:'

   // Erstelle das messages-Objekt
   return {
       id: idPart, // Entfernt '0x'
       data: dataPart // Entfernt 'Data:'
   };
}
// Beispiel für die Verwendung der Funktion
//const messageStr = {"ID": "0x301", "Len": "7", "Data": "C0 01 11 00 DF 00 00"};
//evaluateMessages(messageStr)
// ****************************************************************
// :
function parseCanTelegram(telegram) {
   // Entferne alle Leerzeichen und prüfe das Format
   let dataString = telegram.Data.replace(/\s/g, '');
   if (dataString.length % 2 !== 0) {
       throw new Error('Ungültige Datenlänge');
   }
   // Zerlege die Daten in ihre Teile
   let parts = dataString.match(/.{1,2}/g).map(byte => parseInt(byte, 16));
   // Berechne die CAN-ID
   let calculatedId = (8 * (parts[0] & 0xF0)) + (parts[1] & 0x0F);
   let calculatedIdHex = calculatedId.toString(16).toUpperCase();
   calculatedIdHex = "0x" + ("000" + calculatedIdHex).slice(-4);
   // Überprüfe den Typ des Telegramms
   let typID = (parts[0] & 0x0F)
   let type
   switch (typID) {
       case 0:
           type = "write"
           break;
       case 1:
           type = "read"
           break;
       case 2:
           type = "response"
           break;
       case 3:
           type = "ack"
           break;
       case 4:
           type = "write ack"
           break;
       case 5:
           type = "write respond"
           break;
       case 6:
           type = "system"
           break;
       case 7:
           type = "system respond"
           break;
       default:
           type = "Unbekannt"
   }
   // Bestimme den Elster-Index und erhöhe ihn um 1
   let elsterIndex = parts[2] === 0xFA ? (((parts[3] << 8) + parts[4])) : (parts[2]);
   // Konvertiere den Elster-Index in vierstellige Hexadezimalzahl und entferne das zuvor hinzugefügte +1
   let elsterIndexHex = elsterIndex.toString(16).toUpperCase();
   let elsterFunktion = elsterTable[elsterIndex];
   elsterIndexHex = "0x" + ("000" + elsterIndexHex).slice(-4);
   let data = parts.slice(3).map(byte => byte.toString(16).padStart(2, '0')).join(' ').toUpperCase();
   // Nutzdaten, beginnend nach dem Elster-Index
   let dataIndexStart = parts[2] === 0xFA ? 5 : 3;
   let dataBytes = parts.slice(dataIndexStart, dataIndexStart + 2);
   let dataHex = dataBytes.map(byte => byte.toString(16).padStart(2, '0')).join('').toUpperCase();
   let dataDecimal = (dataBytes[0] << 8) + dataBytes[1];
   let dataDecimalCon = AllValuesConverter(dataDecimal, elsterFunktion.type, true)
   let StateToSet = "0_userdata.0.WP13." + telegram.ID.replace("0x", "") + "." + elsterFunktion.name
   log(StateToSet)
   log("state:" + StateToSet + " dataDecimalCon: " + dataDecimalCon)
   if (dataDecimal != 32768) {
       createState(StateToSet, dataDecimalCon, false)
       setState(StateToSet, dataDecimalCon, true)
   }
   return {
       raw: dataString,
       calculatedId: calculatedIdHex,
       type,
       elsterIndex: elsterIndexHex,
       elsterFunktion,
       dataHex,
       dataDecimal,
       FromID: telegram.ID,
       Len: telegram.Len
   };
}
function AllValuesConverter(value, TypeString, read = true) {
   //log("value to String: " +  value.toString().toLowerCase() )
   switch (TypeString) {
       case "et_datum":
           if (read) {
               return convertBytesToDatum(Number(value))
           } else {
               return convertDatumToBytes(value)
           }
           break;
       case "et_dec_val":
           if (read) {
               return Number((interpretAsSigned16(value) / 10).toFixed(1))
           } else {
               return Number((interpretAsSigned16(value) * 10).toFixed(0))
           }
           break;
       case "et_time_domain":
           if (read) {
               if (value == 0xFFFF) return "NA"
               if (value == 0x8080) return "-----"
               return convertBytesToTime(Number(value))
           } else {
               if (value.toString() == "NA") return 0xFFFF
               if (value.toString() == "-----") return 0x8080
               log("Zeitrückgabe: " + value + " zu: " + Number(convertTimeRangeToBytes(value.toString())))
               return Number(convertTimeRangeToBytes(value.toString()))
           }
           break;
       case "et_betriebsart":
           if (read) {
               if (value == 0x0000) return "Notbetrieb"
               if (value == 0x0100) return "Bereitschaft"
               if (value == 0x0200) return "Automatik"
               if (value == 0x0300) return "Tagbetrieb"
               if (value == 0x0400) return "Absenkbetrieb"
               if (value == 0x0500) return "Warmwasser"
               if (value == 0x0B00) return "FEKAuto"
               return value
           } else {
               //log("value to String: " +  value.toString().toLowerCase() )
               if (value.toString().toLowerCase() == "notbetrieb") return 0x0000
               if (value.toString().toLowerCase() == "bereitschaft") return 0x0100
               if (value.toString().toLowerCase() == "automatik") return 0x0200
               if (value.toString().toLowerCase() == "tagbetrieb") return 0x0300
               if (value.toString().toLowerCase() == "absenkbetrieb") return 0x0400
               if (value.toString().toLowerCase() == "warmwasser") return 0x0500
               if (value.toString().toLowerCase() == "fekauto") return 0x0B00
               return Number(value)
           }
           break;
       case "et_little_endian":
       case "et_little_bool":
           return littleEndianHexConvert(value)
           break;
       default:
           return value
   }
}
function interpretAsSigned16(uint16) {
   // Prüfen, ob die Zahl größer als der maximal positive Wert für einen vorzeichenbehafteten 16-Bit-Integer ist
   if (uint16 > 32767) {
       return uint16 - 65536;
   } else {
       return uint16;
   }
}
// Von Little Endian Hex zu Dezimal
function littleEndianHexConvert(value) {
   // Verschieben Sie die Bytes und kombinieren Sie sie
   let lowByte = value & 0xFF; // Extrahieren Sie das niedrigwertige Byte
   let highByte = (value & 0xFF00) >> 8; // Extrahieren und verschieben Sie das hochwertige Byte
   return (highByte | (lowByte << 8));
}
function convertBytesToTime(value) {
   let startByte = value >> 8;
   let endByte = value & 0xFF;
   return convertToTime(startByte) + ' - ' + convertToTime(endByte);
}
function convertBytesToDatum(value) {
   let startByte = value >> 8;
   let endByte = value & 0xFF;
   return (startByte) + '.' + (endByte);
}
function convertToTime(value) {
   let hours = Math.floor(value / 4);
   let minutes = (value % 4) * 15;
   return hours.toString().padStart(2, '0') + ':' + minutes.toString().padStart(2, '0');
}
function convertTimeToBytes(startTime, endTime) {
   let startUnits = convertToUnits(startTime);
   let endUnits = convertToUnits(endTime);
   return (startUnits << 8) + endUnits;
}
function convertToUnits(time) {
   let [hours, minutes] = time.split(':').map(Number);
   return hours * 4 + Math.floor(minutes / 15);
}
function convertTimeRangeToBytes(timeRange) {
   // Entfernen Sie alle Leerzeichen aus dem String
   let cleanedTimeRange = timeRange.replace(/\s/g, '');

   // Teilen Sie den bereinigten String in Start- und Endzeit
   let [startTime, endTime] = cleanedTimeRange.split('-');
   if (!endTime) return timeRange
   return convertTimeToBytes(startTime, endTime);
}
function convertDatumToBytes(datum) {
   let cleaneddatum = datum.replace(/\s/g, '');
   let [tag, monat] = cleaneddatum.split('.').map(Number);
   //log(tag + " " + monat + " " + typeof(monat))
   if (!monat) return datum
   return ((tag << 8) + (monat));
}
//console.log(convertBytesToTime(0x8080)); // Gibt "00:00 - 01:15" aus
//console.log(convertTimeToBytes("15:30", "01:15").toString(16)); // Gibt "105" aus
//console.log(convertTimeRangeToBytes("32:00 - 32:00").toString(16)); // Gibt "105" aus
//log(convertBytesToDatum(3851)) // Gibt "15.11" aus
//log(convertDatumToBytes("15.11"))
// Beispiel-Telegramm
let telegram = {
   "ID": "0x680",
   "Len": "6",
   "Data": "61010112340000"
}
//console.log(parseCanTelegram(telegram));
function buildCanIdWithTypeId(canId, typeId, elsterIndexHex, HexDaten) {
   let hexbuffer = Buffer.from("0000000000", "hex")
   hexbuffer[0] = Math.floor(parseInt(canId, 16) / 8) + parseInt(typeId, 16)
   hexbuffer[1] = (parseInt(canId, 16) % 8)
   let elsterBytes = Buffer.from(elsterIndexHex, "hex");
   hexbuffer[2] = elsterBytes[1];
   //hexbuffer[3] = elsterBytes[1];
   let DatenBytes = Buffer.from(HexDaten, "hex");
   hexbuffer[3] = DatenBytes[0];
   hexbuffer[4] = DatenBytes[1];
   return hexbuffer.toString('hex')
}
/***************************************
**********  LOG FILE ERSTELLEN  ************ 
****************************************/
const logpath = '/opt/iobroker/log/';
const fs = require('fs').promises;
async function writeLog(logEntry, filename = "ECOTest2.csv") {
   // Get the current date and time
   const now = new Date();
   const dateTime = now.toLocaleString();
{1}
   // Format the log entry
   const formattedEntry = `${dateTime}\t${logEntry}\n`;
{1}
   try {
       // Check if the file already exists
       await fs.stat(logpath + filename);
   } catch (error) {
       if (error.code === 'ENOENT') {
           // If the file does not exist, we need to add the header
           const header = 'DateTime\tLog Entry\n';
           await fs.writeFile(logpath + filename, header);
           log("neue datei erstellt");
       } else {
           // Some other error occurred
           throw error;
       }
   }
   // Append the log entry to the file
   try {
       await fs.appendFile(logpath + filename, formattedEntry);
       //console.log('Log entry saved!');
   } catch (error) {
       throw error;
   }
}
// Anwendung:
//writeLog('This is a test entry.', 'Filename.csv').catch(error => console.error(error));
//***************************************
//***************************************
function initElsterFrame(senderId, receiverId, elsterIdx, pdaten, typ = 1) {
   senderId = Number(senderId)
   const address = (Number(receiverId) & 0x780) >> 3;
   let data = new Array(7); // Erstellt ein Array mit 5 Elementen für die Datenbytes
   // Die Id und die Länge des Frames werden nicht direkt gesetzt, da in JavaScript
   // üblicherweise Objekte anstelle von direkt manipulierten Byte-Arrays verwendet werden.
   data[0] = (Number(address) & 0xF0) + Number(typ);
   data[1] = Number(receiverId) & 0x07;
   data[2] = 0xFA;
   data[3] = (Number(elsterIdx) >> 8) & 0xFF; // Höherwertiges Byte von ElsterIdx
   data[4] = Number(elsterIdx) & 0xFF; // Niederwertiges Byte von ElsterIdx
   data[5] = (Number(pdaten) >> 8) & 0xFF; // Niederwertiges Byte von ElsterIdx
   data[6] = Number(pdaten) & 0xFF; // Niederwertiges Byte von ElsterIdx
   return {
       ID: "0x" + senderId.toString(16),
       Len: "7",
       Data: data.map(byte => byte.toString(16).padStart(2, '0')).join('').toUpperCase()
   };
}
// Änderungen senden:
on({ id: new RegExp("0_userdata.0.WP13\..*"), change: "any", ack: false }, function (obj) {
   log("was geändert:" + obj.id + " ack:" + obj.state.ack)
   readDataFromObject(obj, 'write')
});
function readDataFromObject(obj, art = 'readonly') {
   let ID, elstername, mtelegram
   if (obj.id) {
       ID = "0x" + ((obj.id).split('.').slice(-2, -1)[0])
       elstername = ((obj.id).split('.').slice(-1)[0])
   } else {
       ID = "0x" + ((obj._id).split('.').slice(-2, -1)[0])
       elstername = ((obj._id).split('.').slice(-1)[0])
   }
   let elsterObjekt = Object.entries(elsterJsObject).find(([key, value]) => value.name === elstername);
{1}
   let elsterID = elsterObjekt[0]; // Der Schlüssel
   let gesuchtesObjekt = elsterObjekt[1]; // Das gesuchte Objekt
   // Verwenden Sie hier elsterID und gesuchtesObjekt wie benötigt
   // log (JSON.stringify(gesuchtesObjekt) + " : " + obj.state.val + " Konvertiert: " + AllValuesConverter(obj.state.val, gesuchtesObjekt.type ,true))
{1}
   //let elsterID = Object.keys(elsterJsObject).find(key => elsterJsObject[key].name === elstername);
   /*
       log("Gerät: " + ID)
       log("elstername: " + elstername)
       log("elsterIDHex: " + Number(elsterID).toString(16))
       log("value: " + obj.state.val)
       log("art: " + art)
   */
   if (art == 'write') {
       let dataDecimalCon = AllValuesConverter((obj.state.val), gesuchtesObjekt.type, false)
       mtelegram = JSON.stringify(initElsterFrame("0x680", ID, elsterID, dataDecimalCon, 2))
       log(" Wert Setzten: " + mtelegram)
       setState(CanScnifferId + '.canSend', mtelegram)
       setTimeout(function () {
           mtelegram = JSON.stringify(initElsterFrame("0x680", ID, elsterID, 0, 1))
           //log(" Wert abrufen: " + mtelegram)
           setState(CanScnifferId + '.canSend', mtelegram)
       }, 2 * 1000);
   } else if (art == 'readonly') {
       mtelegram = JSON.stringify(initElsterFrame("0x680", ID, elsterID, 0, 1))
       //log(" Wert abrufen: " + mtelegram)
       setState(CanScnifferId + '.canSend', mtelegram)
   }
}
//Zum Scannen aller verfügbaren Parameter eines gerätes
function scanAllElsterIds(geraet = 0x180, lastPosition = 0) {
   GlobscanAllElsterIds.geraet = geraet
   let canId, mtelegram
   let maxScan
   let keys = Object.keys(elsterJsObject);
   maxScan = keys.length
   if (lastPosition >= maxScan) {
       let Zeitkompl = Math.floor((Date.now() - GlobscanAllStates.Starttime) / 1000)
       if (DEBUG) log("Scan all ElsterIds beendet. Scandauer: " + Zeitkompl + " Sekunden für " + lastPosition + " Scans")
       GlobscanAllElsterIds.lastPosition = 0
       GlobscanAllElsterIds.lastkey = "0"
       GlobscanAllElsterIds.Starttime = 0
       return
   } else if (lastPosition == 0) {
       if (DEBUG) log("Scan all States gestartet")
       GlobscanAllElsterIds.Starttime = Date.now()
   }
   let key = keys[lastPosition]
   if (DEBUG) if (lastPosition % 20 == 0) log("(" + ((100 / maxScan) * lastPosition).toFixed(0) + "%) Scanposition: " + lastPosition + " von " + maxScan + " elsterID:" + key + " elstername:" + elsterJsObject[key].name)
   //log(key)
   mtelegram = JSON.stringify(initElsterFrame("0x680", geraet, key, 0, 1))
   //log(lastPosition + " von " + maxScan + " Wert abrufen: " + mtelegram)
   setState(CanScnifferId + '.canSend', mtelegram)
   GlobscanAllElsterIds.lastPosition = lastPosition
   GlobscanAllElsterIds.lastkey = key
   scanAllElsterIdsTimerVar = setTimeout(function () {
       scanAllElsterIds(geraet, lastPosition + 1); // Setzt den nächsten Aufruf auf 1000 ms später
   }, 5000)
}
//Zum Scannen aller Angelegten States
function scanAllStates(lastPosition = 0) {
   let mSelector = $("0_userdata.0.WP13.*");
   let maxScan = mSelector.length
   if (lastPosition >= maxScan - 1) {
       let Zeitkompl = Math.floor((Date.now() - GlobscanAllStates.Starttime) / 1000)
       if (DEBUG) log("Scan all States beendet. Scandauer: " + Zeitkompl + " Sekunden für " + lastPosition + " Scans")
       GlobscanAllStates.lastPosition = 0
       GlobscanAllStates.lastkey = "0"
       GlobscanAllStates.Starttime = 0
       setTimeout(function () {
           scanAllStates(0); // Setzt den nächsten Aufruf auf 1000 ms später
       }, GlobscanAllStates.intervall)
       return
   } else if (lastPosition == 0) {
       if (DEBUG) log("Scan all States gestartet")
       GlobscanAllStates.Starttime = Date.now()
   }
   //log("mSelector " + mSelector[lastPosition])
   let elstername = ((mSelector[lastPosition]).split('.').slice(-1)[0])
   let geraeteId = (mSelector[lastPosition]).split('.').slice(-2)[0]
   //log("GeraeteID:" + geraeteId )
   let elsterID = Object.keys(elsterJsObject).find(key => elsterJsObject[key].name === elstername);
   GlobscanAllStates.lastPosition = lastPosition
   GlobscanAllStates.lastkey = elsterID
   if (DEBUG) if (lastPosition % 20 == 0) log("ScanAllStates (" + ((100 / maxScan) * lastPosition).toFixed(0) + "%) Positiom:" + lastPosition + " von " + maxScan + " geraeteId:" + geraeteId + " elsterID:" + elsterID + " elstername:" + elstername)
   let myObj = getObject(mSelector[lastPosition])
   myObj.state = getState(mSelector[lastPosition])
   myObj.id = mSelector[lastPosition]
   //log(JSON.stringify(myObj))
   readDataFromObject(myObj)
   scanAllStatestimerVar = setTimeout(function () {
       if (elstername != "DATUM") log("Timeout position:" + lastPosition + " geraeteId:" + geraeteId + " elsterID:" + elsterID + " elstername:" + elstername)
       scanAllStates(lastPosition + 1); // Setzt den nächsten Aufruf auf 1000 ms später
   }, 5000)
}
function scanShortStates(lastPosition = 0) {
   let maxScan = GlobshortScan.iDs.length
   //log("Anzahl IDs Short:" + maxScan)
   if (lastPosition >= maxScan) {
       let Zeitkompl = Math.floor((Date.now() - GlobshortScan.Starttime) / 1000)
       if (DEBUG) log("Scan Short States beendet. Scandauer: " + Zeitkompl + " Sekunden für " + lastPosition + " Scans")
       GlobshortScan.lastPosition = 0
       GlobshortScan.lastkey = "0"
       GlobshortScan.Starttime = 0
       setTimeout(function () {
           scanShortStates(0); // Setzt den nächsten Aufruf auf 1000 ms später
       }, GlobshortScan.intervall)
       return
   } else if (lastPosition == 0) {
       if (DEBUG) log("Scan Short States gestartet")
       GlobshortScan.Starttime = Date.now()
   }
   //log("mSelector " + mSelector[lastPosition])
   let elstername = GlobshortScan.iDs[lastPosition].elsterName
   let elsterID = Object.keys(elsterJsObject).find(key => elsterJsObject[key].name === elstername);
   GlobshortScan.lastPosition = lastPosition
   GlobshortScan.lastkey = elsterID
   let esterState = "0_userdata.0.WP13." + GlobshortScan.iDs[lastPosition].geraet.toString(16).replace("tzt0x", "") + "." + elstername
   //log(esterState)
   if (DEBUG) if (lastPosition % 20 == 0) log("ScanShortStates (" + ((100 / maxScan) * lastPosition).toFixed(0) + "%) Positiom:" + lastPosition + " von " + maxScan + " elsterID:" + elsterID + " elstername:" + elstername)
   let myObj = getObject(esterState)
   myObj.state = getState(esterState)
   myObj.id = esterState
   //log(JSON.stringify(myObj))
   readDataFromObject(myObj)
   scanShortStatestimerVar = setTimeout(function () {
       log("Timeout Shortscan position:" + lastPosition + " elsterID:" + elsterID + " elstername:" + elstername)
       scanShortStates(lastPosition + 1); // Setzt den nächsten Aufruf auf 1000 ms später
   }, 5000)
}
/*
//Objekte löschen:
$('0_userdata.0.WP13.180.EL_*').each(function (id, i) {
           log(i + " - " + id + " existsObject: " + existsObject(id))
           //deleteObject(id,true);
});
*/
// Beispielaufruf
let canId, mtelegram
let Senderid = "0x680"
canId = "0x180"; // 384 in dezimal
//canId = "0x601"; // 384 in dezimal
let typeId = 1; // 1 in dezimal
let elsterIndexHex = "0x17a0"
let pHexDaten = 0x0000
mtelegram = JSON.stringify(initElsterFrame(Senderid, canId, elsterIndexHex, pHexDaten, typeId))
//console.log("Generiertes Telegramm:" + mtelegram);
//setState( CanScnifferId +'.canSend', mtelegram)
/*
setState( CanScnifferId +'.canSend', mtelegram, function () {
   setTimeout(function () {
       elsterIndexHex = "0x1700"
       pHexDaten = 0x8080
       mtelegram = JSON.stringify(initElsterFrame(Senderid, canId, elsterIndexHex, pHexDaten, typeId))
       console.log("Generiertes Telegramm:" + mtelegram);
       setState( CanScnifferId +'.canSend', mtelegram, function () {
           setTimeout(function () {
               elsterIndexHex = "0x1722"
               pHexDaten = 0x8080
               mtelegram = JSON.stringify(initElsterFrame(Senderid, canId, elsterIndexHex, pHexDaten, typeId))
               console.log("Generiertes Telegramm:" + mtelegram);
               setState( CanScnifferId +'.canSend', mtelegram)
           }, 200);
       })
   }, 200);
})
*/
//console.log(mtelegram); 
setTimeout(function () {
   typeId = 1;
   //elsterIndexHex = "0x1720"
   //HexDaten = "0000"
   mtelegram = JSON.stringify(initElsterFrame(Senderid, canId, elsterIndexHex, pHexDaten, typeId))
   //console.log("Generiertes Telegramm:" + mtelegram);
   //setState( CanScnifferId +'.canSend', mtelegram)
}, 2 * 1000);
//

[Tom c]

Guten morgen zusammen.

ich gehöre auch zu den Kollegen die nicht bereit sind so viel Geld für ein ISG zu bezahlen. Von daher verfolge ich seit längerem die Beiträge in Netz.
Ich möchte gerne meine LWZ 404Sol über den CAN-Bus auslesen. Später dann auch steuern...
Als Hardware habe ich einen alten RPI3 genommen der vorhanden war und eine Waveshare 2-CH CAN HAT+ verbaut.
Die Hardware als solche funktioniert und ich kann über candump bzw. cansend Infos von Kanal0 zu 1 senden.
Danach habe ich jetzt ioBroker installiert und den Adapter CAN-Bus. dieser erkennt ebenfalls die CAN0 Schnittstelle und speichert brav die Infos von cansend in den objekten.
So weit so gut dachte ich und habe dann die LWZ mit dem Kanal0 verbunden. Leider kann ich hier keine Werte sehen oder empfangen. Habe mittlerweile neben H und L auch eine GND Leitung gelegt und mit verschiedenen Baudraten gespielt. Leider keine Infos auf dem Bus.

Kann mir jemand einen Tipp geben was der nächste Schritt wäre um Infos auf dem Bus zu empfangen? Bisher habe ich noch kein Script oder ElsterTable oder ähnliches eingebunden.

Vielen lieben Dank für die Unterstützung,
Tom

[D12A13]

@randyandy
Hi RandyAndy, dein Script läuft super bei unserer TTL 23 cool. Welche Fehler bekommst du denn?

[D12A13]

@tom-c
Hast du den 120k ohm Wiederstand an deinem CAN HAT als Terminator aktiv? Hast du Wärmepumpe mal Strom los gemacht? Mehr fällt mir leider nicht ein.