Zwave - Yale YRD220 Lock

Hi Scott ,@5iver,

if i use the decorator

i get a error message.

==> /var/log/openhab2/openhab.log <==

2020-04-09 18:36:49.442 [ERROR] [jsr223.jython.Main door Alarm Decode] - Traceback (most recent call last):

  File "/etc/openhab2/automation/lib/python/core/log.py", line 51, in wrapper

    return fn(*args, **kwargs)

  File "<script>", line 40, in main_Door_Alarm_Decode

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 1151, in info

    self._log(INFO, msg, args, **kwargs)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 1270, in _log

    self.handle(record)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 1280, in handle

    self.callHandlers(record)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 1320, in callHandlers

    hdlr.handle(record)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 751, in handle

    self.emit(record)

  File "/etc/openhab2/automation/lib/python/core/log.py", line 17, in emit

    message = self.format(record)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 726, in format

    return fmt.format(record)

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 466, in format

    record.message = record.getMessage()

  File "/etc/openhab2/automation/jython/jython-standalone-2.7.2.jar/Lib/logging/__init__.py", line 330, in getMessage

    msg = msg % self.args

TypeError: not all arguments converted during string formatting

but if i use
main_Door_Alarm_Decode.log.info(“Lock Alarm Message : {}”.format(message))

it runs fine.

Sorry, I just copied what you had in your rule. Use the example from the documentation.

Its OK, still learning the new syntax.
Thanks for your inputs.

hey guys, im getting the following errors.i had a crack at this a couple of years ago and im still stumped now. ive got a Yale door lock and im guessing that Unknown Type in alarmRawParser means the codes that its sending to openhanded are different to what’s in the rule but im a little over my head tbh so any help would be awesome.

2020-06-21 23:20:38.474 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"24","value":"1"}]
2020-06-21 23:20:38.474 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"24","value":"1"}]
2020-06-21 23:20:38.477 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"24","value":"1"}
2020-06-21 23:20:38.478 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"24","value":"1"}
2020-06-21 23:20:40.589 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"24","value":"1"}]
2020-06-21 23:20:40.591 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"24","value":"1"}
2020-06-21 23:20:41.400 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"25","value":"1"}]
2020-06-21 23:20:41.402 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"25","value":"1"}
2020-06-21 23:20:58.158 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"0","value":"0"}]
2020-06-21 23:20:58.160 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"0","value":"0"}
2020-06-21 23:21:00.221 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"24","value":"1"}]
2020-06-21 23:21:00.223 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"24","value":"1"}
2020-06-21 23:21:12.568 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"0","value":"0"}]
2020-06-21 23:21:12.571 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"0","value":"0"}
2020-06-21 23:21:13.218 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: FrontDoor_Test_DoorLock=[{"type":"24","value":"1"}]
2020-06-21 23:21:13.220 [INFO ] [eclipse.smarthome.model.script.Rules] - Lock: Alarm events: Unknown Type in alarmRawParser, {"type":"24","value":"1"}

here’s my item files

Group:Switch:OR(OFF,ON)    gLock                       "Locks [MAP(lock.map):%s]"
Switch                     FrontDoor_Test_DoorLock              "Lock (Front Door [MAP(lock.map):%s]"     (gLock)       {channel="zwave:device:b0b17ba4:node27:lock_door"}
String                     FrontDoor_Test_DoorLock_Alarm_Raw    "Lock (Front Door): Alarm Raw [%s]"       (gLock)       {channel="zwave:device:b0b17ba4:node27:alarm_raw"}

and my rule file too

rule "Lock: Update lock states after alarm_raw event" when
    Item FrontDoor_Test_DoorLock_Alarm_Raw received update then
    val actionItem = gLock.members.findFirst[ item | item.name.toString == triggeringItem.name.toString.replace("_Alarm_Raw","") ]
    logInfo("Rules", "Lock: Alarm events: {}=[{}]",actionItem.name,triggeringItem.state.toString)
    switch (transform("JSONPATH","$.type",triggeringItem.state.toString)) {
        case "ACCESS_CONTROL" : {
            switch (transform("JSONPATH", "$.event", triggeringItem.state.toString)) {
                      case "1" : {
                    actionItem.postUpdate(ON)
                    logInfo("FrontDoor", "Lock: Alarm events: {} updated to Locked",actionItem.name)
                    val StringBuilder message = new StringBuilder("Locked via")
                    switch (transform("JSONPATH", "$.level", triggeringItem.state.toString)) {
                       case "1" : {
                            message.append(" Twist Knob")
                        }
                        case "2" : {
                            message.append(" Lock and Leave")
                        }
                    }
                     logInfo("FrontDoor", "Lock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                        sendBroadcastNotification(message.toString)
                    }
                    if(gPresenceSensors.state == ON) {
                    /*gAllEchoAlerts.sendCommand(message.toString)*/
                    UserCode.postUpdate(message.toString)
                  }
                }
                case "2" : {
                    actionItem.postUpdate(OFF)
                    val StringBuilder message = new StringBuilder("Unlocked via TwistKnob")
                    logInfo("FrontDoor", "Unlock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                    sendBroadcastNotification(message.toString)
                    }
                    if(gPresenceSensors.state == ON) {
                    /*gAllEchoAlerts.sendCommand(message.toString)*/
                    UserCode.postUpdate(message.toString)
                  }
                }
                case "3" : {
                    actionItem.postUpdate(ON)
                    val StringBuilder message = new StringBuilder("Locked via UI")
                    logInfo("FrontDoor", "Lock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                      sendBroadcastNotification(message.toString)
                    }
                    if(gPresenceSensors.state == ON) {
                      /*gAllEchoAlerts.sendCommand(message.toString)*/
                      UserCode.postUpdate(message.toString)
                  }
                }
                case "4" : {
                    actionItem.postUpdate(OFF)
                    val StringBuilder message = new StringBuilder("Unlocked via UI")
                    logInfo("FrontDoor", "Unlock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                      sendBroadcastNotification(message.toString)
                    }
                    if(gPresenceSensors.state == ON) {
                      /*gAllEchoAlerts.sendCommand(message.toString)*/
                      UserCode.postUpdate(message.toString)
                    }
                }
                case "5" : {
                    actionItem.postUpdate(ON)
                    val StringBuilder message = new StringBuilder("Locked with ")
                    switch (transform("JSONPATH", "$.level", triggeringItem.state.toString)) {
                        case "1" : {
                            message.append(" Jodies Code")
                        }
                        case "2" : {
                            message.append(" Kris Code")
                        }
                        case "3" : {
                            message.append(" user code 3")
                        }
                        case "4" : {
                            message.append(" user code 4")
                        }
                        case "5" : {
                            message.append(" user code 5")
                        }
                    }
                    logInfo("FrontDoor", "Lock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                        sendBroadcastNotification(message.toString)
                    }
                    if(gPresenceSensors.state == ON) {
                        /*gAllEchoAlerts.sendCommand(message.toString)*/
                        UserCode.postUpdate(message.toString)
                    }
                }
                case "6" : {
                    actionItem.postUpdate(OFF)
                    val StringBuilder message = new StringBuilder("Unlocked with")
                    switch (transform("JSONPATH", "$.level", triggeringItem.state.toString)) {
                        case "1" : {
                            message.append(" Jodies Code")
                        }
                        case "2" : {
                            message.append(" Kris Code")
                        }
                        case "3" : {
                            message.append(" user code 3")
                        }
                        case "4" : {
                            message.append(" user code 4")
                        }
                        case "5" : {
                            message.append(" user code 5")
                        }
                        case "251" : {
                            message.append(" Master code")
                        }
                    }
                    logInfo("Rules", "Unlock: {}",message.toString)
                    if(gPresenceSensors.state == OFF) {
                        sendBroadcastNotification(message.toString)
                     }
                     if(gPresenceSensors.state == ON) {
                          /*gAllEchoAlerts.sendCommand(message.toString)*/
                          UserCode.postUpdate(message.toString)
                      }
                }
                case "11" : {
                    logInfo("Rules", "Lock: Alarm events: {} is jammed, so setting lock to OFF (unlocked)",actionItem.label)
                    actionItem.postUpdate(OFF)
                    sendBroadcastNotification(actionItem.label + " is jammed")
                }
                case "13" : {
                    val String message = "Front Door Usercode has been deleted"
                    logInfo("Rules", "Door Lock: User Code: {}",message)
                }
                case "14" : {
                    val String message = "Front Door Usercode has been added"
                    logInfo("Rules", "Door Lock: User Code: {}",message)
                }
                case "16" : {
                    val String message = actionItem.label + " keypad is disabled due to too many failed codes"
                    logInfo("Rules", "Lock: Alarm events: {}",message)
                }
                default : {
                    val String message = "Unknown door lock Event, " + triggeringItem.state.toString
                    logInfo("Rules", "Lock: Alarm events: {}",message)
                    sendBroadcastNotification(message)
                }
            }
            if (transform("JSONPATH", "$.event", triggeringItem.previousState(true, "influxdb").state.toString) == "11" && transform("JSONPATH", "$.event", triggeringItem.state.toString)
!= "11") {
                val String message = actionItem.label + " is no longer jammed"
                logInfo("Rules", "Lock: Alarm events: {}",message)
            }
        }
        case "BURGLAR" : {
            FrontDoorLock_Tamper.sendCommand(ON)
            val String message = "Intruder at " + actionItem.name
            logInfo("Tamper Alert", "Lock: Alarm events: {}",message)
        }
        case "POWER_MANAGEMENT" : {
            val String message = "Power Management alarm for " + actionItem.label + ", " + triggeringItem.state.toString
            logInfo("Rules", "Lock: Alarm events: {}",message)
            //SMS_Notification.sendCommand(message)
        }
        default : {
            val String message = "Unknown Type in alarmRawParser, " + triggeringItem.state.toString
            logInfo("Rules", "Lock: Alarm events: {}",message)
            //SMS_Notification.sendCommand(message)
        }
    }
end

The problem is that your lock only supports ALARM V1, but you have the rule setup for V2. There are some posts in this and other topics for V1. For example, look at the reply to…

thanks, using that example I get the following error.

2020-06-22 18:48:04.862 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Lock: Update lock states after alarm_raw event (Lock_EntranceFront)': Could not invoke method: org.eclipse.smarthome.core.items.GenericItem.getState() on instance: {"type":"0","value":"0"}
2020-06-22 18:48:05.701 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Lock: Update lock states after alarm_raw event (Lock_EntranceFront)': Could not invoke method: org.eclipse.smarthome.core.items.GenericItem.getState() on instance: {"type":"25","value":"1"}
2020-06-22 18:48:10.004 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Lock: Update lock states after alarm_raw event (Lock_EntranceFront)': Could not invoke method: org.eclipse.smarthome.core.items.GenericItem.getState() on instance: {"type":"21","value":"1"}

import org.eclipse.xtext.xbase.lib.Functions

val Functions$Function2<GenericItem, GenericItem, Boolean> alarmRawParser = [
    lockAlarmRaw,
    lockItem |
    
    logDebug("Rules", "Lock: Alarm events: {}=[{}]",lockItem.getName,lockAlarmRaw.state.toString)
            switch (transform("JSONPATH", "$.type", lockAlarmRaw.state.toString)) {
                case "21" : {
                    //lockItem.postUpdate(ON)
                    logDebug("Rules", "Lock: Alarm events: {} updated to ON (locked)",lockItem.getName)
                    sendNotification("xxxx@gmail.com", "Front Door Unlocked.")
                }
                case "22" : {
                    //lockItem.postUpdate(OFF)
                    logDebug("Rules", "Lock: Alarm events: {} updated to OFF (unlocked)",lockItem.getName)
                    sendNotification("xxxx@gmail.com", "Front Door locked.")
                }
                case "19" : {
                    switch (transform("JSONPATH", "$.value", lockAlarmRaw.state.toString)) {
                        case "1" : {
                            sendNotification("xxx@gmail.com", "Front Door Unlocked.")
                        }
                        case "2" : {
                            sendNotification("xxx@gmail.com", "Front Door Unlocked.")
                        }
                    }
                }
            }
    true
]

rule "Lock: Update lock states after alarm_raw event (Lock_EntranceFront)"
when
	Item Lock_FrontDoor_Alarm_Raw received update
then
    alarmRawParser.apply(Lock_FrontDoor_Alarm_Raw.state.toString,Lock_FrontDoor,"Lock (Front Entrance)")
end
Group:Switch:OR(OFF,ON)    gLock                       "Locks [MAP(lock.map):%s]"
Switch                     Lock_FrontDoor              "Lock (Front Door [MAP(lock.map):%s]"     (gLock)       {channel="zwave:device:b0b17ba4:node27:lock_door"}
String                     Lock_FrontDoor_Alarm_Raw    "Lock (Front Door): Alarm Raw [%s]"       (gLock)       {channel="zwave:device:b0b17ba4:node27:alarm_raw"}

Read further…

thanks, got it working. here’s my working Rule for anyone that might be interested.

import org.eclipse.xtext.xbase.lib.Functions

val Functions$Function2<GenericItem, GenericItem, Boolean> alarmRawParser = [
    lockAlarmRaw,
    lockItem |
    
    logDebug("Rules", "Lock: Alarm events: {}=[{}]",lockItem.getName,lockAlarmRaw.state.toString)
            switch (transform("JSONPATH", "$.type", lockAlarmRaw.state.toString)) {
                case "21" : {
                    lockItem.postUpdate(ON)
                }
                case "22" : {
                    lockItem.postUpdate(OFF)
                }
                case "24" : {
                    lockItem.postUpdate(ON)
                }
                case "25" : {
                    lockItem.postUpdate(OFF)
                }
                case "19" : {
                    switch (transform("JSONPATH", "$.value", lockAlarmRaw.state.toString)) {
                        case "0" : {
				lockItem.postUpdate(OFF)
                    		Ricks_Iphone_networkBinding.sendCommand(ON)
                        	sendNotification("xxx@gmail.com", "Front Door Unlocked.")
                        }
                        case "1" : {
                    		lockItem.postUpdate(OFF)
                        	sendNotification("***@***", "Mum and Andrew arrived at home.")
				Guests_Home.sendCommand(ON)
                        }
                        case "2" : {
                    		lockItem.postUpdate(OFF)
                        	sendNotification("***@****", "Kylie arrived at home.")
				Guests_Home.sendCommand(ON)
                        }
                    }
                }
            }
    true
]

rule "Lock: Update lock states after alarm_raw event (Lock_EntranceFront)"
when
	Item Lock_FrontDoor_Alarm_Raw changed
then
    alarmRawParser.apply(Lock_FrontDoor_Alarm_Raw,Lock_FrontDoor,"Lock (Front Entrance)")
end
Group:Switch:OR(OFF,ON)    gLock                       "Locks [MAP(lock.map):%s]"
Switch                     Lock_FrontDoor              "Lock (Front Door [MAP(lock.map):%s]"     (gLock)       {channel="zwave:device:b0b17ba4:node27:lock_door"}
String                     Lock_FrontDoor_Alarm_Raw    "Lock (Front Door): Alarm Raw [%s]"       (gLock)       {channel="zwave:device:b0b17ba4:node27:alarm_raw"}
1 Like