UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[Rene55]

@sborg Danke für die schnellen Antworten. Ja sicher, ob der Wind vor nem Jahr aus Osten kam ist sicher nicht wichtig. Ich hatte mich anhand des Dashboards hier angenähert. Da sah ich eigentlich nur vier Datenpunkte, die im long waren (Aussentemperatur, Temperatur_außen_Max_24h, Temperatur_außen_Min_24h und Solarenergie_Vortag). Wobei die Werte möglicherweise ja auch ins short könnten - oder liege ich da falsch? Welchen Ansatz verfolgst du denn, um den überflüssigen Datensalat zu entsorgen?

[Rene55]

@sborg Da ich gerade so schön tief im Dashboard stecke. Welcher Adapter liefert denn die Ozon-Werte?

[Latzi]

@rene55 sagte in [Linux Shell-Skript] WLAN-Wetterstation:

Ozon-Werte

z.B.

[Rene55]

@latzi Danke dafür! Jetzt habe ich auch Ozon-Werte. Hast du das Wetterstation-Dashboard_V3 am laufen? Ich hab da einige leere und blöd aussehende Felder drin.

[Latzi]

@rene55 sagte in [Linux Shell-Skript] WLAN-Wetterstation:

Wetterstation-Dashboard_V3

nein, verwende ich nicht!

[Rene55]

@latzi ok, trotzdem Danke.

[SBorg]

@rene55 sagte in [Linux Shell-Skript] WLAN-Wetterstation:

@latzi Danke dafür! Jetzt habe ich auch Ozon-Werte. Hast du das Wetterstation-Dashboard_V3 am laufen? Ich hab da einige leere und blöd aussehende Felder drin.

Wenn du sie füllen willst dann sag doch mal welche fehlen. Das Dashboard hatte ich für mich erstellt, wurde dann aber gebeten es öffentlich zu stellen. Deswegen sind da auch Dinge drin wie bspw. "Ozon" was überhaupt nichts mit dem WLAN-Skript zu tun hat. Ein oder zwei Dinge basieren auch auf einem JS (glaube Temperatur in 3 Stunden).

Solange es im Thema "Wetter" bleibt habe ich hier auch keine Probleme mit Fragen über Grafana/Influx, nur keine allgemeine Fragen diesbzgl. wie zB. "wie komme ich denn in Influx an die Daten meines Smartmeters..."

[Rene55]

@sborg Besten Dank. Auch dafür, dass du das .json veröffentlicht hast. Vorweg: das alte Dashboard mit Influx1 habe ich derzeit auch noch laufen. Aber ich möchte den alten Ballast mal abwerfen. Ja konkret Ozon bekomme ich jetzt wahrscheinlich hin. Stimmt auch "Temperatur in 3 Stunden" fehlt (oder würde mir fehlen). Dann habe ich genau unter UV Index ein Panel, in dem keine Abfrage drin ist. OK, könnte ich löschen. Der größte Missstand ist der, dass ich z.B beim Regen dieses sehe:

Ich denke, ich hab da auch noch ein grundlegendes Problem mit Mehrfachdaten.

[SBorg]

@negalein sagte in [Linux Shell-Skript] WLAN-Wetterstation:

@sborg sagte in [Linux Shell-Skript] WLAN-Wetterstation:

Also schmeiße ich die per Task (glaube 7 Tage) kpl. aus der DB raus

kannst du das genauer erklären?

Hab mir dazu schon öfter was im Netz gesucht. Aber so richtig schlau, wie wo was konfiguriert werden muss, hab ich nichts vernünftiges gefunden.

+ @Rene55

Da wirst du so auch nichts "gutes" finden, denn Flux beherrscht kein "drop" von Datenreihen. Mit einem einfachen Task ist da nichts zu machen. Meine Lösung war (ich nutze sie auch nicht mehr) weder richtig praktikabel, geschweige denn massentauglich. Das war auslagern der gewünschten Daten, kpl. Reihe droppen und die ausgelagerte wieder importieren.
Sehr, sehr System lastig und durch den Im- und Export gehen auch definitiv Daten verloren, da alles was in dem Zeitraum Export - droppen - Import in die InfluxDB an neuen Daten geschrieben wird geht unweigerlich den Weg ins Nirvana.

Aus Zeitmangel speichere ich aktuell einfach alles. Mein NAS hat im Moment 20TB, da ist noch Platz (auch für zusätzliche HDDs).
Der Zukunftsplan sieht dann aggregieren vor wo es Sinn macht (Temperatur genügt IMO alle 15 Minuten ein Messwert) und leider per Bash-Skript und Cronjob dann droppen der nicht benötigten Daten per Influx-CLI. Eine andere praktikable Lösung sehe ich aktuell nicht. Das Hauptproblem dabei ist, man kann halt nicht das aktuelle Bucket bearbeiten. Man muss immer alles in ein anderes Bucket schreiben. Verweist man bei Grafana auf das "neue" Bucket fehlen aktuelle Daten (außer man lässt den Task alle x Minuten laufen), nimmt man das "aktuelle" Bucket muss man die Daten in diesem auch zumindest für 365 Tage vorhalten :(

[Rene55]

@sborg Das hört sich für mich gerade so an, als ob das aufspalten in long/short eigentlich gar nichts bringt.
Ergo: speichern bis die Platte voll ist; ja oder bis kurz davor, damit man noch was retten kann. Oder einen Fummel schreiben, der aus dem Datenwust, irgendetwas komprimiertes macht. Noch keine Ahnung, was das sein könnte.

[SBorg]

@rene55
Jupp, da fehlt wohl bisserl was beim Regen. Irgendwie finde ich im neuen Grafana gerade nicht den JSON-Export für ein Panel...
Hier ist mal mein JSON, allerdings müsstest du da überall die "uid": "ssI1YtJ4z" durch die UID deiner InfluxDB vor dem Import ersetzen.

Regentabelle

{
 "datasource": {
   "uid": "000000001",
   "type": "influxdb"
 },
 "fieldConfig": {
   "defaults": {
     "custom": {
       "align": "left",
       "cellOptions": {
         "type": "auto"
       },
       "inspect": false,
       "filterable": false
     },
     "mappings": [],
     "thresholds": {
       "mode": "absolute",
       "steps": [
         {
           "color": "green",
           "value": null
         }
       ]
     },
     "color": {
       "mode": "thresholds"
     },
     "decimals": 1,
     "displayName": "${__field.name}"
   },
   "overrides": [
     {
       "matcher": {
         "id": "byName",
         "options": "Field"
       },
       "properties": [
         {
           "id": "displayName",
           "value": "Zeitraum"
         },
         {
           "id": "custom.align",
           "value": "left"
         }
       ]
     },
     {
       "matcher": {
         "id": "byName",
         "options": "Last"
       },
       "properties": [
         {
           "id": "displayName",
           "value": "Regenmenge"
         },
         {
           "id": "custom.align",
           "value": "left"
         },
         {
           "id": "decimals",
           "value": 1
         },
         {
           "id": "unit",
           "value": "mm"
         }
       ]
     }
   ]
 },
 "gridPos": {
   "h": 7,
   "w": 5,
   "x": 9,
   "y": 12
 },
 "id": 79,
 "options": {
   "showHeader": true,
   "cellHeight": "sm",
   "footer": {
     "show": false,
     "reducer": [
       "sum"
     ],
     "countRows": false,
     "fields": "",
     "enablePagination": false
   }
 },
 "pluginVersion": "10.2.3",
 "targets": [
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.Statistik.Wetter.VorTag.Regenmenge\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ Gestern\")\r\n  |> yield(name: \"Gestern\")\r\n  ",
     "refId": "B",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   },
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.${Data_Ordnername}.Regen_Tag\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ Heute\")\r\n  |> yield(name: \"Heute\")\r\n\r\n  ",
     "refId": "C",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   },
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.${Data_Ordnername}.Regen_Woche\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ aktuelle Woche\")\r\n  |> yield(name: \"aktuelle Woche\")\r\n\r\n  ",
     "refId": "D",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   },
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.${Data_Ordnername}.Regen_Monat\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ aktueller Monat\")\r\n  |> yield(name: \"aktueller Monat\")\r\n\r\n  ",
     "refId": "E",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   },
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.${Data_Ordnername}.Regen_Jahr_kumuliert\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ aktuelles Jahr\")\r\n  |> yield(name: \"aktuelles Jahr\")\r\n\r\n  ",
     "refId": "F",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   },
   {
     "datasource": {
       "type": "influxdb",
       "uid": "ssI1YtJ4z"
     },
     "alias": "☂️ Heute",
     "groupBy": [
       {
         "params": [
           "$__interval"
         ],
         "type": "time"
       },
       {
         "params": [
           "none"
         ],
         "type": "fill"
       }
     ],
     "hide": false,
     "measurement": "0_userdata.0.Wetterstation.Regen_Tag",
     "orderByTime": "ASC",
     "policy": "default",
     "query": " from(bucket: \"${DatenBucket}\")\r\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\r\n  |> filter(fn: (r) => r._measurement == \"${Data_Prefix}.${Data_Instanz}.${Data_Ordnername}.Info.Regenmenge_VorJahr\" and r._field == \"value\")\r\n  |> set(key: \"_field\", value: \"☂️ VorJahr\")\r\n  |> yield(name: \"VorJahr\")\r\n\r\n  ",
     "refId": "G",
     "resultFormat": "time_series",
     "select": [
       [
         {
           "params": [
             "value"
           ],
           "type": "field"
         },
         {
           "params": [],
           "type": "last"
         }
       ]
     ],
     "tags": []
   }
 ],
 "transformations": [
   {
     "id": "reduce",
     "options": {
       "includeTimeField": false,
       "labelsToFields": true,
       "mode": "seriesToRows",
       "reducers": [
         "last"
       ]
     }
   }
 ],
 "transparent": true,
 "type": "table",
 "description": ""
}

---

Temperatur in 3h geht über den Adapter "Das Wetter" und ein kleines JS:

const idTemp = '0_userdata.0.Data.Temperatur_in_3h';
if (!existsState(idTemp)) { createState(idTemp, 0, { name: "erwartete Aussentemperatur in 3 Stunden", type: "number", role: "state", unit: "°C" }); }

schedule('2 * * * *', function () {
   let hours3 = new Date().getHours() + 3;
   let id = 'daswetter.0.NextHours.Location_1.Day_1.Hour_' + hours3 + '.temp_value';

   if(hours3 > 24) { 
      hours3 -= 24;
      id = 'daswetter.0.NextHours.Location_1.Day_2.Hour_' + hours3 + '.temp_value';
    }

    setState(idTemp, getState(id).val, true);
});

Das leere Panel unter UV-Index existiert bei mir nicht mehr, aber das könnte das Panel für das "Boom-Theme" sein. Das ist eigentlich auf unsichtbar gestellt, darüber kann man aber das Hintergrundbild auswählen.

---

Mit dem long/short bin ich noch unschlüssig. Eine Idee wäre in ein "Tages-Bucket" zu schreiben. Hierauf würden dann aktuelle Werte von Grafana (short) verweisen. Per Tasks wird dann alles kopiert, aggregiert und ins long geshifftet. Hierauf verweist dann Grafana auf alles was eben nicht "heute" ist (zB. Temperaturgraf der letzten 365 Tage).
Die Retention für dieses "Tages-Bucket" könnte dann bspw. 5 Tage sein, sprich alles älter als 5 Tage wird automatisch aus diesem Bucket gelöscht. Deswegen ist die Idee mit mehreren Buckets nicht abwegig, da man pro Bucket die Retention wählen kann ;)

[Rene55]

@sborg Mega Danke. Ich werde mich jetzt erstmal um die uid kümmern und dein Script einbauen. Damit komme ich bestimmt weiter. (Hab aber bestimmt noch weitere Fragen) :blush:
Tasks wird dann alles kopiert, aggregiert und ins long geshifftet das wäre sowas, wie ich oben den Fummel betitelt hatte.

[Nashra]

@SBorg
welchen Adapter nutzt du für die Ozonwerte?

[SBorg]

@nashra
Keinen, mir ist auch keiner bekannt, ich nutze (wie bei mir fast üblich :blush: ) ein Linux Shell-Skript.
Bevor nun wieder die Frage kommt: nein, das kann ich schlecht zur Verfügung stellen, da es die Daten vom HLNUG bezieht und somit nur für Hessen gültig ist.

Weil aber bestimmt hier wieder Begehrlichkeiten geweckt wurden (nehme ich mal an :innocent: ), habe ich mir heute morgen mal Gedanken gemacht und bin auf die Suche gegangen.
Übrig bleibt eigentlich nur das "Umwelt Bundesamt", da es für ganz Deutschland Daten liefert (sry @Negalein), auch kleinere Stationen. Leider keine API verfügbar und https://www.umweltbundesamt.de/daten/luft/luftdaten/luftqualitaet/ verlangt das ausfüllen der gewünschten Daten (ist hier nicht einfach zu automatisieren, da darüber ein Einmal-Token generiert wird).
Aber wird sind ja nicht blöd :joy:
Über die "Stationen" kommen wir zwar zu einer ähnlichen Eingabemaske, aber nach dem ausfüllen erhalten wir einen nutzbaren Link "Station herunterladen". Per MouseOver erkennen wir nun auch einen für uns nutzbaren Link 8)
Beispiel: https://www.umweltbundesamt.de/api/air_data/v3/measures/csv?date_from=2024-01-18&time_from=11&date_to=2024-01-18&time_to=11&data%5B0%5D%5Bco%5D=3&data%5B0%5D%5Bsc%5D=2&data%5B0%5D%5Bst%5D=533&lang=de
Also doch eine (nicht öffentliche) API. Die Daten könnte ich automatisieren, man muss es nur einmalig per Frontend ausfüllen damit man seine StationID bekommt. In der heruntergeladenen CSV steht dann der Ozonwert drin :grinning:

[Nashra]

@sborg
nö lass mal, so wichtig ist das nicht. Aber trotzdem danke fürs suchen :-)

[Boronsbruder]

@sborg
Doch öffentliche Api ;)
Git-Hub zur Luftqualität-Api des Bundes
Dokumentation der Api

Beispiel Daten für Ulm:
(https://umweltbundesamt.api.proxy.bund.dev/api/air_data/v2/airquality/json?date_from=2024-01-18&time_from=13&date_to=2024-01-18&time_to=13&station=228&lang=de)

{
     "request": {
            "station": "228",
            "date_from": "2024-01-18",
            "date_to": "2024-01-18",
            "time_from": "13:00:00",
            "time_to": "13:00:00",
            "lang": "de",
            "index": "id",
            "datetime_from": "2024-01-18 12:00:00",
            "datetime_to": "2024-01-18 12:00:00"
      },
      "data": {
            "228": {
                  "2024-01-18 12:00:00": [
                        "2024-01-18 13:00:00",
                        1,
                        0,
                        [
                              3,
                              64,
                              1,
                              "1.051"
                        ],
                        [
                              5,
                              9,
                              0,
                              "0.45"
                        ],
                        [
                              1,
                              7,
                              0,
                              "0.35"
                        ]
                  ]
            }
      },
      "indices": {
            "data": {
                  "Id of station - string": {
                        "Date of measure start in CET - string": [
                              "0: Date of measure end  in CET - string",
                              "1: Airquality index for all components - integer",
                              "2: Data incomplete (0|1) - integer",
                              [
                                    "0: Id of component id - integer",
                                    "1: Value - number",
                                    "2: Airquality index of this component- integer",
                                    "3: Decimal representation of Airquality index of this component - string"
                              ]
                        ]
                  }
            }
      },
      "count": 1

}

=> 64 µg/m³ Ozon / 9 µg/m³ NO2 / 7 µg/m³ Feinstaub PM10

Man kann anstatt der 228 auch die von der Stationsseite den angezeigten Code DEBW019 der Station verwenden

Und anscheinend gibts auch schon ne Api v3

Da kommt bei der Station dann sogar ein PM2.5-Wert mit

[Rene55]

@boronsbruder Das schreit ja förmlich nach einem neuen Adapter

[Negalein]

@sborg sagte in [Linux Shell-Skript] WLAN-Wetterstation:

sry @Negalein)

No Problem.
Ich brauch Ozon nicht.
Wenn doch, verwende ich einen deutschen Ort.
Kann von Ö nach DE rüber spucken. :joy: :joy:

[Boronsbruder]

@rene55
Adapter kann ich nicht.
Skripten ein bischen, deswegen hab ich für euch/uns Daten-Fetischisten mal mit nem Skript angefangen:

// Luftqualität v1

// User Einstellungen

const stations = ["DEBW019"]; // Stationen, können durch Komma getrennt werden z.B. ["DEBW019", "DEBY007"]
const datenpunkt_pre ="0_userdata.0" // => wird in 0_userdata.0.Luftqualität gespeichert
const debug = false;
//  Abfrage findet um **:05 und **:10 stündlich statt (um fehlende Daten eventl. nachzufüllen). Die Daten werden sowieso nur stündlich von der letzten Stunde zur Verfügung gestellt...

// Datenverarbeitung 

var dp_path = datenpunkt_pre + ".Luftqualität.";
var timer;
var components;
var stations_list;

const fetch = require('node-fetch');

function createBaseFolder(ID, type, name)
{
/** geklaut bei grrfield
 * Erstellt Basisfolder und stellt den richtigen Typ ein
 * @param   {string}    ID          ID des Folders
 * @param   {any}       type        Typ des Folders
 * @param   {string}    [name]      (optional) Name des Folders
 */  

    createState(ID, function() {
        let obj=getObject(ID);
        obj.type=type;
        if(name != undefined) obj.common.name=name;
        obj.common.role='';
        setObject(ID, obj);
    });
}

const get_stations = async () => {
    const url_stations = "https://umweltbundesamt.api.proxy.bund.dev/api/air_data/v3/stations/json?lang=de";
    var stations_json = fetch(url_stations)
        .then(response => response.json())
        .then(data => {
            //if (debug) console.log(data);
            return data})
        .catch ((err) => {
        console.error("failed fetch " + err);
        
    }
    );
    return stations_json;
}

const send_request = async (station_code) => {
        const d = new Date();

let hour = d.getHours()-1;
let date = d.getFullYear + "-" + d.getMonth + "-" + d.getDay;

        const url_server = "https://umweltbundesamt.api.proxy.bund.dev/api/air_data/v3/airquality/json?date_from=" + date + "&time_from=" + hour + "&date_to=" +date +"&time_to=" + (hour +1) + " &station=" + station_code + "&lang=de";
        var request = fetch(url_server)
        .then(response => response.json())
        .then(data => {
            if (debug) console.log(data);
            return data})
        .catch ((err) => {
        console.error("failed fetch " + err);
  
    }
    );
    return request;

};

const get_components = async () => {
        var list = fetch("https://umweltbundesamt.api.proxy.bund.dev/api/air_data/v3/components/json?lang=de&index=id")
        .then(response => response.json())
        .then(data => {
            if (debug) console.log(data);
            return data})
        .catch ((err) => {
        console.error("failed fetch " + err);
        
    }
    );
    return list;
};

async function get_data (station_code) {
      
    var data = await send_request(station_code);

    if (!existsObject(dp_path + station_code)){
        if (debug) console.warn("not exist => " +  stations_list.data[data.request.station][2]);
        createBaseFolder(dp_path + station_code, "folder", stations_list.data[data.request.station][2]);
    }
    var measure_set = data.data[data.request.station][data.request.datetime_from];
    
    for (let i = 3 ; i < measure_set.length; i++) {
    
        var id = dp_path + station_code + "." + components[measure_set[i][0]][1];
        if (debug) console.log ("ID: " + id);
        existsState(id, (err, isExists) => {
            var idwork = dp_path + station_code + "." + components[measure_set[i][0]][1];
            if (debug){
                console.log ("IDwork: " + idwork);
                console.log ("initval: " + measure_set[i][1]);
                console.log ("Name: " + components[measure_set[i][0]][4] + "(" + components[measure_set[i][0]][1] + ")");
                console.log ("unit: " + components[measure_set[i][0]][3]);
            }
            if (err) console.error (err);
        
            if (isExists) {
                if (debug) console.log ("Exists writing new value");
                setState(idwork,  measure_set[i][1]);
            }
        
            else{
                if (debug) console.log ("Not Exists - creating State");
                createState(idwork, measure_set[i][1], { name: components[measure_set[i][0]][4] + " (" + components[measure_set[i][0]][2] + ")", unit: components[measure_set[i][0]][3], type: "number", role: "value", read: true, write: true} , () => { log('Dp '+ idwork + ' erstellt!'); });
            }
        });
    }
}
onStop (() => {
    clearSchedule(timer);
});
async function init(){
    stations_list = await get_stations();
    components = await get_components();
    stations.forEach (get_data); // init für sofortige Datenverfügbarkeit

    // timer um */5 und */10
    timer = schedule({minute: [5,10]}, () => {
    stations.forEach (get_data);
});
}

init();

Funktion:
auf der SEITE des Umwelbundesamtes die StationsID raussuchen

Es können auch mehrere Stationen durch Komma getrennt im Skript eingetragen werden.
Dann werden die Daten (letzter Stündlicher Mittelwert) unter dem eingestellten Datenpunkt um **:05 und **:10 gespeichert.

Ich plane noch die "Airquality indexes" hinzuzufügen.

[Rene55]

@boronsbruder Ich schau mal, ob es da schon eine Anfrage auf einen Adapter zu diesem Thema gibt. Danke für dein Engagement, aber wir sollten den Thread hier nicht weiter volltexten sondern wenn du willst in einem Neuen.