Domoticz

Code: Select all

local blindCheckVar = "checkBlindState"                -- type string; need to be created manually
local blindIDX      = 296                              -- idx of your blind 

return {
    on      =   {   devices   =   { blindIDX },
                    variables =   { blindCheckVar }},
                
    logging =   {   level     =   domoticz.LOG_DEBUG,
                    marker    =   "Blinds position"    },

    data    =   {   action    = { initial = "Open" },                  -- device.state  
                    active    = { initial = 0 },                       -- information only 
                    position  = { initial = 0  }},                     -- 0 = open / 100 = closed
                    
    execute = function(dz, item )
        local maxActionTime = 46
        local blind         = dz.devices(blindIDX)
        local idleTime      = blind.lastUpdate.secondsAgo
        
        local function updatePersistent(action,active,position)
            dz.data.position = dz.utils.round(math.max(math.min(position,100),0)) or dz.data.position  
            dz.data.active   = active or dz.data.active
            dz.data.action   = action or dz.data.action
        end
        
        -- This block will be triggered by the var change and will set
        -- the position to completely Open or completely Closed when no stop Command is received
        if item.isVariable then
            if idleTime > maxActionTime then
                if dz.data.action == "Open" then 
                    updatePersistent("Stopped",idleTime,0)
                elseif dz.data.action == "Closed" then
                    updatePersistent("Stopped",idleTime,100)
                end
            end
            return
        end    
        
        -- This block will do the actual calculation
        local position = dz.data.position
        if    blind.state == "Stopped"  or
            ( blind.state == "Open"     and dz.data.action == "Closed" ) or 
            ( blind.state == "Closed"   and dz.data.action == "Open"   ) then
            local factor = 1
            if dz.data.action == "Open" then
                factor = -1
            end
            position = dz.data.position + factor * (( idleTime )  * ( 100/maxActionTime ))
        end
        updatePersistent(blind.state,idleTime,position)
        
        -- Next if block will schedule an update of a uservariable that will force 
        -- a trigger of this script even when no stop command is given
        if blind.state == "Open" or blind.state == "Closed" then
            local timeRemains = dz.data.position/100 * maxActionTime  
            if blind.state == "Closed" then
                timeRemains = maxActionTime - timeRemains
            end
            dz.variables(blindCheckVar).set(blind.state).afterSec(timeRemains + 3) 
        end
       
    end
}

Code: Select all

local blindCheckVar = "checkBlindState"                -- type string; need to be created manually
local blindIDX      = 31                             -- idx of your blind 

return {
    on      =   {   devices   =   { blindIDX },
                    variables =   { blindCheckVar }},
                
    logging =   {   level     =   domoticz.LOG_DEBUG,
                    marker    =   "Blinds position"    },

    data    =   {   action    = { initial = "Open" },                  -- device.state  
                    active    = { initial = 0 },                       -- information only 
                    position  = { initial = 0  }},                     -- 0 = open / 100 = closed
                    
    execute = function(dz, item )
        local maxActionTime = 10  -- seconds to completly the action (10 for test)
        local blind         = dz.devices(blindIDX)
        local idleTime      = blind.lastUpdate.secondsAgo
        
        local function updatePersistent(action,active,position)
            dz.data.position = dz.utils.round(math.max(math.min(position,100),0)) or dz.data.position  
            dz.data.active   = active or dz.data.active
            dz.data.action   = action or dz.data.action
        end
        
        -- This block will be triggered by the var change and will set
        -- the position to completely Open or completely Closed when no stop Command is received
        if item.isVariable then
            if idleTime > maxActionTime then
                if dz.data.action == "Open" then 
                    updatePersistent("Stopped",idleTime,0)
                elseif dz.data.action == "Closed" then
                    updatePersistent("Stopped",idleTime,100)
                end
            end
            return
        end    
        
        -- This block will do the actual calculation
        local position = dz.data.position
        if    blind.state == "Stopped"  or
            ( blind.state == "Open"     and dz.data.action == "Closed" ) or 
            ( blind.state == "Closed"   and dz.data.action == "Open"   ) then
            local factor = 1
            if dz.data.action == "Open" then
                factor = -1
            end
            position = dz.data.position + factor * (( idleTime )  * ( 100/maxActionTime ))
        end
        updatePersistent(blind.state,idleTime,position)
        
        -- Next if block will schedule an update of a uservariable that will force 
        -- a trigger of this script even when no stop command is given
        if blind.state == "Open" or blind.state == "Closed" then
            local timeRemains = dz.data.position/100 * maxActionTime  
            if blind.state == "Closed" then
                timeRemains = maxActionTime - timeRemains
            end
            dz.variables(blindCheckVar).set(blind.state).afterSec(timeRemains + 3) 
        end
       
    end
}

Code: Select all

on B_UP#Shortpress do
 if [relayp#R_UP]>0
  output,relayp,0,0
 else
  output,relayp,1,0
  output,relayp,0,1
SendToHTTP 192.168.0.105,8085,/json.htm?type=command&param=switchlight&idx=31&switchcmd=Set%20Level&level=40
  timerset,1,2
 endif 
endon

on B_UP#Longpress do
event,event_UP_domoticz
endon

on event_UP_domoticz do
 if [relayp#R_UP]>0
  output,relayp,0,0
 else
  output,relayp,1,0
  output,relayp,0,1
  timerset,1,10   // 10 sec as test to simulate completly UP
SendToHTTP 192.168.0.105,8085,/json.htm?type=command&param=udevice&idx=31&nvalue=1&svalue=40
 endif 
endon

on B_DOWN#Shortpress do
 if [relayp#R_DOWN]>0
  output,relayp,1,0
 else
  output,relayp,0,0
  output,relayp,1,1
SendToHTTP 192.168.0.105,8085,/json.htm?type=command&param=switchlight&idx=31&switchcmd=Set%20Level&level=0
 endif 
endon

on B_DOWN#Longpress do
event,event_DOWN_domoticz
endon

on event_DOWN_domoticz do
 if [relayp#R_DOWN]>0
  output,relayp,1,0
 else
  output,relayp,0,0
  output,relayp,1,1
  timerset,2,10   // 10 sec as test to simulate completly DOWN
SendToHTTP 192.168.0.105,8085,/json.htm?type=command&param=udevice&idx=31&nvalue=0&svalue=0
 endif 
endon


on Rules#Timer=1 do
 output,relayp,0,0
endon

on Rules#Timer=2 do
 output,relayp,1,0
endon 

Code: Select all

--[[     this scripts handles two way commmunication between domoticz and nodemcu / relais
     *** nodemcu to domoticz: nodemcu update the (type string) uservariable blindControl with an MQTT command json string like
         
        Publish domoticz/in,{"command":"setuservariable","idx":55,"value":"blind_1;Up;42"}     -- testJSON up
        Publish domoticz/in,{"command":"setuservariable","idx":55,"value":"blind_1;Down;2"}    -- testJSON down
          
         dzVents will pickup the variable and set the virtual blind accordingly
         
     *** domoticz to relais :  dzVents is triggered by a change (open / close / On / Off and setting a percentage with the slider )in any device with a name 
                               that starts with "blind_", it will calculate the number of equivalent seconds and the direction and send that together 
                               with the name of the device back to nodemcu with an MQTT command
                               the constructed OS command to send the MQTT message looks like:  
        
        mosquitto_pub -t LM46_213/blind_1_Down -m 1
        
        The OS Command to send the off signal is scheduled for after n seconds using a delayed URL    
                         
         the description field of the virtual blind contain the necessary information to identify the nodemcu and the settings there.
         Layout: {"nodemcu":"LM46_213","maxUpTime":"42","maxDownTime":"36"}
         
        some history (last action per device and last nodemcu action will be maintained in 
        dzVenst persistent data. Lay-out in  domoticzdir/scripts/dzVents/data/__data_scriptname.lua
        also in persistent data is per blind a line setting the until blocktime (in seconds from epoch)
        
        MQTT messages can be monitored on the CLI with mosquitto_sub -F "%U - %t - %p" -v -h <broker IP or broker DNS name> -p 1883 -t '#'
        


]] --

return {
    -- active = false,
    
    on      =   {   devices         =   { "blind_*"  },
                    variables       =   { "blindControl" },
                    httpResponses   =   { "nodemcu_*"              }},     -- wildcard
                
    logging =   {   level           =   domoticz.LOG_DEBUG,
                    marker          =   "MQTT Blindposition"    },
                    
    data    =   {   blinds          = { initial = {}  },
                    commands        = { history = true, maxItems = 10 },
                },

    execute = function(dz, item, info )
       
        _G.logMarker             = info.scriptName                  -- sets the logmarker for dz.log
        local allBlinds          = {"blind_1","blind_2","blind_3"}  -- blind names in domoticz
        local maxBlindDownTime   = 36                               -- default time in seconds for blind to go from fully open to fully closed (can be overruled in description)
        local maxBlindUpTime     = 42                               -- default time in seconds for blind to  go from fully closed to fully open (can be overruled in description)  
        local control            = {}
        local entryTime          = os.date(os.time())
        
        local function logWrite(str,level)
            dz.log(tostring(str),level or dz.LOG_DEBUG)
        end
        
        local function dumpPersist()
            for k,v in pairs(dz.data.blinds[item.name]) do
                logWrite(k .. "  ===>>> " ..tostring(v) )
            end
            logWrite(item.name .. "; state: " .. item.state)
            
        end
        
       -- if item.isDevice then
         --   logWrite("\n\n" .. item.name .. "; state: " .. item.state .. "\n" .. item.name .. "; level: " .. item.level .. "\n")
           -- return
        -- end
        
        local function blockBlind(blind,blockSeconds,blocker)
            dz.data.blinds[blind] = dz.data.blinds[blind] or {}
            dz.data.blinds[blind].blockedUntil = math.ceil(os.date(os.time() + blockSeconds+1))     -- blocked until
            dz.data.blinds[blind].blockedBy    = blocker
            dz.data.blinds[blind].blockedFrom  = os.date(os.time())
            dz.data.blinds[blind].levelFrom    = dz.devices(blind).lastLevel
            
            logWrite(blind .. " is blocked until " .. os.date("%X",os.time() + blockSeconds))
        end

        local function isBlocked(blind) 
            if dz.data.blinds[blind] == nil then dz.data.blinds[blind] = {} end
            dz.log("isBlocked = ".. tostring((tonumber(dz.data.blinds[blind].blockedUntil or 0)) >  tonumber(os.date(os.time()))),dz.LOG_DEBUG)
            return (tonumber(dz.data.blinds[blind].blockedUntil or 0) >  tonumber(os.date(os.time())))
        end
        
        local function delta2Seconds(delta)
            local maxUpTime = control.maxUpTime or maxBlindUpTime
            local maxDownTime = control.maxDownTime or maxBlindDownTime
            
            if    delta > 0 then return "Up", math.abs(math.ceil(math.min((delta * maxUpTime / 100 ),maxUpTime)))  end
            return "Down" , math.abs(math.ceil(math.min((delta * maxDownTime / 100 ),maxDownTime)))
        end
        
        local function keepTrack(origin,targetLevel)
            local tail, info
            if item.level  ~=  nil then info = "; level to " .. item.level .. "%"  -- when triggered by variable, there is no level
            else if bTable.s then tail = " for " .. bTable.s   .. " seconds"              -- variable contain s (seconds)
                 else tail = "; level " .. bTable.p end                            -- variable contain p (position)
                 info = ", moving " .. bTable.d .. tail
            end
            dz.data.blinds[origin].levelTo = targetLevel
            dz.data.blinds[origin].info    = dz.data.blinds[origin].info or {}
            dz.data.blinds[origin].info[dz.data.blinds[origin].direction] = dz.time.rawDate .. " " .. dz.time.rawTime .. info
        end
        
        local function newLevel(direction, duration, oldLevel, screenInversion)
            logWrite("1 ---------")
            
            logWrite(tostring(inverted))
            
            local factor   = 100 *  screenInversion
            local maxTime  = control.maxUpTime or maxBlindUpTime
            if direction  ~= "Down" and not inverted then 
                factor = -1 * factor 
                maxTime = control.maxUpTime or maxBlindDownTime     -- time in seconds for blind to go from fully closed to fully open
            elseif direction ~= "Up" and inverted then 
                 factor = -1 * factor 
                 maxTime = control.maxDownTime or maxBlindDownTime     -- time in seconds for blind to go from fully closed to fully open
            end
            return dz.utils.round(math.min(math.max(oldLevel + ( factor * duration / maxTime ),0),100))
        end

        local function delayedURL(callback,seconds)
            callback = "nodemcu_" ..  callback
            local url = dz.settings['Domoticz url'] .. "/json.htm?type=command&param=addlogmessage&message=" .. 
                        callback ..  "%20Scheduled%20for%20after%20" .. seconds .. "%20seconds."
            dz.openURL  ({ url      = url , method   = "GET", callback = callback,}).afterSec(seconds)
        end
           
        local function makeTableFromVar(str)
            local bTable = {}
             
            bTable.n = item.value:match("[a-zA-Z0-9_]+")       -- blind name 
            bTable.d = item.value:match(";[A-Z][a-z]+"):sub(2)      -- direction  
            
            local seconds = item.value:gsub(bTable.n .. ";" .. bTable.d .. ";","")
            bTable.s = tonumber( seconds )
            logWrite("Seconds: " .. bTable.s)
           
            return bTable
        end        
        
        local function osExecute(cmd)
            logWrite("command for osEexecute: ".. cmd) 
            local fileHandle     = assert(io.popen(cmd, 'r'))
            local commandOutput  = assert(fileHandle:read('*a'))
            local returnTable    = {fileHandle:close()}
            
            logWrite("commandOutput: " .. commandOutput)
            logWrite("returncode   : " .. returnTable[3])
           return commandOutput,returnTable[3]            -- rc[3] contains returnCode
        end
        
        local function sendMQTT(nodemcu,blind,direction,seconds) 
            local seconds   = tonumber(seconds) or 0
            local baseMQTT  = "mosquitto_pub -t " .. nodemcu .. "/" .. blind .. "_" .. direction .. " -m "
            if seconds == 0 then 
                osExecute(baseMQTT .. "0" )
            elseif seconds >= 1 then 
                osExecute(baseMQTT .. "1")            
                delayedURL(blind,seconds)
            else    
                osExecute(baseMQTT .. "1")
                osExecute("sleep 0.5")
                osExecute(baseMQTT .. "0")
            end
            
            dz.data.blinds[blind].nodemcu   = nodemcu
            dz.data.blinds[blind].direction = direction
        end        
        
        local function initPersistentBlind(blind)
            dz.data.blinds[blind] = dz.data.blinds[blind] or {}
        end
        
        local function Response2Parms(str)
            str = str:gsub("nodemcu_","")
            return dz.data.blinds[str].nodemcu, str, dz.data.blinds[str].direction
        end
        
        local function setLevelAfterInterrupt(blind)
            -- When a blind action is interrupted, the new level should take this into acount 
            local deltaLevel = dz.data.blinds[blind].levelFrom - dz.data.blinds[blind].levelTo
            local deltaTime  = dz.data.blinds[blind].blockedUntil - dz.data.blinds[blind].blockedFrom
            local newTime    = entryTime - dz.data.blinds[blind].blockedFrom 
            local newLevel   = dz.utils.round(dz.data.blinds[blind].levelFrom - newTime / deltaTime *  deltaLevel ) 
            
            dz.devices(blind).dimTo(newLevel).silent()
            dz.data.blinds[blind].blockedUntil = os.date(os.time())  -- unblock blind 
            dz.data.blinds[blind].levelTo = newLevel 
        end
        
        local function isCut(silent)
            local closed = 99
            local opened = 1

            
            if item.state == "Closed" then
               item.dimTo(closed)
               return true
            elseif item.state == "Open" then
               item.dimTo(opened)
               return true
            elseif item.level == 100  then
                if inverted then 
                    item.dimTo(opened)
                else
                    item.dimTo(closed)
                end
                return true
            elseif item.level == 0 then
                if inverted then 
                    item.dimTo(closed)
                else
                    item.dimTo(opened)
                end
                return true
            
            end
            return false
        end
        
        local function handleBlind(blind)
            initPersistentBlind(blind)
            control = dz.utils.fromJSON(dz.devices(blind).description)
            local targetLevel
            
            if isBlocked(blind) then 
                dz.log("Blind ".. blind .. " is active; Stopping now",dz.LOG_DEBUG) 
                sendMQTT(control.nodemcu,blind,"Up",0) 
                sendMQTT(control.nodemcu,blind,"Down",0) 
                setLevelAfterInterrupt(blind)
                return 
            else
                blockBlind(blind,bTable.s,control.nodemcu)
            end 
                
            local factor = 1
            if inverted then factor = -1 end
            targetLevel = newLevel(bTable.d,bTable.s,dz.devices(blind).level,factor)
            dz.devices(blind).dimTo(targetLevel).silent()
            sendMQTT(control.nodemcu,blind,bTable.d,bTable.s) 
            keepTrack(blind,targetLevel)
        end
        
        local function dzHandleBlind(blindName)
            local blind = dz.devices(blindName)
            local control = dz.utils.fromJSON(blind.description)           
            local direction 
            local delta     = control.maxUpTime or maxBlindUpTime
            
            
            if not(isBlocked(blindName)) then                                       -- too Quick
                if isCut() then
                    dumpPersist()
                    return
                end
                if  dz.data.blinds[blindName].levelTo == 1 then
                        direction, delta = delta2Seconds(blind.lastLevel - 1)
                        direction = "Up"
                elseif dz.data.blinds[blindName].levelTo == 99 then    
                        direction, delta = delta2Seconds(blind.lastLevel - 99)
                        direction = "Down"
                else
                       direction, delta = delta2Seconds(blind.lastLevel - blind.level)
                end
                
                dumpPersist()
                logWrite("lastLevel: " .. blind.lastLevel)
                logWrite("level: " .. blind.level)
                logWrite("direction: " .. direction)
                logWrite("delta: " .. delta)
                
                
                sendMQTT(control.nodemcu,blindName,direction,delta)
                blockBlind(blindName,delta,"dzVents")
            else
                dz.log("Not enough time (still blocked) ...", dz.LOG_DEBUG)
                blind.dimTo(blind.lastLevel).silent()
                return
            end
            keepTrack(blind.name,blind.level)        -- We are here because blind was set in domoticz so blind.level is targetLevel
        end
        
        --- Main code
        if item.isHTTPResponse then                                  -- Used for switching relais off only
            local nodemcu,blind,direction = Response2Parms(item.trigger)
            sendMQTT(nodemcu,blind,direction,0) 
                
        elseif item.isVariable then                                  -- triggered by nodemcu
            bTable = makeTableFromVar(item.value)
            inverted = dz.devices(bTable.n).switchType ==  "Blinds Percentage Inverted"
            
            if bTable.n ~= "ALLBLINDS" then 
                blinds2Handle = {bTable.n} 
            else
                blinds2Handle = allBlinds 
            end
            
            for i = 1,#blinds2Handle do 
                handleBlind(blinds2Handle[i])
                logWrite(blinds2Handle[i])
            end
        else                                                        -- triggered by device 
            local inverted = item.switchType ==  "Blinds Percentage Inverted"
            if item.name == "blind_Master" then
                if isCut() then return end
                for i = 1,#allBlinds do 
                    dz.devices(allBlinds[i]).dimTo(math.max(math.min(item.level,99),1))
                end
                
            else
                if isCut() then 
                    return 
                end
               
                dzHandleBlind(item.name)
            end 
        end
    end
}