lib/python/Plugins/SystemPlugins/Satfinder/plugin.py

   1 from enigma import eTimer, eDVBSatelliteEquipmentControl, eDVBResourceManager,\
   2         eDVBDiseqcCommand, eDVBFrontendParametersSatellite, eDVBFrontendParameters
   3
   4 from Screens.Screen import Screen
   5 from Screens.ScanSetup import ScanSetup
   6 from Screens.MessageBox import MessageBox
   7 from Plugins.Plugin import PluginDescriptor
   8
   9 from Components.Label import Label
  10 from Components.ConfigList import ConfigList
  11 from Components.TunerInfo import TunerInfo
  12 from Components.ActionMap import ActionMap
  13 from Components.NimManager import nimmanager, getConfigSatlist
  14 from Components.MenuList import MenuList
  15 from Components.config import ConfigSelection, ConfigSatlist, getConfigListEntry
  16
  17 class Tuner:
  18         def __init__(self, frontend):
  19                 self.frontend = frontend
  20
  21         def tune(self, transponder):
  22                 if self.frontend:
  23                         print "tuning to transponder with data", transponder
  24                         parm = eDVBFrontendParametersSatellite()
  25                         parm.frequency = transponder[0] * 1000
  26                         parm.symbol_rate = transponder[1] * 1000
  27                         parm.polarisation = transponder[2]
  28                         parm.fec = transponder[3]
  29                         parm.inversion = transponder[4]
  30                         parm.orbital_position = transponder[5]
  31                         parm.system = 0  # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
  32                         parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
  33                         feparm = eDVBFrontendParameters()
  34                         feparm.setDVBS(parm)
  35                         self.lastparm = feparm
  36                         self.frontend.tune(feparm)
  37
  38         def retune(self):
  39                 if self.frontend:
  40                         self.frontend.tune(self.lastparm)
  41
  42 class Satfinder(ScanSetup):
  43         skin = """
  44                 <screen position="90,100" size="520,400" title="Tune">
  45                         <widget name="config" position="20,10" size="460,240" scrollbarMode="showOnDemand" />
  46                         <widget name="introduction" position="20,360" zPosition="-10" size="350,30" font="Regular;23" />
  47                         <widget name="snr" text="SNR:" position="0,245" size="60,22" font="Regular;21" />
  48                         <widget name="agc" text="AGC:" position="0,270" size="60,22" font="Regular;21" />
  49                         <widget name="ber" text="BER:" position="0,295" size="60,22" font="Regular;21" />
  50                         <widget name="lock" text="Lock:" position="0,320" size="60,22" font="Regular;21" />
  51                         <widget name="snr_percentage" position="220,245" size="60,22" font="Regular;21" />
  52                         <widget name="agc_percentage" position="220,270" size="60,22" font="Regular;21" />
  53                         <widget name="ber_value" position="220,295" size="60,22" font="Regular;21" />
  54                         <widget name="lock_state" position="60,320" size="150,22" font="Regular;21" />
  55                         <widget name="snr_bar" position="60,245" size="150,22" />
  56                         <widget name="agc_bar" position="60,270" size="150,22" />
  57                         <widget name="ber_bar" position="60,295" size="150,22" />
  58                 </screen>"""
  59
  60         def openFrontend(self):
  61                 res_mgr = eDVBResourceManager.getInstance()
  62                 if res_mgr:
  63                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
  64                         if self.raw_channel:
  65                                 self.frontend = self.raw_channel.getFrontend()
  66                                 if self.frontend:
  67                                         return True
  68                                 else:
  69                                         print "getFrontend failed"
  70                         else:
  71                                 print "getRawChannel failed"
  72                 else:
  73                         print "getResourceManager instance failed"
  74                 return False
  75
  76         def __init__(self, session, feid):
  77                 self.initcomplete = False
  78                 self.feid = feid
  79                 self.oldref = None
  80                 self.frontendStatus = { }
  81
  82                 if not self.openFrontend():
  83                         self.oldref = session.nav.getCurrentlyPlayingServiceReference()
  84                         session.nav.stopService() # try to disable foreground service
  85                         if not self.openFrontend():
  86                                 if session.pipshown: # try to disable pip
  87                                         session.pipshown = False
  88                                         del session.pip
  89                                         if not self.openFrontend():
  90                                                 self.frontend = None # in normal case this should not happen
  91
  92                 ScanSetup.__init__(self, session)
  93                 self.tuner = Tuner(self.frontend)
  94
  95                 self["snr"] = Label()
  96                 self["agc"] = Label()
  97                 self["ber"] = Label()
  98                 self["lock"] = Label()
  99                 self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
 100                 self["agc_percentage"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, statusDict = self.frontendStatus)
 101                 self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
 102                 self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
 103                 self["agc_bar"] = TunerInfo(TunerInfo.AGC_BAR, statusDict = self.frontendStatus)
 104                 self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
 105                 self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)
 106
 107                 self["introduction"].setText("")
 108
 109                 self.statusTimer = eTimer()
 110                 self.statusTimer.timeout.get().append(self.updateStatus)
 111                 self.statusTimer.start(50, False)
 112                 self.initcomplete = True
 113
 114         def updateStatus(self):
 115                 if self.frontend:
 116                         self.frontend.getFrontendStatus(self.frontendStatus)
 117                 else:
 118                         self.frontendStatus.clear()
 119                 self["snr_percentage"].update()
 120                 self["agc_percentage"].update()
 121                 self["ber_value"].update()
 122                 self["snr_bar"].update()
 123                 self["agc_bar"].update()
 124                 self["ber_bar"].update()
 125                 self["lock_state"].update()
 126
 127         def createSetup(self):
 128                 self.typeOfTuningEntry = None
 129                 self.satEntry = None
 130
 131                 self.list = []
 132                 self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
 133                 self.list.append(self.typeOfTuningEntry)
 134                 self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
 135                 self.list.append(self.satEntry)
 136                 if self.tuning_type.value == "manual_transponder":
 137                         self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
 138                         self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
 139                         self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
 140                         self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
 141                         self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
 142                 elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
 143                         self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
 144                 self["config"].list = self.list
 145                 self["config"].l.setList(self.list)
 146
 147         def newConfig(self):
 148                 if self["config"].getCurrent() == self.typeOfTuningEntry:
 149                         self.createSetup()
 150                 elif self["config"].getCurrent() == self.satEntry:
 151                         self.updateSats()
 152                         self.createSetup()
 153
 154         def sat_changed(self, config_element):
 155                 self.newConfig()
 156                 self.retune(config_element)
 157
 158         def retune(self, configElement):
 159                 returnvalue = (0, 0, 0, 0, 0, 0, 0)
 160                 satpos = self.tuning_sat.orbital_position
 161
 162                 if satpos is not None:
 163                         if self.tuning_type.value == "manual_transponder":
 164                                 returnvalue = (self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.index, self.scan_sat.fec.index, self.scan_sat.inversion.index, satpos)
 165                         elif self.tuning_type.value == "predefined_transponder":
 166                                 transponder = nimmanager.getTransponders(satpos)[self.tuning_transponder.index]
 167                                 returnvalue = (int(transponder[1] / 1000), int(transponder[2] / 1000), transponder[3], transponder[4], 2, satpos)
 168                         self.tune(returnvalue)
 169
 170         def createConfig(self, foo):
 171                 self.tuning_transponder = None
 172                 self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))])
 173                 self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid))
 174                 ScanSetup.createConfig(self, None)
 175
 176                 self.updateSats()
 177
 178                 self.tuning_type.addNotifier(self.retune, initial_call = False)
 179                 self.tuning_sat.addNotifier(self.sat_changed, initial_call = False)
 180                 self.scan_sat.frequency.addNotifier(self.retune, initial_call = False)
 181                 self.scan_sat.inversion.addNotifier(self.retune, initial_call = False)
 182                 self.scan_sat.symbolrate.addNotifier(self.retune, initial_call = False)
 183                 self.scan_sat.polarization.addNotifier(self.retune, initial_call = False)
 184                 self.scan_sat.fec.addNotifier(self.retune, initial_call = False)
 185
 186         def updateSats(self):
 187                 orb_pos = self.tuning_sat.orbital_position
 188                 if orb_pos is not None:
 189                         transponderlist = nimmanager.getTransponders(orb_pos)
 190                         list = []
 191                         for x in transponderlist:
 192                                 if x[3] == 0:
 193                                         pol = "H"
 194                                 elif x[3] == 1:
 195                                         pol = "V"
 196                                 elif x[3] == 2:
 197                                         pol = "CL"
 198                                 elif x[3] == 3:
 199                                         pol = "CR"
 200                                 if x[4] == 0:
 201                                         fec = "FEC_AUTO"
 202                                 elif x[4] == 1:
 203                                         fec = "FEC_1_2"
 204                                 elif x[4] == 2:
 205                                         fec = "FEC_2_3"
 206                                 elif x[4] == 3:
 207                                         fec = "FEC_3_4"
 208                                 elif x[4] == 4:
 209                                         fec = "FEC_5_6"
 210                                 elif x[4] == 5:
 211                                         fec = "FEC_7_8"
 212                                 elif x[4] == 5:
 213                                         fec = "FEC_8_9"
 214                                 elif x[4] == 6:
 215                                         fec = "FEC_None"
 216                                 list.append(str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec)
 217                         self.tuning_transponder = ConfigSelection(choices = list)
 218                         self.tuning_transponder.addNotifier(self.retune, initial_call = False)
 219
 220         def keyGo(self):
 221                 self.retune(self.tuning_type)
 222
 223         def restartPrevService(self, yesno):
 224                 if yesno:
 225                         if self.frontend:
 226                                 self.frontend = None
 227                                 del self.raw_channel
 228                         self.session.nav.playService(self.oldref)
 229                 self.close(None)
 230
 231         def keyCancel(self):
 232                 if self.oldref:
 233                         self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before satfinder?"), MessageBox.TYPE_YESNO)
 234                 else:
 235                         self.restartPrevService(False)
 236
 237         def tune(self, transponder):
 238                 if self.initcomplete:
 239                         if transponder is not None:
 240                                 self.tuner.tune(transponder)
 241
 242 class NimSelection(Screen):
 243         skin = """
 244                 <screen position="140,165" size="400,100" title="select Slot">
 245                         <widget name="nimlist" position="20,10" size="360,75" />
 246                 </screen>"""
 247
 248         def __init__(self, session):
 249                 Screen.__init__(self, session)
 250
 251                 nimlist = nimmanager.getNimListOfType("DVB-S")
 252                 nimMenuList = []
 253                 for x in nimlist:
 254                         nimMenuList.append((nimmanager.nim_slots[x].friendly_full_description, x))
 255
 256                 self["nimlist"] = MenuList(nimMenuList)
 257
 258                 self["actions"] = ActionMap(["OkCancelActions"],
 259                 {
 260                         "ok": self.okbuttonClick ,
 261                         "cancel": self.close
 262                 }, -1)
 263
 264         def okbuttonClick(self):
 265                 selection = self["nimlist"].getCurrent()[1]
 266                 self.session.open(Satfinder, selection)
 267
 268 def SatfinderMain(session, **kwargs):
 269         nimList = nimmanager.getNimListOfType("DVB-S")
 270         if len(nimList) == 0:
 271                 session.open(MessageBox, _("No satellite frontend found!!"), MessageBox.TYPE_ERROR)
 272         else:
 273                 if session.nav.RecordTimer.isRecording():
 274                         session.open(MessageBox, _("A recording is currently running. Please stop the recording before trying to start the satfinder."), MessageBox.TYPE_ERROR)
 275                 else:
 276                         if len(nimList) == 1:
 277                                 session.open(Satfinder, nimList[0])
 278                         else:
 279                                 session.open(NimSelection)
 280
 281 def SatfinderStart(menuid):
 282         if menuid == "scan":
 283                 return [(_("Satfinder"), SatfinderMain)]
 284         else:
 285                 return []
 286
 287 def Plugins(**kwargs):
 288         return PluginDescriptor(name=_("Satfinder"), description="Helps setting up your dish", where = PluginDescriptor.WHERE_SETUP, fnc=SatfinderStart)