MSA-1818: Yamaha Receiver and Zones

2026-03-11 05:11:51 +00:00 · 2017-03-04 07:54:50 -08:00
10 changed files with 785 additions and 1351 deletions
--- a/build.gradle
+++ b/build.gradle
@@ -9,7 +9,7 @@ apply plugin: 'smartthings-slack'

 buildscript {
    dependencies {
-        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.11"
+        classpath "com.smartthings.deployment:executable-deployment-scripts:1.0.8"
    }
    repositories {
        mavenLocal()
--- a/devicetypes/fibargroup/fibaro-flood-sensor-zw5.src/fibaro-flood-sensor-zw5.groovy
+++ b/devicetypes/fibargroup/fibaro-flood-sensor-zw5.src/fibaro-flood-sensor-zw5.groovy
@@ -21,30 +21,28 @@ metadata {
 		capability "Tamper Alert"
 		capability "Temperature Measurement"
 		capability "Water Sensor"
-		capability "Health Check"
-
-		fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x22, 0x85, 0x59, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x9C, 0x31, 0x86", outClusters: ""
-		fingerprint mfr:"010F", prod:"0B01", model:"2002"
-		fingerprint mfr:"010F", prod:"0B01", model:"1002"
+        
+        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x22, 0x85, 0x59, 0x20, 0x80, 0x70, 0x56, 0x5A, 0x7A, 0x72, 0x8E, 0x71, 0x73, 0x98, 0x9C, 0x31, 0x86", outClusters: ""
 	}

 	simulator {
+    
 	}
-
-	tiles(scale: 2) {
-		multiAttributeTile(name:"FGFS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
-			tileAttribute("device.water", key:"PRIMARY_CONTROL") {
-				attributeState("dry", icon:"st.alarm.water.dry", backgroundColor:"#00a0dc")
-				attributeState("wet", icon:"st.alarm.water.wet", backgroundColor:"#e86d13")
-			}
-			
-			tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
+    
+    tiles(scale: 2) {
+    	multiAttributeTile(name:"FGFS", type:"lighting", width:6, height:4) {//with generic type secondary control text is not displayed in Android app
+        	tileAttribute("device.water", key:"PRIMARY_CONTROL") {
+            	attributeState("dry", icon:"st.alarm.water.dry", backgroundColor:"#00a0dc")
+            	attributeState("wet", icon:"st.alarm.water.wet", backgroundColor:"#e86d13")
+            }
+            
+            tileAttribute("device.tamper", key:"SECONDARY_CONTROL") {
 				attributeState("active", label:'tamper active', backgroundColor:"#00a0dc")
 				attributeState("inactive", label:'tamper inactive', backgroundColor:"#cccccc")
-			}
-		}
-		
-		valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
+			}       
+        }
+        
+        valueTile("temperature", "device.temperature", inactiveLabel: false, width: 2, height: 2) {
 			state "temperature", label:'${currentValue}°',
 			backgroundColors:[
 				[value: 31, color: "#153591"],
@@ -56,22 +54,22 @@ metadata {
 				[value: 96, color: "#bc2323"]
 			]
 		}
-
-		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-			state "battery", label:'${currentValue}% battery', unit:""
-		}
-
-		main "FGFS"
-		details(["FGFS","battery", "temperature"])
-	}
+       	        
+        valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
+        	state "battery", label:'${currentValue}% battery', unit:""
+        }
+        
+        main "FGFS"
+        details(["FGFS","battery", "temperature"])
+    }
 }

 // parse events into attributes
 def parse(String description) {
 	log.debug "Parsing '${description}'"
 	def result = []
-
-	if (description.startsWith("Err 106")) {
+    
+    if (description.startsWith("Err 106")) {
 		if (state.sec) {
 			result = createEvent(descriptionText:description, displayed:false)
 		} else {
@@ -86,13 +84,13 @@ def parse(String description) {
 	} else if (description == "updated") {
 		return null
 	} else {
-		def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72:2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])
+        def cmd = zwave.parse(description, [0x31: 5, 0x56: 1, 0x71: 3, 0x72:2, 0x80: 1, 0x84: 2, 0x85: 2, 0x86: 1, 0x98: 1])

-		if (cmd) {
-			log.debug "Parsed '${cmd}'"
-			zwaveEvent(cmd)
-		}
-	}
+        if (cmd) {
+            log.debug "Parsed '${cmd}'"
+            zwaveEvent(cmd)
+        }
+    }
 }

 //security
@@ -109,7 +107,7 @@ def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulat
 //crc16
 def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
 {
-	def versions = [0x31: 5, 0x72: 2, 0x80: 1]
+    def versions = [0x31: 5, 0x72: 2, 0x80: 1]
 	def version = versions[cmd.commandClass as Integer]
 	def ccObj = version ? zwave.commandClass(cmd.commandClass, version) : zwave.commandClass(cmd.commandClass)
 	def encapsulatedCommand = ccObj?.command(cmd.command)?.parse(cmd.data)
@@ -123,124 +121,105 @@ def zwaveEvent(physicalgraph.zwave.commands.crc16encapv1.Crc16Encap cmd)
 def zwaveEvent(physicalgraph.zwave.commands.wakeupv2.WakeUpNotification cmd)
 {
 	def event = createEvent(descriptionText: "${device.displayName} woke up", displayed: false)
-	def cmds = []
-	// cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
-	// cmds << "delay 500"
-	cmds << encap(zwave.batteryV1.batteryGet())
-	[event, response(cmds)]
+    def cmds = []
+    cmds << encap(zwave.batteryV1.batteryGet())
+    cmds << "delay 500"
+    cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))    
+    cmds << "delay 1200"
+    cmds << encap(zwave.wakeUpV1.wakeUpNoMoreInformation())
+    [event, response(cmds)]
 }

 def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerSpecificReport cmd) { 
 	log.debug "manufacturerId:   ${cmd.manufacturerId}"
-	log.debug "manufacturerName: ${cmd.manufacturerName}"
-	log.debug "productId:        ${cmd.productId}"
-	log.debug "productTypeId:    ${cmd.productTypeId}"
+    log.debug "manufacturerName: ${cmd.manufacturerName}"
+    log.debug "productId:        ${cmd.productId}"
+    log.debug "productTypeId:    ${cmd.productTypeId}"
 }

 def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.DeviceSpecificReport cmd) { 
 	log.debug "deviceIdData:                ${cmd.deviceIdData}"
-	log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
-	log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
-	log.debug "deviceIdType:                ${cmd.deviceIdType}"
-
-	if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) { //serial number in binary format
+    log.debug "deviceIdDataFormat:          ${cmd.deviceIdDataFormat}"
+    log.debug "deviceIdDataLengthIndicator: ${cmd.deviceIdDataLengthIndicator}"
+    log.debug "deviceIdType:                ${cmd.deviceIdType}"
+    
+    if (cmd.deviceIdType == 1 && cmd.deviceIdDataFormat == 1) {//serial number in binary format
 		String serialNumber = "h'"
-
-		cmd.deviceIdData.each{ data ->
-			serialNumber += "${String.format("%02X", data)}"
-		}
-
-		updateDataValue("serialNumber", serialNumber)
-		log.debug "${device.displayName} - serial number: ${serialNumber}"
-	}
-
-	def response_cmds = []
-	if (!device.currentState("temperature")) {
-		response_cmds << encap(zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0))
-	}
-	if (!getDataValue("version") && !zwaveInfo.ver) {
-		log.debug "Requesting Version Report"
-		response_cmds << "delay 500"
-		response_cmds << encap(zwave.versionV1.versionGet())
-	}
-	response_cmds << "delay 1000"
-	response_cmds << encap(zwave.wakeUpV2.wakeUpNoMoreInformation())
-	[[:], response(response_cmds)]
+        
+        cmd.deviceIdData.each{ data ->
+        	serialNumber += "${String.format("%02X", data)}"
+        }
+        
+        updateDataValue("serialNumber", serialNumber)
+        log.debug "${device.displayName} - serial number: ${serialNumber}"
+    }
 }

-def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {
-	updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
-	log.debug "applicationVersion:      ${cmd.applicationVersion}"
-	log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
-	log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
-	log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
-	log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
+def zwaveEvent(physicalgraph.zwave.commands.versionv1.VersionReport cmd) {	
+    updateDataValue("version", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
+    log.debug "applicationVersion:      ${cmd.applicationVersion}"
+    log.debug "applicationSubVersion:   ${cmd.applicationSubVersion}"
+    log.debug "zWaveLibraryType:        ${cmd.zWaveLibraryType}"
+    log.debug "zWaveProtocolVersion:    ${cmd.zWaveProtocolVersion}"
+    log.debug "zWaveProtocolSubVersion: ${cmd.zWaveProtocolSubVersion}"
 }

 def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
-	def result = []
 	def map = [:]
 	map.name = "battery"
 	map.value = cmd.batteryLevel == 255 ? 1 : cmd.batteryLevel.toString()
 	map.unit = "%"
-
-	result << createEvent(map)
-
-	if (!getDataValue("serialNumber")) {
-		result << response(encap(zwave.manufacturerSpecificV2.deviceSpecificGet()))
-	} else {
-		result << response(encap(zwave.wakeUpV2.wakeUpNoMoreInformation()))
-	}
-	result
+	map.displayed = true
+	createEvent(map)
 }

 def zwaveEvent(physicalgraph.zwave.commands.notificationv3.NotificationReport cmd) {
 	def map = [:]
-	if (cmd.notificationType == 5) {
-		switch (cmd.event) {
-			case 2:
-				map.name = "water"
-				map.value = "wet"
-				map.descriptionText = "${device.displayName} is ${map.value}"
+    if (cmd.notificationType == 5) {
+    	switch (cmd.event) {                
+        	case 2:
+            	map.name = "water"
+                map.value = "wet"
+                map.descriptionText = "${device.displayName} is ${map.value}"
+            	break
+                
+            case 0:
+            	map.name = "water"
+                map.value = "dry"
+                map.descriptionText = "${device.displayName} is ${map.value}"
+            	break
+        }
+    } else if (cmd.notificationType == 7) {
+    	switch (cmd.event) {
+        	case 0:
+            	map.name = "tamper"
+                map.value = "inactive"
+                map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
 				break
-
-			case 0:
-				map.name = "water"
-				map.value = "dry"
-				map.descriptionText = "${device.displayName} is ${map.value}"
-				break
-		}
-	} else if (cmd.notificationType == 7) {
-		switch (cmd.event) {
-			case 0:
-				map.name = "tamper"
-				map.value = "inactive"
-				map.descriptionText = "${device.displayName}: tamper alarm has been deactivated"
-				break
-
-			case 3:
-				map.name = "tamper"
-				map.value = "active"
-				map.descriptionText = "${device.displayName}: tamper alarm activated"
-				break
-		}
-	}
-
-	createEvent(map)
+                
+        	case 3:
+            	map.name = "tamper"
+                map.value = "active"
+                map.descriptionText = "${device.displayName}: tamper alarm activated"
+            	break
+        }
+    }
+    
+    createEvent(map)
 }

 def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv5.SensorMultilevelReport cmd) {
 	def map = [:]
 	if (cmd.sensorType == 1) {
-		// temperature
-		def cmdScale = cmd.scale == 1 ? "F" : "C"
-		map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
-		map.unit = getTemperatureScale()
-		map.name = "temperature"
-		map.displayed = true
+        // temperature
+        def cmdScale = cmd.scale == 1 ? "F" : "C"
+        map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmdScale, cmd.precision)
+        map.unit = getTemperatureScale()
+        map.name = "temperature"
+        map.displayed = true
 	}
-
-	createEvent(map)
+	
+    createEvent(map)
 }

 def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLocallyNotification cmd) {
@@ -249,18 +228,19 @@ def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLoca

 def configure() {
 	log.debug "Executing 'configure'"
-	// Device wakes up every 4 hours, this interval of 8h 2m allows us to miss one wakeup notification before marking offline
-	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
+	
+    def cmds = []
+    
+	cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds:21600, nodeid: zwaveHubNodeId)//FGFS' default wake up interval
+    cmds += zwave.manufacturerSpecificV2.manufacturerSpecificGet()
+    cmds += zwave.manufacturerSpecificV2.deviceSpecificGet()
+    cmds += zwave.versionV1.versionGet()
+    cmds += zwave.batteryV1.batteryGet()
+    cmds += zwave.sensorMultilevelV5.sensorMultilevelGet(sensorType: 1, scale: 0)
+    cmds += zwave.associationV2.associationSet(groupingIdentifier:1, nodeId: [zwaveHubNodeId])
+    cmds += zwave.wakeUpV2.wakeUpNoMoreInformation()

-	// default initial state
-	sendEvent(name: "water", value: "dry")
-
-	def cmds = []
-
-	cmds << zwave.associationV2.associationSet(groupingIdentifier:1, nodeId: [zwaveHubNodeId])
-	cmds << zwave.batteryV1.batteryGet()  // other queries sent as response to BatteryReport
-
-	encapSequence(cmds, 200)
+	encapSequence(cmds, 500)
 }

 private secure(physicalgraph.zwave.Command cmd) {
@@ -269,7 +249,7 @@ private secure(physicalgraph.zwave.Command cmd) {

 private crc16(physicalgraph.zwave.Command cmd) {
 	//zwave.crc16EncapV1.crc16Encap().encapsulate(cmd).format()
-	"5601${cmd.format()}0000"
+    "5601${cmd.format()}0000"
 }

 private encapSequence(commands, delay=200) {
@@ -277,10 +257,13 @@ private encapSequence(commands, delay=200) {
 }

 private encap(physicalgraph.zwave.Command cmd) {
-	if (zwaveInfo.zw && !zwaveInfo.zw.contains("s")) {
-		// Secure inclusion failed
-		crc16(cmd)
-	} else {
-		secure(cmd)
-	}
-}
+	def secureClasses = [0x20, 0x5A, 0x70, 0x71, 0x84, 0x85, 0x8E, 0x9C]
+
+	//todo: check if secure inclusion was successful
+    //if not do not send security-encapsulated command
+	if (secureClasses.find{ it == cmd.commandClassId }) {
+    	secure(cmd)
+    } else {
+    	crc16(cmd)
+    }
+}
--- a/devicetypes/fibargroup/fibaro-motion-sensor-zw5.src/fibaro-motion-sensor-zw5.groovy
+++ b/devicetypes/fibargroup/fibaro-motion-sensor-zw5.src/fibaro-motion-sensor-zw5.groovy
@@ -22,7 +22,6 @@ metadata {
 		capability "Sensor"
 		capability "Tamper Alert"
 		capability "Temperature Measurement"
-		capability "Health Check"
        
        fingerprint deviceId: "0x0701", inClusters: "0x5E, 0x20, 0x86, 0x72, 0x5A, 0x59, 0x85, 0x73, 0x84, 0x80, 0x71, 0x56, 0x70, 0x31, 0x8E, 0x22, 0x30, 0x9C, 0x98, 0x7A", outClusters: ""
 	}
@@ -241,9 +240,7 @@ def zwaveEvent(physicalgraph.zwave.commands.deviceresetlocallyv1.DeviceResetLoca

 def configure() {
 	log.debug "Executing 'configure'"
-	// Device-Watch simply pings if no device events received for 8 hrs & 2 minutes
-	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-
+    
    def cmds = []
    
    cmds += zwave.wakeUpV2.wakeUpIntervalSet(seconds: 7200, nodeid: zwaveHubNodeId)//FGMS' default wake up interval
--- a/devicetypes/redloro-smartthings/yamaha-zone.src/yamaha-zone.groovy
+++ b/devicetypes/redloro-smartthings/yamaha-zone.src/yamaha-zone.groovy
@@ -0,0 +1,282 @@
+/**
+ *  SmartThings Device Handler: Yamaha Zone
+ *
+ *  Author: redloro@gmail.com
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ */
+metadata {
+  definition (name: "Yamaha Zone", namespace: "redloro-smartthings", author: "redloro@gmail.com") {
+
+    /**
+     * List our capabilties. Doing so adds predefined command(s) which
+     * belong to the capability.
+     */
+    capability "Music Player"
+    capability "Switch"
+    capability "Switch Level"
+    capability "Refresh"
+    capability "Polling"
+
+    /**
+     * Define all commands, ie, if you have a custom action not
+     * covered by a capability, you NEED to define it here or
+     * the call will not be made.
+     *
+     * To call a capability function, just prefix it with the name
+     * of the capability, for example, refresh would be "refresh.refresh"
+     */
+    command "source0"
+    command "source1"
+    command "source2"
+    command "source3"
+    command "source4"
+    command "source5"
+    command "mutedOn"
+    command "mutedOff"
+    command "partyModeOn"
+    command "partyModeOff"
+    command "zone"
+  }
+
+  /**
+   * Define the various tiles and the states that they can be in.
+   * The 2nd parameter defines an event which the tile listens to,
+   * if received, it tries to map it to a state.
+   *
+   * You can also use ${currentValue} for the value of the event
+   * or ${name} for the name of the event. Just make SURE to use
+   * single quotes, otherwise it will only be interpreted at time of
+   * launch, instead of every time the event triggers.
+   */
+  tiles(scale: 2) {
+    multiAttributeTile(name:"state", type:"lighting", width:6, height:4) {
+      tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
+        attributeState "on", label:'On', action:"switch.off", icon:"st.Electronics.electronics16", backgroundColor:"#79b821", nextState:"off"
+        attributeState "off", label:'Off', action:"switch.on", icon:"st.Electronics.electronics16", backgroundColor:"#ffffff", nextState:"on"
+      }
+      tileAttribute ("source", key: "SECONDARY_CONTROL") {
+        attributeState "source", label:'${currentValue}'
+      }
+    }
+
+    // row
+    //controlTile("volume", "device.volume", "slider", height: 1, width: 6, range:"(0..100)") {
+    controlTile("volume", "device.volume", "slider", height: 1, width: 6, range:"(-80..16)") {
+      state "volume", label: "Volume", action:"music Player.setLevel", backgroundColor:"#00a0dc"
+    }
+
+    // row
+    standardTile("0", "device.source0", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV1", action:"source0", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV1", action:"source0", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+    standardTile("1", "device.source1", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV2", action:"source1", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV2", action:"source1", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+    standardTile("2", "device.source2", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV3", action:"source2", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV3", action:"source2", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+    standardTile("3", "device.source3", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV4", action:"source3", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV4", action:"source3", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+    standardTile("4", "device.source4", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV5", action:"source4", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV5", action:"source4", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+    standardTile("5", "device.source5", decoration: "flat", width: 2, height: 2) {
+      state("off", label:"AV6", action:"source5", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff")
+      state("on", label:"AV6", action:"source5", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-green.png", backgroundColor:"#ffffff")
+    }
+
+    // row
+    standardTile("muted", "device.muted", decoration: "flat", width: 2, height: 2) {
+      state("off", label:'Muted', action:"mutedOn", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff", nextState:"on")
+      state("on", label:'Muted', action:"mutedOff", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-mute.png", backgroundColor:"#ffffff", nextState:"off")
+    }
+    standardTile("partyMode", "device.partyMode", decoration: "flat", width: 2, height: 2, inactiveLabel: false) {
+      state("off", label:'Party Mode', action:"partyModeOn", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-gray.png", backgroundColor:"#ffffff", nextState:"on")
+      state("on", label:'Party Mode', action:"partyModeOff", icon:"https://raw.githubusercontent.com/redloro/smartthings/master/images/indicator-dot-party.png", backgroundColor:"#ffffff", nextState:"off")
+    }
+    standardTile("refresh", "device.status", width: 2, height: 2, inactiveLabel: false, decoration: "flat") {
+      state "default", label:"Refresh", action:"refresh.refresh", icon:"st.secondary.refresh-icon", backgroundColor:"#ffffff"
+    }
+
+    // Defines which tile to show in the overview
+    main "state"
+
+    // Defines which tile(s) to show when user opens the detailed view
+    details([
+      "state",
+      "volume",
+      "0","1","2","3","4","5",
+      "muted", "partyMode","refresh"
+    ])
+  }
+
+  preferences {
+    input name: "source0", type: "text", title: "Source 1", defaultValue: "AV1"
+    input name: "source1", type: "text", title: "Source 2", defaultValue: "AV2"
+    input name: "source2", type: "text", title: "Source 3", defaultValue: "AV3"
+    input name: "source3", type: "text", title: "Source 4", defaultValue: "AV4"
+    input name: "source4", type: "text", title: "Source 5", defaultValue: "AV5"
+    input name: "source5", type: "text", title: "Source 6", defaultValue: "AV6"
+  }
+}
+
+/**************************************************************************
+ * The following section simply maps the actions as defined in
+ * the metadata into onAction() calls.
+ *
+ * This is preferred since some actions can be dealt with more
+ * efficiently this way. Also keeps all user interaction code in
+ * one place.
+ *
+ */
+def on() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Power_Control><Power>On</Power></Power_Control></${getZone()}></YAMAHA_AV>")
+  sendEvent(name: "switch", value: "on")
+}
+def off() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Power_Control><Power>Standby</Power></Power_Control></${getZone()}></YAMAHA_AV>")
+  sendEvent(name: "switch", value: "off")
+}
+def setLevel(value) {
+  //sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Volume><Lvl><Val>${(Math.round(value * 9 / 5) * 5 - 800).intValue()}</Val><Exp>1</Exp><Unit>dB</Unit></Lvl></Volume></${getZone()}></YAMAHA_AV>")
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Volume><Lvl><Val>${(value * 10).intValue()}</Val><Exp>1</Exp><Unit>dB</Unit></Lvl></Volume></${getZone()}></YAMAHA_AV>")
+  sendEvent(name: "volume", value: value)
+}
+def source0() {
+  setSource(0)
+}
+def source1() {
+  setSource(1)
+}
+def source2() {
+  setSource(2)
+}
+def source3() {
+  setSource(3)
+}
+def source4() {
+  setSource(4)
+}
+def source5() {
+  setSource(5)
+}
+def mutedOn() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Volume><Mute>On</Mute></Volume></${getZone()}></YAMAHA_AV>")
+  sendEvent(name: "muted", value: "on")
+}
+def mutedOff() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Volume><Mute>Off</Mute></Volume></${getZone()}></YAMAHA_AV>")
+  sendEvent(name: "muted", value: "off")
+}
+def partyModeOn() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><System><Party_Mode><Mode>On</Mode></Party_Mode></System></YAMAHA_AV>")
+  sendEvent(name: "partyMode", value: "on")
+}
+def partyModeOff() {
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><System><Party_Mode><Mode>Off</Mode></Party_Mode></System></YAMAHA_AV>")
+  sendEvent(name: "partyMode", value: "off")
+}
+def refresh() {
+  sendCommand("<YAMAHA_AV cmd=\"GET\"><${getZone()}><Basic_Status>GetParam</Basic_Status></${getZone()}></YAMAHA_AV>")
+  sendCommand("<YAMAHA_AV cmd=\"GET\"><System><Party_Mode><Mode>GetParam</Mode></Party_Mode></System></YAMAHA_AV>")
+}
+/**************************************************************************/
+
+/**
+ * Called every so often (every 5 minutes actually) to refresh the
+ * tiles so the user gets the correct information.
+ */
+def poll() {
+  refresh()
+}
+
+def parse(String description) {
+  return
+}
+
+def setSource(id) {
+  //log.debug "source: "+getSourceName(id)
+  sendCommand("<YAMAHA_AV cmd=\"PUT\"><${getZone()}><Input><Input_Sel>"+getSourceName(id)+"</Input_Sel></Input></${getZone()}></YAMAHA_AV>")
+  setSourceTile(getSourceName(id))
+}
+
+def getSourceName(id) {
+  if (settings) {
+    return settings."source${id}"
+  } else {
+    return ['AV1', 'AV2', 'AV3', 'AV4', 'AV5', 'AV6'].get(id)
+  }
+}
+
+def setSourceTile(name) {
+  sendEvent(name: "source", value: "Source: ${name}")
+  for (def i = 0; i < 6; i++) {
+    if (name == getSourceName(i)) {
+      sendEvent(name: "source${i}", value: "on")
+    }
+    else {
+      sendEvent(name: "source${i}", value: "off")
+    }
+  }
+}
+
+def zone(evt) {
+  /*
+  * Zone On/Off
+  */
+  if (evt.Basic_Status.Power_Control.Power.text()) {
+    sendEvent(name: "switch", value: (evt.Basic_Status.Power_Control.Power.text() == "On") ? "on" : "off")
+  }
+
+  /*
+  * Zone Volume
+  */
+  if (evt.Basic_Status.Volume.Lvl.Val.text()) {
+    def int volLevel = evt.Basic_Status.Volume.Lvl.Val.toInteger() ?: -250
+    //sendEvent(name: "volume", value: ((volLevel + 800) / 9).intValue())
+    sendEvent(name: "volume", value: (volLevel / 10).intValue())
+  }
+
+  /*
+  * Zone Muted
+  */
+  if (evt.Basic_Status.Volume.Mute.text()) {
+    sendEvent(name: "muted", value: (evt.Basic_Status.Volume.Mute.text() == "On") ? "on" : "off")
+  }
+
+  /*
+  * Zone Source
+  */
+  if (evt.Basic_Status.Input.Input_Sel.text()) {
+    setSourceTile(evt.Basic_Status.Input.Input_Sel.text())
+  }
+
+  /*
+  * Party Mode
+  */
+  if (evt.Party_Mode.Mode.text()) {
+    sendEvent(name: "partyMode", value: (evt.Party_Mode.Mode.text() == "On") ? "on" : "off")
+  }
+}
+
+private sendCommand(body) {
+  parent.sendCommand(body)
+}
+
+private getZone() {
+  return new String(device.deviceNetworkId).tokenize('|')[2]
+}
--- a/devicetypes/smartthings/fibaro-flood-sensor.src/fibaro-flood-sensor.groovy
+++ b/devicetypes/smartthings/fibaro-flood-sensor.src/fibaro-flood-sensor.groovy
@@ -1,12 +1,12 @@
 /**
 *  Device Type Definition File
 *
- *  Device Type:        Fibaro Flood Sensor
- *  File Name:          fibaro-flood-sensor.groovy
- *  Initial Release:    2014-12-10
- *  @author:            Todd Wackford
- *  Email:              todd@wackford.net
- *  @version:           1.0
+ *  Device Type:		Fibaro Flood Sensor
+ *  File Name:			fibaro-flood-sensor.groovy
+ *	Initial Release:	2014-12-10
+ *	@author:			Todd Wackford
+ *  Email:				todd@wackford.net
+ *  @version:			1.0
 *
 *  Copyright 2014 SmartThings
 *
@@ -26,8 +26,8 @@
 * not displayed to the user. We do this so we can receive events and display on device 
 * activity. If the user wants to display the tamper tile, adjust the tile display lines
 * with the following:
- *      main(["water", "temperature", "tamper"])
- *      details(["water", "temperature", "battery", "tamper"])
+ *		main(["water", "temperature", "tamper"])
+ *		details(["water", "temperature", "battery", "tamper"])
 *
 * @param none
 *
@@ -39,17 +39,13 @@ metadata {
 		capability "Temperature Measurement"
 		capability "Configuration"
 		capability "Battery"
-		capability "Health Check"
-
-		command    "resetParams2StDefaults"
-		command    "listCurrentParams"
-		command    "updateZwaveParam"
-		command    "test"
-
+       
+        command		"resetParams2StDefaults"
+        command		"listCurrentParams"
+        command		"updateZwaveParam"
+        command		"test"
+        
 		fingerprint deviceId: "0xA102", inClusters: "0x30,0x9C,0x60,0x85,0x8E,0x72,0x70,0x86,0x80,0x84"
-		fingerprint mfr:"010F", prod:"0000", model:"2002"
-		fingerprint mfr:"010F", prod:"0000", model:"1002"
-		fingerprint mfr:"010F", prod:"0B00", model:"1001"
 	}

 	simulator {
@@ -90,9 +86,9 @@ metadata {
 				[value: 96, color: "#bc2323"]
 			]
 		}
-		standardTile("tamper", "device.tamper") {
-			state("secure",         label:"secure",         icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
-			state("tampered",       label:"tampered",       icon:"st.locks.lock.unlocked", backgroundColor:"#53a7c0")
+        standardTile("tamper", "device.tamper") {
+			state("secure", 	label:"secure",   	icon:"st.locks.lock.locked",   backgroundColor:"#ffffff")
+			state("tampered", 	label:"tampered", 	icon:"st.locks.lock.unlocked", backgroundColor:"#53a7c0")
 		}
 		valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") {
 			state "battery", label:'${currentValue}% battery', unit:""
@@ -110,17 +106,26 @@ metadata {
 def parse(String description)
 {
 	def result = []
-
-	def cmd = zwave.parse(description, [0x31: 2, 0x30: 1, 0x70: 2, 0x71: 1, 0x84: 1, 0x80: 1, 0x9C: 1, 0x72: 2, 0x56: 2, 0x60: 3])
-
-	if (cmd) {
-		result += zwaveEvent(cmd) //createEvent(zwaveEvent(cmd))   
-	}
-
-	if ( result[0] != null ) {
+	
+    if (description == "updated") {
+    	if (!state.MSR) {
+			result << response(zwave.wakeUpV1.wakeUpIntervalSet(seconds: 60*60, nodeid:zwaveHubNodeId))
+			result << response(zwave.manufacturerSpecificV2.manufacturerSpecificGet())
+		} 
+    } else {
+		def cmd = zwave.parse(description, [0x31: 2, 0x30: 1, 0x70: 2, 0x71: 1, 0x84: 1, 0x80: 1, 0x9C: 1, 0x72: 2, 0x56: 2, 0x60: 3])
+    
+		if (cmd) {
+			result += zwaveEvent(cmd) //createEvent(zwaveEvent(cmd))   
+		}
+    }
+    
+    result << response(zwave.batteryV1.batteryGet().format())
+    
+    if ( result[0] != null ) {
 		log.debug "Parse returned ${result}"
 		result
-	}
+    }
 }


@@ -137,9 +142,10 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 	def result = [createEvent(descriptionText: "${device.displayName} woke up", isStateChange: false)]
 	if (!isConfigured()) {
 		// we're still in the process of configuring a newly joined device
-		result << lateConfigure(true)
+		result += lateConfigure(true)
 	} else {
-		result << response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+		result += response(zwave.wakeUpV1.wakeUpNoMoreInformation())
+        log.debug "We're done with WakeUp!"
 	}
 	result
 }
@@ -147,7 +153,7 @@ def zwaveEvent(physicalgraph.zwave.commands.wakeupv1.WakeUpNotification cmd) {
 def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd)
 {
 	def map = [:]
-
+    
 	switch (cmd.sensorType) {
 		case 1:
 			// temperature
@@ -178,7 +184,7 @@ def zwaveEvent(physicalgraph.zwave.commands.sensorbinaryv1.SensorBinaryReport cm
 	def map = [:]
 	map.value = cmd.sensorValue ? "active" : "inactive"
 	map.name = "acceleration"
-
+    
 	if (map.value == "active") {
 		map.descriptionText = "$device.displayName detected vibration"
 	}
@@ -193,49 +199,49 @@ def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport
 }

 def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
-	log.debug "BasicSet with CMD = ${cmd}"
-
-	if (!isConfigured()) {
-		def result = []
-		def map = [:]
-
-		map.name = "water"
+    log.debug "BasicSet with CMD = ${cmd}"
+    
+    if (!isConfigured()) {
+    	def result = []
+    	def map = [:]
+    
+    	map.name = "water"
 		map.value = cmd.value ? "wet" : "dry"
 		map.descriptionText = "${device.displayName} is ${map.value}"
-
-		// If we are getting a BasicSet, and isConfigured == false, then we are likely NOT properly configured.
-		result += lateConfigure(true)
-
-		result << createEvent(map)
-
-		result
-	}
+    
+    	// If we are getting a BasicSet, and isConfigured == false, then we are likely NOT properly configured.
+    	result += lateConfigure(true)
+    
+    	result << createEvent(map)
+        
+        result
+    }
 }

 def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd)
 {
 	def map = [:]
-
+    
 	if (cmd.sensorType == 0x05) {
 		map.name = "water"
 		map.value = cmd.sensorState ? "wet" : "dry"
 		map.descriptionText = "${device.displayName} is ${map.value}"
-
-		log.debug "CMD = SensorAlarmReport: ${cmd}"
-		setConfigured()
-	} else if ( cmd.sensorType == 0) {
-		map.name = "tamper"
-		map.isStateChange = true
-		map.value = cmd.sensorState ? "tampered" : "secure"
-		map.descriptionText = "${device.displayName} has been tampered with"
-		runIn(30, "resetTamper") //device does not send alarm cancelation
-
-	} else if ( cmd.sensorType == 1) {
-		map.name = "tamper"
-		map.value = cmd.sensorState ? "tampered" : "secure"
-		map.descriptionText = "${device.displayName} has been tampered with"
-		runIn(30, "resetTamper") //device does not send alarm cancelation
-
+        
+        log.debug "CMD = SensorAlarmReport: ${cmd}"
+    	setConfigured()
+    } else if ( cmd.sensorType == 0) {
+    	map.name = "tamper"
+        map.isStateChange = true
+        map.value = cmd.sensorState ? "tampered" : "secure"
+        map.descriptionText = "${device.displayName} has been tampered with"
+        runIn(30, "resetTamper") //device does not send alarm cancelation
+        
+    } else if ( cmd.sensorType == 1) {
+    	map.name = "tamper"
+        map.value = cmd.sensorState ? "tampered" : "secure"
+        map.descriptionText = "${device.displayName} has been tampered with"
+        runIn(30, "resetTamper") //device does not send alarm cancelation
+        
 	} else {
 		map.descriptionText = "${device.displayName}: ${cmd}"
 	}
@@ -244,10 +250,10 @@ def zwaveEvent(physicalgraph.zwave.commands.sensoralarmv1.SensorAlarmReport cmd)

 def resetTamper() {
 	def map = [:]
-	map.name = "tamper"
-	map.value = "secure"
-	map.descriptionText = "$device.displayName is secure"
-	sendEvent(map)
+    map.name = "tamper"
+    map.value = "secure"
+    map.descriptionText = "$device.displayName is secure"
+    sendEvent(map)
 }

 def zwaveEvent(physicalgraph.zwave.Command cmd) {
@@ -261,10 +267,10 @@ def zwaveEvent(physicalgraph.zwave.commands.manufacturerspecificv2.ManufacturerS
 	def msr = String.format("%04X-%04X-%04X", cmd.manufacturerId, cmd.productTypeId, cmd.productId)
 	log.debug "msr: $msr"
 	device.updateDataValue(["MSR", msr])
-
-	if ( msr == "010F-0B00-2001" ) { //this is the msr and device type for the fibaro flood sensor
-		result += lateConfigure(true)
-	}
+    
+    if ( msr == "010F-0B00-2001" ) { //this is the msr and device type for the fibaro flood sensor
+    	result += lateConfigure(true)
+    }

 	result << createEvent(descriptionText: "$device.displayName MSR: $msr", isStateChange: false)
 	result
@@ -276,17 +282,17 @@ def setConfigured() {

 def isConfigured() {
 	Boolean configured = device.getDataValue(["configured"]) as Boolean
-
-	return configured
+    
+    return configured
 }

 def lateConfigure(setConf = False) {
 	def res = response(configure())
-
-	if (setConf)
-		setConfigured()
-
-	return res
+    
+    if (setConf)
+        setConfigured()
+        
+    return res
 }

 /**
@@ -298,34 +304,26 @@ def lateConfigure(setConf = False) {
 */
 def configure() {
 	log.debug "Configuring Device..."
-	// Device wakes up every 4 hours, this interval allows us to miss one wakeup notification before marking offline
-	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-
-	// default initial state
-	sendEvent(name: "water", value: "dry")
-
-	def cmds = []
-
-	// send associate to group 2 to get alarm data
-	cmds << zwave.associationV2.associationSet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()
-
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [255], parameterNumber: 5, size: 1).format()
-
-	// send associate to group 3 to get sensor data reported only to hub
-	cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()
-
-	// reporting frequency of temps and battery set to one hour
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60], parameterNumber: 10, size: 2).format()
-	// cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
+    def cmds = []
+    
+    // send associate to group 2 to get alarm data
+    cmds << zwave.associationV2.associationSet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()
+    
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], parameterNumber: 5, size: 1).format()
+    
+    // send associate to group 3 to get sensor data reported only to hub
+    cmds << zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()

 	// temp hysteresis set to .5 degrees celcius
 	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50], parameterNumber: 12, size: 2).format()
-	// cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
-
-	cmds << zwave.batteryV1.batteryGet().format()
-
-	cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()

+	// reporting frequency of temps and battery set to one hour
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60], parameterNumber: 10, size: 2).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
+    
+    cmds << zwave.wakeUpV1.wakeUpNoMoreInformation().format()
+    
 	delayBetween(cmds, 100)
 }

@@ -351,18 +349,18 @@ def test() {
 * @return none
 */
 def updateZwaveParam(params) {
-	if ( params ) {
-		def pNumber = params.paramNumber
-		def pSize	= params.size
-		def pValue	= [params.value]
-		log.debug "Make sure device is awake and in recieve mode (triple-click?)"
-		log.debug "Updating ${device.displayName} parameter number '${pNumber}' with value '${pValue}' with size of '${pSize}'"
+	if ( params ) {     
+        def pNumber = params.paramNumber
+        def pSize	= params.size
+        def pValue	= [params.value]
+        log.debug "Make sure device is awake and in recieve mode (triple-click?)"
+        log.debug "Updating ${device.displayName} parameter number '${pNumber}' with value '${pValue}' with size of '${pSize}'"

 		def cmds = []
-		cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
-		cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
-		delayBetween(cmds, 1000)
-	}
+        cmds << zwave.configurationV1.configurationSet(configurationValue: pValue, parameterNumber: pNumber, size: pSize).format()
+        cmds << zwave.configurationV1.configurationGet(parameterNumber: pNumber).format()
+        delayBetween(cmds, 1000)        
+    }
 }

 /**
@@ -379,26 +377,26 @@ def updateZwaveParam(params) {
 def resetParams2StDefaults() {
 	log.debug "Resetting ${device.displayName} parameters to SmartThings compatible defaults"
 	def cmds = []
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 1,	 size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [3],				parameterNumber: 2,	 size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [255],			parameterNumber: 5,	 size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [255],			parameterNumber: 7,	 size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [1],				parameterNumber: 9,	 size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60],		parameterNumber: 10, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50],			parameterNumber: 12, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 13, size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [5,220],			parameterNumber: 50, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [13,172],		parameterNumber: 51, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0,0,225],		parameterNumber: 61, size: 4).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,255,0,0],		parameterNumber: 62, size: 4).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [2],				parameterNumber: 63, size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 73, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [2],				parameterNumber: 74, size: 1).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 75, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0],			parameterNumber: 76, size: 2).format()
-	cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 77, size: 1).format()
-
-	delayBetween(cmds, 1200)
+	cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 1,  size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [3], 			parameterNumber: 2,  size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], 			parameterNumber: 5,  size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [255], 			parameterNumber: 7,  size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [1], 			parameterNumber: 9,  size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,60*60], 		parameterNumber: 10, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,50], 			parameterNumber: 12, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0],				parameterNumber: 13, size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [5,220], 		parameterNumber: 50, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [13,172],		parameterNumber: 51, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0,0,225],		parameterNumber: 61, size: 4).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,255,0,0], 	parameterNumber: 62, size: 4).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], 			parameterNumber: 63, size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 73, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [2], 			parameterNumber: 74, size: 1).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 75, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0,0], 			parameterNumber: 76, size: 2).format()
+    cmds << zwave.configurationV1.configurationSet(configurationValue: [0], 			parameterNumber: 77, size: 1).format()
+    
+    delayBetween(cmds, 1200)
 }

 /**
@@ -415,25 +413,25 @@ def resetParams2StDefaults() {
 def listCurrentParams() {
 	log.debug "Listing of current parameter settings of ${device.displayName}"
 	def cmds = []
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 1).format() 
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 2).format() 
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 5).format() 
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 7).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 9).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 13).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 50).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 51).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 61).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 62).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 63).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 73).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 74).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 75).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 76).format()
-	cmds << zwave.configurationV1.configurationGet(parameterNumber: 77).format()
-
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 1).format() 
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 2).format() 
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 5).format() 
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 7).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 9).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 10).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 12).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 13).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 50).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 51).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 61).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 62).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 63).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 73).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 74).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 75).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 76).format()
+    cmds << zwave.configurationV1.configurationGet(parameterNumber: 77).format()
+    
 	delayBetween(cmds, 1200)
 }

--- a/devicetypes/smartthings/fibaro-motion-sensor.src/fibaro-motion-sensor.groovy
+++ b/devicetypes/smartthings/fibaro-motion-sensor.src/fibaro-motion-sensor.groovy
@@ -46,7 +46,6 @@
 		capability 	"Illuminance Measurement"
 		capability 	"Sensor"
 		capability 	"Battery"
-		capability  "Health Check"
        
        command		"resetParams2StDefaults"
        command		"listCurrentParams"
@@ -126,9 +125,6 @@
 */
 def configure() {
 	log.debug "Configuring Device For SmartThings Use"
-	// Device-Watch simply pings if no device events received for 8 hrs & 2 minutes
-	sendEvent(name: "checkInterval", value: 8 * 60 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
-
    def cmds = []
    
    // send associate to group 3 to get sensor data reported only to hub
--- a/devicetypes/smartthings/zll-white-color-temperature-bulb-5000k.src/zll-white-color-temperature-bulb-5000k.groovy
+++ b/devicetypes/smartthings/zll-white-color-temperature-bulb-5000k.src/zll-white-color-temperature-bulb-5000k.groovy
@@ -1,169 +0,0 @@
-/**
- *  Copyright 2016 SmartThings
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-import groovy.transform.Field
-
-@Field Boolean hasConfiguredHealthCheck = false
-
-metadata {
-    definition (name: "ZLL White Color Temperature Bulb 5000K", namespace: "smartthings", author: "SmartThings") {
-
-        capability "Actuator"
-        capability "Color Temperature"
-        capability "Configuration"
-        capability "Polling"
-        capability "Refresh"
-        capability "Switch"
-        capability "Switch Level"
-        capability "Health Check"
-
-        attribute "colorName", "string"
-        command "setGenericName"
-
-        fingerprint profileId: "C05E", deviceId: "0220", inClusters: "0000, 0004, 0003, 0006, 0008, 0005, 0300", outClusters: "0019", manufacturer: "Eaton", model: "Halo_LT01", deviceJoinName: "Halo RL56 Wireless"
-    }
-
-    // UI tile definitions
-    tiles(scale: 2) {
-        multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
-            tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
-                attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
-                attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-                attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.light.on", backgroundColor:"#00A0DC", nextState:"turningOff"
-                attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.light.off", backgroundColor:"#ffffff", nextState:"turningOn"
-            }
-            tileAttribute ("device.level", key: "SLIDER_CONTROL") {
-                attributeState "level", action:"switch level.setLevel"
-            }
-            tileAttribute ("colorName", key: "SECONDARY_CONTROL") {
-                attributeState "colorName", label:'${currentValue}'
-            }
-        }
-
-        standardTile("refresh", "device.refresh", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
-        }
-
-        controlTile("colorTempSliderControl", "device.colorTemperature", "slider", width: 4, height: 2, inactiveLabel: false, range:"(2700..5000)") {
-            state "colorTemperature", action:"color temperature.setColorTemperature"
-        }
-        valueTile("colorTemp", "device.colorTemperature", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
-            state "colorTemperature", label: '${currentValue} K'
-        }
-
-        main(["switch"])
-        details(["switch", "colorTempSliderControl", "colorTemp", "refresh"])
-    }
-}
-
-// Parse incoming device messages to generate events
-def parse(String description) {
-    log.debug "description is $description"
-    def event = zigbee.getEvent(description)
-    if (event) {
-        if (event.name == "colorTemperature") {
-            event.unit = "K"
-        }
-        sendEvent(event)
-    }
-    else {
-        log.warn "DID NOT PARSE MESSAGE for description : $description"
-        log.debug zigbee.parseDescriptionAsMap(description)
-    }
-}
-
-def off() {
-    zigbee.off() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def on() {
-    zigbee.on() + ["delay 1500"] + zigbee.onOffRefresh()
-}
-
-def setLevel(value) {
-    zigbee.setLevel(value) + zigbee.onOffRefresh() + zigbee.levelRefresh()
-}
-
-def refresh() {
-	def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
-
-	// Do NOT config if the device is the Eaton Halo_LT01, it responds with "switch:off" to onOffConfig, and maybe other weird things with the others
-    if (!((device.getDataValue("manufacturer") == "Eaton") && (device.getDataValue("model") == "Halo_LT01"))) {
-        cmds = cmds + zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig()
-    }
-    
-	cmds
-}
-
-def poll() {
-    zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
-}
-
-/**
- * PING is used by Device-Watch in attempt to reach the Device
- * */
-def ping() {
-    return zigbee.levelRefresh()
-}
-
-def healthPoll() {
-    log.debug "healthPoll()"
-    def cmds = zigbee.onOffRefresh() + zigbee.levelRefresh()
-    cmds.each{ sendHubCommand(new physicalgraph.device.HubAction(it))}
-}
-
-def configureHealthCheck() {
-    Integer hcIntervalMinutes = 12
-    if (!hasConfiguredHealthCheck) {
-        log.debug "Configuring Health Check, Reporting"
-        unschedule("healthPoll")
-        runEvery5Minutes("healthPoll")
-        // Device-Watch allows 2 check-in misses from device
-        sendEvent(name: "checkInterval", value: hcIntervalMinutes * 60, displayed: false, data: [protocol: "zigbee", hubHardwareId: device.hub.hardwareID])
-        hasConfiguredHealthCheck = true
-    }
-}
-
-def configure() {
-    log.debug "configure()"
-    configureHealthCheck()
-    // Implementation note: for the Eaton Halo_LT01, it responds with "switch:off" to onOffConfig, so be sure this is before the call to onOffRefresh
-    zigbee.onOffConfig() + zigbee.levelConfig() + zigbee.colorTemperatureConfig() + zigbee.onOffRefresh() + zigbee.levelRefresh() + zigbee.colorTemperatureRefresh()
-}
-
-def updated() {
-    log.debug "updated()"
-    configureHealthCheck()
-}
-
-def setColorTemperature(value) {
-    setGenericName(value)
-    zigbee.setColorTemperature(value) + ["delay 1500"] + zigbee.colorTemperatureRefresh()
-}
-
-//Naming based on the wiki article here: http://en.wikipedia.org/wiki/Color_temperature
-def setGenericName(value){
-    if (value != null) {
-        def genericName = ""
-        if (value < 3300) {
-            genericName = "Soft White"
-        } else if (value < 4150) {
-            genericName = "Moonlight"
-        } else if (value <= 5000) {
-            genericName = "Cool White"
-        } else {
-            genericName = "Daylight"
-        }
-        sendEvent(name: "colorName", value: genericName, displayed: false)
-    }
-}
--- a/smartapps/gideon-api/gideon-smart-home.src/gideon-smart-home.groovy
+++ b/smartapps/gideon-api/gideon-smart-home.src/gideon-smart-home.groovy
@@ -1,794 +0,0 @@
-/**
- *  Gideon
- *
- *  Copyright 2016 Nicola Russo
- *
- *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
- *  in compliance with the License. You may obtain a copy of the License at:
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
- *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
- *  for the specific language governing permissions and limitations under the License.
- *
- */
-definition(
-    name: "Gideon Smart Home",
-    namespace: "gideon.api",
-    author: "Braindrain Solutions ltd",
-    description: "Gideon Smart Home SmartApp allows you to connect and control all of your SmartThings devices through the Gideon app, making your SmartThings devices even smarter.",
-    category: "Family",
-    iconUrl: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    iconX2Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    iconX3Url: "http://s33.postimg.org/t77u7y7v3/logo.png",
-    oauth: [displayName: "Gideon Smart Home API app", displayLink: "gideon.ai"])
-
-preferences {
-	section("Control these contact sensors...") {
-        input "contact", "capability.contactSensor", multiple:true, required:false
-    }
-    section("Control these switch levels...") {
-        input "switchlevels", "capability.switchLevel", multiple:true, required:false
-    }
-/*    section("Control these thermostats...") {
-        input "thermostats", "capability.thermostat", multiple:true, required:false
-    }*/
-    section("Control the color for these devices...") {
-        input "colors", "capability.colorControl", multiple:true, required:false
-    }
-    section("Control the color temperature for these devices...") {
-        input "kelvin", "capability.colorTemperature", multiple:true, required:false
-    }
-	section("Control these switches...") {
-        input "switches", "capability.switch", multiple:true, required:false
-    }
-    section("Control these smoke alarms...") {
-        input "smoke_alarms", "capability.smokeDetector", multiple:true, required:false
-    }
-    section("Control these window shades...") {
-        input "shades", "capability.windowShade", multiple:true, required:false
-    }
-    section("Control these garage doors...") {
-        input "garage", "capability.garageDoorControl", multiple:true, required:false
-    }
-    section("Control these water sensors...") {
-        input "water_sensors", "capability.waterSensor", multiple:true, required:false
-    }
-    section("Control these motion sensors...") {
-        input "motions", "capability.motionSensor", multiple:true, required:false
-    }
-    section("Control these presence sensors...") {
-    	input "presence_sensors", "capability.presenceSensor", multiple:true, required:false
-    }
-	section("Control these outlets...") {
-    	input "outlets", "capability.outlet", multiple:true, required:false
-    }
-    section("Control these power meters...") {
-        input "meters", "capability.powerMeter", multiple:true, required:false
-    }
-    section("Control these locks...") {
-    	input "locks", "capability.lock", multiple:true, required:false
-    }
-    section("Control these temperature sensors...") {
-	    input "temperature_sensors", "capability.temperatureMeasurement", multiple:true, required:false
-    }
-    section("Control these batteries...") {
-	    input "batteries", "capability.battery", multiple:true, required:false
-    }
-}
-
-def installed() {
-	log.debug "Installed with settings: ${settings}"
-
-	initialize()
-}
-
-def updated() {
-	log.debug "Updated with settings: ${settings}"
-
-	unsubscribe()
-	initialize()
-}
-
-def initialize() {
-}
-
-private device(it, type) {
-	it ? [id: it.id, label: it.label, type: type] : null
-}
-
-//API Mapping
-mappings {
-   path("/getalldevices") {
-    action: [
-      	GET: "getAllDevices"
-   ]
-  }
-  /*
-  path("/thermostat/setcool/:id/:temp") {
-    action: [
-      GET: "setCoolTemp"
-    ]
-  }
-  path("/thermostat/setheat/:id/:temp") {
-    action: [
-      GET: "setHeatTemp"
-    ]
-  }
-  path("/thermostat/setfanmode/:id/:mode") {
-    action: [
-      GET: "setFanMode"
-    ]
-  }
-  path("/thermostat/setmode/:id/:mode") {
-    action: [
-      GET: "setThermostatMode"
-    ]
-  }
-  path("/thermostat/:id") {
-    action: [
-      GET: "getThermostatStatus"
-    ]
-  }
-  */
-  path("/light/dim/:id/:dim") {
-    action: [
-      GET: "setLevelStatus"
-    ]
-  }
-  path("/light/kelvin/:id/:kelvin") {
-    action: [
-      GET: "setKelvin"
-    ]
-  }
-  path("/colorlight/:id/:hue/:sat") {
-    action: [
-      GET: "setColor"
-    ]
-  }
-  path("/light/status/:id") {
-    action: [
-      GET: "getLightStatus"
-    ]
-  }
-  path("/light/on/:id") {
-    action: [
-      GET: "turnOnLight"
-    ]
-  }
-  path("/light/off/:id") {
-    action: [
-      GET: "turnOffLight"
-    ]
-  }
-  path("/doorlocks/lock/:id") {
-    action: [
-      GET: "lockDoorLock"
-    ]
-  }
-  path("/doorlocks/unlock/:id") {
-    action: [
-      GET: "unlockDoorLock"
-    ]
-  }
-  path("/doorlocks/:id") {
-    action: [
-      GET: "getDoorLockStatus"
-    ]
-  }
-  path("/contacts/:id") {
-    action: [
-  	GET: "getContactStatus"
-    ]
-  }
-  path("/smoke/:id") {
-    action: [
-   	GET: "getSmokeStatus"
-	]
-  }
-    path("/shades/open/:id") {
-    action: [
-      GET: "openShade"
-    ]
-  }
-  path("/shades/preset/:id") {
-    action: [
-      GET: "presetShade"
-    ]
-  }
-  path("/shades/close/:id") {
-    action: [
-      GET: "closeShade"
-    ]
-  }
-  	path("/shades/:id") {
-    action: [
-	GET: "getShadeStatus"
-	]
-}
-    path("/garage/open/:id") {
-    action: [
-      GET: "openGarage"
-    ]
-  }
-  path("/garage/close/:id") {
-    action: [
-      GET: "closeGarage"
-    ]
-  }
-  	path("/garage/:id") {
-    action: [
-  		GET: "getGarageStatus"
-  	]
-  }
-    path("/watersensors/:id") {
-    action: [
-      		GET: "getWaterSensorStatus"
-    	]
-  }
-  	path("/tempsensors/:id") {
-    action: [
-      GET: "getTempSensorsStatus"
-    ]
-  }
-  path("/meters/:id") {
-    action: [
-      GET: "getMeterStatus"
-    ]
-  }
-  path("/batteries/:id") {
-    action: [
-      GET: "getBatteryStatus"
-    ]
-  }
-  	path("/presences/:id") {
-    action: [
-      GET: "getPresenceStatus"
-    ]
-  }
-  	path("/motions/:id") {
-    action: [
-      GET: "getMotionStatus"
-    ]
-  }
-  	path("/outlets/:id") {
-    action: [
-      GET: "getOutletStatus"
-    ]
-  }
-  	path("/outlets/turnon/:id") {
-    action: [
-      GET: "turnOnOutlet"
-    ]
-  }
-  path("/outlets/turnoff/:id") {
-    action: [
-      GET: "turnOffOutlet"
-    ]
-  }
-  path("/switches/turnon/:id") {
-    action: [
-      GET: "turnOnSwitch"
-    ]
-  }
-  path("/switches/turnoff/:id") {
-    action: [
-      GET: "turnOffSwitch"
-    ]
-  }
-  path("/switches/:id") {
-    action: [
-      GET: "getSwitchStatus"
-    ]
-  }
-}
-
-//API Methods
-def getAllDevices() {
-    def locks_list = locks.collect{device(it,"Lock")}
-    /*def thermo_list = thermostats.collect{device(it,"Thermostat")}*/
-    def colors_list = colors.collect{device(it,"Color")}
-    def kelvin_list = kelvin.collect{device(it,"Kelvin")}
-    def contact_list = contact.collect{device(it,"Contact Sensor")}
-    def smokes_list = smoke_alarms.collect{device(it,"Smoke Alarm")}
-    def shades_list = shades.collect{device(it,"Window Shade")}
-    def garage_list = garage.collect{device(it,"Garage Door")}
-    def water_sensors_list = water_sensors.collect{device(it,"Water Sensor")}
-    def presences_list = presence_sensors.collect{device(it,"Presence")}
-    def motions_list = motions.collect{device(it,"Motion")}
-	def outlets_list = outlets.collect{device(it,"Outlet")}
-    def switches_list = switches.collect{device(it,"Switch")}
-    def switchlevels_list = switchlevels.collect{device(it,"Switch Level")}
-    def temp_list = temperature_sensors.collect{device(it,"Temperature")}
-    def meters_list = meters.collect{device(it,"Power Meters")}
-    def battery_list = batteries.collect{device(it,"Batteries")}
-    return outlets_list + kelvin_list + colors_list + switchlevels_list + smokes_list + contact_list + water_sensors_list + shades_list + garage_list + locks_list + presences_list + motions_list + switches_list + temp_list + meters_list + battery_list
-}
-
-//thermostat
-/*
-def setCoolTemp() {
-	def device = thermostats.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            if(device.hasCommand("setCoolingSetpoint")) {
-            	device.setCoolingSetpoint(params.temp.toInteger());
-                return [result_action: "200"]
-            }
-            else {
-            	httpError(510, "Not supported!")
-            }
-       }
-}
-def setHeatTemp() {
-	def device = thermostats.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            if(device.hasCommand("setHeatingSetpoint")) {
-            	device.setHeatingSetpoint(params.temp.toInteger());
-                return [result_action: "200"]
-            }
-            else {
-            	httpError(510, "Not supported!")
-            }
-       }
-}
-def setFanMode() {
-	def device = thermostats.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        if(device.hasCommand("setThermostatFanMode")) {
-            	device.setThermostatFanMode(params.mode);
-                return [result_action: "200"]
-            }
-            else {
-            	httpError(510, "Not supported!")
-            }
-       }
-}
-def setThermostatMode() {
-	def device = thermostats.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        if(device.hasCommand("setThermostatMode")) {
-            	device.setThermostatMode(params.mode);
-                return [result_action: "200"]
-            }
-            else {
-            	httpError(510, "Not supported!")
-            }
-       }
-}
-def getThermostatStatus() {
-	def device = thermostats.find{ it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [ThermostatOperatingState: device.currentValue('thermostatOperatingState'), ThermostatSetpoint: device.currentValue('thermostatSetpoint'), 
-            			ThermostatFanMode: device.currentValue('thermostatFanMode'), ThermostatMode: device.currentValue('thermostatMode')]
-       	}
-}
-*/
-//light
-def turnOnLight() {
-    def device = switches.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            device.on();
-                  
-            return [Device_id: params.id, result_action: "200"]
-        }
-    }
-
-def turnOffLight() {
-    def device = switches.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            device.off();
-                  
-            return [Device_id: params.id, result_action: "200"]
-        }
-}
-
-def getLightStatus() {
-	def device = switches.find{ it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Status: device.currentValue('switch'), Dim: getLevelStatus(params.id), Color: getColorStatus(params.id), Kelvin: getKelvinStatus(params.id)]
-        }
-}
-
-//color control
-def setColor() {
-    def device = colors.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	
-            def map = [hue:params.hue.toInteger(), saturation:params.sat.toInteger()]
-            
-            device.setColor(map);
-                  
-            return [Device_id: params.id, result_action: "200"]
-    }
-}
-
-def getColorStatus(id) {
-	def device = colors.find { it.id == id }
-    if (!device) {
-            return [Color: "none"]
-        } else {
-        	return [hue: device.currentValue('hue'), saturation: device.currentValue('saturation')]
-        }
-}
-
-//kelvin control
-def setKelvin() {
-    def device = kelvin.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        
-            device.setColorTemperature(params.kelvin.toInteger());
-                  
-            return [Device_id: params.id, result_action: "200"]
-    }
-}
-
-def getKelvinStatus(id) {
-	def device = kelvin.find { it.id == id }
-    if (!device) {
-            return [kelvin: "none"]
-        } else {
-        	return [kelvin: device.currentValue('colorTemperature')]
-        }
-}
-
-//switch level
-def getLevelStatus() {
-	def device = switchlevels.find { it.id == params.id }
-    if (!device) {
-            [Level: "No dimmer"]
-        } else {
-        	return [Level: device.currentValue('level')]
-        }
-}
-
-def getLevelStatus(id) {
-	def device = switchlevels.find { it.id == id }
-    if (!device) {
-            [Level: "No dimmer"]
-        } else {
-        	return [Level: device.currentValue('level')]
-        }
-}
-
-
-def setLevelStatus() {
-	def device = switchlevels.find { it.id == params.id }
-    def level = params.dim
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	device.setLevel(level.toInteger())
-        	return [result_action: "200", Level: device.currentValue('level')]
-        }
-}
-
-
-//contact sensors
-def getContactStatus() {
-	def device = contact.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	def args = getTempSensorsStatus(device.id)
-        	return [Device_state: device.currentValue('contact')] + args
-        }
-}
-
-//smoke detectors
-def getSmokeStatus() {
-	def device = smoke_alarms.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        def bat = getBatteryStatus(device.id)
-        	return [Device_state: device.currentValue('smoke')] + bat
-        }
-}
-
-//garage
-def getGarageStatus() {
-	def device = garage.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('door')]
-        }
-}
-
-def openGarage() {
-    def device = garage.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.open();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-
-def closeGarage() {
-	def device = garage.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.close();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-//shades
-def getShadeStatus() {
-	def device = shades.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('windowShade')]
-        }
-}
-
-def openShade() {
-    def device = shades.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.open();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-    
-def presetShade() {
-    def device = shades.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.presetPosition();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-
-def closeShade() {
-	def device = shades.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.close();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-
-//water sensor
-def getWaterSensorStatus() {
-	def device = water_sensors.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	def bat = getBatteryStatus(device.id)
-        	return [Device_state: device.currentValue('water')] + bat
-        }
-}
-//batteries
-def getBatteryStatus() {
-	def device = batteries.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.latestValue("battery")]
-        }
-}
-
-def getBatteryStatus(id) {
-	def device = batteries.find { it.id == id }
-    if (!device) {
-            return []
-        } else {
-        	return [battery_state: device.latestValue("battery")]
-        }
-}
-
-//LOCKS
-def getDoorLockStatus() {
-	def device = locks.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	def bat = getBatteryStatus(device.id)
-        	return [Device_state: device.currentValue('lock')] + bat
-        }
-}
-
-def lockDoorLock() {
-    def device = locks.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.lock();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-
-def unlockDoorLock() {
-	def device = locks.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.unlock();
-                  
-            return [Device_id: params.id, result_action: "200"]                              
-            }
-    }
-//PRESENCE
-def getPresenceStatus() {
-
-	def device = presence_sensors.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        def bat = getBatteryStatus(device.id)
-        	return [Device_state: device.currentValue('presence')] + bat
-   }
-}
-
-//MOTION
-def getMotionStatus() {
-
-	def device = motions.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	def args = getTempSensorsStatus(device.id)
-        	return [Device_state: device.currentValue('motion')] + args
-   }
-}
-
-//OUTLET
-def getOutletStatus() {
-
-    def device = outlets.find { it.id == params.id }
-    if (!device) {
-            device = switches.find { it.id == params.id }
-            if(!device) {
-            	httpError(404, "Device not found")
-        	}
-     }
-     def watt = getMeterStatus(device.id)
-       	
-     return [Device_state: device.currentValue('switch')] + watt
-}
-
-def getMeterStatus() {
-
-    def device = meters.find { it.id == params.id }
-   	if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_id: device.id, Device_type: device.type, Current_watt: device.currentValue("power")]
-  }
-}
-
-def getMeterStatus(id) {
-
-    def device = meters.find { it.id == id }
-   	if (!device) {
-            return []
-        } else {
-        	return [Current_watt: device.currentValue("power")]
-  }
-}
-
-
-def turnOnOutlet() {
-    def device = outlets.find { it.id == params.id }
-    if (!device) {
-            device = switches.find { it.id == params.id }
-            if(!device) {
-            	httpError(404, "Device not found")
-        	}
-     }
-     
-     device.on();
-                  
-     return [Device_id: params.id, result_action: "200"]
-}
-
-def turnOffOutlet() {
-    def device = outlets.find { it.id == params.id }
-    if (!device) {
-            device = switches.find { it.id == params.id }
-            if(!device) {
-            	httpError(404, "Device not found")
-        	}
-     }
-            
-     device.off();
-                  
-     return [Device_id: params.id, result_action: "200"]
-}
-
-//SWITCH
-def getSwitchStatus() {
-	def device = switches.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	return [Device_state: device.currentValue('switch'), Dim: getLevelStatus(params.id)]
-	}
-}
-
-def turnOnSwitch() {
-    def device = switches.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.on();
-                  
-            return [Device_id: params.id, result_action: "200"]
-        }
-}
-
-def turnOffSwitch() {
-    def device = switches.find { it.id == params.id }
-        if (!device) {
-            httpError(404, "Device not found")
-        } else {
-            
-            device.off();
-                  
-            return [Device_id: params.id, result_action: "200"]
-        }
-}
-
-
-//TEMPERATURE
-def getTempSensorsStatus() {
-    def device = temperature_sensors.find { it.id == params.id }
-    if (!device) {
-            httpError(404, "Device not found")
-        } else {
-        	def bat = getBatteryStatus(device.id)
-            def scale = [Scale: location.temperatureScale]
-        	return [Device_state: device.currentValue('temperature')] + scale + bat
-   }
-}
-
-def getTempSensorsStatus(id) {	
-    def device = temperature_sensors.find { it.id == id }
-    if (!device) {
-            return []
-        } else {
-        	def bat = getBatteryStatus(device.id)
-        	return [temperature: device.currentValue('temperature')] + bat
-   		}
-   }
--- a/smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy
+++ b/smartapps/opent2t/opent2t-smartapp-test.src/opent2t-smartapp-test.groovy
@@ -39,7 +39,7 @@ definition(
 *  garageDoors         | door          | open, close           | unknown, closed, open, closing, opening
 *  cameras             | image         | take                  | <String>
 *  thermostats         | thermostat    | setHeatingSetpoint,   | temperature, heatingSetpoint, coolingSetpoint,
- *	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
+ * 	                    |				| setCoolingSetpoint,   | thermostatSetpoint, thermostatMode,
 *                      |				| off, heat, cool, auto,| thermostatFanMode, thermostatOperatingState
 *                      |				| emergencyHeat,        |
 *                      |				| setThermostatMode,    |
@@ -55,7 +55,7 @@ preferences {
 		input "contactSensors", "capability.contactSensor", title: "Which Contact Sensors", multiple: true, required: false
 		input "garageDoors", "capability.garageDoorControl", title: "Which Garage Doors?", multiple: true, required: false
 		input "locks", "capability.lock", title: "Which Locks?", multiple: true, required: false
-		input "cameras", "capability.videoCapture", title: "Which Cameras?",  multiple: true, required: false
+		input "cameras", "capability.videoCapture", title: "Which Cameras?", multiple: true, required: false
 		input "motionSensors", "capability.motionSensor", title: "Which Motion Sensors?", multiple: true, required: false
 		input "presenceSensors", "capability.presenceSensor", title: "Which Presence Sensors", multiple: true, required: false
 		input "switches", "capability.switch", title: "Which Switches and Lights?", multiple: true, required: false
@@ -66,48 +66,54 @@ preferences {

 def getInputs() {
 	def inputList = []
-	inputList += contactSensors?: []
-	inputList += garageDoors?: []
-	inputList += locks?: []
-	inputList += cameras?: []
-	inputList += motionSensors?: []
-	inputList += presenceSensors?: []
-	inputList += switches?: []
-	inputList += thermostats?: []
-	inputList += waterSensors?: []
+	inputList += contactSensors ?: []
+	inputList += garageDoors ?: []
+	inputList += locks ?: []
+	inputList += cameras ?: []
+	inputList += motionSensors ?: []
+	inputList += presenceSensors ?: []
+	inputList += switches ?: []
+	inputList += thermostats ?: []
+	inputList += waterSensors ?: []
 	return inputList
 }

 //API external Endpoints
 mappings {
 	path("/subscriptionURL/:url") {
-		action: [
+		action:
+		[
 				PUT: "updateEndpointURL"
 		]
 	}
 	path("/connectionId/:connId") {
-		action: [
+		action:
+		[
 				PUT: "updateConnectionId"
 		]
 	}
 	path("/devices") {
-		action: [
+		action:
+		[
 				GET: "getDevices"
 		]
 	}
 	path("/devices/:id") {
-		action: [
+		action:
+		[
 				GET: "getDevice"
 		]
 	}
 	path("/update/:id") {
-		action: [
+		action:
+		[
 				PUT: "updateDevice"
 		]
 	}
 	path("/subscription/:id") {
-		action: [
-				POST: "registerDeviceChange",
+		action:
+		[
+				POST  : "registerDeviceChange",
 				DELETE: "unregisterDeviceChange"
 		]
 	}
@@ -139,7 +145,7 @@ def registerSubscriptions() {
 def registerChangeHandler(myList) {
 	myList.each { myDevice ->
 		def theAtts = myDevice.supportedAttributes
-		theAtts.each {att ->
+		theAtts.each { att ->
 			subscribe(myDevice, att.name, eventHandler)
 			log.info "Registering ${myDevice.displayName}.${att.name}"
 		}
@@ -151,7 +157,7 @@ def registerDeviceChange() {
 	def myDevice = findDevice(params.id)
 	def theAtts = myDevice.supportedAttributes
 	try {
-		theAtts.each {att ->
+		theAtts.each { att ->
 			subscribe(myDevice, att.name, eventHandler)
 			log.info "Registering ${myDevice.displayName}.${att.name}"
 		}
@@ -180,20 +186,16 @@ def eventHandler(evt) {
 	def evt_name = evt.name
 	def evt_device = evt.device
 	def evt_deviceType = getDeviceType(evt_device);
-	def deviceInfo
-
-	if(evt_deviceType == "thermostat")
-	{
-		deviceInfo = [name: evt_device.displayName, id: evt_device.id, status:evt_device.getStatus(), deviceType:evt_deviceType, manufacturer:evt_device.getManufacturerName(), model:evt_device.getModelName(), attributes: deviceAttributeList(evt_device), locationMode: getLocationModeInfo()]
-	}
-	else
-	{
-		deviceInfo = [name: evt_device.displayName, id: evt_device.id, status:evt_device.getStatus(), deviceType:evt_deviceType, manufacturer:evt_device.getManufacturerName(), model:evt_device.getModelName(), attributes: deviceAttributeList(evt_device)]
-	}
-
 	def params = [
-			uri: "${state.endpointURL}/${state.connectionId}",
-			body: [ deviceInfo ]
+			uri : "${state.endpointURL}/${state.connectionId}",
+			body: [
+					name        : evt_device.displayName,
+					id          : evt_device.id,
+					deviceType  : evt_deviceType,
+					manufacturer: evt_device.getManufacturerName(),
+					model       : evt_device.getModelName(),
+					attributes  : deviceAttributeList(evt_device)
+			]
 	]
 	try {
 		log.trace "POST URI: ${params.uri}"
@@ -228,13 +230,10 @@ def getDevices() {
 	def deviceData = []
 	inputs?.each {
 		def deviceType = getDeviceType(it)
-		if(deviceType == "thermostat")
-		{
-			deviceData << [name: it.displayName, id: it.id, status:it.getStatus(), deviceType:deviceType, manufacturer:it.getManufacturerName(), model:it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
-		}
-		else
-		{
-			deviceData << [name: it.displayName, id: it.id, status:it.getStatus(), deviceType:deviceType, manufacturer:it.getManufacturerName(), model:it.getModelName(), attributes: deviceAttributeList(it)]
+		if (deviceType == "thermostat") {
+			deviceData << [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
+		} else {
+			deviceData << [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it)]
 		}
 	}

@@ -247,13 +246,10 @@ def getDevice() {
 	def it = findDevice(params.id)
 	def deviceType = getDeviceType(it)
 	def device
-	if(deviceType == "thermostat")
-	{
-		device = [name: it.displayName, id: it.id, status:it.getStatus(), deviceType:deviceType, manufacturer:it.getManufacturerName(), model:it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
-	}
-	else
-	{
-		device = [name: it.displayName, id: it.id, status:it.getStatus(), deviceType:deviceType, manufacturer:it.getManufacturerName(), model:it.getModelName(), attributes: deviceAttributeList(it)]
+	if (deviceType == "thermostat") {
+		device = [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it), locationMode: getLocationModeInfo()]
+	} else {
+		device = [name: it.displayName, id: it.id, deviceType: deviceType, manufacturer: it.getManufacturerName(), model: it.getModelName(), attributes: deviceAttributeList(it)]
 	}
 	log.debug "getDevice, return: ${device}"
 	return device
@@ -265,18 +261,18 @@ void updateDevice() {
 	request.JSON.each {
 		def command = it.key
 		def value = it.value
-		if (command){
+		if (command) {
 			def commandList = mapDeviceCommands(command, value)
 			command = commandList[0]
 			value = commandList[1]

 			if (command == "setAwayMode") {
 				log.info "Setting away mode to ${value}"
-				if (location.modes?.find {it.name == value}) {
+				if (location.modes?.find { it.name == value }) {
 					location.setMode(value)
 				}
-			}else if (command == "thermostatSetpoint"){
-				switch(device.currentThermostatMode){
+			} else if (command == "thermostatSetpoint") {
+				switch (device.currentThermostatMode) {
 					case "cool":
 						log.info "Update: ${device.displayName}, [${command}, ${value}]"
 						device.setCoolingSetpoint(value)
@@ -290,7 +286,7 @@ void updateDevice() {
 						httpError(501, "this mode: ${device.currentThermostatMode} does not allow changing thermostat setpoint.")
 						break
 				}
-			}else if (!device) {
+			} else if (!device) {
 				log.error "updateDevice, Device not found"
 				httpError(404, "Device not found")
 			} else if (!device.hasCommand(command)) {
@@ -300,11 +296,11 @@ void updateDevice() {
 				if (command == "setColor") {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(hex: value)
-				} else if(value.isNumber()) {
+				} else if (value.isNumber()) {
 					def intValue = value as Integer
 					log.info "Update: ${device.displayName}, [${command}, ${intValue}(int)]"
 					device."$command"(intValue)
-				} else if (value){
+				} else if (value) {
 					log.info "Update: ${device.displayName}, [${command}, ${value}]"
 					device."$command"(value)
 				} else {
@@ -326,28 +322,19 @@ private getLocationModeInfo() {
 //Map each device to a type given it's capabilities
 private getDeviceType(device) {
 	def deviceType
-	def capabilities = device.capabilities
-	log.debug "capabilities: [${device}, ${capabilities}]"
+	def caps = device.capabilities
+	log.debug "capabilities: [${device}, ${caps}]"
 	log.debug "supported commands: [${device}, ${device.supportedCommands}]"
-
-	//Loop through the device capability list to determine the device type.
-	capabilities.each {capability ->
-		switch(capability.name.toLowerCase())
-		{
+	caps.each {
+		switch (it.name.toLowerCase()) {
 			case "switch":
 				deviceType = "switch"
-
-				//If the device also contains "Switch Level" capability, identify it as a "light" device.
-				if (capabilities.any{it.name.toLowerCase() == "switch level"}){
-
-					//If the device also contains "Power Meter" capability, identify it as a "dimmerSwitch" device.
-					if (capabilities.any{it.name.toLowerCase() == "power meter"}){
-						deviceType = "dimmerSwitch"
-						return deviceType
-					} else {
-						deviceType = "light"
-						return deviceType
-					}
+				if (caps.any { it.name.toLowerCase() == "power meter" }) {
+					return deviceType
+				}
+				if (caps.any { it.name.toLowerCase() == "switch level" }) {
+					deviceType = "light"
+					return deviceType
 				}
 				break
 			case "contact sensor":
@@ -388,16 +375,16 @@ private findDevice(deviceId) {

 //Return a list of device attributes
 private deviceAttributeList(device) {
-	device.supportedAttributes.collectEntries { attribute->
+	device.supportedAttributes.collectEntries { attribute ->
 		try {
-			[ (attribute.name): device.currentValue(attribute.name) ]
-		} catch(e) {
-			[ (attribute.name): null ]
+			[(attribute.name): device.currentValue(attribute.name)]
+		} catch (e) {
+			[(attribute.name): null]
 		}
 	}
 }

-//Map device command and value. 
+//Map device command and value.
 //input command and value are from UWP,
 //returns resultCommand and resultValue that corresponds with function and value in SmartApps
 private mapDeviceCommands(command, value) {
@@ -427,7 +414,7 @@ private mapDeviceCommands(command, value) {
 			resultCommand = "setSaturation"
 			resultValue = value
 			break
-		case "colorTemperature":
+		case "ct":
 			resultCommand = "setColorTemperature"
 			resultValue = value
 			break
@@ -464,8 +451,7 @@ private mapDeviceCommands(command, value) {
 			if (value == 1 || value == "1" || value == "lock") {
 				resultCommand = "lock"
 				resultValue = ""
-			}
-			else if (value == 0 || value == "0" || value == "unlock") {
+			} else if (value == 0 || value == "0" || value == "unlock") {
 				resultCommand = "unlock"
 				resultValue = ""
 			}
@@ -474,5 +460,6 @@ private mapDeviceCommands(command, value) {
 			break
 	}

-	return [resultCommand,resultValue]
+	return [resultCommand, resultValue]
 }
+
--- a/smartapps/redloro-smartthings/yamaha-receiver.src/yamaha-receiver.groovy
+++ b/smartapps/redloro-smartthings/yamaha-receiver.src/yamaha-receiver.groovy
@@ -0,0 +1,154 @@
+/**
+ *  SmartThings SmartApp: Yamaha Network Receiver
+ *
+ *  Author: redloro@gmail.com
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ *  in compliance with the License. You may obtain a copy of the License at:
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
+ *  for the specific language governing permissions and limitations under the License.
+ *
+ *  https://github.com/PSeitz/yamaha-nodejs
+ *  http://<RECEIVER_IP_ADDRESS>/YamahaRemoteControl/desc.xml
+ */
+import groovy.util.XmlSlurper
+
+definition(
+  name: "Yamaha Receiver",
+  namespace: "redloro-smartthings",
+  author: "redloro@gmail.com",
+  description: "Yamaha SmartApp",
+  category: "My Apps",
+  iconUrl: "https://raw.githubusercontent.com/redloro/smartthings/master/images/yamaha-receiver.png",
+  iconX2Url: "https://raw.githubusercontent.com/redloro/smartthings/master/images/yamaha-receiver.png",
+  iconX3Url: "https://raw.githubusercontent.com/redloro/smartthings/master/images/yamaha-receiver.png"
+)
+
+preferences {
+  section("SmartThings Hub") {
+    input "hostHub", "hub", title: "Select Hub", multiple: false, required: true
+  }
+  section("Yamaha Receiver") {
+    input name: "receiverName", type: "text", title: "Name", required: true, defaultValue: "Yamaha"
+    input name: "receiverIp", type: "text", title: "IP", required: true
+    input name: "receiverZones", type: "enum", title: "Zones", required: true, multiple: true, options: ["Main_Zone","Zone_B","Zone_2","Zone_3","Zone_4"]
+  }
+}
+
+def installed() {
+  subscribeToEvents()
+}
+
+def subscribeToEvents() {
+  subscribe(location, null, lanResponseHandler, [filterEvents:false])
+}
+
+def updated() {
+  addChildDevices()
+}
+
+def uninstalled() {
+  removeChildDevices()
+}
+
+def lanResponseHandler(evt) {
+  def map = stringToMap(evt.stringValue)
+
+  //verify that this message is from Yamaha Receiver IP
+  if (!map.ip || map.ip != convertIPtoHex(settings.receiverIp)) {
+    return
+  }
+
+  def headers = getHttpHeaders(map.headers);
+  def body = getHttpBody(map.body);
+  //log.trace "Headers: ${headers}"
+  //log.trace "Body: ${body}"
+
+  updateZoneDevices(body.children()[0])
+}
+
+private updateZoneDevices(evt) {
+  //log.debug "updateZoneDevices: ${evt.toString()}"
+  if (evt.name() == "System") {
+    //log.debug "Update all zones"
+    childDevices*.zone(evt)
+    return
+  }
+
+  def zonedevice = getChildDevice(getDeviceId(evt.name()))
+  if (zonedevice) {
+    zonedevice.zone(evt)
+  }
+
+  //check for Zone_B
+  zonedevice = getChildDevice(getDeviceId("Zone_B"))
+  if (zonedevice && evt.name() == "Main_Zone") {
+    zonedevice.zone(evt)
+  }
+}
+
+private addChildDevices() {
+  // add yamaha device
+  settings.receiverZones.each {
+    def deviceId = getDeviceId(it)
+    if (!getChildDevice(deviceId)) {
+      addChildDevice("redloro-smartthings", "Yamaha Zone", deviceId, hostHub.id, ["name": it, label: "${settings.receiverName}: ${it}", completedSetup: true])
+      log.debug "Added Yamaha zone: ${deviceId}"
+    }
+  }
+
+  childDevices*.refresh()
+}
+
+private removeChildDevices() {
+  getAllChildDevices().each { deleteChildDevice(it.deviceNetworkId) }
+}
+
+private sendCommand(body) {
+  //log.debug "Yamaha Network Receiver send command: ${body}"
+
+  def hubAction = new physicalgraph.device.HubAction(
+      headers: [HOST: getReceiverAddress()],
+      method: "POST",
+      path: "/YamahaRemoteControl/ctrl",
+      body: body
+  )
+  sendHubCommand(hubAction)
+}
+
+private getHttpHeaders(headers) {
+  def obj = [:]
+  new String(headers.decodeBase64()).split("\r\n").each {param ->
+    def nameAndValue = param.split(":")
+    obj[nameAndValue[0]] = (nameAndValue.length == 1) ? "" : nameAndValue[1].trim()
+  }
+  return obj
+}
+
+private getHttpBody(body) {
+  def obj = null;
+  if (body) {
+    obj = new XmlSlurper().parseText(new String(body.decodeBase64()))
+  }
+  return obj
+}
+
+private getDeviceId(zone) {
+  return "yamaha|${settings.receiverIp}|${zone}"
+}
+
+private getReceiverAddress() {
+  return settings.receiverIp + ":80"
+}
+
+private String convertIPtoHex(ipAddress) {
+  return ipAddress.tokenize( '.' ).collect {  String.format( '%02x', it.toInteger() ) }.join().toUpperCase()
+}
+
+private String convertPortToHex(port) {
+  return port.toString().format( '%04x', port.toInteger() ).toUpperCase()
+}