Skriptlogik mit internen Variablen aufbauen, oder getState?

[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.