From 216dbbfd18a36835b8a48d2f2e1e1ce2c65c8f14 Mon Sep 17 00:00:00 2001 From: Stefan Pluecken Date: Mon, 24 Nov 2008 22:42:42 +0100 Subject: catch up DiseqcTest development --- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 239 +++++++++++++++++++++ 1 file changed, 239 insertions(+) create mode 100644 lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py new file mode 100644 index 00000000..57340368 --- /dev/null +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -0,0 +1,239 @@ +from Screens.Satconfig import NimSelection +from Screens.Screen import Screen + +from Plugins.Plugin import PluginDescriptor + +from Components.ActionMap import 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.Progress import Progress +from Components.Sources.StaticText import StaticText + +class DiseqcTester(Screen, TuneTest): + skin = """ + + + + SNRdB + + + + SNR + + + SNR + + + + AGC + + + AGC + + + + BER + + + BER + + + + LOCK + + + + LOCK + Invert + + + + + + + + + + + + """ + + TEST_TYPE_QUICK = 0 + TEST_TYPE_RANDOM = 1 + TEST_TYPE_COMPLETE = 2 + def __init__(self, session, feid, test_type = TEST_TYPE_QUICK): + Screen.__init__(self, session) + self.feid = feid + self.test_type = test_type + + self["actions"] = NumberActionMap(["SetupActions"], + { + "ok": self.keyGo, + "cancel": self.keyCancel, + }, -2) + + TuneTest.__init__(self, feid, stopOnSuccess = True) + 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.indexlist = {} + self.readTransponderList() + + def readTransponderList(self): + for sat in nimmanager.getSatListForNim(self.feid): + for transponder in nimmanager.getTransponders(sat[0]): + #print transponder + mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[5], sat[0], None, None, transponder[10], transponder[11]) + self.analyseTransponder(mytransponder) + + def getIndexForTransponder(self, transponder): + if transponder[0] < 11700: + band = 1 # low + else: + band = 0 # high + + polarisation = transponder[2] + + sat = transponder[5] + + index = (band, polarisation, sat) + return index + + # sort the transponder into self.transponderlist + def analyseTransponder(self, transponder): + index = self.getIndexForTransponder(transponder) + if index not in self.indexlist: + self.indexlist[index] = [] + self.indexlist[index].append(transponder) + #print "self.indexlist:", self.indexlist + + # returns a string for the user representing a human readable output for index + def getTextualIndexRepresentation(self, index): + print "getTextualIndexRepresentation:", index + text = "" + + # TODO better sat representation + text += "%s, " % index[2] + + if index[0] == 1: + text += "Low Band, " + else: + text += "High Band, " + + if index[1] == 0: + text += "H" + else: + text += "V" + return text + + def fillTransponderList(self): + self.clearTransponder() + print "----------- fillTransponderList" + print "index:", self.currentlyTestedIndex + keys = self.indexlist.keys() + if self.getContinueScanning(): + print "index:", self.getTextualIndexRepresentation(self.currentlyTestedIndex) + for transponder in self.indexlist[self.currentlyTestedIndex]: + self.addTransponder(transponder) + print "transponderList:", self.transponderlist + return True + else: + return False + + def progressCallback(self, progress): + if progress[0] != self["sub_progress"].getRange(): + self["sub_progress"].setRange(progress[0]) + self["sub_progress"].setValue(progress[1]) + + # logic for scanning order of transponders + # on go getFirstIndex is called + def getFirstIndex(self): + # TODO use other function to scan more randomly + if self.test_type == self.TEST_TYPE_QUICK: + self.myindex = 0 + keys = self.indexlist.keys() + self["overall_progress"].setRange(len(keys)) + self["overall_progress"].setValue(self.myindex) + return keys[0] + + # after each index is finished, getNextIndex is called to get the next index to scan + def getNextIndex(self): + # TODO use other function to scan more randomly + if self.test_type == self.TEST_TYPE_QUICK: + self.myindex += 1 + keys = self.indexlist.keys() + + self["overall_progress"].setValue(self.myindex) + if self.myindex < len(keys): + return keys[self.myindex] + else: + return None + + # after each index is finished and the next index is returned by getNextIndex + # the algorithm checks, if we should continue scanning + def getContinueScanning(self): + if self.test_type == self.TEST_TYPE_QUICK: + return (self.myindex < len(self.indexlist.keys())) + + def finishedChecking(self): + print "finishedChecking" + TuneTest.finishedChecking(self) + self.currentlyTestedIndex = self.getNextIndex() + if self.fillTransponderList(): + self.run(checkPIDs = True) + + def keyGo(self): + self.currentlyTestedIndex = self.getFirstIndex() + if self.fillTransponderList(): + self.run(True) + + def keyCancel(self): + self.close() + +class DiseqcTesterNimSelection(NimSelection): + skin = """ + + + + {"template": [ + MultiContentEntryText(pos = (10, 5), size = (360, 30), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the nim name, + MultiContentEntryText(pos = (50, 30), size = (320, 30), font = 1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is a description of the nim settings, + ], + "fonts": [gFont("Regular", 20), gFont("Regular", 15)], + "itemHeight": 70 + } + + + """ + + def __init__(self, session, args = None): + NimSelection.__init__(self, session) + + def setResultClass(self): + self.resultclass = DiseqcTester + + def showNim(self, nim): + nimConfig = nimmanager.getNimConfig(nim.slot) + if nim.isCompatible("DVB-S"): + if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends", "nothing"]: + return False + if nimConfig.configMode.value == "simple": + if nimConfig.diseqcMode.value == "positioner": + return False + return True + return False + +def DiseqcTesterMain(session, **kwargs): + session.open(DiseqcTesterNimSelection) + +def autostart(reason, **kwargs): + resourcemanager.addResource("DiseqcTester", DiseqcTesterMain) + +def Plugins(**kwargs): + return [ PluginDescriptor(name="DiSEqC Tester", description=_("Test DiSEqC settings"), where = PluginDescriptor.WHERE_PLUGINMENU, fnc=DiseqcTesterMain), + PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)] \ No newline at end of file -- cgit v1.2.3 From f95be11f0517eac56013b0ccb14825be97fc1540 Mon Sep 17 00:00:00 2001 From: stefan Date: Tue, 16 Dec 2008 10:33:19 +0000 Subject: finish and polish diseqc tester plugin --- data/skin_default.xml | 5 + lib/dvb/db.cpp | 2 +- lib/python/Components/TuneTest.py | 54 +++- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 283 +++++++++++++++++++-- lib/python/Screens/Makefile.am | 3 +- lib/python/Screens/TextBox.py | 26 ++ 6 files changed, 340 insertions(+), 33 deletions(-) mode change 100755 => 100644 data/skin_default.xml mode change 100755 => 100644 lib/python/Screens/Makefile.am create mode 100644 lib/python/Screens/TextBox.py (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') 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 -- cgit v1.2.3 From c58fda6723e55fb47af610a17377279247d2f0b6 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 16 Dec 2008 19:34:25 +0100 Subject: show transponders in diseqc tester results --- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index f997acd1..5779b3b0 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -58,6 +58,27 @@ class ResultParser: for reason in reasons.keys(): text += "%s: %d transponders failed\n" % (reason, len(reasons[reason])) + + for reason in reasons.keys(): + text += "\n" + text += "%s previous planes:\n" % reason + for transponder in reasons[reason]: + if transponder[1] is not None: + text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1])) + else: + text += "No transponder tuned" + text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0])) + text += "\n" + if countsuccessful > 0: + text += "\n" + text += "Successfully tuned transponders' previous planes:\n" + for transponder in successful: + if transponder[1] is not None: + text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1])) + else: + text += "No transponder tuned" + text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0])) + text += "\n" return text def getTextualResult(self): -- cgit v1.2.3 From ab6ca9d52c8431d66c3d785e6810470eafd5e35a Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 16 Dec 2008 20:20:28 +0100 Subject: add diseqc tester test type "random" --- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 24 +++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index 5779b3b0..f55ba766 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -15,6 +15,8 @@ from Components.Sources.StaticText import StaticText from Components.ConfigList import ConfigListScreen from Components.config import getConfigListEntry, ConfigSelection +import random + # always use: # setResultType(type) # setResultParameter(parameter) @@ -312,6 +314,13 @@ class DiseqcTester(Screen, TuneTest, ResultParser): self["overall_progress"].setRange(len(keys)) self["overall_progress"].setValue(self.myindex) return keys[0] + elif self.test_type == self.TEST_TYPE_RANDOM: + self.randomkeys = self.indexlist.keys() + random.shuffle(self.randomkeys) + self.myindex = 0 + self["overall_progress"].setRange(len(self.randomkeys)) + self["overall_progress"].setValue(self.myindex) + return self.randomkeys[0] # after each index is finished, getNextIndex is called to get the next index to scan def getNextIndex(self): @@ -326,11 +335,20 @@ class DiseqcTester(Screen, TuneTest, ResultParser): return keys[self.myindex] else: return None - + elif self.test_type == self.TEST_TYPE_RANDOM: + self.myindex += 1 + keys = self.randomkeys + + self["overall_progress"].setValue(self.myindex) + if self.myindex < len(keys): + return keys[self.myindex] + else: + return None + # after each index is finished and the next index is returned by getNextIndex # the algorithm checks, if we should continue scanning def getContinueScanning(self): - if self.test_type == self.TEST_TYPE_QUICK: + if self.test_type == self.TEST_TYPE_QUICK or self.test_type == self.TEST_TYPE_RANDOM: return (self.myindex < len(self.indexlist.keys())) def addResult(self, index, status, failedTune, successfullyTune): @@ -435,7 +453,7 @@ class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): self.createSetup() def createSetup(self): - self.testtype = ConfigSelection(choices={"quick": _("Quick")}, default = "quick") + self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random")}, default = "quick") self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype) self.list.append(self.testtypeEntry) -- cgit v1.2.3 From b10857da7a1853f816adcb2c0464e9c759190c26 Mon Sep 17 00:00:00 2001 From: Stefan Date: Tue, 16 Dec 2008 20:22:17 +0100 Subject: add newlines at end of file --- lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py | 2 +- lib/python/Screens/TextBox.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index f55ba766..2c8c5c38 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -524,4 +524,4 @@ def autostart(reason, **kwargs): def Plugins(**kwargs): return [ PluginDescriptor(name="DiSEqC Tester", description=_("Test DiSEqC settings"), where = PluginDescriptor.WHERE_PLUGINMENU, fnc=DiseqcTesterMain), - PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)] \ No newline at end of file + PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)] diff --git a/lib/python/Screens/TextBox.py b/lib/python/Screens/TextBox.py index 117c5c72..44b8a3cf 100644 --- a/lib/python/Screens/TextBox.py +++ b/lib/python/Screens/TextBox.py @@ -23,4 +23,4 @@ class TextBox(Screen): self.close() def cancel(self): - self.close() \ No newline at end of file + self.close() -- cgit v1.2.3 From e6b7c85963535ecfb113300330158d14f7fea430 Mon Sep 17 00:00:00 2001 From: Stefan Pluecken Date: Thu, 18 Dec 2008 14:32:36 +0100 Subject: allow writing of diseqc tester results to /media/hdd/diseqctester.log --- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 44 ++++++++++++++++++++-- 1 file changed, 40 insertions(+), 4 deletions(-) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index 2c8c5c38..1213de2b 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -1,6 +1,7 @@ from Screens.Satconfig import NimSelection from Screens.Screen import Screen from Screens.TextBox import TextBox +from Screens.MessageBox import MessageBox from Plugins.Plugin import PluginDescriptor @@ -13,7 +14,8 @@ 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 +from Components.config import getConfigListEntry, ConfigSelection, ConfigYesNo +from Components.Harddisk import harddiskmanager import random @@ -37,7 +39,7 @@ class ResultParser: elif self.type == self.TYPE_BYINDEX: self.index = parameter - def getTextualResultForIndex(self, index): + def getTextualResultForIndex(self, index, logfulltransponders = False): text = "" text += "%s:\n" % self.getTextualIndexRepresentation(index) @@ -71,6 +73,11 @@ class ResultParser: text += "No transponder tuned" text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0])) text += "\n" + if logfulltransponders: + text += str(transponder[1]) + text += " ==> " + text += str(transponder[0]) + text += "\n" if countsuccessful > 0: text += "\n" text += "Successfully tuned transponders' previous planes:\n" @@ -92,6 +99,22 @@ class ResultParser: if index[2] == self.orbpos: text += self.getTextualResultForIndex(index) text += "\n-----------------------------------------------------\n" + elif self.type == self.TYPE_ALL: + orderedResults = {} + for index in self.results.keys(): + orbpos = index[2] + orderedResults[orbpos] = orderedResults.get(orbpos, []) + orderedResults[orbpos].append(index) + ordered_orbpos = orderedResults.keys() + ordered_orbpos.sort() + for orbpos in ordered_orbpos: + text += "\n*****************************************\n" + text += "Orbital position %s:" % str(orbpos) + text += "\n*****************************************\n" + for index in orderedResults[orbpos]: + text += self.getTextualResultForIndex(index, logfulltransponders = True) + text += "\n-----------------------------------------------------\n" + return text @@ -166,12 +189,13 @@ class DiseqcTester(Screen, TuneTest, ResultParser): TEST_TYPE_QUICK = 0 TEST_TYPE_RANDOM = 1 TEST_TYPE_COMPLETE = 2 - def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1): + def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1, log = False): Screen.__init__(self, session) self.feid = feid self.test_type = test_type self.loopsfailed = loopsfailed self.loopssuccessful = loopssuccessful + self.log = log self["actions"] = NumberActionMap(["SetupActions"], { @@ -401,6 +425,12 @@ class DiseqcTester(Screen, TuneTest, ResultParser): self["progress_list"].setIndex(0) print "results:", self.results print "resultsstatus:", self.resultsstatus + if self.log: + file = open("/media/hdd/diseqctester.log", "w") + self.setResultType(ResultParser.TYPE_ALL) + file.write(self.getTextualResult()) + file.close() + self.session.open(MessageBox, text=_("The results have been written to %s.") % "/media/hdd/diseqctester.log", type = MessageBox.TYPE_INFO) def go(self): self.running = True @@ -426,6 +456,7 @@ class DiseqcTester(Screen, TuneTest, ResultParser): #self.setResultParameter(index[2]) self.setResultType(ResultParser.TYPE_BYINDEX) self.setResultParameter(index) + #self.setResultType(ResultParser.TYPE_ALL) self.session.open(TextBox, self.getTextualResult()) def selectionChanged(self): @@ -465,6 +496,11 @@ class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) + self.log = ConfigYesNo(False) + if harddiskmanager.HDDCount() > 0: + self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log) + self.list.append(self.logEntry) + self["config"].list = self.list self["config"].l.setList(self.list) @@ -477,7 +513,7 @@ class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): 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)) + self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value), log = self.log.value) def keyCancel(self): self.close() -- cgit v1.2.3 From 28d687070e681346837eed434fc4e68ca2f323db Mon Sep 17 00:00:00 2001 From: Stefan Pluecken Date: Thu, 18 Dec 2008 18:06:37 +0100 Subject: count indexes instead of transponders for failed/successfully tuned indexes --- lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index 1213de2b..f22bf00a 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -402,11 +402,13 @@ class DiseqcTester(Screen, TuneTest, ResultParser): 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["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune))) + self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + 1)) 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["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune))) + self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + 1)) self.addResult(self.currentlyTestedIndex, "successful", self.failedTune, self.successfullyTune) -- cgit v1.2.3 From 69ef41671f62de96cb607b971fe6c82c61703a28 Mon Sep 17 00:00:00 2001 From: Stefan Pluecken Date: Thu, 18 Dec 2008 19:10:18 +0100 Subject: add diseqc tester test type complete (tune FROM every possible index TO every possible index) (can take some time until eternity for a high number of orbital positions) --- .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 93 ++++++++++++++++++++-- 1 file changed, 85 insertions(+), 8 deletions(-) (limited to 'lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py') diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py index f22bf00a..07861954 100644 --- a/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py @@ -345,7 +345,39 @@ class DiseqcTester(Screen, TuneTest, ResultParser): self["overall_progress"].setRange(len(self.randomkeys)) self["overall_progress"].setValue(self.myindex) return self.randomkeys[0] - + elif self.test_type == self.TEST_TYPE_COMPLETE: + keys = self.indexlist.keys() + print "keys:", keys + successorindex = {} + for index in keys: + successorindex[index] = [] + for otherindex in keys: + if otherindex != index: + successorindex[index].append(otherindex) + random.shuffle(successorindex[index]) + self.keylist = [] + stop = False + currindex = None + while not stop: + if currindex is None or len(successorindex[currindex]) == 0: + oldindex = currindex + for index in successorindex.keys(): + if len(successorindex[index]) > 0: + currindex = index + self.keylist.append(currindex) + break + if currindex == oldindex: + stop = True + else: + currindex = successorindex[currindex].pop() + self.keylist.append(currindex) + print "self.keylist:", self.keylist + self.myindex = 0 + self["overall_progress"].setRange(len(self.keylist)) + self["overall_progress"].setValue(self.myindex) + return self.keylist[0] + + # after each index is finished, getNextIndex is called to get the next index to scan def getNextIndex(self): # TODO use other function to scan more randomly @@ -363,6 +395,15 @@ class DiseqcTester(Screen, TuneTest, ResultParser): self.myindex += 1 keys = self.randomkeys + self["overall_progress"].setValue(self.myindex) + if self.myindex < len(keys): + return keys[self.myindex] + else: + return None + elif self.test_type == self.TEST_TYPE_COMPLETE: + self.myindex += 1 + keys = self.keylist + self["overall_progress"].setValue(self.myindex) if self.myindex < len(keys): return keys[self.myindex] @@ -374,14 +415,50 @@ class DiseqcTester(Screen, TuneTest, ResultParser): def getContinueScanning(self): if self.test_type == self.TEST_TYPE_QUICK or self.test_type == self.TEST_TYPE_RANDOM: return (self.myindex < len(self.indexlist.keys())) + elif self.test_type == self.TEST_TYPE_COMPLETE: + return (self.myindex < len(self.keylist)) def addResult(self, index, status, failedTune, successfullyTune): - self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None}) + self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None, "internalstatus": None}) self.resultsstatus[status] = self.resultsstatus.get(status, []) - - self.results[index]["status"] = status - self.results[index]["failed"] = failedTune - self.results[index]["successful"] = successfullyTune + + oldstatus = self.results[index]["internalstatus"] + if oldstatus is None: + self.results[index]["status"] = status + elif oldstatus == "successful": + if status == "failed": + self.results[index]["status"] = "with_errors" + elif status == "successful": + self.results[index]["status"] = oldstatus + elif status == "with_errors": + self.results[index]["status"] = "with_errors" + elif status == "not_tested": + self.results[index]["status"] = oldstatus + elif oldstatus == "failed": + if status == "failed": + self.results[index]["status"] = oldstatus + elif status == "successful": + self.results[index]["status"] = "with_errors" + elif status == "with_errors": + self.results[index]["status"] = "with_errors" + elif status == "not_tested": + self.results[index]["status"] = oldstatus + elif oldstatus == "with_errors": + if status == "failed": + self.results[index]["status"] = oldstatus + elif status == "successful": + self.results[index]["status"] = oldstatus + elif status == "with_errors": + self.results[index]["status"] = oldstatus + elif status == "not_tested": + self.results[index]["status"] = oldstatus + elif oldstatus == "not_tested": + self.results[index]["status"] = status + + if self.results[index]["status"] != "working": + self.results[index]["internalstatus"] = self.results[index]["status"] + self.results[index]["failed"] = failedTune + self.results[index]["failed"] + self.results[index]["successful"] = successfullyTune + self.results[index]["successful"] self.resultsstatus[status].append(index) @@ -390,7 +467,7 @@ class DiseqcTester(Screen, TuneTest, ResultParser): TuneTest.finishedChecking(self) if not self.results.has_key(self.currentlyTestedIndex): - self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None} + self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None, "internalstatus": None} if len(self.failedTune) > 0 and len(self.successfullyTune) > 0: self.changeProgressListStatus(self.currentlyTestedIndex, "with errors") @@ -486,7 +563,7 @@ class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): self.createSetup() def createSetup(self): - self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random")}, default = "quick") + self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default = "quick") self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype) self.list.append(self.testtypeEntry) -- cgit v1.2.3