feat(openclaw): add shopping, supermarket deals, geizhals, and ebay MCP tools
This commit is contained in:
Moritz Graf
@@ -1,398 +1,299 @@
|
||||
////////////// TAUPI 4.0 @ Shelly //////////////
|
||||
// copyright by boeserbob und holzachr
|
||||
// Fragen an quirb@web.de
|
||||
// Dokumentation und aktuelle Versionen unter https://github.com/BoeserBob/Taupi-4.0
|
||||
//
|
||||
// Dieses Skript verwandelt z.B. eine Shelly Plug in eine Taupunktlüftersteuerung.
|
||||
// Der Skript schaltet einen angeschlossenen Lüfter über den Schalter des Shellys auf dem er installiert ist entsprechend der Taupunktunterschiede innen - außen.
|
||||
// - Es empfängt Messwert-Events von BLE-Sensoren auf.
|
||||
// - Wenn die Messwerte von den angegebenen Innen- und Außen-Sensoren stammen, werden aus Temperatur und Luftfeuchte die jeweiligen Taupunkte berechnet.
|
||||
// - Eine Timerschleife überprüft regelmäßig, ob alle Einschaltbedingungen fuer den Lüfter erfüllt sind:
|
||||
// - Wenn der Taupunkt innen größer als der Taupunkt außen + einem Schwellwert ist wird der Lüfter eingeschaltet, sonst ausgeschaltet.
|
||||
// - Wenn die Innentermperatur unter 10 °C und die Innenraumfeuchte unter 50 % ist wird der Lüfer ausgeschaltet.
|
||||
////////////// TAUPI 4.5 @ Shelly //////////////
|
||||
// Dynamic Quality-Score Psychrometric Controller & Adaptive Thermal Governor
|
||||
|
||||
//========== Sensor-Konfiguration ==========
|
||||
var sensor_aussen = "${sensor_aussen_mac}";
|
||||
var sensor_innen = "${sensor_innen_mac}";
|
||||
//========== Debug-Konfiguration ==========
|
||||
var DEBUG = false;
|
||||
//========== Schalt-Konfiguration ==========
|
||||
var taupunktschwelle = ${taupunktschwelle}; // [°C] Lüfter einschalten wenn TPinnen > (TPaussen + taupunktschwelle)...
|
||||
var mindesttemperatur = ${mindesttemperatur}; // [°C] ...und Tinnen > mindesttemperatur...
|
||||
var mindesthumi = ${mindesthumi}; // [%] ...und RHinnen > mindesthumi
|
||||
var schaltzeit = ${schaltzeit}; // [s] Schaltbedingung prüfen alle X Sekunden
|
||||
var battery_warngrenze = ${battery_warngrenze}; // [%] wenn dieser Schwellwert unterschritten ist blinkt der Plug rot
|
||||
var lost_connection = ${lost_connection}; // [s] Zeit nach der frische Sensordaten gekommen sein müssen um tote Verbindungen zu finden
|
||||
//========== Kritische Feuchte-Konfiguration (Schimmelgefahr) ==========
|
||||
var critical_humi_base = ${critical_humi_base}; // [%] Kritische relative Feuchte bei Referenztemp.
|
||||
var critical_humi_temp_coeff = ${critical_humi_temp_coeff}; // [%/°C] Steigung des Grenzwerts pro °C
|
||||
var critical_humi_ref_temp = ${critical_humi_ref_temp}; // [°C] Referenztemperatur
|
||||
var critical_humi_buffer = ${critical_humi_buffer}; // [%] Sicherheitspuffer
|
||||
//===== Ende Sensor-Konfiguration === AB HIER MUSS NICHTS MEHR GEÄNDERT WERDEN =====================================
|
||||
var MAC_OUT = "${sensor_aussen_mac}".toLowerCase();
|
||||
var MAC_IN = "${sensor_innen_mac}".toLowerCase();
|
||||
|
||||
var taupunkt_aussen;
|
||||
var taupunkt_innen;
|
||||
var temperatur_innen;
|
||||
var temperatur_aussen;
|
||||
var humidity_innen;
|
||||
var humidity_aussen;
|
||||
var battery_innen;
|
||||
var battery_aussen;
|
||||
var lost_connection_innen;
|
||||
var lost_connection_aussen;
|
||||
var SCHALTZEIT_SEC = ${schaltzeit};
|
||||
var LOST_LIMIT = ${lost_connection};
|
||||
var BATT_LIMIT = ${battery_warngrenze};
|
||||
var DP_SPREAD_BASE = ${taupunktschwelle};
|
||||
var MIN_TEMP_FLOOR = ${mindesttemperatur};
|
||||
var MAX_HEAT_CEIL = ${max_indoor_temp_heating};
|
||||
var WINTER_IN_TH = ${winter_temp_threshold_in};
|
||||
var TARGET_SUMMER = ${target_humi_summer};
|
||||
var TARGET_WINTER = ${target_humi_winter};
|
||||
var MIN_PAUSE_MIN = ${min_pause_minutes};
|
||||
|
||||
var luefterstatus = null; // Merkt sich letzten Schaltzustand, um unnötige Schaltvorgänge zu vermeiden
|
||||
var LIM_BASE = ${critical_humi_base};
|
||||
var LIM_COEFF = ${critical_humi_temp_coeff};
|
||||
var LIM_REF_T = ${critical_humi_ref_temp};
|
||||
var LIM_BUF = ${critical_humi_buffer};
|
||||
|
||||
// Taupunktberechnung
|
||||
function taupunkt(T, RH) {
|
||||
var a = (T >= 0) ? 17.27 : 21.875;
|
||||
var b = (T >= 0) ? 237.7 : 265.5;
|
||||
var ti = undefined, hi = undefined, di = undefined, bi = undefined, age_in = 999999;
|
||||
var to = undefined, ho = undefined, do_ = undefined, bo = undefined, age_out = 999999;
|
||||
|
||||
var fan_run_sec = 0, fan_pause_sec = 0, relay_on = false, last_reason = "INIT", last_color = -1;
|
||||
var st_run = 0, st_target = TARGET_SUMMER, st_mold_th = 70.0, st_mold_crit = 0, st_spread = 0;
|
||||
var st_quality = 0, st_max_run_min = 0, st_gov_state = 0;
|
||||
var pid_out = -1, pid_in = -1;
|
||||
|
||||
function calcDewPoint(T, RH) {
|
||||
if (typeof T !== "number" || typeof RH !== "number" || isNaN(T) || isNaN(RH) || RH <= 0) return undefined;
|
||||
var a = (T >= 0) ? 17.27 : 21.875, b = (T >= 0) ? 237.7 : 265.5;
|
||||
var alpha = (a * T) / (b + T) + Math.log(RH / 100);
|
||||
return (b * alpha) / (a - alpha);
|
||||
}
|
||||
|
||||
// Lüftersteuerung
|
||||
function schalten() {
|
||||
// Sicherheitsprüfung: Sind alle benötigten Werte vorhanden?
|
||||
if (typeof taupunkt_innen === "undefined" ||
|
||||
typeof taupunkt_aussen === "undefined" ||
|
||||
typeof temperatur_innen === "undefined" ||
|
||||
typeof humidity_innen === "undefined")
|
||||
{
|
||||
print("Nicht alle Sensorwerte vorhanden - Schaltung übersprungen.");
|
||||
farbring(80,80,0,100);
|
||||
return;
|
||||
function calcMoldThresh(T) {
|
||||
if (typeof T !== "number" || isNaN(T)) return undefined;
|
||||
return LIM_BASE - LIM_COEFF * (T - LIM_REF_T) - LIM_BUF;
|
||||
}
|
||||
|
||||
function evaluateDecision() {
|
||||
var telOk = (typeof ti === "number" && typeof to === "number" && typeof hi === "number" && typeof ho === "number" &&
|
||||
typeof di === "number" && typeof do_ === "number" && !isNaN(ti) && !isNaN(to) && !isNaN(hi) &&
|
||||
!isNaN(ho) && !isNaN(di) && !isNaN(do_) && age_in <= LOST_LIMIT && age_out <= LOST_LIMIT);
|
||||
if (!telOk) return { run: false, reason: "TELEMETRY_INVALID", maxRun: 0, qual: 0, gov: 0 };
|
||||
|
||||
if (fan_pause_sec > 0) return { run: false, reason: "COOLDOWN_PAUSE", maxRun: 0, qual: 0, gov: 0 };
|
||||
|
||||
var mt = calcMoldThresh(ti);
|
||||
var isMoldCrit = (typeof mt === "number" && hi >= mt);
|
||||
|
||||
// 1. Frost Floor Check
|
||||
if (ti <= MIN_TEMP_FLOOR && !isMoldCrit) {
|
||||
return { run: false, reason: "FROST_PROTECTION", maxRun: 0, qual: 0, gov: 1 };
|
||||
}
|
||||
|
||||
// Kritische Feuchte (Schimmelgrenzkurve) berechnen
|
||||
var rh_crit = critical_humi_base - critical_humi_temp_coeff * (temperatur_innen - critical_humi_ref_temp);
|
||||
var rh_activation = rh_crit - critical_humi_buffer;
|
||||
var is_critical = humidity_innen >= rh_activation;
|
||||
// 2. Adaptive Thermal Governor
|
||||
var reqSpread = DP_SPREAD_BASE;
|
||||
var targetHumi = TARGET_SUMMER;
|
||||
var govState = 2; // Comfort default
|
||||
|
||||
print("Schimmelprüfung: T_innen =", temperatur_innen, "°C, RH_innen =", humidity_innen, "%, RH_crit =", rh_crit, "%, Aktivierung ab =", rh_activation, "%, Kritisch =", is_critical);
|
||||
|
||||
// Sicherheitsprüfung kommen regelmäßig frische Daten von den Sensoren?
|
||||
lost_connection_innen = lost_connection_innen + schaltzeit
|
||||
lost_connection_aussen = lost_connection_aussen + schaltzeit
|
||||
print("letzte Verbindung zum Sensor innen vor " ,lost_connection_innen, " Sekunden " );
|
||||
print("letzte Verbindung zum Sensor außen vor " ,lost_connection_aussen, " Sekunden " );
|
||||
|
||||
if (lost_connection_innen > lost_connection ||
|
||||
lost_connection_aussen > lost_connection )
|
||||
{
|
||||
print("Verbindung zu Sensoren zu lange verloren, Lüfter ausschalten.");
|
||||
Shelly.call("Switch.Set", { id: 0, on: false });
|
||||
farbring(80,80,0,100);
|
||||
return;
|
||||
}
|
||||
|
||||
// Visualisierung Batteriefüllstand durch roten Blink
|
||||
if (battery_innen < battery_warngrenze ||
|
||||
battery_aussen < battery_warngrenze)
|
||||
{
|
||||
print("Batteriestand niedrig");
|
||||
farbring(100,0,0,100);
|
||||
}
|
||||
|
||||
// Schaltlogik (immer schalten, der Shelly schaltet nur, wenn er schaltet muss).
|
||||
if ( is_critical &&
|
||||
temperatur_innen > mindesttemperatur &&
|
||||
humidity_innen > mindesthumi &&
|
||||
taupunkt_innen > taupunkt_aussen + taupunktschwelle
|
||||
)
|
||||
{
|
||||
print("Lüfter einschalten");
|
||||
Shelly.call("Switch.Set", { id: 0, on: true });
|
||||
farbring(80,10,0,100);
|
||||
|
||||
if (ti > MAX_HEAT_CEIL) {
|
||||
// Warm Zone (> 20°C): Maximize cooling. Prevent heating if To > Ti.
|
||||
govState = 3;
|
||||
if (to > ti) return { run: false, reason: "HEATING_PREVENTED", maxRun: 0, qual: 0, gov: govState };
|
||||
reqSpread = DP_SPREAD_BASE;
|
||||
targetHumi = TARGET_SUMMER;
|
||||
} else if (ti >= WINTER_IN_TH) {
|
||||
// Comfort Zone (14°C - 20°C)
|
||||
govState = 2;
|
||||
targetHumi = TARGET_SUMMER;
|
||||
if (to < (ti - 5.0)) {
|
||||
reqSpread = DP_SPREAD_BASE + 1.0; // Strong cooling requires prime spread >= 3.0°C
|
||||
}
|
||||
} else {
|
||||
print("Lüfter ausschalten.");
|
||||
Shelly.call("Switch.Set", { id: 0, on: false });
|
||||
farbring(0,0,80,100);
|
||||
}
|
||||
}
|
||||
|
||||
// Farbe Farbring setzen für Standalone Betrieb.
|
||||
function farbring(red,green,blue,helligkeit) {
|
||||
Shelly.call(
|
||||
"PLUGS_UI.SetConfig",{ id:0, config:{"leds":{"mode":"switch","colors":
|
||||
{"switch:0":
|
||||
{"on":{"rgb":[red,green,blue],"brightness":helligkeit},
|
||||
"off":{"rgb":[red,green,blue],"brightness":helligkeit}}}}}},
|
||||
function (result, code, msg, ud) {
|
||||
},
|
||||
null
|
||||
);
|
||||
}
|
||||
|
||||
// Event-Verarbeitung
|
||||
function checkBlu(event) {
|
||||
var addr = event.address.toLowerCase();
|
||||
var aussen = sensor_aussen.toLowerCase();
|
||||
var innen = sensor_innen.toLowerCase();
|
||||
|
||||
if (DEBUG) {
|
||||
print("DEBUG checkBlu: event.addr=", addr, " aussen=", aussen, " innen=", innen);
|
||||
// Cold Zone (< 14°C)
|
||||
govState = 4;
|
||||
targetHumi = TARGET_WINTER;
|
||||
if (to >= ti) {
|
||||
reqSpread = DP_SPREAD_BASE + 0.5; // Warming cellar allowed at spread >= 2.5°C
|
||||
} else {
|
||||
reqSpread = DP_SPREAD_BASE + 1.5; // Further cooling an already cold cellar requires >= 3.5°C
|
||||
}
|
||||
}
|
||||
|
||||
if (addr === aussen) {
|
||||
if (typeof event.temperature !== "undefined") {
|
||||
temperatur_aussen = event.temperature;
|
||||
}
|
||||
if (typeof event.humidity !== "undefined") {
|
||||
humidity_aussen = event.humidity;
|
||||
}
|
||||
if (typeof temperatur_aussen !== "undefined" && typeof humidity_aussen !== "undefined") {
|
||||
taupunkt_aussen = taupunkt(temperatur_aussen, humidity_aussen);
|
||||
}
|
||||
if (typeof event.battery !== "undefined") {
|
||||
battery_aussen = event.battery;
|
||||
}
|
||||
lost_connection_aussen = 0;
|
||||
print("Neue Werte für Außen: T=", temperatur_aussen, "°C, RH=", humidity_aussen, "%, Tp=", taupunkt_aussen, "°C, Batt=", battery_aussen, "%");
|
||||
} else if (addr === innen) {
|
||||
if (typeof event.temperature !== "undefined") {
|
||||
temperatur_innen = event.temperature;
|
||||
}
|
||||
if (typeof event.humidity !== "undefined") {
|
||||
humidity_innen = event.humidity;
|
||||
}
|
||||
if (typeof temperatur_innen !== "undefined" && typeof humidity_innen !== "undefined") {
|
||||
taupunkt_innen = taupunkt(temperatur_innen, humidity_innen);
|
||||
}
|
||||
if (typeof event.battery !== "undefined") {
|
||||
battery_innen = event.battery;
|
||||
}
|
||||
lost_connection_innen = 0;
|
||||
print("Neue Werte für Innen: T=", temperatur_innen, "°C, RH=", humidity_innen, "%, Tp=", taupunkt_innen, "°C, Batt=", battery_innen, "%");
|
||||
// 3. Target Humidity Gate
|
||||
if (hi <= targetHumi) {
|
||||
return { run: false, reason: "TARGET_REACHED", maxRun: 0, qual: 0, gov: govState };
|
||||
}
|
||||
|
||||
// 4. Dew Point Spread Gate
|
||||
var spread = di - do_;
|
||||
if (spread < reqSpread) {
|
||||
return { run: false, reason: "INSUFFICIENT_SPREAD", maxRun: 0, qual: Math.round(Math.max(0, spread * 20)), gov: govState };
|
||||
}
|
||||
|
||||
// 5. Dynamic Quality Runtime Formula
|
||||
// Runtime [min] = (spread - DP_SPREAD_BASE) * 45 min
|
||||
var maxRunMin = 0;
|
||||
if (spread >= 5.0) {
|
||||
maxRunMin = 9999; // Unlimited continuous run
|
||||
} else {
|
||||
maxRunMin = Math.round((spread - DP_SPREAD_BASE) * 45);
|
||||
if (maxRunMin < 15) maxRunMin = 15;
|
||||
}
|
||||
|
||||
// Cold Zone burst throttle (max 25 min bursts when Ti < 14°C)
|
||||
if (ti < WINTER_IN_TH && maxRunMin > 25) {
|
||||
maxRunMin = 25;
|
||||
}
|
||||
|
||||
var qualityScore = Math.min(100, Math.round(spread * 20));
|
||||
|
||||
return { run: true, reason: "VENTILATING_QUALITY", maxRun: maxRunMin, qual: qualityScore, gov: govState };
|
||||
}
|
||||
|
||||
// Haupt-Timer für Steuerlogik
|
||||
Timer.set(schaltzeit * 1000, true, function () {
|
||||
var rh_crit_t = (typeof temperatur_innen !== "undefined") ? (critical_humi_base - critical_humi_temp_coeff * (temperatur_innen - critical_humi_ref_temp)) : undefined;
|
||||
var rh_act_t = (typeof rh_crit_t !== "undefined") ? (rh_crit_t - critical_humi_buffer) : undefined;
|
||||
function updateLeds(c) {
|
||||
if (c === last_color) return;
|
||||
last_color = c;
|
||||
var r = 0, g = 40, b = 80, br = 60;
|
||||
if (c === 1) { r = 100; g = 0; b = 0; br = 100; }
|
||||
else if (c === 2) { r = 80; g = 80; b = 0; br = 100; }
|
||||
else if (c === 3) { r = 60; g = 0; b = 80; br = 80; }
|
||||
else if (c === 4) { r = 80; g = 20; b = 0; br = 100; }
|
||||
|
||||
print("----- Steuerung alle", schaltzeit, "s -----");
|
||||
print("Innen: T =", temperatur_innen, "°C, RH =", humidity_innen, "%, Tp =", taupunkt_innen, "°C, Aktivierung ab RH =", rh_act_t, "% (Batterie:", battery_innen, "%)");
|
||||
print("Außen: T =", temperatur_aussen, "°C, RH =", humidity_aussen, "%, Tp =", taupunkt_aussen, "°C (Batterie:", battery_aussen, "%)");
|
||||
schalten();
|
||||
Shelly.call("PLUGS_UI.SetConfig", {
|
||||
id: 0,
|
||||
config: { leds: { mode: "switch", colors: { "switch:0": { on: { rgb: [r, g, b], brightness: br }, off: { rgb: [r, g, b], brightness: br } } } } }
|
||||
});
|
||||
}
|
||||
|
||||
function applyDecision(d) {
|
||||
last_reason = d.reason;
|
||||
st_quality = d.qual;
|
||||
st_max_run_min = d.maxRun;
|
||||
st_gov_state = d.gov;
|
||||
|
||||
if (d.run) {
|
||||
fan_run_sec += SCHALTZEIT_SEC;
|
||||
if (d.maxRun < 9999 && fan_run_sec >= d.maxRun * 60) {
|
||||
d.run = false;
|
||||
last_reason = "BURST_LIMIT_REACHED";
|
||||
fan_pause_sec = MIN_PAUSE_MIN * 60;
|
||||
fan_run_sec = 0;
|
||||
}
|
||||
} else {
|
||||
fan_run_sec = 0;
|
||||
if (fan_pause_sec > 0) {
|
||||
fan_pause_sec -= SCHALTZEIT_SEC;
|
||||
if (fan_pause_sec < 0) fan_pause_sec = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (d.run !== relay_on) {
|
||||
print("Relais:", d.run ? "EIN" : "AUS", "|", last_reason, "| MaxRun:", st_max_run_min, "min | Qual:", st_quality);
|
||||
Shelly.call("Switch.Set", { id: 0, on: d.run });
|
||||
relay_on = d.run;
|
||||
}
|
||||
|
||||
var c = 5;
|
||||
if (bi < BATT_LIMIT || bo < BATT_LIMIT) c = 1;
|
||||
else if (age_in > LOST_LIMIT || age_out > LOST_LIMIT) c = 2;
|
||||
else if (fan_pause_sec > 0) c = 3;
|
||||
else if (d.run) c = 4;
|
||||
updateLeds(c);
|
||||
|
||||
var isWinter = (typeof ti === "number") ? (ti < WINTER_IN_TH) : false;
|
||||
var mt = calcMoldThresh(ti);
|
||||
var mc = (typeof ti === "number" && typeof hi === "number" && typeof mt === "number" && hi >= mt) ? 1 : 0;
|
||||
|
||||
st_run = d.run ? 1 : 0;
|
||||
st_target = isWinter ? TARGET_WINTER : TARGET_SUMMER;
|
||||
st_mold_th = (typeof mt === "number") ? mt : 70.0;
|
||||
st_mold_crit = mc;
|
||||
st_spread = (typeof di === "number" && typeof do_ === "number") ? (di - do_) : 0;
|
||||
}
|
||||
|
||||
Timer.set(SCHALTZEIT_SEC * 1000, true, function () {
|
||||
age_in += SCHALTZEIT_SEC;
|
||||
age_out += SCHALTZEIT_SEC;
|
||||
var d = evaluateDecision();
|
||||
print("Taupi:", d.run, d.reason, "| Qual:", d.qual, "| Spread:", st_spread);
|
||||
applyDecision(d);
|
||||
});
|
||||
|
||||
///////////////// BLE-Decoder ///////////////////////
|
||||
const BTHOME_SVC_ID_STR = "fcd2";
|
||||
function decodeBTHome(buf, isOut) {
|
||||
if (typeof buf !== "string" || buf.length < 2) return;
|
||||
var dib = buf.at(0);
|
||||
if ((dib >> 5) !== 2 || (dib & 0x1)) return;
|
||||
var off = 1, pid = -1, t = undefined, h = undefined, b = undefined;
|
||||
|
||||
const uint8 = 0;
|
||||
const int8 = 1;
|
||||
const uint16 = 2;
|
||||
const int16 = 3;
|
||||
while (off < buf.length) {
|
||||
var id = buf.at(off++);
|
||||
if (id === 0x00) { pid = buf.at(off++); }
|
||||
else if (id === 0x01) { b = buf.at(off++); }
|
||||
else if (id === 0x2e) { h = buf.at(off++); }
|
||||
else if (id === 0x1e || id === 0x20 || id === 0x21 || id === 0x2d || id === 0x3a || id === 0x60) { off++; }
|
||||
else if (id === 0x02) {
|
||||
var u = (buf.at(off + 1) << 8) | buf.at(off);
|
||||
off += 2;
|
||||
var raw = (u & 0x8000) ? (u - 0x10000) : u;
|
||||
t = raw * 0.01;
|
||||
} else if (id === 0x03) {
|
||||
var u = (buf.at(off + 1) << 8) | buf.at(off);
|
||||
off += 2;
|
||||
h = u * 0.01;
|
||||
} else if (id === 0x45) {
|
||||
var u = (buf.at(off + 1) << 8) | buf.at(off);
|
||||
off += 2;
|
||||
var raw = (u & 0x8000) ? (u - 0x10000) : u;
|
||||
t = raw * 0.1;
|
||||
} else if (id === 0x08 || id === 0x0c || id === 0x3c || id === 0x3f || id === 0x44 || id === 0x46 || id === 0x5e || id === 0x5f || id === 0xf0) {
|
||||
off += 2;
|
||||
} else if (id === 0x04 || id === 0x05 || id === 0xf2) {
|
||||
off += 3;
|
||||
} else if (id === 0xf1) {
|
||||
off += 4;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// The BTH object defines the structure of the BTHome data (trimmed to temperature/humidity/battery)
|
||||
const BTH = {
|
||||
0x00: { n: "pid", t: uint8 },
|
||||
0x01: { n: "battery", t: uint8 },
|
||||
0x02: { n: "temperature", t: int16, f: 0.01 },
|
||||
0x03: { n: "humidity", t: uint16, f: 0.01 },
|
||||
0x1e: { n: "light", t: uint8 },
|
||||
0x2d: { n: "window", t: uint8 },
|
||||
0x2e: { n: "humidity", t: uint8 },
|
||||
0x3f: { n: "rotation", t: int16, f: 0.1 },
|
||||
0x45: { n: "temperature", t: int16, f: 0.1 }
|
||||
};
|
||||
|
||||
function getByteSize(type) {
|
||||
if (type === uint8 || type === int8) return 1;
|
||||
if (type === uint16 || type === int16) return 2;
|
||||
return 255;
|
||||
if (isOut) {
|
||||
if (pid !== -1) {
|
||||
if (pid === pid_out && typeof t !== "number") return;
|
||||
pid_out = pid;
|
||||
}
|
||||
if (typeof t === "number") to = t;
|
||||
if (typeof h === "number") ho = h;
|
||||
if (typeof to === "number" && typeof ho === "number") do_ = calcDewPoint(to, ho);
|
||||
if (typeof b === "number") bo = b;
|
||||
age_out = 0;
|
||||
} else {
|
||||
if (pid !== -1) {
|
||||
if (pid === pid_in && typeof t !== "number") return;
|
||||
pid_in = pid;
|
||||
}
|
||||
if (typeof t === "number") ti = t;
|
||||
if (typeof h === "number") hi = h;
|
||||
if (typeof ti === "number" && typeof hi === "number") di = calcDewPoint(ti, hi);
|
||||
if (typeof b === "number") bi = b;
|
||||
age_in = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Functions for decoding and unpacking the service data from Shelly BLU devices
|
||||
const BTHomeDecoder = {
|
||||
utoi: function (num, bitsz) {
|
||||
const mask = 1 << (bitsz - 1);
|
||||
return num & mask ? num - (1 << bitsz) : num;
|
||||
},
|
||||
getUInt8: function (buffer, offset) {
|
||||
return buffer.at(offset);
|
||||
},
|
||||
getInt8: function (buffer, offset) {
|
||||
return this.utoi(this.getUInt8(buffer, offset), 8);
|
||||
},
|
||||
getUInt16LE: function (buffer, offset) {
|
||||
return 0xffff & ((buffer.at(offset + 1) << 8) | buffer.at(offset));
|
||||
},
|
||||
getInt16LE: function (buffer, offset) {
|
||||
return this.utoi(this.getUInt16LE(buffer, offset), 16);
|
||||
},
|
||||
getBufValue: function (type, buffer, offset) {
|
||||
if (buffer.length - offset < getByteSize(type)) return null;
|
||||
if (type === uint8) return this.getUInt8(buffer, offset);
|
||||
if (type === int8) return this.getInt8(buffer, offset);
|
||||
if (type === uint16) return this.getUInt16LE(buffer, offset);
|
||||
if (type === int16) return this.getInt16LE(buffer, offset);
|
||||
return null;
|
||||
},
|
||||
|
||||
unpack: function (buffer) {
|
||||
if (typeof buffer !== "string" || buffer.length === 0) return null;
|
||||
let result = {};
|
||||
let _dib = buffer.at(0);
|
||||
result["encryption"] = _dib & 0x1 ? true : false;
|
||||
result["BTHome_version"] = _dib >> 5;
|
||||
if (result["BTHome_version"] !== 2) return null;
|
||||
if (result["encryption"]) return result;
|
||||
|
||||
let offset = 1;
|
||||
let _bth;
|
||||
let _value;
|
||||
while (offset < buffer.length) {
|
||||
_bth = BTH[buffer.at(offset)];
|
||||
if (typeof _bth === "undefined") {
|
||||
break;
|
||||
}
|
||||
offset++;
|
||||
_value = this.getBufValue(_bth.t, buffer, offset);
|
||||
|
||||
if (_value === null) break;
|
||||
if (typeof _bth.f !== "undefined") _value = _value * _bth.f;
|
||||
|
||||
if (typeof result[_bth.n] === "undefined") {
|
||||
result[_bth.n] = _value;
|
||||
}
|
||||
else {
|
||||
if (Array.isArray(result[_bth.n])) {
|
||||
result[_bth.n].push(_value);
|
||||
}
|
||||
else {
|
||||
result[_bth.n] = [
|
||||
result[_bth.n],
|
||||
_value
|
||||
];
|
||||
}
|
||||
}
|
||||
|
||||
offset += getByteSize(_bth.t);
|
||||
}
|
||||
return result;
|
||||
},
|
||||
};
|
||||
|
||||
let lastPacketId = 0x100;
|
||||
|
||||
function BLEScanCallback(event, result) {
|
||||
if (event !== BLE.Scanner.SCAN_RESULT) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
print("DEBUG BLEScanCallback: addr=", result.addr, " rssi=", result.rssi);
|
||||
}
|
||||
|
||||
if (typeof result.service_data === "undefined" ||
|
||||
typeof result.service_data[BTHOME_SVC_ID_STR] === "undefined") {
|
||||
return;
|
||||
}
|
||||
|
||||
let unpackedData = BTHomeDecoder.unpack(result.service_data[BTHOME_SVC_ID_STR]);
|
||||
|
||||
if (unpackedData === null ||
|
||||
typeof unpackedData === "undefined" ||
|
||||
unpackedData["encryption"]) {
|
||||
print("Error: Encrypted devices are not supported or unpacking failed");
|
||||
return;
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
print("DEBUG unpacked BTHome:", JSON.stringify(unpackedData));
|
||||
}
|
||||
|
||||
if (lastPacketId === unpackedData.pid) {
|
||||
return;
|
||||
}
|
||||
|
||||
lastPacketId = unpackedData.pid;
|
||||
unpackedData.address = result.addr;
|
||||
checkBlu(unpackedData);
|
||||
if (event !== BLE.Scanner.SCAN_RESULT || !result || typeof result.addr !== "string") return;
|
||||
var a = result.addr.toLowerCase();
|
||||
var isOut = (a === MAC_OUT), isIn = (a === MAC_IN);
|
||||
if (!isOut && !isIn) return;
|
||||
if (!result.service_data || typeof result.service_data["fcd2"] === "undefined") return;
|
||||
decodeBTHome(result.service_data["fcd2"], isOut);
|
||||
}
|
||||
|
||||
function initBLE() {
|
||||
const BLEConfig = Shelly.getComponentConfig("ble");
|
||||
|
||||
if (!BLEConfig.enable) {
|
||||
print("Error: The Bluetooth is not enabled, please enable it from settings");
|
||||
return;
|
||||
var c = Shelly.getComponentConfig("ble");
|
||||
if (!c || !c.enable) return;
|
||||
if (!BLE.Scanner.isRunning()) {
|
||||
BLE.Scanner.Start({ duration_ms: BLE.Scanner.INFINITE_SCAN, active: false });
|
||||
}
|
||||
|
||||
if (BLE.Scanner.isRunning()) {
|
||||
print("Info: The BLE gateway is running, the BLE scan configuration is managed by the device");
|
||||
}
|
||||
else {
|
||||
const bleScanner = BLE.Scanner.Start({
|
||||
duration_ms: BLE.Scanner.INFINITE_SCAN,
|
||||
active: false
|
||||
});
|
||||
|
||||
if(!bleScanner) {
|
||||
print("Error: Can not start new scanner");
|
||||
}
|
||||
}
|
||||
|
||||
BLE.Scanner.Subscribe(BLEScanCallback);
|
||||
}
|
||||
|
||||
initBLE();
|
||||
|
||||
// Expose metrics for Prometheus
|
||||
function g(n, v) {
|
||||
return (typeof v === "number" && !isNaN(v)) ? (n + " " + JSON.stringify(v) + "\n") : "";
|
||||
}
|
||||
|
||||
if (typeof HTTPServer !== "undefined" && typeof HTTPServer.registerEndpoint === "function") {
|
||||
HTTPServer.registerEndpoint("prometheus", function(req, res) {
|
||||
var body = "";
|
||||
|
||||
function addGauge(name, val, help) {
|
||||
if ((typeof val === "number" && !isNaN(val)) || typeof val === "boolean") {
|
||||
var numVal = (typeof val === "boolean") ? (val ? 1 : 0) : val;
|
||||
body += name + " " + numVal + "\n";
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate helper values
|
||||
var rh_crit = (typeof temperatur_innen !== "undefined" && !isNaN(temperatur_innen)) ? (critical_humi_base - critical_humi_temp_coeff * (temperatur_innen - critical_humi_ref_temp)) : undefined;
|
||||
var rh_activation = (typeof rh_crit !== "undefined" && !isNaN(rh_crit)) ? (rh_crit - critical_humi_buffer) : undefined;
|
||||
var is_critical_val = (typeof humidity_innen !== "undefined" && !isNaN(humidity_innen) && typeof rh_activation !== "undefined" && !isNaN(rh_activation)) ? (humidity_innen >= rh_activation) : undefined;
|
||||
|
||||
var would_fan_activate = false;
|
||||
if (typeof is_critical_val !== "undefined" && is_critical_val !== null &&
|
||||
typeof temperatur_innen !== "undefined" && !isNaN(temperatur_innen) &&
|
||||
typeof humidity_innen !== "undefined" && !isNaN(humidity_innen) &&
|
||||
typeof taupunkt_innen !== "undefined" && !isNaN(taupunkt_innen) &&
|
||||
typeof taupunkt_aussen !== "undefined" && !isNaN(taupunkt_aussen)) {
|
||||
would_fan_activate = is_critical_val &&
|
||||
(temperatur_innen > mindesttemperatur) &&
|
||||
(humidity_innen > mindesthumi) &&
|
||||
(taupunkt_innen > taupunkt_aussen + taupunktschwelle);
|
||||
}
|
||||
|
||||
addGauge("taupi_temperature_celsius_innen", temperatur_innen, "Indoor temperature in Celsius");
|
||||
addGauge("taupi_temperature_celsius_aussen", temperatur_aussen, "Outdoor temperature in Celsius");
|
||||
addGauge("taupi_humidity_percent_innen", humidity_innen, "Indoor relative humidity in percent");
|
||||
addGauge("taupi_humidity_percent_aussen", humidity_aussen, "Outdoor relative humidity in percent");
|
||||
addGauge("taupi_dewpoint_celsius_innen", taupunkt_innen, "Indoor dew point in Celsius");
|
||||
addGauge("taupi_dewpoint_celsius_aussen", taupunkt_aussen, "Outdoor dew point in Celsius");
|
||||
addGauge("taupi_battery_percent_innen", battery_innen, "Indoor sensor battery percentage");
|
||||
addGauge("taupi_battery_percent_aussen", battery_aussen, "Outdoor sensor battery percentage");
|
||||
addGauge("taupi_lost_connection_seconds_innen", lost_connection_innen, "Seconds since last contact with indoor sensor");
|
||||
addGauge("taupi_lost_connection_seconds_aussen", lost_connection_aussen, "Seconds since last contact with outdoor sensor");
|
||||
addGauge("taupi_critical_humidity_threshold_percent", rh_activation, "Calculated relative humidity threshold above which it is critical");
|
||||
addGauge("taupi_is_critical", is_critical_val, "Flag indicating mold danger inside (humidity exceeds threshold)");
|
||||
addGauge("taupi_would_fan_activate", would_fan_activate, "Flag indicating if all fan activation criteria are met");
|
||||
|
||||
var relay_status = Shelly.getComponentStatus("switch", 0);
|
||||
if (relay_status && typeof relay_status.output !== "undefined") {
|
||||
addGauge("taupi_relay_status", relay_status.output, "Physical switch status (1 = on, 0 = off)");
|
||||
}
|
||||
|
||||
res.body = body;
|
||||
res.headers = [["Content-Type", "text/plain; version=0.0.4"]];
|
||||
HTTPServer.registerEndpoint("prometheus", function (req, res) {
|
||||
res.code = 200;
|
||||
res.headers = [["Content-Type", "text/plain; version=0.0.4"]];
|
||||
res.body =
|
||||
g("taupi_temperature_celsius_innen", ti) +
|
||||
g("taupi_temperature_celsius_aussen", to) +
|
||||
g("taupi_humidity_percent_innen", hi) +
|
||||
g("taupi_humidity_percent_aussen", ho) +
|
||||
g("taupi_dewpoint_celsius_innen", di) +
|
||||
g("taupi_dewpoint_celsius_aussen", do_) +
|
||||
g("taupi_dewpoint_spread_celsius", st_spread) +
|
||||
g("taupi_target_humidity_percent", st_target) +
|
||||
g("taupi_critical_humidity_threshold_percent", st_mold_th) +
|
||||
g("taupi_is_critical", st_mold_crit) +
|
||||
g("taupi_would_fan_activate", st_run) +
|
||||
g("taupi_quality_score", st_quality) +
|
||||
g("taupi_max_allowed_runtime_minutes", st_max_run_min) +
|
||||
g("taupi_thermal_governor_state", st_gov_state) +
|
||||
g("taupi_fan_running_seconds", fan_run_sec) +
|
||||
g("taupi_fan_pause_remaining_seconds", fan_pause_sec) +
|
||||
g("taupi_battery_percent_innen", bi) +
|
||||
g("taupi_battery_percent_aussen", bo) +
|
||||
g("taupi_lost_connection_seconds_innen", age_in) +
|
||||
g("taupi_lost_connection_seconds_aussen", age_out) +
|
||||
g("taupi_relay_status", relay_on ? 1 : 0);
|
||||
res.send();
|
||||
});
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user