def sendCmd(self):
if len(self.queue):
(address, cmd, data) = self.queue.pop(0)
if config.hdmicec.debug.value:
self.CECdebug('Tx', address, cmd, data, len(data))
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
self.wait.start(int(config.hdmicec.minimum_send_interval.value), True)
def keyEvent(self, keyCode, keyEvent):
if not self.volumeForwardingEnabled: return
cmd = 0
data = ''
if keyEvent == 0:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 2:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 1:
if keyCode == 115 or keyCode == 114 or keyCode == 113:
cmd = 0x45
if cmd:
eHdmiCEC.getInstance().sendMessage(
self.volumeForwardingDestination, cmd, data, len(data))
return 1
else:
return 0
def keyEvent(self, keyCode, keyEvent):
if not self.volumeForwardingEnabled: return
cmd = 0
data = ''
if keyEvent == 0:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 2:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 1:
if keyCode == 115 or keyCode == 114 or keyCode == 113:
cmd = 0x45
if cmd:
eHdmiCEC.getInstance().sendMessage(self.volumeForwardingDestination, cmd, data, len(data))
return 1
else:
return 0
def setFixedPhysicalAddress(self, address):
if address != config.hdmicec.fixed_physical_address.value:
config.hdmicec.fixed_physical_address.value = address
config.hdmicec.fixed_physical_address.save()
hexstring = address[0] + address[2] + address[4] + address[6]
eHdmiCEC.getInstance().setFixedPhysicalAddress(
int(float.fromhex(hexstring)))
def __init__(self):
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
eHdmiCEC.getInstance().messageReceived.get().append(
self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby,
initial_call=False)
self.setFixedPhysicalAddress(
config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(
self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.enabled.value and config.hdmicec.handle_deepstandby_events.value and not getFPWasTimerWakeup(
):
self.onLeaveStandby()
def __init__(self):
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.waitKeyEvent = eTimer()
self.waitKeyEvent.timeout.get().append(self.sendKeyEvent)
self.queueKeyEvent = []
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
self.delay = eTimer()
self.delay.timeout.get().append(self.sendStandbyMessages)
self.useStandby = True
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
self.wakeup_from_tv = False
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.enabled.value:
if config.hdmicec.report_active_menu.value:
if config.hdmicec.report_active_source.value and NavigationInstance.instance and not NavigationInstance.instance.isRestartUI():
self.sendMessage(0, "sourceinactive")
self.sendMessage(0, "menuactive")
if config.hdmicec.handle_deepstandby_events.value and (not getFPWasTimerWakeup() or (config.usage.startup_to_standby.value == "no" and config.misc.prev_wakeup_time_type.value == 3)):
self.onLeaveStandby()
def keyEvent(self, keyCode, keyEvent):
if not self.volumeForwardingEnabled:
return
cmd = 0
address = keyEvent
data = ''
if keyEvent in (0, 2):
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
elif keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
elif keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
elif keyEvent == 1 and keyCode in (113, 114, 115):
cmd = 0x45
if cmd:
if config.hdmicec.debug.value:
self.CECdebug('Tx', address, cmd, data, len(data))
eHdmiCEC.getInstance().sendMessage(self.volumeForwardingDestination, cmd, data, len(data))
return 1
else:
return 0
def __init__(self):
if config.hdmicec.enabled.value:
try:
if HdmiCec.instance:
raise AssertionError("only one HdmiCec instance is allowed!")
except:
pass
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.queue = []
self.messages = []
self.handleTimer = eTimer()
self.stateTimer = eTimer()
self.stateTimer.callback.append(self.stateTimeout)
self.repeatTimer = eTimer()
self.repeatTimer.callback.append(self.repeatMessages)
self.cmdPollTimer = eTimer()
self.cmdPollTimer.callback.append(self.CECcmdline)
self.cmdWaitTimer = eTimer()
self.repeatCounter = 0
self.what = ''
self.tv_lastrequest = ''
self.tv_powerstate = 'unknown'
self.tv_skip_messages = False
self.activesource = False
self.firstrun = True
self.standbytime = 0
self.disk_full = False
self.start_log = True
self.sethdmipreemphasis()
self.checkifPowerupWithoutWakingTv() # initially write 'False' to file, see below
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call=False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxsize - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding, initial_call=False)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
#workaround for needless messages after cancel settings
self.old_configReportActiveMenu = config.hdmicec.report_active_menu.value
self.old_configTVstate = config.hdmicec.check_tv_state.value or (config.hdmicec.tv_standby_notinputactive.value and config.hdmicec.control_tv_standby.value)
#
config.hdmicec.report_active_menu.addNotifier(self.configReportActiveMenu, initial_call=False)
config.hdmicec.check_tv_state.addNotifier(self.configTVstate, initial_call=False)
config.hdmicec.tv_standby_notinputactive.addNotifier(self.configTVstate, initial_call=False)
config.hdmicec.control_tv_standby.addNotifier(self.configTVstate, initial_call=False)
config.hdmicec.commandline.addNotifier(self.CECcmdstart)
self.checkTVstate('firstrun')
def sendKeyEventQ(self):
if len(self.queueKeyEvent):
(msgaddress, cmd, data) = self.queueKeyEvent.pop(0)
# print("[HdmiCEC][sendKeyEventQ]: msgaddress=%s, cmd=%X, data=%s" % (msgaddress, cmd, data))
eHdmiCEC.getInstance().sendMessage(msgaddress, cmd, data,
len(data))
self.waitKeyEvent.start(
int(config.hdmicec.minimum_send_interval.value), True)
def sendCECMessage(self, cmd, addressvalue, logcmd, delay=0):
eHdmiCEC.getInstance().sendMessage(addressvalue, len(cmd), str(cmd))
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
time.sleep(delay)
def quit(self):
# remove rx routine from list
index = eHdmiCEC.getInstance().messageReceived.get().index(
self.messageReceived)
eHdmiCEC.getInstance().messageReceived.get().pop(index)
# push back Components.HdmiCec to list
if self.queryHdmiCec() is None:
self.activateHdmiCec()
self.close()
def sendMsgQ(self):
if len(self.queue):
(msgaddress, cmd, data) = self.queue.pop(0)
CECcmd = cmdList.get(cmd, "<Polling Message>")
# print("[HdmiCEC][sendMsgQ1]: msgaddress=%s, CECcmd=%s cmd=%X,data=%s \n" % (msgaddress, CECcmd, cmd, data))
eHdmiCEC.getInstance().sendMessage(msgaddress, cmd, data,
len(data))
self.wait.start(int(config.hdmicec.minimum_send_interval.value),
True)
def packDevAddr(self, devicetypeSend=False):
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
if devicetypeSend:
devicetype = eHdmiCEC.getInstance().getDeviceType()
return struct.pack("BBB", int(physicaladdress // 256),
int(physicaladdress % 256), devicetype)
else:
return struct.pack("BB", int(physicaladdress // 256),
int(physicaladdress % 256))
def sendMessages(self, messages):
for message in messages.split(','):
cmd = None
logcmd = None
addressvaluebroadcast = int("0F",16)
addressvalue = int("0",16)
addressvalueav = int("5",16)
wakeupmessage = int("04",16)
standbymessage=int("36",16)
activesourcemessage=int("82",16)
inactivesourcemessage=int("9D",16)
sendkeymessage = int("44",16)
sendkeypwronmessage = int("6D",16)
sendkeypwroffmessage = int("6C",16)
activevumessage=int("85",16)
physaddress1 = int("0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value),16)
physaddress2 = int("0x00",16)
if message == "wakeup":
cmd = struct.pack('B', wakeupmessage)
logcmd = "[HDMI-CEC] ** WakeUpMessage ** send message: %x to address %x" % (wakeupmessage, addressvalue)
elif message == "active":
addressvalue = addressvaluebroadcast
cmd = struct.pack('BBB', activesourcemessage,physaddress1,physaddress2)
logcmd = "[HDMI-CEC] ** ActiveSourceMessage ** send message: %x:%x:%x to address %x" % (activesourcemessage,physaddress1,physaddress2,addressvalue)
elif message == "standby":
cmd = struct.pack('B', standbymessage)
logcmd = "[HDMI-CEC] ** StandByMessage ** send message: %x to address %x" % (standbymessage, addressvalue)
elif message == "inactive":
addressvalue = addressvaluebroadcast
cmd = struct.pack('BBB', inactivesourcemessage,physaddress1,physaddress2)
logcmd = "[HDMI-CEC] ** InActiveSourceMessage ** send message: %x:%x:%x to address %x" % (inactivesourcemessage,physaddress1,physaddress2,addressvalue)
elif message == "avpwron":
cmd = struct.pack('BB', sendkeymessage,sendkeypwronmessage)
addressvalue = addressvalueav
logcmd = "[HDMI-CEC] ** Power on A/V ** send message: %x:%x to address %x" % (sendkeymessage, sendkeypwronmessage, addressvalue)
elif message == "avdeeppwroff":
cmd = struct.pack('BB',sendkeymessage,sendkeypwroffmessage)
addressvalue = addressvalueav
logcmd = "[HDMI-CEC] ** Standby A/V (Deepstandby)** send message: %x:%x to address %x" % (sendkeymessage,sendkeypwroffmessage, addressvalue)
elif message == "avpwroff":
addressvalue = addressvalueav
cmd = struct.pack('BB',sendkeymessage,sendkeypwroffmessage)
logcmd = "[HDMI-CEC] ** Standby A/V ** send message: %x:%x to address %x" % (sendkeymessage,sendkeypwroffmessage, addressvalue)
elif message == "activevu":
addressvalue = addressvaluebroadcast
cmd = struct.pack('B', activevumessage)
logcmd = "[HDMI-CEC] ** Active VU Message ** send message: %x to address %x" % (activevumessage,addressvalue)
if cmd:
eHdmiCEC.getInstance().sendMessage(addressvalue, len(cmd), str(cmd))
time.sleep(1)
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
def __init__(self, session):
Screen.__init__(self, session)
self.setup_title = _("HdmiTest")
self.HDMICEC = None
for routine in eHdmiCEC.getInstance().messageReceived.get():
if str(routine).find("Components.HdmiCec.HdmiCec"):
index = eHdmiCEC.getInstance().messageReceived.get().index(
routine)
self.HDMICEC = eHdmiCEC.getInstance().messageReceived.get(
).pop(index)
self.activateHdmiCec()
self['address'] = Label()
self['sendto'] = Label()
self.mainMenu()
self.onChangedEntry = []
ConfigListScreen.__init__(self,
self.HdmiTestMenuList,
session=session,
on_change=self.changedEntry)
self["actions"] = ActionMap(
["SetupActions", "ColorActions", "NumberActions", "MenuActions"], {
"cancel": self.quit,
"green": self.send,
"ok": self.send,
"red": self.quit,
"blue": self.wakeup,
"yellow": self.rxMonitor,
"0": self.standbyN,
"1": self.wakeupN,
"5": self.clear,
"7": self.active_sourceN,
"9": self.inactive_sourceN,
"menu": self.options,
}, -2)
self["key_green"] = Label(_("Send"))
self["key_red"] = Label(_("Cancel"))
self["key_yellow"] = Label(_("Monitor"))
self["key_blue"] = Label(_("Wakeup TV"))
self["help"] = Label(
_("'0/1'\tStandby/WakeUp\n'5'\tClear\n'7/9'\tSource active/inactive"
))
self["ltx"] = Label(_("Tx:"))
self["lrx"] = Label(_("Rx:"))
self['txtext'] = Label()
self['rxtext'] = Label()
self.txline = 0
self.rxline = 0
self.onLayoutFinish.append(self.layoutFinished)
def setData(self, devicetypeSend=False):
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
if devicetypeSend:
devicetype = eHdmiCEC.getInstance().getDeviceType()
return str(
struct.pack('BBB', int(physicaladdress / 256),
int(physicaladdress % 256), devicetype))
return str(
struct.pack('BB', int(physicaladdress / 256),
int(physicaladdress % 256)))
def keyOk(self):
cmd = None
logcmd = None
if self["config"].getCurrent() == self.hdmiavvolup:
address = int("5",16)
cecmessage = int("44",16)
cecmessagetwo = int("41",16)
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif self["config"].getCurrent() == self.hdmiavvoldown:
address = int("5",16)
cecmessage = int("44",16)
cecmessagetwo = int("42",16)
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif self["config"].getCurrent() == self.hdmiavvolmute:
address = int("5",16)
cecmessage = int("44",16)
cecmessagetwo = int("43",16)
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif self["config"].getCurrent() == self.hdmiavpwron:
address = int("5",16)
cecmessage = int("44",16)
cecmessagetwo = int("6D",16)
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif self["config"].getCurrent() == self.hdmiavpwroff:
address = int("5",16)
cecmessage = int("44",16)
cecmessagetwo = int("6C",16)
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif self["config"].getCurrent() == self.hdmitvpwroff:
address = int("0",16)
cecmessage = int("36",16)
cmd = struct.pack('B',cecmessage)
logcmd = "[HDMI-CEC] send cec message %x to %x" % (cecmessage,address)
elif self["config"].getCurrent() == self.hdmitvpwron:
address = int("0",16)
cecmessage = int("04",16)
cmd = struct.pack('B',cecmessage)
logcmd = "[HDMI-CEC] send cec message %x to %x" % (cecmessage,address)
else:
ConfigListScreen.keySave(self)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
messagecmd = int("45",16)
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
def __init__(self):
if config.hdmicec.enabled.value:
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.queue = []
self.messages = []
self.handleTimer = eTimer()
self.stateTimer = eTimer()
self.stateTimer.callback.append(self.stateTimeout)
self.repeatTimer = eTimer()
self.repeatTimer.callback.append(self.repeatMessages)
self.repeatCounter = 0
self.messageCounter = 0
self.what = ''
self.tv_lastrequest = ''
self.tv_powerstate = 'unknown'
self.tv_skip_messages = False
self.activesource = False
self.firstrun = True
self.sethdmipreemphasis()
self.checkifPowerupWithoutWakingTv(
) # initially write 'False' to file, see below
eHdmiCEC.getInstance().messageReceived.get().append(
self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby,
initial_call=False)
self.setFixedPhysicalAddress(
config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(
self.configVolumeForwarding, initial_call=False)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
config.hdmicec.report_active_menu.addNotifier(
self.configReportActiveMenu, initial_call=False)
config.hdmicec.check_tv_state.addNotifier(self.configTVstate,
initial_call=False)
config.hdmicec.tv_standby_notinputactive.addNotifier(
self.configTVstate, initial_call=False)
config.hdmicec.control_tv_standby.addNotifier(self.configTVstate,
initial_call=False)
self.checkTVstate('firstrun')
def autostart(reason, **kwargs):
global session
if kwargs.has_key("session") and reason == 0:
if config.hdmicec.enabled.value:
session = kwargs["session"]
if config.hdmicec.avvolumecontrol.value:
## from InfoBarGenerics.py
eActionMap.getInstance().bindAction('', -0x7FFFFFFF, volumekeyPressed)
##
eHdmiCEC.getInstance().messageReceived.get().append(messageReceived)
eHdmiCEC.getInstance().messageReceivedKey.get().append(messageReceivedKey)
def hdmi1(self):
try:
from enigma import eHdmiCEC
cmd = struct.pack('BBB', int("82", 16), int("10", 16), 0)
addressvaluebroadcast = int("0F", 16)
eHdmiCEC.getInstance().sendMessage(addressvaluebroadcast, len(cmd),
str(cmd))
cmd = struct.pack('B', int("85", 16))
eHdmiCEC.getInstance().sendMessage(addressvaluebroadcast, len(cmd),
str(cmd))
except:
pass
def sendMessages(self, address, messages):
for message in messages.split(','):
cmd = None
if message == "wakeup":
cmd = struct.pack('B', 0x04)
elif message == "active":
cmd = struct.pack('B', 0x82)
elif message == "standby":
cmd = struct.pack('B', 0x36)
elif message == "inactive":
cmd = struct.pack('B', 0x9e)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
def sendMessages(self, address, messages):
for message in messages.split(','):
cmd = None
if message == "wakeup":
cmd = struct.pack('B', 0x04)
elif message == "active":
cmd = struct.pack('B', 0x82)
elif message == "standby":
cmd = struct.pack('B', 0x36)
elif message == "inactive":
cmd = struct.pack('B', 0x9e)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
def address2data(self, full=False):
if cfg.realphysicaladdress.value:
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
hi = int(physicaladdress / 256)
lo = int(physicaladdress % 256)
else:
hi = 16 * int(cfg.hh.value) + int(cfg.hl.value)
lo = 16 * int(cfg.lh.value) + int(cfg.ll.value)
if full:
devicetype = eHdmiCEC.getInstance().getDeviceType()
return str(struct.pack('BBB', hi, lo, devicetype))
return str(struct.pack('BB', hi, lo))
def __init__(self):
try:
if HdmiCec.instance:
raise AssertionError("only one HdmiCec instance is allowed!")
except:
pass
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.waitKeyEvent = eTimer()
self.waitKeyEvent.timeout.get().append(self.sendKeyEvent)
self.queueKeyEvent = []
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
self.delay = eTimer()
self.delay.timeout.get().append(self.sendStandbyMessages)
self.useStandby = True
self.handlingStandbyFromTV = False
eHdmiCEC.getInstance().messageReceived.get().append(
self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby,
initial_call=False)
self.setFixedPhysicalAddress(
config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
self.wakeup_from_tv = False
eActionMap.getInstance().bindAction('', -sys.maxsize - 1,
self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(
self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.enabled.value:
if config.hdmicec.report_active_menu.value:
if config.hdmicec.report_active_source.value and NavigationInstance.instance and not NavigationInstance.instance.isRestartUI(
):
self.sendMessage(0, "sourceinactive")
self.sendMessage(0, "menuactive")
if config.hdmicec.handle_deepstandby_events.value and (
not getFPWasTimerWakeup() or
(config.usage.startup_to_standby.value == "no"
and config.misc.prev_wakeup_time_type.value == 3)):
self.onLeaveStandby()
def autostart(reason, **kwargs):
global session
if kwargs.has_key("session") and reason == 0:
if config.hdmicec.enabled.value:
session = kwargs["session"]
if config.hdmicec.avvolumecontrol.value:
## from InfoBarGenerics.py
eActionMap.getInstance().bindAction('', -0x7FFFFFFF,
volumekeyPressed)
##
eHdmiCEC.getInstance().messageReceived.get().append(
messageReceived)
eHdmiCEC.getInstance().messageReceivedKey.get().append(
messageReceivedKey)
def __init__(self):
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
eHdmiCEC.getInstance().messageReceived.get().append(
self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby,
initial_call=False)
self.setFixedPhysicalAddress(
config.hdmicec.fixed_physical_address.value)
self.logicaladdress = eHdmiCEC.getInstance().getLogicalAddress()
self.saveVolUp = None
self.saveVolDown = None
self.saveVolMute = None
self.volumeForwardingDestination = 0
config.hdmicec.volume_forwarding.addNotifier(
self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
uptime = float(open("/proc/uptime", "r").read().split()[0])
if config.hdmicec.enabled.value and config.hdmicec.handle_deepstandby_events.value and uptime < 120:
filename = Directories.resolveFilename(Directories.SCOPE_CONFIG,
"timers.xml")
try:
doc = xml.etree.cElementTree.parse(filename)
except:
doc = None
if doc:
root = doc.getroot()
for timer in root.findall("timer"):
begin = int(timer.get("begin"))
disabled = long(timer.get("disabled") or "0")
justplay = long(timer.get("justplay") or "0")
always_zap = long(timer.get("always_zap") or "0")
if begin < time() or begin > time(
) + 360 or disabled or justplay or always_zap:
continue
if Standby.inStandby is None:
Notifications.AddNotification(Standby.Standby)
return
self.onLeaveStandby()
def __init__(self):
assert HdmiCec.instance is None, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendMsgQ)
self.queue = [
] # if config.hdmicec.minimum_send_interval.value != "0" queue send message -> (sendMsgQ)
self.waitKeyEvent = eTimer()
self.waitKeyEvent.timeout.get().append(self.sendKeyEventQ)
self.queueKeyEvent = [
] # if config.hdmicec.minimum_send_interval.value != "0" queue key event -> sendKeyEventQ
self.repeat = eTimer()
self.repeat.timeout.get().append(self.sendWakeupMessages)
self.delay = eTimer()
self.delay.timeout.get().append(self.sendStandbyMessages)
self.useStandby = True
self.handlingStandbyFromTV = False
if config.hdmicec.enabled.value and config.hdmicec.fixed_physical_address.value[
1:3] != ".0":
print("[HdmiCEC][init]phsyical address changed by setup value:",
config.hdmicec.fixed_physical_address.value)
setFixedPhysicalAddress(
config.hdmicec.fixed_physical_address.value)
else:
print("[HdmiCEC][init] no set physical address ")
setFixedPhysicalAddress(
"0.0.0.0"
) # no fixed physical address send 0 to eHdmiCec C++ driver
eHdmiCEC.getInstance().messageReceived.get().append(
self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
# config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call=False)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
self.wakeup_from_tv = False
eActionMap.getInstance().bindAction("", -maxsize - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(
self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.enabled.value:
if config.hdmicec.report_active_menu.value:
if config.hdmicec.report_active_source.value and NavigationInstance.instance and not NavigationInstance.instance.isRestartUI(
):
self.sendMessage(0, "sourceinactive")
self.sendMessage(0, "menuactive")
if config.hdmicec.handle_deepstandby_events.value and not getFPWasTimerWakeup(
):
self.onLeaveStandby()
def __init__(self):
if config.hdmicec.enabled.value:
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.queue = []
self.messages = []
self.handleTimer = eTimer()
self.stateTimer = eTimer()
self.stateTimer.callback.append(self.stateTimeout)
self.repeatTimer = eTimer()
self.repeatTimer.callback.append(self.repeatMessages)
self.repeatCounter = 0
self.what = ''
self.tv_lastrequest = ''
self.tv_powerstate = 'unknown'
self.tv_skip_messages = False
self.activesource = False
self.firstrun = True
self.standbytime = 0
self.sethdmipreemphasis()
self.checkifPowerupWithoutWakingTv() # initially write 'False' to file, see below
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding, initial_call = False)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
#workaround for needless messages after cancel settings
self.old_configReportActiveMenu = config.hdmicec.report_active_menu.value
self.old_configTVstate = config.hdmicec.check_tv_state.value or (config.hdmicec.tv_standby_notinputactive.value and config.hdmicec.control_tv_standby.value)
#
config.hdmicec.report_active_menu.addNotifier(self.configReportActiveMenu, initial_call = False)
config.hdmicec.check_tv_state.addNotifier(self.configTVstate, initial_call = False)
config.hdmicec.tv_standby_notinputactive.addNotifier(self.configTVstate, initial_call = False)
config.hdmicec.control_tv_standby.addNotifier(self.configTVstate, initial_call = False)
self.checkTVstate('firstrun')
def hdmiStandby(self):
try:
import Components.HdmiCec
Components.HdmiCec.hdmi_cec.standbyMessages()
except:
pass
try:
from enigma import eHdmiCEC
addressvalue = int("0", 16)
standbymessage = int("36", 16)
cmd = struct.pack('B', standbymessage)
eHdmiCEC.getInstance().sendMessage(addressvalue, len(cmd),
str(cmd))
print "AQPlayer go Standby"
except:
pass
def activeSource(self):
if config.hdmicec.enabled.value is True:
physadress1 = "0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value)
physadress2 = "0x00"
cecmessage = int("0x82", 16)
address = int("0x0F", 16)
valuethree = int(physadress1, 16)
valuefour = int(physadress2, 16)
cmd = struct.pack("BBB", cecmessage, valuethree, valuefour)
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
if config.hdmicec.enabletvrc.value:
cecmessage = int("0x8E", 16)
address = int("0", 16)
valuethree = int("0", 16)
cmd = struct.pack("BB", cecmessage, valuethree)
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
def __init__(self): assert not HdmiCec.instance, "only one HdmiCec instance is allowed!" HdmiCec.instance = self eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived) config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False) config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False) self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.getValue()) self.volumeForwardingEnabled = False self.volumeForwardingDestination = 0 eRCInput.getInstance().pyKeyEvent.get().append(self.keyEvent) config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding) if config.hdmicec.handle_deepstandby_events.getValue(): if not getFPWasTimerWakeup(): self.wakeupMessages()
def activeSource(self):
if config.hdmicec.enabled.value is True:
physadress1 = "0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value)
physadress2 = "0x00"
cecmessage = int('0x82',16)
address = int('0x0F',16)
valuethree = int(physadress1,16)
valuefour = int(physadress2,16)
cmd = struct.pack('BBB',cecmessage,valuethree,valuefour)
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
if config.hdmicec.enabletvrc.value:
cecmessage = int('0x8E',16)
address = int('0',16)
valuethree = int('0',16)
cmd = struct.pack('BB',cecmessage,valuethree)
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
def CECwritedebug(self, debugtext, debugprint = False):
if debugprint and not config.hdmicec.debug.value:
print debugtext
return
log_path = config.crash.debug_path.value
if pathExists(log_path):
stat = os.statvfs(log_path)
disk_free = stat.f_bavail * stat.f_bsize / 1024
if self.disk_full:
self.start_log = True
if not self.disk_full and disk_free < 500:
print "[HdmiCec] write debug file failed - disk full!"
self.disk_full = True
return
elif not self.disk_full and disk_free < 1000:
self.disk_full = True
elif disk_free >= 1000:
self.disk_full = False
else:
return
now = datetime.datetime.now()
debugfile = os.path.join(log_path, now.strftime("Enigma2-hdmicec-%Y%m%d.log"))
timestamp = now.strftime("%H:%M:%S.%f")[:-2]
debugtext = "%s %s%s\n" %(timestamp, ("[ ] " if debugprint else ""), debugtext.replace("[HdmiCec] ", ""))
if self.start_log:
self.start_log = False
la = eHdmiCEC.getInstance().getLogicalAddress()
debugtext = "%s +++ start logging +++ physical address: %s - logical address: %d - device type: %s\n%s" %(timestamp, self.getPhysicalAddress(), la, CECaddr.get(la, "<unknown>"), debugtext)
if self.disk_full:
debugtext += "%s +++ stop logging +++ disk full!\n" % timestamp
self.CECwritefile(debugfile, "a", debugtext)
else:
print "[HdmiCec] write debug file failed - log path (%s) not found!" %log_path
def hdmiWakeup(self):
try:
import Components.HdmiCec
Components.HdmiCec.hdmi_cec.wakeupMessages()
except:
pass
try:
from enigma import eHdmiCEC
addressvalue = int("0", 16)
wakeupmessage = int("04", 16)
cmd = struct.pack('B', wakeupmessage)
eHdmiCEC.getInstance().sendMessage(addressvalue, len(cmd),
str(cmd))
reactor.callLater(1, self.hdmi1)
print "AQPlayer go Wakeup"
except:
pass
def sendMessage(self, address, message):
cmd = 0
data = ''
if message == "wakeup":
cmd = 0x04
elif message == "sourceactive":
address = 0x0f # use broadcast for active source command
cmd = 0x82
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(
struct.pack('BB', int(physicaladdress / 256),
int(physicaladdress % 256)))
elif message == "standby":
cmd = 0x36
elif message == "sourceinactive":
address = 0x0f # use broadcast for inactive source command
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
cmd = 0x9d
data = str(
struct.pack('BB', int(physicaladdress / 256),
int(physicaladdress % 256)))
elif message == "menuactive":
cmd = 0x8e
data = str(struct.pack('B', 0x00))
elif message == "menuinactive":
cmd = 0x8e
data = str(struct.pack('B', 0x01))
elif message == "givesystemaudiostatus":
cmd = 0x7d
address = 0x05
elif message == "setsystemaudiomode":
cmd = 0x70
address = 0x05
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(
struct.pack('BB', int(physicaladdress / 256),
int(physicaladdress % 256)))
elif message == "osdname":
cmd = 0x47
data = os.uname()[1]
data = data[:14]
elif message == "poweractive":
cmd = 0x90
data = str(struct.pack('B', 0x00))
elif message == "powerinactive":
cmd = 0x90
data = str(struct.pack('B', 0x01))
elif message == "reportaddress":
address = 0x0f # use broadcast address
cmd = 0x84
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
devicetype = eHdmiCEC.getInstance().getDeviceType()
data = str(
struct.pack('BBB', int(physicaladdress / 256),
int(physicaladdress % 256), devicetype))
elif message == "vendorid":
cmd = 0x87
data = '\x00\x00\x00'
if cmd:
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
def __init__(self):
if config.hdmicec.enabled.value:
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.queue = []
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call=False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call=False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.handle_deepstandby_events.value:
if not getFPWasTimerWakeup():
self.wakeupMessages()
dummy = self.checkifPowerupWithoutWakingTv()
def sendCECMessage(self, delay = True):
self.delayTimer.stop()
if len(self.cecmessage_queue):
cmd, addressvalue, logcmd = self.cecmessage_queue.pop(0)
eHdmiCEC.getInstance().sendMessage(addressvalue, len(cmd), str(cmd))
if config.hdmicec.logenabledserial.value:
vtilog("[HDMICEC] "+logcmd)
#if config.hdmicec.logenabledfile.value:
# filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
# system(filelog)
if self.log:
self.log.info( lineno() + logcmd )
if len(self.cecmessage_queue):
if not delay:
messagedelay = float(config.hdmicec.message_delay.value)/10.0
time.sleep(messagedelay)
self.sendCECMessage(delay = False)
else:
self.delayTimer.start(self.delayTimer_intervall, True)
def keyEvent(self, keyCode, keyEvent):
if not self.volumeForwardingEnabled:
return
cmd = 0
data = ''
if keyEvent == 0:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 2:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 1:
if keyCode == 115 or keyCode == 114 or keyCode == 113:
cmd = 0x45
if cmd:
if config.hdmicec.minimum_send_interval.value != "0":
self.queueKeyEvent.append(
(self.volumeForwardingDestination, cmd, data))
if not self.waitKeyEvent.isActive():
self.waitKeyEvent.start(
int(config.hdmicec.minimum_send_interval.value), True)
else:
eHdmiCEC.getInstance().sendMessage(
self.volumeForwardingDestination, cmd, data, len(data))
if config.hdmicec.debug.value in ["2", "3"]:
self.debugTx(self.volumeForwardingDestination, cmd, data)
return 1
else:
return 0
def sendMessage(self, address, message):
cmd = 0
data = ''
if message == "wakeup":
cmd = 0x04
elif message == "sourceactive":
address = 0x0f # use broadcast for active source command
cmd = 0x82
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "standby":
cmd = 0x36
elif message == "sourceinactive":
address = 0x0f # use broadcast for inactive source command
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
cmd = 0x9d
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "menuactive":
cmd = 0x8e
data = str(struct.pack('B', 0x00))
elif message == "menuinactive":
cmd = 0x8e
data = str(struct.pack('B', 0x01))
elif message == "givesystemaudiostatus":
cmd = 0x7d
address = 0x05
elif message == "setsystemaudiomode":
cmd = 0x70
address = 0x05
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "osdname":
cmd = 0x47
data = os.uname()[1]
data = data[:14]
elif message == "poweractive":
cmd = 0x90
data = str(struct.pack('B', 0x00))
elif message == "powerinactive":
cmd = 0x90
data = str(struct.pack('B', 0x01))
elif message == "reportaddress":
address = 0x0f # use broadcast address
cmd = 0x84
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
devicetype = eHdmiCEC.getInstance().getDeviceType()
data = str(struct.pack('BBB', int(physicaladdress/256), int(physicaladdress%256), devicetype))
elif message == "vendorid":
cmd = 0x87
data = '\x00\x00\x00'
elif message == "keypoweron":
cmd = 0x44
data = str(struct.pack('B', 0x6d))
elif message == "keypoweroff":
cmd = 0x44
data = str(struct.pack('B', 0x6c))
if cmd:
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
def __init__(self):
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.logicaladdress = eHdmiCEC.getInstance().getLogicalAddress()
self.saveVolUp = None
self.saveVolDown = None
self.saveVolMute = None
self.volumeForwardingDestination = 0
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
uptime = float(open("/proc/uptime", "r").read().split()[0])
if config.hdmicec.handle_deepstandby_events.value and uptime < 120:
filename = Directories.resolveFilename(Directories.SCOPE_CONFIG, "timers.xml")
try:
doc = xml.etree.cElementTree.parse(filename)
except:
doc = None
if doc:
root = doc.getroot()
for timer in root.findall("timer"):
begin = int(timer.get("begin"))
disabled = long(timer.get("disabled") or "0")
justplay = long(timer.get("justplay") or "0")
always_zap = long(timer.get("always_zap") or "0")
if begin < time() or begin > time() + 360 or disabled or justplay or always_zap:
continue
if Standby.inStandby is None:
Notifications.AddNotification(Standby.Standby)
return
self.onLeaveStandby()
def __init__(self):
config.hdmicec = ConfigSubsection()
config.hdmicec.enabled = ConfigYesNo(default = True)
config.hdmicec.active_source_reply = ConfigYesNo(default = True)
config.hdmicec.standby_message = ConfigSelection(
choices = {
"inactive,standby": _("TV standby"),
"inactive": _("Source inactive"),
"nothing": _("Nothing"),
},
default = "inactive,standby")
config.hdmicec.wakeup_message = ConfigSelection(
choices = {
"wakeup,active": _("TV wakeup"),
"active": _("Source active"),
"nothing": _("Nothing"),
},
default = "wakeup,active")
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.enterStandby, initial_call = False)
def keyDisconnect(self):
cmd = None
logcmd = None
physaddress1 = int("0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value),16)
physaddress2 = int("0x00",16)
address = int('0',16)
cecmessage = int('0x9D',16)
cecmessagetwo = physaddress1
cecmessagethree = physaddress2
cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
def volumekeyPressed(key, flag):
if config.hdmicec.avvolumecontrol.value and config.hdmicec.enabled.value and config.hdmicec.avinput.value != "0":
if key == 113 or key == 114 or key == 115:
address = int("5",16)
cecmessagesendkey = int("44",16)
cecmessagekeyevent = None
if flag == 1:
cecmessagekeybreak = int("45",16)
cmd = struct.pack('B',cecmessagekeybreak)
else:
if key == 113:
cecmessagekeyevent = int("43",16)
elif key == 114:
cecmessagekeyevent = int("42",16)
elif key == 115:
cecmessagekeyevent = int("41",16)
if cecmessagekeyevent:
cmd = struct.pack('BB',cecmessagesendkey,cecmessagekeyevent)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
return 1
return 0
def __init__(self):
assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
HdmiCec.instance = self
self.wait = eTimer()
self.wait.timeout.get().append(self.sendCmd)
self.repeat = eTimer()
self.repeat.timeout.get().append(self.wakeupMessages)
self.queue = []
eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False)
config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False)
self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)
self.volumeForwardingEnabled = False
self.volumeForwardingDestination = 0
eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding)
config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
if config.hdmicec.enabled.value and config.hdmicec.handle_deepstandby_events.value and not getFPWasTimerWakeup():
self.onLeaveStandby()
def keyEvent(self, keyCode, keyEvent):
if not self.volumeForwardingEnabled: return
cmd = 0
data = ''
if keyEvent == 0:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 2:
if keyCode == 115:
cmd = 0x44
data = str(struct.pack('B', 0x41))
if keyCode == 114:
cmd = 0x44
data = str(struct.pack('B', 0x42))
if keyCode == 113:
cmd = 0x44
data = str(struct.pack('B', 0x43))
if keyEvent == 1:
if keyCode == 115 or keyCode == 114 or keyCode == 113:
cmd = 0x45
if cmd:
if config.hdmicec.minimum_send_interval.value != "0":
self.queueKeyEvent.append((self.volumeForwardingDestination, cmd, data))
if not self.waitKeyEvent.isActive():
self.waitKeyEvent.start(int(config.hdmicec.minimum_send_interval.value), True)
else:
eHdmiCEC.getInstance().sendMessage(self.volumeForwardingDestination, cmd, data, len(data))
if config.hdmicec.debug.value in["2","3"]:
self.debugTx(self.volumeForwardingDestination, cmd, data)
return 1
else:
return 0
def getPhysicalAddress(self): physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress() hexstring = '%04x' % physicaladdress return hexstring[0] + '.' + hexstring[1] + '.' + hexstring[2] + '.' + hexstring[3]
def messageReceived(address, message):
logcmd = "[VTI HDMI-CEC] received cec message %x from %x" % (message, address)
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
if config.hdmicec.enabled.value:
from Screens.Standby import inStandby
from Screens.Standby import Standby
cmd = None
cmdtwo = None
addresstwo = None
logcmd = None
logcmdtwo = None
physaddress1 = int("0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value),16)
physaddress2 = int("0x00",16)
addresstv = int("0x00",16)
addressav = int("0x05",16)
addressglobal = int("0x0F",16)
powerstatereportmessage = int("0x90",16)
powerstate = int("0x00",16)
physaddressmessage = int('0x84',16)
devicetypmessage = int('0x03',16)
activesourcemessage = int('0x82',16)
menuonmessage = int('0x8E',16)
menustatemessage = int('0x00',16)
setnamemessage = int('0x47',16)
sendkeymessage = int("44",16)
sendkeypwronmessage = int("6D",16)
sendkeypwroffmessage = int("6C",16)
if message == 0x8f: # request power state
address = addresstv
cecmessage = powerstatereportmessage
cecmessagetwo = powerstate
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif message == 0x83: # request physical address
address = addressglobal
cecmessage = physaddressmessage
cecmessagetwo = physaddress1
cecmessagethree = physaddress2
cecmessagefour = devicetypmessage
cmd = struct.pack('BBBB',cecmessage,cecmessagetwo,cecmessagethree,cecmessagefour)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,cecmessagefour,address)
elif message == 0x86: # request streampath
if (inStandby) and (config.hdmicec.vuwakeup_message.value == "vuwakeup"):
inStandby.Power()
address = addressglobal
cecmessage = activesourcemessage
cecmessagetwo = physaddress1
cecmessagethree = physaddress2
cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
if config.hdmicec.enabletvrc.value:
addresstwo = addresstv
cecmessage = menuonmessage
cecmessagetwo = menustatemessage
cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif message == 0x8d: # request menu state
if config.hdmicec.enabletvrc.value:
address = addresstv
cecmessage = menuonmessage
cecmessagetwo = menustatemessage
cmd = struct.pack('BB',cecmessage,cecmessagetwo)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif message == 0x46: # request device name
address = addresstv
cecmessage = setnamemessage
name_len = len(config.hdmicec.device_name.value)
if name_len == 0:
cecmessagetwo ="VU+"
cmd = struct.pack('B4s',cecmessage,cecmessagetwo)
else:
cecmessagetwo = config.hdmicec.device_name.value
cmd = struct.pack('B'+str(name_len+1)+'s',cecmessage,cecmessagetwo)
logcmd = "[VTI HDMI-CEC] send cec message %x:%s to %x" % (cecmessage,cecmessagetwo,address)
elif message == 0x85: # request active source
if not inStandby:
if config.hdmicec.active_source_reply.value or hdmi_cec.initial_active_source_call == True:
address = addressglobal
cecmessage = activesourcemessage
cecmessagetwo = physaddress1
cecmessagethree = physaddress2
cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
if config.hdmicec.enabletvrc.value:
addresstwo = addresstv
cecmessage = menuonmessage
cecmessagetwo = menustatemessage
cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif inStandby:
if config.hdmicec.vuwakeup_message.value == "vuwakeup":
inStandby.Power()
address = addressglobal
cecmessage = activesourcemessage
cecmessagetwo = physaddress1
cecmessagethree = physaddress2
cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
if config.hdmicec.enabletvrc.value:
addresstwo = addresstv
cecmessage = menuonmessage
cecmessagetwo = menustatemessage
cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
elif message == 0x36:
if config.hdmicec.vustandby_message.value == "vustandby":
if inStandby == None:
logcmd = "[VTI HDMI-CEC] VU+ STB goto standby"
session.open(Standby)
elif config.hdmicec.vustandby_message.value == "vudeepstandby":
import Screens.Standby
logcmd = "[VTI HDMI-CEC] VU+ STB goto deepstandby"
session.open(Screens.Standby.TryQuitMainloop,1)
if inStandby == None:
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
if cmdtwo:
eHdmiCEC.getInstance().sendMessage(addresstwo, len(cmdtwo), str(cmdtwo))
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
if logcmdtwo:
if config.hdmicec.logenabledserial.value:
print logcmdtwo
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmdtwo)
system(filelog)
def sendCmd(self): if len(self.queue): (address, cmd, data) = self.queue.pop(0) eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data)) self.wait.start(int(config.hdmicec.minimum_send_interval.getValue()), True)
def messageReceived(self, message): if config.hdmicec.enabled.getValue(): from Screens.Standby import inStandby cmd = message.getCommand() data = 16 * '\x00' length = message.getData(data, len(data)) if cmd == 0x00: # feature abort if data[0] == '\x44': print 'eHdmiCec: volume forwarding not supported by device %02x'%(message.getAddress()) self.volumeForwardingEnabled = False; elif cmd == 0x46: # request name self.sendMessage(message.getAddress(), 'osdname') elif cmd == 0x7e or cmd == 0x72: # system audio mode status if data[0] == '\x01': self.volumeForwardingDestination = 5; # on: send volume keys to receiver else: self.volumeForwardingDestination = 0; # off: send volume keys to tv if config.hdmicec.volume_forwarding.getValue(): print 'eHdmiCec: volume forwarding to device %02x enabled'% self.volumeForwardingDestination self.volumeForwardingEnabled = True; elif cmd == 0x8f: # request power status if inStandby: self.sendMessage(message.getAddress(), 'powerinactive') else: self.sendMessage(message.getAddress(), 'poweractive') elif cmd == 0x83: # request address self.sendMessage(message.getAddress(), 'reportaddress') elif cmd == 0x86: # request streaming path physicaladdress = ord(data[0]) * 256 + ord(data[1]) ouraddress = eHdmiCEC.getInstance().getPhysicalAddress() if physicaladdress == ouraddress: if not inStandby: if config.hdmicec.report_active_source.getValue(): self.sendMessage(message.getAddress(), 'sourceactive') elif cmd == 0x85: # request active source if not inStandby: if config.hdmicec.report_active_source.getValue(): self.sendMessage(message.getAddress(), 'sourceactive') elif cmd == 0x8c: # request vendor id self.sendMessage(message.getAddress(), 'vendorid') elif cmd == 0x8d: # menu request requesttype = ord(data[0]) if requesttype == 2: # query if inStandby: self.sendMessage(message.getAddress(), 'menuinactive') else: self.sendMessage(message.getAddress(), 'menuactive') # handle standby request from the tv if cmd == 0x36 and config.hdmicec.handle_tv_standby.getValue(): self.standby() # handle wakeup requests from the tv if config.hdmicec.handle_tv_wakeup.getValue(): if cmd == 0x04 and config.hdmicec.tv_wakeup_detection.getValue() == "wakeup": self.wakeup() elif cmd == 0x84 and config.hdmicec.tv_wakeup_detection.getValue() == "tvreportphysicaladdress": if (ord(data[0]) * 256 + ord(data[1])) == 0 and ord(data[2]) == 0: self.wakeup() elif cmd == 0x85 and config.hdmicec.tv_wakeup_detection.getValue() == "sourcerequest": self.wakeup() elif cmd == 0x86 and config.hdmicec.tv_wakeup_detection.getValue() == "streamrequest": physicaladdress = ord(data[0]) * 256 + ord(data[1]) ouraddress = eHdmiCEC.getInstance().getPhysicalAddress() if physicaladdress == ouraddress: self.wakeup() elif cmd == 0x46 and config.hdmicec.tv_wakeup_detection.getValue() == "osdnamerequest": self.wakeup() elif cmd != 0x36 and config.hdmicec.tv_wakeup_detection.getValue() == "activity": self.wakeup()
def sendMessage(self, address, message):
if config.hdmicec.enabled.value:
cmd = 0
data = ''
if message == "wakeup":
cmd = 0x04
elif message == "sourceactive":
address = 0x0f # use broadcast for active source command
cmd = 0x82
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "standby":
cmd = 0x36
elif message == "sourceinactive":
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
cmd = 0x9d
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "menuactive":
cmd = 0x8e
data = str(struct.pack('B', 0x00))
elif message == "menuinactive":
cmd = 0x8e
data = str(struct.pack('B', 0x01))
elif message == "givesystemaudiostatus":
cmd = 0x7d
address = 0x05
elif message == "setsystemaudiomode":
cmd = 0x70
address = 0x05
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "osdname":
cmd = 0x47
data = os.uname()[1]
data = data[:14]
elif message == "poweractive":
cmd = 0x90
data = str(struct.pack('B', 0x00))
elif message == "powerinactive":
cmd = 0x90
data = str(struct.pack('B', 0x01))
elif message == "reportaddress":
address = 0x0f # use broadcast address
cmd = 0x84
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
devicetype = eHdmiCEC.getInstance().getDeviceType()
data = str(struct.pack('BBB', int(physicaladdress/256), int(physicaladdress%256), devicetype))
elif message == "vendorid":
cmd = 0x87
data = '\x00\x00\x00'
elif message == "keypoweron":
cmd = 0x44
data = str(struct.pack('B', 0x6d))
elif message == "keypoweroff":
cmd = 0x44
data = str(struct.pack('B', 0x6c))
if cmd:
if config.hdmicec.minimum_send_interval.value != "0" and message != "standby": # Use no interval time when message is standby. usefull for Panasonic TV
self.queue.append((address, cmd, data))
if not self.wait.isActive():
self.wait.start(int(config.hdmicec.minimum_send_interval.value), True)
else:
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
def sendKeyEvent(self): if len(self.queueKeyEvent): (address, cmd, data) = self.queueKeyEvent.pop(0) eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data)) self.waitKeyEvent.start(int(config.hdmicec.minimum_send_interval.value), True)
def setData(self, devicetypeSend=False):
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
if devicetypeSend:
devicetype = eHdmiCEC.getInstance().getDeviceType()
return str(struct.pack('BBB', int(physicaladdress/256), int(physicaladdress%256), devicetype))
return str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
def messageReceived(self, message): if config.hdmicec.enabled.value: from Screens.Standby import inStandby cmd = message.getCommand() data = 16 * '\x00' length = message.getData(data, len(data)) if config.hdmicec.debug.value != "0": self.debugRx(length, cmd, data) if cmd == 0x00: if length == 0: # only polling message ( it's some as ping ) print "eHdmiCec: received polling message" else: # feature abort if data[0] == '\x44': print 'eHdmiCec: volume forwarding not supported by device %02x'%(message.getAddress()) self.volumeForwardingEnabled = False elif cmd == 0x46: # request name self.sendMessage(message.getAddress(), 'osdname') elif cmd == 0x7e or cmd == 0x72: # system audio mode status if data[0] == '\x01': self.volumeForwardingDestination = 5 # on: send volume keys to receiver else: self.volumeForwardingDestination = 0 # off: send volume keys to tv if config.hdmicec.volume_forwarding.value: print 'eHdmiCec: volume forwarding to device %02x enabled'%(self.volumeForwardingDestination) self.volumeForwardingEnabled = True elif cmd == 0x8f: # request power status if inStandby: self.sendMessage(message.getAddress(), 'powerinactive') else: self.sendMessage(message.getAddress(), 'poweractive') elif cmd == 0x83: # request address self.sendMessage(message.getAddress(), 'reportaddress') elif cmd == 0x86: # request streaming path physicaladdress = ord(data[0]) * 256 + ord(data[1]) ouraddress = eHdmiCEC.getInstance().getPhysicalAddress() if physicaladdress == ouraddress: if not inStandby: if config.hdmicec.report_active_source.value: self.sendMessage(message.getAddress(), 'sourceactive') elif cmd == 0x85: # request active source if not inStandby: if config.hdmicec.report_active_source.value: self.sendMessage(message.getAddress(), 'sourceactive') elif cmd == 0x8c: # request vendor id self.sendMessage(message.getAddress(), 'vendorid') elif cmd == 0x8d: # menu request requesttype = ord(data[0]) if requesttype == 2: # query if inStandby: self.sendMessage(message.getAddress(), 'menuinactive') else: self.sendMessage(message.getAddress(), 'menuactive') elif cmd == 0x90: # receive powerstatus report if ord(data[0]) == 0: # some box is powered self.useStandby = False print "[HDMI-CEC] powered box found" elif cmd == 0x9F: # request get CEC version self.sendMessage(message.getAddress(), 'sendcecversion') # handle standby request from the tv if cmd == 0x36 and config.hdmicec.handle_tv_standby.value: self.standby() # handle wakeup requests from the tv if inStandby and config.hdmicec.handle_tv_wakeup.value: if cmd == 0x04 and config.hdmicec.tv_wakeup_detection.value == "wakeup": self.wakeup() elif cmd == 0x83 and config.hdmicec.tv_wakeup_detection.value == "requestphysicaladdress": self.wakeup() elif cmd == 0x84 and config.hdmicec.tv_wakeup_detection.value == "tvreportphysicaladdress": if (ord(data[0]) * 256 + ord(data[1])) == 0 and ord(data[2]) == 0: self.wakeup() elif cmd == 0x85 and config.hdmicec.tv_wakeup_detection.value == "sourcerequest": self.wakeup() elif cmd == 0x86 and config.hdmicec.tv_wakeup_detection.value == "streamrequest": physicaladdress = ord(data[0]) * 256 + ord(data[1]) ouraddress = eHdmiCEC.getInstance().getPhysicalAddress() if physicaladdress == ouraddress: self.wakeup() elif cmd == 0x8C and config.hdmicec.tv_wakeup_detection.value == "requestvendor": self.wakeup() elif cmd == 0x46 and config.hdmicec.tv_wakeup_detection.value == "osdnamerequest": self.wakeup() elif cmd != 0x36 and config.hdmicec.tv_wakeup_detection.value == "activity": self.wakeup()
def sendMessage(self, address, message):
cmd = 0
data = ''
if message == "wakeup":
cmd = 0x04
elif message == "sourceactive":
address = 0x0f # use broadcast for active source command
cmd = 0x82
data = self.setData()
elif message == "standby":
cmd = 0x36
elif message == "sourceinactive":
cmd = 0x9d
data = self.setData()
elif message == "menuactive":
cmd = 0x8e
data = str(struct.pack('B', 0x00))
elif message == "menuinactive":
cmd = 0x8e
data = str(struct.pack('B', 0x01))
elif message == "givesystemaudiostatus":
cmd = 0x7d
address = 0x05
elif message == "setsystemaudiomode":
cmd = 0x70
address = 0x05
data = self.setData()
elif message == "osdname":
cmd = 0x47
data = os.uname()[1]
data = data[:14]
elif message == "poweractive":
cmd = 0x90
data = str(struct.pack('B', 0x00))
elif message == "powerinactive":
cmd = 0x90
data = str(struct.pack('B', 0x01))
elif message == "reportaddress":
address = 0x0f # use broadcast address
cmd = 0x84
data = self.setData(True)
elif message == "vendorid":
cmd = 0x87
data = '\x00\x00\x00'
elif message == "keypoweron":
cmd = 0x44
data = str(struct.pack('B', 0x6d))
elif message == "keypoweroff":
cmd = 0x44
data = str(struct.pack('B', 0x6c))
elif message == "sendcecversion":
cmd = 0x9E
data = str(struct.pack('B', 0x04)) # v1.3a
elif message == "requestactivesource":
address = 0x0f # use broadcast address
cmd = 0x85
elif message == "getpowerstatus":
self.useStandby = True;
address = 0x0f # use broadcast address => boxes will send info
cmd = 0x8f
if cmd:
if config.hdmicec.minimum_send_interval.value != "0" and message != "standby": # Use no interval time when message is standby. usefull for Panasonic TV
self.queue.append((address, cmd, data))
if not self.wait.isActive():
self.wait.start(int(config.hdmicec.minimum_send_interval.value), True)
else:
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
if config.hdmicec.debug.value in["1","3"]:
self.debugTx(address, cmd, data)
def setFixedPhysicalAddress(self, address): if address != config.hdmicec.fixed_physical_address.value: config.hdmicec.fixed_physical_address.value = address config.hdmicec.fixed_physical_address.save() hexstring = address[0] + address[2] + address[4] + address[6] eHdmiCEC.getInstance().setFixedPhysicalAddress(int(float.fromhex(hexstring)))
def keySend(self):
cmd = None
logcmd = None
addresstmp=config.hdmicec.input_address.value
tmp1=config.hdmicec.input_value1.value
tmp2=config.hdmicec.input_value2.value
tmp3=config.hdmicec.input_value3.value
tmp4=config.hdmicec.input_value4.value
address=int(addresstmp,16)
if address not in range(0,256):
address = 255
if tmp4:
val1=int(tmp1,16)
val2=int(tmp2,16)
val3=int(tmp3,16)
val4=int(tmp4,16)
if val1 not in range(0,256):
val1 = 00
if val2 not in range(0,256):
val2 = 00
if val3 not in range(0,256):
val3 = 00
if val4 not in range(0,256):
val4 = 00
cmd = struct.pack('BBBB',val1,val2,val3,val4)
logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x:%x:%x to address %x" % (val1,val2,val3,val4,address)
else:
if tmp3:
val1=int(tmp1,16)
val2=int(tmp2,16)
val3=int(tmp3,16)
if val1 not in range(0,256):
val1 = 00
if val2 not in range(0,256):
val2 = 00
if val3 not in range(0,256):
val3 = 00
cmd = struct.pack('BBB',val1,val2,val3)
logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x:%x to address %x" % (val1,val2,val3,address)
else:
if tmp2:
val1=int(tmp1,16)
val2=int(tmp2,16)
if val1 not in range(0,256):
val1 = 00
if val2 not in range(0,256):
val2 = 00
cmd = struct.pack('BB',val1,val2)
logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x to address %x" % (val1,val2,address)
else:
val1=int(tmp1,16)
if val1 not in range(0,256):
val1 = 00
cmd = struct.pack('B',val1)
logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x to address %x" % (val1, address)
if cmd:
eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
if logcmd:
if config.hdmicec.logenabledserial.value:
print logcmd
if config.hdmicec.logenabledfile.value:
filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
system(filelog)
def messageReceived(self, message):
if config.hdmicec.enabled.value:
checkstate = self.stateTimer.isActive()
data = 16 * '\x00'
cmd = message.getCommand()
length = message.getData(data, len(data))
address = message.getAddress()
#// workaround for wrong address vom driver (e.g. hd51, message comes from tv -> address is only sometimes 0, dm920, same tv -> address is always 0)
if address > 15:
address = 0
print "[HdmiCec] workaround for wrong received address data enabled"
#//
if cmd == 0x00: # feature abort
if data[0] == '\x44':
print 'eHdmiCec: volume forwarding not supported by device %02x'%(address)
self.volumeForwardingEnabled = False
elif cmd == 0x46: # request name
self.sendMessage(address, 'osdname')
elif cmd in (0x7e, 0x72): # system audio mode status
if data[0] == '\x01':
self.volumeForwardingDestination = 5 # on: send volume keys to receiver
else:
self.volumeForwardingDestination = 0 # off: send volume keys to tv
if config.hdmicec.volume_forwarding.value:
print 'eHdmiCec: volume forwarding to device %02x enabled'% self.volumeForwardingDestination
self.volumeForwardingEnabled = True
elif cmd == 0x8f: # request power status
if Screens.Standby.inStandby:
self.sendMessage(address, 'powerinactive')
else:
self.sendMessage(address, 'poweractive')
elif cmd == 0x83: # request address
self.sendMessage(address, 'reportaddress')
elif cmd == 0x85: # request active source
if not Screens.Standby.inStandby and config.hdmicec.report_active_source.value:
self.sendMessage(address, 'sourceactive')
elif cmd == 0x8c: # request vendor id
self.sendMessage(address, 'vendorid')
elif cmd == 0x8d: # menu request
requesttype = ord(data[0])
if requesttype == 2: # query
if Screens.Standby.inStandby:
self.sendMessage(address, 'menuinactive')
else:
self.sendMessage(address, 'menuactive')
elif address == 0 and cmd == 0x90: # report power state from the tv
if data[0] == '\x00':
self.tv_powerstate = "on"
elif data[0] == '\x01':
self.tv_powerstate = "standby"
elif data[0] == '\x02':
self.tv_powerstate = "get_on"
elif data[0] == '\x03':
self.tv_powerstate = "get_standby"
if checkstate and not self.firstrun:
self.checkTVstate('powerstate')
elif self.firstrun and not config.hdmicec.handle_deepstandby_events.value:
self.firstrun = False
else:
self.checkTVstate()
elif address == 0 and cmd == 0x36: # handle standby request from the tv
if config.hdmicec.handle_tv_standby.value != 'disabled':
self.handleTVRequest('tvstandby')
self.checkTVstate('tvstandby')
elif cmd == 0x80: # routing changed
oldaddress = ord(data[0]) * 256 + ord(data[1])
newaddress = ord(data[2]) * 256 + ord(data[3])
ouraddress = eHdmiCEC.getInstance().getPhysicalAddress()
active = (newaddress == ouraddress)
hexstring = '%04x' % oldaddress
oldaddress = hexstring[0] + '.' + hexstring[1] + '.' + hexstring[2] + '.' + hexstring[3]
hexstring = '%04x' % newaddress
newaddress = hexstring[0] + '.' + hexstring[1] + '.' + hexstring[2] + '.' + hexstring[3]
print "[HdmiCec] routing has changed... from '%s' to '%s' (to our address: %s)" %(oldaddress, newaddress, active)
elif cmd in (0x86, 0x82): # set streaming path, active source changed
newaddress = ord(data[0]) * 256 + ord(data[1])
ouraddress = eHdmiCEC.getInstance().getPhysicalAddress()
active = (newaddress == ouraddress)
if checkstate or self.activesource != active:
if checkstate:
txt = 'our receiver is active source'
else:
txt = 'active source'
if cmd == 0x86: txt = 'streaming path'
txt += ' has changed... to our address'
print '[HdmiCec] %s: %s' %(txt, active)
self.activesource = active
if not checkstate:
if cmd == 0x86 and not Screens.Standby.inStandby and self.activesource:
self.sendMessage(address, 'sourceactive')
if config.hdmicec.report_active_menu.value:
self.sendMessage(0, 'menuactive')
if config.hdmicec.handle_tv_input.value != 'disabled':
self.handleTVRequest('activesource')
self.checkTVstate('changesource')
else:
self.checkTVstate('activesource')
# handle wakeup requests from the tv
wakeup = False
if address == 0 and cmd == 0x44 and data[0] in ('\x40', '\x6D'): # handle wakeup from tv hdmi-cec menu (e.g. panasonic tv apps, viera link)
wakeup = True
elif not checkstate and config.hdmicec.handle_tv_wakeup.value != 'disabled':
if address == 0:
if ((cmd == 0x04 and config.hdmicec.handle_tv_wakeup.value == "wakeup") or
(cmd == 0x85 and config.hdmicec.handle_tv_wakeup.value == "sourcerequest") or
(cmd == 0x46 and config.hdmicec.handle_tv_wakeup.value == "osdnamerequest") or
(cmd != 0x36 and config.hdmicec.handle_tv_wakeup.value == "activity")):
wakeup = True
elif cmd == 0x84 and config.hdmicec.handle_tv_wakeup.value == "tvreportphysicaladdress":
if (ord(data[0]) * 256 + ord(data[1])) == 0 and ord(data[2]) == 0:
wakeup = True
if (cmd == 0x80 and config.hdmicec.handle_tv_wakeup.value == "routingrequest") or (cmd == 0x86 and config.hdmicec.handle_tv_wakeup.value == "streamrequest"):
if active:
wakeup = True
if wakeup:
self.wakeup()
def sendMessage(self, address, message):
if config.hdmicec.enabled.value:
cmd = 0
data = ''
if message == "wakeup":
cmd = 0x04
elif message == "sourceactive":
address = 0x0f # use broadcast address
cmd = 0x82
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "routinginfo":
address = 0x0f # use broadcast address
cmd = 0x81
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "standby":
cmd = 0x36
elif message == "sourceinactive":
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
cmd = 0x9d
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "menuactive":
cmd = 0x8e
data = str(struct.pack('B', 0x00))
elif message == "menuinactive":
cmd = 0x8e
data = str(struct.pack('B', 0x01))
elif message == "givesystemaudiostatus":
cmd = 0x7d
elif message == "setsystemaudiomode":
cmd = 0x70
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
data = str(struct.pack('BB', int(physicaladdress/256), int(physicaladdress%256)))
elif message == "activatesystemaudiomode":
cmd = 0x72
data = str(struct.pack('B', 0x01))
elif message == "deactivatesystemaudiomode":
cmd = 0x72
data = str(struct.pack('B', 0x00))
elif message == "osdname":
cmd = 0x47
data = os.uname()[1]
data = data[:14]
elif message == "poweractive":
cmd = 0x90
data = str(struct.pack('B', 0x00))
elif message == "powerinactive":
cmd = 0x90
data = str(struct.pack('B', 0x01))
elif message == "reportaddress":
address = 0x0f # use broadcast address
cmd = 0x84
physicaladdress = eHdmiCEC.getInstance().getPhysicalAddress()
devicetype = eHdmiCEC.getInstance().getDeviceType()
data = str(struct.pack('BBB', int(physicaladdress/256), int(physicaladdress%256), devicetype))
elif message == "vendorid":
cmd = 0x87
data = '\x00\x00\x00'
elif message == "keypoweron":
cmd = 0x44
data = str(struct.pack('B', 0x6d))
elif message == "keypoweroff":
cmd = 0x44
data = str(struct.pack('B', 0x6c))
elif message == "powerstate":
cmd = 0x8f
if cmd:
if config.misc.DeepStandby.value: # no delay for messages before go in to deep-standby
eHdmiCEC.getInstance().sendMessage(address, cmd, data, len(data))
else:
self.queue.append((address, cmd, data))
if not self.wait.isActive():
self.wait.start(int(config.hdmicec.minimum_send_interval.value), True)
