Beiträge von bp4willi

bp4willi

Zitat von charleswolff

War ich beim Kauf der Meinung, dass ich damit mein WLAN erweitern könnte...

Es war doch klar, das LoRa eine ganz andere Technik ist, und keine WLAN repeater Funktion.

Oder hattest du dich nur missverständlich ausgedrückt?

Natürlich kann LoRa dafür genutzt werden Shelly Bausteine anzusteuern, die außerhalb der WLAN Reichweite liegen. Das hat aber dann nichts mehr mit WLAN zu tun.

Ob der ferne LoRa-Shelly dann als Bluetooth oder WLAN Kontakt für weitere Shelly (und nur Shelly, keine anderen WLAN Clients) dienen kann, ist wohl noch nicht eruiert worden.

bp4willi

Meine Schätzung aufgrund persönlicher Nutzung und Batterieentleerung im Testobjekt, liegt bei ca 1000 Fensteröffnungen.

Was leider für meinen Anwendungsfall echt nicht viel ist.

Ich hätte mir das zehnfache erhofft.

Habe es denn eine Möglichkeit, die Anzahl der Meldevorgänge in einem Shelly zu zählen?

Da müsste ja ein Blu Door mit einem Shelly verknüpft werden, damit dieser per Skript in einem virtuellen counter zählen kann. Oder so....

bp4willi

Ich habe einen mechanischen End-taster gebastelt, der aktiviert wird , wenn das Garagentor zu ist.

Den habe ich mit dem SW Eingang des Shelly 1 Mini verbunden, der auch das Tor steuert. Der SW Eingang ist aber auf detached gestellt.

Jetzt zeigt mir der kleine rote oder grüne Strich im Button des Shelly Mini an (das ist die Anzeige des Eingangs Status), ob das Tor auf oder korrekt zu ist.

bp4willi

Hat schonmal jemand mitgezählt , wieviele "offen"+"geschlossen " Meldungen ein Blu Door Window mit einer Batterie schafft??

Sind ja diese üblichen CR2032 drin.

bp4willi

Ich würde davon abraten den Shelly Mini stromlos zu halten und nur zum schalten mit Strom zu versorgen. Das kann unschöne unerwartete Nebeneffekte haben.

Besser den Shelly Mini immer am Strom lassen, und nur den SW Eingang über Taster/Schalter schalten.

Für die Weiterleitung einer Aktion auf die Shelly PlugS, muss nicht einmal das Relais im Shelly Mini aktiviert werden.

Es reicht, den SW Eingang Status über die Aktion abzufragen und den SW Eingang im Shelly Mini auf detached zu stellen.

Der Eingangszustand SW am Mini dient dann einer Aktion im Shelly Mini als Trigger für die Aktivierung der Shelly Plug . (ohne dass das Relais im Mini Strom braucht)

bp4willi

Den Shelly Plug durch ein Shelly 1 oder 1PM ersetzen, und du kannst den Shelly direkt mit der schaltleitung vom Schwimmerschalter betätigen (abschalten).

Wenn der Schwimmerschalter den Pool nicht vollautomatisch selbsttätig nachfüllen soll, einfach den SW Eingang im Shelly auf detached stellen und die Steuerung über Aktionen oder Szenen definieren.

bp4willi

wie es im Foto den Anschein hat, sind 2 Niederspannungstaster der original-Steuerung durch Shelly zu ersetzen
(oder mit parallelen Shelly zur Steuerung zu nutzen),
dann brauchst du auch 2x Shelly 1 Gen 3 oder Gen4 .
Je Taster einen.

bp4willi

PS. Da sich Home und Remote Shelly , wenn sie zeitgleich senden ins Gehege kommen, haben wir in die Sendefunktion für Wiederholungen des Paket sendens, eine Zeitvariabilität eingebaut, dass die Wiederholungen zufällig im Range von 10 bis 20 Sekunden passieren, damit die Gegenstelle auch Zeit hat durchzukommen und ihr Sendepaket abzusetzen. Die Anzahl der Wiederholungen ("MAX_RETRIES") hatten wir in unserem Beipiel auf der Remote Seite auf 100 und auf der Home Seite auf 8 gesetzt. Bei einer stabilen Funkverbindung reichen vieleicht auch 4.

Aufgrund der vermuteten Begrenztheit der Shelly Kapazität, haben wir die Anzahl der parallel zum Versand anstehenden Texte/Befehle auf maximal 4 begrenzt ("MAX_CONCURRENT_CALLS = 4").
Sonst kommen sich die Sende-Wiederholungen und die Acknowledgements der Gegenseite ggf. zu sehr ins Gehege und blockieren sich dann gegenseitig. wir hatten festgestellt, dass ein Paket senden etwa 2-3 sekunden braucht.

bp4willi

Hier die von uns verwendeten LoRa Skripte auf der Home und Remote Seite.
Beide Seiten sind sowohl Sender, wie auch Empfänger.

Auf beiden Seiten werden im Shelly virtuelle Komponenten genutzt, als Mittler zwischen der LoRa-Funk-Welt und den Shelly Aktionen auf die physikalischen Shelly-Funktionen im Heimnetz.
Das versprach Flexibilität in der Anwendung, weil über LoRa beliebige Texte transportiert werden, die dann je nach definiertem Text, für jede Menge variabler Funktionen als Trigger dienen können, -- über ein einzelnes Text Ein- oder Ausgabefeld.
Es werden einfach die Texte in den Aktionen definiert, die gesendet werden, - oder die als Trigger für eine Aktion fungieren.
Im Beispiel geht es um die Fernalarmierung einer Statusänderung am Remote Shelly.
Durch den Home Shelly kann dann wiederum eine Aktion am Remote Shelly getriggert werden.

Home Shelly:
virtual Components:
button:200 , button:201 -- zur Steuerung einer Remote Komponente;
text:200 -- zur Darstellung empfangener (remote Shelly) Textnachricht auf dem Home Shelly
(z.B. Eingangs-Status remote Shelly)
number:200 , number:201 -- zur Darstellung des Packet transmission fail

Code: comms-LoRa-Home.js

// #### comms-LoRa-Home.js ####
// #### Shelly local input ####

let btnOff = Virtual.getHandle("button:200");
btnOff.on("single_push", function(ev) {
    console.log("Button OFF");
    sendPacket(PACKET_TYPE_COMMAND, "turn_alarm_off");
});

let btnOn = Virtual.getHandle("button:201");
btnOn.on("single_push", function(ev) {
    console.log("Button ON");
    sendPacket(PACKET_TYPE_COMMAND, "turn_alarm_on");
});

// #### Shelly local output ####

function onReceiveStatus(statusText) {
    let alarm = Virtual.getHandle("text:200");
    alarm.setValue(statusText);
}

function onReceiveCommand(commandText) {
  /* no-op */
}

// #### display count of unconfirmed transmissions ####

function onUpdatePaketsWaiting(count) {
    let number = Virtual.getHandle("number:200");
    number.setValue(count);
}

function onUpdatePacketsLost(count) {
    let number = Virtual.getHandle("number:201");
    number.setValue(count);
}

// #### Start of common script ####

const MAX_RETRIES = 8;
const MIN_RETRY_INTERVAL = 10000;
const MAX_RETRY_INTERVAL = 20000;
const MAX_CONCURRENT_CALLS = 4;

// #### encryption - decryption functions ####

const KEY_RAW = "<put your encryption key here>";

function keyFromHex(hex) {
    const buffer = new ArrayBuffer(hex.length / 2);
    for (let i = 0; i < hex.length; i += 2) {
        buffer[i / 2] = parseInt(hex.substr(i, 2), 16);
    }
    return buffer;
}

const KEY = keyFromHex(KEY_RAW);
const AES_MODE = "ECB";

function encrypt(plaintext, key) {
    //console.log("Encrypting: ", plaintext);
    
    function stringToBlockBuffer(string, blocksize) {
        let size = string.length;
        const lastBlock = string.length % blocksize;
        if (lastBlock > 0) {
            size += blocksize - lastBlock;
        }
        const buffer = new ArrayBuffer(size);
        let i = 0;
        for (; i < string.length; i++) {
            buffer[i] = string.charCodeAt(i);
        }
        for (; i < size; i++) {
            buffer[i] = 0;
        }
        return buffer;
    }

    return AES.encrypt(stringToBlockBuffer(plaintext, 16), key, { mode: AES_MODE });
}

function decrypt(cyphertext, key) {

    function bufferToString(buffer) {
        let string = '';
        for (let i = 0; i < buffer.length; i++) {
        const code = buffer[i];
        if (code == 0) continue;
            string += String.fromCharCode(buffer[i]);
        }
        return string;
    }

    const buffer = AES.decrypt(cyphertext, key, { mode: 'ECB' });
    if (!buffer || buffer.byteLength === 0) {
        console.log('Could not decrypt message');
        return;
    }
    return bufferToString(buffer);
}

function numberToHex(n, size) {
    let string = n.toString(16);
    while (string.length < size) {
        string = '0' + string;
    }
    return string.slice(-size);
}

function checksum(text, size) {
    let checksum = 0;
    for (let i = 0; i < text.length; i++) {
        checksum ^= text.charCodeAt(i);
    }
    return numberToHex(checksum , size);
}

// #### packet tracking functions ####

const CHECKSUM_SIZE = 4;
const PACKET_TYPE_SIZE = 1;
const PACKET_ID_SIZE = 2;

const PACKET_TYPE_STATUS = "S";
const PACKET_TYPE_COMMAND = "C";
const PACKET_TYPE_ACK = "A";

var checkAcknowledgementsTimer = undefined;

function generatePacket(type, id, text) {
    let packet = type + id + text;
    packet = checksum(packet, CHECKSUM_SIZE) + packet;
    return packet;
}

let nextPacketId = 0;

var receivedAcknowledgments = [ ];
var awaitsAcknowledgment = { };

function sendPacket(type, text) {
    const id = numberToHex(nextPacketId++, PACKET_ID_SIZE);
    const packet = generatePacket(type, id, text);
    awaitsAcknowledgment[id] = {
        "packet": packet,
        "retries": 0,
    };
    loraSend(packet);
    updatePacketsWaiting();
    setCheckAcknowledgementsTimer();
}

function sendAcknowledgment(id) {
    const packet = generatePacket(PACKET_TYPE_ACK, id, '');
    loraSend(packet);
}

function receivePacket(packet) {
    if (packet.length < CHECKSUM_SIZE + PACKET_TYPE_SIZE + PACKET_ID_SIZE) {
        console.log("Error: Packet too short");
        return;
    }
    
    const actualChecksum = packet.slice(0, CHECKSUM_SIZE);
    const afterChecksum = packet.slice(CHECKSUM_SIZE);
    const expectedChecksum = checksum(afterChecksum, CHECKSUM_SIZE);
    if (actualChecksum !== expectedChecksum) {
        console.log("Error: Checksum mismatch");
        return;
    }

    const packetType = afterChecksum.slice(0, PACKET_TYPE_SIZE);
    const packetId = afterChecksum.slice(PACKET_TYPE_SIZE, PACKET_TYPE_SIZE + PACKET_ID_SIZE);
    const text = afterChecksum.slice(PACKET_TYPE_SIZE + PACKET_ID_SIZE);
    console.log("Received {type:"+packetType+",id:"+packetId+",text:'"+text+"'}");

    switch (packetType) {
        case PACKET_TYPE_STATUS:
            onReceiveStatus(text);
            break;
        case PACKET_TYPE_COMMAND:
            onReceiveCommand(text);
            break;
        case PACKET_TYPE_ACK:
            console.log("Received acknowledgment for packet " + packetId);
            receivedAcknowledgments.push(packetId);
            delete awaitsAcknowledgment[packetId];
            updatePacketsWaiting();
            setCheckAcknowledgementsTimer();
            return;
        default:
            console.log("Error: Unknown packet type");
            return
    }
    sendAcknowledgment(packetId);
}


// #### LoRa send- receive functions ####

var concurrentCalls = 0;

function loraSend(packet) {
    console.log("Sending: ", packet);
    const encoded = btoa(encrypt(packet, KEY));
    if (concurrentCalls >= MAX_CONCURRENT_CALLS) {
        console.log("Error: Too many concurrent calls, skipping ...");
        return;
    }
    concurrentCalls++;
    Shelly.call(
        'Lora.SendBytes',
        { id: 100, data: encoded },
        function (_, err_code, err_msg) {
            if (err_code !== 0) {
                console.log('Error:', err_code, err_msg);
            }
            concurrentCalls--;
        }
    );
}

function loraReceive(data) {
    const packet = decrypt(atob(data), KEY);
    if (!packet) {
        return;
    }
    console.log("Received: ", packet);
    receivePacket(packet);
}

Shelly.addEventHandler(function (event) {
    if (
      typeof event !== 'object' ||
      event.name !== 'lora' ||
      !event.info ||
      !event.info.data
    ) {
      return;
    }
  
    loraReceive(event.info.data);
});

var totalPacketsLost = 0;

function updatePacketsWaiting() {
    onUpdatePaketsWaiting(Object.keys(awaitsAcknowledgment).length);
}

function updatePacketsLost() {
    updatePacketsWaiting();
    onUpdatePacketsLost(totalPacketsLost);
}

function checkAcknowledgements() {
    for (const id of receivedAcknowledgments) {
        delete awaitsAcknowledgment[id];
    }
    receivedAcknowledgments = [];

    const waiting = Object.keys(awaitsAcknowledgment);
    updatePacketsWaiting();
    if (waiting.length === 0) {
        console.log("No packets waiting");
        return;
    }

    for (const id of waiting) {
        const entry = awaitsAcknowledgment[id];
        if (entry.retries >= MAX_RETRIES) {
            console.log("Error: Packet " + id + " not acknowledged after " + MAX_RETRIES + " retries");
            delete awaitsAcknowledgment[id];
            totalPacketsLost++;
            onUpdatePacketsLost(totalPacketsLost);
            continue;
        }
        console.log("Retrying packet " + id + ", retries left: " + (MAX_RETRIES - entry.retries));
        entry.retries++;
        loraSend(entry.packet);
        anyRetry = true;
    }
    
    setCheckAcknowledgementsTimer();
}

function setCheckAcknowledgementsTimer() {
    if (checkAcknowledgementsTimer) {
        return;
    }

    const interval = MIN_RETRY_INTERVAL + Math.random() * (MAX_RETRY_INTERVAL - MIN_RETRY_INTERVAL);
    console.log("Setting timer to check acknowledgments in " + interval + " ms");
    checkAcknowledgementsTimer = Timer.set(interval, false, function() {
        checkAcknowledgementsTimer = undefined;
        checkAcknowledgements();
    });
}

Alles anzeigen

Remote Shelly:
virtual Components:
text:200 , text:201 -- zur Darstellung von zu sendenden (remote Shelly) oder empfangenen (Home Shelly) Textnachricht ;
(z.B. senden des remote Shelly Eingangs-Status ; Empfang des Kommandos vom Home Shelly)
number:200 , number:201 -- zur Darstellung des Packet transmission fail

Code: comms-Lora-Remote.js

// #### comms-Lora-Remote.js ####
// #### Shelly local input ####

let alarm = Virtual.getHandle("text:200");
alarm.on("change", function(ev) {
    console.log("Alarm changed: ", ev.value);
    sendPacket(PACKET_TYPE_STATUS, ev.value);
});

// #### Shelly local output ####

function onReceiveStatus(statusText) {
    /* no-op */
}

function onReceiveCommand(commandText) {
    let command = Virtual.getHandle("text:201");
    command.setValue(commandText);
}

// #### display count of unconfirmed transmissions ####

function onUpdatePaketsWaiting(count) {
    let number = Virtual.getHandle("number:200");
    number.setValue(count);
}

function onUpdatePacketsLost(count) {
    let number = Virtual.getHandle("number:201");
    number.setValue(count);
}

// #### Start of common script ####

const MAX_RETRIES = 100;
const MIN_RETRY_INTERVAL = 10000;
const MAX_RETRY_INTERVAL = 20000;
const MAX_CONCURRENT_CALLS = 4;

// #### encryption - decryption functions ####

const KEY_RAW = "<put your encryption key here>";

function keyFromHex(hex) {
    const buffer = new ArrayBuffer(hex.length / 2);
    for (let i = 0; i < hex.length; i += 2) {
        buffer[i / 2] = parseInt(hex.substr(i, 2), 16);
    }
    return buffer;
}

const KEY = keyFromHex(KEY_RAW);
const AES_MODE = "ECB";

function encrypt(plaintext, key) {
    //console.log("Encrypting: ", plaintext);
    
    function stringToBlockBuffer(string, blocksize) {
        let size = string.length;
        const lastBlock = string.length % blocksize;
        if (lastBlock > 0) {
            size += blocksize - lastBlock;
        }
        const buffer = new ArrayBuffer(size);
        let i = 0;
        for (; i < string.length; i++) {
            buffer[i] = string.charCodeAt(i);
        }
        for (; i < size; i++) {
            buffer[i] = 0;
        }
        return buffer;
    }

    return AES.encrypt(stringToBlockBuffer(plaintext, 16), key, { mode: AES_MODE });
}

function decrypt(cyphertext, key) {

    function bufferToString(buffer) {
        let string = '';
        for (let i = 0; i < buffer.length; i++) {
        const code = buffer[i];
        if (code == 0) continue;
            string += String.fromCharCode(buffer[i]);
        }
        return string;
    }

    const buffer = AES.decrypt(cyphertext, key, { mode: 'ECB' });
    if (!buffer || buffer.byteLength === 0) {
        console.log('Could not decrypt message');
        return;
    }
    return bufferToString(buffer);
}

function numberToHex(n, size) {
    let string = n.toString(16);
    while (string.length < size) {
        string = '0' + string;
    }
    return string.slice(-size);
}

function checksum(text, size) {
    let checksum = 0;
    for (let i = 0; i < text.length; i++) {
        checksum ^= text.charCodeAt(i);
    }
    return numberToHex(checksum , size);
}

// #### packet tracking functions ####

const CHECKSUM_SIZE = 4;
const PACKET_TYPE_SIZE = 1;
const PACKET_ID_SIZE = 2;

const PACKET_TYPE_STATUS = "S";
const PACKET_TYPE_COMMAND = "C";
const PACKET_TYPE_ACK = "A";

var checkAcknowledgementsTimer = undefined;

function generatePacket(type, id, text) {
    let packet = type + id + text;
    packet = checksum(packet, CHECKSUM_SIZE) + packet;
    return packet;
}

let nextPacketId = 0;

var receivedAcknowledgments = [ ];
var awaitsAcknowledgment = { };

function sendPacket(type, text) {
    const id = numberToHex(nextPacketId++, PACKET_ID_SIZE);
    const packet = generatePacket(type, id, text);
    awaitsAcknowledgment[id] = {
        "packet": packet,
        "retries": 0,
    };
    loraSend(packet);
    updatePacketsWaiting();
    setCheckAcknowledgementsTimer();
}

function sendAcknowledgment(id) {
    const packet = generatePacket(PACKET_TYPE_ACK, id, '');
    loraSend(packet);
}

function receivePacket(packet) {
    if (packet.length < CHECKSUM_SIZE + PACKET_TYPE_SIZE + PACKET_ID_SIZE) {
        console.log("Error: Packet too short");
        return;
    }
    
    const actualChecksum = packet.slice(0, CHECKSUM_SIZE);
    const afterChecksum = packet.slice(CHECKSUM_SIZE);
    const expectedChecksum = checksum(afterChecksum, CHECKSUM_SIZE);
    if (actualChecksum !== expectedChecksum) {
        console.log("Error: Checksum mismatch");
        return;
    }

    const packetType = afterChecksum.slice(0, PACKET_TYPE_SIZE);
    const packetId = afterChecksum.slice(PACKET_TYPE_SIZE, PACKET_TYPE_SIZE + PACKET_ID_SIZE);
    const text = afterChecksum.slice(PACKET_TYPE_SIZE + PACKET_ID_SIZE);
    console.log("Received {type:"+packetType+",id:"+packetId+",text:'"+text+"'}");

    switch (packetType) {
        case PACKET_TYPE_STATUS:
            onReceiveStatus(text);
            break;
        case PACKET_TYPE_COMMAND:
            onReceiveCommand(text);
            break;
        case PACKET_TYPE_ACK:
            console.log("Received acknowledgment for packet " + packetId);
            receivedAcknowledgments.push(packetId);
            delete awaitsAcknowledgment[packetId];
            updatePacketsWaiting();
            setCheckAcknowledgementsTimer();
            return;
        default:
            console.log("Error: Unknown packet type");
            return
    }
    sendAcknowledgment(packetId);
}

// #### LoRa send- receive functions ####

var concurrentCalls = 0;

function loraSend(packet) {
    console.log("Sending: ", packet);
    const encoded = btoa(encrypt(packet, KEY));
    if (concurrentCalls >= MAX_CONCURRENT_CALLS) {
        console.log("Error: Too many concurrent calls, skipping ...");
        return;
    }
    concurrentCalls++;
    Shelly.call(
        'Lora.SendBytes',
        { id: 100, data: encoded },
        function (_, err_code, err_msg) {
            if (err_code !== 0) {
                console.log('Error:', err_code, err_msg);
            }
            concurrentCalls--;
        }
    );
}

function loraReceive(data) {
    const packet = decrypt(atob(data), KEY);
    if (!packet) {
        return;
    }
    console.log("Received: ", packet);
    receivePacket(packet);
}

Shelly.addEventHandler(function (event) {
    if (
      typeof event !== 'object' ||
      event.name !== 'lora' ||
      !event.info ||
      !event.info.data
    ) {
      return;
    }
  
    loraReceive(event.info.data);
});

var totalPacketsLost = 0;

function updatePacketsWaiting() {
    onUpdatePaketsWaiting(Object.keys(awaitsAcknowledgment).length);
}

function updatePacketsLost() {
    updatePacketsWaiting();
    onUpdatePacketsLost(totalPacketsLost);
}

function checkAcknowledgements() {
    for (const id of receivedAcknowledgments) {
        delete awaitsAcknowledgment[id];
    }
    receivedAcknowledgments = [];

    const waiting = Object.keys(awaitsAcknowledgment);
    updatePacketsWaiting();
    if (waiting.length === 0) {
        console.log("No packets waiting");
        return;
    }

    for (const id of waiting) {
        const entry = awaitsAcknowledgment[id];
        if (entry.retries >= MAX_RETRIES) {
            console.log("Error: Packet " + id + " not acknowledged after " + MAX_RETRIES + " retries");
            delete awaitsAcknowledgment[id];
            totalPacketsLost++;
            onUpdatePacketsLost(totalPacketsLost);
            continue;
        }
        console.log("Retrying packet " + id + ", retries left: " + (MAX_RETRIES - entry.retries));
        entry.retries++;
        loraSend(entry.packet);
        anyRetry = true;
    }
    
    setCheckAcknowledgementsTimer();
}

function setCheckAcknowledgementsTimer() {
    if (checkAcknowledgementsTimer) {
        return;
    }

    const interval = MIN_RETRY_INTERVAL + Math.random() * (MAX_RETRY_INTERVAL - MIN_RETRY_INTERVAL);
    console.log("Setting timer to check acknowledgments in " + interval + " ms");
    checkAcknowledgementsTimer = Timer.set(interval, false, function() {
        checkAcknowledgementsTimer = undefined;
        checkAcknowledgements();
    });
}

Alles anzeigen

Für die Encryption muss bitte jeder seinen eigenen persönlichen encryption key definieren (lange Zeichen+Ziffernfolge), und an der Skriptstelle KEY_RAW zwischen den Gänsefüßchen einfügen.

Wir hoffen, dass dies hilfreich ist für neue LoRa Projekte.

Mit Reichweiten-Test bin ich noch nicht weitergekommen.
Die bisherigen Ergebnisse waren ernüchternd, und eher im Range von 500m (und nicht 5km).

bp4willi

tvbshelly da die skripte nicht mein geistiges Eigentum sind, muss ich das erst klären. Melde mich.

bp4willi

Habe dieses WE die LoRa module mit zwei Shelly1 Gen3 getestet. Mein Informatik talentierter Sohn hat mit den Skripten geholfen.

Basierend auf den Beispiel-Skripten zum encrypted send und Receiver, haben wir erst eine Methode über virtuelle Komponenten als Mittler entwickelt.

Da LoRa ja Text überträgt, haben den Shellys virtuelle Textfelder hinzugefügt. Über Texte die man dort über Kommandos in Aktionen, Szenen oder rpc calls einträgt, kann die LoRa Übertragung getriggert werden. Und die Texte können als Kommandos auf der Empfangsseite genutzt werden.

Damit haben wir dann die Reichweite getestet. Weiter als 500m sind wir noch nicht gekommen. Standen aber Gebäude und natürlich die Fensterscheibe dazwischen.

Außerdem war dann der Signalempfang, und entsrechende Schaltvorgänge nicht zuverlässig.

Da von Hause aus kein automatischer Rückkanal mit Acknowledge vorgesehen ist,

hat mein Sohn encrypted send und receive in einem Skript kombiniert und mit einem Paket Tracking und einer automatischen Sendewiederholung programmiert. Das ganze wird über counter als virtuelle Komponenten dokumentiert. Paket acknowledgement pending, und paket acknowledge failed, nachdem die einstellbare Zahl an re-tries nicht erfolgreich zu einem Acknowledge des Empfängers führte.

Damit will ich demnächst neue mobile Reichweiten Tests ausführen.

bp4willi

Pro 3EM im Hausanschlusskasten. Der misst, ob du Solarstrom über hast, und kann dann andere Shellys ansteuern.

bp4willi

tvbshelly hätte dann nicht für den 1Mini Gen4 in der Bedienungsanleitung der Hinweis auf SELV/PELV auch drin sein müssen, so wie in der Anleitung zum 1Mini Gen3 ??

bp4willi

Zitat von funkenwerner

siehe Potentialfreier Schaltausgang Shelly 1 / PLUS 1 / PLUS 1 Mini

funkenwerner die Antwort hat keinen hinreichenden Bezug zu meiner Frage. Es geht um 1Mini Gen4

bp4willi

Hi,

In der Anleitung vom 1 Mini Gen3 stand noch der Hinweis, dass keine SELV/PELV Kleinspannungskomponenten an die Lastanschlüsse angeschl ssen werden dürfen.

In der Anleitung zum 1 Mini Gen4 fehlt dieser Hinweis.

Heißt das, dass der Mini Gen4 so konstruktiv optimiert wurde, dass die nötigen Abstände der Leiterbahnen im Gerät eingehalten werden, und SELV/PELV Geräte sicher damit betrieben werden können ??

bp4willi

Ok, da liegt ein Missverständnis vor.

Zuerst war die Spannungsversorgung des Mini1 an den Ausgang des Mini1PM angeschlossen. Hat sich nicht bewährt, da der Mini1PM zu häufig geschaltet hat (weil in Aktionen keine Zeitsperre haben) und der nachrangige Mini1 deshalb in den Anlernmodus ging.

Danach hatte ich den Mini1 direkt an der Phase für die Stromversorgung, und der Ausgang des Mini1PM hat den SW Eingang des Mini1 angesteuert. (Detached mode) Gleichzeitig war der Ausgang des Mini1PM parallel über den NTC mit dem Ladegerät verbunden. Das hat sich auch nicht bewährt, weil anscheinend Spannung der Eingangsstufe des Ladegerätes auf den SW Eingang des Mini1 rückgewirkt hat. Der Mini1 Eingang blieb "grün" und das Relais eingeschaltet.

Deshalb in letzter Konsequenz die physikalische Kopplung der Mini1PM und Mini1 gekappt, und die Ansteuerung des Mini1 durch den Mini1PM nur durch eine Aktion realisiert. Das funktioniert bisher verlässlich.

Ich hoffe das klärt es hinreichend.

bp4willi

An dem Mini1 gibt es dank NTC keinen hohen Einschaltstrom und wenn nur der Kontakt geklebt hätte wäre der Shelly nicht als aktiviert/"on" in der App angezeigt worden.

Spannung am SW Eingang des Mini1 hab ich zu dem Zeitpunkt nicht gemessen.

Ohne angeschlossenes Ladegerät haben beide Shelly Mini ordnungsgemäß geschaltet.

bp4willi

Zitat von bp4willi

Hinter den Shelly mini 1PM Gen3, der eigentlich das Ladegerät einschaltet, habe ich an den Lastausgang
einen Shelly mini 1 Gen3 angeschlossen, den ich so konfiguriert habe, dass er automatisch nach 1sec einschaltet, sobald er mit Strom versorgt wird (vom 1PM). Der Shelly mini 1 braucht also nur Strom (Verlustleistung 0,6W), wenn der Shelly mini 1PM eingeschaltet ist.

Das hat sich leider nicht bewährt. In Konstellation mit Aktionen können die Shelly ja unverzögert hin und her schalten, je nach erfüllter Bedingung.

Der Mini 1PM hat heute wohl den Mini 1 mehr als 4x in einer Minute mit Strom versorgt und wieder ausgeschaltet. Das hat dazu geführt, dass der Mini1 wieder in den Anlernmodus gegangen ist (rote LED blinkt) und gar nichts mehr geschaltet hat.

Mal wieder eine neue Shelly (un)Funktion gelernt, die nicht im Handbuch/Beipackzettel steht.

(Doof. Es gibt doch den Resettaster)

Habe jetzt umverkabelt. Sowohl Mini1PM und nachgeschalteter Mini1 sind jetzt permanent am Strom.

Verzögerte Aktivierung und sofortige Deaktivierung des Mini1 durch den Mini1PM über Aktionen. Nicht über die Steuerleitung des Mini1.

Denn die Eingangskondensatoren des nachgeschalteten Ladegerätes haben über den durchgeschalteten Mini1 Relaiskontakt auch den SW Eingang des Mini1 auf "on" gehalten. Der schaltete gar nicht mehr ab. Auch als detached Eingang nicht.

Bei den Shellys muss man schon ziemlich um die Ecke denken, um das Geraffel ans laufen zu bringen.

bp4willi

crazyman69 ja , leider geht das nur mit Szenen via Cloud, also mit Internetverbindung (und funktionierendem Server in Bulgarien).

Mit lokalen Aktionen geht das nicht. Da können die Shellys wild hin und her schalten, da sie sich direkt über http Befehle ansprechen. Und im http Befehlssortiment ist keine Funktion implementiert, die für eine definierte Zeit nachfolgende Befehle ignorieren würde.

Das wäre echt hilfreich für viele Anwendungen und zu schön um wahr zu sein.

bp4willi

Der Inhalt kann nicht angezeigt werden, da Sie keine Berechtigung haben, diesen Inhalt zu sehen.

Beiträge von bp4willi

Einrichtung lora addon

Blu Door Window - wieviele "offen" Meldungen mit einer CR2032

Zustandstsanzeige Garagentor

Blu Door Window - wieviele "offen" Meldungen mit einer CR2032

Hilfe bei Einrichtung einer Aktion

Ich brauch eine Anzeige, ob ein Kontakt geschlossen ist doer nicht

Garagentor - welcher Shelly und wie verdrahtet?

Einrichtung lora addon

Einrichtung lora addon

Einrichtung lora addon

Einrichtung lora addon

Shelly schalten bei Solarüberschuss

1 Mini Gen4 SELV/PELV konform??

1 Mini Gen4 SELV/PELV konform??

1 Mini Gen4 SELV/PELV konform??

Sicherung fliegt, wenn Shelly ein Ladegerät häufig ein/aus schaltet

Sicherung fliegt, wenn Shelly ein Ladegerät häufig ein/aus schaltet

Sicherung fliegt, wenn Shelly ein Ladegerät häufig ein/aus schaltet

Aktionen -Mindestintervall für aufeinanderfolgende Aufrufe

Shelly plus Uni Voltmeter Anzeige mit 2 Nachkommastellen