Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. JavaScript
    5. [Vorlage] Xiaomi Airpurifier 3H u.a. inkl. Token auslesen.

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    [Vorlage] Xiaomi Airpurifier 3H u.a. inkl. Token auslesen.

    This topic has been deleted. Only users with topic management privileges can see it.
    • haselchen
      haselchen Most Active @LassMichIchMachDasSelberKaputt last edited by

      @lassmichichmachdasselberkaputt

      Unterstützt ja, aber die Datei musste selber kopieren.
      Haste das Modul im Adapter eingetragen ?

      L 1 Reply Last reply Reply Quote 0
      • L
        LassMichIchMachDasSelberKaputt @haselchen last edited by

        @haselchen

        Ja, das war der Zustand von meinem ersten Post. Sonst kommt das Script nicht so weit und meldet das fehlende Modul.

        haselchen 1 Reply Last reply Reply Quote 0
        • haselchen
          haselchen Most Active @LassMichIchMachDasSelberKaputt last edited by haselchen

          @lassmichichmachdasselberkaputt

          Hast du auch mal nen früheres Skript probiert?
          Hab dir mal meine 23er Version hier reingepackt.
          Haste axios auch als Modul in dem Adapter eingetragen?


          const SkriptVersion = "0.2.23"; //vom 30.06.2021 / Link zu Git: https://github.com/Pittini/iobroker-nodemihome / Forum: https://forum.iobroker.net/topic/39388/vorlage-xiaomi-airpurifier-3h-u-a-inkl-token-auslesen

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

          // Logindaten für Xiaomi Cloud:
          const username = 'XXXXXXX';
          const password = 'XXXXXXX';
          const options = { country: 'de' }; // 'ru', 'us', 'tw', 'sg', 'cn', 'de' (Default: 'cn');
          const refresh = 13000; // Alle 13sek neue Daten

          const praefix0 = "javascript.0.MiHomeAll"; //Root für Skriptdatenpunkte

          const logging = false; //Logging aktivieren/deaktivieren

          //Ab hier nix mehr ändern!
          /*

          1. Xiaomi Cloudlogin
          2. Alle dort gelisteten Geräte und deren Basicdaten abrufen
          3. Für alle abgerufenen Geräte Basic Channel/Datenpunkte anlegen
          4. Prüfen welche supporteten Geräte in der Auflistung vorhanden sind und die entsprechenden spezifischen Datenpunkte erstellen
          5. Basic Channels mit Daten füllen / einlesen
          6. devicearray erstellen via node-mihome und die Gerätespezifischen Werte einlesen
            */
            // ######### TESTBEREICH ################
            //const axios = require('axios');

          //let miotDefinition= getMiotData('https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-mc1:1');

          async function getMiotData(url) {
          if (logging) log("Reaching MiotUrlConstructor");
          try {
          const response = await axios.get(url, { timeout: 10000 });
          log("resp:" + JSON.stringify(response.data));
          for (let z in Object.keys(response.data.services)) {
          log("Keys=" + Object.keys(response.data.services[z]))
          log(JSON.stringify(response.data.services[z]))
          }

              return response.data;
          } catch (error) {
              console.error(error);
          }
          

          }

          function MiotUrlConstructor(miotdevice) {
          if (logging) log("Reaching MiotUrlConstructor");
          let BaseUrl = "https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:" + miotdevice;
          return BaseUrl;
          }

          // ################ ENDE TESTBEREICH ####################

          const DeviceData = [];
          let AllDevicesRaw = [];

          let device = [];

          const States = [];
          let DpCount = 0;
          log("Starting AllMyMi V." + SkriptVersion);

          Init();

          const DefineDevice = [];

          // ***************************** Device Definitions *************************

          // ***************************** Airpurifiers ********************************

          DefineDevice[0] = { // Tested and working
          info: {},
          model: "zhimi.airpurifier.mb3",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-mb3:2
          description: "Purifier 3H",
          setter: {
          "air-purifier.on": async function (obj, val) { await device[obj].setPower(val) },
          "air-purifier.mode": async function (obj, val) { await device[obj].setMode(val) },
          "motor-speed.favorite-fan-level": async function (obj, val) { await device[obj].setFavLevel(val) },
          "air-purifier.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setBuzzer(val) },
          "indicator-light.brightness": async function (obj, val) { await device[obj].setLcdBrightness(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "air-purifier.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "air-purifier.fault", type: "number", read: true, write: false, min: 0, max: 5, states: { 0: "No faults", 1: "m1_run", 2: "m1_stuck", 3: "no_sensor", 4: "error_hum", 5: "error_temp", 6: "timer_error1", 7: "timer_error2" } },
          { name: "air-purifier.mode", type: "number", read: true, write: true, min: 0, max: 3, states: { 0: "auto", 1: "sleep", 2: "favorite", 3: "fanset" } },
          { name: "air-purifier.fan-level", type: "number", read: true, write: true, min: 1, max: 3 },
          { name: "alarm.alarm", type: "boolean", read: true, write: true },
          { name: "indicator-light.brightness", type: "number", read: true, write: true, min: 0, max: 2 },
          { name: "indicator-light.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "environment.temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "motor-speed.motor-speed", type: "number", read: true, write: false, min: 0, max: 3000, unit: "rpm" },
          { name: "motor-speed.motor-set-speed", type: "number", read: true, write: false, min: 0, max: 3000, unit: "rpm" },
          { name: "motor-speed.favorite-fan-level", type: "number", read: true, write: true, min: 0, max: 14 },
          { name: "use-time.use-time", type: "number", read: true, write: false },
          { name: "environment.relative-humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "environment.pm2_5-density", type: "number", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "filter.filter-life-level", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "filter.filter-used-time", type: "number", read: true, write: false, unit: "h" },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[20] = { // tested and ok
          info: {},
          model: "zhimi.airpurifier.mc1",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-mc1:1
          description: "Purifier 2S",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "mode": async function (obj, val) { await device[obj].setMode(val) },
          "favorite_level": async function (obj, val) { await device[obj].setFavoriteLevel(val) },
          "led": async function (obj, val) { await device[obj].setLed(val) },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", role: "state", read: true, write: true, states: { "auto": "auto", "silent": "silent", "favorite": "favorite" } },
          { name: "favorite_level", type: "number", role: "state", read: true, write: true, min: 1, max: 10 },
          { name: "temp_dec", type: "number", role: "value.temperature", read: true, write: false, min: -40.0, max: 525.0, unit: "°C" },
          { name: "humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "aqi", type: "number", role: "value", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "led", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "filter1_life", type: "number", role: "value", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "f1_hour", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "f1_hour_used", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[22] = {
          info: {},
          model: "zhimi.airpurifier.m1",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-m1:1
          description: "Purifier 2",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "mode": async function (obj, val) { await device[obj].setMode(val) },
          "favorite_level": async function (obj, val) { await device[obj].setFavoriteLevel(val) },
          "led": async function (obj, val) { await device[obj].setLed(val) },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", role: "state", read: true, write: true, states: { "auto": "auto", "silent": "silent", "favorite": "favorite" } },
          { name: "favorite_level", type: "number", role: "state", read: true, write: true, min: 1, max: 10 },
          { name: "temp_dec", type: "number", role: "value.temperature", read: true, write: false, min: -40.0, max: 525.0, unit: "°C" },
          { name: "humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "aqi", type: "number", role: "value", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "led", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "filter1_life", type: "number", role: "value", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "f1_hour", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "f1_hour_used", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[8] = { // Tested and working
          info: {},
          model: "zhimi.airpurifier.mc2",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-mc2:1
          description: "Purifier 2H",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "mode": async function (obj, val) { await device[obj].setMode(val) },
          "favorite_level": async function (obj, val) { await device[obj].setFavoriteLevel(val) },
          "led": async function (obj, val) { await device[obj].setLed(val) },
          "led_b": async function (obj, val) { await device[obj].setLedB(val) },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", role: "state", read: true, write: true, states: { "auto": "auto", "silent": "silent", "favorite": "favorite" } },
          { name: "favorite_level", type: "number", role: "state", read: true, write: true, min: 0, max: 16 },
          { name: "temp_dec", type: "number", role: "value.temperature", read: true, write: false, min: -40.0, max: 525.0, unit: "°C" },
          { name: "humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "aqi", type: "number", role: "value", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "average_aqi", type: "number", role: "value", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "led", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "led_b", type: "number", role: "state", read: true, write: true, min: 0, max: 2, states: { 0: "bright", 1: "dim", 2: "off" } },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "filter1_life", type: "number", role: "value", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "f1_hour", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "f1_hour_used", type: "number", role: "value", read: true, write: false, unit: "h" },
          { name: "motor1_speed", type: "number", role: "value", read: true, write: false, unit: "rpm" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[13] = { // Tested and working
          info: {},
          model: "zhimi.airpurifier.vb2",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-vb2:1
          description: "Mi Air Purifier Pro H",
          setter: {
          "air-purifier.on": async function (obj, val) { await device[obj].setPower(val) },
          "air-purifier.mode": async function (obj, val) { await device[obj].setMode(val) },
          "motor-speed.favorite-level": async function (obj, val) { await device[obj].setFavLevel(val) },
          "air-purifier.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "alarm.volume": async function (obj, val) { await device[obj].setBuzzer(val) },
          "indicator-light.brightness": async function (obj, val) { await device[obj].setLcdBrightness(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "air-purifier.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "air-purifier.fault", type: "number", read: true, write: false, min: 0, max: 5, states: { 0: "No faults", 1: "m1_run", 2: "m1_stuck", 3: "no_sensor", 4: "error_hum", 5: "error_temp", 6: "timer_error1", 7: "timer_error2" } },
          { name: "air-purifier.mode", type: "number", read: true, write: true, min: 0, max: 3, states: { 0: "auto", 1: "sleep", 2: "favorite", 3: "fanset" } },
          { name: "air-purifier.fan-level", type: "number", read: true, write: true, min: 1, max: 3 },
          { name: "alarm.volume", type: "number", read: true, write: true, min: 0, max: 100 },
          { name: "indicator-light.brightness", type: "number", read: true, write: true, min: 0, max: 2 },
          { name: "indicator-light.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "environment.temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "motor-speed.motor1-speed", type: "number", read: true, write: false, min: 0, max: 3000, unit: "rpm" },
          { name: "motor-speed.motor1-set-speed", type: "number", read: true, write: false, min: 0, max: 3000, unit: "rpm" },
          { name: "motor-speed.favorite-level", type: "number", read: true, write: true, min: 0, max: 14 },
          { name: "use-time.use-time", type: "number", read: true, write: false },
          { name: "environment.relative-humidity", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "environment.pm2_5-density", type: "number", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "filter.filter-life-level", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "filter.filter-used-time", type: "number", read: true, write: false, unit: "h" },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[14] = { // Tested and working
          info: {},
          model: "zhimi.airpurifier.v7",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-v7:1
          description: "Mi Air Purifier",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "mode": async function (obj, val) { await device[obj].setFanLevel(val) },
          "led": async function (obj, val) { await device[obj].setDisplay(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", read: true, write: true, states: { "auto": "auto", "silent": "silent", "favorite": "favorite" } },
          { name: "favorite_level", type: "number", read: true, write: false, min: 0, max: 16 },
          { name: "temp_dec", type: "number", role: "value.temperature", read: true, write: false },
          { name: "humidity", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "aqi", type: "number", read: true, write: false, unit: "μg/m³" },
          { name: "average_aqi", type: "number", read: true, write: false, unit: "μg/m³" },
          { name: "led", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "bright", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "volume", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "filter1_life", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "f1_hour", type: "number", read: true, write: false },
          { name: "f1_hour_used", type: "number", read: true, write: false },
          { name: "motor1_speed", type: "number", read: true, write: false, unit: "rpm" },
          { name: "motor2_speed", type: "number", read: true, write: false, unit: "rpm" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[15] = { // Tested and working
          info: {},
          model: "zhimi.airpurifier.mb4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-mb4:2
          description: "Purifier 3C",
          setter: {
          "air-purifier.on": async function (obj, val) { await device[obj].setPower(val) },
          "air-purifier.mode": async function (obj, val) { await device[obj].setMode(val) },
          "custom-service.favorite-speed": async function (obj, val) { await device[obj].setFavSpeed(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setBuzzer(val) },
          "screen.brightness": async function (obj, val) { await device[obj].setLcdBrightness(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "air-purifier.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "air-purifier.fault", type: "string", read: true, write: false },
          { name: "air-purifier.mode", type: "number", read: true, write: true, min: 0, max: 3, states: { 0: "auto", 1: "sleep", 2: "favorite", 3: "fanset" } },
          { name: "alarm.alarm", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "screen.brightness", type: "number", read: true, write: true, min: 0, max: 8 },
          { name: "environment.pm2_5-density", type: "number", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "custom-service.moto-speed-rpm", type: "number", read: true, write: false, min: 0, max: 65535, unit: "rpm" },
          { name: "custom-service.favorite-speed", type: "number", read: true, write: true, min: 300, max: 2300, unit: "rpm" },
          { name: "filter.filter-life-level", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "filter.filter-used-time", type: "number", read: true, write: false, unit: "h" },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          DefineDevice[18] = { // Untested
          info: {},
          model: "zhimi.airpurifier.ma4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:air-purifier:0000A007:zhimi-ma4:1
          description: "Air Purifier",
          setter: {
          "air-purifier.on": async function (obj, val) { await device[obj].setPower(val) },
          "air-purifier.mode": async function (obj, val) { await device[obj].setMode(val) },
          "air-purifier.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setBuzzer(val) },
          "indicator-light.brightness": async function (obj, val) { await device[obj].setLcdBrightness(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "air-purifier.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "air-purifier.fault", type: "number", read: true, write: false, min: 0, max: 5, states: { 0: "No faults", 1: "m1_run", 2: "m1_stuck", 3: "no_sensor", 4: "error_hum", 5: "error_temp", 6: "timer_error1", 7: "timer_error2" } },
          { name: "air-purifier.mode", type: "number", read: true, write: true, min: 0, max: 3, states: { 0: "auto", 1: "sleep", 2: "favorite", 3: "none" } },
          { name: "air-purifier.fan-level", type: "number", read: true, write: true, min: 1, max: 3 },
          { name: "alarm.alarm", type: "boolean", read: true, write: true, min: false, max: true },
          { name: "indicator-light.brightness", type: "number", read: true, write: true, min: 0, max: 2 },
          { name: "indicator-light.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "environment.temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "environment.relative-humidity", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "environment.pm2_5-density", type: "number", read: true, write: false, min: 0, max: 600, unit: "μg/m³" },
          { name: "filter.filter-life-level", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "filter.filter-used-time", type: "number", read: true, write: false, unit: "h" },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };

          // ***************************** Fans *********************************
          // TODO https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:zhimi-sa1:1

          DefineDevice[1] = { // untested
          info: {},
          model: "leshow.fan.ss4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:leshow-ss4:1
          description: "Leshow Fan",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "blow": async function (obj, val) { await device[obj].setFanLevel(val) },
          "yaw": async function (obj, val) { await device[obj].setFanSwing(val ? 'on' : 'off') },
          "mode": async function (obj, val) { await device[obj].setSleepMode(val) },
          "sound": async function (obj, val) { await device[obj].setBuzzer(val ? 'on' : 'off') },
          "timer": async function (obj, val) { await device[obj].setTimer(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "blow", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "yaw", type: "boolean", role: "switch", read: true, write: true },
          { name: "mode", type: "boolean", role: "switch", read: true, write: true },
          { name: "sound", type: "boolean", role: "switch", read: true, write: true },
          { name: "timer", type: "number", read: true, write: true, min: 0, max: 540, unit: "m" }]
          };

          DefineDevice[9] = { // Tested and working
          info: {},
          model: "zhimi.fan.za4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:zhimi-za4:1
          description: "Mi Fan 2S",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "angle": async function (obj, val) { await device[obj].setSwingAngle(val) },
          "angle_enable": async function (obj, val) { await device[obj].setSwing(val) },
          "natural_level": async function (obj, val) { await device[obj].setSleepMode((val == 1) ? true : false) },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val ? 'on' : 'off') },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val ? 'on' : 'off') },
          "led_b": async function (obj, val) { await device[obj].setLcdBrightness(val) },
          "speed_level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "poweroff_time": async function (obj, val) { await device[obj].setTimer(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "angle", type: "number", read: true, write: true, min: 1, max: 120 },
          { name: "angle_enable", type: "boolean", role: "switch", read: true, write: true },
          { name: "natural_level", type: "number", read: true, write: true, min: 0, max: 1, states: { 0: "Straight Wind", 1: "Natural Wind" } },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true },
          { name: "led_b", type: "boolean", role: "switch", read: true, write: true },
          { name: "speed_level", type: "number", read: true, write: true, min: 1, max: 100, unit: "%" },
          { name: "poweroff_time", type: "number", read: true, write: true, min: 0, max: 540, unit: "m" }]
          };

          DefineDevice[17] = { // Tested and working
          info: {},
          model: "dmaker.fan.p15",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:dmaker-p15:1
          description: "Mi Smart Standing Fan Pro",
          setter: {
          "fan.on": async function (obj, val) { await device[obj].setPower(val) },
          "fan.mode": async function (obj, val) { await device[obj].setMode(val) },
          "fan.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "fan.horizontal-swing": async function (obj, val) { await device[obj].setHorizontalSwing(val) },
          "fan.horizontal-angle": async function (obj, val) { await device[obj].setHorizontalAngle(val) },
          "indicator-light.on": async function (obj, val) { await device[obj].setIndicatorLight(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setAlarm(val) },
          "motor-controller.motor-control": async function (obj, val) { await device[obj].setMotorController(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) },
          "off-delay-time.off-delay-time": async function (obj, val) { await device[obj].setOffDelayTime(val) }
          },
          common:
          [{ name: "fan.on", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.mode", type: "number", role: "switch", read: true, write: true, min: 0, max: 1, states: { 0: "Straight Wind", 1: "Natural Wind" } },
          { name: "fan.fan-level", type: "number", role: "switch", read: true, write: true, min: 1, max: 4, states: { 1: "Slow", 2: "Middle", 3: "High", 4: "Turbo" } },
          { name: "fan.horizontal-swing", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.horizontal-angle", type: "number", role: "switch", read: true, write: true, min: 30, max: 140, unit: "°", states: { 30: "30°", 60: "60°", 90: "90°", 120: "120°", 140: "140°" } },
          { name: "fan.status", type: "number", role: "indicator", read: true, write: false, min: 1, max: 100 },
          { name: "indicator-light.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "alarm.alarm", type: "boolean", role: "switch", read: true, write: true },
          { name: "motor-controller.motor-control", type: "number", role: "switch", read: false, write: true, min: 0, max: 2, states: { 0: "None", 1: "Left", 2: "Right" } },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "off-delay-time.off-delay-time", type: "number", role: "switch", read: true, write: true, min: 0, max: 480, unit: "m" }
          ]
          };

          DefineDevice[19] = { // untested
          info: {},
          model: "dmaker.fan.1c",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:dmaker-1c:1
          description: "Mi Smart Standing Fan 1C",
          setter: {
          "fan.on": async function (obj, val) { await device[obj].setPower(val) },
          "fan.mode": async function (obj, val) { await device[obj].setMode(val) },
          "fan.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "fan.horizontal-swing": async function (obj, val) { await device[obj].setHorizontalSwing(val) },
          "fan.brightness": async function (obj, val) { await device[obj].setBrightness(val) },
          "fan.alarm": async function (obj, val) { await device[obj].setAlarm(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) },
          "fan.off-delay-time": async function (obj, val) { await device[obj].setOffDelayTime(val) }
          },
          common:
          [{ name: "fan.on", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.mode", type: "number", role: "switch", read: true, write: true, min: 0, max: 1, states: { 0: "Straight Wind", 1: "Sleep" } },
          { name: "fan.fan-level", type: "number", role: "switch", read: true, write: true, min: 1, max: 3, states: { 1: "Slow", 2: "Middle", 3: "High" } },
          { name: "fan.horizontal-swing", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.status", type: "number", role: "indicator", read: true, write: false, min: 1, max: 100 },
          { name: "fan.brightness", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "fan.alarm", type: "boolean", role: "switch", read: true, write: true },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "fan.off-delay-time", type: "number", role: "switch", read: true, write: true, min: 0, max: 480, unit: "m" }
          ]
          };

          DefineDevice[23] = { // Tested and working
          info: {},
          model: "dmaker.fan.p18",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:dmaker-p18:1
          description: "Mi Smart Standing Fan 2",
          setter: {
          "fan.on": async function (obj, val) { await device[obj].setPower(val) },
          "fan.mode": async function (obj, val) { await device[obj].setMode(val) },
          "fan.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "fan.horizontal-swing": async function (obj, val) { await device[obj].setHorizontalSwing(val) },
          "fan.horizontal-angle": async function (obj, val) { await device[obj].setHorizontalAngle(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setAlarm(val) },
          "motor-controller.motor-control": async function (obj, val) { await device[obj].setMotorController(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) },
          "off-delay-time.off-delay-time": async function (obj, val) { await device[obj].setOffDelayTime(val) }
          },
          common:
          [{ name: "fan.on", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.mode", type: "number", role: "switch", read: true, write: true, min: 0, max: 1, states: { 0: "Straight Wind", 1: "Natural Wind" } },
          { name: "fan.fan-level", type: "number", role: "switch", read: true, write: true, min: 1, max: 4, states: { 1: "Slow", 2: "Middle", 3: "High", 4: "Turbo" } },
          { name: "fan.horizontal-swing", type: "boolean", role: "switch", read: true, write: true },
          { name: "fan.horizontal-angle", type: "number", role: "switch", read: true, write: true, min: 30, max: 140, unit: "°", states: { 30: "30°", 60: "60°", 90: "90°", 120: "120°", 140: "140°" } },
          { name: "fan.status", type: "number", role: "indicator", read: true, write: false, min: 1, max: 100 },
          { name: "alarm.alarm", type: "boolean", role: "switch", read: true, write: true },
          { name: "motor-controller.motor-control", type: "number", role: "switch", read: false, write: true, min: 0, max: 2, states: { 0: "None", 1: "Left", 2: "Right" } },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "off-delay-time.off-delay-time", type: "number", role: "switch", read: true, write: true, min: 0, max: 480, unit: "m" }
          ]
          };

          // ***************************** Lights *********************************

          DefineDevice[2] = { // Tested and ok except setting color
          info: {},
          model: "yeelink.light.strip2",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-color2:1
          description: "Yeelight Lightstrip Plus",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "hue": async function (obj, val) { await device[obj].setColorHSV(val) },
          "color_mode": async function (obj, val) { await device[obj].setColorMode(val) },
          "ct": async function (obj, val) { await device[obj].setCt(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "hue", type: "number", read: true, write: true, min: 0, max: 16777215 },
          { name: "sat", type: "number", read: true, write: true, min: 0, max: 100 },
          { name: "color_mode", type: "number", read: true, write: true, min: 1, max: 2 },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };

          DefineDevice[5] = { // Tested and working
          info: {},
          model: "yeelink.light.ct2",// http://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-ct2:1
          description: "Yeelight LED Bulb (Tunable)",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "ct": async function (obj, val) { await device[obj].setColorTemperature(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };

          DefineDevice[6] = { // Tested and working except color setting
          info: {},
          model: "yeelink.light.color2",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-color2:1
          description: "Yeelight LED Bulb (Color)",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "rgb": async function (obj, val) { await device[obj].setColorRgb(val) },
          "color_mode": async function (obj, val) { await device[obj].setColorMode(val) },
          "ct": async function (obj, val) { await device[obj].setCt(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "rgb", type: "number", read: true, write: true, min: 1, max: 16777215 },
          { name: "color_mode", type: "number", read: true, write: true, min: 1, max: 2 },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };
          DefineDevice[10] = { // untested
          info: {},
          model: "yeelink.light.ceiling3",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-ceiling3:1
          description: "Yeelight LED Ceiling Light",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "nl_br": async function (obj, val) { await device[obj].setBrightness(val) },
          "night_mode": async function (obj, val) { await device[obj].setSleepMode(val) },
          "ct": async function (obj, val) { await device[obj].setCt(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "nl_br", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "night_mode", type: "boolean", role: "switch", read: true, write: true },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };
          DefineDevice[11] = { // untested
          info: {},
          model: "yeelink.light.ceiling1",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-ceiling1:1
          description: "Yeelight Crystal Pedestal Light",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "nl_br": async function (obj, val) { await device[obj].setBrightness(val) },
          "night_mode": async function (obj, val) { await device[obj].setSleepMode(val) },
          "ct": async function (obj, val) { await device[obj].setCt(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "nl_br", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "night_mode", type: "boolean", read: true, write: true },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };

          DefineDevice[21] = { // untested
          info: {},
          model: "yeelink.light.ceiling10",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-ceiling10:1
          description: "Yeelight Meteorite Pedestal Light",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "main_power": async function (obj, val) { await device[obj].setMainPower(val) },
          "bg_power": async function (obj, val) { await device[obj].setBgPower(val) },
          "bg_bright": async function (obj, val) { await device[obj].setBgBrightness(val) },
          "active_bright": async function (obj, val) { await device[obj].setActiveBrightness(val) },
          "color_mode": async function (obj, val) { await device[obj].setColorMode(val) },
          "ct": async function (obj, val) { await device[obj].setColorTemperature(val) },
          "bg_ct": async function (obj, val) { await device[obj].setBgColorTemperature(val) },
          "bg_rgb": async function (obj, val) { await device[obj].setBgColorRgb(val) },
          "bg_hue": async function (obj, val) { await device[obj].setBgColorHSV([val, 100]) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "main_power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bg_power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bg_bright", type: "number", role: 'level.dimmer', read: true, write: true, min: 1, max: 100, unit: "%" },
          { name: "active_bright", type: "number", role: 'level.dimmer', read: true, write: true, min: 1, max: 100, unit: "%" },
          { name: "color_mode", type: "boolean", role: 'switch.mode.color', read: true, write: true },
          { name: "moon_mode", type: "boolean", role: 'switch.mode.moon', read: true, write: true },
          { name: "bg_ct", type: "number", role: 'level.color.temperature', read: true, write: true, min: 2600, max: 6500, unit: "K" },
          { name: "ct", type: "number", role: 'level.color.temperature', read: true, write: true, min: 2600, max: 6500, unit: "K" },
          { name: "bg_rgb", type: "string", role: 'level.color.rgb', read: true, write: true },
          { name: "bg_hue", type: "number", role: 'level.color.hue', read: true, write: true, min: 0, max: 359 },
          { name: "bg_sat", type: "number", role: 'level.color.saturation', read: true, write: true, min: 1, max: 100 }]
          };

          DefineDevice[16] = { // untested
          info: {},
          model: "yeelink.light.lamp4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:light:0000A001:yeelink-lamp4:1
          description: "Mi LED Desk Lamp 1S",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "bright": async function (obj, val) { await device[obj].setBrightness(val) },
          "ct": async function (obj, val) { await device[obj].setColorTemperature(val) }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true },
          { name: "bright", type: "number", read: true, write: true, min: 1, max: 100 },
          { name: "ct", type: "number", read: true, write: true, min: 1700, max: 6500 }]
          };

          // ***************************** Humidifier *********************************

          DefineDevice[3] = { // Tested and working
          info: {},
          model: "zhimi.humidifier.cb1",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:humidifier:0000A00E:zhimi-cb1:1
          description: "Smartmi Evaporative Humidifier",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val ? 'on' : 'off') },
          "mode": async function (obj, val) { await device[obj].setFanLevel(val) },
          "limit_hum": async function (obj, val) { await device[obj].setTargetHumidity(val) },
          "led": async function (obj, val) { await device[obj].setLedBrightness(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val) },
          "dry": async function (obj, val) { await device[obj].setMode(val ? 'dry' : 'humidify') }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "depth", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "limit_hum", type: "number", read: true, write: true, min: 0, max: 100, unit: "%", states: { 30: "30%", 40: "40%", 50: "50%", 60: "60%", 70: "70%", 80: "80%" } },
          { name: "led", type: "number", read: true, write: true, min: 0, max: 2, states: { 0: "bright", 1: "dim", 2: "off" } },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "dry", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", read: true, write: true, states: { "auto": "auto", "silent": "silent", "medium": "medium", "high": "high" } }]
          };
          DefineDevice[4] = { // untested
          info: {},
          model: "deerma.humidifier.jsq",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:humidifier:0000A00E:deerma-jsq:1
          description: "Mi Smart Antibacterial Humidifier",
          setter: {
          "humidifier.on": async function (obj, val) { await device[obj].setPower(val) },
          "humidifier.fan-level": async function (obj, val) { await device[obj].setFanLevel(val) },
          "alarm.alarm": async function (obj, val) { await device[obj].setBuzzer(val) },
          "physical-controls-locked.physical-controls-locked": async function (obj, val) { await device[obj].setChildLock(val) }
          },
          common:
          [{ name: "humidifier.on", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "humidifier.fan-level", type: "number", read: true, write: true, min: 0, max: 3, states: { 0: "auto", 1: "level1", 2: "level2", 3: "level3" } },
          { name: "humidifier.water-level", type: "number", read: true, write: false, min: 0, max: 127 },
          { name: "alarm.alarm", type: "boolean", read: true, write: true, min: false, max: true },
          { name: "environment.temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "environment.relative-humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "physical-controls-locked.physical-controls-locked", type: "boolean", role: "switch", read: true, write: true, min: false, max: true }]
          };
          DefineDevice[12] = { // untested
          info: {},
          model: "zhimi.humidifier.ca4",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:humidifier:0000A00E:zhimi-ca4:1
          description: "Smartmi Evaporative Humidifier",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val ? 'on' : 'off') },
          "buzzer": async function (obj, val) { await device[obj].setBuzzer(val ? 'on' : 'off') },
          "mode": async function (obj, val) { await device[obj].setFanLevel(val) },
          "limit_hum": async function (obj, val) { await device[obj].setTargetHumidity(val) },
          "led": async function (obj, val) { await device[obj].setLedBrightness(val) },
          "child_lock": async function (obj, val) { await device[obj].setChildLock(val ? 'on' : 'off') },
          "dry": async function (obj, val) { await device[obj].setMode(val ? 'dry' : 'humidify') }
          },
          common:
          [{ name: "power", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "depth", type: "number", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "limit_hum", type: "number", read: true, write: true, min: 0, max: 100, unit: "%", states: { 30: "30%", 40: "40%", 50: "50%", 60: "60%", 70: "70%", 80: "80%" } },
          { name: "led", type: "number", read: true, write: true, min: 0, max: 2, states: { 0: "bright", 1: "dim", 2: "off" } },
          { name: "buzzer", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "temperature", type: "number", role: "value.temperature", read: true, write: false, min: -40, max: 125, unit: "°C" },
          { name: "humidity", type: "number", role: "value.humidity", read: true, write: false, min: 0, max: 100, unit: "%" },
          { name: "child_lock", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "dry", type: "boolean", role: "switch", read: true, write: true, min: false, max: true },
          { name: "mode", type: "string", read: true, write: true, states: { "auto": "auto", "silent": "silent", "medium": "medium", "high": "high" } }]
          };

          // ***************************** Divers *********************************
          // TODO https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:coffee-machine:0000A049:scishare-s1102:1
          // TODO https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device📷0000A01C:mijia-v1:1
          // TODO https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:plant-monitor:0000A030:hhcc-v1:1
          // TODO https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:heater:0000A01A:zhimi-mc2:1

          DefineDevice[7] = { // In arbeit - unvollständig
          info: {},
          model: "lumi.gateway.v3",// https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:gateway:0000A019:lumi-v3:1
          description: "Xiaomi RGB Gateway",
          setter: {
          "power": async function (obj, val) { await device[obj].setPower(val) },
          "doorbell_push": async function (obj, val) { await device[obj].setBrightness(val) },
          "toggle_light": async function (obj, val) { await device[obj].setLightPower(val) },
          },
          common:
          [{ name: 'illumination', role: 'value.lux', write: false, read: true, type: 'number', unit: 'lux' },
          { name: 'rgb', role: 'level.color.rgb', write: true, read: true, type: 'string' },
          { name: 'nightlight_rgb', role: 'level.color.rgb', write: true, read: true, type: 'string' },
          { name: "mute", type: "boolean", read: true, write: true },
          { name: 'toggle_light', role: 'switch', write: true, read: true, type: 'boolean' },
          { name: 'light.dimmer', role: 'level.dimmer', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100 },
          { name: 'gateway_volume', role: 'level.volume', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100 },
          { name: 'doorbell_volume', role: 'level.volume', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100 },
          { name: 'alarming_volume', role: 'level.volume', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100 },
          { name: "doorbell_push", type: "boolean", read: true, write: true },
          { name: "arming", type: "boolean", read: true, write: true },
          { name: "arming_time", type: "number", read: true, write: true },
          { name: 'music_ID', role: 'state', write: true, read: false, type: 'number', desc: '10000 - stop, 10005 - custom ringtone' },
          { name: 'proto_version', role: 'info', write: false, read: true, type: 'string' },
          { name: 'join_permission', role: 'state', write: true, read: true, type: 'string' },
          { name: 'remove_device', role: 'state', write: true, read: true, type: 'string' }, // Removing a subdevice (device sid)
          { name: 'connected', role: 'indicator.reachable', write: false, read: true, type: 'boolean', desc: 'Will be set to false if no packets received in 20 seconds' }]
          };

          /*
          gateway: {type: 'gateway', fullName: 'Xiaomi RGB Gateway', ClassName: Gateway, states: {
          + illumination: {name: 'Illumination', role: 'value.lux', write: false, read: true, type: 'number', unit: 'lux'},
          + rgb: {name: 'RGB', role: 'level.color.rgb', write: true, read: true, type: 'string'},
          on: {name: 'Light', role: 'switch', write: true, read: true, type: 'boolean'},
          dimmer: {name: 'Light', role: 'level.dimmer', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100},
          volume: {name: 'Volume', role: 'level.volume', write: true, read: true, type: 'number', unit: '%', min: 0, max: 100},
          mid: {name: 'Music ID', role: 'state', write: true, read: false, type: 'number', desc: '10000 - stop, 10005 - custom ringtone'},
          proto_version: {name: 'Proto Version', role: 'info', write: false, read: true, type: 'string'},
          join_permission:{name: 'Add device', role: 'state', write: true, read: true, type: 'string'}, // Permission to add subdevices (yes / no)
          remove_device: {name: 'Remove device', role: 'state', write: true, read: true, type: 'string'}, // Removing a subdevice (device sid)
          connected: {name: 'Is gateway connected', role: 'indicator.reachable', write: false, read: true, type: 'boolean', desc: 'Will be set to false if no packets received in 20 seconds'}
          }
          */

          for (let x in DefineDevice) { //An alle Devicedefinitionen die generischen Datenpunkte anhängen
          DefineDevice[x].info = [
          { id: "localip", initial: "", forceCreation: false, common: { read: true, write: true, name: "Ip Adress", type: "string", role: "value", def: "" } },
          { id: "token", initial: "", forceCreation: false, common: { read: true, write: true, name: "Token", type: "string", role: "value", def: "" } },
          { id: "did", initial: "", forceCreation: false, common: { read: true, write: true, name: "Device Id", type: "string", role: "value", def: "" } },
          { id: "model", initial: "", forceCreation: false, common: { read: true, write: true, name: "Model", type: "string", role: "value", def: "" } },
          { id: "rssi", initial: 0, forceCreation: false, common: { read: true, write: false, name: "rssi", type: "number", role: "value.rssi", def: 0 } },
          { id: "name", initial: "", forceCreation: false, common: { read: true, write: true, name: "Name", type: "string", role: "value", def: "" } },
          { id: "isOnline", initial: false, forceCreation: false, common: { read: true, write: true, name: "Is online", type: "boolean", role: "value", def: false } }]

          }

          function PrepareDeviceDps(did, model) {
          if (logging) log("Reaching PrepareDeviceDps, did=" + did + " model=" + model);
          for (let x in DefineDevice) { //Alle definierten Model durchgehen
          if (DefineDevice[x].model == model) { //bei Model match
          for (let y in DefineDevice[x].common) { //Alle common propertys des models durchgehen und Var zusammensetzen
          States[DpCount] = { id: praefix0 + "." + did + "." + DefineDevice[x].common[y].name, common: DefineDevice[x].common[y] }; //
          DpCount++;
          };
          };
          };
          }

          function PrepareGenericDps(did) { //GenericDps
          // if (logging) log("Reaching PrepareGenericDps(did)");
          for (let y in DefineDevice[0].info) { //Alle info propertys des models durchgehen und Var zusammensetzen
          // log("DefineDevice[0].info[y]=" + JSON.stringify(DefineDevice[0].info[y].common.name))
          States[DpCount] = { id: praefix0 + "." + did + ".info." + DefineDevice[0].info[y].id, common: DefineDevice[0].info[y].common }; //
          DpCount++;
          };
          }

          function CreateStates() {
          if (logging) log("Reaching CreateStates()");

          //Alle States anlegen, Main aufrufen wenn fertig
          let numStates = States.length;
          States.forEach(function (state) {
              createState(state.id, state.initial, state.forceCreation, state.common, function () {
                  numStates--;
                  if (numStates === 0) {
                      if (logging) log(States.length + " States created, now setting up channels!");
                      setObject(praefix0, { type: 'channel', common: { name: "" }, native: {} }); //Root zum Channel machen
                      for (let x = 0; x < AllDevicesRaw.length; x++) {
                          setObject(praefix0 + "." + AllDevicesRaw[x].did, { type: 'device', common: { name: AllDevicesRaw[x].name }, native: {} }); //DeviceChannels machen
                          // if (logging) log("AllDevicesRaw[x]=" +JSON.stringify (AllDevicesRaw[x]))
                      };
                      main();
                  };
              });
          });
          

          }

          async function main() {
          if (logging) log("Reaching main");
          await WriteGenericDpValues();
          await CreateDevices();
          CreateDpTrigger();
          }

          function WriteGenericDpValues() { //Alle vorhandenen generischen Werte einlesen und in Dps schreiben
          if (logging) log("Reaching WriteGenericDpValues()");
          for (let x in AllDevicesRaw) { //Alle vorhandenen Xiaomi Devices durchgehen
          for (let y in DefineDevice[0].info) { //Nimm ersten Eintrag aus DefineDevices da die Generics bei allen gleich sind
          setState(praefix0 + "." + AllDevicesRaw[x].did + ".info." + DefineDevice[0].info[y].id, AllDevicesRaw[x][DefineDevice[0].info[y].id], true);
          // log("DefineDevice[" + 0 + "].info[" + y + "]=" + JSON.stringify(DefineDevice[0].info[y]));
          // log("" + praefix0 + "." + AllDevicesRaw[x].did + ".Info." + DefineDevice[0].info[y].id)
          // log(AllDevicesRaw[x][DefineDevice[0].info[y].id])
          };
          };
          return true;
          }

          //################################################

          //Step 1 - Einloggen in die Cloud und abrufen aller Gerätedaten, dann vorbereiten der allgemeinen und devicespezifischen Datenpunkte mit anschließendem anlegen derselben
          async function Init() { //Cloudlogin und auslesen der gesamten Clouddaten
          if (logging) log("Reaching init");

          mihome.miioProtocol.init();// local miIO
          
          try {// cloud MIoT Login
              await mihome.miCloudProtocol.login(username, password); //Versuch einzuloggen
          }
          catch {
              log("You are already logged in, login canceled"); //Wenn schon eingeloggt
          };
          log("Retrieving your in " + options.country + " registered MiHome Devices");
          AllDevicesRaw = await mihome.miCloudProtocol.getDevices(null, options); //Gibt alle vorhandenen Devices zurück und weist die Werte einem lokalen Array zu
          log("Found " + AllDevicesRaw.length + " MiHome Devices, those are:");
          
          for (let x = 0; x < AllDevicesRaw.length; x++) { //Alle beim User vorhandenen Xiaomi Devices durchgehen
              log(AllDevicesRaw[x].name);
              await PrepareGenericDps(AllDevicesRaw[x].did); //und allgemeine generische Infos Dps vorbereiten
          };
          log("Now searching for supported Devices...");
          let NoDeviceMatch = true;
          for (let x = 0; x < AllDevicesRaw.length; x++) { //Jetzt erneut alle beim User vorhandenen Xiaomi Devices durchgehen
              for (let y = 0; y < DefineDevice.length; y++) { //und abgleichen mit von Skript und node-mihome unterstützten Geräten
                  if (AllDevicesRaw[x].model == DefineDevice[y].model) { //Bei match Devicespezifische DPs vorbereiten
                      log("Device " + AllDevicesRaw[x].name + " is supported, creating DataPoints");
                      await PrepareDeviceDps(AllDevicesRaw[x].did, AllDevicesRaw[x].model);
                      NoDeviceMatch = false;
                  };
              };
          };
          if (NoDeviceMatch) {
              log("No supported Devices found!", "warn");
          }
          CreateStates();
          

          }

          //################################################

          //Step 2 - Deviceobjekte anlegen, Trigger erzeugen und Datenpunktrefresh initieren
          async function CreateDevices() {
          if (logging) log("Reaching CreateDevices ");
          let z = 0;

          for (let x in AllDevicesRaw) { //Alle beim User gefundenen Geräte durchlaufen
              for (let y in DefineDevice) { //Alle vom Skript unterstützten und definierten Devices durchlaufen
                  if (AllDevicesRaw[x].model == DefineDevice[y].model) { //Wenn die beiden matchen
                      log("Now creating device for " + AllDevicesRaw[x].model + " / " + AllDevicesRaw[x].did + " / " + AllDevicesRaw[x].localip + " / " + AllDevicesRaw[x].token + " / " + refresh);
          
                      device[z] = mihome.device({
                          id: AllDevicesRaw[x].did, // required, device id
                          model: AllDevicesRaw[x].model, // required, device model "zhimi.airpurifier.mb3"
                          address: AllDevicesRaw[x].localip, // miio-device option, local ip address
                          token: AllDevicesRaw[x].token, // miio-device option, device token 4ff8a96292d0451c5148142a0a851e4f
                          refresh: refresh // miio-device option, device properties refresh interval in ms
                      });
                      device[z].model = AllDevicesRaw[x].model;
                      device[z].setter = DefineDevice[y].setter;
                      device[z].definition = DefineDevice[y];
                      device[z].firstrun = true;
                      log("Created device " + JSON.stringify(device[z]) + " now fetching data");
                      await device[z].init(); // connect to device and poll for properties
                      log("Init Device# " + z + " - device=" + JSON.stringify(device[z].model));
                      z++;
                  };
              };
          };
          
          for (let i in device) { //Datenabruf zyklisch entsprechend refresh
              log("Setting trigger #" + i + " for " + device[i].model);
              device[i].on('properties', (data) => {
                  if (typeof data != "undefined" && data != {}) {
                      if (JSON.stringify(device[i].data) !== JSON.stringify(data)) {//Prüfen ob Datenänderung pro device
                          //if (logging) log(data)
                          if (typeof device[i].data == "undefined") {
                              device[i].data = data;
                          };
                          RefreshDps(i, data);
                      };
                  } else {
                      log("Data was empty (undefined), aborting refresh", "warn");
                  };
              });
          };
          
          onStop(function () { //Bei Scriptende alle Devices löschen
              for (let x in device) {
                  device[x].destroy();
              };
              unsubscribe('properties');
          }, 10);
          

          }

          function RefreshDps(DeviceIndex, NewData) {
          // if (logging) log("Reaching RefreshDps at " + device[DeviceIndex].definition.description);

          for (let x in device[DeviceIndex].data) { //Alle properties des Devices durchgehen
              for (let i in NewData) {//Alle properties des Datenblocks durchgehen
                  if ((NewData[i] !== device[DeviceIndex].data[x] || device[DeviceIndex].firstrun == true) && i === x) { //Überprüfen ob Datenänderung im property bei propertymatch, firstrun immer refreshen
          
                      if (logging) log("New Data at " + device[DeviceIndex].model + " " + i + " oldvalue=" + device[DeviceIndex].data[x] + " newvalue=" + NewData[i] + " path=" + praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x));
                      device[DeviceIndex].data[x] = NewData[i]; //Geänderten Wert ins Objekt schreiben
          
                      for (let y in device[DeviceIndex].definition.common) { //Alle Definitionsproperties durchgehen um ChannelId zu suchen
                          if (device[DeviceIndex].definition.common[y].name == CorrectChannelId(x) && device[DeviceIndex].definition.common[y].read == true) { //Wenn match und read=true
                              if (typeof device[DeviceIndex].data[x] == 'undefined' || typeof device[DeviceIndex].id == 'undefined') { //Wenn kein Pfad oder keine Daten
                                  log("Empty packet for " + device[DeviceIndex].definition.common[y].name + ", skipping refresh", 'warn');
                                  //return false;
                              } else {
                                  //Prüfung auf bestimmte keys
                                  switch (device[DeviceIndex].definition.common[y].name) {
                                      case 'temp_dec': //Umwandlung von 10tel Grad auf Grad beim Dp schreiben. data muß unverändert bleiben da im Trigger mit origdaten abgeglichen wird
                                          setState(praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x), parseInt(device[DeviceIndex].data[x]) / 10, true);
                                          break;
                                      default: //Wenn kein Treffer jetzt Prüfung auf bestimmte Daten
                                          switch (device[DeviceIndex].data[x]) {
                                              case 'on':
                                                  setState(praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x), true, true);
                                                  break;
                                              case 'off':
                                                  setState(praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x), false, true);
                                                  break;
                                              default:
                                                  setState(praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x), device[DeviceIndex].data[x], true);
                                          };
                                  };
                              };
                              if (logging) log("Refreshing " + praefix0 + "." + device[DeviceIndex].id + "." + CorrectChannelId(x) + " / value=" + device[DeviceIndex].data[x] + " / read=" + device[DeviceIndex].definition.common[y].read + " write=" + device[DeviceIndex].definition.common[y].write);
                          };
                      };
                  };
              };
          };
          device[DeviceIndex].firstrun = false;
          //if (logging) log(DeviceData[DeviceIndex])
          return true;
          

          }

          async function SetDevice(i, key, keyvalue) {
          if (logging) log("Reaching SetDevice - i=" + i + " key=" + key + " keyvalue=" + keyvalue);
          if (device[i].definition.common[key].name == 'rgb') { //Block wandelt Farb Hewwerte in Dezimalwert um
          keyvalue = ConvertHexToDezi(keyvalue);
          keyvalue = String(keyvalue);
          }
          if (device[i].definition.common[key].name == 'hue') { //Block kombiniert bei Änderungen von hue oder sat jweils die beiden Werte zu Array für übergabe an Funktion
          keyvalue = [keyvalue, device[i].data['sat']];
          } else if (device[i].definition.common[key].name == 'sat') {
          keyvalue = [device[i].data['hue'], keyvalue];
          for (let x in device[i].definition.common) {
          if (device[i].definition.common[x].name == 'hue') {
          key = x;
          };
          };
          };
          log("Keyvalue=" + keyvalue + " key=" + key)
          if (logging) log("Reaching SetDevice i=" + i);
          // log("Setting Device " + device[i].model + " to value " + keyvalue + " at " + device[i].definition.common[key].name)
          // log("Setting Device " + device[i].model + " to value " + keyvalue + " at " + device[i].setter[device[i].definition.common[key].name])
          log(device[i].setter[device[i].definition.common[key].name](i, keyvalue)); //Diese Zeile nicht entfernen, Funktionsaufruf!!!
          }

          function CreateDpTrigger() {
          if (logging) log("Reaching CreateDpTrigger");

          for (let i in device) {
              if (logging) log("Setting DataPointTrigger #" + i + " for " + device[i].model);
          
              for (let x in device[i].definition.common) { //Alle properties der Devicedefinition durchgehen
                  if (device[i].definition.common[x].write) {
                      //  log(praefix0 + "." + device[i].id + "." + device[i].definition.common[x].name)
                      on({ id: praefix0 + "." + device[i].id + "." + device[i].definition.common[x].name, change: "ne", ack: false }, function (dp) { //Bei Statusänderung
                          if (logging) log("Triggered i=" + i + " x=" + x + " ack=" + dp.state.ack);
                          SetDevice(i, x, CheckDataTypeAndConvert(dp.state.val, device[i].definition.common[x].type));
                      });
                      if (logging) log("Setting Datapoint Trigger for " + praefix0 + "." + device[i].id + "." + device[i].definition.common[x].name + " / read=" + device[i].definition.common[x].read + " write=" + device[i].definition.common[x].write);
                  } else {
                      if (logging) log("No Datapoint Trigger set for " + device[i].definition.common[x].name + " because its readonly.");
                  };
              };
          };
          

          }

          //***************** U T I L S *********************** */
          function CheckDataTypeAndConvert(value, HasToBe) {
          if (typeof value == "string" && HasToBe == "number") {
          if (parseFloat(value) == parseInt(value)) { //Umgewandelter String ist Int
          return parseInt(value);
          } else {
          return parseFloat(value);
          };
          } else {
          return value;
          };
          }

          function CorrectChannelId(cid) { //Erzeugt eine iobroker taugliche channelid. Punkte werden zu unterstrichen gewandelt, Doppelpunkte zu Punkten
          let temp = cid;
          if (typeof temp == "object") {
          temp = JSON.stringify(cid);
          };
          cid = temp.replace(".", '_'); //Erstmal alle potentiellen Punkte im channelnamen entfernen
          temp = cid.replace(/:/g, "."); //Jetzt alle Doppelpunkte durch Punkte ersetzen
          return temp;
          }

          function ConvertDeziToHex(DeziValue) {
          DeziValue = toInt(DeziValue)
          //log(typeof DeziValue)
          if (typeof DeziValue == "number") {
          return "#" + DeziValue.toString(16)
          };
          }

          function ConvertHexToDezi(HexValue) {

          if (typeof HexValue == "string") {
              if (HexValue.indexOf('#') != -1) {
                  HexValue = HexValue.substr(1).toLowerCase()
              } else {
                  HexValue = HexValue.toLowerCase()
              };
          };
          
          var i, j, digits = [0], carry;
          for (i = 0; i < HexValue.length; i += 1) {
              carry = parseInt(HexValue.charAt(i), 16);
              for (j = 0; j < digits.length; j += 1) {
                  digits[j] = digits[j] * 16 + carry;
                  carry = digits[j] / 10 | 0;
                  digits[j] %= 10;
              }
              while (carry > 0) {
                  digits.push(carry % 10);
                  carry = carry / 10 | 0;
              }
          }
          return digits.reverse().join('');
          

          }

          /*

          • Converts an RGB color value to HSL. Conversion formula

          • adapted from http://en.wikipedia.org/wiki/HSL_color_space.

          • Assumes r, g, and b are contained in the set [0, 255] and

          • returns h, s, and l in the set [0, 1].

          • @param {number} r The red color value

          • @param {number} g The green color value

          • @param {number} b The blue color value

          • @return {Array} The HSL representation
            */
            function rgbToHsl(hex) {
            var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);

            var r = parseInt(result[1], 16);
            var g = parseInt(result[2], 16);
            var b = parseInt(result[3], 16);

            r /= 255, g /= 255, b /= 255;
            var max = Math.max(r, g, b),
            min = Math.min(r, g, b);
            var h, s, l = (max + min) / 2;

            if (max == min) {
            h = s = 0; // achromatic
            } else {
            var d = max - min;
            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
            switch (max) {
            case r:
            h = (g - b) / d + (g < b ? 6 : 0);
            break;
            case g:
            h = (b - r) / d + 2;
            break;
            case b:
            h = (r - g) / d + 4;
            break;
            }
            h /= 6;
            }

            return [Math.round(h * 360), Math.round(s * 100)];
            }

          L 1 Reply Last reply Reply Quote 0
          • L
            LassMichIchMachDasSelberKaputt @haselchen last edited by

            @haselchen

            Ich werde es die Tage versuchen, danke dir für deine Hilfe!

            L 1 Reply Last reply Reply Quote 0
            • L
              LassMichIchMachDasSelberKaputt @LassMichIchMachDasSelberKaputt last edited by

              Ich habe jetzt mal VNC installiert und gesehen dass die Datei welche ich per wget kopiert habe nicht den richtigen Inhalt hatte. Das habe ich geändert. Nun läuft das Script weiter aber produziert einen neuen Fehler:

              11.4.2022, 17:41:30.005	[info ]: javascript.0 (385244) Start javascript script.js.Xiaomi.MiHomeScript
              11.4.2022, 17:41:30.010	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Starting AllMyMi V.0.2.29
              11.4.2022, 17:41:30.011	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: registered 0 subscriptions and 0 schedules
              11.4.2022, 17:41:30.012	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: You are already logged in, login canceled
              11.4.2022, 17:41:30.012	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Retrieving your in de registered MiHome Devices
              11.4.2022, 17:41:30.152	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Found 5 MiHome Devices, those are:
              11.4.2022, 17:41:30.152	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Videokamera
              11.4.2022, 17:41:30.153	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Mi Air Purifier 3/3H
              11.4.2022, 17:41:30.153	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Eve
              11.4.2022, 17:41:30.153	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Ventilator Schlafzimmer
              11.4.2022, 17:41:30.153	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Mi Electric Scooter Pro 2 series
              11.4.2022, 17:41:30.154	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Now searching for supported Devices...
              11.4.2022, 17:41:30.154	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Device Mi Air Purifier 3/3H is supported, creating DataPoints if necessary
              11.4.2022, 17:41:30.154	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Device Ventilator Schlafzimmer is supported, creating DataPoints if necessary
              11.4.2022, 17:41:30.169	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Now creating device for zhimi.airpurifier.mb3 / 359561707 / 192.168.3.56 / f0c2418e128fce7315ed211901198273 / 10000
              11.4.2022, 17:41:30.170	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Created device {"_events": GEKÜRZT
              11.4.2022, 17:41:30.757	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Init Device# 0 - device="zhimi.airpurifier.mb3"
              11.4.2022, 17:41:30.757	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Now creating device for dmaker.fan.p18 / GEKÜRZT
              11.4.2022, 17:41:30.758	[info ]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: Created device {"_events": GEKÜRZT
              11.4.2022, 17:41:30.832	[error]: javascript.0 (385244) script.js.Xiaomi.MiHomeScript: TypeError: Cannot read property 'forEach' of undefined
              11.4.2022, 17:41:30.833	[error]: javascript.0 (385244)     at CreateDevices (script.js.Xiaomi.MiHomeScript:924:17)
              11.4.2022, 17:41:30.834	[error]: javascript.0 (385244)     at main (script.js.Xiaomi.MiHomeScript:842:5)
              
              P 1 Reply Last reply Reply Quote 0
              • P
                Pittini Developer @LassMichIchMachDasSelberKaputt last edited by

                @lassmichichmachdasselberkaputt Du erwähnst "die Datei", da Du aber 2 unterstützte Geräte haste müssten es aber auch 2 DateiEN sein. Haste die vom Venti evtl. vergessen?

                L 3 Replies Last reply Reply Quote 0
                • L
                  LassMichIchMachDasSelberKaputt @Pittini last edited by LassMichIchMachDasSelberKaputt

                  @pittini
                  Hallo Pittini!

                  Ich habe jetzt die Dateien für den 3H UND den Fan 2 geupdated. es bleibt bei folgenden errors am Ende:

                  18:34:34.164	error	javascript.0 (401850) script.js.Xiaomi.MiHomeScript: TypeError: Cannot read property 'forEach' of undefined
                  18:34:34.167	error	javascript.0 (401850) at CreateDevices (script.js.Xiaomi.MiHomeScript:924:17)
                  18:34:34.167	error	javascript.0 (401850) at main (script.js.Xiaomi.MiHomeScript:842:5)
                  

                  er zeigt den Fehler also nach Zeile 923, denn "now fetching data" wird im log noch angezeigt:
                  6e40a44b-fd07-428e-829b-c3ee2d68f406-image.png

                  Device 0 wäre der 3H, der hat jetzt allerdings die frische Config Datei erhalten...

                  EDIT:
                  Sehe gerade dass node-mihome auch fehler zeigt:

                  
                  javascript.0
                  2022-04-11 18:50:18.774	error	at main (script.js.Xiaomi.MiHomeScript:842:5)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at CreateDevices (script.js.Xiaomi.MiHomeScript:924:17)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at module.exports.init (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-mihome/lib/device-miio.js:43:7)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at processTicksAndRejections (internal/process/task_queues.js:95:5)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at runMicrotasks (<anonymous>:null:null)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at module.exports.miotFetchSpec (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-mihome/lib/device-miio.js:190:14)
                  
                  javascript.0
                  2022-04-11 18:50:18.773	error	at Array.forEach (<anonymous>:null:null)
                  
                  javascript.0
                  2022-04-11 18:50:18.772	error	at /opt/iobroker/node_modules/iobroker.javascript/node_modules/node-mihome/lib/device-miio.js:192:18
                  
                  javascript.0
                  2022-04-11 18:50:18.772	error	script.js.Xiaomi.MiHomeScript: TypeError: Cannot read property 'forEach' of undefined
                  
                  1 Reply Last reply Reply Quote 0
                  • L
                    LassMichIchMachDasSelberKaputt @Pittini last edited by LassMichIchMachDasSelberKaputt

                    @pittini
                    Erst mal Danke für das Skript, das sieht nach einer menge Arbeit aus!

                    1 Reply Last reply Reply Quote 0
                    • L
                      LassMichIchMachDasSelberKaputt @Pittini last edited by

                      @pittini @haselchen
                      Hallo Leute!

                      Ich bin dem Problem etwas näher gekommen, kann es aber nicht lösen: Nehme ich den Ventilator aus meinem Xiaomi Account, läuft das script durch und ich bekomme sowohl Werte und Steuerungsmöglichkeiten für den Luftfilter.

                      Ist der Lüfter dabei und kommentiere folgende Stelle aus, läuft das script auch durch, jedoch bekomme ich für keines der Geräte Werte, mit Ausnahme von den Werten im jeweiligen Objekt Ordner Info:
                      fa415164-f521-4d67-8696-2204a4a8001f-image.png

                      Auf Systemebene gibt es dann auch keinen Fehler mehr von node-mihome. Die Datei für Mi Smart Standing Fan 2 - dmaker.fan.p18 - (voll/voll) ist in den entsprechenden Ordner kopiert und kontrolliert. Auch das Verhalten des scriptes ändert sich wenn die Datei kopiert wurde wie ich schon mal gezeigt habe. Mit der Definitionsdatei wird u.a. ein link erzeugt, der auf https://miot-spec.org/miot-spec-v2/instance?type=urn:miot-spec-v2:device:fan:0000A005:dmaker-p18:1 zeigt. Der funktioniert auch...

                      Ich kann echt kein JavaScript und komme nicht weiter. Ich habe das Gefühl ich übersehe etwas offensichtliches...

                      1 Reply Last reply Reply Quote 0
                      • ?
                        A Former User last edited by

                        Darf ich in die Runde fragen, ob der 3er nun reibungslos funktioniert? Also mit ioBroker zusammen?
                        Und wie schaut es mit dem "Xiaomi Smart Air Purifier 4" aus? Falls nicht, so würde ich ihn mir eventuell nicht kaufen. Weiß nicht so recht. In den Kommentaren steht immer, jaja, alles geht mit ioBroker, aber dann dauert es Monate und Jahre bis es funktioniert.

                        crunchip 1 Reply Last reply Reply Quote 1
                        • crunchip
                          crunchip Forum Testing Most Active @Guest last edited by

                          @paul-ol Der 3H funktioniert, haben ja einige am laufen

                          1 Reply Last reply Reply Quote 1
                          • ?
                            A Former User last edited by

                            Hi Ihr,

                            ich betreibe seit heute meinen "Smartmi Standing Fan 2S" (zhimi.fan.za4) mit dem genialen Skript. VIELEN DANK @Pittini !!!
                            Es klappt hervorragend.

                            Jetzt noch speziell zu meinem Gerät:
                            Drei Variable funktionieren nicht. Dort ist die Geräte-Datei zumindest für mein Gerät nicht korrekt. Kann hier jemand helfen?

                            Ich habe das hier mal zusammengetragen:

                            f5f29e57-2bdf-4a2a-ba8f-8a5b2e793d6a-2022-06-23_20-29-35.png

                            "buzzer" und "child_lock" ist wie in der App ein boolean.
                            "led_b" ist im Skript boolean, in der App könnte es aber auch was anderes sein, denn dort wählt man "hell, dunkel und aus" aus.
                            Bei "power_off" muss in der Device-Datei "m" in "s" geändert werden. Gut, das wäre das Einzige, was ich selbst schaffen würde 😉

                            Was noch zur Anleitung hinzugefügt werden könnte, sofern sich das auf längere Sicht bewahrheitet:

                            • Gerät kann nach erfolgreicher Verknüpfung (z.B. in einer FritzBox) vom Internet gekappt werden
                            • Gerät kann nach erfolgreicher Verknüpfung aus der Xiaomi-App gelöscht werden
                            • Gerät wird direkt im eigenen Netzwerk bedient. Der Umweg über das Internet, die Cloud ist nicht notwendig!!!

                            Soweit so erfolgreich heute. Ich glaube ich kaufe noch ein paar von den Dingern. Nochmal dickes DANKE!!!

                            HANNES

                            P 1 Reply Last reply Reply Quote 0
                            • P
                              Pittini Developer @Guest last edited by

                              @hannnes sagte in [Vorlage] Xiaomi Airpurifier 3H u.a. inkl. Token auslesen.:

                              Was noch zur Anleitung hinzugefügt werden könnte, sofern sich das auf längere Sicht bewahrheitet:

                              Gerät kann nach erfolgreicher Verknüpfung (z.B. in einer FritzBox) vom Internet gekappt werden
                              Gerät kann nach erfolgreicher Verknüpfung aus der Xiaomi-App gelöscht werden
                              Gerät wird direkt im eigenen Netzwerk bedient. Der Umweg über das Internet, die Cloud ist nicht notwendig!!!

                              Zu den Fehlern kann ich wenig sagen, da ich das Gerät nicht habe, da müßten mal andere User reagieren und das bestätigen oder nicht.
                              Was sicher nicht geht sind die 3 Vorschläge. Das Skript simuliert ja quasi nur die App, machste da das Inet weg kommen weder Daten noch kannste was steuern. Löschen des Gerätes in der App (und somit in der CLoud) sorgt dafür dass das Skript das GErät auch nimmer "sieht". Und doch, der Umweg über Internet/Cloud is nötig.

                              ? 1 Reply Last reply Reply Quote 1
                              • ?
                                A Former User @Pittini last edited by

                                @pittini said in [Vorlage] Xiaomi Airpurifier 3H u.a. inkl. Token auslesen.:

                                Das Skript simuliert ja quasi nur die App, machste da das Inet weg kommen weder Daten noch kannste was steuern. Löschen des Gerätes in der App (und somit in der CLoud) sorgt dafür dass das Skript das GErät auch nimmer "sieht". Und doch, der Umweg über Internet/Cloud is nötig.

                                Antwort:
                                Das Verrückte ist, dass ich in der Fritz!Box dem Ventilator den Internetzugriff ja tatsächlich entzogen habe

                                d905b6ed-f0ad-4851-9548-ebe9f5b07dce-2022-06-25_15-25-31.png /var/folders/21/gzf2n3jj16j4pzdqpl9rc3gh0000gn/T/2022-06-25_15-25-31.png

                                und in der App ihn rausgeschmissen hatte

                                32ff59d8-a7c2-46ed-b642-2fe6f0a2daea-2022-06-25_15-30-12.png /var/folders/21/gzf2n3jj16j4pzdqpl9rc3gh0000gn/T/2022-06-25_15-30-12.png

                                Wenn das, was Du schreibst stimmen würde, und ich glaube Dir, dass Du Dir ganz sicher bist, dann würde man zu anderen Schlussfolgerungen kommen müssen, oder?
                                Die Xiaomi-App vergisst nie, wäre so eine Begründung, und die FritzBox kann alles blocken, aber keine Geräte von Xiaomi.
                                Wer weiß, was Da alles an Zaubertechnologie nötig wäre, um das möglich zu machen, aber eines weiß ich ganz sicher, wenn das Kabel zwischen FritzBox und Telefondose ausgesteckt ist, hat mein Netzwerk wirklich kein Internet mehr (ich habe kein 5G-Notfallnetz oder ähnliches...), dann kann er ja nicht mehr funktionieren.
                                Und trotzdem lässt er sich fernsteuern! Habe es gerade getestet.

                                Am besten Du testest es selbst einfach mal mit einem ähnlichen Produkt, das Du hast. Für mich ist das DIE Lösung!! Genau so wollte ich es haben.

                                haselchen 1 Reply Last reply Reply Quote 0
                                • haselchen
                                  haselchen Most Active @Guest last edited by

                                  @hannnes

                                  Zeig mal bitte, wie du ihn steuerst.....

                                  ? 1 Reply Last reply Reply Quote 0
                                  • ?
                                    A Former User @haselchen last edited by

                                    @haselchen

                                    im Moment noch so:
                                    5cde27f4-0f51-43de-a979-f10951d80de5-2022-06-25_15-54-17.png /var/folders/21/gzf2n3jj16j4pzdqpl9rc3gh0000gn/T/2022-06-25_15-54-17.png

                                    oder war die Frage anders gemeint?

                                    haselchen 1 Reply Last reply Reply Quote 0
                                    • haselchen
                                      haselchen Most Active @Guest last edited by

                                      @hannnes

                                      Rein praktisch, wie schaltest du ihn ein oder aus?
                                      Über Alexa, Blockly, manuell in den Datenpunkt schreiben?

                                      ? 1 Reply Last reply Reply Quote 0
                                      • ?
                                        A Former User @haselchen last edited by

                                        @haselchen

                                        aktuell Datenpunkt auswählen.

                                        d33e025e-0eda-4ede-b7a9-583a66705603-2022-06-25_16-01-30 (1).gif /Users/hannes/Pictures/Snagit/Autosaved Captures.localized/2022-06-25_16-01-30 (1).gif

                                        haselchen 1 Reply Last reply Reply Quote 0
                                        • haselchen
                                          haselchen Most Active @Guest last edited by haselchen

                                          @hannnes

                                          Also definitiv muss was an deinem Netzwerk haken.
                                          Wie Pittini schon schrieb, geht es ohne Verbindung mit dem INet nicht.
                                          Ich habs nachgestellt.

                                          39d3735d-9939-48e1-ad82-e44887106116-grafik.png

                                          041b2f6d-f1d2-4107-8730-2e26cc9b18b6-grafik.png

                                          Edit:

                                          @Hannnes ich nehme alles zurück und behaupte das Gegenteil.

                                          @Pittini trotz INet Sperre kann ich per Eingabe in den Datenpunkte das Gewünschte einstellen.

                                          An / Aus , Natürliche Brise etc. , es wird alles ausgeführt.

                                          ? 1 Reply Last reply Reply Quote 0
                                          • ?
                                            A Former User @haselchen last edited by

                                            @haselchen

                                            gut zu lesen! Ich dachte schon Du hältst mich für verrückt.

                                            Inzwischen habe ich das Gerät (im vom Internet abgeschnittenen Zustand) in HomeKit eingebunden. Klappt mega gut.

                                            haselchen 1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            885
                                            Online

                                            31.9k
                                            Users

                                            80.2k
                                            Topics

                                            1.3m
                                            Posts

                                            50
                                            454
                                            65636
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo