/*
von Smartboart / ioBroker Forum
-
https://forum.iobroker.net/topic/38118/tasmota-one-click-firmware-update-vis-javascript
-
31.10.2020
-
Tasmota One Click Firmware Update Vis.extra auch für Geräte die für das internet gesperrt sind.
automatischer Download der firmware / minimal , sensors, tasmota und speichern auf dem file system.
Starten eines lokalen http: Servers (python) per ssh und einleiten des OTA download der Tasmota Firmware.
für selektierbare Geräte über Vis.
-
Nötige Addons im javascript adapter: node-ssh und fs
-
inspiriert durch das script um auf neue Tasmota Version zu prüfen von forummitglied Machinima..
https://forum.iobroker.net/topic/22389/skript-um-auf-neue-tasmota-version-zu-pr%C3%BCfen/11
-
31.10.2020 Beta release
V0.0.1 Automatisches Tasmota Firmwaredownload bei Update Benachrichtigung:
onclickupdate mit http Server Start (python) über ssh inkl Vorwahl des abzudatenden Teilnehmers.
31.10.2020
V0.0.2 Konfigurationsteil überarbeitet http source.
03.11.2020
V0.0.3 Kommentare ergänzt um mölichen Missverständnissen entgegen zu wirken.
Beim Scriptstart immer die bins runterladen, auch wenn kein Update verfügbar um sicher zu stellen, dass immer was im Download Ordner liegt.
06.11.2020
V0.0.4 Implementierung der Funktion Update All
Im Bereich der Device Zuordnung mussten anpassungen vorgenommen werden umd diese beim Updat All der Reihe nach abarbeiten zu können.
Dazu wurde auch der Userconfig Bereich angepasst.
Anzahl Geräte wird Automatisch ermittelt und gesetzt. Device 1 - n / AnzahlSensors ist für Sensor reserviert.
AnzahlSensors muss im Konfigbereich eingetragen werden. Standart Tasmota Firmware Geräte sind dann automatisch gesetzt von
Anzahl Sensors bis automatisch ermittelte Geräte.
Hinweis: damit nicht während des Update Prozess durch Eingabe in Vis beim derDevice Auswahl die Schrittkette durcheinander gebract wird, sollte
das widget für die DeviceAuswahl nur Sichtbar sein wenn der neue State javascript.0.Status.Tasmota.Tasmota_Firmware.UpdateAll false ist.
Um alle Geräte upzudaten muss nun einfach der State UpdateAll auf true gesetzt werden und dann mit dem State UpdateStart das Update eingeleitet
werden. Das einzeln Update der Geräte bleibt natürlich erhalten und ist aktiv wenn UpdateAll false ist.
Nach Update All wird automatisch die Funktion funcVersion gestartet um alle Geräte nach der installierten Version zu befragen. Im Log kann nun
alles nachvollzogen werden.
17.12.2020
V0.0.4 kleine Fehlerkorrekturen
24.02.2021
V0.0.5 State UpdateAll kann entfallen Auswahl Update all erfolgt nun über den State Auswahl
Bei Update All Nach Ende Update sicher beenden if (count >= ANZAHL_DEVICES)
01.03.2021
V0.0.6 Tasmota Statebezeichner haben sich geändert, dies habe ich nun berücksichtigt.
Anzahl Device wieder manuell in der Konfig angeben. Autozählung Hat unter bestimmten umständen zu Fehlern geführt.
16.07.2021
V0.0.7 Optimierungen von cruzix (iobroker-forum) integriert.
Danke @ cruzix
Komplett Test noch offen. Testversion.
To do....Wenn es die Zeit zulässt..
zusätzlich den Changelog in den Versionsinfostate schreiben.
*/
createState('javascript.0.Status.Tasmota.Tasmota_Firmware.Update', {
def: false,
type: 'boolean',
name: 'Tasmota Update verfügbar'
});
createState('javascript.0.Status.Tasmota.Tasmota_Firmware.Version', {
type: 'string',
read: true,
write: true,
desc: 'Tasmota Firmware Version online',
name: 'Tasmota Firmware Update Version'
});
createState('javascript.0.Status.Tasmota.Tasmota_Firmware.Updatestart', {
def: false,
type: 'boolean',
name: 'Tasmota Firmware Update starten'
});
const fc = true; // force creation zum aktualisieren des Auswahl state
// 1 - AnzahlSensors (bei mir 17) müssen Sensor Geräte zugeordnet haben
// > AnzahlSensors + sind Standart Firmware Geräten vorbehalten.
createState('javascript.0.Status.Tasmota.Tasmota_Firmware.Auswahl', 0, fc, {
def: 0,
type: 'number',
name: 'Auswahl Teilnehmer fuer Tasmota Firmware Update',
min: 0,
max: 100,
role: 'value',
states: {
0:'Update All',
1:'NodeMCU Garage',
2:'Wemo Schuppen',
3:'Wemo Keller',
4:'NodeMCU Huette',
5:'Wemo Fitttnessraum',
6:'Wemo Eingang',
7:'NodeMCU Dachboden',
8:'Steckdose Waschmaschine',
9:'Steckdose Trockner',
10:'Steckdose Spülmaschine',
11:'Steckdose Dunstabzug',
12:'Steckdose 4',
13:'Steckdose 3',
14:'Steckdose 2',
15:'Steckdose 1',
16:'Wemo Ankleidezimmer',
17:'Wemo Bad',
18:'Steckdosenleiste WZ',
19:'Steckdosenleiste FR',
20:'RGBW Briefkasren',
21:'RGBW Bad',
22:'Reserve',
23:'Reserve',
24:'Reserve',
25:'Reserve',
26:'Reserve',
27:'Reserve',
28:'Reserve',
29:'Reserve',
30:'Reserve',
31:'Reserve',
32:'Reserve',
33:'Reserve',
34:'Reserve',
35:'Reserve',
36:'Reserve',
37:'Reserve',
38:'Reserve',
39:'Reserve',
40:'Reserve',
}
});
// User konfig
const WARTEZEIT = '*/3 * * * *'; // jede Minute Trigger Wartezeit zwischen den Updates der Tasmota Geräte
const TIMEOUT = 90 * 1000; // Wartezeit zwischen dem upgrade von minimal auf sensors oder tasmota
const TIMEOUT2 = 3*1000; // Wartezeit zwischen URL Set und Upgrade bzw. http start und URL minimal set
const DOWNLOAD = true; // automatischer Firmware download wenn update verfügbar
const LOGGING = true;
const DEBUG = false;
const SEND_TELEGRAM = true;
const SEND_MAIL = true;
const ANZAHL_SENSORS = 17; // Hier die Anzahl der TasmotaSensor Geräte eintragen Entspicht Devices 1-17
const ANZAHL_DEVICES = 21; //Anzahl der Tasmota Geräte. Wichtig für Update aller Geräte
// ssh Konfigbereich
// sudo python3 -m http.server 8000 im Terminal testen. Startet den minimal http server
const SSH_IP = '192.168.XXX.XXX';
const SSH_USR = 'User';
const SSH_PWD = 'passwd';
const SSH_CMD = 'python3 -m http.server 8000';
// Ordner müssen angelegt werden unter dem ssh Benutzer home/pi und muss schreibrechte für iobroker haben
// sudo chmod -R 777 /home/pi/Tasmota
const DEST_PATH1 = '/home/pi/Tasmota/tasmota-sensors.bin.gz';
const DEST_PATH2 = '/home/pi/Tasmota/tasmota.bin.gz';
const DEST_PATH3 = '/home/pi/Tasmota/tasmota-minimal.bin.gz';
//http IP Downloadlink muss auch im Browser funktionieren wenn die bins dort liegen
const SOURCE_SENSORS = '192.168.XXX.XXX:8000/Tasmota/tasmota-sensors.bin.gz';
const SOURCE_MINIMAL = '192.168.XXX.XXX:8000/Tasmota/tasmota-minimal.bin.gz';
const SOURCE_TASMOTA = '192.168.XXX.XXX:8000/Tasmota/tasmota.bin.gz';
// download Quelle der tasmota firmware
const DOWNLOAD_LINK1 = 'http://ota.tasmota.com/tasmota/release/tasmota-sensors.bin.gz'; //downloadlink für bin file
const DOWNLOAD_LINK2 = 'http://ota.tasmota.com/tasmota/release/tasmota.bin.gz'; //downloadlink für bin file
const DOWNLOAD_LINK3 = 'http://ota.tasmota.com/tasmota/release/tasmota-minimal.bin.gz'; //downloadlink für bin file
//Sensors Tasmota Firmware
const DEVICES = [
//Sensors Tasmota Firmware
// Device 1 - AnzahlSensors müssen Sensor Geräte zugeordnet haben. >Anzahl Sensors bis ANZAHL_DEVICES ist für Standart Tasmota Firmware
'192.168.XXX.XXX',//NodeMCUGarage
'192.168.XXX.XXX',//WemoSchuppen
'192.168.XXX.XXX',//WemoKeller
'192.168.XXX.XXX',//NodeMCUHuette
'192.168.XXX.XXX',//WemoFitttnesraum
'192.168.XXX.XXX',//WemoEingang
'192.168.XXX.XXX',//NodeMCUDachboden
'192.168.XXX.XXX',//SteckdoseWama
'192.168.XXX.XXX',//SteckdoseTrockner
'192.168.XXX.XXX',//SteckdoseSpülmaschine
'192.168.XXX.XXX',//SteckdoseDunstabzug
'192.168.XXX.XXX',//Steckdose4
'192.168.XXX.XXX',//Steckdose3
'192.168.XXX.XXX',//Steckdose2
'192.168.XXX.XXX',//Steckdose1
'192.168.XXX.XXX',//Wemo Ankleidezimmer
'192.168.XXX.XXX',//Wemo Bad
// Tasmota Firmware
'192.168.XXX.XXX',//SteckdosenleisteWZ
'192.168.XXX.XXX',//SteckdosenleisteFR
'192.168.XXX.XXX',//RGBW1
'192.168.XXX.XXX',//RGBWBad
]
// User States / Objekte
const idUpdate = 'javascript.0.Status.Tasmota.Tasmota_Firmware.Update';
const id_Version_Internet = 'javascript.0.Status.Tasmota.Tasmota_Firmware.Version';
const idUpdatestart = 'javascript.0.Status.Tasmota.Tasmota_Firmware.Updatestart';
const idAuswahl = 'javascript.0.Status.Tasmota.Tasmota_Firmware.Auswahl';
let cacheSelectorTasmotaVersions = $('channel[state.id=sonoff.0.*.Info1_Version]');
// fs und node-ssh unter Einstellungen im javascript Adapter hinzufügen
const fs = require('fs');
const request = require('request');
const node_ssh = require('node-ssh').NodeSSH;
let select = '';
let sshcommand = false;
let Sensor = null;
let Tasmota = null;
let trigger = null;
//let ANZAHL_DEVICES = 0; //Anzahl der Tasmota Geräte. Wichtig für Update aller Geräte
let _message = '';
let _message_tmp = '';
function bLOG(str) {
if (LOGGING) log(str);
}
function bDEBUG(str) {
if (DEBUG) console.debug(`[DEBUG] ${str}`);
}
function func_Version() {
let options = {
url: 'https://api.github.com/repos/arendst/Tasmota/releases/latest',
headers: {
'User-Agent': 'ioBroker Tasmota Firmware Check'
}
};
request(options, async function(error, response, body) {
const availableFirmware = getState(id_Version_Internet).val;
if (error) {
log('error: ' + error);
} else {
let tasmotaJson = JSON.parse(body);
let tasmotaTagName = tasmotaJson.tag_name;
let tasmotaVersion = tasmotaTagName.replace(/v/i, "").trim();
if (availableFirmware.length === 0) {
bLOG(`Ausgewähltes Objekt leer. Firmware wird erstmalig gesetzt. Firmware: ${tasmotaVersion}`); // +' Zentrale: ' +Version[3]);
await setStateAsync(id_Version_Internet, tasmotaVersion);
}
let devices = [];
cacheSelectorTasmotaVersions.each(async function(id, i) {
const installedFirmware = getState(id).val.trim()
.replace('(sonoff)', '').trim()
.replace('(tasmota)', '').trim()
.replace('(sensors)', '').trim();
let infoId = id.substring(0, id.lastIndexOf("."));
let hostName = getState(infoId + '.Info2_Hostname').val;
if (installedFirmware == tasmotaVersion) {
bLOG(`Tasmota: Installierte Firmware für Gerät ${hostName} ist aktuell.`);
} else {
bLOG(`Tasmota: Installierte Firmware für Gerät ${hostName} (${installedFirmware}) ist nicht aktuell. Aktuell verfügbare Version: ${tasmotaVersion}`);
if (availableFirmware == tasmotaVersion) {
await setStateAsync(idUpdate, false, true);
bDEBUG('Tasmota: Version Internet hat sich nicht verändert');
} else {
setState(idUpdate, true, true);
bDEBUG('Tasmota: Installierte Firmware ist nicht aktuell.');
await setStateAsync(id_Version_Internet, tasmotaVersion);
devices.push(hostName + ' (' + installedFirmware + ')');
}
}
});
if (devices.length > 0) {
_message_tmp = `Neue Tasmota-Firmware ${tasmotaVersion} für folgende Geräte verfügbar:\n${devices.join('\n')}`;
if (SEND_TELEGRAM) {
_message = _message_tmp;
send_telegram();
}
if (SEND_MAIL) {
_message = _message_tmp;
send_mail();
}
}
}
});
}
function send_telegram() {
sendTo('telegram.0', {
text: _message
});
}
function send_mail() {
sendTo("email", {
subject: "Servicemeldung",
text: _message
});
}
// um 12:45 Uhr prüfen
schedule({
hour: 12,
minute: 45
}, func_Version);
function downloadFile1() {
request.get({
url: DOWNLOAD_LINK1,
encoding: 'binary'
}, function(err, response, body) {
if (err) {
return log(`Tasmota: Fehler beim Download: ${err}`);
}
fs.writeFile(DEST_PATH1, body, 'binary', function(err) {
const fileName = DOWNLOAD_LINK1.split('/').pop();
if (err) {
return log(`Tasmota: Fehler beim Speichern: ${err}`);
}
bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
});
});
}
function downloadFile2() {
request.get({
url: DOWNLOAD_LINK2,
encoding: 'binary'
}, function(err, response, body) {
if (err) {
return log(`Tasmota: Fehler beim Download: ${err}`);
}
fs.writeFile(DEST_PATH2, body, 'binary', function(err) {
const fileName = DOWNLOAD_LINK2.split('/').pop();
if (err) {
return log(`Tasmota: Fehler beim Speichern: ${err}`);
}
bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
});
});
}
function downloadFile3() {
request.get({
url: DOWNLOAD_LINK3,
encoding: 'binary'
}, function(err, response, body) {
if (err) {
return log(`Tasmota: Fehler beim Download: ${err}`);
}
fs.writeFile(DEST_PATH3, body, 'binary', function(err) {
const fileName = DOWNLOAD_LINK3.split('/').pop();
if (err) {
return log(`Tasmota: Fehler beim Speichern: ${err}`);
}
bLOG(`Tasmota: Firmwaredownload ${fileName} gestartet `);
});
});
}
// http Server starten
on({
id: idUpdatestart,
val: true,
change: 'ne'
}, async function() {
let UpdateAll = getState(idAuswahl).val;
if (UpdateAll != 0) {
setTimeout(async function() {
minimalURLset();
await setStateAsync(idUpdatestart, false, true);
}, TIMEOUT2);
} else {
startUpdateAll();
}
if (!sshcommand) {
sshcommand = true;
let ssh = new node_ssh();
ssh.connect({
host: SSH_IP,
username: SSH_USR,
password: SSH_PWD
}).then(() => {
ssh.execCommand(SSH_CMD);
});
}
});
// Alles updaten Alle Geräte werden von 1 an durchgezählt
async function startUpdateAll() {
let count = 0;
bLOG(`Tasmota: Update aller Geräte gestartet.`);
trigger = schedule(WARTEZEIT, async function() {
count++;
await setStateAsync(idAuswahl, count, true);
setTimeout(minimalURLset, 500);
bLOG(`Tasmota: Aktuell wird das Update für Device ${count} gestartet.`);
if (count >= ANZAHL_DEVICES) {
clearSchedule(trigger);
setTimeout(async function() {
func_Version();
await setStateAsync(idAuswahl, 0, true);
}, 2 * TIMEOUT);
setTimeout(async function() {
await setStateAsync(idUpdatestart, false, true);
count = 0;
}, TIMEOUT2);
}
});
}
// Entscheiden ob Sensor oder Tasmota aktiv für Upgrade und Device Vorwahl
on(idAuswahl, function(dp) {
if (dp.state.val > 0 && dp.state.val <= ANZAHL_SENSORS) {
Sensor = true;
Tasmota = false;
}
if (dp.state.val > ANZAHL_SENSORS) {
Sensor = false;
Tasmota = true;
}
if (DEVICES.length >= dp.state.val) {
select = DEVICES[dp.state.val - 1];
}
bLOG(`Tasmota: Folgende IP wurde für das Update vorgewählt: ${select}`);
});
function minimalURLset() {
let Auswahl = getState(idAuswahl).val;
if (DOWNLOAD && Auswahl > 0)
request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_MINIMAL}`, function(error, response, body) {
if (error) {
log(`Tasmota: Fehler beim setzen der OTA Minimal URL für: ${select} ${error}`);
} else {
bLOG(`Tasmota: OTA Firmware URL auf Minimal gesetzt für IP: ${select}`);
setTimeout(minimalUpgrade, TIMEOUT2);
}
});
}
function minimalUpgrade() {
request(`http://${select}/cm?cmnd=upgrade%201`, function(error, response) {
if (error) {
log('Tasmota: Fehler beim setzen des Minimal Upgrade Befehl für: ' + select + ' ' + error);
} else {
bLOG('Tasmota: OTA Firmware upgrade Minimal für IP: ' + select);
setTimeout(function() {
if (Sensor) sensorURLset();
if (Tasmota) TasmotaURLset();
}, TIMEOUT);
}
});
}
// Sensor URL setzen und update
function sensorURLset() {
request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_SENSORS}`, function(error, response) {
if (error) {
log('Fehler beim setzen der OTA Sensor URL für: ' + select + ' ' + error);
} else {
bLOG('Tasmota: OTA Firmware URL auf Sensor gesetzt für IP: ' + select);
setTimeout(sensorUpgrade, TIMEOUT2);
}
});
}
function sensorUpgrade() {
request(`http://${select}/cm?cmnd=upgrade%201`, function(error, response) {
if (error) {
log('Tasmota: Fehler beim setzen des Sensor Upgrade Befehl für: ' + select + ' ' + error);
} else {
bLOG('Tasmota: OTA Firmware upgrade Sensors für IP: ' + select);
}
});
}
// Tasmota URL setzen und update
function TasmotaURLset() {
request(`http://${select}/cm?cmnd=OtaUrl%20http://${SOURCE_TASMOTA}`, function(error, response) {
if (error) {
log('Fehler beim setzen der OTA Tasmota URL: ' + error);
} else {
bLOG('Tasmota: OTA Firmware URL auf Tasmota gesetzt für IP: ' + select);
setTimeout(tasmotaUpgrade, TIMEOUT2);
}
});
}
function tasmotaUpgrade() {
request(`http://${select}/cm?cmnd=upgrade%201`, function(error, respnsoe) {
if (error) {
log('Tasmota: Fehler beim setzen des Tasmota Upgrade Befehl für: ' + select + ' ' + error);
} else {
bLOG('Tasmota: OTA Firmware upgrade Tasmota für IP: ' + select);
}
});
}
// Firmware automatisch herunter laden
on({
id: idUpdate,
val: true,
change: 'ne'
}, function(dp) {
if (DOWNLOAD) {
downloadFile1();
downloadFile2();
downloadFile3();
}
});
//beim SkriptStart
func_Version();
if (DOWNLOAD) {
setTimeout(function() {
let Update = getState(idUpdate).val;
if (Update === false) {
downloadFile1();
downloadFile2();
downloadFile3();
}
}, 10 * 1000);
}
ziemlich kompliziert... Egal, vielen Dank für deine tolle Arbeit! Das macht es sowas von viel einfacher...
