mtan93/SmartThingsPublic
1
0
Fork 0
mirror of https://github.com/mtan93/SmartThingsPublic.git synced 2026-03-08 05:31:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
bflorian
2015-08-04 15:49:03 -07:00
commit 6ad3c4fd7a
322 changed files with 67201 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
devicetypes/capabilities/acceleration-sensor-capability.src/acceleration-sensor-capability.groovy Normal file
View File

@@ -0,0 +1,38 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Acceleration Sensor Capability", namespace: "capabilities", author: "SmartThings") {
capability "Acceleration Sensor"
}
simulator {
status "active": "acceleration:active"
status "inactive": "acceleration:inactive"
}
tiles {
standardTile("acceleration", "device.acceleration", width: 2, height: 2) {
state("inactive", label:'${name}', icon:"st.motion.acceleration.inactive", backgroundColor:"#ffffff")
state("active", label:'${name}', icon:"st.motion.acceleration.active", backgroundColor:"#53a7c0")
}
main "acceleration"
details "acceleration"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

73
devicetypes/capabilities/alarm-capability.src/alarm-capability.groovy Normal file
View File

@@ -0,0 +1,73 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Alarm Capability", namespace: "capabilities", author: "SmartThings") {
capability "Alarm"
}
simulator {
// reply messages
["strobe","siren","both","off"].each {
reply "$it": "alarm:$it"
}
}
tiles {
standardTile("alarm", "device.alarm", width: 2, height: 2) {
state "off", label:'off', action:'alarm.strobe', icon:"st.alarm.alarm.alarm", backgroundColor:"#ffffff"
state "strobe", label:'strobe!', action:'alarm.off', icon:"st.alarm.alarm.alarm", backgroundColor:"#e86d13"
state "siren", label:'siren!', action:'alarm.off', icon:"st.alarm.alarm.alarm", backgroundColor:"#e86d13"
state "both", label:'alarm!', action:'alarm.off', icon:"st.alarm.alarm.alarm", backgroundColor:"#e86d13"
}
standardTile("strobe", "device.alarm", inactiveLabel: false, decoration: "flat") {
state "off", label:'', action:"alarm.strobe", icon:"st.secondary.strobe", backgroundColor:"#cccccc"
state "siren", label:'', action:"alarm.strobe", icon:"st.secondary.strobe", backgroundColor:"#cccccc"
state "strobe", label:'', action:'alarm.strobe', icon:"st.secondary.strobe", backgroundColor:"#e86d13"
state "both", label:'', action:'alarm.strobe', icon:"st.secondary.strobe", backgroundColor:"#e86d13"
}
standardTile("siren", "device.alarm", inactiveLabel: false, decoration: "flat") {
state "off", label:'', action:"alarm.siren", icon:"st.secondary.siren", backgroundColor:"#cccccc"
state "strobe", label:'', action:"alarm.siren", icon:"st.secondary.siren", backgroundColor:"#cccccc"
state "siren", label:'', action:'alarm.siren', icon:"st.secondary.siren", backgroundColor:"#e86d13"
state "both", label:'', action:'alarm.siren', icon:"st.secondary.siren", backgroundColor:"#e86d13"
}
standardTile("off", "device.alarm", inactiveLabel: false, decoration: "flat") {
state "default", label:'', action:"alarm.off", icon:"st.secondary.off"
}
main "alarm"
details(["alarm","strobe","siren","test","off"])
}
}
def strobe() {
"strobe"
}
def siren() {
"siren"
}
def both() {
"both"
}
def off() {
"off"
}
// Parse incoming device messages to generate events
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

46
devicetypes/capabilities/button-capability.src/button-capability.groovy Normal file
View File

@@ -0,0 +1,46 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Button Capability", namespace: "capabilities", author: "SmartThings") {
capability "Button"
}
simulator {
status "button 1 pushed": "command: 2001, payload: 01"
status "button 1 held": "command: 2001, payload: 15"
status "button 2 pushed": "command: 2001, payload: 29"
status "button 2 held": "command: 2001, payload: 3D"
status "wakeup": "command: 8407, payload: "
}
tiles {
standardTile("button", "device.button", width: 2, height: 2) {
state "default", label: "", icon: "st.unknown.zwave.remote-controller", backgroundColor: "#ffffff"
}
main "button"
details "button"
}
}
def parse(String description) {
def results = []
if (description.startsWith("Err")) {
results = createEvent(descriptionText:description, displayed:true)
} else {
def cmd = zwave.parse(description, [0x2B: 1, 0x80: 1, 0x84: 1])
if(cmd) results += zwaveEvent(cmd)
if(!results) results = [ descriptionText: cmd, displayed: false ]
}
// log.debug("Parsed '$description' to $results")
return results
}

37
devicetypes/capabilities/contact-sensor-capability.src/contact-sensor-capability.groovy Normal file
View File

@@ -0,0 +1,37 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Contact Sensor Capability", namespace: "capabilities", author: "SmartThings") {
capability "Contact Sensor"
}
simulator {
status "open": "contact:open"
status "closed": "contact:closed"
}
tiles {
standardTile("contact", "device.contact", width: 2, height: 2) {
state("closed", label:'${name}', icon:"st.contact.contact.closed", backgroundColor:"#79b821")
state("open", label:'${name}', icon:"st.contact.contact.open", backgroundColor:"#ffa81e")
}
main "contact"
details "contact"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

39
devicetypes/capabilities/illuminance-measurement-capability.src/illuminance-measurement-capability.groovy Normal file
View File

@@ -0,0 +1,39 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Illuminance Measurement Capability", namespace: "capabilities", author: "SmartThings") {
capability "Illuminance Measurement"
}
simulator {
for (i in [0,5,10,15,20,30,40,50,100,200,300,400,600,800,1000]) {
status "${i} lux": "illuminance:${i}"
}
}
tiles {
valueTile("illuminance", "device.illuminance", width: 2, height: 2) {
state "luminosity", label:'${currentValue} ${unit}', unit:"lux"
}
main(["illuminance"])
details(["illuminance"])
}
}
// Parse incoming device messages to generate events
def parse(String description)
{
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

55
devicetypes/capabilities/lock-capability.src/lock-capability.groovy Normal file
View File

@@ -0,0 +1,55 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Lock Capability", namespace: "capabilities", author: "SmartThings") {
capability "Lock"
}
simulator {
status "locked": "lock:locked"
status "unlocked": "lock:unlocked"
reply "lock": "lock:locked"
reply "unlock": "lock:unlocked"
}
tiles {
standardTile("toggle", "device.lock", width: 2, height: 2) {
state "unlocked", label:'unlocked', action:"lock.lock", icon:"st.locks.lock.unlocked", backgroundColor:"#ffffff"
state "locked", label:'locked', action:"lock.unlock", icon:"st.locks.lock.locked", backgroundColor:"#79b821"
}
standardTile("lock", "device.lock", inactiveLabel: false, decoration: "flat") {
state "default", label:'lock', action:"lock.lock", icon:"st.locks.lock.locked"
}
standardTile("unlock", "device.lock", inactiveLabel: false, decoration: "flat") {
state "default", label:'unlock', action:"lock.unlock", icon:"st.locks.lock.unlocked"
}
main "toggle"
details(["toggle", "lock", "unlock", "refresh"])
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}
def lock() {
"lock"
}
def unlock() {
"unlock"
}

50
devicetypes/capabilities/momentary-capability.src/momentary-capability.groovy Normal file
View File

@@ -0,0 +1,50 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Momentary Capability", namespace: "capabilities", author: "SmartThings") {
capability "Momentary"
}
// simulator metadata
simulator {
// status messages
// none
// reply messages
reply "'on','delay 2000','off'": "switch:off"
}
// UI tile definitions
tiles {
standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff", nextState: "on"
state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
}
main "switch"
details "switch"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}
def push() {
['on','delay 2000','off']
}
def off() {
'off'
}

37
devicetypes/capabilities/motion-sensor-capability.src/motion-sensor-capability.groovy Normal file
View File

@@ -0,0 +1,37 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Motion Sensor Capability", namespace: "capabilities", author: "SmartThings") {
capability "Motion Sensor"
}
simulator {
status "active": "motion:active"
status "inactive": "motion:inactive"
}
tiles {
standardTile("motion", "device.motion", width: 2, height: 2) {
state("inactive", label:'no motion', icon:"st.motion.motion.inactive", backgroundColor:"#ffffff")
state("active", label:'motion', icon:"st.motion.motion.active", backgroundColor:"#53a7c0")
}
main "motion"
details "motion"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

37
devicetypes/capabilities/presence-sensor-capability.src/presence-sensor-capability.groovy Normal file
View File

@@ -0,0 +1,37 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Presence Sensor Capability", namespace: "capabilities", author: "SmartThings") {
capability "Presence Sensor"
}
simulator {
status "present": "presence: present"
status "not present": "presence: not present"
}
tiles {
standardTile("presence", "device.presence", width: 2, height: 2) {
state("not present", label:'not present', icon:"st.presence.tile.not-present", backgroundColor:"#ffffff")
state("present", label:'present', icon:"st.presence.tile.present", backgroundColor:"#53a7c0")
}
main "presence"
details "presence"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

39
devicetypes/capabilities/relative-humidity-measurement-capability.src/relative-humidity-measurement-capability.groovy Normal file
View File

@@ -0,0 +1,39 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Relative Humidity Measurement Capability", namespace: "capabilities", author: "SmartThings") {
capability "Relative Humidity Measurement"
}
// simulator metadata
simulator {
for (int i = 0; i <= 100; i += 10) {
status "${i}%": "humidity: ${i}"
}
}
// UI tile definitions
tiles {
valueTile("humidity", "device.humidity", width: 2, height: 2) {
state "humidity", label:'${currentValue}%', unit:""
}
}
}
// Parse incoming device messages to generate events
// Parse incoming device messages to generate events
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim(), unit:"%")
}

52
devicetypes/capabilities/switch-capability.src/switch-capability.groovy Normal file
View File

@@ -0,0 +1,52 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Switch Capability", namespace: "capabilities", author: "SmartThings") {
capability "Switch"
}
// simulator metadata
simulator {
// status messages
status "on": "switch:on"
status "off": "switch:off"
// reply messages
reply "on": "switch:on"
reply "off": "switch:off"
}
// UI tile definitions
tiles {
standardTile("switch", "device.switch", width: 2, height: 2, canChangeIcon: true) {
state "off", label: '${name}', action: "switch.on", icon: "st.switches.switch.off", backgroundColor: "#ffffff"
state "on", label: '${name}', action: "switch.off", icon: "st.switches.switch.on", backgroundColor: "#79b821"
}
main "switch"
details "switch"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}
def on() {
'on'
}
def off() {
'off'
}

80
devicetypes/capabilities/switch-level-capability.src/switch-level-capability.groovy Normal file
View File

@@ -0,0 +1,80 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Switch Level Capability", namespace: "capabilities", author: "SmartThings") {
capability "Switch Level"
}
simulator {
status "on": "switch:on"
status "off": "switch:off"
reply "on":"on"
reply "off":"off"
[5,10,25,33,50,66,75,99].each {
status "$it%": "switch:on,level:$it"
}
reply "setLevel: 0":"switch:off,level:0"
(1..99).each {
reply "setLevel: $it":"switch:on,level:$it"
}
}
tiles {
standardTile("switch", "device.switch", width: 2, height: 2) {
state "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
state "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#79b821", nextState:"turningOff"
state "turningOn", label:'${name}', icon:"st.switches.switch.on", backgroundColor:"#79b821"
state "turningOff", label:'${name}', icon:"st.switches.switch.off", backgroundColor:"#ffffff"
}
controlTile("levelSliderControl", "device.level", "slider", height: 2, width: 1, inactiveLabel: false) {
state "level", action:"setLevel"
}
standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat") {
state "default", label:"", action:"refresh", icon:"st.secondary.refresh"
}
main "switch"
details "switch", "levelSliderControl", "refresh"
}
}
def parse(String description) {
log.trace description
def pairs = description.split(",")
def result = []
pairs.each {
def pair = it.split(":")
result << createEvent(name: pair[0].trim(), value: pair[1].trim())
}
log.trace result
result
}
def on() {
'on'
}
def off() {
'off'
}
def setLevel(value) {
"setLevel: $value"
}
def refresh() {
'refresh'
}

50
devicetypes/capabilities/temperature-measurement-capability.src/temperature-measurement-capability.groovy Normal file
View File

@@ -0,0 +1,50 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Temperature Measurement Capability", namespace: "capabilities", author: "SmartThings") {
capability "Temperature Measurement"
}
// simulator metadata
simulator {
for (int i = 0; i <= 100; i += 10) {
status "${i} F": "temperature:$i"
}
}
// UI tile definitions
tiles {
valueTile("temperature", "device.temperature", width: 2, height: 2) {
state("temperature", label:'${currentValue}°', unit:"F",
backgroundColors:[
[value: 31, color: "#153591"],
[value: 44, color: "#1e9cbb"],
[value: 59, color: "#90d2a7"],
[value: 74, color: "#44b621"],
[value: 84, color: "#f1d801"],
[value: 95, color: "#d04e00"],
[value: 96, color: "#bc2323"]
]
)
}
main "temperature"
details "temperature"
}
}
// Parse incoming device messages to generate events
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim(), unit:"F")
}

181
devicetypes/capabilities/thermostat-capability.src/thermostat-capability.groovy Normal file
View File

@@ -0,0 +1,181 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Thermostat Capability", namespace: "capabilities", author: "SmartThings") {
capability "Thermostat"
}
// simulator metadata
simulator {
["on","off","heat","cool","emergency heat"].each {
status "$it": "thermostatMode:$it"
}
["on","auto","circulate"].each {
status "fan $it": "thermostatFanMode:$it"
}
[60,68,72].each {
status "heat $it": "heatingSetpoint:$it"
}
[72,76,80,85].each {
status "cool $it": "coolingSetpoint:$it"
}
[40,58,62,70,74,78,82,86].each {
status "temp $it": "temperature:$it"
}
// reply messages
//reply "2502": "command: 2503, payload: FF"
["on","off","heat","cool","emergency heat"].each {
reply "thermostatMode:$it": "thermostatMode:$it"
}
["on","auto","circulate"].each {
reply "thermostatFanMode:$it": "thermostatFanMode:$it"
}
for (n in 60..90) {
reply "heatingSetpoint:${n}": "heatingSetpoint:$n"
reply "heatingSetpoint:${n}.0": "heatingSetpoint:$n"
}
for (n in 60..90) {
reply "coolingSetpoint:${n}": "coolingSetpoint:$n"
reply "coolingSetpoint:${n}.0": "coolingSetpoint:$n"
}
}
tiles {
valueTile("temperature", "device.temperature", width: 2, height: 2) {
state("temperature", label:'${currentValue}°', unit:"F",
backgroundColors:[
[value: 31, color: "#153591"],
[value: 44, color: "#1e9cbb"],
[value: 59, color: "#90d2a7"],
[value: 74, color: "#44b621"],
[value: 84, color: "#f1d801"],
[value: 95, color: "#d04e00"],
[value: 96, color: "#bc2323"]
]
)
}
valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
state "heat", label:'${currentValue}° heat', unit: "F", backgroundColor:"#ffffff"
}
valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
state "cool", label:'${currentValue}° cool', unit:"F", backgroundColor:"#ffffff"
}
standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
state "off", label:'${name}', action:"thermostat.emergencyHeat", backgroundColor:"#ffffff"
state "emergencyHeat", label:'${name}', action:"thermostat.heat", backgroundColor:"#e86d13"
state "heat", label:'${name}', action:"thermostat.cool", backgroundColor:"#ffc000"
state "cool", label:'${name}', action:"thermostat.off", backgroundColor:"#269bd2"
}
standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
state "fanAuto", label:'${name}', action:"thermostat.fanOn", backgroundColor:"#ffffff"
state "fanOn", label:'${name}', action:"thermostat.fanCirculate", backgroundColor:"#ffffff"
state "fanCirculate", label:'${name}', action:"thermostat.fanAuto", backgroundColor:"#ffffff"
}
main "temperature"
details(["temperature", "heatingSetpoint", "coolingSetpoint", "mode", "fanMode"])
}
}
def parse(String description)
{
def pair = description.split(":")
def map = createEvent(name: pair[0].trim(), value: pair[1].trim())
def result = [map]
if (map.isStateChange && map.name in ["heatingSetpoint","coolingSetpoint","thermostatMode"]) {
def map2 = [
name: "thermostatSetpoint",
unit: "F"
]
if (map.name == "thermostatMode") {
if (map.value == "cool") {
map2.value = device.latestValue("coolingSetpoint")
log.info "THERMOSTAT, latest cooling setpoint = ${map2.value}"
}
else {
map2.value = device.latestValue("heatingSetpoint")
log.info "THERMOSTAT, latest heating setpoint = ${map2.value}"
}
}
else {
def mode = device.latestValue("thermostatMode")
log.info "THERMOSTAT, latest mode = ${mode}"
if ((map.name == "heatingSetpoint" && mode == "heat") || (map.name == "coolingSetpoint" && mode == "cool")) {
map2.value = map.value
map2.unit = map.unit
}
}
if (map2.value != null) {
log.debug "THERMOSTAT, adding setpoint event: $map"
result << createEvent(map2)
}
}
log.debug "Parse returned ${result?.descriptionText}"
result
}
def setHeatingSetpoint(Double degreesF) {
"heatingSetpoint:$degreesF"
}
def setCoolingSetpoint(Double degreesF) {
"coolingSetpoint:$degreesF"
}
def setThermostatMode(String value) {
"thermostatMode:$value"
}
def setThermostatFanMode(String value) {
"thermostatFanMode:$value"
}
def off() {
"thermostatMode:off"
}
def heat() {
"thermostatMode:heat"
}
def emergencyHeat() {
"thermostatMode:emergency heat"
}
def cool() {
"thermostatMode:cool"
}
def fanOn() {
"thermostatFanMode:on"
}
def fanAuto() {
"thermostatMode:auto"
}
def fanCirculate() {
"thermostatMode:circulate"
}
def poll() {
null
}

42
devicetypes/capabilities/three-axis-capability.src/three-axis-capability.groovy Normal file
View File

@@ -0,0 +1,42 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Three Axis Capability", namespace: "capabilities", author: "SmartThings") {
capability "Three Axis"
}
simulator {
status "x,y,z: 0,0,0": "threeAxis:0,0,0"
status "x,y,z: 1000,0,0": "threeAxis:1000,0,0"
status "x,y,z: 0,1000,0": "threeAxis:0,1000,0"
status "x,y,z: 0,0,1000": "xthreeAxis:0,0,1000"
status "x,y,z: -1000,0,0": "threeAxis:-1000,0,0"
status "x,y,z: 0,-1000,0": "threeAxis:0,-1000,0"
status "x,y,z: 0,0,-1000": "xthreeAxis:0,0,-1000"
}
tiles {
valueTile("3axis", "device.threeAxis", decoration: "flat") {
state("threeAxis", label:'${currentValue}', unit:"", backgroundColor:"#ffffff")
}
main "3axis"
details "3axis"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}

38
devicetypes/capabilities/water-sensor-capability.src/water-sensor-capability.groovy Normal file
View File

@@ -0,0 +1,38 @@
/**
* Copyright 2015 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.
*
*/
metadata {
definition (name: "Water Sensor Capability", namespace: "capabilities", author: "SmartThings") {
capability "Water Sensor"
}
simulator {
status "wet": "water:wet"
status "dry": "water:dry"
}
tiles {
standardTile("water", "device.water", width: 2, height: 2) {
state "dry", icon:"st.alarm.water.dry", backgroundColor:"#ffffff"
state "wet", icon:"st.alarm.water.wet", backgroundColor:"#53a7c0"
}
main "water"
details "water"
}
}
def parse(String description) {
def pair = description.split(":")
createEvent(name: pair[0].trim(), value: pair[1].trim())
}