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

[Ralf77]

@est58 ich habe alle Plugs aus meinem System entfernt. Das war auch mal die Empfehlung hier im Forum. Ich sehe keinen Nutzen noch einen SP im System zu verwenden, wenn mit dem Script geregelt wird.

[Ein ehemaliger Benutzer]

@ralf77 So lange es läuft, stimme ich Dir zu.
Aber die letzten 3 Wochen lief es nicht mehr so rund. Ich war ja auch nicht der Einzige, dem das widerfuhr.
Und da ich die 8 noch im Boot hatte als reine Verbrauchsanzeiger, war ich dann froh, dass ich wieder auf deren Regelung zurückgreifen konnte und dazu nur noch die verbleibende Grundlast manuell einstellen musste.

[Ein ehemaliger Benutzer]

@est58
Werde nach diesem Eintrag mein Profil-Account löschen.
Bis gestern hatte ich noch -6, nun -7, obwohl ich m.E. nach nach dem einen Tag, an dem ich recht grätig war, normale Beiträge geschrieben hatte, die jedes Mal durch die Oberaufsicht mussten.
Auf eine derartige Supervision ohne jegliche Chance wieder ins "Plus" zu kommen, hab ich keine Lust.

Also in diesem Sinne, Adieu....................

[Homoran]

@est58 sagte in ecoflow-connector-Script zur dynamischen Leistungsanpassung:

nach dem einen Tag, an dem ich recht grätig war,

und heute war wohl ein User wieder online, der einen dieser Beiträge zum ersten mal gelesen und entsprechend bewertet hat.

@est58 sagte in ecoflow-connector-Script zur dynamischen Leistungsanpassung:

Auf eine derartige Supervision ohne jegliche Chance wieder ins "Plus" zu kommen, hab ich keine Lust.

die hast du!
du warst ja schonmal auf -7.

oder hast du das vergessen?

[Ralf77]

Kurze Frage, wenn man mehrere Powerstream im System hat:

Im Balanced-Mode wird die benötigte Leistung ja relativ gleichmäßig über die Anzahl der Powerstream verteilt.

Da ich aber unterschiedlich große Speicher habe wäre es super, wenn ich jedem Powerstream einen prozentualen Wert der gesamten Einspeisung zuteilen könnte.

Als Beispiel:
Powerstream 1 hat einen 3,6 kWh Akku —> PS 1 soll 33% der benötigten Eimspeisung abdecken

Powerstream 2 hat einen 7,2 kWh Akku —> PS 2 soll 67% der benötigten Einspeiseleistung abdecken

@Waly_de Wäre sowas möglich?

[gooflo]

@ralf77 ich habe sowas implementiert, da sind einige Anpassungen notwendig. Wenn Du es ausprobieren willst, kontaktiere mich gerne direkt.

[Ralf77]

@gooflo Danke für Deine Info. Würde es sehr gerne versuchen.
Ich habe jetzt gerade mal die neue Version installiert und dachte, dass es eigentlich genau das ist, was ich suchte...

1.2.5.f1 Fork von Florian Vogt (25.06.2024)
Feature hinzugefügt, um die Größe der Delta-Speicher beim Ausbalancieren der Entladeleistung zu berücksichtigen, damit die Batterien gleichmäßig geleert werden.
Parameter battCapacity bei den Einstellungen für PowerStream = Kapazität der angeschlossenen Batterie in kWh, default = 1

Im ChangeLog steht es aber dann genau anders drin: "...der Delta-Speicher beim Ausbalancieren der Ladeleistung zur berücksichtigen, damit die Batterien gleichzeitig voll werden"

Keine Ahnung, was jetzt richtig ist. Geht es um die gleichmäßige Entladeleistung, was ich genre möchte oder um eine gleichmäßige Ladeleistung (was mir eigentlich egal ist...soll rein, was an PC verfügbar ist)

Hat da jemand eine Info?

[Ralf77]

Ok, habe es jetzt getestet. Es geht wirklich um die ENTLADUNG!
Es funktioniert soweit auch ganz gut. Bin damit zufrieden und die Erweiterung des Scriptes ermöglicht jetzt eine deutlich bessere gleichmäßige Entladung bei unterschiedlichen Akku-Kapazitäten in Verbindung mit mehreren Powerstreams.

Vielen Dank an die Entwickler für die ständige Pflege des Scriptes.

[gooflo]

@ralf77 genau, es geht um die Entladung, da hast Du dann noch einen Fehler im Changelog gefunden @Waly_de . Bitte beobachte mal, wie gut das funktioniert. Soweit ich mich erinnere bin ich im Laufe der Zeit auf Fälle gestoßen, bei denen es nicht so gut funktioniert hat. Deswegen und weil ich auch das Laden (abhängig von PV (inklusive PV an der D2M) und Ladestand) regeln wollte, habe ich es nochmal weiterentwickelt.

[Ralf77]

@gooflo vielen Dank! Sehr gute Erweiterung. Ich habe heute auch schon teilweise gesehen, dass es bei hoher Einspeisung nicht immer geklappt hat. Da kam teilweise eine „unlogische“ Einspeisung zustande. Das sind aber eh die Ausnahmesituationen, welche nur kurzzeitig vorhanden sein sollten. Bis jetzt konnte ich das Problem nicht reproduzieren.

Könnt3 mir aber vorstellen, dass das Problem bei gleichzeitiger Ladung durch PV am Powerstream aufkam. Ich werde beobachten.

Aktuell läuft es absolut top.

[Ralf77]

@gooflo habe jetzt immer etwas beobachtet. Es scheint aber die Aufteilung der Einspeiseleistung nicht ganz korrekt entsprechend der Akku-Kapazität berechnet zu werden.

Hier mal ein Bild. Am obern Powerstream sind 7,2kWh Akku-Kapazität. Am unteren Powerstream ist eine Akku-Kapazität von 3.6kWh.

Die Einspeiseleistungsollte somit am oberen PS das doppelte der unteren Einspeisung betragen. Ich sehe aber, dass am Morgen der kleine Akku immer stärker entladen wird.

[photon-harvester]

@ralf77 Das liegt daran, dass der obere Akku noch 81% anzeigt und er untere 80%. Das Script entlädt den Akku mit der größeren Kapazität gemäß Anzeige und nicht der tatsächlichen Akkugröße stärker.

[gooflo]

@ralf77 hm, stimmt, das sieht seltsam aus. Wenn kein PV reinkommt sollte es eigentlich genau nach Kapazität aufgeteilt werden. Aus dem Logfile könnte man vermutlich die Ursache finden (mlog = true setzen).

[sirdir]

Ich krieg plötzlich keinen Akkustand mehr angezeigt. Hat Ecoflow was gebastelt? Gibt's plänte auf die offizielle API umzusteigen?

[Ralf77]

@sirdir auch bei mir Funktion die Regelung über das Script gerade gar nicht…

[sirdir]

@ralf77 Stimmt, bei mir auch nicht. Hab dann den Shelly 3EM der an meinem Gästehaus hängt in der App eingefügt... Hab gedacht, damit wenigstens etwas gedeckt wird. Dann ist mir aber eingefallen, dass das nicht gehen wird, da die PS die einspeisen nicht am Gästehaus hängen, der Shelly also die Einspeisung nicht misst… Aber, weiss nicht ob's am Einbinden des Shellies lag oder einfach Zufall war, als ich danach wieder das Script startete ging es wieder.

[Ralf77]

@sirdir die Regelung läuft bei mir auch. Nur springen die Werte extrem hin- und her.
Mal speisen meine Deltas 150W ins öffentliche Netz ein, da zu viel Ins Hausnetz eingespeist wird… dann zieht mein Haus wieder 200 Watt aus dem öffentlichen Netz, da die Deltas zu wenig ins Hausnetz einspeisen.

Normalerweise sollte ja gar nichts ins öffentliche Netz eingespeist werden und immer leicht aus dem öffentlichen Netz gezogen werden. Das klappt irgendwie gerade nicht gut bei mir.

[sirdir]

@ralf77 Ich denke das Script muss langfristig die öffentliche API benützen. Irgendwann wird der ‘Hack’ bestimmt abgedreht oder geht sonst kaputt. Ich bin mir das grad etwas am anschauen aber hab weder viel Erfahrung mit http Kommunikation unter javascript noch mit Verschlüsselung… Mal sehen ob ich was hin krieg.

[Waly_de]

@sirdir
Sorry, dass ich mich hier so rausnehmen. Aber ich hab wirklich im Moment üble Probleme, worüber ich jetzt hier nicht jammern möchte.
Ich finde es aber auch extrem frustrierend, dass der Hersteller, obwohl wir hier Funktionserweiterungen entwickelt haben, ganz ohne Gegenleistung, die dazu führen, dass mehr Leute, auch im professionellen Bereich auf EF Produkte zurückgreifen, nicht einmal versucht, Kontakt aufzunehmen, geschweige denn Hilfe anbietet, im gegenteil. Die API Dokumentation ist relativ frustrierend, ich habe schon einige Versuche gemacht damit zu arbeiten, leider bisher ziemlich erfolglos.
Natürlich wäre eine Umstellung auf die offizielle API sehr wünschenswert, solange das keine Nachteile bei der Geschwindigkeit oder der Qualität der Regulierung einbringt.
Ich lade euch herzlich ein, an dieser API Anbindung zu arbeiten.
Theoretisch gibt es dort auch einen MQTT server, der uns die relevanten Daten liefern kann.

Hier die Einsiegsseite für die API
https://developer-eu.ecoflow.com/us

Hier mal einer meiner Versuche mit der API zu kommunizieren.
Verbindung wird aufgebaut, aber es kommen keine Telegramme:
Auch konnte ich keine Daten an meine Geräte senden.

const axios = require('axios');
const mqtt = require('mqtt');
const crypto = require('crypto');

// Konfigurationen
const host = 'api-e.ecoflow.com';
const mqttHost = 'mqtt.ecoflow.com';
const mqttPort = 8883;
const mqttProtocol = 'mqtts';
const accessKey = 'DLXXXXXXXXXXXXXXXXXXXXXXXXX6D6'; // Ersetze dies mit deinem tatsächlichen Access Key
const secretKey = 'XxXXXXXXXXXXXXXXXXXXXXXXXXXLA'; // Ersetze dies mit deinem tatsächlichen Secret Key
const deviceSN = 'HW5XXXXXXXXXX55'; // Ersetze dies mit der tatsächlichen Seriennummer deines Geräts

// Hilfsfunktion zur Erstellung eines HMAC-SHA256-Signatur
function createSignature(params, secretKey) {
    const queryString = Object.keys(params)
        .sort()
        .map(key => `${key}=${params[key]}`)
        .join('&');
    return crypto.createHmac('sha256', secretKey).update(queryString).digest('hex');
}

// Zertifikate für MQTT abrufen
async function getMQTTCertification() {
    const nonce = Math.floor(Math.random() * 1000000);
    const timestamp = Date.now();
    const params = {
        accessKey: accessKey,
        nonce: nonce,
        timestamp: timestamp
    };

    const signature = createSignature(params, secretKey);

    try {
        const response = await axios.get(`https://${host}/iot-open/sign/certification`, {
            headers: {
                accessKey: accessKey,
                nonce: nonce,
                timestamp: timestamp,
                sign: signature
            }
        });
        return response.data.data;
    } catch (error) {
        console.error('Fehler beim Abrufen der MQTT-Zertifikate:', error);
        throw error;
    }
}

// MQTT-Verbindung herstellen und Daten empfangen
async function startMQTTClient() {
    try {
        const certification = await getMQTTCertification();

        const client = mqtt.connect(`${mqttProtocol}://${mqttHost}:${mqttPort}`, {
            username: certification.certificateAccount,
            password: certification.certificatePassword,
            protocol: mqttProtocol
        });

        const deviceTopic = `/open/${certification.certificateAccount}/${deviceSN}/quota`;
        const powerstreamTopic = `/open/${certification.certificateAccount}/${deviceSN}/status`;



        client.on('connect', () => {
            console.log('Verbunden mit dem MQTT-Broker');

            // Geräteliste anfordern
            //const deviceListTopic = `/open/${certification.certificateAccount.replace("open-", "")}/${deviceSN}/get`;
			const deviceListTopic = `/open/${certification.certificateAccount}/${deviceSN}/get`;
            client.subscribe(deviceListTopic, (err) => {
                if (!err) {
                    console.log(`Abonniert auf Geräteliste-Topic: ${deviceListTopic}`);
                    client.publish(deviceListTopic, JSON.stringify({}));
                } else {
                    console.error('Fehler beim Abonnieren des Geräteliste-Themas:', err);
                }
            });

            // Powerstream-Daten abonnieren
            client.subscribe(powerstreamTopic, (err) => {
                if (!err) {
                    console.log(`Abonniert auf Powerstream-Daten: ${powerstreamTopic}`);
                } else {
                    console.error('Fehler beim Abonnieren des Powerstream-Themas:', err);
                }
            });
             // Alle Topics abonnieren, um alle Nachrichten zu empfangen
            client.subscribe('#', (err) => {  // '#' ist ein Wildcard-Topic, das alle Topics abonniert
                if (!err) {
                    console.log('Abonniert auf alle Topics (#)');
                } else {
                    console.error('Fehler beim Abonnieren aller Topics:', err);
                }
            });
        });

        
        client.on('message', (topic, message) => {
            // Ausgabe des empfangenen Telegramms
            console.log(`Nachricht empfangen von Topic ${topic}: ${message.toString()}`);
        });

        client.on('error', (err) => {
            console.error('MQTT-Verbindungsfehler:', err);
        });

        client.on('close', () => {
            console.log('MQTT-Verbindung geschlossen');
        });

    } catch (error) {
        console.error('Fehler beim Starten des MQTT-Clients:', error);
    }
}

startMQTTClient();

Ihr müsst euch dafür als Entwickler registrieren (sehr einfach) und euch den
accessKey und secretKey dort generieren.

Bei mir treten diese Probleme übrigens nicht auf.
Was mich noch interessieren würde: wenn keine Daten mehr am Skript ankommen, und ihr das Skript im iobroker einige Male neu startet, kommen dann wieder Daten?

Mehr kann ich im Moment nicht beitragen. Sorry.

[Waly_de]

@waly_de okay, ich konnte heute noch ein bisschen Zeit aufbringen und hab es tatsächlich geschafft mit dem offiziellen API Server zu kommunizieren. Auch das Schreiben von Werten ist mir gelungen.
Hier ist der Ansatz:

const axios = require('axios');
const mqtt = require('mqtt');
const crypto = require('crypto');

//****** HIER DEINE DATEN ******
const accessKey = 'XXXXXXXXXXXXXXXX'; // Ersetze dies mit deinem tatsächlichen Access Key
const secretKey = 'XXXXXXXXXXXXXXXX'; // Ersetze dies mit deinem tatsächlichen Secret Key
const deviceSNs = ['XXXXXXXXXXXXXXXX', 'XXXXXXXXXXXXXXXX']; // Mehrere Geräte-Seriennummern
const MQTT_Clientid = 1
//*********************/


// Konfigurationen
const host = 'api-e.ecoflow.com';
const mqttHost = 'mqtt.ecoflow.com';
const mqttPort = 8883;
const mqttProtocol = 'mqtts';
const mqttCert = '0_userdata.0.ecoflow.mqttCert'
// Globale Variablen für client und certification
let client;
let certification;

if (!existsState(mqttCert)) {
    createState(mqttCert, "");
}

// Hilfsfunktion zur Erstellung eines HMAC-SHA256-Signatur
function createSignature(params, secretKey) {
    const queryString = Object.keys(params)
        .sort()
        .map(key => `${key}=${params[key]}`)
        .join('&');
    return crypto.createHmac('sha256', secretKey).update(queryString).digest('hex');
}

// Funktion zur Überprüfung, ob Zertifikat bereits vorhanden ist
async function loadMQTTCertification() {
    return new Promise((resolve, reject) => {
        // Überprüfen, ob der State existiert

        getState(mqttCert, (err, state) => {
            if (err) {
                console.error('Fehler beim Überprüfen des Zertifikat-States:', err);
                return reject(err);
            }
            if (state && state.val) {
                try {
                    const storedCert = JSON.parse(state.val);
                    // Überprüfen, ob die Felder im Zertifikat vorhanden sind
                    if (storedCert.certificateAccount && storedCert.certificatePassword) {
                        console.log('Zertifikat aus ioBroker geladen');
                        return resolve(storedCert);
                    }
                } catch (error) {
                    console.error('Fehler beim Parsen des Zertifikats:'+ error);
                }
            }
            resolve(null); // Kein Zertifikat gefunden oder ungültig
        });
    });
}

// Zertifikate für MQTT abrufen und speichern
async function getMQTTCertification() {
    const nonce = Math.floor(Math.random() * 1000000);
    const timestamp = Date.now();
    const params = {
        accessKey: accessKey,
        nonce: nonce,
        timestamp: timestamp
    };

    const signature = createSignature(params, secretKey);

    try {
        const response = await axios.get(`https://${host}/iot-open/sign/certification`, {
            headers: {
                accessKey: accessKey,
                nonce: nonce,
                timestamp: timestamp,
                sign: signature
            }
        });

        const certData = response.data.data;
        // Zertifikat in ioBroker speichern
        setState(mqttCert, JSON.stringify(certData), true);
        console.log('Zertifikat erfolgreich abgerufen und in ioBroker gespeichert');
        return certData;
    } catch (error) {
        console.error('Fehler beim Abrufen der MQTT-Zertifikate:'+ error);
        throw error;
    }
}

// Funktion zum Setzen von Parametern (z.B. permanentWatts) ohne client und certification als Parameter
function setPermanentWatts(deviceSN, wattsValue) {
    if (!client || !certification) {
        console.error("MQTT-Client oder Zertifizierung nicht bereit.");
        return;
    }

    const setTopic = `/open/${certification.certificateAccount}/${deviceSN}/set`;

    const message = {
        id: Date.now(), // Einzigartige ID
        version: "1.0",
        cmdCode: "WN511_SET_PERMANENT_WATTS_PACK", // Befehlscode zum Setzen von permanentWatts
        params: {
            permanentWatts: wattsValue // Der Wert, den du setzen möchtest
        }
    };

    client.publish(setTopic, JSON.stringify(message), (err) => {
        if (!err) {
            console.log(`Befehl zum Setzen von permanentWatts auf ${wattsValue} W für Gerät ${deviceSN} wurde gesendet.`);
        } else {
            console.error(`Fehler beim Senden des permanentWatts-Befehls für Gerät ${deviceSN}:` + err);
        }
    });
}

// MQTT-Verbindung herstellen und Daten empfangen
async function startMQTTClient() {
    try {
        // Zertifikat aus ioBroker laden, falls vorhanden
        certification = await loadMQTTCertification();
        if (!certification) {
            // Zertifikat neu generieren, wenn es nicht vorhanden ist
            certification = await getMQTTCertification();
        }

        client = mqtt.connect(`${mqttProtocol}://${mqttHost}:${mqttPort}`, {
            clientId: 'EcoFlowClient_' + MQTT_Clientid,
            username: certification.certificateAccount,
            password: certification.certificatePassword,
            protocol: mqttProtocol
        });

        client.on('connect', () => {
            console.log('Verbunden mit dem MQTT-Broker');

            // Abonnieren von Status und anderen Daten für jedes Gerät
            deviceSNs.forEach((deviceSN) => {
                const quotaTopic = `/open/${certification.certificateAccount}/${deviceSN}/quota`;
                const statusTopic = `/open/${certification.certificateAccount}/${deviceSN}/status`;

                // Abonnieren des Status-Themas
                client.subscribe(statusTopic, (err) => {
                    if (!err) {
                        console.log(`Abonniert auf Status-Topic: ${statusTopic}`);
                    } else {
                        console.error(`Fehler beim Abonnieren des Status-Themas für Gerät ${deviceSN}:` + err);
                    }
                });

                // Abonnieren des Quota-Themas
                client.subscribe(quotaTopic, (err) => {
                    if (!err) {
                        console.log(`Abonniert auf Quota-Topic: ${quotaTopic}`);
                    } else {
                        console.error(`Fehler beim Abonnieren des Quota-Themas für Gerät ${deviceSN}:` + err);
                    }
                });
            });
        });

        client.on('message', (topic, message) => {
            console.log(`Nachricht empfangen von Topic ${topic}: ${message.toString()}`);
        });

        client.on('error', (err) => {
            console.error('MQTT-Verbindungsfehler:' + err);
            client.end();  // Trenne die Verbindung bei einem Fehler
            console.log('Verbindung getrennt aufgrund eines Fehlers ' + err);
        });

        client.on('close', () => {
            console.log('MQTT-Verbindung geschlossen');
        });

    } catch (error) {
        console.error('Fehler beim Starten des MQTT-Clients:' + error);
    }
}
// Schließe die Verbindung, wenn das Skript gestoppt wird
onStop(function (callback) {
    if (client) {
        client.end();
        log("Script gestoppt");
    }
    callback();
}, 2000);
// Start der MQTT-Client-Verbindung
startMQTTClient();



// Beispielaufruf von setPermanentWatts außerhalb von startMQTTClient()
setTimeout(() => {
    setPermanentWatts(deviceSNs[0], 3000); // Setzt permanentWatts für ein bestimmtes Gerät auf 300 W
}, 5000); // Warte 5 Sekunden, damit der Client verbunden ist

Ich würde mich freuen, wenn ihr euch näher damit befasst. bevor ich das ins Skript einbauen kann, wird noch einige Zeit vergehen. Vielleicht schafft ja einer von euch.