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

[loehrj1]

@arteck
Danke, dein Tipp hat mich auf die richtige Spur geführt - manchmal hat man eben Tomaten auf den Augen....
JSON.parse liefert mir allerdings einen Fehler zurück.
Die Ausgabe console.log(typeof data) liefert mir object zurück. Ich habe hier doch bereits ein Javascript Objekt vorliegen und muss folglich nicht parsen. Richtig?

Der Zugriff erfolgt mit einfach mit dem Punktoperator auf die jeweiligen Eigenschaften des Objektes....

[Singular75]

@MiSchroe Gibt es hier ggf. schon ein Update? Der Umweg über die KLF200-API geht zwar rudimentär, ein "echter" Adapter wäre aber deutlich angenehmer in der Nutzung :)

[Homoran]

@Singular75 sagte in Adapter für VELUX KLF-200 Interface:

ein "echter" Adapter

Wie meinst du das?

https://github.com/MiSchroe/ioBroker.klf200/blob/master/README.md

Das ist ein Adapter

[Singular75]

@Homoran Ja, aber der funktioniert seit dem Firmwareupdate des KLF200 nicht mehr, da die API sich komplett geändert hat. @MiSchroe wollte ihn dahingehend anpassen. In der Zwischenzeit nutzen einige die Umweg über die KLF200-API, was allerdings anteilig suboptimal funktioniert (Verbindungsabbrüche, etc.)

[Singular75]

@loehrj1 said in Adapter für VELUX KLF-200 Interface:

7:41:30.056 info javascript.0 script.js.Velux: [object

Kannst Du Deine Scripte in diesem Kontext (Reset, Detailansteuerung inkl. Stop, Verbindungsaufrechterhaltung) bitte hier alle geeignet posten? Das wäre sehr hilfreich :)

lg
Alex

[loehrj1]

Hallo Alex,

ich steuere aktuell 5 Solarroladen (Az..., Sz, Wz...) über dieses Script in Verbindung mit der KLF-200 API.
Die Ansteuerung der einzelnen Rolladen erfolgt über die Logitech Harmony und über Apple Homekit.

Eine kurze Beschreibung der verwendeten Funktionen:

function ConnectKlf()
Aufbau der Vebindung zum KLF200

function Rollo( Num, Val)
Ansteuerung der Rolladen. Num ist NodeId des zu steuernden Rollos. Num entspricht einem Wert zwischen 0 und 0xc700, 0xD200 entspricht dem Wert für Stop

function GetState()
Holt den Öffnungswert aller 5 Rolladen. Verwende ich zyklisch als Idle-Telegramm zur Aufrechterhaltung der Verbindung

function Status(data)
Callbackfunktion zur Auswertung der Öffnungswerte der Rolladen aus data.parameterData[0].parameter (Highbyte) und data.parameterData[0].parameterValue (Lowbyte)

function JobFinished(data)
Callback fuer Ende der Befehlsausfuehrung

onStop(function skriptStop () {....
Beenden des scripts mit Verbindungsabbau und Aufräumen

schedule('/1 * * * ', function () {...
Lebenszeichentelegramm und Statusabfrage jede Minute

*schedule('5 23 * * ', function () {....
Reboot des KLF200 einmal am Tag

Viele Grüße
Jürgen

Hier das Script:

'use strict' ; 
// Netzwerk
const Ip       = '192.168.178.5'
const Passwort = '0123456789' // WLAN Passwort
 
// nodeIDs der einzelnen Rollos
const AzWest = 0 // nodeId Arbeitzimmer Fenster Westseite
const AzOst  = 1 // nodeId Arbeitzimmer Fenster Ostseite
const SzSued = 2 // nodeId Schlafzimmer Fenster Suedseite
const WzSued = 3 // nodeId Wohnzimmer Fenster Suedseite
const WzNord = 4 // nodeId Wohnzimmer Fenster Nordseite

const MaxNodeIdx = 5;  // 5 Rollos..

const Z = ["AzWest","AzOst","Sz","WzSued","WzNord"] // Name fuer Zuugriff azf Statevariable
 
// Gruppen
const All   = 5 // Alles Dachrolladen
const Wz    = 6 // Wohnzimmer
const Az    = 7 // Arbeitszimmer
const Sz    = 2 // Schlafzimmer
  
const Up    = 0      // Rollo oben
const Down  = 0xc800 // Rollo unten
const Stop  = 0xD200 // Stopkommando
  
// Variable
var velux  = require('velux-klf200-api')
var Connected = false

var SessionId = 1

// Zustand der 5 Rollos holen  
 function GetState()
 {
    velux.sendCommand({ api: velux.API.GW_STATUS_REQUEST_REQ,
                    sessionID: 0,
                    indexArrayCount: 5,
                    indexArray : [AzOst, AzWest, SzSued, WzSued, WzNord],
                    statusType : 3 // Main Info
                    })  
 }
    

 
// Callback fuer Positionsrueckmeldung 
velux.on('GW_STATUS_REQUEST_NTF', Status)     
function Status(data)
{
    var Target     = Math.round(100 - data.targetPosition.value)
    var Current    = Math.round(100 - data.currentPosition.value) // aktuelle Position
    var Time       = data.remainingTime // Restlaufzeit
    var Index      = data.index         // Node index
    var StatusType = data.statusType    // Status Typ "Main Info" = 3 erwartet

    //  console.log(JSON.stringify(data))
    console.log(Z[data.index] + ',Ziel:' +Target + ' Aktuell:' + data.currentPosition.value + ' Restlaufzeit:' + Time)

    if ( (StatusType == 3) && 
         (Time == 0) && 
         (Index >= 0) && 
         (Index < MaxNodeIdx))
    {
        var IdStr    = "javascript.0.Var.DG.Dach.Soll." + Z[data.index] 
        var IdStrIst = "javascript.0.Var.DG.Dach.Ist."  + Z[data.index] 
        setState(IdStr,    Current)
        setState(IdStrIst, Current)
    }
}
  
// Callback Ende Job
velux.on('GW_SESSION_FINISHED_NTF',JobFinished)
function JobFinished(data){
    if ( SessionId == data.sessionID )  // Ende letztes Kommando
    {
        console.log("EndCmd (" + SessionId+')')
        GetState()    // bei Befehlsende Position der fenster abfragen
    }
}
  
// Verbindung aufbauen
function ConnectKlf() { 
    if (! Connected)
    {
        Connected = true;
        velux.connect( Ip, {} )
        .then(()=>{
            velux.login( Passwort ).then(()=>{
            sendMsg("KLF: Connected")
            console.log("Klf connected!")
            Connected = true
            GetState();
            })
        })
        .catch((err)=>{
            console.log(err)
            Connected = false
            velux.end()
        })
    }
} 
   
// Rollos ansteuern
var Rollos = [0,1,2,3,4]
var Count  = 5 
function Rollo( Num, Val) {
    if ( Connected )
    {
        if (Num == All)
        {
            Rollos[0] = WzSued
            Rollos[1] = WzNord
            Rollos[2] = AzOst
            Rollos[3] = AzWest
            Rollos[4] = SzSued
            Count = 5
        }
        else if (Num == Wz)
        {
            Rollos[0] = WzSued
            Rollos[1] = WzNord
            Count = 2
        }
        else if (Num == Az)
        {
            Rollos[0] = AzOst
            Rollos[1] = AzWest
            Count = 2
        }
        else
        {
            Rollos[0] = Num
            Count = 1
        }
        return velux.sendCommand({ api: velux.API.GW_COMMAND_SEND_REQ,
            sessionID : ++SessionId,
            commandOriginator: 1,
            priorityLevel:     2,
            parameterActive:   1,
            functionalParameterMP:  {rawValue : Val}, 
            indexArrayCount: Count,
            indexArray : [Rollos[0], Rollos[1], Rollos[2], Rollos[3], Rollos[4]] ,
            priorityLevelLock: false,
            })
        .then((data)=>{
                console.log("StartCmd (" + data.sessionID+')')
        })
        .catch((err)=>{
            console.log(err)
    })
    }
} 

// Restart einmal pro Tag um 22 Uhr 
schedule('5 20 * * *', function () {
    velux.sendCommand({ api: velux.API.GW_REBOOT_REQ})
    Connected = false
});

// zyklisches Senden Idle Telegramm und Rolladenstatus holen 
schedule('*/1 * * * *', function () {
    velux.sendCommand({ api: velux.API.GW_GET_STATE_REQ})
    .then((data)=>{
        Connected = true
        GetState()       // Rolladenpostionen holen
    })
    .catch((err)=>{
        Connected = false
        sendMsg("KLF: Connection lost")
        console.log("Connection lost...")       
        ConnectKlf() 
    })
}); 
  
// Verbinden zu klf200
ConnectKlf()

 
// Verbindung abbauen und aufraeumen bei Stop
onStop(function skriptStop () {
    Connected = false
    console.log("Disconnect")
    velux.off('GW_STATUS_REQUEST_NTF',  Status)
    velux.off('GW_SESSION_FINISHED_NTF',JobFinished)
    velux.end()
});
 
 



//*******************************************************************************
//    Befehle aus Homekit
//*******************************************************************************
on({id: 'javascript.0.Var.DG.Dach.Alle', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(All, State)
});
on({id: 'javascript.0.Var.DG.Dach.Soll.WzSued', change: 'ne'}, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(WzSued, State)
});
on({id: 'javascript.0.Var.DG.Dach.Soll.WzNord', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(WzNord, State)
});
on({id: 'javascript.0.Var.DG.Dach.Soll.AzOst', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(AzOst, State)
});  
on({id: 'javascript.0.Var.DG.Dach.Soll.AzWest', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(AzWest, State)
});
on({id: 'javascript.0.Var.DG.Dach.Soll.Sz', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(Sz, State)
});   

//*******************************************************************************
//    Mapping fuer Logitech Harmony
//*******************************************************************************
// Dach zu
subscribe({id: 'fakeroku.0.Rolladen.keys.Left', val : true, ack :true}, function (obj) {
    Rollo(Wz, Down)
});
// Dach auf
subscribe({id: 'fakeroku.0.Rolladen.keys.Down', val : true, ack :true}, function (obj) {
    Rollo(Wz, Up)
});
// Dach Stop
subscribe({id: 'fakeroku.0.Rolladen.keys.Info', val : true, ack :true}, function (obj) {
    Rollo(Wz, Stop)
});
// Alles zu
subscribe({id: 'fakeroku.0.Rolladen.keys.Home', change :'ne', ack :true}, function (obj) {
    Rollo(Wz, Down)
    setStateDelayed("hm-rpc.1.OEQ1312460.1.LEVEL", 0,  100, true)
    setStateDelayed('hm-rpc.1.KEQ0157348.1.LEVEL', 0,  100, true)
});

[Singular75]

@loehrj1 said in Adapter für VELUX KLF-200 Interface:

e Ansteuerung der einzelnen Rolladen erfolgt über die Logitech Harmony und über Apple Homekit.

Danke! :)

[paulkerl]

Hallo zusammen,
habe das Script von loehrj1 mal auf meine Bedürfnisse angepasst. Funktioniert super und vor allem schön schnell gegenüber meiner oberen Lösung per CMD einzelne Scripts aufzurufen.

Leider scheine ich einen Fehler im Script zu haben, welchen ich nicht finden kann.

Wenn ich über die Iobroker Objekte die Rollläden steuere funktioniert dies wie es soll bis auf in einem Fall. Ändere ich den Wert von KuNord werden drei der SZ*****-Rolläden ebenfalls gesteuert mit Ausnahme von SzOstRechts. Bedeutet, dass wenn ich z.B. den Wert von KuNord auf 80 setze wird dies ausgeführt. Bei der nächsten Statusabfrage des Scripts werden die o.g. Rollläden ebenfalls auf diesen Wert gesetzt. Dies passiert nur bei KuNord.

Wer hat eine Idee?

Danke euch.

VG P.

'use strict' ; 
// Netzwerk 
const Ip        = '192.168.98.145'
const Passwort = 'XXXXXXXXXXXX' // WLAN Passwort
 
// nodeIDs der einzelnen Rollos
const SzSudLinks = 0 
const SzSudRechts = 1 
const KuNord = 2
const SzOstLinks = 3
const SzOstRechts = 4 
 
const MaxNodeIdx = 5;  // 5 Rollos..
 
const Z = ["SzSudLinks","SzSudRechts","KuNord","SzOstLinks","SzOstRechts"] // Name fuer Zuugriff azf Statevariable
 
// Gruppen
const All   = 5 // Alles Dachrolladen
// const Ku    = 6 // Kueche
const Sz    = 2 // Schlafzimmer
// const Az    = 7 // Arbeitszimmer

const Up    = 0      // Rollo oben
const Down  = 0xc800 // Rollo unten
const Stop  = 0xD200 // Stopkommando
  
// Variable
var velux  = require('velux-klf200-api')
var Connected = false
 
var SessionId = 1
 
// Zustand der 5 Rollos holen  
 function GetState()
 {
    velux.sendCommand({ api: velux.API.GW_STATUS_REQUEST_REQ,
                    sessionID: 0,
                    indexArrayCount: 5,
                    indexArray : [SzSudLinks, SzSudRechts, KuNord, SzOstLinks, SzOstRechts],
                    statusType : 3 // Main Info
                    })  
 }
    
 
 
// Callback fuer Positionsrueckmeldung 
velux.on('GW_STATUS_REQUEST_NTF', Status)     
function Status(data)
{
    var Target     = Math.round(100 - data.targetPosition.value)
    var Current    = Math.round(100 - data.currentPosition.value) // aktuelle Position
    var Time       = data.remainingTime // Restlaufzeit
    var Index      = data.index         // Node index
    var StatusType = data.statusType    // Status Typ "Main Info" = 3 erwartet
 
    //  console.log(JSON.stringify(data))
    console.log(Z[data.index] + ',Ziel:' +Target + ' Aktuell:' + data.currentPosition.value + ' Restlaufzeit:' + Time)
 
    if ( (StatusType == 3) && 
         (Time == 0) && 
         (Index >= 0) && 
         (Index < MaxNodeIdx))
    {
        var IdStr    = "javascript.1.shutter.soll." + Z[data.index] 
        var IdStrIst = "javascript.1.shutter.ist."  + Z[data.index] 
        setState(IdStr,    Current)
        setState(IdStrIst, Current)
    }
}
  
// Callback Ende Job
velux.on('GW_SESSION_FINISHED_NTF',JobFinished)
function JobFinished(data){
    if ( SessionId == data.sessionID )  // Ende letztes Kommando
    {
        console.log("EndCmd (" + SessionId+')')
        GetState()    // bei Befehlsende Position der fenster abfragen
    }
}
  
// Verbindung aufbauen
function ConnectKlf() { 
    if (! Connected)
    {
        Connected = true;
        velux.connect( Ip, {} )
        .then(()=>{
            velux.login( Passwort ).then(()=>{
            sendMsg("KLF: Connected")
            console.log("Klf connected!")
            Connected = true
            GetState();
            })
        })
        .catch((err)=>{
            console.log(err)
            Connected = false
            velux.end()
        })
    }
} 
   
// Rollos ansteuern
var Rollos = [0,1,2,3,4]
var Count  = 5 
function Rollo( Num, Val) {
    if ( Connected )
    {
        if (Num == All)
        {
            Rollos[0] = SzSudLinks
            Rollos[1] = SzSudRechts
            Rollos[2] = KuNord
            Rollos[3] = SzOstLinks
            Rollos[4] = SzOstRechts
            Count = 5
        }
        else if (Num == Sz)
        {
            Rollos[0] = SzSudLinks
            Rollos[1] = SzSudRechts
            Rollos[3] = SzOstLinks
            Rollos[4] = SzOstRechts
            Count = 4
        }
        else
        {
            Rollos[0] = Num
            Count = 1
        }
        return velux.sendCommand({ api: velux.API.GW_COMMAND_SEND_REQ,
            sessionID : ++SessionId,
            commandOriginator: 1,
            priorityLevel:     2,
            parameterActive:   1,
            functionalParameterMP:  {rawValue : Val}, 
            indexArrayCount: Count,
            indexArray : [Rollos[0], Rollos[1], Rollos[2], Rollos[3], Rollos[4]] ,
            priorityLevelLock: false,
            })
        .then((data)=>{
                console.log("StartCmd (" + data.sessionID+')')
        })
        .catch((err)=>{
            console.log(err)
    })
    }
} 
 
// Restart einmal pro Tag um 04 Uhr 
schedule('0 4 * * *', function () {
    velux.sendCommand({ api: velux.API.GW_REBOOT_REQ})
    Connected = false
});
 
// zyklisches Senden Idle Telegramm und Rolladenstatus holen 
schedule('*/1 * * * *', function () {
    velux.sendCommand({ api: velux.API.GW_GET_STATE_REQ})
    .then((data)=>{
        Connected = true
        GetState()       // Rolladenpostionen holen
    })
    .catch((err)=>{
        Connected = false
        sendMsg("KLF: Connection lost")
        console.log("Connection lost...")       
        ConnectKlf() 
    })
}); 
  
// Verbinden zu klf200
ConnectKlf()
 
 
// Verbindung abbauen und aufraeumen bei Stop
onStop(function skriptStop () {
    Connected = false
    console.log("Disconnect")
    velux.off('GW_STATUS_REQUEST_NTF',  Status)
    velux.off('GW_SESSION_FINISHED_NTF',JobFinished)
    velux.end()
});
 
 
 
 
 
//*******************************************************************************
//    Befehle aus Homekit
//*******************************************************************************
on({id: 'javascript.1.shutter.Alle', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(All, State)
});
on({id: 'javascript.1.shutter.soll.KuNord', change: 'ne'}, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(KuNord, State)
});
on({id: 'javascript.1.shutter.soll.SzOstLinks', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzOstLinks, State)
});
on({id: 'javascript.1.shutter.soll.SzOstRechts', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzOstRechts, State)
});  
on({id: 'javascript.1.shutter.soll.SzSudLinks', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzSudLinks, State)
});
on({id: 'javascript.1.shutter.soll.SzSudRechts', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzSudRechts, State)
});   

[paulkerl]

Hallo zusammen,
Problem gelöst. NodeID von KuNord war gleich Const von Gruppe Schlafzimmer.
Const geändert auf 7 und tut.
VG P.

[Singular75]

@loehrj1 So, alles erfolgreich implementiert und funktioniert super. Herzlichen Dank dafür. Hattest Du auch eine "Stop"-Funktion implementiert, die sich aufrufen lässt, während gerade eine Fahrt läuft? Das wäre dann noch das i-Tüpfelchen :)

[loehrj1]

@Singular75
Hallo Singular75,
gern geschehen. Übergebe während der Rollofahrt den Wert 0xD200 für Val an function Rollo(...) und das Rollo sollte an der aktuellen Position stehen bleiben.....
Viele Grüße
Jürgen

[paulkerl]

@loehrj1

nochmals Danke für das Skript. Sehr komfortabel.
Habe ein Problem, welches ich nicht gelöst bekomme.

Wenn ich 'Sz' schalte, werden die Rollos 0,1,2,3 geschaltet. In der Gruppe Sz sind aber die Rollos 0,1,3,4. Wie es aussieht nimmt die Routine ALLE fünf Rollos, arbeitet aber nur die ersten vier ab da count=4 ist.

Hast Du eine Idee was ich falsch mache?
Vielen Dank im Voraus.

LG Paulkerl

'use strict' ; 
// Netzwerk 
const Ip        = '192.168.98.45'
const Passwort = 'XXXXXXXXXXXXX' // WLAN Passwort
 
// nodeIDs der einzelnen Rollos
const SzSudLinks = 0 
const SzSudRechts = 1 
const KuNord = 2
const SzOstLinks = 3
const SzOstRechts = 4 

const MaxNodeIdx = 5;  // 5 Rollos..
 
const Z = ["SzSudLinks","SzSudRechts","KuNord","SzOstLinks","SzOstRechts"] // Name fuer Zuugriff azf Statevariable
 
// Gruppen
const All   = 6 // Alles Dachrolladen
const Sz    = 7 // Schlafzimmer

const Up    = 0      // Rollo oben
const Down  = 0xc800 // Rollo unten
const Stop  = 0xD200 // Stopkommando
  
// Variable
var velux  = require('velux-klf200-api')
var Connected = false
 
var SessionId = 1
 
// Zustand der 5 Rollos holen  
 function GetState()
 {
    velux.sendCommand({ api: velux.API.GW_STATUS_REQUEST_REQ,
                    sessionID: 0,
                    indexArrayCount: 5,
                    indexArray : [SzSudLinks, SzSudRechts, KuNord, SzOstLinks, SzOstRechts],
                    statusType : 3 // Main Info
                    })  
 }
    
 
 
// Callback fuer Positionsrueckmeldung 
velux.on('GW_STATUS_REQUEST_NTF', Status)     
function Status(data)
{
    var Target     = Math.round(100 - data.targetPosition.value)
    var Current    = Math.round(100 - data.currentPosition.value) // aktuelle Position
    var Time       = data.remainingTime // Restlaufzeit
    var Index      = data.index         // Node index
    var StatusType = data.statusType    // Status Typ "Main Info" = 3 erwartet
 
    //  console.log(JSON.stringify(data))
    console.log(Z[data.index] + ',Ziel:' +Target + ' Aktuell:' + data.currentPosition.value + ' Restlaufzeit:' + Time)
 
    if ( (StatusType == 3) && 
         (Time == 0) && 
         (Index >= 0) && 
         (Index < MaxNodeIdx))
    {
        var IdStr    = "javascript.1.shutter.soll." + Z[data.index] 
        var IdStrIst = "javascript.1.shutter.ist."  + Z[data.index] 
        setState(IdStr,    Current)
        setState(IdStrIst, Current)
    }
}
  
// Callback Ende Job
velux.on('GW_SESSION_FINISHED_NTF',JobFinished)
function JobFinished(data){
    if ( SessionId == data.sessionID )  // Ende letztes Kommando
    {
        console.log("EndCmd (" + SessionId+')')
        GetState()    // bei Befehlsende Position der fenster abfragen
    }
}
  
// Verbindung aufbauen
function ConnectKlf() { 
    if (! Connected)
    {
        Connected = true;
        velux.connect( Ip, {} )
        .then(()=>{
            velux.login( Passwort ).then(()=>{
            sendMsg("KLF: Connected")
            console.log("Klf connected!")
            Connected = true
            GetState();
            })
        })
        .catch((err)=>{
            console.log(err)
            Connected = false
            velux.end()
        })
    }
} 
   
// Rollos ansteuern
var Rollos = [0,1,2,3,4]
var Count  = 5 
function Rollo( Num, Val) {
    if ( Connected )
    {
        if (Num == All)
        {
            Rollos[0] = SzSudLinks
            Rollos[1] = SzSudRechts
            Rollos[2] = KuNord
            Rollos[3] = SzOstLinks
            Rollos[4] = SzOstRechts
            Count = 5
        }
        else if (Num == Sz)
        {
            Rollos[0] = SzSudLinks
            Rollos[1] = SzSudRechts
            Rollos[3] = SzOstLinks
            Rollos[4] = SzOstRechts
            Count = 4
        }
        else
        {
            Rollos[0] = Num
            Count = 1
        }
        return velux.sendCommand({ api: velux.API.GW_COMMAND_SEND_REQ,
            sessionID : ++SessionId,
            commandOriginator: 1,
            priorityLevel:     2,
            parameterActive:   1,
            functionalParameterMP:  {rawValue : Val}, 
            indexArrayCount: Count,
            indexArray : [Rollos[0], Rollos[1], Rollos[2], Rollos[3], Rollos[4]] ,
            priorityLevelLock: false,
            })
        .then((data)=>{
                console.log("StartCmd (" + data.sessionID+')')
        })
        .catch((err)=>{
            console.log(err)
    })
    }
} 
 
// Restart einmal pro Tag um 04 Uhr 
//schedule('0 4 * * *', function () {
//    velux.sendCommand({ api: velux.API.GW_REBOOT_REQ})
//    Connected = false
//});
 
// zyklisches Senden Idle Telegramm und Rolladenstatus holen 
schedule('*/1 * * * *', function () {
    velux.sendCommand({ api: velux.API.GW_GET_STATE_REQ})
    .then((data)=>{
        Connected = true
        GetState()       // Rolladenpostionen holen
    })
    .catch((err)=>{
        Connected = false
        sendMsg("KLF: Connection lost")
        console.log("Connection lost...")       
        ConnectKlf() 
    })
}); 
  
// Verbinden zu klf200
ConnectKlf()
 
 
// Verbindung abbauen und aufraeumen bei Stop
onStop(function skriptStop () {
    Connected = false
    console.log("Disconnect")
    velux.off('GW_STATUS_REQUEST_NTF',  Status)
    velux.off('GW_SESSION_FINISHED_NTF',JobFinished)
    velux.end()
});
 
 
 
 
 
//*******************************************************************************
//    Befehle aus Homekit
//*******************************************************************************
on({id: 'javascript.1.shutter.All', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(All, State)
});
on({id: 'javascript.1.shutter.Sz', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(Sz, State)
});
on({id: 'javascript.1.shutter.soll.KuNord', change: 'ne'}, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(KuNord, State)
});
on({id: 'javascript.1.shutter.soll.SzOstLinks', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzOstLinks, State)
});
on({id: 'javascript.1.shutter.soll.SzOstRechts', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzOstRechts, State)
});  
on({id: 'javascript.1.shutter.soll.SzSudLinks', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzSudLinks, State)
});
on({id: 'javascript.1.shutter.soll.SzSudRechts', change: 'ne' }, function (obj) {
    var State = Down - Down / 100 * obj.state.val
    Rollo(SzSudRechts, State)
});   
 

[loehrj1]

Hallo Paulkern,

so sollte es klappen:

else if (Num == Sz)
     {
         Rollos[0] = SzSudLinks
         Rollos[1] = SzSudRechts
         Rollos[2] = SzOstLinks
         Rollos[3] = SzOstRechts
         Count = 4

Du musst die Arrayelemente mit den Indizes ab 0 bis Count-1 mit den gewünschten Node Indizes (SzSudlinks, SzSudRechts,...) belegen
Gruß
jürgen

[paulkerl]

@loehrj1
Hallo,

vielen lieben Dank,
so funktioniert. Hatte das Script falsch interpretiert.
VG Paulkerl

[Singular75]

@loehrj1 Danke! :)

[BoZt]

Guten Abend,

ich bin noch ziemlich neu was das Thema Smart Home betrifft, konnte aber dank der wirklich guten Adapter (Anleitungen) schon einiges mit dem RasPi und Iobroker umsetzen. (Zigbee, Telegram, Sonoff etc.) Was ich aber leider nicht schaffe, ist den KLF200 einzubinden bzw. ihn an zu steuern. Ich habe die Firmware 2.0.0.71. Leider gibt es noch keinen neuen Adapter zur KLF200. Ich bekomme aber die KLF-200-API nicht installiert.

erst bekam ich die Fehlermeldung :

• npm WARN enoent ENOENT: ....
  und jetzt
• npm ERR! code EISDIR
• npm ERR! errno -21 ...

mein System
Raspberry B3
Iobroker 3.6.2
Node.js v8.16.0
NPM 6.4.1

Vielen Dank im voraus

[gemuesepudding]

Moin!

Ich habe versucht das o.g. script für klf200 mit den shuttercontrol zu nutzen. Leider scheiterte es an manchen Punkten (z.B: Sonnenschutz) da dran, dass die aktuelle Position nicht im selben State wie die gewollte steht. Also habe ich das umgebaut.

Es gibt jetzt ein Bereich "Velux.shutter" für die Rollos und einen "Velux.groups" für die Gruppen. Beide werden anhand der Definition im Script automatisch angelegt.

Wenn man jetzt ein Rollo oder eine Gruppe steuern will, so muss der neue Zielwert nur als unbestätigt eingetragen werden. Dieses Verfahren nutzen auch viele Adapter.

Auch muss baseObjectPath ggf. passend gesetzt werden, wenn das Script nicht auf Instanz 0 läuft, oder Ihr das nicht unter Velux haben wollt. Ich habe noch nicht geschaut, ob man die Instanz dynamisch abfragen kann.

Hier kommt es....

'use strict' ; 
// Netzwerk
const Ip       = '192.168.XXX.XXX'
const Passwort = '********' // WLAN Passwort
const baseObjectPath = 'javascript.0.Velux.'

// nodeIDs der einzelnen Rollos
const Papa = 0 // nodeId Fenster 0
const Mama  = 1 // nodeId Fenster 1
const Buero = 2 // nodeId Fenster 2
const Flur = 3 // nodeId Fenster 3
const Bad = 4 // nodeId Fenster 4

const All = [Papa, Mama, Buero, Flur, Bad]

const Z = ["Papa","Mama","Buero","Flur","Bad"] // Name fuer Zugriff auf Statevariable
for(let shutter of Z) {
    createState(baseObjectPath + 'shutter.' + shutter, 0, { name: 'shutter ' + shutter, type: 'number', min: 0, max: 100, unit: '%'})
}

// Gruppen. All, SZ, .. are then names of states. Add new properties for more groups
const groups = {
    All   : All,                // Alles Rolladen
    Sz    : [Papa, Mama],       // Schlafzimmer
    Sued  : [Papa, Mama],
    Nord  : [Buero, Bad, Flur],
}
for(let key of Object.keys(groups)) {
    createState(baseObjectPath + 'groups.' + key, 0, { name: 'group ' + key, type: 'number', min: 0, max: 100, unit: '%'})
}

const MaxNodeIdx = All.length;  // 5 Rollos..

const Up    = 0      // Rollo oben
const Down  = 0xc800 // Rollo unten
const Stop  = 0xD200 // Stopkommando

// Variable
var velux  = require('velux-klf200-api')
var Connected = false
let Commands = {}

var SessionId = 0

// Zustand der Rollos holen  
function GetState(shutters, sessionId)
{
    if (Connected) {
        shutters = shutters || All
        log('checking shutters ' + JSON.stringify(shutters), 'debug')
        velux.sendCommand({ 
            api: velux.API.GW_STATUS_REQUEST_REQ,
            sessionID: sessionId || 0,
            indexArrayCount: shutters.length,
            indexArray : shutters,
            statusType : 3 // Main Info
        })  
    }
}
    
// Callback fuer Positionsrueckmeldung
velux.on('GW_STATUS_REQUEST_NTF', Status);
function Status(data) {
    var Target     = Math.round(100 - data.targetPosition.value)
    var Current    = Math.round(100 - data.currentPosition.value) // aktuelle Position
    var Time       = data.remainingTime // Restlaufzeit
    var Index      = data.index         // Node index
    var StatusType = data.statusType    // Status Typ "Main Info" = 3 erwartet

    //console.log(JSON.stringify(data))
    //console.log(Z[data.index] + ': Ziel ' + Target + ' Aktuell: ' + Current + ' Restlaufzeit :' + Time)

    if ( (StatusType === 3) && 
        (Index >= 0) && 
        (Index < MaxNodeIdx))
    {
        var IdStrIst = baseObjectPath + 'shutter.'  + Z[data.index]
        setState(IdStrIst, Current, true)
    }
}

// Callback Ende Job
velux.on('GW_SESSION_FINISHED_NTF', JobFinished);
function JobFinished(data) {
    log("EndCmd (" + data.sessionID+')', 'debug')
    let sessionKey = 'session_' + data.sessionID
    if (typeof Commands[sessionKey] !== 'undefined') {
        let shutters = Commands[sessionKey].shutters
        // get state after job finished
        GetState(shutters, data.sessionID)
        delete Commands[sessionKey]
    }
}

// Verbindung aufbauen
function ConnectKlf() { 
    if (! Connected) {
        Connected = true;
        velux.connect( Ip, {} ).then(()=>{
            velux.login( Passwort ).then(()=>{
                log("Klf connected!", 'info')
                Connected = true
                GetState();
            })
        })
        .catch((err)=>{
            log('connect error ' + JSON.stringify(err), 'error')
            Connected = false
            velux.end()
        })
    }
} 

function Rollo( Rollos, Val) {
    if ( Connected )
    {
        return velux.sendCommand({ api: velux.API.GW_COMMAND_SEND_REQ,
            sessionID : ++SessionId,
            commandOriginator: 1,
            priorityLevel:     2,
            parameterActive:   1,
            functionalParameterMP:  {rawValue : Val}, 
            indexArrayCount: Rollos.length,
            indexArray : Rollos,
            priorityLevelLock: false,
        }).then((data)=>{
            log("StartCmd (" + data.sessionID+')', 'debug')
            Commands['session_' + data.sessionID] = {
                shutters: Rollos
            }
        })
        .catch((err)=>{
            log(err, 'error')
        })
    }
} 

// Restart einmal pro Tag um 22 Uhr 
schedule('5 20 * * *', function () {
    velux.sendCommand({ api: velux.API.GW_REBOOT_REQ})
    Connected = false
});

// zyklisches Senden Idle Telegramm und Rolladenstatus holen 
schedule('*/1 * * * *', function () {
    velux.sendCommand({ api: velux.API.GW_GET_STATE_REQ})
    .then((data) => {
        //Connected = true
        GetState()       // Rolladenpostionen holen
    })
    .catch((err) => {
        Connected = false
        log('Connection lost...' +JSON.stringify(err), 'error')       
        ConnectKlf() 
    })
}); 

// Verbinden zu klf200
ConnectKlf()

// Verbindung abbauen und aufraeumen bei Stop
onStop(() => {
    Connected = false

    log("Disconnect", 'info')
    velux.off('GW_STATUS_REQUEST_NTF',   Status)
    velux.off('GW_SESSION_FINISHED_NTF', JobFinished)
    velux.end()
});


on({id: new RegExp(baseObjectPath.replace('.', '\.') + 'shutter\..*'), change:'any', ack: false}, function (obj) {
    let State = Down - Down / 100 * obj.state.val
    let shutterName = obj.id.split('.').slice(-1)[0]
    let shutterId = Z.indexOf(shutterName)
    log('Moving shutter ' + shutterName + ' to ' + obj.state.val + '%', 'info')
    Rollo([shutterId], State)
});

on({id: new RegExp(baseObjectPath.replace('.', '\.') + 'groups\..*'), change:'any', ack: false}, function (obj) {
    let State = Down - Down / 100 * obj.state.val
    let shutterName = obj.id.split('.').slice(-1)[0]
    let shutters = groups[shutterName] || []
    if (shutters.length > 0) {
        log('Moving shutter group ' + shutterName + ' to ' + obj.state.val + '%', 'info')
        Rollo(shutters, State)
    }
});

Perfekt ist es noch nicht, da man z.B. die shutter noch 2x im script angeben muss. Bei den Gruppen geht das schon über eine Definition. Aber da man das ja nur recht selten macht sollte das ok sein.

Feel free to comment, like and subscribe. :smirk:

Volker

[gemuesepudding]

Moin... Ich musste ein Rollo auswechseln. Also habe ich jetzt eine Lücke in den IDs.

Hier nochmal die überarbeitete Version:

'use strict' ; 
// Netzwerk
const Ip       = '192.168.120.38'
const Passwort = '*******' // WLAN Passwort
const baseObjectPath = 'javascript.0.Velux.'

const Rollos = {
    Papa: 0, // nodeId Fenster 0
    Mama: 1, // nodeId Fenster 1
    Buero: 2, // nodeId Fenster 2
    Flur: 3, // nodeId Fenster 3
    Bad: 5
}

// Gruppen. All, SZ, .. are then names of states. Add new properties for more groups
const groups = {
    All   : Object.values(Rollos), // all IDs of shutters
    Sz    : [Rollos.Papa, Rollos.Mama],       // Schlafzimmer
    Sued  : [Rollos.Papa, Rollos.Mama],
    Nord  : [Rollos.Buero, Rollos.Bad, Rollos.Flur],
}

const All = Object.keys(Rollos)
for(let shutter of All) {
    createState(baseObjectPath + 'shutter.' + shutter, 0, { name: 'shutter ' + shutter, type: 'number', min: 0, max: 100, unit: '%'})
}

for(let key of Object.keys(groups)) {
    createState(baseObjectPath + 'groups.' + key, 0, { name: 'group ' + key, type: 'number', min: 0, max: 100, unit: '%'})
}
const MaxNodeIdx = All.length;  // 5 Rollos..

const Up    = 0      // Rollo oben
const Down  = 0xc800 // Rollo unten
const Stop  = 0xD200 // Stopkommando

// Variable
var velux  = require('velux-klf200-api')
var Connected = false
let Commands = {}

var SessionId = 0

// Zustand der Rollos holen  
function GetState(shutters, sessionId)
{
    if (Connected) {
        shutters = shutters || All
        log('checking shutters ' + JSON.stringify(shutters), 'debug')
        velux.sendCommand({ 
            api: velux.API.GW_STATUS_REQUEST_REQ,
            sessionID: sessionId || 0,
            indexArrayCount: shutters.length,
            indexArray : shutters,
            statusType : 3 // Main Info
        })  
    }
}
    
// Callback fuer Positionsrueckmeldung
velux.on('GW_STATUS_REQUEST_NTF', Status);
function Status(data) {
    var Target     = Math.round(100 - data.targetPosition.value)
    var Current    = Math.round(100 - data.currentPosition.value) // aktuelle Position
    var Time       = data.remainingTime // Restlaufzeit
    var Index      = data.index         // Node index
    var StatusType = data.statusType    // Status Typ "Main Info" = 3 erwartet

    //console.log(JSON.stringify(data))
    //console.log(Z[data.index] + ': Ziel ' + Target + ' Aktuell: ' + Current + ' Restlaufzeit :' + Time)

    if ( (StatusType === 3) && 
        (Index >= 0) && 
        (Index < MaxNodeIdx))
    {
        var IdStrIst = baseObjectPath + 'shutter.'  + Z[data.index]
        setState(IdStrIst, Current, true)
    }
}

// Callback Ende Job
velux.on('GW_SESSION_FINISHED_NTF', JobFinished);
function JobFinished(data) {
    log("EndCmd (" + data.sessionID+')', 'debug')
    let sessionKey = 'session_' + data.sessionID
    if (typeof Commands[sessionKey] !== 'undefined') {
        let shutters = Commands[sessionKey].shutters
        // get state after job finished
        GetState(shutters, data.sessionID)
        delete Commands[sessionKey]
    }
}

// Verbindung aufbauen
function ConnectKlf() { 
    if (! Connected) {
        Connected = true;
        velux.connect( Ip, {} ).then(()=>{
            velux.login( Passwort ).then(()=>{
                log("Klf connected!", 'info')
                Connected = true
                GetState();
            })
        })
        .catch((err)=>{
            log('connect error ' + JSON.stringify(err), 'error')
            Connected = false
            velux.end()
        })
    }
} 

function Rollo( Rollos, Val) {
    if ( Connected )
    {
        return velux.sendCommand({ api: velux.API.GW_COMMAND_SEND_REQ,
            sessionID : ++SessionId,
            commandOriginator: 1,
            priorityLevel:     2,
            parameterActive:   1,
            functionalParameterMP:  {rawValue : Val}, 
            indexArrayCount: Rollos.length,
            indexArray : Rollos,
            priorityLevelLock: false,
        }).then((data)=>{
            log("StartCmd (" + data.sessionID+')', 'debug')
            Commands['session_' + data.sessionID] = {
                shutters: Rollos
            }
        })
        .catch((err)=>{
            log(err, 'error')
        })
    }
} 

// Restart einmal pro Tag um 22 Uhr 
schedule('5 20 * * *', function () {
    velux.sendCommand({ api: velux.API.GW_REBOOT_REQ})
    Connected = false
});

// zyklisches Senden Idle Telegramm und Rolladenstatus holen 
schedule('*/1 * * * *', function () {
    velux.sendCommand({ api: velux.API.GW_GET_STATE_REQ})
    .then((data) => {
        //Connected = true
        GetState()       // Rolladenpostionen holen
    })
    .catch((err) => {
        Connected = false
        log('Connection lost...' +JSON.stringify(err), 'error')       
        ConnectKlf() 
    })
}); 

// Verbinden zu klf200
ConnectKlf()

// Verbindung abbauen und aufraeumen bei Stop
onStop(() => {
    Connected = false

    log("Disconnect", 'info')
    velux.off('GW_STATUS_REQUEST_NTF',   Status)
    velux.off('GW_SESSION_FINISHED_NTF', JobFinished)
    velux.end()
});


on({id: new RegExp(baseObjectPath.replace('.', '\.') + 'shutter\..*'), change:'any', ack: false}, function (obj) {
    let State = Down - Down / 100 * obj.state.val
    let shutterName = obj.id.split('.').slice(-1)[0]
    let shutterId = Rollos[shutterName]
    log('Moving shutter ' + shutterName + '(' + shutterId + ')' + ' to ' + obj.state.val + '%', 'info')
    Rollo([shutterId], State)
});

on({id: new RegExp(baseObjectPath.replace('.', '\.') + 'groups\..*'), change:'any', ack: false}, function (obj) {
    let State = Down - Down / 100 * obj.state.val
    let shutterName = obj.id.split('.').slice(-1)[0]
    let shutters = groups[shutterName] || []
    if (shutters.length > 0) {
        log('Moving shutter group ' + shutterName + ' to ' + obj.state.val + '%', 'info')
        Rollo(shutters, State)
    }
});

[tcj]

Mein klf200 kam auch heute an.
Firmware 0.2.0.0.71.0
Sehe ich es richtig, dass

• man das Webinterface nur per WLAN erreicht?
• man das WLAN nicht ändern kann, damit der klf200 sich in das heimische einwählt?
• man das LAN im INterface auf DHCP oder eine feste andere eigene IP einstellen kann, aber dann immer noch der erste Punkt oben gilt?
• man aber dennoch zur Steuerung etc. das LAN nutzen kann bzw. muss?

Dank & Gruß
Thomas

[tcj]

Dann antworte ich mir mal selbst mit vier mal Ja ;-)