[BETA RELEASE] Remotec ZXT-120

This is the thermostat. Split system in apartment.

1 Like

Never mind

For a long while I've been using my ZXT-120s through smartthings and hubconnect for two reasons: there was no driver in hubitat and no Alexa to hubitat thermostat communication.

Yesterday for some reason my ZXT-120s went offline in Smartthings which lead me to check the Hubitat forums to see if there were any updates.

I was excited to see that both of my issues have been mostly resolved! There's a builtin driver in hubitat that more or less works (which is why I'm replying to this thread) and I can tell alexa to control my mini splits!

There are a few things I've noticed with the driver that the Smartthings one does include.

  1. For some reason, the driver thinks I don't have an auto thermostat mode despite the mini split having one.

  2. With both Homekit and Alexa, on smartthings/hubconnect I'd say "Turn on " and it would turn on the mini split and would be set to cool. With the hubitat driver, in homekit, it switches to auto mode, which doesn't do anything because the driver doesn't think my mini split has an auto mode. In alexa, it says turning on the mini split is not supported. I did see in the driver that "on" is marked as ambiguous, but it would be nice to have it turn on to the last state.

  3. There is no option to select fan speed, just on and auto. In smartthings, you can pick low, medium, and high.

  4. There is no option to turn on/off oscillation. This one confuses me because I thought how mini splits remote work was when you send a command to it, it sends all the settings together each time you make a change. My mini split has been set to oscillate even though there doesn't seem to be a setting in the driver.

Thank you for adding support for this discontinued device! I've now gone full Hubitat!

@bcopeland

Hi,

I've been using this a lot lately, but I noticed a little bug with when setting the fan mode while the AC unit is off. When you set the fan mode, It turns on the ac unit but the device thinks it's still off. It does seem to happen in other situations but I can't pinpoint when this happens, but definitely if you switch the fan mode while off. So to turn it off you have to set it to cool then back to off.

Also is there any chance of adding a fan speed capability (fancontrol)? I tried modifying the driver, but was only able to add a fan speed switch command for low, medium, high, and auto, but nothing that can be driven through homekit. Previously I had tested a driver based on a Smartthings driver. The current state thermostat fan mode displays auto, high, medium, and low, but your driver only displays auto and on. I'm not exactly sure what On actually represents, low maybe? Feels like low.

Thank you!

Where can I learn how to use the IR learning function? when I click the learn button with "0" for OFF, the ZXT-120 does not flash twice as per the instructions

@M6TTL , would you mind share your driver code to handle fan control speed please. I would like to start from there. I will then try to adjust it for full controls and share it after.

I was a smartthings user a long time ago but the new app destroyed the classic devices handler for this device ... I switched to home assistant but always had problem with this device. I'm new yo hubitat but seems promising from what I see !

Thank you

I believe the modifications I made are commented with "Added". These came from the SmartThings code someone had created there.

I also ended up using node red to change a fan on setting to fan speed high and off to Auto.

import groovy.transform.Field

/**
 * Remotec ZXT-120
 * v0.1B
 */

metadata {
    definition (name: "Remotec ZXT-120", namespace: "djdizzyd", author: "Bryan Copeland", importUrl: "https://raw.githubusercontent.com/djdizzyd/hubitat/master/Drivers/Remotec/ZXT-120.groovy" ) {

        capability "Actuator"
        capability "Battery"
        capability "Configuration"
        capability "Refresh"
        capability "Sensor"
        capability "TemperatureMeasurement"
        capability "Thermostat"
        capability "ThermostatMode"
        capability "ThermostatFanMode"
        capability "ThermostatSetpoint"
        capability "ThermostatCoolingSetpoint"
        capability "ThermostatHeatingSetpoint"
        capability "ThermostatOperatingState"

        command "startLearning", [[name:"location",type:"ENUM", description:"location for IR code learning", constraints:["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"]]]

        // Added
        command "switchFanLow"
        command "switchFanMed"
        command "switchFanHigh"
        command "switchFanAuto"

        attribute "learningStatus", "string"

        fingerprint mfr:"5254", prod:"0100", deviceId:"8377", inClusters:"0x20,0x27,0x31,0x40,0x43,0x44,0x70,0x72,0x80,0x86", deviceJoinName: "Remotec ZXT-120"
    }
    preferences {
        configParams.each { input it.value.input }
        input "logEnable", "bool", title: "Enable debug logging", defaultValue: false
    }

}

@Field static Map CMD_CLASS_VERS=[0x86:1, 0x80:1, 0x72:1, 0x70:1, 0x44:2, 0x43:2, 0x40:2, 0x31:1]
@Field static Map learingStatusCode=[0:"Idle",1:"OK",2:"Busy",4:"Failed"]
@Field static Map THERMOSTAT_MODE=[0x00:"off",0x01:"heat",0x02:"cool",0x03:"auto",0x04:"emergency heat"]
@Field static Map SET_THERMOSTAT_MODE=["off":0x00,"heat":0x01,"cool":0x02,"auto":0x03,"emergency heat":0x04]
@Field static Map THERMOSTAT_FAN_MODE=[0x00:"auto",0x01:"on",0x02:"auto",0x03:"on"]
@Field static Map SET_THERMOSTAT_FAN_MODE=["auto":0x00,"on":0x01]
@Field static List<String> supportedThermostatFanModes=["on","auto"]
@Field static List<String> supportedThermostatModes=["off", "heat", "cool"]
@Field static Map configParams = [
        27: [input: [name: "configParam27", type: "number", title: "IR Code Number", description: "for built-in code library", defaultValue: 0], parameterSize: 2],
        28: [input: [name: "configParam28", type: "enum", title: "External IR Emitter Power", description:"", defaultValue: 0, options: [0:"Normal", (-1):"High"]], parameterSize: 1],
        32: [input: [name: "configParam32", type: "enum", title: "Surround IR Control", description:"", defaultValue: 0xFF, options: [0:"Disable", (-1):"Enabled"]], parameterSize: 1],
        33: [input: [name: "configParam33", type: "enum", title: "AC Swing Control", defaultValue: 1, options: [0:"Disabled", 1:"Auto"]], parameterSize: 1],
        37: [input: [name: "configParam37", type: "enum", title: "Temperature Offset", defaultValue: 0, options: [(-5):"-5°C", (-4):"-4°C", (-3):"-3°C", (-2):"-2°C", (-1):"-1°C",0:"0°C",1:"+1°C",2:"+2°C",3:"+3°C",4:"+4°C",5:"+5°C"]], parameterSize:1]
]
void logsOff(){
    log.warn "debug logging disabled..."
    device.updateSetting("logEnable",[value:"false",type:"bool"])
}

void configure() {
    if (!state.initialized) initializeVars()
    runIn(5, "pollDeviceData")
}

void initializeVars() {
    // first run only
    state.each{k -> v
        state.remove("$k")
    }
    sendEvent(name:"supportedThermostatModes", value: supportedThermostatModes.toString().replaceAll(/"/,""), isStateChange:true)
    sendEvent(name:"supportedThermostatFanModes", value: supportedThermostatFanModes.toString().replaceAll(/"/,""), isStateChange:true)
    state.initialized=true
    runIn(5, refresh)
}

void installed() {
    if (logEnable) log.debug "installed()..."
    initializeVars()
}

void updated() {
    log.info "updated..."
    log.warn "debug logging is: ${logEnable == true}"
    unschedule()
    if (logEnable) runIn(1800,logsOff)
    runConfigs()
}

void runConfigs() {
    List<hubitat.zwave.Command> cmds=[]
    configParams.each { param, data ->
        if (settings[data.input.name]) {
            cmds.addAll(configCmd(param, data.parameterSize, settings[data.input.name]))
        }
    }
    sendToDevice(cmds)
}

List<hubitat.zwave.Command> pollConfigs() {
    List<hubitat.zwave.Command> cmds=[]
    configParams.each { param, data ->
        if (settings[data.input.name]) {
            cmds.add(zwave.configurationV1.configurationGet(parameterNumber: param.toInteger()))
        }
    }
    return cmds
}

List<hubitat.zwave.Command> configCmd(parameterNumber, size, scaledConfigurationValue) {
    List<hubitat.zwave.Command> cmds = []
    int intval=scaledConfigurationValue.toInteger()
    if (size==1) {
        if (intval < 0) intval = 256 + intval
        cmds.add(zwave.configurationV1.configurationSet(parameterNumber: parameterNumber.toInteger(), size: size.toInteger(), configurationValue: [intval]))
    } else {
        cmds.add(zwave.configurationV1.configurationSet(parameterNumber: parameterNumber.toInteger(), size: size.toInteger(), scaledConfigurationValue: intval))
    }
    cmds.add(zwave.configurationV1.configurationGet(parameterNumber: parameterNumber.toInteger()))
    return cmds
}

void startLearning(location) {
    List<hubitat.zwave.Command> cmds=[]
    cmds.add(zwave.configurationV1.configurationSet(parameterNumber: 25, size:1, configurationValue: [location.toInteger()]))
    cmds.add(zwave.configurationV1.configurationGet(parameterNumber: 26))
}

void zwaveEvent(hubitat.zwave.commands.configurationv1.ConfigurationReport cmd) {
    int scaledValue
    cmd.configurationValue.reverse().eachWithIndex { v, index -> scaledValue=scaledValue | v << (8*index) }
    if(configParams[cmd.parameterNumber.toInteger()]) {
        Map configParam=configParams[cmd.parameterNumber.toInteger()]
        if (configParam.parameterSize==1 && configParam.input.range) {
            if (configParam.input.range.matches("-(.*)")) {
                if (scaledValue > 127) {
                    scaledValue = scaledValue - 256
                }
            }
        }
        device.updateSetting(configParam.input.name, [value: "${scaledValue}", type: configParam.input.type])
    } else {
        if (cmd.parameterNumber.toInteger()==26) {
            eventProcess(name: "learningStatus", value: learingStatusCode[cmd.configurationValue[0]])
        }
    }
}

void eventProcess(Map evt) {
    if (device.currentValue(evt.name).toString() != evt.value.toString()) {
        evt.isStateChange=true
        sendEvent(evt)
    }
}

void pollDeviceData() {
    List<hubitat.zwave.Command> cmds = []
    cmds.add(zwave.batteryV1.batteryGet())
    cmds.add(zwave.versionV1.versionGet())
    cmds.addAll(pollConfigs())
    sendToDevice(cmds)
}

void refresh() {
    List<hubitat.zwave.Command> cmds=[]
    cmds.add(zwave.batteryV1.batteryGet())
    cmds.add(zwave.sensorMultilevelV1.sensorMultilevelGet())
    cmds.add(zwave.thermostatFanModeV2.thermostatFanModeGet())
    cmds.add(zwave.thermostatModeV2.thermostatModeGet())
    cmds.add(zwave.thermostatSetpointV2.thermostatSetpointGet(setpointType: 1))
    cmds.add(zwave.thermostatSetpointV2.thermostatSetpointGet(setpointType: 2))
    cmds.add(zwave.configurationV1.configurationGet(parameterNumber: 26))
    sendToDevice(cmds)
}

void parse(String description) {
    if (logEnable) log.debug "parse:${description}"
    hubitat.zwave.Command cmd = zwave.parse(description, CMD_CLASS_VERS)
    if (cmd) {
        zwaveEvent(cmd)
    }
}

void zwaveEvent(hubitat.zwave.commands.versionv1.VersionReport cmd) {
    if (logEnable) log.debug "version1 report: ${cmd}"
    device.updateDataValue("firmwareVersion", "${cmd.applicationVersion}.${cmd.applicationSubVersion}")
    device.updateDataValue("protocolVersion", "${cmd.zWaveProtocolVersion}.${cmd.zWaveProtocolSubVersion}")
}

void sendToDevice(List<hubitat.zwave.Command> cmds) {
    sendHubCommand(new hubitat.device.HubMultiAction(commands(cmds), hubitat.device.Protocol.ZWAVE))
}

void sendToDevice(hubitat.zwave.Command cmd) {
    sendHubCommand(new hubitat.device.HubAction(cmd.format(), hubitat.device.Protocol.ZWAVE))
}

void sendToDevice(String cmd) {
    sendHubCommand(new hubitat.device.HubAction(cmd.format(), hubitat.device.Protocol.ZWAVE))
}

List<String> commands(List<hubitat.zwave.Command> cmds, Long delay=200) {
    return delayBetween(cmds.collect{ it.format() }, delay)
}

void zwaveEvent(hubitat.zwave.Command cmd) {
    if (logEnable) log.debug "skip:${cmd}"
}

void zwaveEvent(hubitat.zwave.commands.batteryv1.BatteryReport cmd) {
    if (logEnable) log.debug "got battery report: ${cmd.batteryLevel}"
    Map evt = [name: "battery", unit: "%"]
    if (cmd.batteryLevel == 0xFF) {
        evt.descriptionText = "${device.displayName} has a low battery"
        evt.value = "1"
    } else {
        evt.descriptionText = "${device.displayName} battery is ${cmd.batteryLevel}%"
        evt.value = "${cmd.batteryLevel}"
    }
    if (txtEnable) log.info evt.descriptionText
    eventProcess(evt)
}

void zwaveEvent(hubitat.zwave.commands.sensormultilevelv1.SensorMultilevelReport cmd) {
    if (cmd.sensorType.toInteger() == 1) {
        String scale = cmd.scale == 1 ? "F" : "C"
        BigDecimal sensorValue=0
        if (logEnable) log.debug "got temp: ${cmd.scaledSensorValue}"
        if (scale==getTemperatureScale()) {
            sensorValue=cmd.scaledSensorValue
        } else if (scale=="C" && getTemperatureScale()=="F") {
            sensorValue=celsiusToFahrenheit(cmd.scaledSensorValue)
        } else if (scale=="F" && getTemperatureScale()=="C") {
            sensorValue=fahrenheitToCelsius(cmd.scaledSensorValue)
        }
        eventProcess(name: "temperature", value: sensorValue, unit: getTemperatureScale())
    }
}

void setpointCalc(String newmode, String unit, value) {
    String mode="cool"
    if (device.currentValue("thermostatMode")=="heat" || device.currentValue("thermostatMode")=="emergency heat") {
        state.lastMode="heat"
        mode="heat"
    } else if (device.currentValue("thermostatMode")=="cool") {
        state.lastMode="cool"
        mode="cool"
    } else if (state.lastMode) {
        mode=state.lastMode
    }
    if (newmode==mode) {
        eventProcess(name: "thermostatSetpoint", value: value, unit: unit, type: state.isDigital?"digital":"physical")
    }
}

void zwaveEvent(hubitat.zwave.commands.thermostatsetpointv2.ThermostatSetpointReport cmd) {
    if (logEnable) log.debug "Got thermostat setpoint report: ${cmd}"
    if (device.currentValue("thermostatMode")=="heat") mode="heat"
    if (device.currentValue("thermostatMode")=="cool") mode="cool"
    String unit=cmd.scale == 1 ? "F" : "C"
    BigDecimal setpointValue
    if (unit==getTemperatureScale()) {
        setpointValue=cmd.scaledValue
    } else if (unit=="C" && getTemperatureScale()=="F") {
        setpointValue=celsiusToFahrenheit(cmd.scaledValue)
    } else if (unit=="F" && getTemperatureScale()=="C") {
        setpointValue=fahrenheitToCelsius(cmd.scaledValue)
    }
    switch (cmd.setpointType) {
        case 1:
            eventProcess(name: "heatingSetpoint", value: setpointValue, unit: getTemperatureScale(), type: state.isDigital?"digital":"physical")
            setpointCalc("heat", getTemperatureScale(), setpointValue)
            break
        case 2:
            eventProcess(name: "coolingSetpoint", value: setpointValue, unit: getTemperatureScale(), type: state.isDigital?"digital":"physical")
            setpointCalc("cool", getTemperatureScale(), setpointValue)
            break
    }
    state.isDigital=false
}

void zwaveEvent(hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeReport cmd) {
    if (logEnable) log.debug "Got thermostat fan mode report: ${cmd}"
    String newmode=THERMOSTAT_FAN_MODE[cmd.fanMode.toInteger()]
    if (logEnable) log.debug "Translated fan mode: " + newmode
    eventProcess(name: "thermostatFanMode", value: newmode, type: state.isDigital?"digital":"physical")
    state.isDigital=false
}

void zwaveEvent(hubitat.zwave.commands.thermostatmodev2.ThermostatModeReport cmd) {
    if (logEnable) log.debug "Got thermostat mode report: ${cmd}"
    String newmode=THERMOSTAT_MODE[cmd.mode.toInteger()]
    if (logEnable) log.debug "Translated thermostat mode: " + newmode
    eventProcess(name: "thermostatMode", value: newmode, type: state.isDigital?"digital":"physical")
    state.isDigital=false
}

private void setSetpoint(setPointType, value) {
    List<hubitat.zwave.Command> cmds=[]
    cmds.add(zwave.thermostatSetpointV2.thermostatSetpointSet(setpointType: setPointType, scale: getTemperatureScale()=="F" ? 1:0 , precision: 0, scaledValue: value))
    cmds.add(zwave.thermostatSetpointV2.thermostatSetpointGet(setpointType: setPointType))
    state.isDigital=true
    sendToDevice(cmds)
}

void setHeatingSetpoint(degrees) {
    if (logEnable) log.debug "setHeatingSetpoint(${degrees}) called"
    state.isDigital=true
    setSetpoint(1,degrees)
}

void setCoolingSetpoint(degrees) {
    if (logEnable) log.debug "setCoolingSetpoint(${degrees}) called"
    state.isDigital=true
    setSetpoint(2,degrees)
}

void setThermostatMode(mode) {
    if (logEnable) log.debug "setThermostatMode($mode)"
    List<hubitat.zwave.Command> cmds = []
    if (logEnable) log.debug "setting zwave thermostat mode ${SET_THERMOSTAT_MODE[mode]}"
    cmds.add(zwave.thermostatModeV2.thermostatModeSet(mode: SET_THERMOSTAT_MODE[mode]))
    cmds.add(zwave.thermostatModeV2.thermostatModeGet())
    state.isDigital=true
    sendToDevice(cmds)
}

void off() {
    state.isDigital=true
    setThermostatMode("off")
}

void on() {
    log.warn "Ambiguous use of on()"
}

void heat() {
    state.isDigital=true
    setThermostatMode("heat")
}

void emergencyHeat() {
    state.isDigital=true
    setThermostatMode("heat")
}

void cool() {
    state.isDigital=true
    setThermostatMode("cool")
}

void auto() {
    state.isDigital=true
    setThermostatMode("auto")
}

void setThermostatFanMode(mode) {
    if (logEnable) log.debug "setThermostatFanMode($mode)"
    List<hubitat.zwave.Command> cmds = []
    if (logEnable) log.debug "setting zwave thermostat fan mode ${SET_THERMOSTAT_FAN_MODE[mode]}"
    cmds.add(zwave.thermostatFanModeV2.thermostatFanModeSet(fanMode: SET_THERMOSTAT_FAN_MODE[mode]))
    cmds.add(zwave.thermostatFanModeV2.thermostatFanModeGet())
    state.isDigital=true
    sendToDevice(cmds)
}

void fanOn() {
    state.isDigital=true
    setThermostatFanMode("on")
}

void fanAuto() {
    state.isDigital=true
    setThermostatFanMode("auto")
}

void fanCirculate() {
    log.warn "fanCirculate is not supported by this device"
}

void setSchedule() {
    log.warn "setSchedule is not supported by this driver"
}


//Fan Speeds - Added

// Set Thermostat Fan Mode
// Set the device to the named fan speed
def setSpeed(String value) {

    log.debug value + " ${fanModeMap[value]}"
    delayBetween([
            // Command the device to change the fan speed
            zwave.thermostatFanModeV2.thermostatFanModeSet(fanMode: fanModeMap[value]).format(),
            // Request an update to make sure it worked
            zwave.thermostatFanModeV2.thermostatFanModeGet().format(),
            //zwave.thermostatModeV2.thermostatModeGet().format()
            //refresh()
    ])
}

def fanModes() {
    ["Auto", "Low", "Medium", "High"]
}
// fanModeMap - Link the possible fan speeds with their ZWave id numbers
def getFanModeMap() { [
        "Auto": hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeReport.FAN_MODE_AUTO_HIGH,
        "Low": hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeReport.FAN_MODE_LOW,
        "Medium": hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeReport.FAN_MODE_MEDIUM,
        "High": hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeReport.FAN_MODE_HIGH
]}

def zwaveEvent(hubitat.zwave.commands.thermostatfanmodev2.ThermostatFanModeSupportedReport cmd) {
    // Create a string with mode names for each available mode
    def supportedFanModes = ""
    if(cmd.auto) { supportedFanModes += "Auto " }
    if(cmd.low) { supportedFanModes += "Low " }
    if(cmd.medium) { supportedFanModes += "Medium " }
    if(cmd.high) { supportedFanModes += "High " }

    // Report and save available speeds
    log.debug "Supported Fan Modes: ${supportedFanModes}"
    updateState("supportedFanModes", supportedFanModes)
}


def switchFanLow() {
    log.debug "setting fan mode low"
    setSpeed("Low")
}

def switchFanMed() {
    log.debug "setting fan mode med"
    setSpeed("Medium")
}

def switchFanHigh() {
    state.isDigital=true
    log.debug "setting fan mode high"
    setSpeed("High")
}

def switchFanAuto() {
    log.debug "setting fan mode auto"
    setSpeed("Auto")
}

Hi, I am now switching to Hubitat and one of the drives that does not come original is the Romotec ZXT-120.

I see its development, and recent update date June 9.

Any reason why this drive is not RELEASED yet? Is it still in beta, and should I take any precautions? Or is it just copy this code and generate the drive in Hubitat?

Last and final question, do I add the control as a Romotec ZXT600 and then replace it with your drive, or should I create it as a Generic and then replace it with your drive?

Thanks!

@bcopeland created this driver before he was hired to work at Hubitat.

The ZXT-120 has built-in driver support now.

2 Likes

Hi

Sorry can you help me, looking at this list does not have the ZXT120:

https://docs.hubitat.com/index.php?title=List_of_Compatible_Devices

However if I search, appears in this version:

https://docs.hubitat.com/index.php?title=Release_Notes_2.2.1

Then in the add looking Remotec only has the model ZXT-600.

What should I do? Should I search or use another name?

Thanks.

You can do a manual z-wave pairing. The device will be assigned the correct driver, which is “Remotec Z-Wave-to-AC IR Extender.”

@bcopeland maybe the zxt-120 driver should include the model # like the zxt-600 does?

2 Likes

Thanks for the recommendations, it worked perfectly, I performed the process adding it as Remotec, it showed the ZXT-600, but when it recognized it, it already changed the drive to the ZXT-120.

2 Likes

I suppose you eventually figured out how to use the learning function with the HE driver?
I looked around but couldn't find any instructions, and I simply can't figure out how to use it. The obvious stuff like clicking on the learning button in the driver, has no obvious effect.
Perhaps someone else can help, please?

For future reference, I could not get this driver (I'll called it Driver 1) to issue learning commands to my ZXT-120 (reporting firmware version 1.0.2).
With this driver (Driver 2), the ZXT-120 responded to the learning command from within the driver, but there is a trick to selecting the memory slot on the device, which took me a while to figure out.

  1. With this driver selected, you first have to select the slot in the preferences sections of the driver, e.g. To learn position/slot 5 (which is for "22°C, cooling" according to the manual):

  2. Click on Save Preferences

  3. Set the A/C's remote to the temperature and mode according to the slot you are programming. (Refer to the IR Learning Mapping Table in the manual that comes with the device.) Ensure the remote is in the Off position.

  4. Back in the top section of the driver page:
    (a) select "cool" for Set Thermostat Mode (I'm not sure if this step is necessary.)
    (b) Enter "5" (or whatever slot the device should learn) for Set Learning Position and afterwards, click the Set Learning Position button.
    (c) Click on Issue Learning Command

  5. Keep an eye on the ZXT-120 - the LED in the centre of the device will flash once.

  6. Hold the A/C remote about 3 inches from the centre section of the ZXT-120 and press the On button on the remote. The ZXT-120 should blink twice.
    Position/slot 5 on the device has now been programmed.
    Follow these steps for each slot - steps 1 and 2 are especially important.

The ZXT-120 learned the commands using Driver 2, but Driver 2 would not change settings (temperatures) on the A/C while running. To change temperatures while the A/C is running (using the Set Cooling Setpoint command, I had to switch back to Driver 1.

All seem to be good now, apart from that ZXT simply refuses to learn/save slot 4 (24°C).

Hello!

I'm trying to use either this drive or the now official one (that seems to be really close to this one) and in both cases, when I set my IR code for my device (228) the drive automatically resets it a bit later to 72.

The result is the ZXT-120 receives the zWaves commands but nothing happens on the AC unit...

Anybody experienced something similar ?

Thanks !

Steve

I know this is an older thread, but it looks like a very recent Alexa or Hubitat update broke Alexa control. Modes - cooling, Heating, Off are no longer available in Alexa. Alexa just reports operating status. I created virtual switches and basic rules to actually control the mits minisplits for now. Alexa stiil reports ambient temp and allows you to control the set temps. The problem stated within the past week. The broadlink rm mini ir controler still allows modes to be chosen in Alexa for these minisplits. Anyone else have this issue?

I have also tried user created remotec drivers and they throw a json error when trying to set up rules or use the Hubitat thermostat scheduler.

On a somewhat related note is there any way to force the Hubitat driver to include the discovered fan speed modes (High, Low, Medium) it reports for the minisplits or to select dry mode?

Thanks so much.