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