refs bug #429
[enigma2.git] / lib / python / Components / TuneTest.py
index 7b087b9..44b1909 100644 (file)
@@ -1,11 +1,12 @@
 from enigma import eDVBFrontendParametersSatellite, eDVBFrontendParameters, eDVBResourceManager, eTimer
 
 class Tuner:
-       def __init__(self, frontend):
+       def __init__(self, frontend, ignore_rotor=False):
                self.frontend = frontend
-       
-       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation)
-       #                    0         1             2         3       4         5       6        7
+               self.ignore_rotor = ignore_rotor
+
+       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation, rolloff, pilot, tsid, onid)
+       #                    0         1             2         3       4         5       6        7          8       9      10    11
        def tune(self, transponder):
                if self.frontend:
                        print "tuning to transponder with data", transponder
@@ -16,23 +17,31 @@ class Tuner:
                        parm.fec = transponder[3]
                        parm.inversion = transponder[4]
                        parm.orbital_position = transponder[5]
-                       parm.system = 0  # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
-                       parm.modulation = 1 # FIXMEE !! HARDCODED QPSK 
+                       parm.system = transponder[6]
+                       parm.modulation = transponder[7]
+                       parm.rolloff = transponder[8]
+                       parm.pilot = transponder[9]
                        feparm = eDVBFrontendParameters()
-                       feparm.setDVBS(parm)
+                       feparm.setDVBS(parm, self.ignore_rotor)
                        self.lastparm = feparm
                        self.frontend.tune(feparm)
-       
+
        def retune(self):
                if self.frontend:
                        self.frontend.tune(self.lastparm)
 
+       def getTransponderData(self):
+               ret = { }
+               if self.frontend:
+                       self.frontend.getTransponderData(ret, True)
+               return ret
+
 # tunes a list of transponders and checks, if they lock and optionally checks the onid/tsid combination
 # 1) add transponders with addTransponder()
 # 2) call run(<checkPIDs = True>)
 # 3) finishedChecking() is called, when the run is finished
 class TuneTest:
-       def __init__(self, feid, stopOnSuccess = False, stopOnError = False):
+       def __init__(self, feid, stopOnSuccess = -1, stopOnError = -1):
                self.stopOnSuccess = stopOnSuccess
                self.stopOnError = stopOnError
                self.feid = feid
@@ -51,21 +60,34 @@ class TuneTest:
                self.tuner = Tuner(self.frontend)
                self.timer = eTimer()
                self.timer.callback.append(self.updateStatus)
+               
+       def gotTsidOnid(self, tsid, onid):
+               print "******** got tsid, onid:", tsid, onid
+               if tsid is not None and onid is not None:
+                       self.pidStatus = self.INTERNAL_PID_STATUS_SUCCESSFUL
+                       self.tsid = tsid
+                       self.onid = onid
+               else:
+                       self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
+                       self.tsid = -1
+                       self.onid = -1
+               self.timer.start(100, True)
                        
        def updateStatus(self):
                dict = {}
                self.frontend.getFrontendStatus(dict)
-               print "status:", dict
-
                stop = False
                
+               print "status:", dict
                if dict["tuner_state"] == "TUNING":
+                       print "TUNING"
                        self.timer.start(100, True)
-                       self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_TUNING, self.currTuned))
+                       self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_TUNING, self.currTuned))
                elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_NOOP:
+                       print "2nd choice"
                        if dict["tuner_state"] == "LOCKED":
                                print "acquiring TSID/ONID"
-                               # TODO start getting TSID/ONID
+                               self.raw_channel.requestTsidOnid(self.gotTsidOnid)
                                self.pidStatus = self.INTERNAL_PID_STATUS_WAITING
                        else:
                                self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
@@ -74,34 +96,40 @@ class TuneTest:
                else:
                        if dict["tuner_state"] == "LOSTLOCK" or dict["tuner_state"] == "FAILED":
                                self.tuningtransponder = self.nextTransponder()
-                               self.failedTune.append([self.currTuned, self.oldTuned, "tune_failed"])
-                               if self.stopOnError == True:
+                               self.failedTune.append([self.currTuned, self.oldTuned, "tune_failed", dict])  # last parameter is the frontend status)
+                               if self.stopOnError != -1 and self.stopOnError <= len(self.failedTune):
                                        stop = True
                        elif dict["tuner_state"] == "LOCKED":
                                pidsFailed = False
                                if self.checkPIDs:
-                                       tsid = 0 # TODO read values
-                                       onid = 0 # TODO read values
-                                       if tsid != self.currTuned[8] or onid != self.currTuned[9]:
-                                               self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed"])
-                                               pidsFailes = True
+                                       if self.currTuned is not None:
+                                               if self.tsid != self.currTuned[10] or self.onid != self.currTuned[11]:
+                                                       self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[10], self.currTuned[11])}, dict])  # last parameter is the frontend status
+                                                       pidsFailed = True
+                                               else:
+                                                       self.successfullyTune.append([self.currTuned, self.oldTuned, dict])  # 3rd parameter is the frontend status
+                                                       if self.stopOnSuccess != -1 and self.stopOnSuccess <= len(self.successfullyTune):
+                                                               stop = True
                                elif not self.checkPIDs or (self.checkPids and not pidsFailed):  
-                                       self.successfullyTune.append([self.currTuned, self.oldTuned])
-                                       if self.stopOnSuccess == True:
-                                               stop = True
+                                       self.successfullyTune.append([self.currTuned, self.oldTuned, dict]) # 3rd parameter is the frontend status
+                                       if self.stopOnSuccess != -1 and self.stopOnSuccess <= len(self.successfullyTune):
+                                                               stop = True
                                self.tuningtransponder = self.nextTransponder()
                        else:
                                print "************* tuner_state:", dict["tuner_state"]
                                
-                       self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_NOOP, self.currTuned))
+                       self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_NOOP, self.currTuned))
                        
                        if not stop:
                                self.tune()
                if self.tuningtransponder < len(self.transponderlist) and not stop:
-                       self.timer.start(100, True)
-                       print "restart timer"
+                       if self.pidStatus != self.INTERNAL_PID_STATUS_WAITING:
+                               self.timer.start(100, True)
+                               print "restart timer"
+                       else:
+                               print "not restarting timers (waiting for pids)"
                else:
-                       self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_DONE, self.currTuned))
+                       self.progressCallback((self.getProgressLength(), len(self.transponderlist), self.STATUS_DONE, self.currTuned))
                        print "finishedChecking"
                        self.finishedChecking()
                                
@@ -113,18 +141,23 @@ class TuneTest:
                        # check for tsid != -1 and onid != -1 
                        print "index:", index
                        print "len(self.transponderlist):", len(self.transponderlist)
-                       while (index < len(self.transponderlist) and (self.transponderlist[index][8] == -1 or self.transponderlist[index][9] == -1)):
+                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
                                index += 1
                print "FirstTransponder final index:", index
                return index
        
        def nextTransponder(self):
+               print "getting next transponder", self.tuningtransponder
                index = self.tuningtransponder + 1
                if self.checkPIDs:
+                       print "checkPIDs-loop"
                        # check for tsid != -1 and onid != -1 
-                       while (index < len(self.transponderlist) and self.transponderlist[index][8] != -1 and self.transponderlist[index][9] != -1):
+                       print "index:", index
+                       print "len(self.transponderlist):", len(self.transponderlist)
+                       while (index < len(self.transponderlist) and (self.transponderlist[index][10] == -1 or self.transponderlist[index][11] == -1)):
                                index += 1
 
+               print "next transponder index:", index
                return index
        
        def finishedChecking(self):
@@ -168,17 +201,31 @@ class TuneTest:
                self.successfullyTune = []
                self.tuningtransponder = self.firstTransponder()
                self.tune()
-               self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_START, self.currTuned))
+               self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
                self.timer.start(100, True)
        
-       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <tsid>, <onid>)
-       #                    0         1             2         3       4         5       6        7              8      9
+       # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <rolloff>, <pilot>, <tsid>, <onid>)
+       #                    0         1             2         3       4         5       6        7              8         9        10       11
        def addTransponder(self, transponder):
                self.transponderlist.append(transponder)
                
        def clearTransponder(self):
                self.transponderlist = []
                
+       def getProgressLength(self):
+               count = 0
+               if self.stopOnError == -1:
+                       count = len(self.transponderlist)
+               else:
+                       if count < self.stopOnError:
+                               count = self.stopOnError
+               if self.stopOnSuccess == -1:
+                       count = len(self.transponderlist)
+               else:
+                       if count < self.stopOnSuccess:
+                               count = self.stopOnSuccess
+               return count
+               
        STATUS_START = 0
        STATUS_TUNING = 1
        STATUS_DONE = 2