I'm trying to port my ST DTH for an Onkyo receiver to Hubitat. I've started by replacing every instance of 'physicalgraph' with 'hubitat'. When I click on a device command it shows an event occurred but nothing happens with the receiver. It works with ST, so any thoughts on what I may be missing in Hubitat would be appreciated.
/**
* Onkyo IP Control Device Type for Hubitat
* Carson Dallum (@cdallum)
* Originally based on: Mike Maxwell's and Allan Klein's code
*
* Usage:
* 1. Be sure you have enabled control of the receiver via the network under the settings on your receiver.
* 2. Add this code as a device handler in the Hubitat Drivers Code section
* 3. Create a device using OnkyoIP as the device handler using a hexadecimal representation of IP:port as the device network ID value
* For example, a receiver at 192.168.1.222:60128 would have a device network ID of C0A801DE:EAE0
* Note: Port 60128 is the default Onkyo eISCP port so you shouldn't need to change anything after the colon
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
* for the specific language governing permissions and limitations under the License.
*
* Some future commands that might be useful to incorporate reading:
* Power Status: PWRQSTN
* Input Selected: SLIQSTN
* Volume Level: MVLQSTN (value in hex)
* Artist Name: NATQSTN
* Track Name: NTIQSTN
* Zone 2 Mute: ZMTQSTN
* Zone 2 Volume: ZVLQSTN
* Zone 2 Input Selected: SLZQSTN
* ISCP commands were found at https://github.com/miracle2k/onkyo-eiscp/blob/master/eiscp-commands.yaml
*/
metadata {
definition (name: "Onkyo Receiver", namespace: "cdallum", author: "Carson Dallum") {
capability "Switch"
command "cable"
command "stb"
command "pc"
}
main "switch"
details(["switch","cable","stb","pc"])
}
// parse events into attributes
def parse(description) {
def msg = parseLanMessage(description)
def headersAsString = msg.header // => headers as a string
def headerMap = msg.headers // => headers as a Map
def body = msg.body // => request body as a string
def status = msg.status // => http status code of the response
def json = msg.json // => any JSON included in response body, as a data structure of lists and maps
def xml = msg.xml // => any XML included in response body, as a document tree structure
def data = msg.data // => either JSON or XML in response body (whichever is specified by content-type header in response)
}
def on() {
log.debug "Powering on receiver"
sendEvent(name: "switch", value: "on")
def msg = getEiscpMessage("PWR01")
def ha = new hubitat.device.HubAction(msg,hubitat.device.Protocol.LAN)
return ha
}
def off() {
log.debug "Powering off receiver"
sendEvent(name: "switch", value: "off")
def msg = getEiscpMessage("PWR00")
def ha = new hubitat.device.HubAction(msg,hubitat.device.Protocol.LAN)
return ha
}
def cable() {
log.debug "Setting input to Cable"
def msg = getEiscpMessage("SLI01")
def ha = new hubitat.device.HubAction(msg,hubitat.device.Protocol.LAN)
return ha
}
def stb() {
log.debug "Setting input to STB"
def msg = getEiscpMessage("SLI02")
def ha = new hubitat.device.HubAction(msg,hubitat.device.Protocol.LAN)
return ha
}
def pc() {
log.debug "Setting input to PC"
def msg = getEiscpMessage("SLI05")
def ha = new hubitat.device.HubAction(msg,hubitat.device.Protocol.LAN)
return ha
}
def getEiscpMessage(command){
def sb = StringBuilder.newInstance()
def eiscpDataSize = command.length() + 3 // this is the eISCP data size
def eiscpMsgSize = eiscpDataSize + 1 + 16 // this is the size of the entire eISCP msg
/* This is where I construct the entire message
character by character. Each char is represented by a 2 disgit hex value */
sb.append("ISCP")
// the following are all in HEX representing one char
// 4 char Big Endian Header
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("10", 16))
// 4 char Big Endian data size
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
// the official ISCP docs say this is supposed to be just the data size (eiscpDataSize)
// ** BUT **
// It only works if you send the size of the entire Message size (eiscpMsgSize)
// Changing eiscpMsgSize to eiscpDataSize for testing
sb.append((char)Integer.parseInt(Integer.toHexString(eiscpDataSize), 16))
//sb.append((char)Integer.parseInt(Integer.toHexString(eiscpMsgSize), 16))
// eiscp_version = "01";
sb.append((char)Integer.parseInt("01", 16))
// 3 chars reserved = "00"+"00"+"00";
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
sb.append((char)Integer.parseInt("00", 16))
// eISCP data
// Start Character
sb.append("!")
// eISCP data - unittype char '1' is receiver
sb.append("1")
// eISCP data - 3 char command and param ie PWR01
sb.append(command)
// msg end - this can be a few different cahrs depending on you receiver
// my NR5008 works when I use 'EOF'
//OD is CR
//0A is LF
/*
[CR] Carriage Return ASCII Code 0x0D
[LF] Line Feed ASCII Code 0x0A
[EOF] End of File ASCII Code 0x1A
*/
//works with cr or crlf
sb.append((char)Integer.parseInt("0D", 16)) //cr
//sb.append((char)Integer.parseInt("0A", 16))
return sb.toString()
}
