Jahresrückblick 2025 – unser neuer Blogbeitrag ist online! ✨

[mickym]

@ticaki sagte in Skriptlogik mit internen Variablen aufbauen, oder getState?:

@ben1983

Kommt darauf an was du mit den Werten machst, ich benutze in schedule() gesteuerten Skripten fast immer getState und in on() fast immer Variablen.

a = getState().val +1 ist auch ca. 10-20 mal langsamer als a = b +1

Na ja das ist aber nicht ganz fair, was Du damit anstellst, wobei ich jetzt nichts zum Code sagen will. Aber Du musst ja bei a=b+1 auch die Zeit dazu rechnen, die das Auslesen des States zur Variable b benötigt. ;)

Rechnen tut sich das nur, wenn Du b oder die Variable mehrfach im Code verwendest und ist wie @Ben1983 sagt eher eine Frage der Aktualität des Wertes.

[ticaki]

@mickym sagte in Skriptlogik mit internen Variablen aufbauen, oder getState?:

Ich glaube nicht das eine Zuweisung in on() auch nur teilweise die Zeit benötigt von einem getState(). Und natürlich hängt es vom Skript ab ob das wirklich schneller ist. Da der meiste komplexere Code aber durch die Verwendung von Variablen lesbarer wird, sind dieses zu bevorzugen.

[BananaJoe]

@ben1983 Ich mache ja beides. Im Skript arbeite ich - eigentlich - nur mit Variablen, schreibe aber das notwendigste in States damit das Skript bei einem JavaScript-Neustart sinnvoll weitermachen kann.

[MiniBlister]

wow, vielen Dank für den Post. Dies ist auch für mich derzeit ein sehr aktulles Thema und ich versuche zu verstehen, wie ich mein Skript optimal gestallte.
Folgende Situation: Ich versuche über ein Skript die Power Flows im Haus abzubilden und reagiere auf Änderung des Stroms in den SmartMetern (das sind bei mir 4 Stück) zu reagieren und dann zu berechnen, welche Energie in welchem Zeig gebraucht wurde. Das sind sehr viele States und vor allem sehr viele Änderungen auf die ich reagieren muss.
Bis dato habe ich das über on() und getState gemacht. Was ich mir nun überlegt hatte ist folgendes:

const objStrom = [
    {id: 'idGen24E', uid: `${upath}.E_PV_Gen24_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom GEN24', value: 0, did: 'idGen24E_D', tid: 'idPVToE'},
    {id: 'idGen24E_D', uid: `${upath}.E_PV_Gen24_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom GEN24', value: 0, did: '', tid: ''},
    {id: 'idSymoE', uid: `${upath}.E_PV_Symo_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom Symo', value: 0, did: 'idSymoE_D', tid: 'idPVToE'},
    {id: 'idSymoE_D', uid: `${upath}.E_PV_Symo_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom Symo', value: 0, did: '', tid: ''},
    {id: 'idHoyE', uid: `${upath}.E_PV_Hoy_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom Hoymiles', value: 0, did: 'idHoyE_D', tid: 'idPVToE'},
    {id: 'idHoyE_D', uid: `${upath}.E_PV_Hoy_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energie produziert vom Hoymiles', value: 0, did: '', tid: ''},
    {id: 'idPVToE', uid: `${upath}.E_PV_Total_Production`, type: 'energy', name: 'Total Energy produziert von der PV Anlage', value: 0, did: 'idPVToE_D', tid: ''},
    {id: 'idPVToE_D', uid: `${upath}.E_PV_Total_Daily_Production`, type: 'energy', name: 'Tägliche Energy produziert von der PV Anlage', value: 0, did: '', tid: ''},
    {id: 'idAkkuCE', uid: `${upath}.E_Akku_Total_Charged`, type: 'energy', name: 'Gesamte Energie in den Speicher geladen', value: 0, did: 'idAkkuCE_D', tid: ''},
    {id: 'idAkkuCE_D', uid: `${upath}.E_Akku_Total_Daily_Charged`, type: 'energy', name: 'Tägliche Energie in den Speicher geladen', value: 0, did: '', tid: ''},
    {id: 'idAkkuDE', uid: `${upath}.E_Akku_Total_DisCharged`, type: 'energy', name: 'Gesamte Energie aus dem Speicher entladen', value: 0, did: 'idAkkuDE_D', tid: ''},
    {id: 'idAkkuDE_D', uid: `${upath}.E_Akku_Total_Daily_DisCharged`, type: 'energy', name: 'Tägliche Energie aus dem Speicher entladen', value: 0, did: '', tid: ''},
    {id: 'idEMeterFeedP', uid: `${upath}.P_Feed`, type: 'power', name: 'E-Meter: Leistung ins Netz', value: 0, did: '', tid: ''},
    {id: 'idEMeterConP', uid: `${upath}.P_Consumption`, type: 'power', name: 'E-Meter: Leistung aus dem Netz', value: 0, did: '', tid: ''},
    {id: 'idGridConE', uid: `${upath}.E_Grid_Total_Consumed`, type: 'energy', name: 'Gesamte Energie Bezug vom Netz', value: 0, did: 'idGridConE_D', tid: ''},
    {id: 'idGridConE_D', uid: `${upath}.E_Grid_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie Bezug vom Netz', value: 0, did: '', tid: ''},
    {id: 'idGridFeeE', uid: `${upath}.E_Grid_Total_Feed`, type: 'energy', name: 'Gesamte Energie Einspeisung ins Netz', value: 0, did: 'idGridFeeE_D', tid: ''},
    {id: 'idGridFeeE_D', uid: `${upath}.E_Grid_Total_Daily_Feed`, type: 'energy', name: 'Tägliche Energie Einspeisung ins Netz', value: 0, did: '', tid: ''},
    {id: 'idPVDirectE', uid: `${upath}.E_PV_Total_Direct_Consumed`, type: 'energy', name: 'Gesamte Energie direkt verbraucht', value: 0, did: 'idPVDirectE_D', tid: ''},
    {id: 'idPVDirectE_D', uid: `${upath}.E_PV_Total_Daily_Direct_Consumed`, type: 'energy', name: 'Tägliche Energie direkt verbraucht', value: 0, did: '', tid: ''},
    {id: 'idHomeE', uid: `${upath}.E_Home_Total_Consumed`, type: 'energy', name: 'Gesamte Energie verbraucht vom Haus', value: 0, did: 'idHomeE_D', tid: ''},
    {id: 'idHomeE_D', uid: `${upath}.E_Home_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie verbraucht vom Haus', value: 0, did: '', tid: ''},
    {id: 'idWBTotal', uid: `${upath}.E_WB_Total_Consumed`, type: 'energy', name: 'Gesamte Energie verbraucht von der Wallbox', value: 0, did: 'idWBTotal_D', tid: ''},
    {id: 'idWBTotal_D', uid: `${upath}.E_WB_Total_Daily_Consumed`, type: 'energy', name: 'Tägliche Energie verbraucht von der Wallbox', value: 0, did: '', tid: ''},
    {id: 'idWBPVE', uid: `${upath}.E_WB_Total_PV`, type: 'energy', name: 'Gesamte Energie direkt verbraucht von der Wallbox', value: 0, did: 'idWBPVE_D', tid: ''},
    {id: 'idWBPVE_D', uid: `${upath}.E_WB_Total_Daily_PV`, type: 'energy', name: 'Tägliche Energie direkt verbraucht von der Wallbox', value: 0, did: '', tid: ''},
    {id: 'idWBGridE', uid: `${upath}.E_WB_Total_Grid`, type: 'energy', name: 'Gesamte Energie vom Netz Bezug für die Wallbox', value: 0, did: 'idWBGridE_D', tid: ''},
    {id: 'idWBGridE_D', uid: `${upath}.E_WB_Total_Daily_Grid`, type: 'energy', name: 'Tägliche Energie vom Netz Bezug für die Wallbox', value: 0, did: '', tid: ''},
    {id: 'idHeatPVE', uid: `${upath}.E_HP_Total_PV`, type: 'energy', name: 'Gesamte Energie direkt verbraucht von der Wärmepumpe', value: 0, did: 'idHeatPVE_D', tid: ''},
    {id: 'idHeatPVE_D', uid: `${upath}.E_HP_Total_Daily_PV`, type: 'energy', name: 'Tägliche Energie direkt verbraucht von der Wärmepumpe', value: 0, did: '', tid: ''},
    {id: 'idHeatGridE', uid: `${upath}.E_HP_Total_Grid`, type: 'energy', name: 'Gesamte Energie vom Netz Bezug für die Wärmepumpe', value: 0, did: 'idHeatGridE_D', tid: ''},
    {id: 'idHeatGridE_D', uid: `${upath}.E_HP_Total_Daily_Grid`, type: 'energy', name: 'Tägliche Energie vom Netz Bezug für die Wärmepumpe', value: 0, did: '', tid: ''},
    {id: 'idHeatTotalE', uid: `${upath}.E_HP_Total`, type: 'energy', name: 'Gesamte Energie für die Wärmepumpe', value: 0, did: 'idHeatTotalE_D', tid: ''},
    {id: 'idHeatTotalE_D', uid: `${upath}.E_HP_Total_Daily`, type: 'energy', name: 'Tägliche Energie für die Wärmepumpe', value: 0, did: '', tid: ''},

    {id: 'idPVToP', uid: `${upath}.P_PV_Total_Production`, type: 'power', name: 'Gesamte Leistung von der PV Anlage', value: 0, did: '', tid: ''},
    {id: 'idAkkuCP', uid: `${upath}.P_Akku_Total_Charged`, type: 'power', name: 'Leistung mit welcher der Speicher geladen wird', value: 0, did: '', tid: ''},
    {id: 'idAkkuDP', uid: `${upath}.P_Akku_Total_DisCharged`, type: 'power', name: 'Leistung mit welcher der Speicher entgeladen wird', value: 0, did: '', tid: ''},
    {id: 'idAkkuDP', uid: `${upath}.P_HP_Total`, type: 'power', name: 'Wärmepumpe Leistung', value: 0, did: '', tid: ''},

    // test
    {id: 'idPVToE2', uid: `${upath}.E_PV_Total_PV_Production`, type: 'energy', name: 'Total Energy produziert von der PV Anlage über E_Total Werte', value: 0, did: 'idPVToE2_D', tid: ''},
    {id: 'idPVToE2_D', uid: `${upath}.E_PV_Total_Daily_PV_Production`, type: 'energy', name: 'Tägliche Energy produziert von der PV Anlage über E_Total Werte', value: 0, did: '', tid: ''}

];

Dieses Array verwende ich zum Initializieren und generieren der UserStates. Dann hatte ich mir überlegt das Array value her zu nehmen um Zwischenergebnisse zu speichen um dann mit einem schedule alle x Minuten oder sekunden die states zu aktuallisieren.
Das aufwendige dabei ist, den jeweiligen Array Index zu finden. Das muss ich jedes mal mit einem find machen was ebenfalls nicht toll ist.

Wäre es möglich den index selbst zu definieren und macht das aus eurer Sicht Sinn?

z.b.

const objStrom = [

    ['idGen24E', {uid: `${upath}.E_PV_Gen24_Total_Production`, type: 'energy', name: 'Gesamte Energie produziert vom GEN24', value: 0, did: 'idGen24E_D', tid: 'idPVToE'}],
 ...
];

Ich hab das mal versucht generisch zu erstellen und wollte eure Meinung dazu haben ob sowas ressourcen schonender läuft.

// Define your data points as an array of objects with custom IDs
const dataPoints = [
  { customId: 'point1', value: 0, dataPointId: 'javascript.0.dataPoint1' },
  { customId: 'point2', value: 0, dataPointId: 'javascript.0.dataPoint2' },
  // Add more data points as needed
];

// Function to update array values
function updateArrayValues(customId, value) {
  const dataPoint = dataPoints.find((dp) => dp.customId === customId);
  if (dataPoint) {
    dataPoint.value = value;
  }
}

// Scheduler to check and store array values to data points every 5 minutes
schedule('*/5 * * * *', () => {
  dataPoints.forEach((dataPoint) => {
    // Check if the value has changed before updating
    const currentValue = getState(dataPoint.dataPointId).val;
    if (dataPoint.value !== currentValue) {
      setState(dataPoint.dataPointId, dataPoint.value, true);
    }
  });
});

// Example usage: Update array values using custom IDs
updateArrayValues('point1', 42);
updateArrayValues('point2', 'Hello, world!');
// Add more updateArrayValues calls as needed

Grüße MiniBlister

[ticaki]

@miniblister

Benutze ein Json, kein Array.

const meinJson = {
  "mein.Strom.eingehende.Daten": {daHin:'', dasMachen:'', denNamen:'', derAktuelleWert:0,
  "mein.StromWoanders.eingehendeDaten": {...}
}

for(const dp in meinJson) {
  on({id: dp}, (obj) => {
    const definition = meinJson[obj.id];
    ...

Davon aber ab, bei etwas das alle 5 Minuten läuft mag es schön sein, wenn das optimiert ist. Wichtig ist es nicht. Ich hab hier Skripte die jede Sekunde getriggert werden und einen Mittelwert über 5 Sekunden bilden.

[MiniBlister]

@ticaki

vielen Dank für die Hilfe. Du gehst mit einer for Schleife durch und generierst mehrere on's.
Die folgende Methode ist etwas kürzer. Was hälst du davon? Kann man das so machen?

let myPVAidsPower = {
    "aidGen24P" :   { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
    "aidSymoP" :    { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
    "aidHoyP" :     { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
}
const dataPointIds = Object.values(myPVAidsPower).map(dataPointInfo => dataPointInfo.dataPointId);
on({id: dataPointIds, change: "ne"}, async (obj) => {await calcPowerAndEnergie (obj);});

[ticaki]

@miniblister

Jo geht natürlich auch.

mit deinem Json geht aber nicht:

on(blabla, (obj) => {
  if (!obj.id) return;
  const meineDaten = meinJson[obj.id];
}

Json würde ich mit dem verständlichen Bezeichner im Datenteil aufbauen.

[MiniBlister]

@ticaki

hatte ich mir auch überlegt.
Aber wenn ich ich das Script an jemanden weiter geben möchte, dann könnten ja die alisa ganz anders aussehen. Es könnte im Verlauf der Entwicklung des Scripts durchaus sein, dass ich einen bestimmten Wert zusätzlich benötige.

Daher hatte ich mich das wir folgt zusammen gebaut:

async function findKeyinDataPoints(dataPoints, findinKey, valueToFind) {
    const foundKey = Object.keys(dataPoints).find(key => dataPoints[key][findinKey] === valueToFind);
    return foundKey || null;
}
on(blabla, (obj) => {
  const foundKey = await findKeyinDataPoints(myPVAidsPower, "dataPointId", obj.id);
  (foundKey && myPVAidsPower.hasOwnProperty(foundKey)) && myPVAidsPower[foundKey].value;
}

Ob ich die hasOwnProperty Abfrage noch benötige, weiß ich noch nicht. Ich bin so denke ich sehr flexible.
Macht das Sinn aus deiner Sicht?

[ticaki]

@miniblister

Es spricht nicht dagegen, das so zu machen. Ich wollte dir nur aufzeigen wie ich es tue :)

Ich mache viel mit vscode und fast alles in typescript. Da bietet die umgedrehte Versionvorteile die aber nichts mit der Ausführung sondern Erstellung zu tun haben. Glaube ich hab auch kein einfaches Beispiel.

Dann mal was nicht extrem kompiziertes... aber trotzdem sehr komplex

Typescript, vscode als editor, auszüge aus dem NSPanel.ts Skript.

Wenn ich z.B.

export type PagetypeType = 'cardChart' | 'cardLChart' | 'cardEntities' |'cardGrid'|'cardGrid2'|'cardThermo'|'cardMedia'|'cardUnlock'|'cardQR'|'cardAlarm'|'cardPower' //| 'cardBurnRec'

den Type anlege

und dann diesen:

export type PageThermo = {
        type: 'cardThermo',
        items: [PageThermoItem],
        
    } & Omit<PageBaseType, 'useColor'>

und dann das json definiere das ich einem array zuweise:
(PageType ist eine oder Verknüpfung die auch PageThermo enthält.)

let Bad_Thermostat: PageType = 
{
    'type': 'cardThermo',
    'heading': 'Bad',
    'subPage': true,
    
    'parent': SensorGrid,
    'items': [{ 
                id: 'alias.0.NSPanel.1.usr.Temperatur.G.Bad',
                minValue: 100, 
                maxValue: 300,
                stepValue: 1
             }]
};

Kann ich davon ausgehen dass das hier richtig ist:

function GeneratePage(page: PageType): void {
    try {
        ...
        switch (page.type) {
            case 'cardEntities':
                SendToPanel(GenerateEntitiesPage(page));
                break;
            case 'cardThermo':
                SendToPanel(GenerateThermoPage(page));
                break;
            case 'cardGrid':
                SendToPan...

vscode baut mir auch das switch mit allen möglichen case dahin, so das ich keine vergesse und Rechtschreibfehler werden auch gefunden.

z.B würde if (page.type == 'nope') einen Fehler erzeugen da es a) immer false wäre und b) vscode meint das ich da was vergleiche was nicht zusammengehört.

typescript würde da auch nen Fehler rauswerfen.

[MiniBlister]

@ticaki

hmmm, jetzt stehe ich auf dem Schlauch.
Dein PageType hat ja 'items':
Wenn ich das richtig lese definierst du die ja nicht so wie du es mir empfiehlst, oder?
Nach deiner Empfehlung müsste es doch so aussehen

let Bad_Thermostat: PageType = 
{
    'type': 'cardThermo',
    'heading': 'Bad',
    'subPage': true,

    'parent': SensorGrid,
    'items': [{ 
                'alias.0.NSPanel.1.usr.Temperatur.G.Bad' : {
                   minValue: 100, 
                   maxValue: 300,
                   stepValue: 1
                  },
                 'alias.0.NSPanel.1.usr.Temperatur.G.WC' : {
                    minValue: 200, 
                    maxValue: 100,
                    stepValue: 1
                 } 
             }]
};

[ticaki]

@miniblister

Jap wir haben uns gegenseitig mit erfolg verwirrt - 10 Punkte :)

Du hast oben ein Array verwendet um Daten abzuspeichern und dieses Daten waren wiederrum ein Array - Das letzte würde ich durch ein Json ersetzten und es dann so suchen wie du vorgeschlagen hast.

Wenn die Datensätze im Array jedoch kaum Gemeinsamkeiten hätten, würde ich alles im JSON haben und dann die ID nicht als KEY verwenden.

Entschuldige die Verwirrung ich hab in letzter Zeit einige meiner Skripte auf Selektor umgebaut und dann speichere ich die Daten dazu in einer DB mit Key ID und dem Datensatz. Von Hand mache ich es aber nicht so.

[MiniBlister]

@ticaki

nur nochmals um sicher zu gehen, dass ich deine zwei Ansätze verstehe. Du schreibst im zweiten Teila ja, dass du die ID NICHT als KEY verwenden würdest.

Ansatz 1: Array mit JSON

let myPVAidsPower = [
    { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
    { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
    { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
]

Ansatz 2: Array mit JSON

let myPVAidsPower = {
    { "dataPointId": "alias.0.KG.HR.FroniusGen24.P_PV", "value": 0},
    { "dataPointId": "alias.0.OD.GA.FroniusSymo.P_PV", "value": 0},
    { "dataPointId": "alias.0.OD.GH.Hoymiles1500.power", "value": 0}
}

[ticaki]

@miniblister

Du must mir mehr zeigen, ich weiß nicht was myPVAidsPower ist und wie das im Zusammenhang steht. Davon hängt es ab, wie mein Rat lautet.

[MiniBlister]

@ticaki

Ok, was ich eigentlich habe sind 3 Wechselrichter, eine Gen24 für das Hausdach, ein Symo für die Garage und ein Hoymiles für das Gartenhaus.
Alle liefern einen Leistungwert und einen gesamten Energie Wert seit Beginn des Betriebs. Beides habe ich als Alias verfügbar.
Weiterhin habe ich zwei E-Meter die mir den Netzbezug bzw. die Einspießung liefert. Mit all diesen Werten möchte ich die folgenden Daten berechnen.

• Gesamt Leistung aller Wechselrichter = alias.0.KG.HR.FroniusGen24.P_PV + alias.0.OD.GA.FroniusSymo.P_PV + alias.0.OD.GH.Hoymiles1500.power
• Gesamte Energie aller Wechselricht = ....
• Tägliche Energie aller Wechselricht = ....
• Wie viel Produzierte PV Energie wurde von der Wärmepumpe verbraucht (das mach ich dann über die Energieflüsse und einer Prozentuale aufteilung)

Was ich mir schon überlegt hatte ist eine Strukture wie folgt aufzubauen:

let datastuctur = 
{
    'type': 'wechselrichter',
    'name': 'GEN24',
    'power': {
                 id: 'alias.0.KG.HR.FroniusGen24.P_PV',
                 unit: 'W'
                 }
    'energie': {
                 id: 'alias.0.KG.HR.FroniusGen24.E_PV',
                 unit: 'kW'
                 }
},
{
    'type': 'wechselrichter',
    'name': 'Symo',
    'power': {
                 id: 'alias.0.KG.HR.FroniusSymo.P_PV',
                 unit: 'W'
                 }
    'energie': {
                 id: 'alias.0.KG.HR.FroniusSymo.E_PV',
                 unit: 'kW'
                 }
},
{
    'type': 'PVTotalPower',
    'name': 'Total',
    'datapoint': {
                 id: 'userdata.0.blbla.PowerGesamt',
                 unit: 'kW'
                 init: true
                 }
    'daily' : {
                 id: 'userdata.0.blbla.DailyPowerGesamt',
                 unit: 'kW'
                 init: true
                 }
},

Dann würde ich durch gehen und mit dieser Struktur alle Datenpunkte automatisch generieren und dann je nach type verschiedene Funktionen ausführe.

[ticaki]

@miniblister
Das sieht gut aus. Aber datapoint würde ich noch einen weniger generischen namen geben.