Neuer ioBroker-Blog online: Monatsrückblick März/April 2026

[ticaki]

@homoran

Soll ich das mit der Solarberechung als Feature fürs latest aufnehmen oder taugt es nix? Meine Solaranlage wird durchs L Dach im Sommer ab 19:00 komplett abgeschattet, das einzurechnen ist mir zuviel :) Daher kann ich das schlecht bewerten.

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@homoran

Soll ich das mit der Solarberechung als Feature fürs latest aufnehmen oder taugt es nix?

Also....
es taugt!
es passt zumindest sehr gut zu meiner Faktorisierung.

lila ist dein Estimate.

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Meine Solaranlage wird durchs L Dach im Sommer ab 19:00 komplett abgeschattet, das einzurechnen ist mir zuviel Daher kann ich das schlecht bewerten.

du hast editiert !?
Das mit möglichem Optimierungspotential hatte ich wieder gelöscht.

hab da zwar ne Idee, aber keine Zeit und kein Wissen über deinen Algorithmus

[ticaki]

@homoran
Ja, wollte das mit dem L Dach klarstellen - damit muß ich dann ne Strahlenverfolgung machen was dann irgendwie so endet - das kann ich ja für mich in nem Skript machen zum rumspielen, aber in einem adapter - wow bis das getestet ist vergeht ja ein Jahr :D und dann will jemand bäume eingeben können ^^

Falls jemand will - Berechnung ob Sonnenstrahlen durch ein Fenster eine definierte Fläche treffen

function init() {
    // === AB HIER: deine States, Fenster/Ziel definieren & aufrufen ===
    const altState = '0_userdata.0.sonstiges.sun.altitude';
    const aziState = '0_userdata.0.sonstiges.sun.azimuth';

    const windows: {name:string, window: {center: Vec3, width: number, height: number, facadeAzDeg: number, normalElevationDeg: number}, target: TargetSpec}[] = [
    {
        name: 'Schlafzimmer',
        window: {
            center:[0, 0, 1], 
            width:1.0, 
            height: 0.60, /*Azimut*/ 
            facadeAzDeg:270, /*Neigung*/ 
            normalElevationDeg:0
        },  // Western, senkrecht
        target: {
            kind: 'wall',
            distance: .1,
            width: 2,
            height:2,
            lateral: 0,
            zCenter: 1
        },                  // Ost-ausgerichtete Wandfläche
    }
    ];

    const az = Number(getState(aziState).val);
    const alt = Number(getState(altState).val);
    const win = makeWindowRect(windows[0].window)
    const hits = sunlightHitsSurface(az, alt, win, ( buildTargetFromSpec(win, windows[0].target)))
    console.log(`Hits surface? ${hits ? "YES" : "NO"} (az=${az}°, alt=${alt}°)`);
}
// Konfigende
// === Vektormathe & Utils (ganz nach oben) ===
type Vec3 = [number, number, number];
type Vec2 = [number, number];

const add = (a: Vec3, b: Vec3): Vec3 => [a[0]+b[0], a[1]+b[1], a[2]+b[2]];
const sub = (a: Vec3, b: Vec3): Vec3 => [a[0]-b[0], a[1]-b[1], a[2]-b[2]];
const dot = (a: Vec3, b: Vec3): number => a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
const mul = (a: Vec3, s: number): Vec3 => [a[0]*s, a[1]*s, a[2]*s];
const norm = (a: Vec3): Vec3 => {
  const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0]/l, a[1]/l, a[2]/l];
};
const cross = (a: Vec3, b: Vec3): Vec3 => [
  a[1]*b[2]-a[2]*b[1],
  a[2]*b[0]-a[0]*b[2],
  a[0]*b[1]-a[1]*b[0],
];
const deg2rad = (d: number) => (d * Math.PI) / 180;

// === Geometrietyp ===
interface Rect3D {
  center: Vec3;
  normal: Vec3;
  right: Vec3;
  up: Vec3;
  halfWidth: number;
  halfHeight: number;
}

// === Orientierungen/Factorys ===
function makeOrientationFromAzEl(azDeg: number, elDeg: number) {
  const az = deg2rad(azDeg), el = deg2rad(elDeg);
  const normal: Vec3 = norm([ Math.sin(az)*Math.cos(el), Math.cos(az)*Math.cos(el), Math.sin(el) ]);
  const worldUp: Vec3 = [0,0,1];
  let right = cross(worldUp, normal);
  if (Math.hypot(right[0], right[1], right[2]) < 1e-8) right = cross([0,1,0], normal);
  right = norm(right);
  const up = norm(cross(normal, right));
  return { normal, right, up };
}

function makeWindowRect(val:{center: Vec3, width: number, height: number, facadeAzDeg: number, normalElevationDeg: number}): Rect3D {
  const { normal, right, up } = makeOrientationFromAzEl(val.facadeAzDeg, val.normalElevationDeg);
  return { center:val.center, normal, right, up, halfWidth: val.width/2, halfHeight: val.height/2 };
}

function makeWallRect(center: Vec3, width: number, height: number, facingAzDeg: number): Rect3D {
  const { normal, right, up } = makeOrientationFromAzEl(facingAzDeg, 0);
  return { center, normal, right, up, halfWidth: width/2, halfHeight: height/2 };
}

// === Kernfunktionen für die Flächenprüfung ===
function rectCorners(r: Rect3D): Vec3[] {
  const u = norm(r.right), v = norm(r.up);
  const dx = mul(u, r.halfWidth), dy = mul(v, r.halfHeight);
  return [
    add(add(r.center, dx), dy),
    add(sub(r.center, dx), dy),
    sub(sub(r.center, dx), dy),
    sub(add(r.center, dx), dy),
  ];
}

function sunDirIncoming(azDeg: number, altDeg: number): Vec3 {
  const az = deg2rad(azDeg), alt = deg2rad(altDeg);
  const toSun: Vec3 = [ Math.sin(az)*Math.cos(alt), Math.cos(az)*Math.cos(alt), Math.sin(alt) ];
  return norm(mul(toSun, -1));
}

function projectAlongDirToPlane(P: Vec3, d: Vec3, planeNormal: Vec3, planePoint: Vec3): Vec3 | null {
  const n = norm(planeNormal);
  const denom = dot(n, d);
  if (Math.abs(denom) < 1e-9) return null;
  const t = dot(n, sub(planePoint, P)) / denom;
  if (t <= 0) return null;
  return add(P, mul(d, t));
}

function toPlane2D(P: Vec3, origin: Vec3, u: Vec3, v: Vec3): Vec2 {
  const rel = sub(P, origin);
  return [dot(rel, u), dot(rel, v)];
}

function polygonsOverlap2D(A: Vec2[], B: Vec2[]): boolean {
  const axes: Vec2[] = [];
  const edges = (poly: Vec2[]) => poly.map((p, i) => {
    const q = poly[(i+1)%poly.length]; return [q[0]-p[0], q[1]-p[1]] as Vec2;
  });
  const addAxes = (poly: Vec2[]) => {
    for (const e of edges(poly)) {
      const n: Vec2 = [-e[1], e[0]];
      const len = Math.hypot(n[0], n[1]) || 1;
      axes.push([n[0]/len, n[1]/len]);
    }
  };
  addAxes(A); addAxes(B);

  const proj = (poly: Vec2[], axis: Vec2) => {
    let min = Infinity, max = -Infinity;
    for (const p of poly) {
      const s = p[0]*axis[0] + p[1]*axis[1];
      if (s < min) min = s; if (s > max) max = s;
    }
    return {min, max};
  };

  for (const axis of axes) {
    const a = proj(A, axis), b = proj(B, axis);
    if (a.max < b.min - 1e-9 || b.max < a.min - 1e-9) return false;
  }
  return true;
}

function sunlightHitsSurface(sunAzDeg: number, sunAltDeg: number, windowRect: Rect3D, targetRect: Rect3D): boolean {
  const d = sunDirIncoming(sunAzDeg, sunAltDeg);
  if (dot(d, norm(windowRect.normal)) >= 0) return false; // muss nach innen zeigen

  const winCorners = rectCorners(windowRect);
  const proj: Vec3[] = [];
  for (const w of winCorners) {
    const hit = projectAlongDirToPlane(w, d, targetRect.normal, targetRect.center);
    if (hit) proj.push(hit);
  }
  if (proj.length < 3) return false;

  const tgtCorners = rectCorners(targetRect);
  const U = norm(targetRect.right), V = norm(targetRect.up);
  const proj2D = proj.map(p => toPlane2D(p, targetRect.center, U, V));
  const tgt2D  = tgtCorners.map(p => toPlane2D(p, targetRect.center, U, V));
  return polygonsOverlap2D(proj2D, tgt2D);
}
/**
 * Erzeugt eine Innen-WAND parallel zum Fenster:
 * - Abstand INS ZIMMER entlang (−window.normal)
 * - Wand-Normale zeigt ZUM FENSTER (== +window.normal)
 * - right/up werden vom Fenster übernommen
 */
function makeInteriorWallFromWindow(
  windowRect: Rect3D,
  distance: number,   // Abstand ins Zimmer (m)
  width: number,      // Breite (entlang window.right)
  height: number,     // Höhe (entlang window.up)
  lateral = 0,        // seitlicher Versatz entlang window.right (m)
  zCenter = 0         // vertikaler Versatz des Wandmittelpunkts entlang window.up (m)
): Rect3D {
  const n = norm(windowRect.normal); // außen
  const r = norm(windowRect.right);
  const u = norm(windowRect.up);

  const center: Vec3 = add(
    add(
      add(windowRect.center, mul(n, -distance)), // ins Zimmer
      mul(r, lateral)                            // seitlich
    ),
    mul(u, zCenter)                               // vertikal
  );

  return {
    center,
    normal: n,   // Blick zurück zum Fenster
    right:  r,
    up:     u,
    halfWidth:  width / 2,
    halfHeight: height / 2,
  };
}

/**
 * Erzeugt eine HORIZONTALE Fläche (Boden/Tisch) relativ zum Fenster:
 * - Ebene ist horizontal (Normal = Welt +Z)
 * - center liegt distance ins Zimmer (−normal), plus lateral entlang window.right, plus absolute Höhe zWorld
 * - right wird aus Fenster-right auf die Horizontalebene projiziert (mit Fallback)
 */
function makeHorizontalFromWindow(
  windowRect: Rect3D,
  distance: number,   // Abstand ins Zimmer (m)
  width: number,      // Ausdehnung quer (m)
  depth: number,      // Ausdehnung in „Tiefe“ (m)
  lateral = 0,        // seitlicher Versatz entlang window.right (m)
  zWorld = 0,         // absolute Welt-Höhe der Fläche (m)
  yawDeg = 0          // Drehung in der Ebene (um +Z), 0°: right ~ projiziertes Fenster-right
): Rect3D {
  const n = norm(windowRect.normal);
  const r = norm(windowRect.right);

  // center: vom Fensterzentrum distance nach innen, lateral nach rechts, dann z auf zWorld setzen
  let center = add(add(windowRect.center, mul(n, -distance)), mul(r, lateral));
  center = [center[0], center[1], zWorld];

  // Horizontalbasis: projiziere Fenster-right auf Ebene z=konstant
  let rightH: Vec3 = [r[0], r[1], 0];
  const len = Math.hypot(rightH[0], rightH[1]);
  if (len < 1e-8) {
    // Fallback: n (Fensternormale) um 90° in XY drehen
    // (−ny, nx) ist rechtwinklig in XY
    rightH = [-n[1], n[0], 0];
  } else {
    rightH = [rightH[0] / len, rightH[1] / len, 0];
  }

  // yaw in der Horizontalebene anwenden
  const yaw = (yawDeg * Math.PI) / 180;
  const cos = Math.cos(yaw), sin = Math.sin(yaw);
  const right: Vec3 = [ rightH[0]*cos - rightH[1]*sin, rightH[0]*sin + rightH[1]*cos, 0 ];
  const up:    Vec3 = [ -right[1], right[0], 0 ]; // 90° gedreht, bleibt in XY

  return {
    center,
    normal: [0, 0, 1],   // horizontal
    right:  right,
    up:     up,
    halfWidth:  width / 2,
    halfHeight: depth / 2,
  };
}
/** Wand-Spezifikation (parallel zum Fenster, ins Zimmer versetzt) */
interface TargetWall {
  kind: 'wall';
  /** Abstand ins Zimmer (Meter, entlang -window.normal) */
  distance: number;
  /** Breite der Wand (entlang window.right, Meter) */
  width: number;
  /** Höhe der Wand (entlang window.up, Meter) */
  height: number;
  /** optional: seitlicher Versatz (Meter) entlang window.right */
  lateral?: number;
  /** optional: vertikale Verschiebung (Meter relativ zum Fensterzentrum) */
  zCenter?: number;
}

/** Horizontale Fläche (Boden, Tisch, Regalbrett …) */
interface TargetFloor {
  kind: 'floor';
  /** Abstand ins Zimmer (Meter, entlang -window.normal) */
  distance: number;
  /** Ausdehnung quer (Meter, entlang window.right) */
  width: number;
  /** Ausdehnung in die Tiefe (Meter, entlang Innenrichtung) */
  depth: number;
  /** optional: seitlicher Versatz (Meter) entlang window.right */
  lateral?: number;
  /** optionale absolute Welt-Höhe (z-Koordinate des Mittelpunkts, Meter) */
  zWorld?: number;
  /** optionale Drehung in der Horizontalebene (0°=Fenster-right, Grad) */
  yawDeg?: number;
}

type TargetSpec = TargetWall | TargetFloor;

/** Hilfswert: relative z-Lage (zCenter) aus absoluter Welt-Höhe berechnen */
function relZFromWorld(windowRect: Rect3D, zWorld: number): number {
  return zWorld - windowRect.center[2];
}

/**
 * Baut aus einer JSON-Spezifikation (TargetWall/TargetFloor) ein fertiges Rechteck (Rect3D).
 */
function buildTargetFromSpec(windowRect: Rect3D, spec: TargetSpec): Rect3D {
  if (spec.kind === 'wall') {
    return makeInteriorWallFromWindow(
      windowRect,
      spec.distance,
      spec.width,
      spec.height,
      spec.lateral ?? 0,
      spec.zCenter ?? 0
    );
  } else {
    return makeHorizontalFromWindow(
      windowRect,
      spec.distance,
      spec.width,
      spec.depth,
      spec.lateral ?? 0,
      spec.zWorld ?? 0,
      spec.yawDeg ?? 0
    );
  }
}

init();

EDIT- und mache EDITS wieder drunter sonst haut mich homoran ^^
Das ist ein TS-Skript - leicht getestet scheint aber zu funktionieren, habs dann wieder vergessen. Aktuell wird ergebnis ins log geschrieben

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

damit muß ich dann ne Strahlenverfolgung machen was dann irgendwie so endet

ich frag mal gaaanz vorsichtig!
Die Berechnung der nutzbaren Energie scheint ja korrekt zu funktionieren.
rechnest du für jede Stunde unter Hourly diese Auftreffwinkel und addierst diese dann?
oder addierst du erst und rechnest dann die resultierende Energie?

[klassisch]

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

rechnest du für jede Stunde unter Hourly diese Auftreffwinkel und addierst diese dann?

so sollte man das tun

oder addierst du erst und rechnest dann die resultierende Energie?

so sollte man das nicht tun. Da sind etliche trigonometrische Funktionen und damit auch Nichtlinearitäten involviert. Da darf man die Operationen nicht vertauschen.

Ob es hilft? Schwierig wenn das so aussieht wie gestern:

Aber am Ende des Tages war der Minderertrag nur 5,4% gegenüber der 05:00 Berechnung und 7,1% gegenüber der 08:00 Berechnung

Vorgestern sah es so aus:

Da lag dann die Realität 15% über der 08:00 Berechnung und 8% über der 08:00 Berechnung.

Ich finde das gar nicht so schlecht für solch ein Wolkengewimmel. Sind aber jetzt noch zu wenige Tage.

[ticaki]

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

damit muß ich dann ne Strahlenverfolgung machen was dann irgendwie so endet

ich frag mal gaaanz vorsichtig!
Die Berechnung der nutzbaren Energie scheint ja korrekt zu funktionieren.
rechnest du für jede Stunde unter Hourly diese Auftreffwinkel und addierst diese dann?
oder addierst du erst und rechnest dann die resultierende Energie?

Du kannst auch unvorsichtig fragen :P

Es wird der Eintrag von z.B. 07:00 genommen und dann mit dem Sonnenstand um 07:00 gerechnet, und das halt für jede Stunden. Am Ende summiert - Formel steht oben :)

                                               dailyData.solar_estimate = values.reduce((sum, value, index) => {
                                                    if (typeof sum !== 'number') {
                                                        sum = 0; // Initialize sum to 0 if it's not a number
                                                    }
                                                    if (value != null && typeof value === 'number') {
                                                        const newValue = estimatePVEnergyForHour(
                                                            value,
                                                            new Date(weatherArr[i].timestamp[index] as string),
                                                            {
                                                                lat: parseFloat(this.config.position.split(',')[0]),
                                                                lon: parseFloat(this.config.position.split(',')[1]),
                                                            },
                                                            this.config.panels,
                                                        );

                                                        return sum + newValue;
                                                    }
                                                    return sum;
                                                });
                                                dailyData.solar_estimate = dailyData.solar_estimate
                                                    ? Math.round(dailyData.solar_estimate * 1000) / 1000
                                                    : dailyData.solar_estimate;

Edit: Bild gegen code getauscht

EDIT2: Ich könnte die Berechnung noch hourly hinzufügen, wenn das jemand braucht?!

[klassisch]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

EDIT2: Ich könnte die Berechnung noch hourly hinzufügen, wenn das jemand braucht?!

Das habe ich jetzt nicht verstanden. Die Berechnung basiert doch auf den Stundenwerten?

[ticaki]

@klassisch

Die Berechnungen sind mit den stündlichen Werten - aber ich gebe die nur summiert unterhalb von daily aus, ich könnte die berechneten Werte auch unter hourly ausgeben.

[klassisch]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

ich könnte die berechneten Werte auch unter hourly ausgeben.

D.h. man hätte dann 12 Datenpunkte mit der jeweils bis zu diesem Zeitpunkt kumulierten Energie?

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Ich könnte die Berechnung noch hourly hinzufügen, wenn das jemand braucht?!

ich (erst mal) nicht.
Aber weil es da eben nicht stand, kam meine Frage auf.

[Homoran]

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

bis zu diesem Zeitpunkt kumulierten Energie?

nein, mit der entsprechenden Stundenenergie deiner Anlage

[ticaki]

@klassisch

Nein, man hätte unter hourly jeweils den Wert für diese Stunde und müsste selbst kumulieren - könnte natürlich auch einen datenpunkt mit Kumulation anbieten.

Ich meine hier:

EDIT - dazu müsste ich aber die schreiblogik verändern, das geht nicht mal gerade so - also das kumulieren.

[klassisch]

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

nein, mit der entsprechenden Stundenenergie deiner Anlage

Den tatsächlich eingetretenen oder den vorhergesagten? Die tatsächlich eingetretenen Energiewerte die habe ich ja bereits von der PV Anlage.

Di prognostizierten wären für das Thema Netzdienlichkeit aber wichtig.

Es könnte ja sein, daß fast die gesamte Tagesenergie z.B. vormittags kommt und nachmittags fast nichts mehr.

Dafür wäre der Tagesverlauf schon wichtig. Ansonsten kann man sich leicht "verzocken".

[Homoran]

@klassisch ja, du hast ja recht!
ist nicht präzise!

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

den vorhergesagten

Natürlich!

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Es könnte ja sein, daß fast die gesamte Tagesenergie z.B. vormittags kommt und nachmittags fast nichts mehr.

richtig!
Deswegen beobachte ich gerade meine faktorisierte Vorhersage, basierend auf solar (grün) im Vergleich zu solar_estimate (lila)

Nach den ersten Tagen war da nach meinem Gefühl der Unterschied zu gering. Aber das heisst erst mal nichts.
Deswegen hatte ich nach dem Algorithmus gefragt.

Habe das bisher nicht selber angegangen, da du für jede Stunde den mittleren Azimut, Elevation und solar mit dem Timestamp mappen müsstest, dann die trigonometrischen Berechnungen ausführst und das dann kumulierst

[klassisch]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@klassisch

Nein, man hätte unter hourly jeweils den Wert für diese Stunde und müsste selbst kumulieren - könnte natürlich auch einen datenpunkt mit Kumulation anbieten.

Ich meine hier:

Ah, ich glaube jetzt habe ich es verstanden. Zusätzlich zu den DWD Werten kämen dann noch die für mein Dach customized Werte mit der ganzen Geometrie.
Ich fände es praktisch. Derzeit rechne ich das intern in meinem Frickelskript - ohne diese Datenpunkte anzulegen. Aber eine Lösung von einem professionellen Adapterprogrammierer wäre natürlich immer besser als mein Gefrickel.

EDIT - dazu müsste ich aber die schreiblogik verändern, das geht nicht mal gerade so - also das kumulieren.

Ja, in dieser Richtung klemmt es bei mir auch gerade. Ich habe ja noch keinen netzdienlichen Algo. Ich mache das noch manuell. Dazu schreibe ich mit die prognostizierten Stundenwerte meiner Anlage als Sequenz in einen Datenpunkt. Der erzeugt dann die blaue Linie. Dann kann ich als Mensch grob abschätzen, wie ich heute einspeise bzw. den Akku lade.
Wenn dann die 08:00 Berechnung kommt, oder das Skript untertägig neu gestartet wird, dann werden die neuen Daten an das History json File hinten angehängt, was doof ist. Wenn ich das file vorher löschen lasse, wird auch das Vortags-File gelöscht. Wie gesagt, ein Gefrickel bei mir.

[klassisch]

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Habe das bisher nicht selber angegangen, da du für jede Stunde den mittleren Azimut, Elevation und solar mit dem Timestamp mappen müsstest, dann die trigonometrischen Berechnungen ausführst und das dann kumulierst

Ich mache das ja - aber halt nicht professionell sondern Laiengefrickel.
Dann schreibe ich die Daten sequentiell in ein history json, welches die Blaue Forecast-Kurve macht.
Für heute sieht das dann so aus:

[Homoran]

@klassisch

Dann bist du schon weiter als ich!

[klassisch]

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@klassisch
Dann bist du schon weiter als ich!

Ja, Deine abgeschattete Tageskurve hat mich angespornt.
Bin aber noch nicht zufrieden wegen Mehrfachschreiben, Tageswechsel etc.
Gehe ich noch an, aber derzeite beobachte ich soll und ist.

[Homoran]

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

derzeite beobachte ich soll und ist.

aber schon auf hourly Basis!
Da wäre es natürlich schön die Estimate-Werte von @ticaki unter hourly zu haben und dein Skript zu füttern.
Ich würde es erstmal zur manuellen Plausibilitätsprüfung nutzen.

Zu mehr komme ich im Moment nicht