Node.js 24 ist jetzt offiziell empfohlen!

[Agrippinenser]

@dering sagte:

hast du ein abschließendes ]?

ja, beide sind so aufgebaut: ( wobei Label des aktuellen Jahr 01-08 und des Vorjahr 01-12 ist.

[
  {
    "label": "01",
    "value": "486.1276999999973"
  },
  {
    "label": "02",
    "value": "431.4953000000023"
  },
  {
    "label": "03",
    "value": "402.8855000000003"
  },
  {
    "label": "04",
    "value": "366.4457000000002"
  },
  {
    "label": "05",
    "value": "356.8279999999977"
  },
  {
    "label": "06",
    "value": "327.6875"
  },
  {
    "label": "07",
    "value": "326.859800000002"
  },
  {
    "label": "08",
    "value": "320.52289999999994"
  }
]

[dering]

Im Screenshot sagt der rote Text eigentlich was das Problem ist. Im Modus Zeitreihe muss im JSON ein Zeitstempel enthalten sein. Du musst auf den Modus JSON wechseln, dann sieht es so aus:

in der nächsten Version (0.52.5) ist ein Hinweis eingebaut.

[Agrippinenser]

@dering sagte:

Modus JSON wechseln

ja, hatte ich gelesen. Leider habe ich die 4 Schalter oben links übersehen. Hatte den Schalter irgendwo rechts gesucht.
Funktioniert nun vielen Dank !

[FredF]

@dering super wie es hier weiter geht.
Eine bescheidene Frage: Aus welchem Grunde nutzt du nicht den MCP Server den ioBroker selbst anbietet?

[dering]

@FredF Der iobroker-mcp kennt ja nicht die Möglichkeiten die Aura anbietet. Der aura-mcp liefert dir das und die KI weiß dann was damit anzufangen.
Man sollte aber beides verwenden. Mit dem iobroker-mcp bekommst du alle Datenpunkte und mit dem aura-mcp baust du dann ein Dashboard.

[sigi234]

Hallo,

kann mir wer erklären wie das mit dem AI assistant (MCP) geht ein Dasboard zu erstellen?

[TbsJah]

An die Frage schließe ich mich an

[dering]

@sigi234 @tbsjah
https://hdering.github.io/ioBroker.aura/einstellungen/mcp

[JoJo58]

@sigi234 @dering @tbsjah

Ich musste auch etwas suchen und hatte es falsch verstanden. Ich habe Claude Desktop installiert und das war falsch, der konnte auch nichts damit anfangen, wenn ich ihm sage er soll einen MCP Server hinzufügen.
Man muss wirklich "Claude Code" haben. Ich habe das denn direkt über PowerShell installiert:

irm https://claude.ai/install.ps1 | iex

Dann kommt der Hinweis das man claude.exe noch zur Path Variablen hinzufügen muss.

Claude dann über PS gestartet und da kommt dann auch die Abfrage, wie man sich anmelden will, da ich kein Pro oder so habe, habe ich API genommen, den nutze ich eh schon.
Angemeldet, ein paar Dinge bestätigt, Claude neu gestartet und dann gings los.

Als erstes sollte ein Tab MCP-Test mit einem Widget angelegt werden. Da es noch kein Layout gab, kam die Rückfrage, ob eines angelegt werden soll usw., danach wurde es auch gemacht.
Zu Beginn muss man oft bestätigen, das man das zulassen will, aber das finde ich schon korrekt und muss sein.
Als das Dashboard und der Tab angelegt waren, habe ich eine etwas schwierigere Aufgabe gestellt. 4 Widgets mit den Außentemperaturen.
Es gab Nachfragen und ich hatte mehrere Änderungswünsche, aber es wurde alles umgesetzt und ein weiterer Tab wurde angelegt und dann wurde es witzig (oder spuki?), ich habe zugesehen, wie die Widgets erstellt wurden, die Werte ankamen, die Größe und Position geändert wurde usw..

Ich bin begeistert, muss aber sagen, da ich über API abgerechnet werde, ist mir das dann doch etwas zu teuer. Wenn ich es weiter nutze, werde ich mir ein Claude Pro Konto zulegen, das kostet monatlich und da ist Code mit drin.

Also wie schon gesagt, ich bin immer wieder begeistert von Aura und der ganzen Entwicklung die der Adapter da hinlegt.

Gruß, Johannes

[beetle-fan]

Ich nutze seit neustem auch AURA und bin wirklich begeistern vom UI. Klar sind bei Vis2 die Möglichkeiten sicherlich noch viel größer/weiter, mir gefällt aber insb. das optische Ergebnis der AURA Dashboards - das sieht einfach von sich aus (für mich) ansprechender aus.

Ich würde gerne ein älteres iPad Air als Dashboard-Gerät nutzen. Wenn ich das Dashboard über die URL aufrufe steht da allerdings immer "nicht verbunden" und es zeigt nichts an? An meinem iPad Pro funktioniert es hingegen, genauso wie am Laptop. Hat jemand eine Idee, woran das liegen kann?

[Agrippinenser]

Ich habe einige Widgets kopiert, eingefügt und anschließend angepasst. Seitdem wird in allen Dashboards unten links diese ID dargestellt. Irgendetwas ist dabei schief gegangen.

Wie bekomme ich das korrigiert ?

[JoJo58]

@Agrippinenser

Im Backend links auf Einstellungen und dann den Haken bei "ID-Badge auf jedem Gerät anzeigen" rausnehmen.

Gruß, Johannes

[Agrippinenser]

Danke, das hat geholfen.

[Agrippinenser]

das ist mein Stand :

LG

[beetle-fan]

Ich zitiere mich mal selbst :

Ich würde gerne ein älteres iPad Air als Dashboard-Gerät nutzen. Wenn ich das Dashboard über die URL aufrufe steht da allerdings immer "nicht verbunden" und es zeigt nichts an? An meinem iPad Pro funktioniert es hingegen, genauso wie am Laptop. Hat jemand eine Idee, woran das liegen kann?

Also nochmal: wenn ich dir URL öffne, zeigt das iPad zwar die Aura Oberfläche, aber nicht das Dashboard, Status oben rechts sagt "nicht verbunden". Alle Geräte sind natürlich im gleichen Netzwerk.

[icebear]

@Agrippinenser said:

das ist mein Stand :

Darf ich dich mal fragen welche Adapter bzw. welches Script du nutzt um die Telefone von der FB abzufragen bzw anzuzeigen?

[dering]

@beetle-fan ist Aura per http oder https erreichbar?
Wenn https, dann würde ich Mal ohne Zertifikat testen.

[beetle-fan]

Zugriff per http.

Ich konnte das Problem aber lösen: im Web-Adapter musste ich die Option "Reine Web-Sockets (iobroker.ws) verwenden" deaktivieren. Nun wird das Dashboard angezeigt.

Danke trotzdem!

[Agrippinenser]

@icebear sagte:

Darf ich dich mal fragen welche Adapter bzw

gerne:-) also das ist eher ein über viele Jahre immer mal wieder hier und dort angepasstes Bastelwerk - aber es funktioniert. Ich schaue gleich mal drüber um persönlichen Kram rauszunehmen und wenn ich mich dann noch traue poste ich.
Adapter war TR064.

[Agrippinenser]

@icebear sagte:

Script du nutzt um die Telefone von der FB abzufragen bzw anzuzeigen?

Wir nutzen ein Telefonbuch mit gesperrten Nummern und zudem 29 Rufnummernbereiche. Mehr als 30 lässt AVM nicht zu. Bei Anruf wird die eingehende Nummer mit den Sperrlisten abgeglichen, abgewiesen und in die Liste der gesperrtem eingetragen.
Alle anderen Anrufer kommen durch und ein hinterlegtes Bild wird zu Anzeige aktualisiert.
Der Status der einzelnen Telefone wird aus den "tr-064.0.callmonitor.toPauseState*" ermittelt.
Bilder liegen in einem NAS-Verzeichnis.

Wie oben gesagt habe ich über die Jahre hinweg daran gebastelt und vieles kann sehr wahrscheinlich verbessert werden. Tipps nehme ich gerne an .
LG

Verwendetes CSS

Spoiler

@keyframes yellow-blink {
 0%,50% {filter: drop-shadow(0px 0px 4px #FFDB3B) drop-shadow(0px 0px 4px #FFDB3B) drop-shadow(0px 0px 4px #FFDB3B); }
 51% {filter: none;}
}
.gelbblink {  
 animation: yellow-blink 2s infinite;
}
@keyframes red-blink {
0%,50% {filter: drop-shadow(0px 0px 4px #f13164) drop-shadow(0px 0px 4px #f13164) drop-shadow(0px 0px 4px #f13164); }
 51% {filter: none;}
}
.rotblink {  
 animation: red-blink 2s infinite;
}
.red { color:#f44336 !important; }
.deeporange { color:#ff5722 !important; }
.lime { color:#cddc39 !important; }
.lightgreen { color:#8bc34a !important; }
.yellow { color:#ffeb3b !important; }
.white { color:#f8f8f8 !important; }
.grey { color:#9e9e9e !important; }

Skript Rufbehandlung

Spoiler

//const moment = require('moment');
const fs = require('fs');

//let idrufegesperrt = "0_userdata.0.vis.Tabellen.eingehendgesperrt";
let idrufegesperrt = '0_userdata.0.Telefon.gesperrteAnrufe';
let idAnrufe = '0_userdata.0.Telefon.Anrufe';
let jsontab = [];

// zur Anzeige in VIS
createState(
   idrufegesperrt,
   JSON.stringify(jsontab),
   false,
   { type: 'string', name: 'unerwuenschte Anrufe' },
   function () {},
);
createState(idAnrufe, JSON.stringify(jsontab), false, { type: 'string', name: 'Anrufe' }, function () {});

const maxUnerwuenschteAnrufer = 99; // Tabelleneinträge begrenzen
const maxAnrufe = 99; // Tabelleneinträge begrenzen

const vorwahl = '0xxxxx';
// MSN, Gerätename, Anruf auf Alexa ausgeben
const arrAnschluss = [
   { AnschlussNr: '11111', Name: 'Anschluss 0', Ansage: false },
   { AnschlussNr: '2222', Name: 'Anschluss 1', Ansage: false },
   { AnschlussNr: '33333', Name: 'Anschluss 2', Ansage: false },
   { AnschlussNr: '4444', Name: 'Anschluss 3', Ansage: true },
   { AnschlussNr: '5555', Name: 'Anschluss 4, Ansage: false },
   { AnschlussNr: '6666', Name: 'Anschluss 5', Ansage: false },
   { AnschlussNr: '7777', Name: 'Anschluss 6', Ansage: false },
   { AnschlussNr: '8888', Name: 'Anschluss 7', Ansage: true },
   { AnschlussNr: '9999', Name: 'Anschluss 8', Ansage: true },
   { AnschlussNr: '00000', Name: 'Anschluss 9', Ansage: true }
];

var push = true; // Ausgabe Pushover
var clog = true; // Ausgabe ins Logfile

var AnruferName = ''; // Name des Anrufern
var AnruferNummer = ''; // Nummer des Anrufern
var AnschlussName = ''; // Bezeichnug des Hausanschlusses
var AnschlussNummer = ''; // Nummer des Hausanschlusses


on({ id: 'tr-064.0.callmonitor.inbound.json' /*json*/, change: 'any' }, function (obj) {

   var jObj = JSON.parse(obj.state.val);

   AnruferNummer = jObj.caller; // Nummer des Anrufers
   AnruferName = jObj.callerName; //Name des Anrufers
   AnschlussNummer = jObj.callee.replace(vorwahl, ''); //eigene Nummer ohne Vorwahl
   AnschlussName = AName(AnschlussNummer); //Bezeichnung des Telefonanschlusses

   //Anrufer nicht im Telefonbuch, dann Ansage der eingehenden Nummer
   if (AnruferNummer.length > 0 && AnruferName.length == 0) {
       AnruferName = AnruferNummer;
   } else {
       // Anfufer sendet keine Nummer
       if (AnruferNummer.length == 0) {
           AnruferName = 'verdeckter Anrufer';
       }
   }

   // wenn Anrufer gesperrt dann Spaemmer in Tabelle speichern und ggf. Pushnachricht
   if (istRufnummernbereichgesperrt(AnruferNummer) || istSperrTelefonbuch(AnruferName)) {
       const jsonObj = JSON.parse(getState(idrufegesperrt).val);
       const jsontrimmed = jsonObj.slice(-maxUnerwuenschteAnrufer);

       jsontrimmed.push({
           id: Date.now(),
           _type: jObj._type,
           timestamp: jObj.timestamp,
           caller: jObj.caller,
           callee: jObj.callee,
           calleeName: jObj.calleeName,
       });

       jsontrimmed.sort((a, b) => b.id - a.id);
       setState(idrufegesperrt, JSON.stringify(jsontrimmed));

       if (push) {
           var nachricht =
               'von: <font color="#ff4d00">' +
               AnruferName +
               '</font>\n' +
               'Nr.: <font color="#ff4d00">' +
               AnruferNummer +
               '</font>\n' +
               'auf: <font color="#ff4d00">' +
               AnschlussName +
               '</font>';
           fPush(nachricht, 'Anruf', 'intermission');
       }

       //Bild von Synology/Kontakte auf gemountetes Verzeichnis legen
       BildVisualisieren('spammer');

       return;
   }
   
   if (push) {
       var nachricht =
           'von: <font color="#00CD00">' +
           AnruferName +
           '</font>\n' +
           'Nr.: <font color="#00CD00">' +
           AnruferNummer +
           '</font>\n' +
           'auf: <font color="#00CD00">' +
           AnschlussName +
           '</font>';
       fPush(nachricht, 'Anruf', 'intermission');
   }

   //Bild von Synology/Kontakte auf gemountetes Verzeichnis legen
   BildVisualisieren(AnruferNummer);
});

//----------------------------------------------------------------------------------------------------------------
// Tabelle Anrufe aktualisieren
// ---------------------------------------------------------------------------------------
on({ id: 'tr-064.0.calllists.all.json', change: 'any' }, function (calllistsobj) {

   // Neue Anrufdaten einlesen
   const call = JSON.parse(calllistsobj.state.val)[0];

   // Bestehende Anrufliste einlesen
   const anrufe = JSON.parse(getState(idAnrufe).val || '[]');

   // Richtung / Modus bestimmen
   let modus = '';
   
   if (call.path.length > 0) {
       modus = '<span class=\"deeporange\">#AB</span>';
   } else if (call.device === 'Anrufbeantworter') {
       modus = '<span class=\"grey\">-AB</span>';
   } else if (call.sym === '>') {
       modus = '<span class=\"yellow\">-IN</span>';
   } else if (call.sym === '<') {
       modus = '<span class=\"lightgreen\">OUT</span>';
   } else if (call.sym === 'x') {
       modus = '<span class=\"grey\">-X-</span>';
   }
   
   // Name bestimmen, fall nicht vorhanden Nummer eintragen
   const name = call.name && call.name.length > 0
       ? call.name
       : call.called;

   // Neuen Anruf hinzufügen
   anrufe.push({
       id: Date.now(),
       Richtung: modus,
       Zeit: call.date,
       Name: name,
       Dauer: call.duration
   });

   // Neueste Anrufe zuerst und auf maxAnrufe begrenzen
   anrufe.sort((a, b) => b.id - a.id);
   const anrufeBegrenzt = anrufe.slice(0, maxAnrufe);

   // Speichern
   setState(idAnrufe, JSON.stringify(anrufeBegrenzt));

   //Bild des Anrufers durch Platzhalter ersetzten
   BildVisualisieren('frei');

});

// Funktionen ---------------------------------------------------------------------------------------

/**
* @param {string} eingehend Nummer
*/
function BildVisualisieren(eingehend) {
   const SynoPath = '/mnt/synology/kontakte/';
   const CheckSynology = SynoPath + '0000000000.jpg';
   const SynoDown = '/home/iobroker/Synology_offline.jpg';

   var anrufer = eingehend;

   if (fs.existsSync(CheckSynology)) { 
       if (clog) {
           console.log('150-Synology gemountet');
       }

       // Anrufer sendet keine Nummer
       if (anrufer.length == 0) {
           const bild = fs.readFileSync(SynoPath + 'unterdrueckt.jpg');
           writeFile('vis-2.0', '/RHv2/images/anrufer.jpg', bild, function (error) {});
           if (clog) {
               console.log('156-unterdrueckt');
           }
       }

       // unbekannter Anrufer
       else if (!fs.existsSync(SynoPath + anrufer + '.jpg')) {
           const bild = fs.readFileSync(SynoPath + 'unbekannt.jpg');
           writeFile('vis-2.0', '/RHv2/images/anrufer.jpg', bild, function (error) {
               console.log(error);
           });
           if (clog) {
               console.log('165-unbekannt.jpg kopiert');
           }
       }

       // Anrufer bekannt
       else {
           const bild = fs.readFileSync(SynoPath + anrufer + '.jpg');
           writeFile('vis-2.0', '/RHv2/images/anrufer.jpg', bild, function (error) {});
           if (clog) {
               console.log('172-' + anrufer + '.jpg kopiert');
           }
       }
   } else {
       if (clog) {
           console.log('175-Synology nicht gemountet');
       }
       var datei = fs.readFileSync(SynoDown);
       writeFile('vis-2.0', '/RHv2/images/anrufer.jpg', datei, function (error) {});
   }
}

/**
* @param {string} eingehend
*/
function AName(eingehend) {
   for (var i = 0; i < arrAnschluss.length; i++) {
       if (arrAnschluss[i].AnschlussNr === eingehend) {
           return arrAnschluss[i].Name;
       }
   }
}

function istAnschlussansagen(eingehend) {
   for (var i = 0; i < arrAnschluss.length; i++) {
       if (arrAnschluss[i].AnschlussNr === eingehend) {
           return arrAnschluss[i].Ansage;
       }
   }
}

/*
* Prüft über ioBroker-Selektoren, ob die Nummer in einer Rufumleitung/Sperre liegt
* @param {string} eingehend - Anrufernummer
* @returns {boolean} True falls gesperrt
*/
function istRufnummernbereichgesperrt(eingehend) {
   let treffer = false;
   // Durchläuft alle FritzBox-Rufumleitungen/Sperren effizient
   $('tr-064.0.callForwarding.*').each((id) => {
       const obj = getObject(id);
       if (!obj || !obj.common || !obj.common.name) return;

       const parts = obj.common.name.split(' ');
       // Erwartetes Format: "fromNumber [NUMMER] -> ..."
       if (parts[0] === 'fromNumber' && parts[2] === '->') {
           const sperrNummer = parts[1];
           if (eingehend.startsWith(sperrNummer)) {
               if (clog) {console.log(`Nummer unerwünscht: ${eingehend} - FritzBox-Filter: ${sperrNummer}`);}
               treffer = true;
           }
       }
   });
   
   return treffer;
}

/*
* Prüft ob die Nummer im Sperr-Telefonbuch vorhanden ist
* @param {string} eingehend - Anrufernummer
* @returns {boolean} True falls gesperrt
*/
function istSperrTelefonbuch(eingehend) {
   var treffer = false;
   if (eingehend.startsWith('*')) {
       if (clog) {
           console.log('226-gesperrter Anrufer: ' + eingehend);
       }
       treffer = true;
   }
   return treffer;
}

/**
* @param {string} Nachricht
* @param {string} Titel
* @param {string} Sound
*/
function fPush(message, titel, sound) {
   if (clog) {
       console.log('250-Pushover:=' + titel);
   }
   sendTo('pushover.0', {
       message: message,
       title: titel,
       sound: sound,
       priority: 0,
       file: '',
       html: 1,
   });
}

Status Telefone

Spoiler

const Phones = "0_userdata.0.Telefon.phones";

// Vorgegebene Texte für die jeweiligen IDs
const PHONE_MAPPING = {
   "toPauseState-10": "Phone1",
   "toPauseState-11": "Phone2",
   "toPauseState-12": "Phone3",
   "toPauseState-13": "Phone4",
   "toPauseState-14": "Phone5"
};

// Kombiniertes Mapping für Text und CSS-Klasse je nach Status
const STATUS_CONFIG = {
   "ring":    { text: "klingelt",  css: "gelbblink" },
   "connect": { text: "verbunden", css: "red" },
   "end":     { text: "frei",      css: "lightgreen" }
};

// Generiert das ID-Array automatisch aus den Keys von PHONE_MAPPING
const triggerIds = Object.keys(PHONE_MAPPING).map(key => `tr-064.0.callmonitor.${key}`);
on({ id: triggerIds, change: 'any' }, function() {

   const anrufe = [];

   for (const [key, textName] of Object.entries(PHONE_MAPPING)) {
       const stateId = `tr-064.0.callmonitor.${key}`;
       const currentStatus = getState(stateId).val; // Liefert "ring", "connect" oder "end"

       // Holt die Konfiguration für den aktuellen Status (Fallback auf leere Standardwerte)
       const config = STATUS_CONFIG[currentStatus] || { text: "", css: "" };

       // HTML dynamisch mit der passenden CSS-Klasse zusammenbauen
       const statusHtml = config.css 
           ? `<span class="${config.css}">${config.text}</span>` 
           : `<span>${config.text}</span>`;

       anrufe.push({
           phone: textName,
           Status: statusHtml
       });
   }

   setState(Phones, JSON.stringify(anrufe));
});