Beiträge von PatrickR

// Control_Gong_v1.5
// 18.01.2025 by PatrickR
//
// 14.12.2024 v1.0  
// 15.12.2024 v1.1  time control: locking/unlocking controlling the relay after x minutes
// 17.12.2024 v1.2  remaining time in the response of the status, Gong_OFF, naming changed
// 17.12.2024 v1.3  add Math.round for calculation in fkt_calc_endtime()
// 01.01.2025 v1.4  add 2nd status answer
// 18.01.2025 v1.5  change request reply
//
//
// The ouput will be switched ON by receving a command via Endpoint "Gong_ON"
// Via WebHook will the output blocked
//
// WebHook to activate Gong (enter correct IP and scriptId):
// http://IP/script/scriptId/Gong_ENDPOINT?Gong_ON
// IP: shelly of the IP
// scriptId: Id of the script 
//
// WebHook to deactivate Gong (enter correct IP and scriptId):
// http://IP/script/scriptId/Gong_ENDPOINT?Gong_OFF
// IP: shelly of the IP
// scriptId: Id of the script 
//
// WebHook to unlock relay control via this script (enter correct IP, scriptId and minutes):
// http://IP/script/scriptId/Gong_ENDPOINT?unlocked_tm
// http://IP/script/scriptId/Gong_ENDPOINT?unlocked_tm:minutes
// IP: shelly of the IP
// scriptId: Id of the script 
// minutes: time after the relay control of this script will be locked
//
// WebHook to lock relay control via this script (enter correct IP, scriptId and minutes):
// http://IP/script/scriptId/Gong_ENDPOINT?locked_tm
// http://IP/script/scriptId/Gong_ENDPOINT?locked_tm:minutes
// IP: shelly of the IP
// scriptId: Id of the script 
// minutes: time after the relay control of this script will be unlocked
//
// WebHook to read status in EN of the relay control (enter correct IP and scriptId):
// http://IP/script/scriptId/Gong_ENDPOINT?status_en
// IP: shelly of the IP
// scriptId: Id of the script 
//
// WebHook to read status in DE of the relay control (enter correct IP and scriptId):
// http://IP/script/scriptId/Gong_ENDPOINT?status_de
// IP: shelly of the IP
// scriptId: Id of the script 
//
//
// Endpoint_Solution by ostfriese
// GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
// More information: https://www.gnu.org/licenses/gpl-3.0.txt
// ABSOLUTELY NO WARRANTY AT ALL!!!
// Made by ostfriese.
//

// ****************************************************************************************
// ****************************************************************************************
// *******************************          GLOBAL          *******************************
// ****************************************************************************************
// ****************************************************************************************

let debug_step0 = 0;
let debug_step1 = 0;

let vbCrLf = "\n\r";
let vbLf = "\n";

let strIP = ""; 

// ****************************************************************************************
// ****************************************************************************************
// *******************************          CONFIG          *******************************
// ****************************************************************************************
// ****************************************************************************************

let CONFIG = {
    local: {
        script_id:               0,                     // not to change, will be change at runtime
        switchId:                0,                     // relay output id 0 or id 1
        ep_req_Gong_ON:          "Gong_ON",             // request to switch output ON
        ep_req_Gong_OFF:         "Gong_OFF",            // request to switch output OFF
        ep_req_Gong_unlocked:    "unlocked_tm",         // request to unlock output (optional tm in minutes)
        ep_req_Gong_locked:      "locked_tm",           // request to   lock output (optional tm in minutes)
        ep_req_Gong_status_en:   "status_en",           // request status in english
        ep_req_Gong_status_de:   "status_de",           // request status in german
        ep_req_replyStart:       "[",                   // highlight request command Start
        ep_req_replyEnd:         "]",                   // highlight request command End
        delimiter_timer:         ":",                   // delimiter of timer value
        timer_handler:           null,                  // handler variable of timer
        tms_shellyTimeEnd:       0,                     // calculated unixtime when timer ends
        endpoint_locked:         true,                  // problem that endpoint process is locked by an other request
        ctl_Gong_locked:         false                  // status if request to switch output is locked 
    }
}

// ****************************************************************************************
// ****************************************************************************************
// *******************************          DEBUG          ********************************
// ****************************************************************************************
// ****************************************************************************************

function fkt_debug_s0(to_print) {
    if (debug_step0 > 0) {
        print(to_print);
    }
};

function fkt_debug_s1(to_print) {
    if (debug_step1 > 0) {
        print(to_print);
    }
};

// ****************************************************************************************
// ****************************************************************************************
// *****************************          FUNCTION           ******************************
// ****************************************************************************************
// ****************************************************************************************

function fkt_calc_endtime(tm_timer) {
    let tms_shellyTimeCur = Shelly.getComponentStatus("sys").unixtime;
    fkt_debug_s1("tms_shellyTimeCur: " + tms_shellyTimeCur);
    CONFIG.local.tms_shellyTimeEnd = tms_shellyTimeCur + Math.round(tm_timer * 60);
}

function fkt_remaining_time() {
    let tms_shellyTimeCur = Shelly.getComponentStatus("sys").unixtime;
    let tms_newShellyTime = CONFIG.local.tms_shellyTimeEnd - tms_shellyTimeCur; 

    let t_hour = "00";
    let t_min = "00";
    let t_sec = "00";

    if (tms_newShellyTime > 0) {
        t_hour = t_hour + Math.floor(tms_newShellyTime / 3600);
        t_min = t_min + Math.floor(tms_newShellyTime / 60) % 60;
        t_sec = t_sec + (tms_newShellyTime % 60);
    }

    let retvalue = strRight(t_hour, 2) + ":" + strRight(t_min, 2) + ":" + strRight(t_sec, 2) + "  (hh:mm:ss)";
    fkt_debug_s1("remaining time: " + retvalue);
    return retvalue;
}

function fkt_send_response(response, strBody) {
    response.code = 200;
    response.body = strBody;
    response.send();
}

function fkt_check_Endpoint(request, response) {
    if (CONFIG.local.endpoint_locked) {
        fkt_debug_s1("fkt_check_Endpoint: locked");
        return;
    }
    else {
        fkt_debug_s1("fkt_check_Endpoint: not yet locked");

        let arrReqsplit = request.query.split(CONFIG.local.delimiter_timer);
        let strReply = CONFIG.local.ep_req_replyStart + request.query + CONFIG.local.ep_req_replyEnd + " ";

        switch (arrReqsplit[0]) {
            case CONFIG.local.ep_req_Gong_ON:
                fkt_Endpoint_Gong_ON_OFF(true, response, strReply);
                break;
            case CONFIG.local.ep_req_Gong_OFF:
                fkt_Endpoint_Gong_ON_OFF(false, response, strReply);
                break;
            case CONFIG.local.ep_req_Gong_unlocked:
                fkt_Endpoint_Gong_unlocked(arrReqsplit[1]);
                strReply = strReply + !CONFIG.local.ctl_Gong_locked;
                fkt_send_response(response, strReply);
                break;
            case CONFIG.local.ep_req_Gong_locked:
                fkt_Endpoint_Gong_locked(arrReqsplit[1]);
                strReply = strReply + CONFIG.local.ctl_Gong_locked;
                fkt_send_response(response, strReply);
                break;
            case CONFIG.local.ep_req_Gong_status_en:
                fkt_Endpoint_Gong_status(response, request.query, "en");
                break;
            case CONFIG.local.ep_req_Gong_status_de:
                fkt_Endpoint_Gong_status(response, request.query, "de");
                break;
        }
    }
};

function fkt_Endpoint_Gong_ON_OFF(booOutput, responseIN, strReply) {
    let strReturn = "data missing";

    if (CONFIG.local.endpoint_locked) {
        strReturn = "endpoint_locked";
        return strReturn;
    }
    CONFIG.local.endpoint_locked = true;

    if (CONFIG.local.ctl_Gong_locked === true) {
        fkt_debug_s1("fkt_Endpoint_Gong_ON_OFF: Gong control locked");
        strReturn = "Gong control locked"; 
        fkt_send_response(responseIN, (strReply + strReturn));
    }
    else {
        let arrUD = [responseIN, strReply, booOutput];

        let swRelay = {
            id: CONFIG.local.switchId,
            on: arrUD[2]
        };

        Shelly.call("Switch.Set", swRelay,
            function (response, error_code, error_message, ud) {
                fkt_debug_s1(JSON.stringify(response));
                let SW_Out = Shelly.getComponentStatus("switch", CONFIG.local.switchId).output
                if (ud[2] === false) {
                    SW_Out = !SW_Out;        // question is if out is off, means if .output is false then answere is true
                }
                fkt_send_response(ud[0], (ud[1] + SW_Out))
                },
                arrUD
        );
    }
    CONFIG.local.endpoint_locked = false;
    return strReturn;
}

function fkt_Endpoint_Gong_unlocked(minutes_till_out_be_locked) {
    if (CONFIG.local.endpoint_locked) {
        return;
    }
    CONFIG.local.endpoint_locked = true;

    fkt_unlock_ctl_out();

    Timer.clear(CONFIG.local.timer_handler);

    if (minutes_till_out_be_locked !== undefined) {
        fkt_calc_endtime(minutes_till_out_be_locked);
        let tms = minutes_till_out_be_locked * 60 * 1000;     // minutes in milliseconds
        CONFIG.local.timer_handler = Timer.set(tms, false, fkt_lock_ctl_out);
    }
    else {
        CONFIG.local.tms_shellyTimeEnd = 0;
    }

    CONFIG.local.endpoint_locked = false;
}

function fkt_Endpoint_Gong_locked(minutes_till_out_be_unlocked) {
    if (CONFIG.local.endpoint_locked) {
        return;
    }
    CONFIG.local.endpoint_locked = true;

    fkt_lock_ctl_out();

    Timer.clear(CONFIG.local.timer_handler);

    if (minutes_till_out_be_unlocked !== undefined) {
        fkt_calc_endtime(minutes_till_out_be_unlocked);
        let tms = minutes_till_out_be_unlocked * 60 * 1000;     // minutes in milliseconds
        CONFIG.local.timer_handler = Timer.set(tms, false, fkt_unlock_ctl_out);
    }
    else {
        CONFIG.local.tms_shellyTimeEnd = 0;
    }

    CONFIG.local.endpoint_locked = false;
}

function fkt_Endpoint_Gong_status(resp, requestquery, version) {
    if (CONFIG.local.endpoint_locked) {
        fkt_send_response(resp, requestquery);
        return;
    }
    CONFIG.local.endpoint_locked = true;

    let switchStatus = Shelly.getComponentStatus("switch", CONFIG.local.switchId).output;
    let strResp = "";
    let tm_remain_time = "00:00:00 (hh:mm:ss)";
    if (CONFIG.local.tms_shellyTimeEnd !== 0) {
        tm_remain_time = fkt_remaining_time();
    }

    switch (version) {
        case "en":
            strResp = "Request: " + CONFIG.local.ep_req_replyStart + requestquery + CONFIG.local.ep_req_replyEnd + vbLf +
                      "Relay output (Id:" + CONFIG.local.switchId + "): " + switchStatus + vbLf +
                      "Control relay locked: " + CONFIG.local.ctl_Gong_locked + vbLf +
                      "Remaining time: " + tm_remain_time;
            break;
        case "de":
            let strGongActivation = 'm' + chr(246) + 'glich';
            if (CONFIG.local.ctl_Gong_locked) strGongActivation = "blockiert";

            let strSwitchStatus = "ausgeschaltet";
            if (switchStatus) strSwitchStatus = "angeschaltet";

            strResp = "Gong Status: " + CONFIG.local.ep_req_replyStart + requestquery + CONFIG.local.ep_req_replyEnd + vbLf +
                      "Der Gong (Id:" + CONFIG.local.switchId + ") ist " + strSwitchStatus + vbLf +
                      "Die Gongaktivierung ist " + strGongActivation + vbLf +
                      "Restlaufzeit: " + tm_remain_time;
            break;
    }

    fkt_send_response(resp, strResp);

    CONFIG.local.endpoint_locked = false;
}

function fkt_lock_ctl_out() {
    CONFIG.local.ctl_Gong_locked = true;
    fkt_debug_s1("fkt_lock_ctl_out");
}

function fkt_unlock_ctl_out() {
    CONFIG.local.ctl_Gong_locked = false;
    fkt_debug_s1("fkt_unlock_ctl_out");
}

function fkt_get_own_ip() {
    //    fkt_debug_s0("get_own_ip");
    Shelly.call("WiFi.GetStatus", null, function (status) {
        strIP = status.sta_ip;
    });
}

function strRight(fulltext, numberChar) {
    let result = fulltext.substr(fulltext.length - numberChar, numberChar);
    return result
}

function fkt_start() {
    HTTPServer.registerEndpoint("Gong_ENDPOINT", fkt_check_Endpoint);
    CONFIG.local.script_id = Shelly.getCurrentScriptId();
    fkt_debug_s0("Your possible urls are:");
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_ON);
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_OFF);
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_unlocked);
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_unlocked + ":60");
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_locked);
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_locked + ":60");
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_status_en);
    fkt_debug_s0("http://" + strIP + "/script/" + CONFIG.local.script_id + "/Gong_ENDPOINT?" + CONFIG.local.ep_req_Gong_status_de);
    CONFIG.local.endpoint_locked = false;
}

print("start 'Control_Gong_v1.5' & debug_step0/debug_step1: " + debug_step0 + "/" + debug_step1);

fkt_get_own_ip();
Timer.set(1000, false, fkt_start);

var intervall = 60, //Humidity Checking Intervall, in Seconds
    remoteIP = "192.168.0.33", //Remote Shelly IP, as String
    BTH_H_id = "201", //BTHomeSensor-Id for humidity
    hum_delta_min = -20, //Hum_min negativ Delta, to turn on, 0 if not needed
    hum_delta_max = -5, //Hum_max postiv Delta, to turn off, 0 if not needed
    debug = true;
//Wenn die Luftfeuchtigkeit um einen gewissen Wert außen niedriger ist, wie in der Garage, soll das Relay des Shelly Plus 1 in der Garage geschlossen werden.
function Check_Loop(res) {
    try {
        if (res.code !== 200) return; //Exit if wrong Response
//        let extern_hum = Number(JSON.parse(res.body).rh); //Getting remote Humidity Value
        let extern_hum = Number(JSON.parse(res.body).value); //Getting remote Humidity Value from BTHomeSensor
        let intern_hum = Number(Status('Humidity', 100).rh); //Getting local Humidity Value
        let hum_Delta = extern_hum - intern_hum; //Calc hum Delta
        if (debug) print('Debug: Hum delta-->', hum_Delta, 'ext_h-->', extern_hum, 'int_h-->', intern_hum); //Debug output
        if (hum_delta_min && hum_Delta < hum_delta_min) Call("Switch.set", { id: 0, on: true }, null, null, debug); //Switching Relay Channed 0 on
        if (hum_delta_max && hum_Delta > hum_delta_max) Call("Switch.set", { id: 0, on: false }, null, null, debug); //Switching Relay Channel 0 off
    } catch (e) { ErrorMsg(e, 'Check_Loop()'); } //Error Handler
}

let tH1 = 0; //Timer Handler
function Main() {
    if (!tH1) Timer.set(1000 * intervall, true, function () { //Endless Loop
        Call("http.get", { url: "http://" + remoteIP + "/rpc/BTHomeSensor.GetStatus?id=" + BTH_H_id, timeout: 5 }, Check_Loop, null, debug); //Call Remote Shelly
//        Call("http.get", { url: "http://" + remoteIP + "/rpc/Humidity.GetStatus?id=100", timeout: 5 }, Check_Loop, null, debug); //Call Remote Shelly
    });
}

// Dekats Toolbox, a universal Toolbox for Shelly scripts
function ErrorChk(r, e, m, d) { //Shelly.call error check
    try {
        aC--; if (aC < 0) aC = 0;
        if (d.CB && d.uD) d.CB(r, d.uD); if (d.CB && !d.uD) d.CB(r);
        if (!d.CB && d.uD) print('Debug: ', d.uD); if (e) throw new Error(Str(m));
        if (Str(r) && Str(r.code) && r.code !== 200) throw new Error(Str(r));
    } catch (e) { ErrorMsg(e, 'ErrorChk(), call Answer'); }
}
function Cqueue() { //Shelly.call queue
    try {
        if (!cCache[0] && !nCall[0]) return;
        while (cCache[0] && aC < callLimit) {
            if (cCache[0] && !nCall[0]) { nCall = cCache[0]; cCache.splice(0, 1); }
            if (nCall[0] && aC < callLimit) { Call(nCall[0], nCall[1], nCall[2], nCall[3], nCall[4]); nCall = []; }
        } if (tH9) { Timer.clear(tH9); tH9 = 0; }
        if (nCall[0] || cCache[0]) if (cSp <= 0) cSp = 0.1; tH9 = Timer.set(1000 * cSp, 0, function () { tH9 = 0; Cqueue(); });
    } catch (e) { ErrorMsg(e, 'Cqueue()'); }
}
function Call(m, p, CB, uD, deBug) { //Upgrade Shelly.call
    try {
        let d = {};
        if (deBug) print('Debug: calling:', m, p); if (CB) d.CB = CB; if (Str(uD)) d.uD = uD; if (!m && CB) { CB(uD); return; }
        if (aC < callLimit) { aC++; Shelly.call(m, p, ErrorChk, d); } else if (cCache.length < cacheLimit) {
            cCache.push([m, p, CB, uD, deBug]); if (deBug) print('Debug: save call:', m, p, ', call queue now:', cCache.length); Cqueue();
        } else { throw new Error('to many Calls in use, droping call: ' + Str(m) + ', ' + Str(p)); }
    } catch (e) { ErrorMsg(e, 'Call()'); }
}
function Str(d) { //Upgrade JSON.stringify
    try {
        if (d === null || d === undefined) return null; if (typeof d === 'string') return d;
        return JSON.stringify(d);
    } catch (e) { ErrorMsg(e, 'Str()'); }
}
function Cut(f, k, o, i) { //Upgrade slice f=fullData, k=key-> where to cut, o=offset->offset behind key, i=invertCut
    try {
        let s = f.indexOf(k); if (s === -1) return; if (o) s = s + o.length || s + o; if (i) return f.slice(0, s);
        return f.slice(s);
    } catch (e) { ErrorMsg(e, 'Cut()'); }
}
function Setup() { //Wating 2sek, to avoid a Shelly FW Bug
    try {
        if (Main && !tH9) {
            tH9 = Timer.set(2000, 0, function () {
                print('\nStatus: started Script _[', scriptN, ']_');
                if (callLimit > 5) { callLimit = 5; } try { Main(); } catch (e) { ErrorMsg(e, 'Main()'); tH9 = 0; Setup(); }
            });
        }
    } catch (e) { ErrorMsg(e, 'Setup()'); }
}
function ErrorMsg(e, s, deBug) { //Toolbox formatted Error Msg
    try {
        let i = 0; if (Cut(e.message, '-104: Timed out')) i = 'wrong URL or device may be offline';
        if (s === 'Main()' || deBug) i = e.stack; if (Cut(e.message, '"Main" is not')) i = 'define a Main() function before using Setup()';
        print('Error:', s || "", '---> ', e.type, e.message); if (i) print('Info: maybe -->', i);
    } catch (e) { print('Error: ErrorMsg() --->', e); }
}
var tH8 = 0, tH9 = 0, aC = 0, cCache = [], nCall = [], callLimit = 5, cacheLimit = 40, cSp = 0.1; //Toolbox global variable
var Status = Shelly.getComponentStatus, Config = Shelly.getComponentConfig; //Renamed native function 
var info = Shelly.getDeviceInfo(), scriptID = Shelly.getCurrentScriptId(), scriptN = Config('script', scriptID).name; //Pseudo const, variabel
//Toolbox v3.5 -Alpha(cut), Shelly FW >1.0.8
Setup();

// Calculation_absolute_humidity_v1.1
// by PatrickR 
// 26.12.2024 
// 
// This script is calculating the absolute humidity
// This script is based on the script by Jan Nikolas Dicke
// https://www.jandicke.net/tools/ which is based on the blog by Peter Mander
// https://carnotcycle.wordpress.com/2012/08/04/how-to-convert-relative-humidity-to-absolute-humidity/
// 

// ****************************************************************************************
// ****************************************************************************************
// *******************************          GLOBAL          *******************************
// ****************************************************************************************
// ****************************************************************************************

let debug_step0 = 1;
let debug_step1 = 0;

//let vbCrLf = "\n\r";
//let vbLf = "\n";
//let vbTab = "\t";

// ****************************************************************************************
// ****************************************************************************************
// *******************************          CONFIG          *******************************
// ****************************************************************************************
// ****************************************************************************************

// ****************************************************************************************
// ****************************************************************************************
// *******************************          DEBUG          ********************************
// ****************************************************************************************
// ****************************************************************************************

function fkt_debug_s0(to_print) {
    if (debug_step0 > 0) {
        print(to_print);
    }
};

function fkt_debug_s1(to_print) {
    if (debug_step1 > 0) {
        print(to_print);
    }
};

// ****************************************************************************************
// ****************************************************************************************
// *****************************          FUNCTION           ******************************
// ****************************************************************************************
// ****************************************************************************************

function fkt_calc_airing(temp_in, relhum_in, temp_out, relhum_out) {
    let open_to_airing = 99; // error 

    if (relhum_in && relhum_out && temp_in && temp_out) {
        let abshum_in = fkt_calc_AbsHum(temp_in, relhum_in);       // absolute humidity inside
        let abshum_out = fkt_calc_AbsHum(temp_out, relhum_out);    // absolute humidity outside
        let abshum_diff = Math.abs(abshum_in - abshum_out);        // difference between inside to outside
        let abshum_diff_rnd = Math.round(abshum_diff * 100) / 100; // round 2 decimal places
        let result_info = "";
        if (abshum_diff < 1) {
            result_info = "does not change or only slightly";
            open_to_airing = 0;
        } else {
            if (abshum_in < abshum_out) {
                result_info = "rises about " + abshum_diff_rnd + "g/m³";
                open_to_airing = -1;
            }
            if (abshum_in > abshum_out) {
                result_info = "drops about " + abshum_diff_rnd + "g/m³";
                open_to_airing = 1;
            }
        }
        // result
        fkt_debug_s1("Information: The humidity inside " + result_info);
        fkt_debug_s1("Outside: absolute humidity: " + abshum_out + "g/m³.");
        fkt_debug_s1("Inside:  absolute humidity: " + abshum_in + "g/m³.");
    }
    return open_to_airing;
}

/* Calculation absolute humidity in g/m3 */
function fkt_calc_AbsHum(temp, relhum) {
    let cnt = 6.112 * Math.pow(Math.E, (17.67 * temp) / (temp + 243.5)) * relhum * 2.1674 / (273.15 + temp);
    let abshum = Math.round(cnt * 100) / 100; // round 2 decimal places
    return abshum;
}

// ****************************************************************************************
// ****************************************************************************************
// *****************************            END              ******************************
// ****************************************************************************************
// ****************************************************************************************

print("start 'Calculation_absolute_humidity_v1.1' & debug_step0/debug_step1/debug_step2: " + debug_step0 + "/" + debug_step1 + "/" + debug_step2);

let airing = 127;
// fkt_calc_result_info_airing(temp_in, relhum_in, temp_out, relhum_out);
airing = fkt_calc_airing(28.5, 60.5, 35.5, 30.5);
fkt_debug_s0("airing: " + airing);