Manufacturer:
Type:
Protocoll:
Devicename:
Model_nr:
Version_nr:
Version_info:
Version_timestamp
Release:
ID
Min_mygekko_version:
Function_type:
Progress_state:

Description (HTML)

<p>With this DDF, Shelly devices with a LoRa add-on can be integrated, allowing one input and one output to be used in each case. Note: Please observe the regionally applicable regulations for LoRa usage. A Shelly with a LoRa add-on is operated in the same IP network as the myGEKKO controller. It serves as a <strong>LoRa master gateway</strong> and communicates with other Shelly devices (slaves) via LoRa.</p>

<p>Connect to the Wi-Fi access point of the Shelly via <code>192.168.33.1</code>, then connect it to your Wi-Fi and perform a firmware update if necessary. Tested with 2.0.0-beta1, add-on 2.1.1.</p>

<h3>Shelly Master (Gateway in Wi-Fi)</h3>
<ul>
  <li>Create and activate script <code>lora_master.js</code></li>
  <li>Enable "Run on startup"</li>
  <li>Activate LoRa add-on, configuration must be identical on all Shellys!</li>
  <li>LoRa transport layer Device Address: <code>0001</code> (HEX)</li>
  <li>Generate and note down the Cryptography-Key</li>
  <li>Enable "User LoRa calls"</li>
</ul>

<details>
  <summary>Script Code: lora_master.js</summary>
<pre><code class="language-javascript">let lastByAddr = {};

function nowIso() {
  return new Date().toISOString();
}

function nowUnix() {
  return Math.floor(Date.now() / 1000);
}

// Shelly-safe Query Parser (NO decodeURIComponent!)
function parseQuery(qs) {
  let out = {};

  if (!qs) return out;

  let parts = qs.split("&");

  for (let i = 0; i < parts.length; i++) {
    let kv = parts[i].split("=");

    let key = kv[0];
    let val = kv.length > 1 ? kv[1] : "";

    if (key) out[key] = val;
  }

  return out;
}

Shelly.addEventHandler(function (ev) {
  if (!ev || !ev.info) return;

  let addr = ev.info.lr_addr || ev.info.addr || ev.info.sender;
  let data = ev.info.data;

  if (addr === undefined || data === undefined) return;

  addr = String(addr);

  try {
    data = JSON.parse(atob(String(data)));
  } catch (e) {
    try {
      data = atob(String(data));
    } catch (e2) {
      data = String(data);
    }
  }

  lastByAddr[addr] = {
    addr: addr,
    data: data,
    rssi: ev.info.rssi,
    snr: ev.info.snr,
    received: nowIso(),
    received_unix: nowUnix()
  };

  print("LoRa received: " + addr);
});

HTTPServer.registerEndpoint("lora", function (req, res) {
  let query = parseQuery(req.query);
  let addr = query.addr;

  if (!addr) {
    res.code = 400;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "addr missing" });
    res.send();
    return;
  }

  let result = lastByAddr[String(addr)];

  if (!result) {
    res.code = 404;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "not found", addr: addr });
    res.send();
    return;
  }

  res.code = 200;
  res.headers = [["Content-Type", "application/json"]];
  res.body = JSON.stringify(result);
  res.send();
});

print("Endpoint active: /script/<id>/lora?addr=<addr>");
</code></pre>
</details>

<h3>Shelly Slave (LoRa End Devices)</h3>
<ul>
  <li>Create and activate script <code>lora_slave.js</code></li>
  <li>Enable "Run on startup"</li>
  <li>LoRa transport layer Device Address:
    <ul>
      <li><code>0002</code> (HEX) &ndash; first device</li>
      <li><code>0003</code> to <code>000F</code> (HEX) &ndash; additional slaves</li>
    </ul>
  </li>
  <li>Insert Cryptography-Key from the Master</li>
  <li>Enable "User LoRa calls"</li>
</ul>

<details>
  <summary>Script Code: lora_slave.js</summary>
<pre><code class="language-javascript">let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let di = 0;
let doo = 0;
let last = "";

function send(force) {
  // Send status as array
  let msg = JSON.stringify([di, doo]);

  if (!force && msg === last) return;
  last = msg;

  console.log("SENDING:", msg);

  Shelly.call("LoRa.Send", {
    id: LORA_ID,
    lr_addr: LORA_ADDR,
    data: btoa(msg)
  }, function (res, err, msg) {
    if (err !== 0) {
      console.log("LoRa Error:", err, msg);
    }
  });
}

function startPeriodicSend() {
  // a status heartbeat every 15 minutes
  Timer.set(15 * 60 * 1000, true, function () {
    send(true);
  });
}

function handleCommand(rawPayload) {
  let payload = rawPayload;

  // If data arrives base64 encoded, decode it
  try {
    payload = atob(rawPayload);
  } catch (e) {
    // if not base64, use rawPayload directly
  }

  console.log("LoRa RX raw:", rawPayload, "decoded:", payload);

  if (payload === "1" || payload === "ON" || payload === "true") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: true }, function (res, err, msg) {
      console.log("Switch.Set ON -> err:", err, "msg:", msg);
    });
  } else if (payload === "0" || payload === "OFF" || payload === "false") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: false }, function (res, err, msg) {
      console.log("Switch.Set OFF -> err:", err, "msg:", msg);
    });
  } else {
    console.log("Unknown payload:", payload);
  }
}

Shelly.addEventHandler(function (ev) {
  if (ev.name !== "lora") return;
  if (!ev.info) return;

  if (ev.info.component !== "lora:100") return;
  if (ev.info.event !== "user_rx") return;

  handleCommand(ev.info.data);
});

Shelly.addStatusHandler(function (e) {
  if (!e || !e.component || !e.delta) return;

  if (e.component === "input:0" && e.delta.state !== undefined) {
    di = e.delta.state ? 1 : 0;
    send(false);
  }

  if (e.component === "switch:0" && e.delta.output !== undefined) {
    doo = e.delta.output ? 1 : 0;
    send(false);
  }
});

// one-time random startup delay
var startDelay = Math.floor(Math.random() * 15 * 60 * 1000);
console.log("Starting in", startDelay, "ms");

Timer.set(startDelay, false, function () {
  send(true);
  startPeriodicSend();
});

console.log("LoRa combo script started");
</code></pre>
</details>

<h3>DeviceStation</h3>
<ul>
  <li>Domain: <code>http://&lt;IP_Shelly_Master&gt;</code></li>
  <li>Slave addresses: <code>1,2, ... ,15</code></li>
</ul>

<h3>"Device" System</h3>
<ul>
  <li>Create one block per Shelly and select Dashboard</li>
  <li>Link as widgets on the homepage or rooms/areas</li>
</ul>

<h3>"Light" or "Socket" System</h3>
<ul>
  <li>Switching output: <code>SET Output</code></li>
  <li>Feedback: <code>State Output</code></li>
</ul>

<div style="padding:10px; border-left:4px solid #f39c12; background:#fff8e6; margin:10px 0;">
  <strong>To Do:</strong> The current slave script does not use a send queue. In case of rapid status changes, multiple <code>LoRa.Send</code> calls can be started simultaneously, which can cause the Shelly error <code>Too many calls in progress</code>. It is recommended to implement a busy-flag or queue/debounce logic so that only one LoRa transmission process is active at a time.
</div>

<details>
  <summary>Script code with queue and sequential input, output: lora_slave_queue.js</summary>
<pre><code class="language-javascript">
let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let LORA_SEND_GAP_MS = 2000;

let di = 0;
let doo = 0;

let loraBusy = false;
let sendQueue = [];
let queuePos = 0;

let lastSent = "";
let lastQueued = "";
let nextSendAllowedAt = 0;

let retryTimerActive = false;

function getNowMs() {
  return Shelly.getUptimeMs();
}

function enqueueSend(force) {
  let msg = JSON.stringify([di, doo]);

  if (!force && msg === lastQueued) {
    return;
  }

  if (!force &&
      msg === lastSent &&
      queuePos >= sendQueue.length &&
      !loraBusy) {
    return;
  }

  sendQueue.push({
    msg: msg,
    force: force
  });

  lastQueued = msg;
  processSendQueue();
}

function processSendQueue() {
  if (loraBusy) {
    return;
  }

  if (queuePos >= sendQueue.length) {
    sendQueue = [];
    queuePos = 0;
    lastQueued = lastSent;
    return;
  }

  let now = getNowMs();

  if (now < nextSendAllowedAt) {
    if (!retryTimerActive) {
      retryTimerActive = true;
      Timer.set(nextSendAllowedAt - now, false, function () {
        retryTimerActive = false;
        processSendQueue();
      });
    }
    return;
  }

  let item = sendQueue[queuePos];
  queuePos++;

  loraBusy = true;
  lastSent = item.msg;

  console.log("SENDING:", item.msg, item.force ? "(force)" : "");

  Shelly.call("LoRa.Send", {
    id: LORA_ID,
    lr_addr: LORA_ADDR,
    data: btoa(item.msg)
  }, function (res, err, errmsg) {
    if (err !== 0) {
      console.log("LoRa Error:", err, errmsg);
    }

    nextSendAllowedAt = getNowMs() + LORA_SEND_GAP_MS;
    loraBusy = false;

    processSendQueue();
  });
}

function startPeriodicSend() {
  Timer.set(15 * 60 * 1000, true, function () {
    enqueueSend(true);
  });
}

function handleCommand(rawPayload) {
  let payload = rawPayload;

  try {
    payload = atob(rawPayload);
  } catch (e) {
    // use rawPayload directly
  }

  console.log("LoRa RX raw:", rawPayload, "decoded:", payload);

  if (payload === "1" || payload === "ON" || payload === "true") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: true }, function (res, err, msg) {
      console.log("Switch.Set ON -> err:", err, "msg:", msg);
    });
  } else if (payload === "0" || payload === "OFF" || payload === "false") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: false }, function (res, err, msg) {
      console.log("Switch.Set OFF -> err:", err, "msg:", msg);
    });
  } else {
    console.log("Unknown payload:", payload);
  }
}

Shelly.addEventHandler(function (ev) {
  if (ev.name !== "lora") return;
  if (!ev.info) return;

  if (ev.info.component !== "lora:100") return;
  if (ev.info.event !== "user_rx") return;

  handleCommand(ev.info.data);
});

Shelly.addStatusHandler(function (e) {
  if (!e || !e.component || !e.delta) return;

  if (e.component === "input:0" && e.delta.state !== undefined) {
    di = e.delta.state ? 1 : 0;
    enqueueSend(false);
  }

  if (e.component === "switch:0" && e.delta.output !== undefined) {
    doo = e.delta.output ? 1 : 0;
    enqueueSend(false);
  }
});

var startDelay = Math.floor(Math.random() * 15 * 60 * 1000);
console.log("Starting in", startDelay, "ms");

Timer.set(startDelay, false, function () {
  enqueueSend(true);
  startPeriodicSend();
});
</code></pre>
</details>

Description (DE)

<p>Mit diesem DDF können Shelly-Geräte mit LoRa-Addon eingebunden werden, wobei jeweils ein Ein- und Ausgang genutzt werden kann. Hinweis: Beachten Sie die regional geltenden Vorschriften zur LoRa-Nutzung. Ein Shelly mit LoRa-Addon wird im selben IP-Netzwerk wie der myGEKKO-Controller betrieben. Er dient als <strong>LoRa-Master-Gateway</strong> und kommuniziert mit weiteren Shelly-Geräten (Slaves) über LoRa.</p>

<p>Verbinden Sie sich über <code>192.168.33.1</code> mit dem WLAN-Access-Point des Shelly, verbinden Sie ihn anschließend mit dem WLAN und führen Sie bei Bedarf ein Firmware-Update durch. Getestet mit 2.0.0-beta1, Add-on 2.1.1.</p>

<h3>Shelly Master (Gateway im WLAN)</h3>
<ul>
  <li>Script <code>lora_master.js</code> erstellen und aktivieren</li>
  <li>Run on startup aktivieren</li>
  <li>LoRa Add-on aktivieren, Config muss bei alles Shellys identisch sein!</li>
  <li>LoRa transport layer Device Address: <code>0001</code> (HEX)</li>
  <li>Cryptography-Key generieren und notieren</li>
  <li>User LoRa calls aktivieren</li>
</ul>

<details>
  <summary>Skript-Code: lora_master.js</summary>
<pre><code class="language-javascript">let lastByAddr = {};

function nowIso() {
  return new Date().toISOString();
}

function nowUnix() {
  return Math.floor(Date.now() / 1000);
}

// Shelly-safe Query Parser (KEIN decodeURIComponent!)
function parseQuery(qs) {
  let out = {};

  if (!qs) return out;

  let parts = qs.split("&");

  for (let i = 0; i < parts.length; i++) {
    let kv = parts[i].split("=");

    let key = kv[0];
    let val = kv.length > 1 ? kv[1] : "";

    if (key) out[key] = val;
  }

  return out;
}

Shelly.addEventHandler(function (ev) {
  if (!ev || !ev.info) return;

  let addr = ev.info.lr_addr || ev.info.addr || ev.info.sender;
  let data = ev.info.data;

  if (addr === undefined || data === undefined) return;

  addr = String(addr);

  try {
    data = JSON.parse(atob(String(data)));
  } catch (e) {
    try {
      data = atob(String(data));
    } catch (e2) {
      data = String(data);
    }
  }

  lastByAddr[addr] = {
    addr: addr,
    data: data,
    rssi: ev.info.rssi,
    snr: ev.info.snr,
    received: nowIso(),
    received_unix: nowUnix()
  };

  print("LoRa empfangen: " + addr);
});

HTTPServer.registerEndpoint("lora", function (req, res) {
  let query = parseQuery(req.query);
  let addr = query.addr;

  if (!addr) {
    res.code = 400;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "addr fehlt" });
    res.send();
    return;
  }

  let result = lastByAddr[String(addr)];

  if (!result) {
    res.code = 404;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "nicht gefunden", addr: addr });
    res.send();
    return;
  }

  res.code = 200;
  res.headers = [["Content-Type", "application/json"]];
  res.body = JSON.stringify(result);
  res.send();
});

print("Endpunkt aktiv: /script/<id>/lora?addr=<addr>");
</code></pre>
</details>

<h3>Shelly Slave (LoRa Endgeräte)</h3>
<ul>
  <li>Script <code>lora_slave.js</code> erstellen und aktivieren</li>
  <li>Run on startup aktivieren</li>
  <li>LoRa transport layer Device Address:
    <ul>
      <li><code>0002</code> (HEX) &ndash; erstes Gerät</li>
      <li><code>0003</code> bis <code>000F</code> (HEX) &ndash; weitere Slaves</li>
    </ul>
  </li>
  <li>Cryptography-Key vom Master einfügen</li>
  <li>User LoRa calls aktivieren</li>
</ul>

<details>
  <summary>Skript-Code: lora_slave.js</summary>
<pre><code class="language-javascript">let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let di = 0;
let doo = 0;
let last = "";

function send(force) {
  // Status als Array senden
  let msg = JSON.stringify([di, doo]);

  if (!force && msg === last) return;
  last = msg;

  console.log("SENDE:", msg);

  Shelly.call("LoRa.Send", {
    id: LORA_ID,
    lr_addr: LORA_ADDR,
    data: btoa(msg)
  }, function (res, err, msg) {
    if (err !== 0) {
      console.log("LoRa Fehler:", err, msg);
    }
  });
}

function startPeriodicSend() {
  // alle 15 Minuten ein Status-Heartbeat
  Timer.set(15 * 60 * 1000, true, function () {
    send(true);
  });
}

function handleCommand(rawPayload) {
  let payload = rawPayload;

  // Falls data base64-kodiert ankommt, dekodieren
  try {
    payload = atob(rawPayload);
  } catch (e) {
    // wenn nicht base64, dann rawPayload direkt verwenden
  }

  console.log("LoRa RX raw:", rawPayload, "decoded:", payload);

  if (payload === "1" || payload === "ON" || payload === "true") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: true }, function (res, err, msg) {
      console.log("Switch.Set ON -> err:", err, "msg:", msg);
    });
  } else if (payload === "0" || payload === "OFF" || payload === "false") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: false }, function (res, err, msg) {
      console.log("Switch.Set OFF -> err:", err, "msg:", msg);
    });
  } else {
    console.log("Unbekannter Payload:", payload);
  }
}

Shelly.addEventHandler(function (ev) {
  if (ev.name !== "lora") return;
  if (!ev.info) return;

  if (ev.info.component !== "lora:100") return;
  if (ev.info.event !== "user_rx") return;

  handleCommand(ev.info.data);
});

Shelly.addStatusHandler(function (e) {
  if (!e || !e.component || !e.delta) return;

  if (e.component === "input:0" && e.delta.state !== undefined) {
    di = e.delta.state ? 1 : 0;
    send(false);
  }

  if (e.component === "switch:0" && e.delta.output !== undefined) {
    doo = e.delta.output ? 1 : 0;
    send(false);
  }
});

// einmaliger zufälliger Startversatz
var startDelay = Math.floor(Math.random() * 15 * 60 * 1000);
console.log("Start in", startDelay, "ms");

Timer.set(startDelay, false, function () {
  send(true);
  startPeriodicSend();
});

console.log("LoRa Kombi-Skript gestartet");
</code></pre>
</details>

<h3>DeviceStation</h3>
<ul>
  <li>Domain: <code>http://&lt;IP_Shelly_Master&gt;</code></li>
  <li>Slave-Adressen: <code>1,2, ... ,15</code></li>
</ul>

<h3>System „Gerät“</h3>
<ul>
  <li>Je Shelly einen Baustein anlegen und Dashboard wählen</li>
  <li>Als Widgets auf Startseite oder Räume/Bereiche verknüpfen</li>
</ul>

<h3>System „Licht“ oder „Steckdose“</h3>
<ul>
  <li>Schaltausgang: <code>SET Output</code></li>
  <li>Rückmeldung: <code>State Output</code></li>
</ul>


<div style="padding:10px; border-left:4px solid #f39c12; background:#fff8e6; margin:10px 0;">
  <strong>To Do:</strong> Das aktuelle Slave-Skript verwendet keine Sendewarteschlange. Bei schnellen Statusänderungen können mehrere
  <code>LoRa.Send</code>-Aufrufe gleichzeitig gestartet werden, wodurch der Shelly-Fehler
  <code>Too many calls in progress</code> auftreten kann. Es wird empfohlen, eine Busy-Flag- bzw.
  Queue-/Debounce-Logik zu implementieren, damit immer nur ein LoRa-Sendevorgang gleichzeitig aktiv ist.
</div>




<details>
  <summary>Skript-Code mit Queue und Input, Outpunt nacheinander: lora_slave_queue.js</summary>
<pre><code class="language-javascript">
let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let LORA_SEND_GAP_MS = 2000;

let di = 0;
let doo = 0;

let loraBusy = false;
let sendQueue = [];
let queuePos = 0;

let lastSent = "";
let lastQueued = "";
let nextSendAllowedAt = 0;

let retryTimerActive = false;

function getNowMs() {
  return Shelly.getUptimeMs();
}

function enqueueSend(force) {
  let msg = JSON.stringify([di, doo]);

  if (!force && msg === lastQueued) {
    return;
  }

  if (!force &&
      msg === lastSent &&
      queuePos >= sendQueue.length &&
      !loraBusy) {
    return;
  }

  sendQueue.push({
    msg: msg,
    force: force
  });

  lastQueued = msg;
  processSendQueue();
}

function processSendQueue() {
  if (loraBusy) {
    return;
  }

  if (queuePos >= sendQueue.length) {
    sendQueue = [];
    queuePos = 0;
    lastQueued = lastSent;
    return;
  }

  let now = getNowMs();

  if (now < nextSendAllowedAt) {
    if (!retryTimerActive) {
      retryTimerActive = true;
      Timer.set(nextSendAllowedAt - now, false, function () {
        retryTimerActive = false;
        processSendQueue();
      });
    }
    return;
  }

  let item = sendQueue[queuePos];
  queuePos++;

  loraBusy = true;
  lastSent = item.msg;

  console.log("SENDE:", item.msg, item.force ? "(force)" : "");

  Shelly.call("LoRa.Send", {
    id: LORA_ID,
    lr_addr: LORA_ADDR,
    data: btoa(item.msg)
  }, function (res, err, errmsg) {
    if (err !== 0) {
      console.log("LoRa Fehler:", err, errmsg);
    }

    nextSendAllowedAt = getNowMs() + LORA_SEND_GAP_MS;
    loraBusy = false;

    processSendQueue();
  });
}

function startPeriodicSend() {
  Timer.set(15 * 60 * 1000, true, function () {
    enqueueSend(true);
  });
}

function handleCommand(rawPayload) {
  let payload = rawPayload;

  try {
    payload = atob(rawPayload);
  } catch (e) {
    // rawPayload direkt verwenden
  }

  console.log("LoRa RX raw:", rawPayload, "decoded:", payload);

  if (payload === "1" || payload === "ON" || payload === "true") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: true }, function (res, err, msg) {
      console.log("Switch.Set ON -> err:", err, "msg:", msg);
    });
  } else if (payload === "0" || payload === "OFF" || payload === "false") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: false }, function (res, err, msg) {
      console.log("Switch.Set OFF -> err:", err, "msg:", msg);
    });
  } else {
    console.log("Unbekannter Payload:", payload);
  }
}

Shelly.addEventHandler(function (ev) {
  if (ev.name !== "lora") return;
  if (!ev.info) return;

  if (ev.info.component !== "lora:100") return;
  if (ev.info.event !== "user_rx") return;

  handleCommand(ev.info.data);
});

Shelly.addStatusHandler(function (e) {
  if (!e || !e.component || !e.delta) return;

  if (e.component === "input:0" && e.delta.state !== undefined) {
    di = e.delta.state ? 1 : 0;
    enqueueSend(false);
  }

  if (e.component === "switch:0" && e.delta.output !== undefined) {
    doo = e.delta.output ? 1 : 0;
    enqueueSend(false);
  }
});

var startDelay = Math.floor(Math.random() * 15 * 60 * 1000);
console.log("Start in", startDelay, "ms");

Timer.set(startDelay, false, function () {
  enqueueSend(true);
  startPeriodicSend();
});

</code></pre>
</details>

Description (IT)

<p>Con questo DDF è possibile integrare i dispositivi Shelly con l'add-on LoRa, consentendo l'uso di un ingresso e un'uscita per ciascuno. Nota: rispettare le normative locali vigenti sull'uso di LoRa. Uno Shelly con add-on LoRa viene gestito nella stessa rete IP del controller myGEKKO. Funge da <strong>gateway master LoRa</strong> e comunica con altri dispositivi Shelly (slave) tramite LoRa.</p>

<p>Connettersi all'access point Wi-Fi dello Shelly tramite <code>192.168.33.1</code>, quindi collegarlo alla rete Wi-Fi ed eseguire un aggiornamento del firmware se necessario. Testato con 2.0.0-beta1, add-on 2.1.1.</p>

<h3>Shelly Master (Gateway nella rete Wi-Fi)</h3>
<ul>
  <li>Creare e attivare lo script <code>lora_master.js</code></li>
  <li>Abilitare "Run on startup"</li>
  <li>Attivare l'add-on LoRa, la configurazione deve essere identica su tutti gli Shelly!</li>
  <li>LoRa transport layer Device Address: <code>0001</code> (HEX)</li>
  <li>Generare e annotare la chiave crittografica (Cryptography-Key)</li>
  <li>Abilitare "User LoRa calls"</li>
</ul>

<details>
  <summary>Codice script: lora_master.js</summary>
<pre><code class="language-javascript">let lastByAddr = {};

function nowIso() {
  return new Date().toISOString();
}

function nowUnix() {
  return Math.floor(Date.now() / 1000);
}

// Shelly-safe Query Parser (NO decodeURIComponent!)
function parseQuery(qs) {
  let out = {};

  if (!qs) return out;

  let parts = qs.split("&");

  for (let i = 0; i < parts.length; i++) {
    let kv = parts[i].split("=");

    let key = kv[0];
    let val = kv.length > 1 ? kv[1] : "";

    if (key) out[key] = val;
  }

  return out;
}

Shelly.addEventHandler(function (ev) {
  if (!ev || !ev.info) return;

  let addr = ev.info.lr_addr || ev.info.addr || ev.info.sender;
  let data = ev.info.data;

  if (addr === undefined || data === undefined) return;

  addr = String(addr);

  try {
    data = JSON.parse(atob(String(data)));
  } catch (e) {
    try {
      data = atob(String(data));
    } catch (e2) {
      data = String(data);
    }
  }

  lastByAddr[addr] = {
    addr: addr,
    data: data,
    rssi: ev.info.rssi,
    snr: ev.info.snr,
    received: nowIso(),
    received_unix: nowUnix()
  };

  print("LoRa ricevuto: " + addr);
});

HTTPServer.registerEndpoint("lora", function (req, res) {
  let query = parseQuery(req.query);
  let addr = query.addr;

  if (!addr) {
    res.code = 400;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "addr mancante" });
    res.send();
    return;
  }

  let result = lastByAddr[String(addr)];

  if (!result) {
    res.code = 404;
    res.headers = [["Content-Type", "application/json"]];
    res.body = JSON.stringify({ error: "non trovato", addr: addr });
    res.send();
    return;
  }

  res.code = 200;
  res.headers = [["Content-Type", "application/json"]];
  res.body = JSON.stringify(result);
  res.send();
});

print("Endpoint attivo: /script/<id>/lora?addr=<addr>");
</code></pre>
</details>

<h3>Shelly Slave (Dispositivi terminali LoRa)</h3>
<ul>
  <li>Creare e attivare lo script <code>lora_slave.js</code></li>
  <li>Abilitare "Run on startup"</li>
  <li>LoRa transport layer Device Address:
    <ul>
      <li><code>0002</code> (HEX) &ndash; primo dispositivo</li>
      <li><code>0003</code> fino a <code>000F</code> (HEX) &ndash; ulteriori slave</li>
    </ul>
  </li>
  <li>Inserire la chiave crittografica (Cryptography-Key) del Master</li>
  <li>Abilitare "User LoRa calls"</li>
</ul>

<details>
  <summary>Codice script: lora_slave.js</summary>
<pre><code class="language-javascript">let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let di = 0;
let doo = 0;
let last = "";

function send(force) {
  // Invia lo stato come array
  let msg = JSON.stringify([di, doo]);

  if (!force && msg === last) return;
  last = msg;

  console.log("INVIO:", msg);

  Shelly.call("LoRa.Send", {
    id: LORA_ID,
    lr_addr: LORA_ADDR,
    data: btoa(msg)
  }, function (res, err, msg) {
    if (err !== 0) {
      console.log("Errore LoRa:", err, msg);
    }
  });
}

function startPeriodicSend() {
  // un heartbeat di stato ogni 15 minuti
  Timer.set(15 * 60 * 1000, true, function () {
    send(true);
  });
}

function handleCommand(rawPayload) {
  let payload = rawPayload;

  // Se i dati arrivano codificati in base64, decodificali
  try {
    payload = atob(rawPayload);
  } catch (e) {
    // se non è in base64, usa direttamente rawPayload
  }

  console.log("LoRa RX raw:", rawPayload, "decoded:", payload);

  if (payload === "1" || payload === "ON" || payload === "true") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: true }, function (res, err, msg) {
      console.log("Switch.Set ON -> err:", err, "msg:", msg);
    });
  } else if (payload === "0" || payload === "OFF" || payload === "false") {
    Shelly.call("Switch.Set", { id: OUTPUT_ID, on: false }, function (res, err, msg) {
      console.log("Switch.Set OFF -> err:", err, "msg:", msg);
    });
  } else {
    console.log("Payload sconosciuto:", payload);
  }
}

Shelly.addEventHandler(function (ev) {
  if (ev.name !== "lora") return;
  if (!ev.info) return;

  if (ev.info.component !== "lora:100") return;
  if (ev.info.event !== "user_rx") return;

  handleCommand(ev.info.data);
});

Shelly.addStatusHandler(function (e) {
  if (!e || !e.component || !e.delta) return;

  if (e.component === "input:0" && e.delta.state !== undefined) {
    di = e.delta.state ? 1 : 0;
    send(false);
  }

  if (e.component === "switch:0" && e.delta.output !== undefined) {
    doo = e.delta.output ? 1 : 0;
    send(false);
  }
});

// ritardo di avvio casuale una tantum
var startDelay = Math.floor(Math.random() * 15 * 60 * 1000);
console.log("Avvio in", startDelay, "ms");

Timer.set(startDelay, false, function () {
  send(true);
  startPeriodicSend();
});

console.log("Script combinato LoRa avviato");
</code></pre>
</details>

<h3>DeviceStation</h3>
<ul>
  <li>Domain: <code>http://&lt;IP_Shelly_Master&gt;</code></li>
  <li>Indirizzi slave: <code>1,2, ... ,15</code></li>
</ul>

<h3>Sistema "Dispositivo"</h3>
<ul>
  <li>Creare un blocco per ogni Shelly e selezionare Dashboard</li>
  <li>Collegare come widget sulla pagina iniziale o nelle stanze/aree</li>
</ul>

<h3>Sistema "Luce" o "Presa"</h3>
<ul>
  <li>Uscita di commutazione: <code>SET Output</code></li>
  <li>Feedback: <code>State Output</code></li>
</ul>

<div style="padding:10px; border-left:4px solid #f39c12; background:#fff8e6; margin:10px 0;">
  <strong>To Do:</strong> Lo script slave attuale non utilizza una coda di invio. In caso di rapidi cambiamenti di stato, possono essere avviate più chiamate <code>LoRa.Send</code> contemporaneamente, il che può causare l'errore Shelly <code>Too many calls in progress</code>. Si consiglia di implementare un flag di occupato (busy flag) o una logica di coda/debounce, in modo che sia attivo un solo processo di invio LoRa alla volta.
</div>

<details>
  <summary>Codice script con coda e input, output sequenziali: lora_slave_queue.js</summary>
<pre><code class="language-javascript">
let LORA_ID = 100;
let LORA_ADDR = "00000001";
let OUTPUT_ID = 0;

let LORA_SEND_GAP_MS = 2000;

let di = 0;
let doo = 0;

let loraBusy = false;
let sendQueue = [];
let queuePos = 0;

let last

Note

from

*2026-06-15 13:30:01 (hw) ******************************
Last Commit: ac75e22f | 2026-06-10 07:25:55

Downloads sind nur für aktive Benutzer (active > 0) verfügbar.

Device images stehen nur für aktive Benutzer (active > 0) zur Verfügung.

Der Zugriff auf DDF-Dateien ist nur für aktive Benutzer (active > 0) möglich.

INDEX	ALIAS	NAME
0	SLAVE	Slave
1	STATE_INPUT	State Input
2	STATE_OUTPUT	State Output
3	RSSI	RSSI
4	RECEIVED_UNIX	Received Unix
5	RECEIVED	Received
6	MESSAGE_AGE	Message Age
100	SET_OUTPUT	SET Output
200	QUALITY	Quality

General Parameters

Description (HTML)

Description (DE)

Description (IT)

Note

Documents

Device Description File