Remotec Z-Thermostat (configuration with Z-Wave Commands)

Dennis,
I had no idea (and still very little now even) about association groups either. I found it in the ZTS’s owners manual:


I figured that is why my thermostats weren’t registering the auto reports. I read somewhere in the Smartthings support docs that the hub auto associates to group 1 so this helped me identify the problem. I’m glad you didn’t have this problem and not sure why yours just worked.

Yes, I just added the association command to the configure function and put a button in there to execute it as well as the config parameters I wanted to set. I thought about expanding on your configuration code for all the other thermostat settings but I have concluded that I probably won’t be changing any of the settings again and if I need to I’ll just go into the device code and put it in the config section again.

I too know very little about Smartthings as I have only had my Hub since Christmas and its my first dive into home automation. I feel like I’m fumbling around in the dark but have managed to get most of my stuff working. I’m with you regarding taking the time to learn more about this stuff. As long as I can get my stuff to work for the most part, I’m happy. The community forums have been a big help to me.

Here is the code for the Device Handler with the buttons (The sliders are way too sensitive for me). Got it from another user on these forums and changed a few things related to the configuration I mentioned above. Hope this helps:

/* Better-Thermostat.device.groovy
 *
 * Variation of the stock SmartThings "Zwave-Thermostat"
 *
 * Device type removes the sliders and replaces them with incremental
 * up and down buttons on each side of the heating and cooling setpoints.
 *
 * To use you must have IDE access on your acount. Add a new device
 * type and add the custom commands:
 * 		heatLevelUp
 *		heatLevelDown
 * 		coolLevelUp
 *		coolLevelDown
 *		switchMode
 *		switchFanMode
 * Replace the starter code with this code and save the file. Go into
 * "My devices" and select the thermostat you want to change. Select "Edit"
 * and then change the "Type" to use this device type.
 *
 * Happy Hacking!
 *
 * twack@wackware.net
 * 20140209
 *
*/
metadata {
	// Automatically generated. Make future change here.
	definition (name: "ZTS-110 Z-Wave Thermostat (Tim)", author: "twack@wackware.net + Tim") {
		capability "Temperature Measurement"
		capability "Refresh"
		capability "Thermostat"
		capability "Configuration"
		capability "Polling"

		command "heatLevelUp"
		command "heatLevelDown"
		command "coolLevelUp"
		command "coolLevelDown"
		command "switchMode"
		command "switchFanMode"
        //fingerprint deviceId: "0x1001"
		//fingerprint inClusters: "0x25,0x27,0x86,0x72", manufacturer: "Remotec", model: "ZTS-110"
	}

	// 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 "fanAuto"		: "command: 4403, payload: 00"
		status "fanOn"			: "command: 4403, payload: 01"
		status "fanCirculate"	: "command: 4403, payload: 06"

		status "heat 60"        : "command: 4303, payload: 01 01 3C"
		status "heat 68"        : "command: 4303, payload: 01 01 44"
		status "heat 72"        : "command: 4303, payload: 01 01 48"

		status "cool 72"        : "command: 4303, payload: 02 01 48"
		status "cool 76"        : "command: 4303, payload: 02 01 4C"
		status "cool 80"        : "command: 4303, payload: 02 01 50"

		status "temp 58"        : "command: 3105, payload: 01 22 02 44"
		status "temp 62"        : "command: 3105, payload: 01 22 02 6C"
		status "temp 70"        : "command: 3105, payload: 01 22 02 BC"
		status "temp 74"        : "command: 3105, payload: 01 22 02 E4"
		status "temp 78"        : "command: 3105, payload: 01 22 03 0C"
		status "temp 82"        : "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}°', 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"]
				]
			)
		}
		standardTile("mode", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
			state "off", label:'', action:"switchMode", icon:"st.thermostat.heating-cooling-off"
			state "heat", label:'', action:"switchMode", icon:"st.thermostat.heat"
			state "cool", label:'', action:"switchMode", icon:"st.thermostat.cool"
			state "auto", label:'', action:"switchMode", icon:"st.thermostat.auto"
		}
		standardTile("fanMode", "device.thermostatFanMode", inactiveLabel: false, decoration: "flat") {
			state "fanAuto", label:'', action:"switchFanMode", icon:"st.thermostat.fan-auto"
			state "fanOn", label:'', action:"switchFanMode", icon:"st.thermostat.fan-on"
			state "fanCirculate", label:'  ', action:"switchFanMode", icon:"st.thermostat.fan-circulate"
		}
		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("refresh", "device.thermostatMode", inactiveLabel: false, decoration: "flat") {
			state "default", action:"polling.poll", icon:"st.secondary.refresh"
		}
        standardTile("heatLevelUp", "device.heatingSetpoint", canChangeIcon: false, inactiveLabel: false, decoration: "flat") {
                        state "heatLevelUp", label:'  ', action:"heatLevelUp", icon:"st.thermostat.thermostat-up"
        }
        standardTile("heatLevelDown", "device.heatingSetpoint", canChangeIcon: false, inactiveLabel: false, decoration: "flat") {
                        state "heatLevelDown", label:'  ', action:"heatLevelDown", icon:"st.thermostat.thermostat-down"
        }
        standardTile("coolLevelUp", "device.heatingSetpoint", canChangeIcon: false, inactiveLabel: false, decoration: "flat") {
                        state "coolLevelUp", label:'  ', action:"coolLevelUp", icon:"st.thermostat.thermostat-up"
        }
        standardTile("coolLevelDown", "device.heatingSetpoint", canChangeIcon: false, inactiveLabel: false, decoration: "flat") {
                        state "coolLevelDown", label:'  ', action:"coolLevelDown", icon:"st.thermostat.thermostat-down"
        }
        standardTile("configure", "device.configure", inactiveLabel: false, decoration: "flat") {
						state "configure", label:'', action:"configuration.configure", icon:"st.secondary.configure"
		}
        main "temperature"
		details(["temperature", "mode", "fanMode", "heatLevelDown", "heatingSetpoint", "heatLevelUp", "coolLevelDown", "coolingSetpoint", "coolLevelUp", "refresh", "configure"])
	}

}


def coolLevelUp(){
    int nextLevel = device.currentValue("coolingSetpoint") + 1
    
    if( nextLevel > 99){
    	nextLevel = 99
    }
    log.debug "Setting cool set point up to: ${nextLevel}"
    setCoolingSetpoint(nextLevel)
}

def coolLevelDown(){
    int nextLevel = device.currentValue("coolingSetpoint") - 1
    
    if( nextLevel < 50){
    	nextLevel = 50
    }
    log.debug "Setting cool set point down to: ${nextLevel}"
    setCoolingSetpoint(nextLevel)
}

def heatLevelUp(){
    int nextLevel = device.currentValue("heatingSetpoint") + 1
    
    if( nextLevel > 90){
    	nextLevel = 90
    }
    log.debug "Setting heat set point up to: ${nextLevel}"
    setHeatingSetpoint(nextLevel)
}

def heatLevelDown(){
	int nextLevel = device.currentValue("heatingSetpoint") - 1
    
    if( nextLevel < 40){
    	nextLevel = 40
    }
    log.debug "Setting heat set point down to: ${nextLevel}"
    setHeatingSetpoint(nextLevel)
}

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

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

// Event Generation
def zwaveEvent(physicalgraph.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd)
{
	def map = [:]
	map.value = cmd.scaledValue.toString()
	map.unit = cmd.scale == 1 ? "F" : "C"
	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 = [:]
	map.value = cmd.scaledSensorValue.toString()
	map.unit = cmd.scale == 1 ? "F" : "C"
	map.name = "temperature"
	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_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.cool) { supportedModes += "cool " }
	if(cmd.auto) { supportedModes += "auto " }

	updateState("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 " }

	updateState("supportedFanModes", supportedFanModes)
}

def updateState(String name, String value) {
	state[name] = value
	device.updateDataValue(name, value)
}

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()
        
        /* Config Polling ****Add comma to previous line****
        zwave.configurationV1.configurationGet(parameterNumber: 1).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 2).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 3).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 4).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 5).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 14).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 6).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 7).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 8).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 9).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 10).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 11).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 12).format(),
        zwave.configurationV1.configurationGet(parameterNumber: 13).format()
        */
        
	], 2300)
}

def setHeatingSetpoint(degreesF) {
	setHeatingSetpoint(degreesF.toDouble())
}

def setHeatingSetpoint(Double degreesF) {
	def p = (state.precision == null) ? 1 : state.precision
	delayBetween([
		zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 1, scale: 1, precision: p, scaledValue: degreesF).format(),
		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 1).format()
	])
}

def setCoolingSetpoint(degreesF) {
	setCoolingSetpoint(degreesF.toDouble())
}

def setCoolingSetpoint(Double degreesF) {
	def p = (state.precision == null) ? 1 : state.precision
	delayBetween([
		zwave.thermostatSetpointV1.thermostatSetpointSet(setpointType: 2, scale: 1, precision: p,  scaledValue: degreesF).format(),
		zwave.thermostatSetpointV1.thermostatSetpointGet(setpointType: 2).format()
	])
}

def configure() {
	
    delayBetween([

		zwave.thermostatModeV2.thermostatModeSupportedGet().format(),
		zwave.thermostatFanModeV3.thermostatFanModeSupportedGet().format(),
		zwave.associationV1.associationSet(groupingIdentifier:1, nodeId:[zwaveHubNodeId]).format(),
        zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format(),
        //Tim Code Start ***Don't forget comma on previous line
        zwave.configurationV1.configurationSet(parameterNumber: 1, size: 1, scaledConfigurationValue: 1).format()
        //zwave.configurationV1.configurationSet(parameterNumber: 11, size: 1, scaledConfigurationValue: 1).format(),
        //zwave.configurationV1.configurationSet(parameterNumber: 13, size: 1, scaledConfigurationValue: 0).format()
        //Tim Code End*/
	], 2300)
    
}


def modes() {
	["off", "auto", "heat", "cool"]
}

def switchMode() {
	def currentMode = device.currentState("thermostatMode")?.value
	def lastTriedMode = getDataByName("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)
		}
	}
    log.debug "Switching to mode: ${nextMode}"
	switchToMode(nextMode)
}

def switchToMode(nextMode) {
	def supportedModes = getDataByName("supportedModes")
	if(supportedModes && !supportedModes.contains(nextMode)) log.warn "thermostat mode '$nextMode' is not supported"
	if (nextMode in modes()) {
		updateState("lastTriedMode", nextMode)
		return "$nextMode"()
	} else {
		log.debug("no mode method '$nextMode'")
	}
}

def switchFanMode() {
	def currentMode = device.currentState("thermostatFanMode")?.value
	def lastTriedMode = getDataByName("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) updateState("lastTriedFanMode", nextMode)
	returnCommand
}

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

def getModeMap() { [
	"off": 0,
	"heat": 1,
	"cool": 2,
	"emergency heat": 4
]}

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

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

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

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

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

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

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

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

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

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

PS I am also using the SmartTiles smartapp to control most of my devices including the thermostats, everything is on one page instead of going into the smartthings app and navigating around to my thermostats, lights etc.

One other smartapp recommendation I would make is to install rule machine (here). I use it to automate almost everything now.

How often does the ZTS-110 report for you guys that have it? It seems mine is not reporting at all even when set to 1 hour or 4 degree temp change. My device is battery powered.

Also, what are the parameters for swing and differential. Is it .5 increments or 1 degree increments? Actual manual says .5 degree, but online manual shows 1 degree.

https://suretydiy.com/wp-content/uploads/IQ-Thermostat-User-Installation-Manual.pdf

Mine is on ac power - not battery and the auto report modes work as advertised if you configure it correctly. I am not familiar with battery powered setup but that may have something to do with your issue. Look through the manual for FLiRS mode. I could not find anything in the manual but perhaps?? it never auto reports in FLiRS mode?

Regarding temp change the settings are for degrees F. Setting = 0x01 => 1.0 F = .5 C (Centigrade) Perhaps that is the confusion?

1 Like

Thank for your response. Does anyone else use this thermostat on battery?

The manual states that even in FLiRS mode, the setup and operations are the same. Maybe I’ll try and reset it and see if it still does not update regularly.

Hi Mclovin50,

I had the same issue you are having with my thermostat not reporting. See my posts above regarding association groups. I don’t really understand them thoroughly, but apparently the thermostat reports only on association group 3 but the smartthings hub only associates with group 1. So I had to send a configure command to the thermostat to get it to report on association group 1 instead. Here is the command that I used in the device profile to change the setting. Once I sent that it started reporting as it should.

“zwave.associationV2.associationSet(groupingIdentifier:3, nodeId:[zwaveHubNodeId]).format()”

For some reason Dennis didn’t need to do this and his just worked but I had the same issue you are having and this solved it for me. Hope this helps.

Tim

1 Like

Thank you thank you. That did the trick. Im now getting more updates.

Tim, Is your thermostat running on battery? If so That might explain why I never had to do the association set.

No, mine is running on AC, don’t even have batteries in it.

I’ve also got two of them and had to associate both.

Do either of you guys get battery updates every 30 minutes?

Don’t know. Mine aren’t running on batteries. I do get temperature updates every 30 minutes though as long as the temperature changed by at least half a degree.

1 Like

Need little assistance. How can I call the association report to find what the thermostat is currently set to? Does below look right?

zwave.associationV2.associationGet(groupingIdentifier:2, nodeId:[zwaveHubNodeId]).format()

def zwaveEvent(physicalgraph.zwave.commands.associationv2.AssociationReport cmd) {

log.debug $cmd

}

Sorry, can’t help you with that one. I have not used association.

Earlier in 2017, SmartThings made sweeping updates to the zwave stack and Z-Wave Thermostat Device Handler. In doing so, my ZTS-110 stopped working well.

I finally had time over the past couple of days to do some debugging and research. My ZTS-110 has some poor z-wave reporting behavior, especially when it comes to reporting it’s supported thermostat modes. I’ve fixed this in my custom device handler.

I found this thread and decided to pull @dspanogle’s battery & configuration parameter code into my device handler. I added support for the Swing and Differential parameters, which I had to customize, as the device defaults are not to my liking.

Finally, I confirmed that deleting the hub from association group 1 and adding the hub to association group 3 ensured changes done via buttons on the thermostat (mode, fan mode, set points, etc) were immediately reflected in the app. Associations are corrected in the device handler.

If you are using a ZTS-110, feel free to pick up this device handler here: https://github.com/cjisndenial/SmartThingsPublic/tree/master/devicetypes/cjisndeial/remotec-zts-110-thermostat.src

Hey. I have two of these same thermostats and found your post after trying to figure out how to get them into ST. Unfortunately, the github link Doesn’t resolve. Do you still have the device handler and if so, please could you make it available again? I’m a noob with this stuff. Thank you!

I have attached the device handler I currently use. It is not perfect but works for what I need

This is excellent thank you. I sort of had it working but now my thermostat has gone into degrees F vs degrees C confusion :slight_smile: I am in the UK . I tried to set the scale from F to C but the thermostat is responding in F and i am trying to set it in C , hence it never switches on as the temperatures are too low. Is there a hex value to set the scale i.e. to C not F ? thanks

It was too long ago when I did my driver mods so my memory is not so good.

Just as a guess (Not sure) may have to add to the configuration part of the driver.

set parameter 5 (0x05)

Scale of temperature:

value 0x00 = degrees C Set it to 0x00 in the configuration section of the driver

value 0x01 = degrees F (default) Since this is the default you have to program it for degrees C

Hey thanks a lot Dennis , I’ll have a play around with that. Much appreciated :slight_smile: and post back if I can get it to work in Centigrade . :grin: