HDMI CEC Einstellung für VU, Samsung TV und LG AV Receiver

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Leider hab ich keinen Rasperry :S

      Also wenn ich den TV anmache (hab linke Taste der VU Fernbedienung jetzt auf den Samsung eingestellt), geht der LG AV Receiver sofort an....es ist echt verhext. Ja wenn die Werte im log auftauchen, das wäre jetzt das letzte, stimmt.

      Das log landet unter /tmp oder?

    • @IchKannDenken Kannst du mir verraten welcher Wert in der .py für das einschalten des AV Receivers verantwortlich ist?

      Gibt es eine Liste die man quasi abarbeiten kann wo solche Werte vermerkt sind?

      Dann würd ich einfach mal gewisse Werte durchprobieren, neu booten und dann mal schauen ob der AV Reveiver doch noch sich einschalten lässt :8|

    • So dann schauen wir doch mal, ob wir den LG ans fliegen bekommen...
      Aktuell sendet das Plugin entweder die Nachricht 44:65 (Einstellung "normaler" AV) oder 89:06:02 (Einstellung "LG A/V Wakup") an die Adresse 5.
      44:65 ist eine User Remote Action (alsob du auf ner Ferbedienung Power On drückst), 89:06:02 ist eine Herstellerspezifische Nachricht die damals für mein altes LG HT System verwendet wurde.
      Man könnte mal versuchen das Kommando 0x70 an den AV zu senden.
      Ich würde mal testhalber in der plugin.py in der Funktion keyOK(self) den Abschnitt, der verwendet wird um den AV über das Plugin Einstellungsmenü zu starten, ändern:

      Quellcode

      1. elif self["config"].getCurrent() == self.hdmiavpwron:
      2. address = int("5",16)
      3. cecmessage = int("44",16)
      4. cecmessagetwo = int("6D",16)
      5. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      6. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      Das würde ich wie folgt ändern:

      Quellcode

      1. elif self["config"].getCurrent() == self.hdmiavpwron:
      2. address = int("5",16)
      3. cecmessage = int("70",16)
      4. cecmessagetwo = int("10",16)
      5. cecmessagethree = int("0",16)
      6. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      7. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)

      In dem Fall würde er die Nachricht 70:10:00 senden, wobei 10:00 für den HDMI Eingang steht, an dem die VU hängt (müsste also vielleicht noch angepasst werden).
      Laut CEC Spezifikation sollte ein AVR bei der Nachricht 0x70 aus dem Standby kommen.
      Natürlich darauf achten, dass du TAB-Stopps einhältst ;)
      Nach nem GUI Neustart kannst du dann mal schauen, ob die Funktion "AV Einschalten" im Plugin den AVR einschaltet.
      Vorher natürlich die Python Datei sichern.

      Kommandos gibt es gar nicht so viele, ich schau da immer auf cec-o-matic oder in HDMI 1.3a Spezifikation.

    • @IchKannDenken So, es hat nicht funktioniert :/

      Was habe ich gemacht, Ich habe als erstes die HdmiCec.py die du mir gegeben hast, korrekt durch die alte ersetzt. Dies allein hat j nicht geklappt, aber sie trotzdem dort gelassen und nicht wieder durch die originale ersetzt.

      Dann habe ich die entsprechenden Einträge in der plugin.py abgeändert und dann gui reboot gemacht, dann ausgeschaltet (dies klappt ja mit allen Geräten) und nach 10 Sekunden wieder eingeschaltet. Der verfluchte Av Receiver startet nicht mit ?(

      Mit TAB Stops habe ich jetzt nicht gearbeitet, aber ich hab quasi vorhandene Zeilen kopiert und dann entsprechend abgeändert.

      Ich häng die Datei hier mal an, vielleicht habe ich doch was falsch gemacht.

      Spoiler anzeigen

      Quellcode

      1. # -*- coding: utf-8 -*-
      3. # maintainer: <plnick@vuplus-support.org>
      5. #This plugin is free software, you are allowed to
      6. #modify it (if you keep the license),
      7. #but you are not allowed to distribute/publish
      8. #it without source code (this version and your modifications).
      9. #This means you also have to distribute
      10. #source code of your modifications.
      12. import struct
      13. from enigma import eActionMap, eHdmiCEC
      14. from Plugins.Plugin import PluginDescriptor
      15. from Components.ActionMap import ActionMap,NumberActionMap
      16. from Components.config import config, getConfigListEntry, ConfigInteger, ConfigSubsection, ConfigSelection, ConfigText, ConfigYesNo, NoSave, ConfigNothing
      17. from Components.ConfigList import ConfigListScreen
      18. from Components.InputDevice import iInputDevices
      19. from Components.Sources.StaticText import StaticText
      20. from Screens.Screen import Screen
      21. from Screens.MessageBox import MessageBox
      22. from Tools import Notifications
      23. from HdmiCec import HdmiCec
      24. from os import system
      25. from __init__ import _
      27. hdmi_cec = HdmiCec()
      29. class HdmiCecPlugin(Screen,ConfigListScreen):
      30. skin = """
      31. <screen name="HDMICEC" position="center,center" size="700,400" title="VTI HDMI-CEC Plugin" >
      32. <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
      33. <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
      34. <ePixmap pixmap="skin_default/buttons/yellow.png" position="280,0" size="140,40" alphatest="on" />
      35. <ePixmap pixmap="skin_default/buttons/blue.png" position="420,0" size="140,40" alphatest="on" />
      36. <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" foregroundColor="#ececec" backgroundColor="#9f1313" transparent="1" />
      37. <widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" foregroundColor="#ececec" backgroundColor="#1f771f" transparent="1" />
      38. <widget source="key_yellow" render="Label" position="280,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" foregroundColor="#ececec" backgroundColor="#1f771f" transparent="1" />
      39. <widget source="key_blue" render="Label" position="420,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" foregroundColor="#ececec" backgroundColor="#1f771f" transparent="1" />
      40. <widget name="config" zPosition="2" position="5,50" size="650,300" scrollbarMode="showOnDemand" transparent="1" />
      41. </screen>"""
      42. def __init__(self, session):
      43. Screen.__init__(self, session)
      45. config.hdmicec.input_address = ConfigText(default = "0", visible_width = 50, fixed_size = False)
      46. config.hdmicec.input_value1 = ConfigText(default = "0", visible_width = 50, fixed_size = False)
      47. config.hdmicec.input_value2 = ConfigText(default = "", visible_width = 50, fixed_size = False)
      48. config.hdmicec.input_value3 = ConfigText(default = "", visible_width = 50, fixed_size = False)
      49. config.hdmicec.input_value4 = ConfigText(default = "", visible_width = 50, fixed_size = False)
      50. config.hdmicec.avvolup = NoSave(ConfigNothing())
      51. config.hdmicec.avvoldown = NoSave(ConfigNothing())
      52. config.hdmicec.avvolmute = NoSave(ConfigNothing())
      53. config.hdmicec.avpwroff = NoSave(ConfigNothing())
      54. config.hdmicec.avpwron = NoSave(ConfigNothing())
      55. config.hdmicec.tvpwroff = NoSave(ConfigNothing())
      56. config.hdmicec.tvpwron = NoSave(ConfigNothing())
      57. self["key_red"] = StaticText(_("Close"))
      58. self["key_green"] = StaticText(_("Save"))
      59. self["key_yellow"] = StaticText(_("Connect"))
      60. self["key_blue"] = StaticText(_("Disconnect"))
      61. self["shortcuts"] = ActionMap(["ShortcutActions", "SetupActions", "NumberActions" ],
      62. {
      63. "ok": self.keyOk,
      64. "cancel": self.keyCancel,
      65. "red": self.keyCancel,
      66. "green": self.keySave,
      67. "yellow": self.keyConnect,
      68. "blue": self.keyDisconnect,
      69. }, -2)
      70. self.list = []
      71. ConfigListScreen.__init__(self, self.list,session = session)
      72. self.createSetup()
      74. def createSetup(self):
      75. self.list = []
      76. self.hdmienabled = getConfigListEntry(_(_("HDMI CEC enabled:")), config.hdmicec.enabled)
      77. self.hdmidisabledtimerwakeup = getConfigListEntry(_(_("Disable power on actions for timer:")), config.hdmicec.disabletimerwakeup)
      78. self.hdmiactivesourcereply = getConfigListEntry(_(_("Active Source Reply On:")), config.hdmicec.active_source_reply)
      79. self.hdmitvstandby = getConfigListEntry(_("VU+ standby => TV activity:"), config.hdmicec.standby_message)
      80. self.hdmitvdeepstandby = getConfigListEntry(_("VU+ deepstandby => TV activity:"), config.hdmicec.deepstandby_message)
      81. self.hdmitvwakeupstandby = getConfigListEntry(_("VU+ on from standby => TV activity:"), config.hdmicec.wakeupstandby_message)
      82. self.hdmitvwakeupdeepstandby = getConfigListEntry(_("VU+ on from deepstandby => TV activity:"), config.hdmicec.wakeupdeepstandby_message)
      83. self.hdmivustandby = getConfigListEntry(_("TV standby => VU+ activity:"), config.hdmicec.vustandby_message)
      84. self.hdmivuwakeup = getConfigListEntry(_("TV on => VU+ activity:"), config.hdmicec.vuwakeup_message)
      85. self.hdmitvinput = getConfigListEntry(_("Choose TV HDMI input:"), config.hdmicec.tvinput)
      86. self.hdmiavinput = getConfigListEntry(_("Choose A/V-Receiver HDMI input:"), config.hdmicec.avinput)
      87. self.hdmiavvolumecontrol = getConfigListEntry(_("Use A/V-Receiver for volume control:"), config.hdmicec.avvolumecontrol)
      88. self.hdmiavvolup = getConfigListEntry(_("A/V-Receiver volume up:"), config.hdmicec.avvolup)
      89. self.hdmiavvoldown = getConfigListEntry(_("A/V-Receiver volume down:"), config.hdmicec.avvoldown)
      90. self.hdmiavvolmute = getConfigListEntry(_("A/V-Receiver toggle mute:"), config.hdmicec.avvolmute)
      91. self.hdmiavpwron = getConfigListEntry(_("A/V-Receiver power on:"), config.hdmicec.avpwron)
      92. self.hdmiavpwroff = getConfigListEntry(_("A/V-Receiver power off:"), config.hdmicec.avpwroff)
      93. self.hdmitvpwron = getConfigListEntry(_("TV power on:"), config.hdmicec.tvpwron)
      94. self.hdmitvpwroff = getConfigListEntry(_("TV power off:"), config.hdmicec.tvpwroff)
      95. self.hdmienabletvrc = getConfigListEntry(_("Use TV remotecontrol:"), config.hdmicec.enabletvrc)
      96. self.hdmidevicename = getConfigListEntry(_("Set VU+ device name:"), config.hdmicec.device_name)
      97. self.hdmiinputaddress = getConfigListEntry(_("Address (0~FF):"), config.hdmicec.input_address)
      98. self.hdmiinputvalue1 = getConfigListEntry("Value 1 (message):", config.hdmicec.input_value1)
      99. self.hdmiinputvalue2 = getConfigListEntry("Value 2 (optional):", config.hdmicec.input_value2)
      100. self.hdmiinputvalue3 = getConfigListEntry("Value 3 (optional):", config.hdmicec.input_value3)
      101. self.hdmiinputvalue4 = getConfigListEntry("Value 4 (optional):", config.hdmicec.input_value4)
      102. self.hdmilogenabledfile = getConfigListEntry(_("Enable debug output to file :"), config.hdmicec.logenabledfile)
      103. self.hdmilogenabledserial = getConfigListEntry(_("Enable debug output to console :"), config.hdmicec.logenabledserial)
      104. self.hdmimessagedelay = getConfigListEntry(_("Delay between CEC messages :"), config.hdmicec.message_delay)
      105. # only used for testing
      106. # self.list.append( self.hdmiinputaddress )
      107. # self.list.append( self.hdmiinputvalue1 )
      108. # self.list.append( self.hdmiinputvalue2 )
      109. # self.list.append( self.hdmiinputvalue3 )
      110. # self.list.append( self.hdmiinputvalue4 )
      111. # self.list.append( self.hdmilogenabledfile )
      112. # end testing
      113. self.list.append( self.hdmienabled )
      114. if config.hdmicec.enabled.value is True:
      115. self.list.append( self.hdmidevicename )
      116. self.list.append( self.hdmitvinput )
      117. self.list.append( self.hdmiavinput )
      118. self.list.append( self.hdmivuwakeup )
      119. self.list.append( self.hdmivustandby )
      120. self.list.append( self.hdmitvwakeupstandby )
      121. self.list.append( self.hdmitvwakeupdeepstandby )
      122. self.list.append( self.hdmitvstandby )
      123. self.list.append( self.hdmitvdeepstandby )
      124. self.list.append( self.hdmidisabledtimerwakeup )
      125. self.list.append( self.hdmienabletvrc )
      126. self.list.append( self.hdmimessagedelay )
      127. if config.hdmicec.avinput.value is not "0":
      128. self.list.append( self.hdmiavvolumecontrol )
      129. self.list.append( self.hdmiavvolup )
      130. self.list.append( self.hdmiavvoldown )
      131. self.list.append( self.hdmiavvolmute )
      132. self.list.append( self.hdmiavpwron )
      133. self.list.append( self.hdmiavpwroff )
      134. self.list.append( self.hdmitvpwron )
      135. self.list.append( self.hdmitvpwroff )
      136. self.list.append( self.hdmiactivesourcereply )
      137. self.list.append( self.hdmilogenabledserial )
      138. self.list.append( self.hdmilogenabledfile )
      139. self["config"].list = self.list
      140. self["config"].l.setList(self.list)
      142. def keyDisconnect(self):
      143. cmd = None
      144. logcmd = None
      145. physaddress1 = int("0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value),16)
      146. physaddress2 = int("0x00",16)
      147. address = int('0',16)
      148. cecmessage = int('0x9D',16)
      149. cecmessagetwo = physaddress1
      150. cecmessagethree = physaddress2
      151. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      152. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
      154. if cmd:
      155. eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
      157. if logcmd:
      158. if config.hdmicec.logenabledserial.value:
      159. print logcmd
      160. if config.hdmicec.logenabledfile.value:
      161. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      162. system(filelog)
      164. # only used for testing
      165. def keySend(self):
      166. cmd = None
      167. logcmd = None
      168. addresstmp=config.hdmicec.input_address.value
      169. tmp1=config.hdmicec.input_value1.value
      170. tmp2=config.hdmicec.input_value2.value
      171. tmp3=config.hdmicec.input_value3.value
      172. tmp4=config.hdmicec.input_value4.value
      173. address=int(addresstmp,16)
      174. if address not in range(0,256):
      175. address = 255
      176. if tmp4:
      177. val1=int(tmp1,16)
      178. val2=int(tmp2,16)
      179. val3=int(tmp3,16)
      180. val4=int(tmp4,16)
      181. if val1 not in range(0,256):
      182. val1 = 00
      183. if val2 not in range(0,256):
      184. val2 = 00
      185. if val3 not in range(0,256):
      186. val3 = 00
      187. if val4 not in range(0,256):
      188. val4 = 00
      189. cmd = struct.pack('BBBB',val1,val2,val3,val4)
      190. logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x:%x:%x to address %x" % (val1,val2,val3,val4,address)
      191. else:
      193. if tmp3:
      194. val1=int(tmp1,16)
      195. val2=int(tmp2,16)
      196. val3=int(tmp3,16)
      197. if val1 not in range(0,256):
      198. val1 = 00
      199. if val2 not in range(0,256):
      200. val2 = 00
      201. if val3 not in range(0,256):
      202. val3 = 00
      203. cmd = struct.pack('BBB',val1,val2,val3)
      204. logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x:%x to address %x" % (val1,val2,val3,address)
      205. else:
      207. if tmp2:
      208. val1=int(tmp1,16)
      209. val2=int(tmp2,16)
      210. if val1 not in range(0,256):
      211. val1 = 00
      212. if val2 not in range(0,256):
      213. val2 = 00
      214. cmd = struct.pack('BB',val1,val2)
      215. logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x:%x to address %x" % (val1,val2,address)
      216. else:
      217. val1=int(tmp1,16)
      218. if val1 not in range(0,256):
      219. val1 = 00
      220. cmd = struct.pack('B',val1)
      221. logcmd = "[VTI HDMI-CEC] ** Test Message ** Send message value: %x to address %x" % (val1, address)
      223. if cmd:
      224. eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
      226. if logcmd:
      227. if config.hdmicec.logenabledserial.value:
      228. print logcmd
      229. if config.hdmicec.logenabledfile.value:
      230. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      231. system(filelog)
      232. # end testing
      234. def keyOk(self):
      235. cmd = None
      236. logcmd = None
      237. if self["config"].getCurrent() == self.hdmiavvolup:
      238. address = int("5",16)
      239. cecmessage = int("44",16)
      240. cecmessagetwo = int("41",16)
      241. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      242. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      243. elif self["config"].getCurrent() == self.hdmiavvoldown:
      244. address = int("5",16)
      245. cecmessage = int("44",16)
      246. cecmessagetwo = int("42",16)
      247. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      248. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      249. elif self["config"].getCurrent() == self.hdmiavvolmute:
      250. address = int("5",16)
      251. cecmessage = int("44",16)
      252. cecmessagetwo = int("43",16)
      253. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      254. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      255. elif self["config"].getCurrent() == self.hdmiavpwron:
      256. address = int("5",16)
      257. cecmessage = int("70",16)
      258. cecmessagetwo = int("10",16)
      259. cecmessagethree = int("0",16)
      260. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      261. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
      262. elif self["config"].getCurrent() == self.hdmiavpwroff:
      263. address = int("5",16)
      264. cecmessage = int("44",16)
      265. cecmessagetwo = int("6C",16)
      266. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      267. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      268. elif self["config"].getCurrent() == self.hdmitvpwroff:
      269. address = int("0",16)
      270. cecmessage = int("36",16)
      271. cmd = struct.pack('B',cecmessage)
      272. logcmd = "[VTI HDMI-CEC] send cec message %x to %x" % (cecmessage,address)
      273. elif self["config"].getCurrent() == self.hdmitvpwron:
      274. address = int("0",16)
      275. cecmessage = int("04",16)
      276. cmd = struct.pack('B',cecmessage)
      277. logcmd = "[VTI HDMI-CEC] send cec message %x to %x" % (cecmessage,address)
      278. else:
      279. ConfigListScreen.keySave(self)
      280. if cmd:
      281. eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
      283. if logcmd:
      284. if config.hdmicec.logenabledserial.value:
      285. print logcmd
      286. if config.hdmicec.logenabledfile.value:
      287. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      288. system(filelog)
      290. def keyConnect(self):
      291. hdmi_cec.activateSourceTimer()
      292. address = 0
      293. message = 0x85
      294. messageReceived(address, message)
      296. def keyLeft(self):
      297. ConfigListScreen.keyLeft(self)
      298. if self["config"].getCurrent() == self.hdmienabled:
      299. self.createSetup()
      300. if self["config"].getCurrent() == self.hdmiavinput:
      301. self.createSetup()
      303. def keyRight(self):
      304. ConfigListScreen.keyRight(self)
      305. if self["config"].getCurrent() == self.hdmienabled:
      306. self.createSetup()
      307. if self["config"].getCurrent() == self.hdmiavinput:
      308. self.createSetup()
      310. def keyCancel(self):
      311. self.close()
      313. def keySave(self):
      314. ConfigListScreen.keySave(self)
      316. def openconfig(session, **kwargs):
      317. session.open(HdmiCecPlugin)
      319. def autostart(reason, **kwargs):
      320. global session
      321. if kwargs.has_key("session") and reason == 0:
      322. if config.hdmicec.enabled.value:
      323. session = kwargs["session"]
      324. if config.hdmicec.avvolumecontrol.value:
      325. ## from InfoBarGenerics.py
      326. eActionMap.getInstance().bindAction('', -0x7FFFFFFF, volumekeyPressed)
      327. ##
      328. eHdmiCEC.getInstance().messageReceived.get().append(messageReceived)
      329. eHdmiCEC.getInstance().messageReceivedKey.get().append(messageReceivedKey)
      331. def Plugins(**kwargs):
      332. return [PluginDescriptor(name=_("VTI HDMI-CEC"), description="VTI HDMI-CEC Configuration", where = PluginDescriptor.WHERE_PLUGINMENU, icon="hdmicec.png", needsRestart = True, fnc=openconfig),
      333. PluginDescriptor(where = [PluginDescriptor.WHERE_SESSIONSTART, PluginDescriptor.WHERE_AUTOSTART], fnc = autostart)]
      336. def volumekeyPressed(key, flag):
      337. if config.hdmicec.avvolumecontrol.value and config.hdmicec.enabled.value and config.hdmicec.avinput.value != "0":
      338. if key == 113 or key == 114 or key == 115:
      339. address = int("5",16)
      340. cecmessagesendkey = int("44",16)
      341. cecmessagekeyevent = None
      342. if flag == 1:
      343. cecmessagekeybreak = int("45",16)
      344. cmd = struct.pack('B',cecmessagekeybreak)
      345. else:
      346. if key == 113:
      347. cecmessagekeyevent = int("43",16)
      348. elif key == 114:
      349. cecmessagekeyevent = int("42",16)
      350. elif key == 115:
      351. cecmessagekeyevent = int("41",16)
      352. if cecmessagekeyevent:
      353. cmd = struct.pack('BB',cecmessagesendkey,cecmessagekeyevent)
      354. if cmd:
      355. eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
      356. return 1
      357. return 0
      359. def messageReceived(address, message):
      361. logcmd = "[VTI HDMI-CEC] received cec message %x from %x" % (message, address)
      362. if logcmd:
      363. if config.hdmicec.logenabledserial.value:
      364. print logcmd
      365. if config.hdmicec.logenabledfile.value:
      366. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      367. system(filelog)
      369. if config.hdmicec.enabled.value:
      370. from Screens.Standby import inStandby
      371. from Screens.Standby import Standby
      373. cmd = None
      374. cmdtwo = None
      375. addresstwo = None
      376. logcmd = None
      377. logcmdtwo = None
      379. physaddress1 = int("0x" + str(config.hdmicec.tvinput.value) + str(config.hdmicec.avinput.value),16)
      380. physaddress2 = int("0x00",16)
      382. addresstv = int("0x00",16)
      383. addressav = int("0x05",16)
      384. addressglobal = int("0x0F",16)
      386. powerstatereportmessage = int("0x90",16)
      387. powerstate = int("0x00",16)
      389. physaddressmessage = int('0x84',16)
      390. devicetypmessage = int('0x03',16)
      392. activesourcemessage = int('0x82',16)
      394. menuonmessage = int('0x8E',16)
      395. menustatemessage = int('0x00',16)
      397. setnamemessage = int('0x47',16)
      399. sendkeymessage = int("44",16)
      400. sendkeypwronmessage = int("6D",16)
      401. sendkeypwroffmessage = int("6C",16)
      403. if message == 0x8f: # request power state
      404. address = addresstv
      405. cecmessage = powerstatereportmessage
      406. cecmessagetwo = powerstate
      407. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      408. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      410. elif message == 0x83: # request physical address
      411. address = addressglobal
      412. cecmessage = physaddressmessage
      413. cecmessagetwo = physaddress1
      414. cecmessagethree = physaddress2
      415. cecmessagefour = devicetypmessage
      416. cmd = struct.pack('BBBB',cecmessage,cecmessagetwo,cecmessagethree,cecmessagefour)
      417. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,cecmessagefour,address)
      419. elif message == 0x86: # request streampath
      420. if (inStandby) and (config.hdmicec.vuwakeup_message.value == "vuwakeup"):
      421. inStandby.Power()
      422. address = addressglobal
      423. cecmessage = activesourcemessage
      424. cecmessagetwo = physaddress1
      425. cecmessagethree = physaddress2
      426. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      427. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
      429. if config.hdmicec.enabletvrc.value:
      430. addresstwo = addresstv
      431. cecmessage = menuonmessage
      432. cecmessagetwo = menustatemessage
      433. cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
      434. logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      436. elif message == 0x8d: # request menu state
      437. if config.hdmicec.enabletvrc.value:
      438. address = addresstv
      439. cecmessage = menuonmessage
      440. cecmessagetwo = menustatemessage
      441. cmd = struct.pack('BB',cecmessage,cecmessagetwo)
      442. logcmd = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      444. elif message == 0x46: # request device name
      445. address = addresstv
      446. cecmessage = setnamemessage
      447. name_len = len(config.hdmicec.device_name.value)
      448. if name_len == 0:
      449. cecmessagetwo ="VU+"
      450. cmd = struct.pack('B4s',cecmessage,cecmessagetwo)
      451. else:
      452. cecmessagetwo = config.hdmicec.device_name.value
      453. cmd = struct.pack('B'+str(name_len+1)+'s',cecmessage,cecmessagetwo)
      454. logcmd = "[VTI HDMI-CEC] send cec message %x:%s to %x" % (cecmessage,cecmessagetwo,address)
      456. elif message == 0x85: # request active source
      457. if not inStandby:
      458. if config.hdmicec.active_source_reply.value or hdmi_cec.initial_active_source_call == True:
      459. address = addressglobal
      460. cecmessage = activesourcemessage
      461. cecmessagetwo = physaddress1
      462. cecmessagethree = physaddress2
      463. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      464. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
      466. if config.hdmicec.enabletvrc.value:
      467. addresstwo = addresstv
      468. cecmessage = menuonmessage
      469. cecmessagetwo = menustatemessage
      470. cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
      471. logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      473. elif inStandby:
      474. if config.hdmicec.vuwakeup_message.value == "vuwakeup":
      475. inStandby.Power()
      476. address = addressglobal
      477. cecmessage = activesourcemessage
      478. cecmessagetwo = physaddress1
      479. cecmessagethree = physaddress2
      480. cmd = struct.pack('BBB',cecmessage,cecmessagetwo,cecmessagethree)
      481. logcmd = "[VTI HDMI-CEC] send cec message %x:%x:%x to %x" % (cecmessage,cecmessagetwo,cecmessagethree,address)
      483. if config.hdmicec.enabletvrc.value:
      484. addresstwo = addresstv
      485. cecmessage = menuonmessage
      486. cecmessagetwo = menustatemessage
      487. cmdtwo = struct.pack('BB',cecmessage,cecmessagetwo)
      488. logcmdtwo = "[VTI HDMI-CEC] send cec message %x:%x to %x" % (cecmessage,cecmessagetwo,address)
      490. elif message == 0x36:
      491. if config.hdmicec.vustandby_message.value == "vustandby":
      492. if inStandby == None:
      493. logcmd = "[VTI HDMI-CEC] VU+ STB goto standby"
      494. session.open(Standby)
      495. elif config.hdmicec.vustandby_message.value == "vudeepstandby":
      496. import Screens.Standby
      497. logcmd = "[VTI HDMI-CEC] VU+ STB goto deepstandby"
      498. session.open(Screens.Standby.TryQuitMainloop,1)
      500. if inStandby == None:
      501. if cmd:
      502. eHdmiCEC.getInstance().sendMessage(address, len(cmd), str(cmd))
      503. if cmdtwo:
      504. eHdmiCEC.getInstance().sendMessage(addresstwo, len(cmdtwo), str(cmdtwo))
      506. if logcmd:
      507. if config.hdmicec.logenabledserial.value:
      508. print logcmd
      509. if config.hdmicec.logenabledfile.value:
      510. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      511. system(filelog)
      512. if logcmdtwo:
      513. if config.hdmicec.logenabledserial.value:
      514. print logcmdtwo
      515. if config.hdmicec.logenabledfile.value:
      516. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmdtwo)
      517. system(filelog)
      519. def messageReceivedKey(address, message):
      521. logcmd = "[VTI HDMI-CEC] received cec message part two %x from %x" % (message, address)
      522. if logcmd:
      523. if config.hdmicec.logenabledserial.value:
      524. print logcmd
      525. if config.hdmicec.logenabledfile.value:
      526. filelog = "echo %s >> /tmp/hdmicec.log" % (logcmd)
      527. system(filelog)
      529. if config.hdmicec.enabled.value is True:
      530. rcdevicename = iInputDevices.getDeviceName('event0') # hschang : get rc device name, /dev/input/event0
      531. keyaction = eActionMap.getInstance()
      532. key = None
      533. #start translate keycodes
      534. if message == 0x32 or message == 0x09: #key menu
      535. key = int(139)
      536. elif message == 0x20: #key 0
      537. key = int(11)
      538. elif message == 0x21: #key 1
      539. key = int(2)
      540. elif message == 0x22: #key 2
      541. key = int(3)
      542. elif message == 0x23: #key 3
      543. key = int(4)
      544. elif message == 0x24: #key 4
      545. key = int(5)
      546. elif message == 0x25: #key 5
      547. key = int(6)
      548. elif message == 0x26: #key 6
      549. key = int(7)
      550. elif message == 0x27: #key 7
      551. key = int(8)
      552. elif message == 0x28: #key 8
      553. key = int(9)
      554. elif message == 0x29: #key 10
      555. key = int(10)
      556. elif message == 0x30: #key bouquet up
      557. key = int(402)
      558. elif message == 0x31: #key bouquet down
      559. key = int(403)
      560. elif message == 0x53: #key info/epg
      561. key = int(358)
      562. elif message == 0x00: #key ok
      563. key = int(352)
      564. elif message == 0x03: #key left
      565. key = int(105)
      566. elif message == 0x04: #key right
      567. key = int(106)
      568. elif message == 0x01: #key up
      569. key = int(103)
      570. elif message == 0x02: #key down
      571. key = int(108)
      572. elif message == 0x0d: #key exit
      573. key = int(174)
      574. elif message == 0x72: #key red
      575. key = int(398)
      576. elif message == 0x71: #key blue
      577. key = int(401)
      578. elif message == 0x73: #key green
      579. key = int(399)
      580. elif message == 0x74: #key yellow
      581. key = int(400)
      582. elif message == 0x44: #key play
      583. if rcdevicename.find("advanced"):
      584. key = int(164) # KEY_PLAYPAUSE
      585. else:
      586. key = int(207) # KEY_PLAY
      587. elif message == 0x46: #key pause
      588. if rcdevicename.find("advanced"):
      589. key = int(164) # KEY_PLAYPAUSE
      590. else:
      591. key = int(119) # KEY_PAUSE
      592. elif message == 0x45: #key stop
      593. key = int(128)
      594. elif message == 0x47: #key record
      595. key = int(167)
      596. elif message == 0x49: #fast forward
      597. if rcdevicename.find("advanced"):
      598. key = int(163) # KEY_NEXTSONG
      599. else:
      600. key = int(208) # KEY_FASTFORWARD
      601. elif message == 0x48: #rewind
      602. if rcdevicename.find("advanced"):
      603. key = int(165) # KEY_NEXTSONG
      604. else:
      605. key = int(168) # KEY_FASTFORWARD
      606. elif message == 0x60: #play 2
      607. key = int(207)
      608. elif message == 0x61: #key pause 2
      609. if rcdevicename.find("advanced"):
      610. key = int(164) # KEY_PLAYPAUSE
      611. else:
      612. key = int(119) # KEY_PAUSE
      613. elif message == 0x64: #key stop 2
      614. key = int(128)
      615. elif message == 0x62: #key record 2
      616. key = int(167)
      617. #end translate keycodes
      618. if key:
      619. keyaction.keyPressed(rcdevicename, key, int(0))
      620. keyaction.keyPressed(rcdevicename, key, int(1))
      Alles anzeigen
      Dateien

      • plugin.py.zip

        (5,26 kB, 5 mal heruntergeladen, zuletzt: )

    • So da bin ich wieder ;)
      Hmm, ja langsam gehen mir so aus der ferne die Ideen aus. Das einzige, was mir jetzt noch einfallen würde, wäre ein Raspberry zu benutzen um rauszufinden, was der TV sendet, wenn du den TV über die TV Taste einschaltest. So hab ich es damals mit meinem LG HT System gemacht.

      Generell wäre das auch der beste Ansatz, da du von nem RPI aus einfacher die Befehle abgesetzt bekommst und nicht jedesmal die VU+ neustarten musst.

      Die Version 9.0.3 sollte nicht das Problem sein.

      Also wie gesagt, ein RPI mit nem cec-client wäre mein Vorschlag.