def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Onkyo platform."""
import eiscp
from eiscp import eISCP
host = config.get(CONF_HOST)
hosts = []
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
hosts.append(
OnkyoDevice(
eiscp.eISCP(host),
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
))
KNOWN_HOSTS.append(host)
# Add Zone2 if configured
if config.get(CONF_ZONE2):
_LOGGER.debug("Setting up zone 2")
hosts.append(
OnkyoDeviceZone2(eiscp.eISCP(host),
config.get(CONF_SOURCES),
name=config.get(CONF_NAME) + " Zone 2"))
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_devices(hosts, True)
def get_status():
receiver = eiscp.eISCP(receiver_address)
main_power_result = receiver.command('main.power=query')
main_power_status = main_power_result[1]
if isinstance(main_power_status, tuple): # main power gives standby,off
main_power_status = main_power_status[0]
main_volume = receiver.command('main.volume=query')[1]
main_source = receiver.command('main.source=query')[1]
if isinstance(main_source, tuple):
main_source = ','.join(main_source)
zone2_power_result = receiver.command('zone2.power=query')
zone2_power_status = zone2_power_result[1]
zone2_volume = receiver.command('zone2.volume=query')[1]
zone2_source = receiver.command('zone2.selector=query')[1]
if isinstance(zone2_source, tuple):
zone2_source = ','.join(zone2_source)
receiver.disconnect()
return jsonify({
"status": {
"main": {
"status": main_power_status,
"volume": volume_output(main_volume),
"source": source_output(main_source)
},
"zone2": {
"status": zone2_power_status,
"volume": volume_output(zone2_volume),
"source": source_output(zone2_source)
}
}
})
def main(workflow):
if 'receiver_host' not in workflow.settings:
foundReceiver = discoverReceiver()
if not foundReceiver:
return
workflow.settings['receiver_host'] = foundReceiver.host
receiver = eiscp.eISCP(workflow.settings['receiver_host'])
data = {
'modelName': receiver.model_name,
'isPowerOn': (receiver.raw('PWRQSTN') == 'PWR01'),
'isMuting': (receiver.raw('AMTQSTN') == 'AMT01'),
'volume': int(receiver.raw('MVLQSTN')[3:], 16),
'source': getSource(receiver.raw('SLIQSTN')[3:]),
}
if data['isPowerOn'] and data['source'] == 'NET':
data['title'] = receiver.raw('NTIQSTN')[3:]
data['artist'] = receiver.raw('NATQSTN')[3:]
data['album'] = receiver.raw('NALQSTN')[3:]
data['time'] = receiver.raw('NTMQSTN')[3:]
data['status'] = getStatus(receiver.raw('NSTQSTN')[3:])
workflow.cache_data('receiver_data', data)
receiver.disconnect()
def get_receiver(onkyo_address=None, onkyo_id=None):
if onkyo_address:
receiver = eiscp.eISCP(onkyo_address)
else:
app.logger.info("Starting auto-discovery of Onkyo AVRs")
receivers = eiscp.eISCP.discover()
for receiver in receivers:
app.logger.info("Disocvered %s at %s:%s with id %s" % (
receiver.info["model_name"],
receiver.host,
receiver.port,
receiver.info["identifier"],
))
if onkyo_id:
receivers = [
r for r in receivers if onkyo_id in r.info["identifier"]
]
if len(receivers) == 0:
app.logger.warning("No specified AVRs discovered")
exit(1)
elif len(receivers) != 1:
app.logger.warning(
"More than one AVR discovered, please specify explicitely using environemnt Variable O2M_ONKYO_ADDRESS or O2M_ONKYO_ID"
)
exit(1)
receiver = receivers.pop(0)
app.logger.info(f"Discovered AVR at {receiver}")
return receiver
async def poll(self):
""" Updates the state by polling the AVR and returns a list of changed properties """
with eiscp.eISCP(self.avr.ip) as receiver:
resp = receiver.command('power', arguments=['query'], zone=self.name)
power = resp[1] == 'on'
resp = receiver.command('volume', arguments=['query'], zone=self.name)
volume = float(0 if resp[1] == 'N/A' else resp[1])
resp = receiver.command('input-selector' if self.zoneId == 0 else 'selector', arguments=['query'], zone=self.name)
inputid = resp[1][0] if isinstance(resp[1], tuple) else resp[1]
if inputid == 'fm' or inputid =='am':
inputid = 'Tuner'
selected_input = self.avr.input_ids.index(inputid)
resp = receiver.command('audio-muting' if self.zoneId == 0 else 'muting', arguments=['query'], zone=self.name)
mute = True if resp[1] == 'on' else False
result = [
self._property_updated('power', power),
self._property_updated('input', selected_input),
self._property_updated('volume', volume),
self._property_updated('mute', mute)
]
return filter(None, result)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Setup the Onkyo platform."""
import eiscp
from eiscp import eISCP
hosts = []
if CONF_HOST in config and config[CONF_HOST] not in KNOWN_HOSTS:
try:
hosts.append(
OnkyoDevice(eiscp.eISCP(config[CONF_HOST]),
config.get(CONFIG_SOURCE_LIST, DEFAULT_SOURCES),
name=config[CONF_NAME]))
KNOWN_HOSTS.append(config[CONF_HOST])
except OSError:
_LOGGER.error('Unable to connect to receiver at %s.',
config[CONF_HOST])
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(
OnkyoDevice(
receiver,
config.get(CONFIG_SOURCE_LIST, DEFAULT_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_devices(hosts)
async def save_preset(self, arguments):
if len(arguments) == 2 and arguments[0] >= 1 and arguments[0] <= 40 and isinstance(arguments[1], str): ## FIXME: Correct preset min/max here
index = arguments[0]
name = arguments[1][:8] ## FIXME: name max length? I assumed 8 here.
with eiscp.eISCP(self.avr.ip) as receiver:
receiver.send('PRM' + '{0:02x}'.format(index))
else:
raise AvrCommandError('Invalid arguments: must be 1. int [1..40] 2. string', 'savePreset', arguments, None)
def av_change_hdmi(config):
logging.info('Onkyo change HDMI Input')
try:
receiver = eiscp.eISCP(config["AV_Ip"])
receiver.raw(config["AV_Input"])
receiver.disconnect()
return ("OK")
except:
return ("Error en el cambio")
def set_power(zone, status):
if zone != 'main' and zone != 'zone2':
return 'unknown zone', 400
if status != 'on' and status != 'standby':
return 'unknown status', 400
receiver = eiscp.eISCP(receiver_address)
receiver.command(zone + '.power=' + status)
receiver.disconnect()
return get_status()
async def select_input(self, inputId):
with eiscp.eISCP(self.avr.ip) as receiver:
if self.avr.input_real_names[inputId][0] == 'Tuner':
resp = receiver.raw('TUNQSTN')
freq = int(resp[3:])
receiver.command('input-selector' if self.zoneId == 0 else 'selector', arguments=['fm' if freq > 5000 else 'am'], zone=self.name)
else:
(receiver.raw('SLI12' if self.zoneId == 0 else 'SLZ12')) if self.avr.input_real_names[inputId][0] == 'tv' else (receiver.command('input-selector' if self.zoneId == 0 else 'selector', arguments=[self.avr.input_real_names[inputId][0]], zone=self.name))
return inputId
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Onkyo platform."""
import eiscp
from eiscp import eISCP
host = config.get(CONF_HOST)
hosts = []
def service_handle(service):
"""Handle for services."""
entity_ids = service.data.get(ATTR_ENTITY_ID)
devices = [d for d in hosts if d.entity_id in entity_ids]
for device in devices:
if service.service == SERVICE_SELECT_HDMI_OUTPUT:
device.select_output(service.data.get(ATTR_HDMI_OUTPUT))
hass.services.register(
DOMAIN, SERVICE_SELECT_HDMI_OUTPUT, service_handle,
schema=ONKYO_SELECT_OUTPUT_SCHEMA)
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
receiver = eiscp.eISCP(host)
hosts.append(OnkyoDevice(
receiver,
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
))
KNOWN_HOSTS.append(host)
zones = determine_zones(receiver)
# Add Zone2 if available
if zones["zone2"]:
_LOGGER.debug("Setting up zone 2")
hosts.append(OnkyoDeviceZone(
"2", receiver,
config.get(CONF_SOURCES),
name="{} Zone 2".format(config[CONF_NAME])))
# Add Zone3 if available
if zones["zone3"]:
_LOGGER.debug("Setting up zone 3")
hosts.append(OnkyoDeviceZone(
"3", receiver,
config.get(CONF_SOURCES),
name="{} Zone 3".format(config[CONF_NAME])))
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_entities(hosts, True)
def __init__(self, args):
self.receiver = eiscp.eISCP(args.ip)
ShetClient.__init__(self)
self.add_action('/onkyo/volUp', self.volume_up)
self.add_action('/onkyo/volDown', self.volume_down)
self.add_action('/onkyo/mute', self.mute)
self.add_action('/onkyo/on', self.on)
self.add_action('/onkyo/standby', self.standby)
def set_volume(zone, level):
if zone != 'main' and zone != 'zone2':
return 'unknown zone', 400
if level < 0: level = 0
if level > 80: level = 80
receiver = eiscp.eISCP(receiver_address)
receiver.command(zone + '.volume=' + str(level))
receiver.disconnect()
return jsonify({"zone": zone, "volume": level})
def av_power_off(config):
logging.info('Llamada a av_power_off')
try:
receiver = eiscp.eISCP(config["AV_Ip"])
onk_status = receiver.command('power query')
logging.info('Onkyo Power Status: %s', onk_status[1])
receiver.raw('PWR00')
receiver.disconnect()
return ("OK")
except:
return ("Error")
return ("OK")
def collect(self):
up = GaugeMetricFamily('onkyo_up',
'Was the last amplifier query successful',
labels=['node'])
duration = GaugeMetricFamily('onkyo_collection_duration_seconds',
'Time spent collecting data',
labels=['node'])
power = GaugeMetricFamily('onkyo_power',
'Power status',
labels=['model', 'identifier', 'node'])
mute = GaugeMetricFamily('onkyo_mute',
'Muting status',
labels=['model', 'identifier', 'node'])
volume = GaugeMetricFamily('onkyo_volume',
'Master volume',
labels=['model', 'identifier', 'node'])
start = time.time()
try:
with eiscp.eISCP(self._target) as receiver:
model = receiver.info['model_name']
identifier = receiver.info['identifier']
try:
power.add_metric(
[model, identifier, self._target],
0 if receiver.command('system-power query')[1][1]
== 'off' else 1)
mute.add_metric(
[model, identifier, self._target],
0 if receiver.command('audio-muting query')[1] == 'off'
else 1)
volume.add_metric(
[model, identifier, self._target],
receiver.command('master-volume query')[1])
except:
print('Error: {}'.format(sys.exc_info()))
up.add_metric(labels=[self._target], value=1)
for metric in [up, power, mute, volume]:
yield metric
except:
print('Error: {}'.format(sys.exc_info()))
up.add_metric([self._target], 0)
yield up
end = time.time()
duration.add_metric([self._target], end - start)
yield duration
def av_test(config):
try:
receiver = eiscp.eISCP(config["AV_Ip"])
onk_status = receiver.command('power query')
print("-----------------------------------------------------------")
print(" Test Conexion AV Onkyo OK ")
print("-----------------------------------------------------------")
return ("OK")
except:
print("-----------------------------------------------------------")
print(" Test Conexion AV Onkyo NO OK ")
print("-----------------------------------------------------------")
return ("Error")
def av_check_power(config):
logging.info('Onkyo Check AV POWER')
try:
receiver = eiscp.eISCP(config["AV_Ip"])
onk_status = receiver.command('power query')
logging.info('Onkyo Power Status: %s', onk_status[1])
if onk_status[1] == ('standby', 'off'):
logging.info('Cambiamos a on')
receiver.command('power on')
receiver.disconnect()
return ("OK")
except:
return ("Error")
async def set_band(self, value):
with eiscp.eISCP(self.avr.ip) as receiver:
resp = receiver.command('input-selector', arguments=['query'], zone='main')
inputid = resp[1][0] if isinstance(resp[1], tuple) else resp[1]
if inputid == 'fm' or inputid == 'am':
receiver.command('input-selector', arguments=[value.lower()], zone='main')
resp = receiver.command('selector', arguments=['query'], zone='zone2')
inputid = resp[1][0] if isinstance(resp[1], tuple) else resp[1]
resp2 = receiver.command('power', arguments=['query'], zone='zone2')
power = resp2[1]
if ((inputid =='fm' or inputid == 'am') and power == 'on'):
receiver.command('selector', arguments=[value.lower()], zone='zone2')
return value
def set_radio1():
with eiscp.eISCP('192.168.1.32') as receiver:
_, powerstatus = receiver.command('main power query')
if powerstatus != 'on':
receiver.command('main power on')
time.sleep(2)
result = receiver.raw('SLI2B') # source NET
result = receiver.raw('NSV0e0')
result = receiver.raw(
'NLSI00001') # select eerste element in de lijst => my Presets
result = receiver.raw(
'NLSI00002') # select tweede element in de lijst => Radio 1
return {}
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Onkyo platform."""
import eiscp
from eiscp import eISCP
host = config.get(CONF_HOST)
hosts = []
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
receiver = eiscp.eISCP(host)
hosts.append(
OnkyoDevice(
receiver,
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
))
KNOWN_HOSTS.append(host)
zones = determine_zones(receiver)
# Add Zone2 if available
if zones["zone2"]:
_LOGGER.debug("Setting up zone 2")
hosts.append(
OnkyoDeviceZone("2",
receiver,
config.get(CONF_SOURCES),
name="{} Zone 2".format(
config[CONF_NAME])))
# Add Zone3 if available
if zones["zone3"]:
_LOGGER.debug("Setting up zone 3")
hosts.append(
OnkyoDeviceZone("3",
receiver,
config.get(CONF_SOURCES),
name="{} Zone 3".format(
config[CONF_NAME])))
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_devices(hosts, True)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Onkyo platform."""
import eiscp
from eiscp import eISCP
host = config.get(CONF_HOST)
hosts = []
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
receiver = eiscp.eISCP(host)
hosts.append(OnkyoDevice(
receiver,
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
))
KNOWN_HOSTS.append(host)
zones = determine_zones(receiver)
# Add Zone2 if available
if zones["zone2"]:
_LOGGER.debug("Setting up zone 2")
hosts.append(OnkyoDeviceZone(
"2", receiver,
config.get(CONF_SOURCES),
name="{} Zone 2".format(config[CONF_NAME])))
# Add Zone3 if available
if zones["zone3"]:
_LOGGER.debug("Setting up zone 3")
hosts.append(OnkyoDeviceZone(
"3", receiver,
config.get(CONF_SOURCES),
name="{} Zone 3".format(config[CONF_NAME])))
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_devices(hosts, True)
def __init__(self, **kwargs):
super(Onkyo, self).__init__(**kwargs)
# the args from the neuron configuration
self.ip_address = kwargs.get('ip_address', None)
self.volume = kwargs.get('volume', None)
self.command_1 = kwargs.get('command_1', None)
self.command_2 = kwargs.get('command_2', None)
self.command_3 = kwargs.get('command_3', None)
self.command_4 = kwargs.get('command_4', None)
self.command_5 = kwargs.get('command_5', None)
self.command_6 = kwargs.get('command_6', None)
# check if parameters have been provided
if self._is_parameters_ok():
receiver = eiscp.eISCP(self.ip_address)
if self.volume is not None:
try:
receiver.command("volume=%s" % int(self.volume))
receiver.disconnect()
except ValueError:
logger.debug("Attention: Onkyo volume needs to be integer")
if self.command_1 is not None:
receiver.command(self.command_1)
if self.command_2 is not None:
receiver.command(self.command_2)
if self.command_3 is not None:
receiver.command(self.command_3)
if self.command_4 is not None:
receiver.command(self.command_4)
if self.command_5 is not None:
receiver.command(self.command_5)
if self.command_6 is not None:
receiver.command(self.command_6)
receiver.disconnect()
def main(workflow):
args = workflow.args[0].split(' ')
action = args[0]
value = args[1] if len(args) > 1 else ''
if action == 'discover':
foundReceiver = discoverReceiver()
if foundReceiver:
workflow.settings['receiver_host'] = foundReceiver.host
notify(
'Onkyo Remote', 'Found %s at %s' %
(foundReceiver.model_name, foundReceiver.host))
return
if 'receiver_host' not in workflow.settings:
return
receiver = eiscp.eISCP(workflow.settings['receiver_host'])
if action in ['off', 'on']:
receiver.command('power %s' % action)
elif action == 'net':
if value in ['pause', 'play']:
receiver.command('network-usb %s' % value)
elif value == 'next-track':
receiver.command('network-usb trup')
elif value == 'previous-track':
receiver.command('network-usb trdn')
elif action == 'source':
receiver.command('source %s' % value)
elif action == 'volume':
if value.isdigit():
receiver.command('volume %d' % int(value))
elif value in ['down', 'up']:
receiver.command('volume level-%s' % value)
elif value == 'mute':
receiver.command('audio-muting toggle')
receiver.disconnect()
def _initialise_volume_control(self):
self.receiver = eiscp.eISCP('192.168.1.31')
self.source = 1
self.tv_mode = False
self.volume_power_held = False
self.button_amp_power = Button(HAL.VOL_C, pull_up=True)
self.button_amp_power.hold_time = Config.BTN_HOLD_TIME
self.button_amp_power.when_held = self.btn_volume_held
self.button_amp_power.when_released = self.btn_volume_release
self.volume_control = RotaryEncoder(HAL.VOL_A,
HAL.VOL_B,
maximum=60,
minimum=0,
initial=30,
step_size=1)
self.volume_control.on_clockwise = self.volume_up
self.volume_control.on_counter_clockwise = self.volume_down
self.btnvol_was_held = False
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Setup the Onkyo platform."""
import eiscp
from eiscp import eISCP
host = config.get(CONF_HOST)
hosts = []
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
hosts.append(OnkyoDevice(eiscp.eISCP(host), config.get(CONF_SOURCES), name=config.get(CONF_NAME)))
KNOWN_HOSTS.append(host)
except OSError:
_LOGGER.error("Unable to connect to receiver at %s.", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_devices(hosts)
def setup_eiscp(args):
if args.onkyo_address:
receiver = eiscp.eISCP(args.onkyo_address)
else:
logging.info('Starting auto-discovery of Onkyo AVRs')
receivers = eiscp.eISCP.discover()
for receiver in receivers:
logging.info("Discovered %s at %s:%s with id %s" %
(receiver.info['model_name'], receiver.host,
receiver.port, receiver.info['identifier']))
if args.onkyo_id:
receivers = [
r for r in receivers if args.onkyo_id in r.info['identifier']
]
if len(receivers) == 0:
raise EiscpError("No specified AVRs discovered")
elif len(receivers) != 1:
raise EiscpError("More than one AVR discovered, please specify "
"explicitely using --onkyo-address or --onkyo-id")
receiver = receivers.pop(0)
logging.info('Discovered AVR at %s', receiver)
return receiver
async def poll(self):
""" Polls the state of the AVR and returns a list of changed properties """
with eiscp.eISCP(self.avr.ip) as receiver:
resp = receiver.raw('TUNQSTN')
freq_raw = int(resp[3:])
if freq_raw > 5000:
band = 'FM'
freq = freq_raw/100
else:
band = 'AM'
freq = freq_raw
selected_preset = receiver.command('preset', arguments=['query'], zone='main') ##FIXME: Where to get zoneId?
presets = [{'index': (i+1), 'name': ('Preset {0}'.format(i+1)), 'freq': None, 'band': None} for i in range(40)] ##FIXME: implement!
preset_count = len(presets) ##FIXME: implement!
result = [
self._property_updated('band', band),
self._property_updated('freq', freq),
self._property_updated('selectedPreset', selected_preset),
self._property_updated('presetCount', preset_count),
self._property_updated('presets', presets),
]
return filter(None, result)
#!/usr/bin/python
# Web server to Arduino gateway
# POST data is sent to the Arduino over the serial link
#
# Copyright 2009 Ken Shirriff
# http://arcfn.com
import cgi
import serial
import eiscp
from BaseHTTPServer import HTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
receiver = eiscp.eISCP('10.0.1.2', 60128)
receiver.connectSocket()
# The web server.
class MyHandler(SimpleHTTPRequestHandler):
def do_POST(self):
if self.path == '/control':
global receiver
form = cgi.FieldStorage(fp=self.rfile, headers=self.headers,
environ={'REQUEST_METHOD':'POST'})
code = form['code'].value
print 'Sent:', code
receiver.writeCommandFromName(code)
self.send_response(200)
self.send_header('Content-type', 'text/html')
return
return self.do_GET()
# You may need something other than /dev/ttyUSB0
server = HTTPServer(('', 8080), MyHandler).serve_forever()
#!/usr/bin/python
from Tkinter import *
import eiscp
receiver = eiscp.eISCP("10.0.1.41", 60128)
receiver.connectSocket()
def poff():
receiver.writeCommandFromName("Power OFF")
def pon():
receiver.writeCommandFromName("Power ON")
def volup():
receiver.writeCommandFromName("Volume Up")
def voldown():
receiver.writeCommandFromName("Volume Down")
def volmute():
receiver.writeCommandFromName("MuteToggle")
def srcDVD():
receiver.writeCommandFromName("DVD")
def test():
receiver = eiscp.eISCP('192.168.2.114')
#receiver.command('zone2.power=on')
receiver.command('zone2.power=standby')
receiver.disconnect()
def main():
receiver = eiscp.eISCP('192.168.1.68')
Receiver(receiver)
gtk.main()
#!/usr/bin/env python
import eiscp
from bright import *
from light_list import *
import threading
import time
receiver = eiscp.eISCP('IP')
print "receiver defined"
print ""
def check(receiver):
if receiver.command('system-power query') == ('system-power', 'on'):
return "on"
else:
return "off"
def adjust_brightness(room):
try:
if check(receiver)=="off":
group_bright(room, 59441, 100)
print "receiver off... brightness set to full"
print ""
else:
group_bright(room, 9000, 100)
print " receiver on... brightness set to movie-mode"
print ""
sleep(10)
import eiscp
# Create a receiver object, connecting to the host
receiver = eiscp.eISCP('192.168.1.67')
#receivers = eiscp.eISCP.discover()
# Turn the receiver on, select PC input
#receiver.command('system-power=standby')
receiver.command('volume=25')
receiver.disconnect()
# receivers = eiscp.eISCP.discover()
# returns list of eISCP
# receivers[0].host is the IP
def disconnecthandler(mqc, userdata, rc):
logging.warning("Disconnected from MQTT broker with rc=%s" % (rc))
time.sleep(5)
mqc = mqtt.Client()
mqc.on_message = msghandler
mqc.on_connect = connecthandler
mqc.on_disconnect = disconnecthandler
mqc.will_set(topic + "connected", 0, qos=2, retain=True)
mqc.connect(args.mqtt_host, args.mqtt_port, 60)
mqc.publish(topic + "connected", 1, qos=1, retain=True)
if args.onkyo_address:
receiver = eiscp.eISCP(args.onkyo_address)
else:
logging.info('Starting auto-discovery of Onkyo AVRs')
receivers = eiscp.eISCP.discover()
for receiver in receivers:
logging.info("Disocvered %s at %s:%s with id %s" %
(receiver.info['model_name'], receiver.host,
receiver.port, receiver.info['identifier']))
if args.onkyo_id:
receivers = [
r for r in receivers if args.onkyo_id in r.info['identifier']
]
if len(receivers) == 0:
logging.warning("No specified AVRs discovered")
exit(1)
elif len(receivers) != 1:
def main():
receiver = eiscp.eISCP('192.168.1.68')
Receiver(receiver)
gtk.main()
def turnOnAudio(source):
# Create a receiver object attached to the host 192.168.0.40
receiver = eiscp.eISCP('192.168.0.40')
receiver.writeCommandFromName('Power ON')
time.sleep(0.1)
receiver.writeCommandFromName(source)
def __init__(self):
super(Onkyo, self).__init__()
self.initUI()
self.settings = QSettings('onkyoqt', 'settings')
self.host = self.settings.value('host', type=str)
self.receiver = eiscp.eISCP(self.host)
def __init__(self, ip_addr):
self.eiscp_inst = eiscp.eISCP(ip_addr)
mqc.publish(topic+"connected",2,qos=1,retain=True)
def disconnecthandler(mqc,userdata,rc):
logging.warning("Disconnected from MQTT broker with rc=%d" % (rc))
time.sleep(5)
mqc=mqtt.Client()
mqc.on_message=msghandler
mqc.on_connect=connecthandler
mqc.on_disconnect=disconnecthandler
mqc.will_set(topic+"connected",0,qos=2,retain=True)
mqc.connect(args.mqtt_host,args.mqtt_port,60)
mqc.publish(topic+"connected",1,qos=1,retain=True)
if args.onkyo_address:
receiver=eiscp.eISCP(args.onkyo_address)
else:
logging.info('Starting auto-discovery of Onkyo AVRs')
receivers=eiscp.eISCP.discover()
for receiver in receivers:
logging.info("Disocvered %s at %s:%s with id %s" % (
receiver.info['model_name'], receiver.host, receiver.port, receiver.info['identifier']))
if args.onkyo_id:
receivers=[r for r in receivers
if args.onkyo_id in r.info['identifier']]
if len(receivers)==0:
logging.warning("No specified AVRs discovered")
exit(1)
elif len(receivers)!=1:
logging.warning("More than one AVR discovered, please specify explicitely using --onkyo-address or --onkyo-id")
exit(1)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Onkyo platform."""
host = config.get(CONF_HOST)
hosts = []
def service_handle(service):
"""Handle for services."""
entity_ids = service.data.get(ATTR_ENTITY_ID)
devices = [d for d in hosts if d.entity_id in entity_ids]
for device in devices:
if service.service == SERVICE_SELECT_HDMI_OUTPUT:
device.select_output(service.data.get(ATTR_HDMI_OUTPUT))
hass.services.register(
DOMAIN,
SERVICE_SELECT_HDMI_OUTPUT,
service_handle,
schema=ONKYO_SELECT_OUTPUT_SCHEMA,
)
if CONF_HOST in config and host not in KNOWN_HOSTS:
try:
receiver = eiscp.eISCP(host)
hosts.append(
OnkyoDevice(
receiver,
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(CONF_RECEIVER_MAX_VOLUME),
))
KNOWN_HOSTS.append(host)
zones = determine_zones(receiver)
# Add Zone2 if available
if zones["zone2"]:
_LOGGER.debug("Setting up zone 2")
hosts.append(
OnkyoDeviceZone(
"2",
receiver,
config.get(CONF_SOURCES),
name=f"{config[CONF_NAME]} Zone 2",
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(
CONF_RECEIVER_MAX_VOLUME),
))
# Add Zone3 if available
if zones["zone3"]:
_LOGGER.debug("Setting up zone 3")
hosts.append(
OnkyoDeviceZone(
"3",
receiver,
config.get(CONF_SOURCES),
name=f"{config[CONF_NAME]} Zone 3",
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(
CONF_RECEIVER_MAX_VOLUME),
))
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
else:
for receiver in eISCP.discover():
if receiver.host not in KNOWN_HOSTS:
hosts.append(OnkyoDevice(receiver, config.get(CONF_SOURCES)))
KNOWN_HOSTS.append(receiver.host)
add_entities(hosts, True)
def setup_platform(
hass: HomeAssistant,
config: ConfigType,
add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the Onkyo platform."""
hosts: list[OnkyoDevice] = []
def service_handle(service: ServiceCall) -> None:
"""Handle for services."""
entity_ids = service.data[ATTR_ENTITY_ID]
devices = [d for d in hosts if d.entity_id in entity_ids]
for device in devices:
if service.service == SERVICE_SELECT_HDMI_OUTPUT:
device.select_output(service.data[ATTR_HDMI_OUTPUT])
hass.services.register(
DOMAIN,
SERVICE_SELECT_HDMI_OUTPUT,
service_handle,
schema=ONKYO_SELECT_OUTPUT_SCHEMA,
)
if CONF_HOST in config and (host := config[CONF_HOST]) not in KNOWN_HOSTS:
try:
receiver = eiscp.eISCP(host)
hosts.append(
OnkyoDevice(
receiver,
config.get(CONF_SOURCES),
name=config.get(CONF_NAME),
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(CONF_RECEIVER_MAX_VOLUME),
)
)
KNOWN_HOSTS.append(host)
zones = determine_zones(receiver)
# Add Zone2 if available
if zones["zone2"]:
_LOGGER.debug("Setting up zone 2")
hosts.append(
OnkyoDeviceZone(
"2",
receiver,
config.get(CONF_SOURCES),
name=f"{config[CONF_NAME]} Zone 2",
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(CONF_RECEIVER_MAX_VOLUME),
)
)
# Add Zone3 if available
if zones["zone3"]:
_LOGGER.debug("Setting up zone 3")
hosts.append(
OnkyoDeviceZone(
"3",
receiver,
config.get(CONF_SOURCES),
name=f"{config[CONF_NAME]} Zone 3",
max_volume=config.get(CONF_MAX_VOLUME),
receiver_max_volume=config.get(CONF_RECEIVER_MAX_VOLUME),
)
)
except OSError:
_LOGGER.error("Unable to connect to receiver at %s", host)
#!/usr/bin/python
import eiscp
# Create a receiver object attached to the host 192.168.1.124
receiver = eiscp.eISCP('192.168.1.125')
# Turn the receiver on
receiver.writeCommandFromName('Power ON')
# Select the PC input
receiver.writeCommandFromName('Computer/PC')
# Done watching a movie, shut it off.
receiver.writeCommandFromName('Power OFF')
def turnOffAudio():
# Create a receiver object attached to the host 192.168.0.40
receiver = eiscp.eISCP('192.168.0.40')
receiver.writeCommandFromName('Power OFF')
