lib/python/Components/TuneTest.py

   1 from enigma import eDVBFrontendParametersSatellite, eDVBFrontendParameters, eDVBResourceManager, eTimer
   2
   3 class Tuner:
   4         def __init__(self, frontend):
   5                 self.frontend = frontend
   6
   7         # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation)
   8         #                    0         1             2         3       4         5       6        7
   9         def tune(self, transponder):
  10                 if self.frontend:
  11                         print "tuning to transponder with data", transponder
  12                         parm = eDVBFrontendParametersSatellite()
  13                         parm.frequency = transponder[0] * 1000
  14                         parm.symbol_rate = transponder[1] * 1000
  15                         parm.polarisation = transponder[2]
  16                         parm.fec = transponder[3]
  17                         parm.inversion = transponder[4]
  18                         parm.orbital_position = transponder[5]
  19                         parm.system = 0  # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
  20                         parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
  21                         feparm = eDVBFrontendParameters()
  22                         feparm.setDVBS(parm)
  23                         self.lastparm = feparm
  24                         self.frontend.tune(feparm)
  25
  26         def retune(self):
  27                 if self.frontend:
  28                         self.frontend.tune(self.lastparm)
  29
  30 # tunes a list of transponders and checks, if they lock and optionally checks the onid/tsid combination
  31 # 1) add transponders with addTransponder()
  32 # 2) call run(<checkPIDs = True>)
  33 # 3) finishedChecking() is called, when the run is finished
  34 class TuneTest:
  35         def __init__(self, feid, stopOnSuccess = False, stopOnError = False):
  36                 self.stopOnSuccess = stopOnSuccess
  37                 self.stopOnError = stopOnError
  38                 self.feid = feid
  39                 self.transponderlist = []
  40                 self.currTuned = None
  41                 print "TuneTest for feid %d" % self.feid
  42                 if not self.openFrontend():
  43                         self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
  44                         self.session.nav.stopService() # try to disable foreground service
  45                         if not self.openFrontend():
  46                                 if self.session.pipshown: # try to disable pip
  47                                         self.session.pipshown = False
  48                                         del self.session.pip
  49                                         if not self.openFrontend():
  50                                                 self.frontend = None # in normal case this should not happen
  51                 self.tuner = Tuner(self.frontend)
  52                 self.timer = eTimer()
  53                 self.timer.callback.append(self.updateStatus)
  54
  55         def gotTsidOnid(self, tsid, onid):
  56                 print "******** got tsid, onid:", tsid, onid
  57                 self.tsid = tsid
  58                 self.onid = onid
  59                 if tsid is not None and onid is not None:
  60                         self.pidStatus = self.INTERNAL_PID_STATUS_SUCCESSFUL
  61                 else:
  62                         self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
  63                 self.timer.start(100, True)
  64
  65         def updateStatus(self):
  66                 dict = {}
  67                 self.frontend.getFrontendStatus(dict)
  68                 stop = False
  69
  70                 print "status:", dict
  71                 if dict["tuner_state"] == "TUNING":
  72                         print "TUNING"
  73                         self.timer.start(100, True)
  74                         self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_TUNING, self.currTuned))
  75                 elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_NOOP:
  76                         print "2nd choice"
  77                         if dict["tuner_state"] == "LOCKED":
  78                                 print "acquiring TSID/ONID"
  79                                 self.raw_channel.requestTsidOnid(self.gotTsidOnid)
  80                                 self.pidStatus = self.INTERNAL_PID_STATUS_WAITING
  81                         else:
  82                                 self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
  83                 elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_WAITING:
  84                         print "waiting for pids"
  85                 else:
  86                         if dict["tuner_state"] == "LOSTLOCK" or dict["tuner_state"] == "FAILED":
  87                                 self.tuningtransponder = self.nextTransponder()
  88                                 self.failedTune.append([self.currTuned, self.oldTuned, "tune_failed"])
  89                                 if self.stopOnError == True:
  90                                         stop = True
  91                         elif dict["tuner_state"] == "LOCKED":
  92                                 pidsFailed = False
  93                                 if self.checkPIDs:
  94                                         if self.tsid != self.currTuned[8] or self.onid != self.currTuned[9]:
  95                                                 self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed"])
  96                                                 pidsFailes = True
  97                                 elif not self.checkPIDs or (self.checkPids and not pidsFailed):
  98                                         self.successfullyTune.append([self.currTuned, self.oldTuned])
  99                                         if self.stopOnSuccess == True:
 100                                                 stop = True
 101                                 self.tuningtransponder = self.nextTransponder()
 102                         else:
 103                                 print "************* tuner_state:", dict["tuner_state"]
 104
 105                         self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_NOOP, self.currTuned))
 106
 107                         if not stop:
 108                                 self.tune()
 109                 if self.tuningtransponder < len(self.transponderlist) and not stop:
 110                         if self.pidStatus != self.INTERNAL_PID_STATUS_WAITING:
 111                                 self.timer.start(100, True)
 112                                 print "restart timer"
 113                         else:
 114                                 print "not restarting timers (waiting for pids)"
 115                 else:
 116                         self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_DONE, self.currTuned))
 117                         print "finishedChecking"
 118                         self.finishedChecking()
 119
 120         def firstTransponder(self):
 121                 print "firstTransponder:"
 122                 index = 0
 123                 if self.checkPIDs:
 124                         print "checkPIDs-loop"
 125                         # check for tsid != -1 and onid != -1
 126                         print "index:", index
 127                         print "len(self.transponderlist):", len(self.transponderlist)
 128                         while (index < len(self.transponderlist) and (self.transponderlist[index][8] == -1 or self.transponderlist[index][9] == -1)):
 129                                 index += 1
 130                 print "FirstTransponder final index:", index
 131                 return index
 132
 133         def nextTransponder(self):
 134                 index = self.tuningtransponder + 1
 135                 if self.checkPIDs:
 136                         # check for tsid != -1 and onid != -1
 137                         while (index < len(self.transponderlist) and self.transponderlist[index][8] != -1 and self.transponderlist[index][9] != -1):
 138                                 index += 1
 139
 140                 return index
 141
 142         def finishedChecking(self):
 143                 print "finished testing"
 144                 print "successfull:", self.successfullyTune
 145                 print "failed:", self.failedTune
 146
 147         def openFrontend(self):
 148                 res_mgr = eDVBResourceManager.getInstance()
 149                 if res_mgr:
 150                         self.raw_channel = res_mgr.allocateRawChannel(self.feid)
 151                         if self.raw_channel:
 152                                 self.frontend = self.raw_channel.getFrontend()
 153                                 if self.frontend:
 154                                         return True
 155                                 else:
 156                                         print "getFrontend failed"
 157                         else:
 158                                 print "getRawChannel failed"
 159                 else:
 160                         print "getResourceManager instance failed"
 161                 return False
 162
 163         def tune(self):
 164                 print "tuning to", self.tuningtransponder
 165                 if self.tuningtransponder < len(self.transponderlist):
 166                         self.pidStatus = self.INTERNAL_PID_STATUS_NOOP
 167                         self.oldTuned = self.currTuned
 168                         self.currTuned = self.transponderlist[self.tuningtransponder]
 169                         self.tuner.tune(self.transponderlist[self.tuningtransponder])
 170
 171         INTERNAL_PID_STATUS_NOOP = 0
 172         INTERNAL_PID_STATUS_WAITING = 1
 173         INTERNAL_PID_STATUS_SUCCESSFUL = 2
 174         INTERNAL_PID_STATUS_FAILED = 3
 175
 176         def run(self, checkPIDs = False):
 177                 self.checkPIDs = checkPIDs
 178                 self.pidStatus = self.INTERNAL_PID_STATUS_NOOP
 179                 self.failedTune = []
 180                 self.successfullyTune = []
 181                 self.tuningtransponder = self.firstTransponder()
 182                 self.tune()
 183                 self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_START, self.currTuned))
 184                 self.timer.start(100, True)
 185
 186         # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <tsid>, <onid>)
 187         #                    0         1             2         3       4         5       6        7              8      9
 188         def addTransponder(self, transponder):
 189                 self.transponderlist.append(transponder)
 190
 191         def clearTransponder(self):
 192                 self.transponderlist = []
 193
 194         STATUS_START = 0
 195         STATUS_TUNING = 1
 196         STATUS_DONE = 2
 197         STATUS_NOOP = 3
 198         # can be overwritten
 199         # progress = (range, value, status, transponder)
 200         def progressCallback(self, progress):
 201                 pass