From: stefan Date: Tue, 16 Dec 2008 10:33:19 +0000 (+0000) Subject: finish and polish diseqc tester plugin X-Git-Tag: 2.6.0~538^2~4 X-Git-Url: https://git.cweiske.de/enigma2.git/commitdiff_plain/f95be11f0517eac56013b0ccb14825be97fc1540 finish and polish diseqc tester plugin --- diff --git a/data/skin_default.xml b/data/skin_default.xml old mode 100755 new mode 100644 index 5946097d..d60933eb --- a/data/skin_default.xml +++ b/data/skin_default.xml @@ -940,6 +940,11 @@ self.instance.move(ePoint(orgpos.x() + (orgwidth - newwidth)/2, orgpos.y())) + + + + + diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp index 6f30253a..e5a94392 100644 --- a/lib/dvb/db.cpp +++ b/lib/dvb/db.cpp @@ -856,7 +856,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it) { -// eDebug("\t\tattr: %s", at->name().c_str()); + //eDebug("\t\tattr: %s", at->name().c_str()); at = *it; name = at->name(); if (name == "modulation") dest = &modulation; diff --git a/lib/python/Components/TuneTest.py b/lib/python/Components/TuneTest.py index 2d448e8f..422036cd 100644 --- a/lib/python/Components/TuneTest.py +++ b/lib/python/Components/TuneTest.py @@ -32,7 +32,7 @@ class Tuner: # 2) call run() # 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 @@ -54,12 +54,14 @@ class TuneTest: def gotTsidOnid(self, tsid, onid): print "******** got tsid, onid:", tsid, onid - self.tsid = tsid - self.onid = 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): @@ -71,7 +73,7 @@ class TuneTest: 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": @@ -86,23 +88,28 @@ class TuneTest: 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: + if self.stopOnError != -1 and self.stopOnError <= len(self.failedTune): stop = True elif dict["tuner_state"] == "LOCKED": pidsFailed = False if self.checkPIDs: - if self.tsid != self.currTuned[8] or self.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[8] or self.onid != self.currTuned[9]: + self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[8], self.currTuned[9])}]) + pidsFailed = True + else: + self.successfullyTune.append([self.currTuned, self.oldTuned]) + 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 + 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() @@ -113,7 +120,7 @@ class TuneTest: 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() @@ -131,12 +138,17 @@ class TuneTest: 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][8] == -1 or self.transponderlist[index][9] == -1)): index += 1 + print "next transponder index:", index return index def finishedChecking(self): @@ -180,7 +192,7 @@ 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, , , , ) @@ -191,6 +203,20 @@ class TuneTest: 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 diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index 57340368..f997acd1 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -1,20 +1,81 @@ from Screens.Satconfig import NimSelection from Screens.Screen import Screen +from Screens.TextBox import TextBox from Plugins.Plugin import PluginDescriptor -from Components.ActionMap import NumberActionMap +from Components.ActionMap import ActionMap, NumberActionMap from Components.NimManager import nimmanager from Components.ResourceManager import resourcemanager from Components.Sources.FrontendStatus import FrontendStatus from Components.TuneTest import TuneTest +from Components.Sources.List import List from Components.Sources.Progress import Progress from Components.Sources.StaticText import StaticText +from Components.ConfigList import ConfigListScreen +from Components.config import getConfigListEntry, ConfigSelection -class DiseqcTester(Screen, TuneTest): +# always use: +# setResultType(type) +# setResultParameter(parameter) +# getTextualResult() +class ResultParser: + def __init__(self): + pass + + TYPE_BYORBPOS = 0 + TYPE_BYINDEX = 1 + TYPE_ALL = 2 + def setResultType(self, type): + self.type = type + + def setResultParameter(self, parameter): + if self.type == self.TYPE_BYORBPOS: + self.orbpos = parameter + elif self.type == self.TYPE_BYINDEX: + self.index = parameter + + def getTextualResultForIndex(self, index): + text = "" + text += "%s:\n" % self.getTextualIndexRepresentation(index) + + failed, successful = self.results[index]["failed"], self.results[index]["successful"] + countfailed = len(failed) + countsuccessful = len(successful) + countall = countfailed + countsuccessful + percentfailed = round(countfailed / float(countall + 0.0001) * 100) + percentsuccessful = round(countsuccessful / float(countall + 0.0001) * 100) + text += "Tested %d transponders\n%d (%d %%) transponders succeeded\n%d (%d %%) transponders failed\n" % (countall, countsuccessful, percentsuccessful, countfailed, percentfailed) + reasons = {} + if countfailed > 0: + for transponder in failed: + reasons[transponder[2]] = reasons.get(transponder[2], []) + reasons[transponder[2]].append(transponder) + if transponder[2] == "pids_failed": + print transponder[2], "-", transponder[3] + + text += "The %d unsuccessful tuning attempts failed for the following reasons:\n" % countfailed + + for reason in reasons.keys(): + text += "%s: %d transponders failed\n" % (reason, len(reasons[reason])) + return text + + def getTextualResult(self): + text = "" + if self.type == self.TYPE_BYINDEX: + text += self.getTextualResultForIndex(self.index) + elif self.type == self.TYPE_BYORBPOS: + for index in self.results.keys(): + if index[2] == self.orbpos: + text += self.getTextualResultForIndex(index) + text += "\n-----------------------------------------------------\n" + + return text + +class DiseqcTester(Screen, TuneTest, ResultParser): skin = """ - + + + + {"template": [ + MultiContentEntryText(pos = (10, 0), size = (330, 25), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the index name, + MultiContentEntryText(pos = (330, 0), size = (150, 25), flags = RT_HALIGN_RIGHT, text = 2) # index 2 is the status, + ], + "fonts": [gFont("Regular", 20)], + "itemHeight": 25 + } + @@ -54,35 +126,93 @@ class DiseqcTester(Screen, TuneTest): - + - + + + + + + + + + """ TEST_TYPE_QUICK = 0 TEST_TYPE_RANDOM = 1 TEST_TYPE_COMPLETE = 2 - def __init__(self, session, feid, test_type = TEST_TYPE_QUICK): + def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1): Screen.__init__(self, session) self.feid = feid self.test_type = test_type + self.loopsfailed = loopsfailed + self.loopssuccessful = loopssuccessful self["actions"] = NumberActionMap(["SetupActions"], { - "ok": self.keyGo, + "ok": self.select, "cancel": self.keyCancel, }, -2) - TuneTest.__init__(self, feid, stopOnSuccess = True) - self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100) + TuneTest.__init__(self, feid, stopOnSuccess = self.loopssuccessful, stopOnError = self.loopsfailed) + #self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100) self["overall_progress"] = Progress() self["sub_progress"] = Progress() - self["failed_counter"] = StaticText("10") - self["succeeded_counter"] = StaticText("10") + + self["failed_counter"] = StaticText("0") + self["succeeded_counter"] = StaticText("0") + self["witherrors_counter"] = StaticText("0") + self["untestable_counter"] = StaticText("0") + + self.list = [] + self["progress_list"] = List(self.list) + self["progress_list"].onSelectionChanged.append(self.selectionChanged) + + self["CmdText"] = StaticText(_("Please wait while scanning is in progress...")) self.indexlist = {} self.readTransponderList() + + self.running = False + + self.results = {} + self.resultsstatus = {} + + self.onLayoutFinish.append(self.go) + + def getProgressListComponent(self, index, status): + return (index, self.getTextualIndexRepresentation(index), status) + + def clearProgressList(self): + self.list = [] + self["progress_list"].list = self.list + + def addProgressListItem(self, index): + if index in self.indexlist: + for entry in self.list: + if entry[0] == index: + self.changeProgressListStatus(index, "working") + return + self.list.append(self.getProgressListComponent(index, _("working"))) + self["progress_list"].list = self.list + self["progress_list"].setIndex(len(self.list) - 1) + + def changeProgressListStatus(self, index, status): + self.newlist = [] + count = 0 + indexpos = 0 + for entry in self.list: + if entry[0] == index: + self.newlist.append(self.getProgressListComponent(index, status)) + indexpos = count + else: + self.newlist.append(entry) + count += 1 + self.list = self.newlist + self["progress_list"].list = self.list + self["progress_list"].setIndex(indexpos) def readTransponderList(self): for sat in nimmanager.getSatListForNim(self.feid): @@ -92,11 +222,12 @@ class DiseqcTester(Screen, TuneTest): self.analyseTransponder(mytransponder) def getIndexForTransponder(self, transponder): + if transponder[0] < 11700: band = 1 # low else: band = 0 # high - + polarisation = transponder[2] sat = transponder[5] @@ -117,8 +248,7 @@ class DiseqcTester(Screen, TuneTest): print "getTextualIndexRepresentation:", index text = "" - # TODO better sat representation - text += "%s, " % index[2] + text += nimmanager.getSatDescription(index[2]) + ", " if index[0] == 1: text += "Low Band, " @@ -157,6 +287,7 @@ class DiseqcTester(Screen, TuneTest): if self.test_type == self.TEST_TYPE_QUICK: self.myindex = 0 keys = self.indexlist.keys() + keys.sort(key = lambda a: a[2]) # sort by orbpos self["overall_progress"].setRange(len(keys)) self["overall_progress"].setValue(self.myindex) return keys[0] @@ -167,6 +298,7 @@ class DiseqcTester(Screen, TuneTest): if self.test_type == self.TEST_TYPE_QUICK: self.myindex += 1 keys = self.indexlist.keys() + keys.sort(key = lambda a: a[2]) # sort by orbpos self["overall_progress"].setValue(self.myindex) if self.myindex < len(keys): @@ -179,21 +311,137 @@ class DiseqcTester(Screen, TuneTest): def getContinueScanning(self): if self.test_type == self.TEST_TYPE_QUICK: return (self.myindex < len(self.indexlist.keys())) + + def addResult(self, index, status, failedTune, successfullyTune): + self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None}) + self.resultsstatus[status] = self.resultsstatus.get(status, []) + + self.results[index]["status"] = status + self.results[index]["failed"] = failedTune + self.results[index]["successful"] = successfullyTune + + self.resultsstatus[status].append(index) def finishedChecking(self): print "finishedChecking" TuneTest.finishedChecking(self) + + if not self.results.has_key(self.currentlyTestedIndex): + self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None} + + if len(self.failedTune) > 0 and len(self.successfullyTune) > 0: + self.changeProgressListStatus(self.currentlyTestedIndex, "with errors") + self["witherrors_counter"].setText(str(int(self["witherrors_counter"].getText()) + 1)) + self.addResult(self.currentlyTestedIndex, "with_errors", self.failedTune, self.successfullyTune) + elif len(self.failedTune) == 0 and len(self.successfullyTune) == 0: + self.changeProgressListStatus(self.currentlyTestedIndex, "not tested") + self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1)) + self.addResult(self.currentlyTestedIndex, "untestable", self.failedTune, self.successfullyTune) + elif len(self.failedTune) > 0: + self.changeProgressListStatus(self.currentlyTestedIndex, "failed") + self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune))) + self.addResult(self.currentlyTestedIndex, "failed", self.failedTune, self.successfullyTune) + else: + self.changeProgressListStatus(self.currentlyTestedIndex, "successful") + self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune))) + self.addResult(self.currentlyTestedIndex, "successful", self.failedTune, self.successfullyTune) + + + #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune))) + #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune))) + #if len(self.failedTune) == 0 and len(self.successfullyTune) == 0: + #self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1)) + self.currentlyTestedIndex = self.getNextIndex() + self.addProgressListItem(self.currentlyTestedIndex) + if self.fillTransponderList(): self.run(checkPIDs = True) + else: + self.running = False + self["progress_list"].setIndex(0) + print "results:", self.results + print "resultsstatus:", self.resultsstatus - def keyGo(self): + def go(self): + self.running = True + self["failed_counter"].setText("0") + self["succeeded_counter"].setText("0") + self["untestable_counter"].setText("0") self.currentlyTestedIndex = self.getFirstIndex() + + self.clearProgressList() + self.addProgressListItem(self.currentlyTestedIndex) + if self.fillTransponderList(): self.run(True) def keyCancel(self): self.close() + + def select(self): + print "selectedIndex:", self["progress_list"].getCurrent()[0] + if not self.running: + index = self["progress_list"].getCurrent()[0] + #self.setResultType(ResultParser.TYPE_BYORBPOS) + #self.setResultParameter(index[2]) + self.setResultType(ResultParser.TYPE_BYINDEX) + self.setResultParameter(index) + self.session.open(TextBox, self.getTextualResult()) + + def selectionChanged(self): + print "selection changed" + if len(self.list) > 0 and not self.running: + self["CmdText"].setText(_("Press OK to get further details for %s") % str(self["progress_list"].getCurrent()[1])) + +class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): + skin = """ + + + """ + def __init__(self, session, feid): + Screen.__init__(self, session) + self.feid = feid + + self.list = [] + ConfigListScreen.__init__(self, self.list) + + self["actions"] = ActionMap(["SetupActions"], + { + "cancel": self.keyCancel + }, -2) + + self.createSetup() + + def createSetup(self): + self.testtype = ConfigSelection(choices={"quick": _("Quick")}, default = "quick") + self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype) + self.list.append(self.testtypeEntry) + + self.loopsfailed = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "3") + self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed) + self.list.append(self.loopsfailedEntry) + + self.loopssuccessful = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "1") + self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful) + self.list.append(self.loopssuccessfulEntry) + + self["config"].list = self.list + self["config"].l.setList(self.list) + + def keyOK(self): + print self.testtype.getValue() + testtype = DiseqcTester.TEST_TYPE_QUICK + if self.testtype.getValue() == "quick": + testtype = DiseqcTester.TEST_TYPE_QUICK + elif self.testtype.getValue() == "random": + testtype = DiseqcTester.TEST_TYPE_RANDOM + elif self.testtype.getValue() == "complete": + testtype = DiseqcTester.TEST_TYPE_COMPLETE + self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value)) + + def keyCancel(self): + self.close() class DiseqcTesterNimSelection(NimSelection): skin = """ @@ -215,7 +463,8 @@ class DiseqcTesterNimSelection(NimSelection): NimSelection.__init__(self, session) def setResultClass(self): - self.resultclass = DiseqcTester + #self.resultclass = DiseqcTester + self.resultclass = DiseqcTesterTestTypeSelection def showNim(self, nim): nimConfig = nimmanager.getNimConfig(nim.slot) @@ -224,7 +473,7 @@ class DiseqcTesterNimSelection(NimSelection): return False if nimConfig.configMode.value == "simple": if nimConfig.diseqcMode.value == "positioner": - return False + return True return True return False diff --git a/lib/python/Screens/Makefile.am b/lib/python/Screens/Makefile.am old mode 100755 new mode 100644 index a3cf70bb..cde2d6c3 --- a/lib/python/Screens/Makefile.am +++ b/lib/python/Screens/Makefile.am @@ -13,5 +13,6 @@ install_PYTHON = \ TimerSelection.py PictureInPicture.py TimeDateInput.py \ SubtitleDisplay.py SubservicesQuickzap.py ParentalControlSetup.py NumericalTextInputHelpDialog.py \ SleepTimerEdit.py Ipkg.py RdsDisplay.py Globals.py DefaultWizard.py \ - SessionGlobals.py LocationBox.py WizardLanguage.py TaskView.py Rc.py VirtualKeyBoard.py + SessionGlobals.py LocationBox.py WizardLanguage.py TaskView.py Rc.py VirtualKeyBoard.py \ + TextBox.py diff --git a/lib/python/Screens/TextBox.py b/lib/python/Screens/TextBox.py new file mode 100644 index 00000000..117c5c72 --- /dev/null +++ b/lib/python/Screens/TextBox.py @@ -0,0 +1,26 @@ +from Screens.Screen import Screen + +from Components.ActionMap import ActionMap +from Components.Sources.StaticText import StaticText +from Components.ScrollLabel import ScrollLabel + +class TextBox(Screen): + def __init__(self, session, text = ""): + Screen.__init__(self, session) + + self.text = text + self["text"] = ScrollLabel(self.text) + + self["actions"] = ActionMap(["OkCancelActions", "DirectionActions"], + { + "cancel": self.cancel, + "ok": self.ok, + "up": self["text"].pageUp, + "down": self["text"].pageDown, + }, -1) + + def ok(self): + self.close() + + def cancel(self): + self.close() \ No newline at end of file