Have you tried using the built-in Google Home integration app on your HE? You can expose devices to your Google Home setup. Not sure how it may treat your Dakin when linked in this way....
Yes I tried using the built in app. It works fine with my lights but will not bring in the Daikin
I use mine with a virtual switch. "A/C upstairs" off turns off the virtual switch and sets the units to fan mode, auto fan. "A/C upstairs" on turns the units back on A/C with a fan rate of 2 and cool set to 74. At night, night mode or 10pm, it changes it to 72 with a fan of 3. This is all done with rules and a virtual switch.
Good idea. I will give this a shot tomorrow when I am more awake! Thanks
This is the one I use when I turn it on, just for a reference. I use rule machine for the actions.
I have mine set on Celsius because it worked better when I had it on ST. I haven't had the guts to try and mess with it and pull it back over to Fahrenheit.
I was able to link mine to google home using the GH community integration, but it takes some trial and error to make it work.
Hi, I was able to integrate it to google home:
/**
* Daikin WiFi Split System Hubitat
* V 1.5 - 11/06/2020
*
* Copyright 2018 Ben Dews - https://bendews.com
* Contribution by RBoy Apps
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*
* Changelog:
*
* 1.0 (06/01/2018) - Initial 1.0 Release. All Temperature, Mode and Fan functions working.
* 1.1 (06/01/2018) - Allow user to change device icon.
* 1.2 (07/01/2018) - Fixed issue preventing user from setting desired temperature, added switch and temperature capabilities
* 1.3 (10/01/2018) - Added support for outside temperature value, 1 minute refresh option (not reccomended) and fixed thermostat and switch state reporting when turned off
* 1.4 (07/06/2018) - Added Fahrenheit support
* 1.4.1 (11/12/2018) - Implemented fix for B-type adapters ('Host' header case) - Big thanks to @WGentine in the SmartThings community
* 1.5 (11/06/2020) - Fixed integration with google home
*/
import groovy.transform.Field
@Field final Map DAIKIN_MODES = [
"0": "auto",
"1": "auto",
"2": "dry",
"3": "cool",
"4": "heat",
"6": "fan",
"7": "auto",
"off": "off",
]
@Field final Map DAIKIN_FAN_RATE = [
"A": "Auto",
"B": "Silence",
"3": "1",
"4": "2",
"5": "3",
"6": "4",
"7": "5"
]
@Field final Map DAIKIN_FAN_DIRECTION = [
"0": "Off",
"1": "Vertical",
"2": "Horizontal",
"3": "3D"
]
metadata {
definition (name: "Daikin WiFi Split System Hubitat", namespace: "bendews", author: "contact@bendews.com") {
capability "Thermostat"
capability "Temperature Measurement"
capability "Actuator"
//capability "Switch" //this is not compatible with google home
capability "Sensor"
capability "Refresh"
capability "Polling"
attribute "outsideTemp", "number"
attribute "targetTemp", "number"
attribute "currMode", "string"
attribute "fanAPISupport", "string"
attribute "fanRate", "string"
attribute "fanDirection", "string"
attribute "statusText", "string"
attribute "connection", "string"
command "fan"
command "dry"
command "tempUp"
command "tempDown"
command "fanRateAuto"
command "fanRateSilence"
command "fanDirectionVertical"
command "fanDirectionHorizontal"
command "setFanRate", ["number"]
command "setTemperature", ["number"]
}
preferences {
input("ipAddress", "string", title:"Daikin WiFi IP Address", required:true, displayDuringSetup:true)
input("ipPort", "string", title:"Daikin WiFi Port (default: 80)", defaultValue:80, required:true, displayDuringSetup:true)
input("refreshInterval", "enum", title: "Refresh Interval in minutes", defaultValue: "10", required:true, displayDuringSetup:true, options: ["1","5","10","15","30"])
input("displayFahrenheit", "boolean", title: "Display Fahrenheit", defaultValue: false, displayDuringSetup:true)
}
}
// Generic Private Functions -------
private getHostAddress() {
def ip = settings.ipAddress
def port = settings.ipPort
return ip + ":" + port
}
private getDNI(String ipAddress, String port){
log.debug "Generating DNI"
String ipHex = ipAddress.tokenize( '.' ).collect { String.format( '%02X', it.toInteger() ) }.join()
String portHex = String.format( '%04X', port.toInteger() )
String newDNI = ipHex + ":" + portHex
return newDNI
}
private apiGet(def apiCommand) {
log.debug "Executing hubaction on " + getHostAddress() + apiCommand
sendEvent(name: "hubactionMode", value: "local")
def hubAction = new hubitat.device.HubAction(
method: "GET",
path: apiCommand,
headers: [Host:getHostAddress()]
)
log.debug hubAction
return hubAction
}
private roundHalf(Double num){
return ((num * 2).round() / 2)
}
private convertTemp(Double temp, Boolean isFahrenheit){
log.debug "Converting ${temp}, Fahrenheit: ${isFahrenheit}"
Double convertedTemp
if (isFahrenheit) {
convertedTemp = ((temp - 32) * 5) / 9
return convertedTemp.round()
}
convertedTemp = ((temp * 9) / 5) + 32
return convertedTemp.round()
}
// -------
// Daikin Specific Private Functions -------
private parseTemp(Double temp, String method){
log.debug "${method}-ing ${temp}"
if (settings.displayFahrenheit.toBoolean()) {
switch(method) {
case "GET":
return convertTemp(temp, false)
case "SET":
return convertTemp(temp, true)
}
}
return temp
}
private parseDaikinResp(String response) {
// Convert Daikin response to Groovy Map
// Convert to JSON
def parsedResponse = response.replace("=", "\":\"").replace(",", "\",\"")
def jsonString = "{\"${parsedResponse}\"}"
// Parse JSON to Map
def results = new groovy.json.JsonSlurper().parseText(jsonString)
return results
}
private updateDaikinDevice(Boolean turnOff = false){
// "Power", either 0 or 1
def pow = "?pow=1"
// "Mode", 0, 1, 2, 3, 4, 6 or 7
def mode = "&mode=3"
// "Set Temperature", degrees in Celsius
def sTemp = "&stemp=26"
// "Fan Rate", A, B, 3, 4, 5, 6, or 7
def fRate = "&f_rate=A"
// "Fan Direction", 0, 1, 2, or 3
def fDir = "&f_dir=3"
// Current mode selected in smartthings
// If turning unit off, get current mode of unit instead of desired mode
String modeAttr = turnOff ? "currMode" : "thermostatMode"
def currentMode = device.currentState(modeAttr)?.value
// Convert textual mode (e.g "cool") to Daikin Code (e.g "3")
def currentModeKey = DAIKIN_MODES.find{ it.value == currentMode }?.key
// Current fan rate selected in smartthings
def currentfRate = device.currentState("fanRate")?.value
// Convert textual fan rate (e.g "lvl1") to Daikin Code (e.g "3")
def currentfRateKey = DAIKIN_FAN_RATE.find{ it.value == currentfRate }?.key
// Current fan direction selected in smartthings
def currentfDir = device.currentState("fanDirection")?.value
// Convert textual fan direction (e.g "3d") to Daikin Code (e.g "3")
def currentfDirKey = DAIKIN_FAN_DIRECTION.find{ it.value == currentfDir }?.key
log.debug "wing: ${currentfDirKey}"
// Get target temperature set in Smartthings
def targetTemp = parseTemp(device.currentValue("targetTemp"), "SET")
// Set power mode in HTTP call
if (turnOff) {
pow = "?pow=0"
}
if (currentModeKey.isNumber()){
// Set desired mode in HTTP call
mode = "&mode=${currentModeKey}"
}
if (targetTemp){
// Set desired Target Temperature in HTTP call
sTemp = "&stemp=${targetTemp}"
}
if (currentfRateKey){
// Set desired Fan Rate in HTTP call
fRate = "&f_rate=${currentfRateKey}"
}
if (currentfDirKey){
// Set desired Fan Direction in HTTP call
fDir = "&f_dir=${currentfDirKey}"
}
def apiCalls = [
// Send HTTP Call to update device
apiGet("/aircon/set_control_info"+pow+mode+sTemp+fRate+fDir+"&shum=0"),
// Get mode info
runIn(2, 'apiGet', [overwrite: false, data : "/aircon/get_control_info"]),
// Get temperature info
runIn(4, 'apiGet', [overwrite: false, data : "/aircon/get_sensor_info"])
]
return apiCalls
}
// -------
// Utility Functions -------
private startScheduledRefresh() {
log.debug "startScheduledRefresh()"
// Get minutes from settings
def minutes = settings.refreshInterval?.toInteger()
if (!minutes) {
log.warn "Using default refresh interval: 10"
minutes = 10
}
log.debug "Scheduling polling task for every '${minutes}' minutes"
if (minutes == 1){
runEvery1Minute(refresh)
} else {
"runEvery${minutes}Minutes"(refresh)
}
}
def setDNI(){
log.debug "Setting DNI"
String ip = settings.ipAddress
String port = settings.ipPort
String newDNI = getDNI(ip, port)
device.setDeviceNetworkId("${newDNI}")
}
def updated() {
log.debug "Updated with settings: ${settings}"
// Prevent function from running twice on save
if (!state.updated || now() >= state.updated + 5000){
// Unschedule existing tasks
unschedule()
// Set DNI
runIn(1, 'setDNI', [overwrite : false])
runIn(5, 'refresh')
// Start scheduled task
startScheduledRefresh()
}
state.updated = now()
}
def poll() {
log.debug "Executing poll(), unscheduling existing"
refresh()
}
def refresh() {
log.debug "Refreshing"
/*def apiCalls = [
sendHubCommand(apiGet("/aircon/get_sensor_info")),
sendHubCommand(delayAction(500)),
sendHubCommand(apiGet("/aircon/get_control_info"))
]
//return apiCalls*/
runIn(2, 'apiGet', [data:"/aircon/get_sensor_info"])
runIn(4, 'apiGet', [overwrite : false, data : "/aircon/get_control_info"])
}
def installed() {
log.debug "installed()"
sendEvent(name:'targetTemp', value: null, displayed:false)
sendEvent(name:'outsideTemp', value: null, displayed:false)
sendEvent(name:'currMode', value: null, displayed:false)
sendEvent(name:'fanRate', value: null, displayed:false)
sendEvent(name:'fanDirection', value: null, displayed:false)
sendEvent(name:'fanState', value: null, displayed:false)
sendEvent(name: "thermostatMode", value: "off", displayed:false, isStateChange: true)
sendEvent(name: "thermostatFanMode", value: "auto", displayed:false, isStateChange: true)
sendEvent(name: "thermostatOperatingState", value: "idle", displayed:false, isStateChange: true)
sendEvent(name: "thermostatSetpoint", value: 18, displayed:false, isStateChange: true)
sendEvent(name: "heatingSetpoint", value: 18, displayed:false, isStateChange: true)
sendEvent(name: "coolingSetpoint", value: 30, displayed:false, isStateChange: true)
sendEvent(name: "temperature", value: 20, displayed:false, isStateChange: true)
updateDataValue("lastRunningMode", "heat")
}
// -------
// Parse and Update functions
def parse(String description) {
// Parse Daikin response
def msg = parseLanMessage(description)
def body = msg.body
def daikinResp = parseDaikinResp(body)
// Debug Response
log.debug "Parsing Response: ${daikinResp}"
// Custom definitions
def events = []
def turnedOff = false
def currMode = null
def modeVal = null
def targetTempVal = null
// Define return field data we are interested in
def devicePower = daikinResp.get("pow", null)
def deviceMode = daikinResp.get("mode", null)
def deviceInsideTempSensor = daikinResp.get("htemp", null)
def deviceOutsideTempSensor = daikinResp.get("otemp", null)
def deviceTargetTemp = daikinResp.get("stemp", null)
def devicefanRate = daikinResp.get("f_rate", null)
def devicefanDirection = daikinResp.get("f_dir", null)
def deviceFanSupport = device.currentValue("fanAPISupport")
// Get power info
if (devicePower){
// log.debug "pow: ${devicePower}"
if (devicePower == "0") {
turnedOff = true
events.add(createEvent(name: "thermostatMode", value: "off"))
}
}
// Get mode info
if (deviceMode){
// log.debug "mode: ${deviceMode}"
currMode = DAIKIN_MODES.get(deviceMode.toString())
if (!turnedOff) {
modeVal = currMode
}
events.add(createEvent(name: "currMode", value: currMode))
}
// Get inside temperature sensor info
if (deviceInsideTempSensor){
// log.debug "htemp: ${deviceInsideTempSensor}"
String insideTemp = parseTemp(Double.parseDouble(deviceInsideTempSensor), "GET")
events.add(createEvent(name: "temperature", value: insideTemp))
}
// Get outside temperature sensor info
if (deviceOutsideTempSensor && deviceOutsideTempSensor != "-"){
log.debug "otemp: ${deviceOutsideTempSensor}"
String outsideTemp = parseTemp(Double.parseDouble(deviceOutsideTempSensor), "GET")
events.add(createEvent(name: "outsideTemp", value: outsideTemp))
}
// Get currently set target temperature
if (deviceTargetTemp){
// log.debug "stemp: ${deviceTargetTemp}"
// Value of "M" is for modes that don't support temperature changes, make value null
targetTempVal = deviceTargetTemp.isNumber() ? parseTemp(Double.parseDouble(deviceTargetTemp), "GET") : null
}
// Get current fan rate
if (devicefanRate){
// log.debug "f_rate: ${devicefanRate}"
events.add(createEvent(name: "fanAPISupport", value: "true", displayed: false))
events.add(createEvent(name: "fanRate", value: DAIKIN_FAN_RATE.get(devicefanRate)))
}
// Get current fan direction
if (devicefanDirection){
// log.debug "f_dir: ${devicefanDirection}"
events.add(createEvent(name: "fanDirection", value: DAIKIN_FAN_DIRECTION.get(devicefanDirection)))
}
// If device doesnt support API Fan functions
if (deviceMode && !devicefanRate){
// log.debug "Fan support: False"
events.add(createEvent(name: "fanAPISupport", value: "false", displayed: false))
}
// Update temperature and mode values if applicable (and all other values based from that)
// Add to start of returned list for faster UI feedback
if (modeVal || targetTempVal){
events.add(0, updateEvents(mode: modeVal, temperature: targetTempVal, updateDevice: false))
}
return events
}
private updateEvents(Map args){
log.debug "Executing 'updateEvents' with ${args.mode}, ${args.temperature} and ${args.updateDevice}"
// Get args with default values
def mode = args.get("mode", null)
def temperature = args.get("temperature", null)
def updateDevice = args.get("updateDevice", false)
// Daikin "Off" mode is handled as seperate attribute
// Smarthings thermostat handles "Off" as another mode
// Work around this by defining a "turnOff" boolean and set where appropiate
Boolean turnOff = false
def events = []
if (!mode){
mode = device.currentValue("thermostatMode")
} else {
events.add(sendEvent(name: "thermostatMode", value: mode))
}
if (!temperature){
temperature = device.currentValue("targetTemp")
}
switch(mode) {
case "fan":
events.add(sendEvent(name: "statusText", value: "Fan Mode", displayed: false))
events.add(sendEvent(name: "thermostatOperatingState", value: "fan only", displayed: false, isStateChange: true))
events.add(sendEvent(name: "targetTemp", value: null))
updateDataValue("lastRunningMode", "auto")
break
case "dry":
events.add(sendEvent(name: "statusText", value: "Dry Mode", displayed: false))
events.add(sendEvent(name: "thermostatOperatingState", value: "fan only", displayed: false, isStateChange: true))
events.add(sendEvent(name: "targetTemp", value: null))
updateDataValue("lastRunningMode", "auto")
break
case "heat":
events.add(sendEvent(name: "statusText", value: "Heating to ${temperature}°", displayed: false))
events.add(sendEvent(name: "thermostatOperatingState", value: "heating", displayed: false, isStateChange: true))
events.add(sendEvent(name: "heatingSetpoint", value: temperature, displayed: false, isStateChange: true))
events.add(sendEvent(name: "thermostatSetpoint", value: temperature, displayed: false, isStateChange: true))
events.add(sendEvent(name: "targetTemp", value: temperature))
updateDataValue("lastRunningMode", "heat")
break
case "cool":
events.add(sendEvent(name: "statusText", value: "Cooling to ${temperature}°", displayed: false))
events.add(sendEvent(name: "thermostatOperatingState", value: "cooling", displayed: false, isStateChange: true))
events.add(sendEvent(name: "coolingSetpoint", value: temperature, displayed: false, isStateChange: true))
events.add(sendEvent(name: "thermostatSetpoint", value: temperature, displayed: false, isStateChange: true))
events.add(sendEvent(name: "targetTemp", value: temperature))
updateDataValue("lastRunningMode", "cool")
break
case "auto":
events.add(sendEvent(name: "statusText", value: "Auto Mode: ${temperature}°", displayed: false))
events.add(sendEvent(name: "targetTemp", value: temperature))
updateDataValue("lastRunningMode", "auto")
break
case "off":
events.add(sendEvent(name: "statusText", value: "System is off", displayed: false))
events.add(sendEvent(name: "thermostatOperatingState", value: "idle", displayed: false, isStateChange: true))
updateDataValue("lastRunningMode", "off")
turnOff = true
break
}
if (turnOff){
events.add(sendEvent(name: "switch", value: "off", displayed: false))
} else {
events.add(sendEvent(name: "switch", value: "on", displayed: false))
}
if (updateDevice){
runIn(1, 'updateDaikinDevice', [ data : turnOff])
}
}
// -------
// Temperature Functions
def tempUp() {
log.debug "tempUp()"
def step = 0.5
def mode = device.currentValue("thermostatMode")
def targetTemp = device.currentValue("targetTemp")
def value = targetTemp + step
updateEvents(temperature: value, updateDevice: true)
}
def tempDown() {
log.debug "tempDown()"
def step = 0.5
def mode = device.currentValue("thermostatMode")
def targetTemp = device.currentValue("targetTemp")
def value = targetTemp - step
updateEvents(temperature: value, updateDevice: true)
}
def setThermostatMode(String newMode) {
log.debug "Executing 'setThermostatMode'"
def currMode = device.currentValue("thermostatMode")
if (currMode != newMode){
updateEvents(mode: newMode, updateDevice: true)
}
}
def setTemperature(Double value) {
log.debug "Executing 'setTemperature' with ${value}"
updateEvents(temperature: value, updateDevice: true)
}
def setHeatingSetpoint(Double value) {
log.debug "Executing 'setHeatingSetpoint' with ${value}"
updateEvents(temperature: value, updateDevice: true)
}
def setCoolingSetpoint(Double value) {
log.debug "Executing 'setCoolingSetpoint' with ${value}"
updateEvents(temperature: value, updateDevice: true)
}
// -------
// Daikin "Modes" ----
def auto(){
log.debug "Executing 'auto'"
updateEvents(mode: "auto", updateDevice: true)
}
def dry() {
log.debug "Executing 'dry'"
updateEvents(mode: "dry", updateDevice: true)
}
def cool() {
log.debug "Executing 'cool'"
// Set target temp to previously set Cool temperature
def coolPoint = device.currentValue("coolingSetpoint")
updateEvents(mode: "cool", temperature: coolPoint, updateDevice: true)
}
def heat() {
log.debug "Executing 'heat'"
// Set target temp to previously set Heat temperature
def heatPoint = device.currentValue("heatingSetpoint")
updateEvents(mode: "heat", temperature: heatPoint, updateDevice: true)
}
def fan() {
log.debug "Executing 'fan'"
updateEvents(mode: "fan", updateDevice: true)
}
// -------
// Switch Functions ----
def on(){
log.debug "Executing 'on'"
def currMode = device.currentValue("currMode")
updateEvents(mode: currMode, updateDevice: true)
}
def off() {
log.debug "Executing 'off'"
updateEvents(mode: "off", updateDevice: true)
}
// -------
// Fan Actions ----
private fanAPISupported() {
// Returns boolean based on whether API Fan actions are supported by the model
String deviceFanSupport = device.currentValue("fanAPISupport")
if (deviceFanSupport == "false"){
log.debug "Fan settings not supported on this model"
sendEvent(name: "fanDirection", value: "Not Supported")
return false
} else {
return true
}
}
def setFanRate(def fanRate) {
log.debug "Executing 'setFanRate' with ${fanRate}"
def currFanRate = device.currentValue("fanRate")
// Check that rate is different before setting.
// TODO: Clean messy IF statements
if (currFanRate != fanRate){
if (fanAPISupported()){
sendEvent(name: "supportedThermostatFanModes", value: ["auto", "on"], displayed: false) // We don't support circulate at this time
if (fanRate == 0){
sendEvent(name: "fanRate", value: "Auto")
sendEvent(name: "thermostatFanMode", value: "auto", displayed: false)
} else {
sendEvent(name: "fanRate", value: fanRate)
switch (fanRate) {
case "Auto":
sendEvent(name: "thermostatFanMode", value: "auto", displayed: false)
break
default: // all other modes indicate fan on
sendEvent(name: "thermostatFanMode", value: "on", displayed: false)
break
}
}
runIn(1, 'updateDaikinDevice', [ data : false])
} else {
sendEvent(name: "fanRate", value: "Not Supported")
}
}
}
def fanRateAuto(){
log.debug "Executing 'fanRateAuto'"
setFanRate("Auto")
}
def fanRateSilence(){
log.debug "Executing 'fanRateSilence'"
setFanRate("Silence")
}
def toggleFanDirection(String toggleDir){
log.debug "Executing 'toggleFanDirection' with ${toggleDir}"
String currentDir = device.currentValue("fanDirection")
if (currentDir == "Off"){
// If both directions are OFF, set to toggled value
sendEvent(name: "fanDirection", value: toggleDir)
} else if (currentDir == "3D"){
// If both directions are on ("3D"), set to opposite of toggled state
String newDir = toggleDir == "Horizontal" ? "Vertical" : "Horizontal"
sendEvent(name: "fanDirection", value: newDir)
} else if (currentDir != toggleDir) {
// If one direction is on and toggled state is not currently active, turn on both
sendEvent(name: "fanDirection", value: "3D")
} else if (currentDir == toggleDir){
// If toggled state is currently active, turn directional off
sendEvent(name: "fanDirection", value: "Off")
}
if (fanAPISupported()){
runIn(1, 'updateDaikinDevice', [ data : false])
} else {
sendEvent(name: "fanDirection", value: "Not Supported")
}
}
def fanDirectionHorizontal() {
log.debug "Executing 'fanDirectionHorizontal'"
toggleFanDirection("Horizontal")
}
def fanDirectionVertical() {
log.debug "Executing 'fanDirectionVertical'"
toggleFanDirection("Vertical")
}
def fanOn() {
log.debug "Executing 'fanOn'"
fanRateSilence() // Should this be made configurable to allow the user to select the default fan rate?
}
def fanAuto() {
log.debug "Executing 'fanAuto'"
fanRateAuto()
}
// TODO: Implement these functions if possible
def fanCirculate() {
log.warn "Executing 'fanCirculate' not currently supported"
// TODO: handle 'fanCirculate' command
}
def setThermostatFanMode(String value) {
log.debug "Executing 'setThermostatFanMode' with fan mode $value"
switch(value){
case "auto":
fanAuto()
break
case "on":
fanOn()
break
case "circulate":
fanCirculate()
break
default:
log.warn "Unknown fan mode: $value"
break
}
}
def setSchedule(schedule)
{
// log.debug "Executing 'setSchedule'"
// TODO: handle 'setSchedule' command
}
// -------
Thank you works great!
1 Like
Hi All,
I'm a bit mystified here. I have the Daikin BRP072C42 wifi adapter on a split system (this adapter wasn't a deliberate choice, it came with the AC unit) and for me it doesn't remotely work with any versions of the driver as posted.
Can I just clarify: is there anyone using the same Daikin wi-fi adapter, who is successfully using this driver?
oh - here is the error messages i get in case there is anyone who is experiencing the same:
dev:6422020-11-17 09:31:55.130 warnConnection refused (Connection refused)
dev:6422020-11-17 09:31:55.120 debugGET /aircon/get_control_info HTTP/1.1 Accept: / User-Agent: Linux UPnP/1.0 Hubitat Host: 192.168.2.88:80
edit, just read some of your other posts from this thread. Your already aware... I guess your just looking for someone that already has this working.
Heres a HomeAssistant article. Yours uses security. Sounds like some extra hurdles.
GH requires that thermostat devices provide a lastRunningMode state. The Hubitat integration may be checking that the Daikin device has it before allowing it to be added.
thanks for the response @ajones , 4 more hours of hair-pulling though and i've managed to re-write it to work. sheer persistence though, not programming knowledge or elegance. i bet one of the guys on here could have done it in 10 minutes.
i'm not sure how daikin only sold this adapter to me, they must have thought i was a HomeAssistant-looking guy, 'cause no-one in Hubitat world seems to have one. Luckily for me there's a bunch of guys in the HA world did the hard work & are happily using it. python grumble grumble 
now for the testing to make sure it actually works as intended...
Just found out my fridgy guys installed a BRP15B61 instead of the BRP072A42 we discussed initially.
Couldn't work out why it wasn't working!
Anyway - Have it working with limited functionality thanks to your suggestions. Have found this https://smedley.id.au/tmp/daikin-wifi-airbase.groovy which is an edit to the original app to make the BRP15B61 work , apparently with zones. I'm not clever enough with .groovy to know the differences, or port it to HE. Maybe someone could take a look and make a merge?
Hi, my daikin AC is also using the same wifi module. Are you ok to share your code please?
aha, same wifi module as me! and here i was starting to think they only made one of these modules as an experiment and gave it to me.
you poor unlucky sod...unless of course you can code then let me start off by saying you're one hell of a fine gentleman!
happy to share...but it doesn't work 
so not really useful?
Out of interest, are there particular errors you get? I don't own a Daikin myself, I have a Mitsubishi system, but am writing a driver, so am always interested in other thermostat implementations. I may consider helping out in some way, but can't promise anything, I have a bad habit of doing that, so wouldn't want to get anyone's hopes up.
Hi @sburke781 i've gotten the driver to talk with the wifi module, i think the issue is about how the messages are sent/received and parsed.
interestingly it can actually turn on the A/C unit, but can't control it any other way (even turn it off), nor does it return temperature or status values.
if you could help i would immediately become your biggest HE fan
happy to post what i have currently, just have to figure out how everybody seems to embed a code window in their post so we don't end up with a 500 line post
2 Likes
You can send me a pm if it's any easier.
If you want to include it in a post on the thread I think it is the </> icon in the reply dialog you want to use (Preformatted Text).
thanks. sent via PM, although looking at the sent msg its formatted shite.
let me know if you want me to re-send it, or try again by posting the whole damn thing line by line. the </> button doesn't seem to do anything but indent the text, there's no lil' window appearing.
2 Likes
