VPN/Proxy erkannt
Es scheint, dass Sie einen VPN- oder Proxy-Dienst verwenden. Bitte beachten Sie, dass die Nutzung eines solchen Dienstes die Funktionalität dieser Webseite einschränken kann.
Beacon Modus wird auch in der BLE Debug App als off angezeigt. Hab's zur Sicherheit auch einmal hin und zurück geschaltet.
Mir ist aber aufgefallen, dass die Angaben zum BT Door in der BLE Debug App je nach BT Door device sehr unterschiedlich ausfallen. Schaut mal die Anzeige werte unten rechts im Bild....
(Der erste BT foor in der Auflistung ist der problematische...
Woher kommt das?
Was mach ich falsch?
Ich hatte am 17.juli die CR2032 in einem BT Door getauscht, und die ist gestern 27.juli nach nur 10 Tagen schon wieder leer.
Ich hatte mir einen Alarm eingerichtet, der mich informiert, wenn die Batterie unter 30% geht. Dieser Alarm kam in 1 Stunde rund 49x, obwohl die Tür in dieser Zeit nicht bewegt wurde.
Ich habe dann gesehen, dass in der App der "letzte (BT) Reporter" alle 15 sec einen Status des BT Door abgibt.
Der Beacon Modus ist aber nach Anzeige in der App nicht eingeschaltet !
Kurz danach war die Batterie leer.
A) Wie kann ich den Beacon Modus verlässlich ausschalten? Oder zumindest verläßlich kontrollieren, dass er wirklich aus ist?
B) kann die Anzahl der zugeordneten BT reporter Einfluß haben auf die Batterielebensdauer im BT Door ? Aus unklaren BT Funkverhältnissen hatte ich dem BT Door mehrere Shelly's in der Nähe als BT reporter Kontakte zugewiesen.
Das Schwimmer Signal muss ja nicht im Wasser abgegriffen werden. Sondern ein Schwimmer kann auch einen Schalter betätigen der außerhalb des Wassers ist.
Der Shelly 3EM saldiert die Phasen nicht unmittelbar, sondern zählt den Einspeisung und Verbrauch separat, wenn dies auf unterschiedlichen Phasen passiert.
Erst in der Raum History Ansicht kannst du auf netto Leistungssaldo umschalten. Was für die 24Std oder Tagesansicht einigermaßen passen mag.
Für den Saldo über mehrere Tage ist die Berechnung leider wieder Unfug. Jedenfalls nach meinem Verständnis im Vergleich mit einem korrekten Saldo auf einem Mechanischen Ferraris-Zähler.
thgoebel in deinem Bild ist ein Zwei-Wege-Mischer. Damit am warm plus Kaltwasseranschluss des WW Behälters wird Wasser aber nur gemischt, wenn auch gezapft wird.
Wenn ausschließlich die Zirkulationspumpe läuft, aber nicht gezapft wird, dann mischt der Zwei-Wege-Mischer nur den warmen und kalten Wasseranteil aus dem Boiler.
Das ist a) kontraproduktiv bei Solarthermiespeichern, weil es die Temperaturschichtung im Speicher durcheinander bringt und damit die Effizienz des Solarspeichers, und
b) wird dann, wenn der Speicher solarthermisch voll durcherhitzt ist, dgarnichts mehr gemischt, weil kein kaltes Wasser mehr im Speicher weilt, und somit maximal solar erhitztes Wasser mit zb. 85 Grad durch die Zirkulationsleitung bis zur Zapfstelle rauscht.
Da helfen dann unterTischmischer je Zapfstelle.
Oder ein Drei-Wege-Mischer am Boiler. Der stellt nögienfalls einen geschlossenen Zirkulationskreis mit WW Leitung, Zirkulationsleitung und Zirkulationspumpe her. Da wird dann bei Überhitzung eben nicht mehr gemischt, sondern das WW mit bestehender Wärme nur zirkuliert.
Hoffe ich hab's gut erklärt. Viele Installateure wissen das leider nicht. (Oder ich hatte nur mit solchen zu tun)
Wenn du den Ertrag der Balkonsolaranlage mit dem Shelly Plug misst, kannst du in der App/Cloud einen separaten Raum für diesen Shelly Plug erstellen und ihn Balkonsolar nennen
In der App/Cloud wird dir dann im Tab/Reiter "History" der Raum Balkonsolar angezeigt, mit den positiven und negativen verbrauchen/Erträgen separat.
Das sowohl im Tagesverlauf, wie auch als Tagessumme in der Wochen oder Monatsansicht.
Das sollte zu dem passen, was du brauchst.
Ich verstehe nur nicht, warum du den Shelly direkt am Schwimmer, nah am Wasser montiert hast. Den hättest du doch auch am oberen Ende vom mess-arm anbringen können. Der Winkel ist der selbe. Aber weiter weg vom Wasser.
Du kannst den mess-arm auch mit einem 90 Grad Winkel nach oben verlängern, in eine Zone die garantiert trocken bleibt. Der Winkel bleibt ja.
Und bin gespannt, wie lang die Batterie im beacon Modus durchhält.
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.
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....
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.
Hat schonmal jemand mitgezählt , wieviele "offen"+"geschlossen " Meldungen ein Blu Door Window mit einer Batterie schafft??
Sind ja diese üblichen CR2032 drin.
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)
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.
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.
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.
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
// #### 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();
});
}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
// #### 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();
});
}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).
tvbshelly da die skripte nicht mein geistiges Eigentum sind, muss ich das erst klären. Melde mich.
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.
Pro 3EM im Hausanschlusskasten. Der misst, ob du Solarstrom über hast, und kann dann andere Shellys ansteuern.