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

[ticaki]

@homoran
dafür gibts einen Wetteradapter die sagen dir was für temperaturen du erwarten kannst und wind ist da auch :P

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

dafür gibts einen Wetteradapter

• ist die Quelle vertrauenswürdig? :joy:
• das Skript ist uralt

[klassisch]

@homoran brightsky hat Temperaturen und Wind in den stündlichen Datenpunkten.

[Homoran]

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@homoran brightsky hat Temperaturen und Wind in den stündlichen Datenpunkten.

wie gesagt habe ich mich
a) noch nicht mit den stündlichen Werten beschäftigt
b) gab es brightsky vor 4 Jahren noch nicht ( https://forum.iobroker.net/post/592093 )
c) wollte ich es "eigentlich" einfacher halten, als in dem verlinkten Thread
...bis der

@klassisch sagte in Vergleich Solarprognosen Solarwetter und brightsky:

@Homoran schen Perfektionismus

zuschlug.
Da würde die Paneltemperatur sinnvoll sein

@homoran sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Der neue Sensor liegt bereit. will ich im Herbst unter zwei Panels kleben.

Außentemperatur und Wind wären da eh nur Hilfsdaten.

Ich muss mal sehen, wann ich wieder mehr Zeit hab

[Homoran]

@ticaki sagte in Vergleich Solarprognosen Solarwetter und brightsky:

Bei mir war es auch recht dicht dran.

noch ein upvote geht leider nicht

Faktorisiert, realer Wert und dein estimate

:+1:

[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 :grin: !?
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 :rolling_on_the_floor_laughing:

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