change iFrontendInformation api
[enigma2.git] / lib / python / Plugins / SystemPlugins / PositionerSetup / plugin.py
1 from enigma import eTimer, eDVBSatelliteEquipmentControl, eDVBResourceManager, \
2         eDVBDiseqcCommand, eDVBFrontendParametersSatellite, eDVBFrontendParameters,\
3         iDVBFrontend
4
5 from Screens.Screen import Screen
6 from Screens.ScanSetup import ScanSetup
7 from Screens.MessageBox import MessageBox
8 from Plugins.Plugin import PluginDescriptor
9
10 from Components.Label import Label
11 from Components.ConfigList import ConfigList
12 from Components.TunerInfo import TunerInfo
13 from Components.ActionMap import ActionMap
14 from Components.NimManager import nimmanager
15 from Components.MenuList import MenuList
16 from Components.config import ConfigSatlist, ConfigNothing, ConfigSelection, ConfigSubsection, KEY_LEFT, KEY_RIGHT, getConfigListEntry
17
18 from time import sleep
19
20 class PositionerSetup(Screen):
21         skin = """
22                 <screen position="100,100" size="560,400" title="Positioner setup..." >
23                         <widget name="list" position="100,0" size="350,155" />
24
25                         <widget name="red" position="0,155" size="140,80" backgroundColor="red" halign="center" valign="center" font="Regular;21" />
26                         <widget name="green" position="140,155" size="140,80" backgroundColor="green" halign="center" valign="center" font="Regular;21" />
27                         <widget name="yellow" position="280,155" size="140,80" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" />
28                         <widget name="blue" position="420,155" size="140,80" backgroundColor="blue" halign="center" valign="center" font="Regular;21" />
29                         
30                         <widget name="snr" text="SNR:" position="0,245" size="60,22" font="Regular;21" />
31                         <widget name="agc" text="AGC:" position="0,270" size="60,22" font="Regular;21" />
32                         <widget name="ber" text="BER:" position="0,295" size="60,22" font="Regular;21" />
33                         <widget name="lock" text="Lock:" position="0,320" size="60,22" font="Regular;21" />
34                         <widget name="snr_percentage" position="220,245" size="60,22" font="Regular;21" />
35                         <widget name="agc_percentage" position="220,270" size="60,22" font="Regular;21" />
36                         <widget name="ber_value" position="220,295" size="60,22" font="Regular;21" />
37                         <widget name="lock_state" position="60,320" size="150,22" font="Regular;21" />
38                         <widget name="snr_bar" position="60,245" size="150,22" />
39                         <widget name="agc_bar" position="60,270" size="150,22" />
40                         <widget name="ber_bar" position="60,295" size="150,22" />
41
42                         <widget name="frequency" text="Frequency:" position="300,245" size="120,22" font="Regular;21" />
43                         <widget name="symbolrate" text="Symbolrate:" position="300,270" size="120,22" font="Regular;21" />
44                         <widget name="fec" text="FEC:" position="300,295" size="120,22" font="Regular;21" />
45                         <widget name="frequency_value" position="420,245" size="120,22" font="Regular;21" />
46                         <widget name="symbolrate_value" position="420,270" size="120,22" font="Regular;21" />
47                         <widget name="fec_value" position="420,295" size="120,22" font="Regular;21" />
48                 </screen>"""
49         def __init__(self, session, feid):
50                 self.skin = PositionerSetup.skin
51                 Screen.__init__(self, session)
52                 self.feid = feid
53                 self.oldref = None
54                 
55                 if not self.openFrontend():
56                         self.oldref = session.nav.getCurrentlyPlayingServiceReference()
57                         session.nav.stopService() # try to disable foreground service
58                         if not self.openFrontend():
59                                 if session.pipshown: # try to disable pip
60                                         session.pipshown = False
61                                         del session.pip
62                                         if not self.openFrontend():
63                                                 self.frontend = None # in normal case this should not happen
64
65                 self.frontendStatus = { }
66
67                 self.diseqc = Diseqc(self.frontend)
68                 self.tuner = Tuner(self.frontend)
69                 self.tuner.tune((0,0,0,0,0,0))
70                 
71                 self.createConfig()
72                 
73                 self.isMoving = False
74                 self.stopOnLock = False
75                 
76                 self.red = Label("")
77                 self["red"] = self.red
78                 self.green = Label("")
79                 self["green"] = self.green
80                 self.yellow = Label("")
81                 self["yellow"] = self.yellow
82                 self.blue = Label("")
83                 self["blue"] = self.blue
84                 
85                 self.list = []
86                 self["list"] = ConfigList(self.list)
87                 self.createSetup()
88                 
89                 self["snr"] = Label()
90                 self["agc"] = Label()
91                 self["ber"] = Label()
92                 self["lock"] = Label()
93                 self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
94                 self["agc_percentage"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, statusDict = self.frontendStatus)
95                 self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
96                 self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
97                 self["agc_bar"] = TunerInfo(TunerInfo.AGC_BAR, statusDict = self.frontendStatus)
98                 self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
99                 self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)
100
101                 self["frequency"] = Label()
102                 self["symbolrate"] = Label()
103                 self["fec"] = Label()
104
105                 self["frequency_value"] = Label("")
106                 self["symbolrate_value"] = Label("")
107                 self["fec_value"] = Label("")
108                 
109                 self["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"],
110                 {
111                         "ok": self.go,
112                         "cancel": self.keyCancel,
113                         "up": self.up,
114                         "down": self.down,
115                         "left": self.left,
116                         "right": self.right,
117                         "red": self.redKey,
118                         "green": self.greenKey,
119                         "yellow": self.yellowKey,
120                         "blue": self.blueKey,
121                 }, -1)
122                 
123                 self.updateColors("tune")
124                 
125                 self.statusTimer = eTimer()
126                 self.statusTimer.timeout.get().append(self.updateStatus)
127                 self.statusTimer.start(50, False)
128
129         def restartPrevService(self, yesno):
130                 if yesno:
131                         if self.frontend:
132                                 self.frontend = None
133                                 del self.raw_channel
134                         self.session.nav.playService(self.oldref)
135                 self.close(None)
136         
137         def keyCancel(self):
138                 if self.oldref:
139                         self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before positioner setup?"), MessageBox.TYPE_YESNO)
140                 else:
141                         self.restartPrevService(False)
142
143         def openFrontend(self):
144                 res_mgr = eDVBResourceManager.getInstance()
145                 if res_mgr:
146                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
147                         if self.raw_channel:
148                                 self.frontend = self.raw_channel.getFrontend()
149                                 if self.frontend:
150                                         return True
151                                 else:
152                                         print "getFrontend failed"
153                         else:
154                                 print "getRawChannel failed"
155                 else:
156                         print "getResourceManager instance failed"
157                 return False
158
159         def createConfig(self):
160                 self.positioner_tune = ConfigNothing()
161                 self.positioner_move = ConfigNothing()
162                 self.positioner_finemove = ConfigNothing()
163                 self.positioner_limits = ConfigNothing()
164                 self.positioner_goto0 = ConfigNothing()
165                 storepos = []
166                 for x in range(1,255):
167                         storepos.append(str(x))
168                 self.positioner_storage = ConfigSelection(choices = storepos)
169
170         def createSetup(self):
171                 self.list.append((_("Tune"), self.positioner_tune, "tune"))
172                 self.list.append((_("Positioner movement"), self.positioner_move, "move"))
173                 self.list.append((_("Positioner fine movement"), self.positioner_finemove, "finemove"))
174                 self.list.append((_("Set limits"), self.positioner_limits, "limits"))
175                 self.list.append((_("Positioner storage"), self.positioner_storage, "storage"))
176                 self.list.append((_("Goto 0"), self.positioner_goto0, "goto0"))
177                 self["list"].l.setList(self.list)
178
179         def go(self):
180                 pass
181
182         def getCurrentConfigPath(self):
183                 return self["list"].getCurrent()[2]
184
185         def up(self):
186                 if not self.isMoving:
187                         self["list"].instance.moveSelection(self["list"].instance.moveUp)
188                         self.updateColors(self.getCurrentConfigPath())
189
190         def down(self):
191                 if not self.isMoving:
192                         self["list"].instance.moveSelection(self["list"].instance.moveDown)
193                         self.updateColors(self.getCurrentConfigPath())
194
195         def left(self):
196                 self["list"].handleKey(KEY_LEFT)
197
198         def right(self):
199                 self["list"].handleKey(KEY_RIGHT)
200
201         def updateColors(self, entry):
202                 if entry == "tune":
203                         self.red.setText(_("Tune"))
204                         self.green.setText("")
205                         self.yellow.setText("")
206                         self.blue.setText("")
207                 elif entry == "move":
208                         if self.isMoving:
209                                 self.red.setText(_("Stop"))
210                                 self.green.setText(_("Stop"))
211                                 self.yellow.setText(_("Stop"))
212                                 self.blue.setText(_("Stop"))
213                         else:
214                                 self.red.setText(_("Move west"))
215                                 self.green.setText(_("Search west"))
216                                 self.yellow.setText(_("Search east"))
217                                 self.blue.setText(_("Move east"))
218                 elif entry == "finemove":
219                         self.red.setText("")
220                         self.green.setText(_("Step west"))
221                         self.yellow.setText(_("Step east"))
222                         self.blue.setText("")
223                 elif entry == "limits":
224                         self.red.setText(_("Limits off"))
225                         self.green.setText(_("Limit west"))
226                         self.yellow.setText(_("Limit east"))
227                         self.blue.setText(_("Limits on"))
228                 elif entry == "storage":
229                         self.red.setText("")
230                         self.green.setText(_("Store position"))
231                         self.yellow.setText(_("Goto position"))
232                         self.blue.setText("")
233                 elif entry == "goto0":
234                         self.red.setText(_("Goto 0"))
235                         self.green.setText("")
236                         self.yellow.setText("")
237                         self.blue.setText("")
238                 else:
239                         self.red.setText("")
240                         self.green.setText("")
241                         self.yellow.setText("")
242                         self.blue.setText("")
243
244         def redKey(self):
245                 entry = self.getCurrentConfigPath()
246                 if entry == "move":
247                         if self.isMoving:
248                                 self.diseqccommand("stop")
249                                 self.isMoving = False
250                                 self.stopOnLock = False
251                         else:
252                                 self.diseqccommand("moveWest", 0)
253                                 self.isMoving = True
254                         self.updateColors("move")
255                 elif entry == "limits":
256                         self.diseqccommand("limitOff")
257                 elif entry == "tune":
258                         self.session.openWithCallback(self.tune, TunerScreen, self.feid)
259                 elif entry == "goto0":
260                         print "move to position 0"
261                         self.diseqccommand("moveTo", 0)
262
263         def greenKey(self):
264                 entry = self.getCurrentConfigPath()
265                 if entry == "move":
266                         if self.isMoving:
267                                 self.diseqccommand("stop")
268                                 self.isMoving = False
269                                 self.stopOnLock = False
270                         else:
271                                 self.isMoving = True
272                                 self.stopOnLock = True
273                                 self.diseqccommand("moveWest", 0)
274                         self.updateColors("move")
275                 elif entry == "finemove":
276                         print "stepping west"
277                         self.diseqccommand("moveWest", 0xFF) # one step
278                 elif entry == "storage":
279                         print "store at position", int(self.positioner_storage.value)
280                         self.diseqccommand("store", int(self.positioner_storage.value))
281                 elif entry == "limits":
282                         self.diseqccommand("limitWest")
283
284         def yellowKey(self):
285                 entry = self.getCurrentConfigPath()
286                 if entry == "move":
287                         if self.isMoving:
288                                 self.diseqccommand("stop")
289                                 self.isMoving = False
290                                 self.stopOnLock = False
291                         else:
292                                 self.isMoving = True
293                                 self.stopOnLock = True
294                                 self.diseqccommand("moveEast", 0)
295                         self.updateColors("move")
296                 elif entry == "finemove":
297                         print "stepping east"
298                         self.diseqccommand("moveEast", 0xFF) # one step
299                 elif entry == "storage":
300                         print "move to position", int(self.positioner_storage.value)
301                         self.diseqccommand("moveTo", int(self.positioner_storage.value))
302                 elif entry == "limits":
303                         self.diseqccommand("limitEast")
304
305         def blueKey(self):
306                 entry = self.getCurrentConfigPath()
307                 if entry == "move":
308                         if self.isMoving:
309                                 self.diseqccommand("stop")
310                                 self.isMoving = False
311                                 self.stopOnLock = False
312                         else:
313                                 self.diseqccommand("moveEast", 0)
314                                 self.isMoving = True
315                         self.updateColors("move")
316                         print "moving east"
317                 elif entry == "limits":
318                         self.diseqccommand("limitOn")
319
320         def diseqccommand(self, cmd, param = 0):
321                 self.diseqc.command(cmd, param)
322                 self.tuner.retune()
323
324         def updateStatus(self):
325                 if self.frontend:
326                         self.frontend.getFrontendStatus(self.frontendStatus)
327                 self["snr_percentage"].update()
328                 self["agc_percentage"].update()
329                 self["ber_value"].update()
330                 self["snr_bar"].update()
331                 self["agc_bar"].update()
332                 self["ber_bar"].update()
333                 self["lock_state"].update()
334                 transponderdata = self.tuner.getTransponderData()
335                 self["frequency_value"].setText(str(transponderdata.get("frequency")))
336                 self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate")))
337                 self["fec_value"].setText(str(transponderdata.get("fec_inner")))
338                 if self.frontendStatus.get("tuner_locked", 0) == 1 and self.isMoving and self.stopOnLock:
339                         self.diseqccommand("stop")
340                         self.isMoving = False
341                         self.stopOnLock = False
342                         self.updateColors(self.getCurrentConfigPath())
343
344         def tune(self, transponder):
345                 if transponder is not None:
346                         self.tuner.tune(transponder)
347
348 class Diseqc:
349         def __init__(self, frontend):
350                 self.frontend = frontend
351
352         def command(self, what, param = 0):
353                 if self.frontend:
354                         cmd = eDVBDiseqcCommand()
355                         if what == "moveWest":
356                                 string = 'e03169' + ("%02x" % param)
357                         elif what == "moveEast":
358                                 string = 'e03168' + ("%02x" % param)
359                         elif what == "moveTo":
360                                 string = 'e0316b' + ("%02x" % param)
361                         elif what == "store":
362                                 string = 'e0316a' + ("%02x" % param)
363                         elif what == "limitOn":
364                                 string = 'e0316a00'
365                         elif what == "limitOff":
366                                 string = 'e03163'
367                         elif what == "limitEast":
368                                 string = 'e03166'
369                         elif what == "limitWest":
370                                 string = 'e03167'
371                         else:
372                                 string = 'e03160' #positioner stop
373                         
374                         print "diseqc command:",
375                         print string
376                         cmd.setCommandString(string)
377                         self.frontend.setTone(iDVBFrontend.toneOff)
378                         sleep(0.015) # wait 15msec after disable tone
379                         self.frontend.sendDiseqc(cmd)
380                         if string == 'e03160': #positioner stop
381                                 sleep(0.05)
382                                 self.frontend.sendDiseqc(cmd) # send 2nd time
383
384 class Tuner:
385         def __init__(self, frontend):
386                 self.frontend = frontend
387
388         def tune(self, transponder):
389                 print "tuning to transponder with data", transponder
390                 parm = eDVBFrontendParametersSatellite()
391                 parm.frequency = transponder[0] * 1000
392                 parm.symbol_rate = transponder[1] * 1000
393                 parm.polarisation = transponder[2]
394                 parm.fec = transponder[3]
395                 parm.inversion = transponder[4]
396                 parm.orbital_position = transponder[5]
397                 parm.system = 0  # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
398                 parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
399                 feparm = eDVBFrontendParameters()
400                 feparm.setDVBS(parm, True)
401                 self.lastparm = feparm
402                 if self.frontend:
403                         self.frontend.tune(feparm)
404
405         def retune(self):
406                 if self.frontend:
407                         self.frontend.tune(self.lastparm)
408
409         def getTransponderData(self):
410                 ret = { }
411                 if self.frontend:
412                         self.frontend.getTransponderData(ret, True)
413                 return ret
414
415 tuning = None
416
417 class TunerScreen(ScanSetup):
418         skin = """
419                 <screen position="90,100" size="520,400" title="Tune">
420                         <widget name="config" position="20,10" size="460,350" scrollbarMode="showOnDemand" />
421                         <widget name="introduction" position="20,360" size="350,30" font="Regular;23" />
422                 </screen>"""
423
424         def __init__(self, session, feid):
425                 self.feid = feid
426                 ScanSetup.__init__(self, session)
427                 self["introduction"].setText("")
428
429         def createSetup(self):
430                 self.typeOfTuningEntry = None
431                 self.satEntry = None
432                 self.list = []
433                 self.typeOfTuningEntry = getConfigListEntry(_('Tune'), tuning.type)
434                 self.list.append(self.typeOfTuningEntry)
435                 self.satEntry = getConfigListEntry(_('Satellite'), tuning.sat)
436                 self.list.append(self.satEntry)
437                 if tuning.type.value == "manual_transponder":
438                         self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
439                         self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
440                         self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
441                         self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
442                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
443                 elif tuning.type.value == "predefined_transponder":
444                         self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
445                 self["config"].list = self.list
446                 self["config"].l.setList(self.list)
447
448         def newConfig(self):
449                 if self["config"].getCurrent() == self.typeOfTuningEntry:
450                         self.createSetup()
451                 elif self["config"].getCurrent() == self.satEntry:
452                         self.createSetup()
453
454         def createConfig(self, foo):
455                 global tuning
456                 if not tuning:
457                         tuning = ConfigSubsection()
458                         tuning.type = ConfigSelection(
459                                 default = "manual_transponder",
460                                 choices = { "manual_transponder" : _("Manual transponder"),
461                                                         "predefined_transponder" : _("Predefined transponder") } )
462                         tuning.sat = ConfigSatlist(list=nimmanager.getRotorSatListForNim(self.feid))
463                         tuning.sat.addNotifier(self.tuningSatChanged)
464                         self.updateTransponders()
465                         TunerScreenConfigCreated = True
466                 ScanSetup.createConfig(self, None)
467
468         def tuningSatChanged(self, *parm):
469                 self.updateTransponders()
470
471         def updateTransponders(self):
472                 if len(tuning.sat.choices):
473                         transponderlist = nimmanager.getTransponders(int(tuning.sat.value))
474                         tps = []
475                         cnt=0
476                         for x in transponderlist:
477                                 if x[3] == 0:
478                                         pol = "H"
479                                 elif x[3] == 1:
480                                         pol = "V"
481                                 elif x[3] == 2:
482                                         pol = "CL"
483                                 elif x[3] == 3:
484                                         pol = "CR"
485                                 if x[4] == 0:
486                                         fec = "FEC_AUTO"
487                                 elif x[4] == 1:
488                                         fec = "FEC_1_2"
489                                 elif x[4] == 2:
490                                         fec = "FEC_2_3"
491                                 elif x[4] == 3:
492                                         fec = "FEC_3_4"
493                                 elif x[4] == 4:
494                                         fec = "FEC_5_6"
495                                 elif x[4] == 5:
496                                         fec = "FEC_7_8"
497                                 elif x[4] == 5:
498                                         fec = "FEC_8_9"
499                                 elif x[4] == 6:
500                                         fec = "FEC_None"
501                                 tps.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)
502                         tuning.transponder = ConfigSelection(choices=tps)
503
504         def keyGo(self):
505                 returnvalue = (0, 0, 0, 0, 0, 0)
506                 satpos = int(tuning.sat.value)
507                 if tuning.type.value == "manual_transponder":
508                         returnvalue = (
509                                 self.scan_sat.frequency.value,
510                                 self.scan_sat.symbolrate.value,
511                                 self.scan_sat.polarization.index,
512                                 self.scan_sat.fec.index,
513                                 self.scan_sat.inversion.index,
514                                 satpos)
515                 elif tuning.type.value == "predefined_transponder":
516                         transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
517                         returnvalue = (int(transponder[1] / 1000), int(transponder[2] / 1000), transponder[3], transponder[4], 2, satpos)
518                 self.close(returnvalue)
519
520         def keyCancel(self):
521                 self.close(None)
522
523 class NimSelection(Screen):
524         skin = """
525                 <screen position="140,165" size="400,100" title="select Slot">
526                         <widget name="nimlist" position="20,10" size="360,75" />
527                 </screen>"""
528
529         def __init__(self, session):
530                 Screen.__init__(self, session)
531
532                 nimlist = nimmanager.getNimListOfType(nimmanager.nimType["DVB-S"])
533                 nimMenuList = []
534                 for x in nimlist:
535                         nimMenuList.append((_("NIM ") + (["A", "B", "C", "D"][x]) + ": " + nimmanager.getNimName(x) + " (" + nimmanager.getNimTypeName(x) + ")", x))
536                 
537                 self["nimlist"] = MenuList(nimMenuList)
538
539                 self["actions"] = ActionMap(["OkCancelActions"],
540                 {
541                         "ok": self.okbuttonClick ,
542                         "cancel": self.close
543                 }, -1)
544
545         def okbuttonClick(self):
546                 selection = self["nimlist"].getCurrent()
547                 self.session.open(PositionerSetup, selection[1])
548
549 def PositionerMain(session, **kwargs):
550         nimList = nimmanager.getNimListOfType(nimmanager.nimType["DVB-S"])
551         if len(nimList) == 0:
552                 session.open(MessageBox, _("No positioner capable frontend found."), MessageBox.TYPE_ERROR)
553         else:
554                 if session.nav.RecordTimer.isRecording():
555                         session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to configure the positioner."), MessageBox.TYPE_ERROR)
556                 else:
557                         usableNims = []
558                         for x in nimList:
559                                 configured_rotor_sats = nimmanager.getRotorSatListForNim(x)
560                                 if len(configured_rotor_sats) != 0:
561                                         usableNims.append(x)
562                         if len(usableNims) == 1:
563                                 session.open(PositionerSetup, usableNims[0])
564                         elif len(usableNims) > 1:
565                                 session.open(NimSelection)
566                         else:
567                                 session.open(MessageBox, _("No tuner is configured for use with a diseqc positioner!"), MessageBox.TYPE_ERROR)
568
569 def PositionerSetupStart(menuid):
570         if menuid == "scan":
571                 return [(_("Positioner setup"), PositionerMain)]
572         else:
573                 return []
574
575 def Plugins(**kwargs):
576         return PluginDescriptor(name=_("Positioner setup"), description="Setup your positioner", where = PluginDescriptor.WHERE_SETUP, fnc=PositionerSetupStart)
577