Mit iobroker-javascript 3.6.4 ist der Fehler wieder da. Eventuell auch schon in einer früheren Version.

https://github.com/ioBroker/ioBroker.ja … issues/277

Ich hatte auch eine NPE im BIN-RPC, die ich dann selber gefixt hatte. (s. http://forum.iobroker.net/viewtopic.php … 83#p115883 )

In deinem Fall könntest Du in der Datei hm-rpc.js Zeile 438 schauen, auf welchem Object "params" aufgerufen wird und hierfür einen null-Check adäquat einbauen.

bugs bzgl. BIN-RPC kann man wohl hier reporten: https://github.com/hobbyquaker/binrpc/issues

PS: Den Fehler mit der Mehrfachausführung habe ich im XML-RPC Modus auch, aber den brauche ich jetzt zum Glück nicht mehr.

Klar, gerne. Falls Du/ihr Anregungen habt, was ich besser machen kann/sollte, dann immer her damit. Bin nicht so der Javascript-Held.

[Global]

Room:````
var BARNEY_MEDIA = BARNEY_MEDIA || {};

(function(rooms, undefined) {
rooms.BUERO = Object.freeze(new Room({
name: "BUERO",
comfortTemp: () => 22.0,
tempControls: [{read: "hm-rpc.0.OEQ0987059.2.SET_TEMPERATURE", write: "hm-rpc.0.OEQ0987059.2.MANU_MODE"}],
tempSensor: "hm-rpc.0.OEQ0987059.2.ACTUAL_TEMPERATURE",
tempSensorCorrectOffset: -2,
tempMiddleRoomOffset: 2,
tempColdPointOffset: -2.8,
humiditySensor: "hm-rpc.0.OEQ0987059.2.ACTUAL_HUMIDITY"
}));

rooms.TRULLAS_ZIMMER = Object.freeze(new Room({ 
    name: "TRULLA", 
    basicTemp: () => 19,
    comfortTemp: () => 22,
    tempControls: [{read: "hm-rpc.0.OEQ0986997.2.SET_TEMPERATURE", write: "hm-rpc.0.OEQ0986997.2.MANU_MODE"}],
    tempSensor: "hm-rpc.0.OEQ0986997.2.ACTUAL_TEMPERATURE",
    tempSensorCorrectOffset: -0.5,
    tempMiddleRoomOffset: 0.5,
    tempColdPointOffset: -5.0,
    humiditySensor: "hm-rpc.0.OEQ0986997.2.ACTUAL_HUMIDITY",
    windowSensors: ["hm-rpc.0.OEQ0926664.1.STATE"]
}));

rooms.KUECHE = Object.freeze(new Room({
    name: "KUECHE", 
    basicTemp: () => 15,
    comfortTemp: () => 17,
    tempControls: [{read: "hm-rpc.0.OEQ1248673.4.SET_TEMPERATURE", write: "hm-rpc.0.OEQ1248673.4.MANU_MODE"}],
    tempSensor: "hm-rpc.0.OEQ1248673.4.ACTUAL_TEMPERATURE"
}));

rooms.WOHNZIMMER = Object.freeze(new Room({ 
    name: "WOHNZIMMER", 
    basicTemp: () => 19,
    comfortTemp: function() { 
        var persons = BARNEY_MEDIA.persons;

        if (persons.ANNA.sensorPresence()) {
            return 22.0;
        } else if (persons.FABI.sensorPresence()) {
            return 21.0;
        }

        return 19.0;
    },
    tempControls: [{read: "hm-rpc.0.LEQ0598095.2.SET_TEMPERATURE", write: "hm-rpc.0.LEQ0598095.2.MANU_MODE"}],
    tempSensor: "hm-rpc.0.LEQ0598095.2.ACTUAL_TEMPERATURE",
    tempSensorCorrectOffset: 0.5,
    tempMiddleRoomOffset: -0.5,
    tempColdPointOffset: -3.0,
    humiditySensor: "hm-rpc.0.LEQ0598095.2.ACTUAL_HUMIDITY",
    windowSensors: ["hm-rpc.0.OEQ0439134.1.STATE", "hm-rpc.0.OEQ0926679.1.STATE"]
}));

rooms.SCHLAFZIMMER = Object.freeze(new Room({
    name: "SCHLAFZIMMER", 
    basicTemp: () => 15,
    comfortTemp: () => 19,
    tempControls: [{read: "hm-rpc.0.KEQ0730154.4.SET_TEMPERATURE", write: "hm-rpc.0.KEQ0730154.4.MANU_MODE"}],
    tempSensor: "hm-rpc.0.KEQ0730154.4.ACTUAL_TEMPERATURE",
    windowSensors: ["hm-rpc.0.OEQ0496309.1.STATE"]
}));

var dewpoint = require('dewpoint');

const MINIMAL_TEMP = 5;

function Room(params) {
    this.name = params.name || "noname";
    this.basicTemp = params.basicTemp || () => 17.0;
    this.comfortTemp = params.comfortTemp || () => 21.0;
    this.tempControls = params.tempControls || [];
    this.tempSensor = params.tempSensor || null;
    this.tempSensorCorrectOffset = params.tempSensorCorrectOffset || 0;
    this.tempMiddleRoomOffset = params.tempMiddleRoomOffset || 0;
    this.tempColdPointOffset = params.tempColdPointOffset || 0;
    this.humiditySensor = params.humiditySensor || null;
    this.humiditySensorCorrectOffset = params.humiditySensorCorrectOffset || 0;
    this.windowSensors = params.windowSensors || [];
}

Room.prototype.sensorTemp = function() {
    return getState(this.tempSensor).val + this.tempSensorCorrectOffset;
};

Room.prototype.sensorHumidity = function() {
    if (this.humiditySensor) {
        return getState(this.humiditySensor).val + this.humiditySensorCorrectOffset;
    }

    return null;
};

Room.prototype.minimalTargetTemp = function() {
    if (this.dewpoint() && this.safetyMargin()) {
        return Math.max(MINIMAL_TEMP, this.dewpoint() + this.safetyMargin());
    }

    return this.basicTemp();
};

Room.prototype.basicTargetTemp = function() {
    return Math.max(this.basicTemp(), this.minimalTargetTemp());
};

Room.prototype.comfortTargetTemp = function() {
    return Math.max(this.comfortTemp(), this.minimalTargetTemp());
};

Room.prototype.controlTargetTemp = function(temp) {
    if (!this.anyWindowOpened()) {
        for (var device in this.tempControls) {
            if (temp != getState(this.tempControls[device].read).val) {
                setState(this.tempControls[device].write, temp);
            }
        } 
    }
};

Room.prototype.anyWindowOpened = function() {
    for (var device in this.windowSensors) {
        if (getState(this.windowSensors[device]).val) {
            return true;
        }
    } 

    return false;
};

Room.prototype.safetyMargin = function() {
    var marginFactor = 1.5;
    return (-1) * this.tempColdPointOffset * marginFactor;
}; 

Room.prototype.dewpoint = function() {
    if (this.sensorTemp() && this.sensorHumidity()) {
        var xdp = new dewpoint(48.09);
        var y = xdp.Calc(this.sensorTemp(), this.sensorHumidity());
        return y.dp;
    }

    return null;
};

Room.prototype.toString = function() {
    return '```

Room: '
+ JSON.stringify(this, null, ' ').replace(/\n/g, "
") + '
'
//+ '---------------------------------\n'
+ this.name + '.sensorTemp(): ' + this.sensorTemp() + '
'
+ this.name + '.sensorHumidity(): ' + this.sensorHumidity()+ '
'
+ this.name + '.minimalTargetTemp(): ' + this.minimalTargetTemp() + '
'
+ this.name + '.basicTargetTemp(): ' + this.basicTargetTemp() + '
'
+ this.name + '.comfortTargetTemp(): ' + this.comfortTargetTemp() + '
'
+ this.name + '.anyWindowOpened(): ' + this.anyWindowOpened() + '
'
+ this.name + '.safetyMargin(): ' + this.safetyMargin() + '
'
+ this.name + '.dewpoint(): ' + this.dewpoint() + '
'
+ '

    };

}(BARNEY_MEDIA.rooms = BARNEY_MEDIA.rooms || {}));

Person:````
var BARNEY_MEDIA = BARNEY_MEDIA || {};

(function(persons, undefined) {
persons.FABI = Object.freeze(new Person({
name: "Fabi",
presenceSensor: "tr-064.0.devices.Handy-Fabi"
}));

persons.TRULLA = Object.freeze(new Person({ 
    name: "Trulla",
    presenceSensor: "tr-064.0.devices.Handy-Trulla"
}));

persons.ANNA = Object.freeze(new Person({
    name: "Anna",
    presenceSensor: "tr-064.0.devices.Handy-Anna"
}));

function Person(params) {
    this.name = params.name || "noname";
    this.presenceSensor = params.presenceSensor;
}

Person.prototype.sensorPresence = function() {
    return getState(this.presenceSensor).val;
};

Person.prototype.toString = function() {
    return '```

Person: '
+ JSON.stringify(this, null, ' ').replace(/\n/g, "
") + '
'
+ this.name + '.sensorPresence(): ' + this.sensorPresence() + '
'
+ '

    };

}(BARNEY_MEDIA.persons = BARNEY_MEDIA.persons || {}));

Thing:````
var BARNEY_MEDIA = BARNEY_MEDIA || {};

(function(things, undefined) {
things.FABI_DESKTOP = Object.freeze(new Thing({
name: "Fabi-Desktop",
activeSensor: "tr-064.0.devices.Desktop-Fabi"
}));

things.ANNA_DESKTOP = Object.freeze(new Thing({
    name: "Anna-Desktop",
    activeSensor: "tr-064.0.devices.Desktop-Anna"
}));

function Thing(params) {
    this.name = params.name || "noname";
    this.activeSensor = params.activeSensor;
}

Thing.prototype.sensorActive = function() {
    return getState(this.activeSensor).val;
};

Thing.prototype.toString = function() {
    return '```

Thing: '
+ JSON.stringify(this, null, ' ').replace(/\n/g, "
") + '
'
+ this.name + '.sensorActive(): ' + this.sensorActive() + '
'
+ '

    };

}(BARNEY_MEDIA.things = BARNEY_MEDIA.things || {}));

Thing (anderer Namespace):````
var SOME_OTHER_NAMESPACE = SOME_OTHER_NAMESPACE || {};

(function(things, undefined) {
things.FOO_BAR = Object.freeze(new Thing({
name: "foobar"
}));

function Thing(params) {
    this.name = params.name || "noname";
}

Thing.prototype.toString = function() {
    return '```

Thing: '
+ JSON.stringify(this, null, ' ').replace(/\n/g, "
") + '
'
+ '

    };

}(SOME_OTHER_NAMESPACE.things = SOME_OTHER_NAMESPACE.things || {}));

[Common]

Alle zusammen in einem Common-Skript benutzt:````
var rooms = BARNEY_MEDIA.rooms;
console.log(rooms.BUERO);

var persons = BARNEY_MEDIA.persons;
console.log(persons.FABI);

var things = BARNEY_MEDIA.things;
console.log(things.FABI_DESKTOP);

var otherThings = SOME_OTHER_NAMESPACE.things;
console.log(otherThings.FOO_BAR);

Ich habe mich jetzt letztendlich erstmal für folgenden Ansatz entschieden:

https://stackoverflow.com/a/5947280/582675

Damit kann ich u.a. im globalen Bereich auch mehrere Skripte unter dem selben Namespace aufbauen - unabhängig davon in welcher Reihenfolge diese eingebunden werden.

Für String Literale ist es egal, ob Du single oder double quotes benutzt.

Quelle: http://www.ecma-international.org/ecma- … g-literals

In der Praxis haben vermutlich die Leute einfach ihre Präferenzen. Wenn Du innerhalb eines String eines von beiden einsetzen willst, dann ist es sinnvoll das String-Literal mit dem jeweils Anderen einzuleiten, um dir das Escaping zu sparen.

• var str = 'Hier kann ich "doppelte Anführungszeichen" einfach so ohne Escaping benutzen.'

Am Ehesten kannst das wohl mit Virtualisierungslösungen erreichen, ohne dass iobroker das selbst unterstützt. Kannst Dir ja mal VMWare HA und FT anschauen. Dürfte allerdings auch eine Frage des Preises werden.

Ich habe den Harmony Hub nicht an iobroker angebunden, aber verwende ihn mit Original-Skill mit Alexa zusammen.

Auch da kommt es regelmäßig vor, dass der Hub zwar den Befehl ausführt, aber Alexa mit einem Fehler quittiert und mir lang und breit erklärt, dass ich mich doch bei Fortbestehen der Probleme an harmony.com/alexa wenden solle bla bla

Sonst hat Alexa solche Probleme nicht.

Lange Rede, kurzer Sinn:

Ich glaube der Harmony Hub ist teilweise Grütze, was Software und/oder Netzwerk angeht. (Ich will ihn nicht generell schlecht reden, weil er kann ja sonst echt viel …)

Ich bin qualitativ aber enttäuscht von dem Hub.

(WLAN ist von ner FritzBox 6490 Cable (kdg))

@AlCalzone:

Module sind im Skripte Adapter nicht vorgesehen. Du kannst mehrfach benutzte Funktionen in ein globales Skript packen, das bedeutet dass der globale Code ALLEN anderen Skripten vorne angestellt wird.

Beachte dass die einzelnen Skripte dennoch getrennt sind, ein Datenaustausch zwischen verschiedenen Skripten lässt sich damit nicht realisieren.

Gesendet von unterwegs `
Ok, wäre für mich ausreichend. Datenaustausch brauche ich nicht zwischen den Skripten, denn die sind thematisch schon unterschiedlich. Brauche nur teilweise die gleichen Klassen in verschiedenen Skripten.

Gibt es Best-Practice Ansätze bzgl. Namespaces in globalen Skripten, da ja meine Skripte dann auch Fremdskripten vorangestellt werden und es zu Namenskonflikten kommen kann?

Oder wäre es besser das außerhalb von iobroker zu machen und dann als Dependency über npm reinzuholen?

Oder geht der Einsatz von http://requirejs.org/docs/node.html?

Ich würde gerne meine Skript in mehrere Dateien aufteilen. Insbesondere gibt es Teile, die von mehreren verschiedenen Skripten genutzt werden.

Ich hatte kurz versucht mitmodule.exportsund entsprechendemrequireans Ziel zu kommen, aber````
ReferenceError: module is not defined

Oder ist der richtige Weg die allgemeinen Sachen ins "Global" packen? (Haben keine Trigger etc, sondern sind Klassen für Raum, Person etc.)

@tempestas:

Du wirst ja einen Grund haben, warum du einen Offset von +2 nimmst. Z.B. weil der Thermostat an einer eher kühlen Außenwand hängt?

Dieser Grund verschwindet ja nicht, bloß weil du jetzt die Feuchtigkeit berechnest. Wenn also die tatsächliche (z.B. Raummitte) Temperatur immer 2°C höher ist, als der Thermostat eigentlich anzeigt (ohne Offset), dann würde ich diesen Offset jetzt nicht künstlich wieder zurücknehmen. `
Das ist zwar grundsätzlich richtig, aber für die Berechnung des Taupunktes interessiere ich mich tendenziell eher für die kälteste Stelle des Raumes. Für das Heizen interessiere ich mich bezüglich Komfort für die Temperatur im Raum selbst und zum Absenken ist wiederum der Taupunkt an der kältesten Stelle besonders interessant.

Auch ist die Berechnung der absoluten Luftfeuchtigkeit dann schlicht falsch, wenn die vom Thermostat gemeldete relative Luftfeuchtigkeit gemessen am kälteren Punkt mit der gemeldeten Offset-Temperatur vom Thermostat vorgenommen wird, denn die relative Luftfeuchtigkeit, die vom Thermostat gemeldet wird ändert sich NICHT mit dem eingestellten Temperatur-Offset und bezieht sich auf die tatsächlich gemessene Temperatur. Die tatsächlich gemessene Temperatur wird aber gar nicht vom Thermostat übermittelt. Das heißt man muss den am Thermostat eingestellten Offset kennen, um aus der vom Thermostat gemeldeten relativen Luftfeuchtigkeit die absolute Feuchtigkeit errechnen zu können.

Es wäre natürlich viel schöner gewesen, wenn ELV gleich die absolute Feuchte übermitteln würde und nicht die Relative, weil damit Abhängigkeiten von anderen (zudem künstlich korrigierten) Messgrößen wegfallen. Erschwerend kommt hinzu, dass die abhängigen Messgrößen eben nicht ohne die künstliche Korrektur ausgelesen werden können. Noch weiter erschwerend kommt hinzu, dass die künstliche Korrektur nicht (zumindest nicht einfach, weil glaube "Master-Parameter" oder sowas) ausgelesen werden kann, was es ohne manuelle Konfiguration unmöglich macht weitere Berechnungen aufgrund der rel. Feuchte durchzuführen.