Can't use the Thermostat 'sliders' very well

[saltH20]

I did a search but most of the posts were from a few years ago.

My issue is I have I bought a CT100 with the hopes of controlling it via the ST app. I lock the thermostat’s controls to keep the family from messing with the temperature too much, and the app allows me to adjust via the phone. Trouble is the tiny sliders are so hard to use, my fingers have a slight shake sometimes and I only need to set it a few degrees here or there and it’s beyond frustrating. Most of the time when I let up on the screen the temperature jumps another 2 degrees because it’s so sensitive and tiny.

Can we get hittable + and - buttons for those of us who can’t use the slider…for when we need to change just a few degrees? Preferably on the screen because I didn’t even realize there was a “refresh” “humidity” and “battery” until just today (I have a galaxy S5).

[mattjfrank (Matt)]

WiFi or ZWave?

For Wifi there is this

statusbits/smartthings

I think there there is one for zwave too but I’m not seeing it right now

[daven]

There is custom Wifi/CT30/Honeywell device code out there that has nice up/down buttons; I use it. Search for “Better Thermostat” or CT30

[allison]

This is one of many complaints that we’ve had for a long time. I’m amazed that it still hasn’t been fixed.

[ero4444 (Eric)]

CT100 is Zwave battery power. So Wifi/CT30 is probly not an option.

Really better not to touch the app (go put on a sweater), but you could make 1 or more routines to set the preferred setpoint in one shot.

[daven]

Don’t know if this helps but here’s the code for the Honeywell Zwave with no sliders. Not sure where the link is so here it comes in nasty text form.

metadata {
// Automatically generated. Make future change here.
definition (name: “CT30+”, namespace: “smartthings”, author: “SmartThings”) {
capability "Actuator"
capability "Temperature Measurement"
capability "Relative Humidity Measurement"
capability "Thermostat"
capability "Configuration"
capability "Polling"
capability "Sensor"
capability “Refresh”

	command "refresh"
	command "switchMode"
	command "switchFanMode"
    command "quickSetCool"
    command "quickSetHeat"
    command "heatLevelUp"
	command "heatLevelDown"
	command "coolLevelUp"
	command "coolLevelDown"

	fingerprint deviceId: "0x08"
	fingerprint inClusters: "0x43,0x40,0x44,0x31"
}

// simulator metadata
simulator {
	status "off"			: "command: 4003, payload: 00"
	status "heat"			: "command: 4003, payload: 01"
	status "cool"			: "command: 4003, payload: 02"
	status "auto"			: "command: 4003, payload: 03"
	status "emergencyHeat"	: "command: 4003, payload: 04"

	status "fanAuto"		: "command: 4403, payload: 00"
	status "fanOn"			: "command: 4403, payload: 01"
	status "fanCirculate"	: "command: 4403, payload: 06"

	status "heat 15.5"        : "command: 4303, payload: 01 01 3C"
	status "heat 20"        : "command: 4303, payload: 01 01 44"
	status "heat 22"        : "command: 4303, payload: 01 01 48"

	status "cool 22"        : "command: 4303, payload: 02 01 48"
	status "cool 24"        : "command: 4303, payload: 02 01 4C"
	status "cool 26.5"        : "command: 4303, payload: 02 01 50"

	status "temp 14.5"        : "command: 3105, payload: 01 22 02 44"
	status "temp 16.5"        : "command: 3105, payload: 01 22 02 6C"
	status "temp 21"        : "command: 3105, payload: 01 22 02 BC"
	status "temp 23"        : "command: 3105, payload: 01 22 02 E4"
	status "temp 25.5"        : "command: 3105, payload: 01 22 03 0C"
	status "temp 27.5"        : "command: 3105, payload: 01 22 03 34"

	status "idle"			: "command: 4203, payload: 00"
	status "heating"		: "command: 4203, payload: 01"
	status "cooling"		: "command: 4203, payload: 02"
	status "fan only"		: "command: 4203, payload: 03"
	status "pending heat"	: "command: 4203, payload: 04"
	status "pending cool"	: "command: 4203, payload: 05"
	status "vent economizer": "command: 4203, payload: 06"

	// reply messages
	reply "2502": "command: 2503, payload: FF"
}

tiles {
	valueTile("temperature", "device.temperature", width: 2, height: 2) {
		state("temperature", label:'${currentValue}°',
			backgroundColors:[
				[value: 0, color: "#153591"],
				[value: 6, color: "#1e9cbb"],
				[value: 15, color: "#90d2a7"],
				[value: 23, color: "#44b621"],
				[value: 28, color: "#f1d801"],
				[value: 35, color: "#d04e00"],
				[value: 36, color: "#bc2323"]
			]
		)
	}

standardTile("mode", "device.thermostatMode", inactiveLabel: false, canChangeIcon: true) {
	state "off", label:'${name}', action:"switchMode", nextState:"to_heat", icon: "st.Outdoor.outdoor19"
	state "heat", label:'${name}', action:"switchMode", nextState:"to_cool", icon: "st.Weather.weather14", backgroundColor: '#E14902'
	state "cool", label:'${name}', action:"switchMode", nextState:"...", icon: "st.Weather.weather7", backgroundColor: '#003CEC'
	state "auto", label:'${name}', action:"switchMode", nextState:"...", icon: "st.Home.home1"
	state "emergencyHeat", label:'${name}', action:"switchMode", nextState:"...", icon: "st.Weather.weather2", backgroundColor: '#E11102'
	state "to_heat", label: "heat", action:"switchMode", nextState:"to_cool"
	state "to_cool", label: "cool", action:"switchMode", nextState:"..."
	state "...", label: "...", action:"off", nextState:"off"
}
standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, canChangeIcon: true) {
	state "fanAuto", label:'${name}', action:"switchFanMode", icon: "st.Appliances.appliances11"
	state "fanOn", label:'${name}', action:"switchFanMode", icon: "st.Appliances.appliances11", backgroundColor: '#02E181'
	state "fanCirculate", label:'${name}', action:"switchFanMode", icon: "st.Appliances.appliances11", backgroundColor: '#02D2E1'
}
        
	standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
		state "fanAuto", label:'${name}', action:"switchFanMode"
		state "fanOn", label:'${name}', action:"switchFanMode"
		state "fanCirculate", label:'${name}', action:"switchFanMode"
	}

	}
	valueTile("heatingSetpoint", "device.heatingSetpoint", inactiveLabel: false, decoration: "flat") {
		state "heat", label:'${currentValue}° heat', backgroundColor:"#ffffff"
	}

	standardTile("heatLevelUp", "device.heatLevelUp", inactiveLabel: false, decoration: "flat") {
                state "heatLevelUp", label:'  ', action:"heatLevelUp", icon:"st.thermostat.thermostat-up"
}
standardTile("heatLevelDown", "device.heatLevelDown", inactiveLabel: false, decoration: "flat") {
                state "heatLevelDown", label:'  ', action:"heatLevelDown", icon:"st.thermostat.thermostat-down"
}
standardTile("coolLevelUp", "device.coolLevelUp", inactiveLabel: false, decoration: "flat") {
                state "coolLevelUp", label:'  ', action:"coolLevelUp", icon:"st.thermostat.thermostat-up"
}
standardTile("coolLevelDown", "device.coolLevelDown", inactiveLabel: false, decoration: "flat") {
                state "coolLevelDown", label:'  ', action:"coolLevelDown", icon:"st.thermostat.thermostat-down"
}
	}
	valueTile("coolingSetpoint", "device.coolingSetpoint", inactiveLabel: false, decoration: "flat") {
		state "cool", label:'${currentValue}° cool', backgroundColor:"#ffffff"
	}
	standardTile("refresh", "command.refresh", inactiveLabel: false, decoration: "flat") {
	state "default", action:"refresh.refresh", icon:"st.secondary.refresh"
}
valueTile("battery", "device.battery", inactiveLabel: false, decoration: "flat") { 
	state "battery", label:'Battery ${currentValue}%', backgroundColor:"#ffffff" 
}
valueTile("humidity", "device.humidity", inactiveLabel: false, decoration: "flat") { 
	state "humidity", label:'Humidity ${currentValue}%', backgroundColor:"#ffffff"
}

	main "temperature"
details(["temperature", "mode", "fanMode", "heatLevelDown", "heatingSetpoint", "heatLevelUp", "coolLevelDown", "coolingSetpoint", "coolLevelUp", "battery", "humidity", "refresh", "configure"]) // CUSTOMIZATION

def parse(String description)
{
def map = createEvent(zwaveEvent(zwave.parse(description, [0x42:1, 0x43:2, 0x31: 3])))
if (!map) {
return null
}

def result = [map]
if (map.isStateChange && map.name in ["heatingSetpoint","coolingSetpoint","thermostatMode"]) {
	def map2 = [
		name: "thermostatSetpoint",
		unit: getTemperatureScale()
	]
	if (map.name == "thermostatMode") {
		state.lastTriedMode = map.value
		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)
	}
} else if (map.name == "thermostatFanMode" && map.isStateChange) {
	state.lastTriedFanMode = map.value
}
log.debug "Parse returned $result"
result

}

// Event Generation
def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd)
{
def cmdScale = cmd.scale == 1 ? “F” : "C"
def map = [:]
map.value = convertTemperatureIfNeeded(cmd.scaledValue, cmdScale, cmd.precision)
map.unit = getTemperatureScale()
map.displayed = false
switch (cmd.setpointType) {
case 1:
map.name = "heatingSetpoint"
break;
case 2:
map.name = "coolingSetpoint"
break;
default:
return [:]
}
// So we can respond with same format
state.size = cmd.size
state.scale = cmd.scale
state.precision = cmd.precision
map
}

def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv3.SensorMultilevelReport cmd)
{
def map = [:]
if (cmd.sensorType == 1) {
map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmd.scale == 1 ? “F” : “C”, cmd.precision)
map.unit = getTemperatureScale()
map.name = “temperature”
} else if (cmd.sensorType == 5) {
map.value = cmd.scaledSensorValue
map.unit = "%"
map.name = “humidity”
}
map
}

def zwaveEvent(physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport cmd)
{
def map = [:]
switch (cmd.operatingState) {
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_IDLE:
map.value = "idle"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_HEATING:
map.value = "heating"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_COOLING:
map.value = "cooling"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_FAN_ONLY:
map.value = "fan only"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_PENDING_HEAT:
map.value = "pending heat"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_PENDING_COOL:
map.value = "pending cool"
break
case physicalgraph.zwave.commands.thermostatoperatingstatev1.ThermostatOperatingStateReport.OPERATING_STATE_VENT_ECONOMIZER:
map.value = "vent economizer"
break
}
map.name = "thermostatOperatingState"
map
}

def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport cmd) {
def map = [:]
switch (cmd.mode) {
case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_OFF:
map.value = "off"
break
case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_HEAT:
map.value = "heat"
break
case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_AUXILIARY_HEAT:
map.value = "emergencyHeat"
break
case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_COOL:
map.value = "cool"
break
case physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeReport.MODE_AUTO:
map.value = "auto"
break
}
map.name = "thermostatMode"
map
}

def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport cmd) {
def map = [:]
switch (cmd.fanMode) {
case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_AUTO_LOW:
map.value = "fanAuto"
break
case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_LOW:
map.value = "fanOn"
break
case physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeReport.FAN_MODE_CIRCULATION:
map.value = "fanCirculate"
break
}
map.name = "thermostatFanMode"
map.displayed = false
map
}

def zwaveEvent(physicalgraph.zwave.commands.thermostatmodev2.ThermostatModeSupportedReport cmd) {
def supportedModes = ""
if(cmd.off) { supportedModes += "off " }
if(cmd.heat) { supportedModes += "heat " }
if(cmd.auxiliaryemergencyHeat) { supportedModes += "emergencyHeat " }
if(cmd.cool) { supportedModes += "cool " }
if(cmd.auto) { supportedModes += "auto " }

state.supportedModes = supportedModes

}

def zwaveEvent(physicalgraph.zwave.commands.thermostatfanmodev3.ThermostatFanModeSupportedReport cmd) {
def supportedFanModes = ""
if(cmd.auto) { supportedFanModes += "fanAuto " }
if(cmd.low) { supportedFanModes += "fanOn " }
if(cmd.circulation) { supportedFanModes += "fanCirculate " }

state.supportedFanModes = supportedFanModes

}

def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
log.debug “Zwave event received: $cmd”
}

def zwaveEvent(physicalgraph.zwave.Command cmd) {
log.warn “Unexpected zwave command $cmd”
}

// Command Implementations
def poll() {
delayBetween([
zwave.sensorMultilevelV3.sensorMultilevelGet().format(), // current temperature
zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format(),
zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format(),
zwave.thermostatModeV2.thermostatModeGet().format(),
zwave.thermostatFanModeV3.thermostatFanModeGet().format(),
zwave.thermostatOperatingStateV1.thermostatOperatingStateGet().format(),
getBattery(), // CUSTOMIZATION
// setClock(), // CUSTOMIZATION
zwave.multiInstanceV1.multiInstanceCmdEncap(instance: 2).encapsulate(zwave.sensorMultilevelV3.sensorMultilevelGet()).format() // CT-100/101 Customization for Humidity
], 2300)
}

def quickSetHeat(degrees) {
setHeatingSetpoint(degrees, 1000)
}

def setHeatingSetpoint(degrees, delay = 30000) {
setHeatingSetpoint(degrees.toDouble(), delay)
}

def setHeatingSetpoint(Double degrees, Integer delay = 30000) {
log.trace "setHeatingSetpoint($degrees, $delay)"
def deviceScale = state.scale ?: 1
def deviceScaleString = deviceScale == 2 ? “C” : "F"
def locationScale = getTemperatureScale()
def p = (state.precision == null) ? 1 : state.precision

def convertedDegrees
if (locationScale == "C" && deviceScaleString == "F") {
	convertedDegrees = celsiusToFahrenheit(degrees)
} else if (locationScale == "F" && deviceScaleString == "C") {
	convertedDegrees = fahrenheitToCelsius(degrees)
} else {
	convertedDegrees = degrees
}

delayBetween([
	zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 1, scale: deviceScale, precision: p, scaledValue: convertedDegrees).format(),
	zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format()
], delay)

}

def quickSetCool(degrees) {
setCoolingSetpoint(degrees, 1000)
}

def setCoolingSetpoint(degrees, delay = 30000) {
setCoolingSetpoint(degrees.toDouble(), delay)
}

def setCoolingSetpoint(Double degrees, Integer delay = 30000) {
log.trace "setCoolingSetpoint($degrees, $delay)"
def deviceScale = state.scale ?: 1
def deviceScaleString = deviceScale == 2 ? “C” : "F"
def locationScale = getTemperatureScale()
def p = (state.precision == null) ? 1 : state.precision

def convertedDegrees
if (locationScale == "C" && deviceScaleString == "F") {
	convertedDegrees = celsiusToFahrenheit(degrees)
} else if (locationScale == "F" && deviceScaleString == "C") {
	convertedDegrees = fahrenheitToCelsius(degrees)
} else {
	convertedDegrees = degrees
}

delayBetween([
	zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 2, scale: deviceScale, precision: p,  scaledValue: convertedDegrees).format(),
	zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format()
], delay)

}

def configure() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSupportedGet().format(),
zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format(),
zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format()
], 2300)
}

def modes() {
[“off”, “heat”, “cool”, “auto”, “emergencyHeat”]
}

def switchMode() {
def currentMode = device.currentState(“thermostatMode”)?.value
def lastTriedMode = state.lastTriedMode ?: currentMode ?: "off"
def supportedModes = getDataByName(“supportedModes”)
def modeOrder = modes()
def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
def nextMode = next(lastTriedMode)
if (supportedModes?.contains(currentMode)) {
while (!supportedModes.contains(nextMode) && nextMode != “off”) {
nextMode = next(nextMode)
}
}
state.lastTriedMode = nextMode
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[nextMode]).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], 1000)
}

def switchToMode(nextMode) {
def supportedModes = getDataByName(“supportedModes”)
if(supportedModes && !supportedModes.contains(nextMode)) log.warn “thermostat mode ‘$nextMode’ is not supported"
if (nextMode in modes()) {
state.lastTriedMode = nextMode
”$nextMode"()
} else {
log.debug(“no mode method ‘$nextMode’”)
}
}

def switchFanMode() {
def currentMode = device.currentState(“thermostatFanMode”)?.value
def lastTriedMode = state.lastTriedFanMode ?: currentMode ?: "off"
def supportedModes = getDataByName(“supportedFanModes”) ?: "fanAuto fanOn"
def modeOrder = [“fanAuto”, “fanCirculate”, “fanOn”]
def next = { modeOrder[modeOrder.indexOf(it) + 1] ?: modeOrder[0] }
def nextMode = next(lastTriedMode)
while (!supportedModes?.contains(nextMode) && nextMode != “fanAuto”) {
nextMode = next(nextMode)
}
switchToFanMode(nextMode)
}

def switchToFanMode(nextMode) {
def supportedFanModes = getDataByName(“supportedFanModes”)
if(supportedFanModes && !supportedFanModes.contains(nextMode)) log.warn “thermostat mode ‘$nextMode’ is not supported”

def returnCommand
if (nextMode == "fanAuto") {
	returnCommand = fanAuto()
} else if (nextMode == "fanOn") {
	returnCommand = fanOn()
} else if (nextMode == "fanCirculate") {
	returnCommand = fanCirculate()
} else {
	log.debug("no fan mode '$nextMode'")
}
if(returnCommand) state.lastTriedFanMode = nextMode
returnCommand

}

def getDataByName(String name) {
state[name] ?: device.getDataValue(name)
}

def getModeMap() { [
“off”: 0,
“heat”: 1,
“cool”: 2,
“auto”: 3,
“emergency heat”: 4
]}

def setThermostatMode(String value) {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: modeMap[value]).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def getFanModeMap() { [
“auto”: 0,
“on”: 1,
“circulate”: 6
]}

def setThermostatFanMode(String value) {
delayBetween([
zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: fanModeMap[value]).format(),
zwave.thermostatFanModeV3.thermostatFanModeGet().format()
], standardDelay)
}

def off() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: 0).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def heat() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: 1).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def emergencyHeat() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: 4).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def cool() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: 2).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def auto() {
delayBetween([
zwave.thermostatModeV2.thermostatModeSet(mode: 3).format(),
zwave.thermostatModeV2.thermostatModeGet().format()
], standardDelay)
}

def fanOn() {
delayBetween([
zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 1).format(),
zwave.thermostatFanModeV3.thermostatFanModeGet().format()
], standardDelay)
}

def fanAuto() {
delayBetween([
zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 0).format(),
zwave.thermostatFanModeV3.thermostatFanModeGet().format()
], standardDelay)
}

def fanCirculate() {
delayBetween([
zwave.thermostatFanModeV3.thermostatFanModeSet(fanMode: 6).format(),
zwave.thermostatFanModeV3.thermostatFanModeGet().format()
], standardDelay)
}

private getStandardDelay() {
1000
}

def zwaveEvent(physicalgraph.zwave.commands.sensormultilevelv2.SensorMultilevelReport cmd) {
log.debug “SensorMultilevelReportV2 $cmd”

def map = [:]
if (cmd.sensorType == 1) {
	map.value = convertTemperatureIfNeeded(cmd.scaledSensorValue, cmd.scale == 1 ? "F" : "C", cmd.precision)
	map.unit = getTemperatureScale()
	map.name = "temperature"
} else if (cmd.sensorType == 5) {
	map.value = cmd.scaledSensorValue
	map.unit = "%"
	map.name = "humidity"
}
map

}

def zwaveEvent(physicalgraph.zwave.commands.multiinstancev1.MultiInstanceCmdEncap cmd) {
def encapsulatedCommand = cmd.encapsulatedCommand([0x31: 3])
log.debug (“multiinstancev1.MultiInstanceCmdEncap: command from instance ${cmd.instance}: ${encapsulatedCommand}”)
if (encapsulatedCommand) {
return zwaveEvent(encapsulatedCommand)
}
}
def zwaveEvent(physicalgraph.zwave.commands.batteryv1.BatteryReport cmd) {
def nowTime = new Date().time
state.lastBatteryGet = nowTime
def map = [ name: “battery”, unit: “%” ]
if (cmd.batteryLevel == 0xFF || cmd.batteryLevel == 0) {
map.value = 1
map.descriptionText = "battery is low!"
sendEvent(name: “BatteryLevel”, value: “battery is low!”)
} else {
map.value = cmd.batteryLevel as Integer
sendEvent(name: “BatteryLevel”, value: “battery is $cmd.batteryLevel%”)
}
map
}

private getBattery() { //once every 24 hours
def nowTime = new Date().time
def ageInMinutes = state.lastBatteryGet ? (nowTime - state.lastBatteryGet)/60000 : 1440
log.debug "Battery report age: ${ageInMinutes} minutes"
if (ageInMinutes >= 1440) {
log.debug "Fetching fresh battery value"
zwave.batteryV1.batteryGet().format()
} else “delay 87”
}

private setClock() { // once a day
def nowTime = new Date().time
def ageInMinutes = state.lastClockSet ? (nowTime - state.lastClockSet)/60000 : 1440
log.debug "Clock set age: ${ageInMinutes} minutes"
if (ageInMinutes >= 1440) {
state.lastClockSet = nowTime
def nowCal = Calendar.getInstance(location.timeZone) // get current location timezone
log.debug "Setting clock to ${nowCal.getTime().format(“EEE MMM dd yyyy HH:mm:ss z”, location.timeZone)}"
sendEvent(name: “SetClock”, value: “setting clock to ${nowCal.getTime().format(“EEE MMM dd yyyy HH:mm:ss z”, location.timeZone)}”)
zwave.clockV1.clockSet(hour: nowCal.get(Calendar.HOUR_OF_DAY), minute: nowCal.get(Calendar.MINUTE), weekday: nowCal.get(Calendar.DAY_OF_WEEK)).format()
} else “delay 87”
}

def refresh() {
// Force a refresh
log.info "Requested a refresh"
state.lastBatteryGet = (new Date().time) - (1440 * 60000)
state.lastClockSet = (new Date().time) - (1440 * 60000)
poll()
}

def coolLevelUp() {
int nextLevel = device.currentValue(“coolingSetpoint”) + 1

if( nextLevel > 35) {
	nextLevel = 35
}
log.debug "Setting cool set point up to: ${nextLevel}"
quickSetCool(nextLevel)

}

def coolLevelDown() {
int nextLevel = device.currentValue(“coolingSetpoint”) - 1

if( nextLevel < 15) {
	nextLevel = 15
}
log.debug "Setting cool set point down to: ${nextLevel}"
quickSetCool(nextLevel)

}

def heatLevelUp() {
int nextLevel = device.currentValue(“heatingSetpoint”) + 1

if( nextLevel > 25) {
	nextLevel = 25
}
log.debug "Setting heat set point up to: ${nextLevel}"
quickSetHeat(nextLevel)

}

def heatLevelDown() {
int nextLevel = device.currentValue(“heatingSetpoint”) - 1

if( nextLevel < 10) {
	nextLevel = 10
}
log.debug "Setting heat set point down to: ${nextLevel}"
quickSetHeat(nextLevel)

}

[saltH20]

Yeah it’s a zwave device as Eric said. Thank you for the routine suggestion, it’s a half-fix. I still have to go into the Thing menu to actually turn on the device, as a routine only allows the temp to be set.

I am no developer so whatever code that is won’t help me. I wonder if any of the engineers/employees at smartthings actually use the thermostat user interface in the app? It just is hard to believe they can’t make a simple update to fix the issue, especially since people have been asking for it for years.

[Lgkahn (Larry)]

How about searching for ct100 I wrote a custom device type.

My custom ct100 device type

Question If I get a CT 100 can I program it to use different temperature sensors throughout the day? I.e. Kid’s bedroom at night, kitchen in the morning etc…

[twack (Todd Wackford)]

twack/smartthings-devices/blob/master/Better-Thermostat.device.groovy

This is code for “better thermostat” device type. Not sure that it will work since I’ve never tried it with a ct100. Install the code thru the IDE and edit the devices type. It looks like this when installed. I too have trouble with sliders.

[baldeagle072 (Eric R)]

I’ve used this code with a CT100 and it works just fine

[saltH20]

Thanks Todd that worked! Some doing to get it setup but hey it has buttons!