Der neue Monatsrückblick für Mai und Juni 2026 ist online!

[lobomau]

Ich bräuchte mal Scripte zum Auslesen einiger Systeminfos vom Raspi, also eigentlich das was schon der rpi-Adapter macht (auf den ich aber verzichten möchte).

Hier wurden schon einige Scripte für andere hardwares beschrieben.

http://forum.iobroker.net/viewtopic.php … ysteminfos

Basierend darauf versuche ich diese für den Raspi (in meinem Fall Pi3) anzuwenden.

Erfolgreich im Einsatz:

• Script für uptime, Load_average_1min, Load_average_5min, Load_average_10min:

! ````
// ermittelt auf Linuxrechner die Uptime und die Systemauslastung
// mit dem Linux Befehl: uptime
//
// Beduetung der Werte:
// http://www.selflinux.org/selflinux/html/information_basic02.html
! // getestet unter Ubuntu 16.04 mit deutscher Ausgabe
! var pfad = "Systeminfos.Pi3" + ".";
var cronStr = "*/1 * * * *";
var abfrageAverageLoad = "uptime";
var abfrageUptime = "uptime -s";
! var forceCreation = false;
! var datenpunkte = {
'uptime': {
"init":0,
"common": {
name: 'uptime',
desc: 'uptime',
type: 'number',
unit: 'Tag(e)',
role: 'value'
}
},
'Load_Average.load_average_01_min': {
"init":0,
"common": {
name: 'mittlere Systemauslastung in der letzten Minute',
desc: 'mittlere Systemauslastung in der letzten Minute',
type: 'number',
unit: '',
role: 'value'
}
},
'Load_Average.load_average_05_min': {
"init":0,
"common": {
name: 'mittlere Systemauslastung in den letzten 5 Minuten',
desc: 'mittlere Systemauslastung in den letzten 5 Minuten, zum Zeitpunkt der Abfrage',
type: 'number',
unit: '',
role: 'value'
}
},
'Load_Average.load_average_15_min': {
"init":0,
"common": {
name: 'mittlere Systemauslastung in den letzten 15 Minuten',
desc: 'mittlere Systemauslastung in den letzten 15 Minuten, zum Zeitpunkt der Abfrage',
type: 'number',
unit: '',
role: 'value'
}
}
};
! function deltaDays(date1, date2) { // Delta in Tagen zwischen zwei Tagen. Format des Datums: "2016-04-26"
if(!date1.match(/\d{4}-\d{1,2}-\d{1,2}/) || !date2.match(/\d{4}-\d{1,2}-\d{1,2}/)) {
log("function deltaDays() hat ein ungültiges Datumsformat erhalten","warn");
log("Skript liefert ggf. ein ungültiges ergebnis");
return -1;
}
date1 = date1.split("-");
date2 = date2.split("-");
if(!date1 || !date2) return null;
var check1 = new Date(date1[0], date1[1], date1[2]);
var check2 = new Date(date2[0], date2[1], date2[2]);
return Math.round(Math.abs(check1 - check2) / (1000 * 60 * 60 * 24 ));
}
! function createDp() {
var name;
var init;
var common;
for (var dp in datenpunkte) {
name = pfad + dp;
init = datenpunkte[dp].init;
common = datenpunkte[dp].common;
createState(name, init , forceCreation, common);
}
}
! function writeDp(arr) {
setState(pfad + 'Load_Average.load_average_01_min',parseFloat(arr[0]));
setState(pfad + 'Load_Average.load_average_05_min',parseFloat(arr[1]));
setState(pfad + 'Load_Average.load_average_15_min',parseFloat(arr[2]));
}
! // Average Load mit uptime auslesen
function getAverage() {
exec(abfrageAverageLoad, function(err, stdout, stderr) {
if (err) {
log(err);
return;
}
stdout = stdout.replace(/(.)+load average: /, "");
stdout = stdout.replace(/,/g,".");
stdout = stdout.split(". ");
//log(stdout);
writeDp(stdout);
});
}
! // Uptime mit uptime auslesen
function getUptime() {
exec(abfrageUptime, function(err, stdout, stderr) {
if (err) {
log(err);
return;
}
stdout = stdout.split(" ");
var now = formatDate(new Date(), "YYYY-MM-DD");
setState(pfad + 'uptime',deltaDays(stdout[0],now));
});
}
! function getData() {
getAverage();
getUptime();
}
! // regelmässige Wiederholungen
// -----------------------------------------------------------------------------
schedule(cronStr, getData);
! // main
// -----------------------------------------------------------------------------
function main() {
getData();
}
! // Start Skript:
// -----------------------------------------------------------------------------
! createDp();
setTimeout(main, 500);

- Script für node Version:

>! ````
var pfad            = "Systeminfos.iobrokerP3" + ".";
var cronStr         = "*/30 * * * *";
>! var abfrage         = "node -v";
>! var idNodeVersion = pfad + 'node_Version';
>! createState(idNodeVersion, "", {
     name: 'node Version',
     desc: 'node Version (abgefragt mit node -v)',
     type: 'string',
     unit: '',
     role: 'value'
});

>! function abfrageVersion() {
    exec(abfrage, function(err, stdout, stderr) {
        if (err) {
            log(err,"error");
            return;
        }
        //log(stdout);
        setStateDelayed(idNodeVersion,stdout,100);
    });
}
>! function abfragen() {
    abfrageVersion();
}
>! // regelmässige Wiederholungen
// -----------------------------------------------------------------------------
schedule(cronStr, abfragen);
>! // main
// -----------------------------------------------------------------------------
function main() {
    abfragen();
}
>! // Start Skript:
// -----------------------------------------------------------------------------
>! setTimeout(main,    500);

• Script für npm Version:

! ````
var pfad = "Systeminfos.iobrokerP3" + ".";
var cronStr = "*/30 * * * *";
! var abfrage = "npm -v";
! var idNpmVersion = pfad + 'npm_Version';
! createState(idNpmVersion, "", {
name: 'npm Version',
desc: 'npm Version (abgefragt mit npm -v)',
type: 'string',
unit: '',
role: 'value'
});

! function abfrageVersion() {
exec(abfrage, function(err, stdout, stderr) {
if (err) {
log(err,"error");
return;
}
//log(stdout);
setStateDelayed(idNpmVersion,stdout,100);
});
}
! function abfragen() {
abfrageVersion();
}
! // regelmässige Wiederholungen
// -----------------------------------------------------------------------------
schedule(cronStr, abfragen);
! // main
// -----------------------------------------------------------------------------
function main() {
abfragen();
}
! // Start Skript:
// -----------------------------------------------------------------------------
! setTimeout(main, 500);

****Wunsch:****

cpu-Frequenz, soc_temp und CPU Last

Versuch mit CPU Last ohne Erfolg mit Ergebnis "null %":

>! ````
var pfad = "Systeminfos.Pi3" + ".";
var cronStr = "*/1 * * * *"; //jede Minute
>! var abfrage = "top -d 1 -b -n2 | grep 'CPU(s)'|tail -n 1 | awk '{print $2 + $3 + $4}'";
>! var idCPUlast = pfad + 'CPU_Last';
>! createState(idCPUlast, 0, {
name: 'CPU Last',
desc: 'CPU Last',
type: 'number',
unit: '%',
role: 'value'
});
>! function abfrageCPU() {
exec(abfrage, function(err, stdout, stderr) {
if (err) {
log(err,"error");
return;
}
//log(stdout);
setStateDelayed(idCPUlast,parseInt(stdout),100);
});
}
>! function abfragen() {
abfrageCPU();
}
>! // regelmässige Wiederholungen
// -----------------------------------------------------------------------------
schedule(cronStr, abfragen);
>! // main
// -----------------------------------------------------------------------------
function main() {
abfragen();
}
>! // Start Skript:
// -----------------------------------------------------------------------------
>! setTimeout(main, 500);

[tempestas]

Das hier?

http://forum.iobroker.net/viewtopic.php?t=7590

[paul53]

Für die CPU-Last verwende ich folgendes Skript:

// CPU-Last aus Datei /proc/stat ermitteln

var fs = require('fs');
var idLast = getIdByName('Service.CPU-Last');
var fn = '/proc/stat';

var cpuUser = 0;
var cpuNice = 0;
var cpuSystem = 0;
var cpuIdle = 0;

function cpuLast(text) {
    var lines = text.split('\n');
    var cpu = lines[0].split(' '); 
    var cUser = parseFloat(cpu[2]) - cpuUser;
    var cNice = parseFloat(cpu[3]) - cpuNice;
    var cSystem = parseFloat(cpu[4]) - cpuSystem;
    var cIdle = parseFloat(cpu[5])- cpuIdle;
    var last = 100 * (1 - cIdle / (cUser + cNice + cSystem + cIdle));
    setState(idLast, runden(last, 1), true);
    cpuUser = parseFloat(cpu[2]);
    cpuNice = parseFloat(cpu[3]);
    cpuSystem = parseFloat(cpu[4]);
    cpuIdle = parseFloat(cpu[5]);
}

function getStat() {
    fs.readFile(fn, 'utf8',  function(err, text) {
        if(err) log('Fehler beim Lesen von /proc/stat', 'error');
        else cpuLast(text);
    });
}

schedule('*/10 * * * * *', getStat);

und das für die Chip-Temperatur:

// Chiptemperatur

var tempid = getIdByName("Service.Pi-Temperatur");

var temp = require("pi-temperature");

function pitemp() {
    temp.measure(function(err, temp) {
        if(err) log('Fehler Pi-Temperatur', 'error');
        else setState(tempid, temp, true);
    });
}

schedule("*/1 * * * *", pitemp);