From b833353b5285a547eb18c079aa860c9ee2765d6e Mon Sep 17 00:00:00 2001 From: ghost Date: Sat, 13 Dec 2008 01:33:05 +0100 Subject: add possibility to set manual lnb priority (only in advanced sat config) range 0..64 to decrease priorities (this is lower as all auto given priorities) range 14000..14064 this is higher than auto given rotor priorities range 19000..19064 this is higher than each auto given priorities --- lib/python/Screens/Satconfig.py | 1 + 1 file changed, 1 insertion(+) (limited to 'lib/python/Screens/Satconfig.py') diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index 6489f28f..5628926f 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -283,6 +283,7 @@ class NimSetup(Screen, ConfigListScreen): self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) # self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) + self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) def fillAdvancedList(self): self.list = [ ] -- cgit v1.2.3 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 --- configure.ac | 1 + lib/dvb/db.cpp | 73 ++++--- lib/python/Components/Makefile.am | 2 +- lib/python/Components/Sources/Progress.py | 7 + lib/python/Components/TuneTest.py | 189 ++++++++++++++++ .../Plugins/SystemPlugins/DiseqcTester/Makefile.am | 5 + .../Plugins/SystemPlugins/DiseqcTester/__init__.py | 0 .../Plugins/SystemPlugins/DiseqcTester/plugin.py | 239 +++++++++++++++++++++ lib/python/Plugins/SystemPlugins/Makefile.am | 2 +- .../Plugins/SystemPlugins/Satfinder/plugin.py | 27 +-- lib/python/Screens/Satconfig.py | 88 ++++---- 11 files changed, 533 insertions(+), 100 deletions(-) create mode 100644 lib/python/Components/TuneTest.py create mode 100644 lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile.am create mode 100644 lib/python/Plugins/SystemPlugins/DiseqcTester/__init__.py create mode 100644 lib/python/Plugins/SystemPlugins/DiseqcTester/plugin.py (limited to 'lib/python/Screens/Satconfig.py') diff --git a/configure.ac b/configure.ac index 7aebe25f..719baa11 100644 --- a/configure.ac +++ b/configure.ac @@ -120,6 +120,7 @@ lib/python/Plugins/SystemPlugins/SkinSelector/Makefile lib/python/Plugins/SystemPlugins/SatelliteEquipmentControl/Makefile lib/python/Plugins/SystemPlugins/Videomode/Makefile lib/python/Plugins/SystemPlugins/VideoTune/Makefile +lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile lib/python/Plugins/DemoPlugins/Makefile lib/python/Plugins/DemoPlugins/TestPlugin/Makefile lib/python/Plugins/Extensions/Makefile diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp index 44191586..6f30253a 100644 --- a/lib/dvb/db.cpp +++ b/lib/dvb/db.cpp @@ -786,7 +786,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje return Py_False; } int tmp, *dest = NULL, - modulation, system, freq, sr, pol, fec, inv, pilot, rolloff; + modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, tsid, onid; char *end_ptr; const Attribute *at; std::string name; @@ -851,6 +851,9 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje inv = 2; // AUTO default pilot = 2; // AUTO default rolloff = 0; // alpha 0.35 + tsid = -1; + onid = -1; + for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it) { // eDebug("\t\tattr: %s", at->name().c_str()); @@ -865,6 +868,8 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje else if (name == "inversion") dest = &inv; else if (name == "rolloff") dest = &rolloff; else if (name == "pilot") dest = &pilot; + else if (name == "tsid") dest = &tsid; + else if (name == "onid") dest = &onid; if (dest) { tmp = strtol(at->value().c_str(), &end_ptr, 10); @@ -874,7 +879,7 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje } if (freq && sr && pol != -1) { - tuple = PyTuple_New(10); + tuple = PyTuple_New(12); PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq)); PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr)); @@ -885,6 +890,8 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv)); PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff)); PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot)); + PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(tsid)); + PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(onid)); PyList_Append(tplist, tuple); Py_DECREF(tuple); } @@ -1497,7 +1504,7 @@ int eDVBDBQueryBase::compareLessEqual(const eServiceReferenceDVB &a, const eServ { ePtr a_service, b_service; int sortmode = m_query ? m_query->m_sort : eDVBChannelQuery::tName; - + if ((sortmode == eDVBChannelQuery::tName) || (sortmode == eDVBChannelQuery::tProvider)) { if (a.name.empty() && m_db->getService(a, a_service)) @@ -1505,7 +1512,7 @@ int eDVBDBQueryBase::compareLessEqual(const eServiceReferenceDVB &a, const eServ if (b.name.empty() && m_db->getService(b, b_service)) return 1; } - + switch (sortmode) { case eDVBChannelQuery::tName: @@ -1747,10 +1754,10 @@ static int decodeType(const std::string &type) RESULT parseExpression(ePtr &res, std::list::const_iterator begin, std::list::const_iterator end) { std::list::const_iterator end_of_exp; - + if (begin == end) return 0; - + if (*begin == "(") { end_of_exp = begin; @@ -1759,36 +1766,36 @@ RESULT parseExpression(ePtr &res, std::list::cons break; else ++end_of_exp; - + if (end_of_exp == end) { eDebug("expression parse: end of expression while searching for closing brace"); return -1; } - + ++begin; // begin..end_of_exp int r = parseExpression(res, begin, end_of_exp); if (r) return r; ++end_of_exp; - + /* we had only one sub expression */ if (end_of_exp == end) { // eDebug("only one sub expression"); return 0; } - + /* otherwise we have an operator here.. */ - + ePtr r2 = res; res = new eDVBChannelQuery(); res->m_sort = 0; res->m_p1 = r2; res->m_inverse = 0; r2 = 0; - + if (*end_of_exp == "||") res->m_type = eDVBChannelQuery::tOR; else if (*end_of_exp == "&&") @@ -1799,18 +1806,18 @@ RESULT parseExpression(ePtr &res, std::list::cons res = 0; return 1; } - + ++end_of_exp; - + return parseExpression(res->m_p2, end_of_exp, end); } - + // "begin" "end" std::string type, op, val; - + res = new eDVBChannelQuery(); res->m_sort = 0; - + int cnt = 0; while (begin != end) { @@ -1832,23 +1839,23 @@ RESULT parseExpression(ePtr &res, std::list::cons ++begin; ++cnt; } - + if (cnt != 3) { eDebug("malformed query: missing stuff"); res = 0; return 1; } - + res->m_type = decodeType(type); - + if (res->m_type == -1) { eDebug("malformed query: invalid type %s", type.c_str()); res = 0; return 1; } - + if (op == "==") res->m_inverse = 0; else if (op == "!=") @@ -1859,7 +1866,7 @@ RESULT parseExpression(ePtr &res, std::list::cons res = 0; return 1; } - + res->m_string = val; if (res->m_type == eDVBChannelQuery::tChannelID) @@ -1879,7 +1886,7 @@ RESULT parseExpression(ePtr &res, std::list::cons RESULT eDVBChannelQuery::compile(ePtr &res, std::string query) { std::list tokens; - + std::string current_token; std::string bouquet_name; @@ -1891,34 +1898,34 @@ RESULT eDVBChannelQuery::compile(ePtr &res, std::string query) { int c = (i < query.size()) ? query[i] : ' '; ++i; - + int issplit = !!strchr(splitchars, c); int isaln = isalnum(c); int iswhite = c == ' '; int isquot = c == '\"'; - + if (quotemode) { iswhite = issplit = 0; isaln = lastalnum; } - + if (issplit || iswhite || isquot || lastsplit || (lastalnum != isaln)) { if (current_token.size()) tokens.push_back(current_token); current_token.clear(); } - + if (!(iswhite || isquot)) current_token += c; - + if (isquot) quotemode = !quotemode; lastsplit = issplit; lastalnum = isaln; } - + // for (std::list::const_iterator a(tokens.begin()); a != tokens.end(); ++a) // { // printf("%s\n", a->c_str()); @@ -1970,12 +1977,12 @@ RESULT eDVBChannelQuery::compile(ePtr &res, std::string query) res = 0; return -1; } - + // eDebug("sort by %d", sort); - + /* now we recursivly parse that. */ int r = parseExpression(res, tokens.begin(), tokens.end()); - + /* we have an empty (but valid!) expression */ if (!r && !res) { @@ -1983,7 +1990,7 @@ RESULT eDVBChannelQuery::compile(ePtr &res, std::string query) res->m_inverse = 0; res->m_type = eDVBChannelQuery::tAny; } - + if (res) { res->m_sort = sort; diff --git a/lib/python/Components/Makefile.am b/lib/python/Components/Makefile.am index 9c04701b..67cec18d 100644 --- a/lib/python/Components/Makefile.am +++ b/lib/python/Components/Makefile.am @@ -18,4 +18,4 @@ install_PYTHON = \ MultiContent.py MediaPlayer.py TunerInfo.py VideoWindow.py ChoiceList.py \ Element.py Playlist.py ParentalControl.py ParentalControlList.py \ Ipkg.py SelectionList.py Scanner.py SystemInfo.py DreamInfoHandler.py \ - Task.py language_cache.py Console.py ResourceManager.py + Task.py language_cache.py Console.py ResourceManager.py TuneTest.py diff --git a/lib/python/Components/Sources/Progress.py b/lib/python/Components/Sources/Progress.py index b96065b3..d57a6179 100644 --- a/lib/python/Components/Sources/Progress.py +++ b/lib/python/Components/Sources/Progress.py @@ -12,5 +12,12 @@ class Progress(Source): def setValue(self, value): self.__value = value self.changed((self.CHANGED_ALL,)) + + def setRange(self, range = 100): + self.range = range + self.changed((self.CHANGED_ALL,)) + + def getRange(self): + return self.range value = property(getValue, setValue) diff --git a/lib/python/Components/TuneTest.py b/lib/python/Components/TuneTest.py new file mode 100644 index 00000000..7b087b98 --- /dev/null +++ b/lib/python/Components/TuneTest.py @@ -0,0 +1,189 @@ +from enigma import eDVBFrontendParametersSatellite, eDVBFrontendParameters, eDVBResourceManager, eTimer + +class Tuner: + def __init__(self, frontend): + self.frontend = frontend + + # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation) + # 0 1 2 3 4 5 6 7 + def tune(self, transponder): + if self.frontend: + print "tuning to transponder with data", transponder + parm = eDVBFrontendParametersSatellite() + parm.frequency = transponder[0] * 1000 + parm.symbol_rate = transponder[1] * 1000 + parm.polarisation = transponder[2] + 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 + feparm = eDVBFrontendParameters() + feparm.setDVBS(parm) + self.lastparm = feparm + self.frontend.tune(feparm) + + def retune(self): + if self.frontend: + self.frontend.tune(self.lastparm) + +# 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() +# 3) finishedChecking() is called, when the run is finished +class TuneTest: + def __init__(self, feid, stopOnSuccess = False, stopOnError = False): + self.stopOnSuccess = stopOnSuccess + self.stopOnError = stopOnError + self.feid = feid + self.transponderlist = [] + self.currTuned = None + print "TuneTest for feid %d" % self.feid + if not self.openFrontend(): + self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() + self.session.nav.stopService() # try to disable foreground service + if not self.openFrontend(): + if self.session.pipshown: # try to disable pip + self.session.pipshown = False + del self.session.pip + if not self.openFrontend(): + self.frontend = None # in normal case this should not happen + self.tuner = Tuner(self.frontend) + self.timer = eTimer() + self.timer.callback.append(self.updateStatus) + + def updateStatus(self): + dict = {} + self.frontend.getFrontendStatus(dict) + print "status:", dict + + stop = False + + if dict["tuner_state"] == "TUNING": + self.timer.start(100, True) + self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_TUNING, self.currTuned)) + elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_NOOP: + if dict["tuner_state"] == "LOCKED": + print "acquiring TSID/ONID" + # TODO start getting TSID/ONID + self.pidStatus = self.INTERNAL_PID_STATUS_WAITING + else: + self.pidStatus = self.INTERNAL_PID_STATUS_FAILED + elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_WAITING: + print "waiting for pids" + 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: + 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 + elif not self.checkPIDs or (self.checkPids and not pidsFailed): + self.successfullyTune.append([self.currTuned, self.oldTuned]) + if self.stopOnSuccess == True: + 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)) + + if not stop: + self.tune() + if self.tuningtransponder < len(self.transponderlist) and not stop: + self.timer.start(100, True) + print "restart timer" + else: + self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_DONE, self.currTuned)) + print "finishedChecking" + self.finishedChecking() + + def firstTransponder(self): + print "firstTransponder:" + index = 0 + if self.checkPIDs: + print "checkPIDs-loop" + # 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)): + index += 1 + print "FirstTransponder final index:", index + return index + + def nextTransponder(self): + index = self.tuningtransponder + 1 + if self.checkPIDs: + # check for tsid != -1 and onid != -1 + while (index < len(self.transponderlist) and self.transponderlist[index][8] != -1 and self.transponderlist[index][9] != -1): + index += 1 + + return index + + def finishedChecking(self): + print "finished testing" + print "successfull:", self.successfullyTune + print "failed:", self.failedTune + + def openFrontend(self): + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: + self.raw_channel = res_mgr.allocateRawChannel(self.feid) + if self.raw_channel: + self.frontend = self.raw_channel.getFrontend() + if self.frontend: + return True + else: + print "getFrontend failed" + else: + print "getRawChannel failed" + else: + print "getResourceManager instance failed" + return False + + def tune(self): + print "tuning to", self.tuningtransponder + if self.tuningtransponder < len(self.transponderlist): + self.pidStatus = self.INTERNAL_PID_STATUS_NOOP + self.oldTuned = self.currTuned + self.currTuned = self.transponderlist[self.tuningtransponder] + self.tuner.tune(self.transponderlist[self.tuningtransponder]) + + INTERNAL_PID_STATUS_NOOP = 0 + INTERNAL_PID_STATUS_WAITING = 1 + INTERNAL_PID_STATUS_SUCCESSFUL = 2 + INTERNAL_PID_STATUS_FAILED = 3 + + def run(self, checkPIDs = False): + self.checkPIDs = checkPIDs + self.pidStatus = self.INTERNAL_PID_STATUS_NOOP + self.failedTune = [] + self.successfullyTune = [] + self.tuningtransponder = self.firstTransponder() + self.tune() + self.progressCallback((len(self.transponderlist), self.tuningtransponder, self.STATUS_START, self.currTuned)) + self.timer.start(100, True) + + # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, , , , ) + # 0 1 2 3 4 5 6 7 8 9 + def addTransponder(self, transponder): + self.transponderlist.append(transponder) + + def clearTransponder(self): + self.transponderlist = [] + + STATUS_START = 0 + STATUS_TUNING = 1 + STATUS_DONE = 2 + STATUS_NOOP = 3 + # can be overwritten + # progress = (range, value, status, transponder) + def progressCallback(self, progress): + pass \ No newline at end of file diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile.am b/lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile.am new file mode 100644 index 00000000..cd72696a --- /dev/null +++ b/lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile.am @@ -0,0 +1,5 @@ +installdir = $(LIBDIR)/enigma2/python/Plugins/SystemPlugins/DiseqcTester + +install_PYTHON = \ + __init__.py \ + plugin.py \ No newline at end of file diff --git a/lib/python/Plugins/SystemPlugins/DiseqcTester/__init__.py b/lib/python/Plugins/SystemPlugins/DiseqcTester/__init__.py new file mode 100644 index 00000000..e69de29b 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 diff --git a/lib/python/Plugins/SystemPlugins/Makefile.am b/lib/python/Plugins/SystemPlugins/Makefile.am index 36b4bde5..4491eafc 100644 --- a/lib/python/Plugins/SystemPlugins/Makefile.am +++ b/lib/python/Plugins/SystemPlugins/Makefile.am @@ -1 +1 @@ -SUBDIRS = SoftwareUpdate FrontprocessorUpgrade PositionerSetup ConfigurationBackup Satfinder SkinSelector SatelliteEquipmentControl Videomode VideoTune Hotplug DefaultServicesScanner NFIFlash +SUBDIRS = SoftwareUpdate FrontprocessorUpgrade PositionerSetup ConfigurationBackup Satfinder SkinSelector SatelliteEquipmentControl Videomode VideoTune Hotplug DefaultServicesScanner NFIFlash DiseqcTester diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py index d61c1503..72982483 100644 --- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py @@ -12,33 +12,8 @@ from Components.ActionMap import ActionMap from Components.NimManager import nimmanager, getConfigSatlist from Components.MenuList import MenuList from Components.config import ConfigSelection, getConfigListEntry +from Components.TuneTest import Tuner -class Tuner: - def __init__(self, frontend): - self.frontend = frontend - - def tune(self, transponder): - if self.frontend: - print "tuning to transponder with data", transponder - parm = eDVBFrontendParametersSatellite() - parm.frequency = transponder[0] * 1000 - parm.symbol_rate = transponder[1] * 1000 - parm.polarisation = transponder[2] - parm.fec = transponder[3] - parm.inversion = transponder[4] - parm.orbital_position = transponder[5] - parm.system = transponder[6] - parm.modulation = transponder[7] - parm.rolloff = transponder[8] - parm.pilot = transponder[9] - feparm = eDVBFrontendParameters() - feparm.setDVBS(parm, True) - self.lastparm = feparm - self.frontend.tune(feparm) - - def retune(self): - if self.frontend: - self.frontend.tune(self.lastparm) class Satfinder(ScanSetup): def openFrontend(self): diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index 5628926f..320bea84 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -384,18 +384,26 @@ class NimSelection(Screen): self.list = [None] * nimmanager.getSlotCount() self["nimlist"] = List(self.list) self.updateList() + + self.setResultClass() self["actions"] = ActionMap(["OkCancelActions"], { "ok": self.okbuttonClick , "cancel": self.close }, -2) + + def setResultClass(self): + self.resultclass = NimSetup def okbuttonClick(self): nim = self["nimlist"].getCurrent() nim = nim and nim[3] if nim is not None and not nim.empty: - self.session.openWithCallback(self.updateList, NimSetup, nim.slot) + self.session.openWithCallback(self.updateList, self.resultclass, nim.slot) + + def showNim(self, nim): + return True def updateList(self): self.list = [ ] @@ -403,42 +411,44 @@ class NimSelection(Screen): slotid = x.slot nimConfig = nimmanager.getNimConfig(x.slot) text = nimConfig.configMode.value - if x.isCompatible("DVB-S"): - if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends"]: - text = { "loopthrough": _("loopthrough to"), - "equal": _("equal to"), - "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value] - text += " " + _("Tuner") + " " + ["A", "B", "C", "D"][int(nimConfig.connectedTo.value)] - elif nimConfig.configMode.value == "nothing": - text = _("nothing connected") - elif nimConfig.configMode.value == "simple": - if nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]: - text = _("Sats") + ": " - if nimConfig.diseqcA.orbital_position != 3601: - text += nimmanager.getSatName(int(nimConfig.diseqcA.value)) - if nimConfig.diseqcMode.value in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]: - if nimConfig.diseqcB.orbital_position != 3601: - text += "," + nimmanager.getSatName(int(nimConfig.diseqcB.value)) - if nimConfig.diseqcMode.value == "diseqc_a_b_c_d": - if nimConfig.diseqcC.orbital_position != 3601: - text += "," + nimmanager.getSatName(int(nimConfig.diseqcC.value)) - if nimConfig.diseqcD.orbital_position != 3601: - text += "," + nimmanager.getSatName(int(nimConfig.diseqcD.value)) - elif nimConfig.diseqcMode.value == "positioner": - text = _("Positioner") + ":" - if nimConfig.positionerMode.value == "usals": - text += _("USALS") - elif nimConfig.positionerMode.value == "manual": - text += _("manual") - else: - text = _("simple") - elif nimConfig.configMode.value == "advanced": - text = _("advanced") - elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"): - if nimConfig.configMode.value == "nothing": - text = _("nothing connected") - elif nimConfig.configMode.value == "enabled": - text = _("enabled") - - self.list.append((slotid, x.friendly_full_description, text, x)) + if self.showNim(x): + if x.isCompatible("DVB-S"): + if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends"]: + text = { "loopthrough": _("loopthrough to"), + "equal": _("equal to"), + "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value] + text += " " + _("Tuner") + " " + ["A", "B", "C", "D"][int(nimConfig.connectedTo.value)] + elif nimConfig.configMode.value == "nothing": + text = _("nothing connected") + elif nimConfig.configMode.value == "simple": + if nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]: + text = _("Sats") + ": " + if nimConfig.diseqcA.orbital_position != 3601: + text += nimmanager.getSatName(int(nimConfig.diseqcA.value)) + if nimConfig.diseqcMode.value in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]: + if nimConfig.diseqcB.orbital_position != 3601: + text += "," + nimmanager.getSatName(int(nimConfig.diseqcB.value)) + if nimConfig.diseqcMode.value == "diseqc_a_b_c_d": + if nimConfig.diseqcC.orbital_position != 3601: + text += "," + nimmanager.getSatName(int(nimConfig.diseqcC.value)) + if nimConfig.diseqcD.orbital_position != 3601: + text += "," + nimmanager.getSatName(int(nimConfig.diseqcD.value)) + elif nimConfig.diseqcMode.value == "positioner": + text = _("Positioner") + ":" + if nimConfig.positionerMode.value == "usals": + text += _("USALS") + elif nimConfig.positionerMode.value == "manual": + text += _("manual") + else: + text = _("simple") + elif nimConfig.configMode.value == "advanced": + text = _("advanced") + elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"): + if nimConfig.configMode.value == "nothing": + text = _("nothing connected") + elif nimConfig.configMode.value == "enabled": + text = _("enabled") + + self.list.append((slotid, x.friendly_full_description, text, x)) + self["nimlist"].setList(self.list) self["nimlist"].updateList(self.list) \ No newline at end of file -- cgit v1.2.3 From a2f2b1a1523b784e70cf3bd9a74b4cc5cfdbb3de Mon Sep 17 00:00:00 2001 From: ghost Date: Mon, 19 Jan 2009 13:24:54 +0100 Subject: add unicable support (thx to adenin) --- lib/dvb/frontend.cpp | 43 ++++ lib/dvb/frontend.h | 4 + lib/dvb/sec.cpp | 378 +++++++++++++++++++++++------------- lib/dvb/sec.h | 24 +++ lib/python/Components/NimManager.py | 183 ++++++++++++++++- lib/python/Screens/Satconfig.py | 76 ++++++-- 6 files changed, 545 insertions(+), 163 deletions(-) (limited to 'lib/python/Screens/Satconfig.py') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index 284844dc..aae7bbc2 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -587,6 +587,10 @@ int eDVBFrontend::closeFrontend(bool force) if (m_fd >= 0) { eDebugNoSimulate("close frontend %d", m_dvbid); + if (m_data[SATCR] != -1) + { + turnOffSatCR(m_data[SATCR]); + } setTone(iDVBFrontend::toneOff); setVoltage(iDVBFrontend::voltageOff); m_tuneTimer->stop(); @@ -2552,3 +2556,42 @@ arg_error: "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean"); return false; } + +RESULT eDVBFrontend::turnOffSatCR(int satcr) +{ + eSecCommandList sec_sequence; + // check if voltage is disabled + eSecCommand::pair compare; + compare.steps = +9; //nothing to do + compare.voltage = iDVBFrontend::voltageOff; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50 ) ); + + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18_5) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); + + eDVBDiseqcCommand diseqc; + memset(diseqc.data, 0, MAX_DISEQC_LENGTH); + diseqc.len = 5; + diseqc.data[0] = 0xE0; + diseqc.data[1] = 0x10; + diseqc.data[2] = 0x5A; + diseqc.data[3] = satcr << 5; + diseqc.data[4] = 0x00; + + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50+20+14*diseqc.len) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + setSecSequence(sec_sequence); + return 0; +} + +RESULT eDVBFrontend::ScanSatCR() +{ + setFrontend(); + usleep(20000); + setTone(iDVBFrontend::toneOff); + return 0; +} diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h index 6e272aca..81334886 100644 --- a/lib/dvb/frontend.h +++ b/lib/dvb/frontend.h @@ -63,6 +63,7 @@ public: FREQ_OFFSET, // current frequency offset CUR_VOLTAGE, // current voltage CUR_TONE, // current continuous tone + SATCR, // current SatCR NUM_DATA_ENTRIES }; Signal1 m_stateChanged; @@ -142,6 +143,9 @@ public: int closeFrontend(bool force=false); const char *getDescription() const { return m_description; } bool is_simulate() const { return m_simulate; } + + RESULT turnOffSatCR(int satcr); + RESULT ScanSatCR(); }; #endif // SWIG diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index da2439f9..6f64cf56 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -305,10 +305,16 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA lnb_param.m_satellites.find(sat.orbital_position); if ( sit != lnb_param.m_satellites.end()) { + eSecCommandList sec_sequence; + + lnb_param.guard_offset = 0; //HACK + + frontend.setData(eDVBFrontend::SATCR, lnb_param.SatCR_idx); + eDVBSatelliteSwitchParameters &sw_param = sit->second; bool doSetFrontend = true; bool doSetVoltageToneFrontend = true; - bool sendDiSEqC = false; + bool forceStaticMode = true; bool forceChanged = false; bool needDiSEqCReset = false; long band=0, @@ -367,35 +373,54 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if ( sat.frequency > lnb_param.m_lof_threshold ) band |= 1; - - if (band&1) - parm.FREQUENCY = sat.frequency - lnb_param.m_lof_hi; - else - parm.FREQUENCY = sat.frequency - lnb_param.m_lof_lo; - - parm.FREQUENCY = abs(parm.FREQUENCY); - - frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY); - if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)) band |= 2; - if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V - || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical - && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) - voltage = VOLTAGE(13); - else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V - || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) - && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) - voltage = VOLTAGE(18); - if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) - || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) ) - tone = iDVBFrontend::toneOn; - else if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::OFF) - || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && !(band&1) ) ) - tone = iDVBFrontend::toneOff; + int lof = (band&1)?lnb_param.m_lof_hi:lnb_param.m_lof_lo; + + int local=0; - eSecCommandList sec_sequence; + + if(lnb_param.SatCR_idx == -1) + { + // calc Frequency + local = abs(sat.frequency + - ((lof - (lof % 1000)) + ((lof % 1000)>500 ? 1000 : 0)) ); //TODO für den Mist mal ein Macro schreiben + parm.FREQUENCY = (local - (local % 125)) + ((local % 125)>62 ? 125 : 0); + frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY); + + if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V + || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + voltage = VOLTAGE(13); + else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V + || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + voltage = VOLTAGE(18); + if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) + || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) ) + tone = iDVBFrontend::toneOn; + else if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::OFF) + || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && !(band&1) ) ) + tone = iDVBFrontend::toneOff; + } + else + { + unsigned int tmp = abs(sat.frequency + - ((lof - (lof % 1000)) + ((lof % 1000)>500 ? 1000 : 0)) ) + + lnb_param.SatCRvco + - 1400000 + + lnb_param.guard_offset; + parm.FREQUENCY = (lnb_param.SatCRvco - (tmp % 4000))+((tmp%4000)>2000?4000:0)+lnb_param.guard_offset; + lnb_param.UnicableTuningWord = (((tmp / 4000)+((tmp%4000)>2000?1:0)) + | ((band & 1) ? 0x400 : 0) //HighLow + | ((band & 2) ? 0x800 : 0) //VertHor + | ((lnb_param.LNBNum & 1) ? 0 : 0x1000) //Umschaltung LNB1 LNB2 + | (lnb_param.SatCR_idx << 13)); //Adresse des SatCR + eDebug("[prepare] UnicableTuningWord %#04x",lnb_param.UnicableTuningWord); + eDebug("[prepare] guard_offset %d",lnb_param.guard_offset); + frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - ((lnb_param.UnicableTuningWord & 0x3FF) *4000 + 1400000 - lnb_param.SatCRvco + lof)); + } if (diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0) { @@ -668,14 +693,13 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if (di_param.m_seq_repeat && seq_repeat == 0) sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_BEFORE_SEQUENCE_REPEAT]) ); } - sendDiSEqC = true; } eDebugNoSimulate("RotorCmd %02x, lastRotorCmd %02lx", RotorCmd, lastRotorCmd); if ( RotorCmd != -1 && RotorCmd != lastRotorCmd ) { eSecCommand::pair compare; - if (!send_mask) + if (!send_mask && lnb_param.SatCR_idx == -1) { compare.steps = +3; compare.tone = iDVBFrontend::toneOff; @@ -729,112 +753,113 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA diseqc.data[3] = RotorCmd; diseqc.data[4] = 0x00; } - - if ( rotor_param.m_inputpower_parameters.m_use ) - { // use measure rotor input power to detect rotor state - bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed); - eSecCommand::rotor cmd; - eSecCommand::pair compare; - if (turn_fast) - compare.voltage = VOLTAGE(18); + if(lnb_param.SatCR_idx == -1) + { + if ( rotor_param.m_inputpower_parameters.m_use ) + { // use measure rotor input power to detect rotor state + bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed); + eSecCommand::rotor cmd; + eSecCommand::pair compare; + if (turn_fast) + compare.voltage = VOLTAGE(18); + else + compare.voltage = VOLTAGE(13); + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); + // measure idle power values + compare.steps = -2; + if (turn_fast) { + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); + compare.val = 1; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + } + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec before measure + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) ); + compare.val = 0; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); + //////////////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) ); // 2 retries + sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) ); // 2 seconds rotor start timout + // rotor start loop + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // 50msec delay + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); + cmd.direction=1; // check for running rotor + cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta; + cmd.steps=+5; + cmd.okcount=0; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); // check if rotor has started + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout .. we assume now the rotor is already at the correct position + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // goto loop start + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) ); // timeout .. we assume now the rotor is already at the correct position + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) ); // goto loop start + //////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); + if (turn_fast) + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*20) ); // 2 minutes running timeout + // rotor running loop + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // wait 50msec + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); + cmd.direction=0; // check for stopped rotor + cmd.steps=+3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout ? this should never happen + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // running loop start + ///////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); + } else + { // use normal turning mode + doSetVoltageToneFrontend=false; + doSetFrontend=false; + eSecCommand::rotor cmd; + eSecCommand::pair compare; compare.voltage = VOLTAGE(13); - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); -// measure idle power values - compare.steps = -2; - if (turn_fast) { - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); - compare.val = 1; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change + + sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + + compare.voltage = voltage; + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage? + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) ); // wait 2 second before set high voltage + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) ); + + compare.tone = tone; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + + cmd.direction=1; // check for running rotor + cmd.deltaA=0; + cmd.steps=+3; + cmd.okcount=0; + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*4) ); // 2 minutes running timeout + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); // 250msec delay + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) ); // goto loop start + sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +3) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); } - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec before measure - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) ); - compare.val = 0; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); -//////////////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) ); // 2 retries - sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) ); // 2 seconds rotor start timout -// rotor start loop - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // 50msec delay - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); - cmd.direction=1; // check for running rotor - cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta; - cmd.steps=+5; - cmd.okcount=0; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); // check if rotor has started - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout .. we assume now the rotor is already at the correct position - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // goto loop start - sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) ); // timeout .. we assume now the rotor is already at the correct position - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) ); // goto loop start -//////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); - if (turn_fast) - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*20) ); // 2 minutes running timeout -// rotor running loop - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // wait 50msec - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); - cmd.direction=0; // check for stopped rotor - cmd.steps=+3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout ? this should never happen - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // running loop start -///////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); - } - else - { // use normal turning mode - doSetVoltageToneFrontend=false; - doSetFrontend=false; - eSecCommand::rotor cmd; - eSecCommand::pair compare; - compare.voltage = VOLTAGE(13); - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change - - sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); - - compare.voltage = voltage; - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage? - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) ); // wait 2 second before set high voltage - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) ); - - compare.tone = tone; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); - - cmd.direction=1; // check for running rotor - cmd.deltaA=0; - cmd.steps=+3; - cmd.okcount=0; - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*4) ); // 2 minutes running timeout - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); // 250msec delay - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) ); // goto loop start - sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +3) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); } sec_fe->setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd); sec_fe->setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position); - sendDiSEqC = true; } } } @@ -844,14 +869,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA csw = band; } -// if (sendDiSEqC) - sec_sequence.push_front( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) ); - sec_fe->setData(eDVBFrontend::NEW_CSW, csw); sec_fe->setData(eDVBFrontend::NEW_UCSW, ucsw); sec_fe->setData(eDVBFrontend::NEW_TONEBURST, di_param.m_toneburst_param); - if (doSetVoltageToneFrontend) + if ((doSetVoltageToneFrontend) && (lnb_param.SatCR_idx == -1)) { eSecCommand::pair compare; compare.voltage = voltage; @@ -867,16 +889,45 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_SWITCHPARMS) ); + if(lnb_param.SatCR_idx != -1) + { + // check if voltage is disabled + eSecCommand::pair compare; + compare.steps = +3; + compare.voltage = iDVBFrontend::voltageOff; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50 ) ); + + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18_5) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change + + eDVBDiseqcCommand diseqc; + memset(diseqc.data, 0, MAX_DISEQC_LENGTH); + diseqc.len = 5; + diseqc.data[0] = 0xE0; + diseqc.data[1] = 0x10; + diseqc.data[2] = 0x5A; + diseqc.data[3] = lnb_param.UnicableTuningWord >> 8; + diseqc.data[4] = lnb_param.UnicableTuningWord; + + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_LAST_DISEQC_CMD]) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + } + if (doSetFrontend) { sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, tunetimeout) ); sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); } - -// if (sendDiSEqC) - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) ); - + + if (forceStaticMode) + { + sec_sequence.push_front( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) ); + } frontend.setSecSequence(sec_sequence); return 0; @@ -928,6 +979,7 @@ RESULT eDVBSatelliteEquipmentControl::clear() it->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_POS, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_CMD, -1); + it->m_frontend->setData(eDVBFrontend::SATCR, -1); } for (eSmartPtrList::iterator it(m_avail_simulate_frontends.begin()); it != m_avail_simulate_frontends.end(); ++it) @@ -937,6 +989,7 @@ RESULT eDVBSatelliteEquipmentControl::clear() it->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_POS, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_CMD, -1); + it->m_frontend->setData(eDVBFrontend::SATCR, -1); } return 0; @@ -1016,6 +1069,17 @@ RESULT eDVBSatelliteEquipmentControl::setLNBPrio(int prio) return 0; } +RESULT eDVBSatelliteEquipmentControl::setLNBNum(int LNBNum) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBNum(%d)", LNBNum); + if(!((LNBNum >= 1) && (LNBNum <= MAX_LNBNUM))) + return -EPERM; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].LNBNum = LNBNum; + else + return -ENOENT; + return 0; +} /* DiSEqC Specific Parameters */ RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode) @@ -1159,6 +1223,46 @@ RESULT eDVBSatelliteEquipmentControl::setInputpowerDelta(int delta) return 0; } +/* Unicable Specific Parameters */ +RESULT eDVBSatelliteEquipmentControl::setLNBSatCR(int SatCR_idx) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBSatCR(%d)", SatCR_idx); + if(!((SatCR_idx >=-1) && (SatCR_idx < MAX_SATCR))) + return -EPERM; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].SatCR_idx = SatCR_idx; + else + return -ENOENT; + return 0; +} + +RESULT eDVBSatelliteEquipmentControl::setLNBSatCRvco(int SatCRvco) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBSatCRvco(%d)", SatCRvco); + if(!((SatCRvco >= 950*1000) && (SatCRvco <= 2150*1000))) + return -EPERM; + if(!((m_lnbs[m_lnbidx].SatCR_idx >= 0) && (m_lnbs[m_lnbidx].SatCR_idx < MAX_SATCR))) + return -ENOENT; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].SatCRvco = SatCRvco; + else + return -ENOENT; + return 0; +} +RESULT eDVBSatelliteEquipmentControl::getLNBSatCR() +{ + if ( currentLNBValid() ) + return m_lnbs[m_lnbidx].SatCR_idx; + return -ENOENT; +} + +RESULT eDVBSatelliteEquipmentControl::getLNBSatCRvco() +{ + if ( currentLNBValid() ) + return m_lnbs[m_lnbidx].SatCRvco; + return -ENOENT; +} + /* Satellite Specific Parameters */ RESULT eDVBSatelliteEquipmentControl::addSatellite(int orbital_position) { diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h index 2efd0b49..5bff6bf7 100644 --- a/lib/dvb/sec.h +++ b/lib/dvb/sec.h @@ -245,6 +245,23 @@ public: int m_prio; // to override automatic tuner management ... -1 is Auto #endif +public: +#define guard_offset_min -8000 +#define guard_offset_max 8000 +#define guard_offset_step 8000 +#define MAX_SATCR 8 +#define MAX_LNBNUM 32 + + int SatCR_idx; + unsigned int SatCRvco; + unsigned int UnicableTuningWord; + unsigned int UnicableConfigWord; + int old_frequency; + int old_polarisation; + int old_orbital_position; + int guard_offset_old; + int guard_offset; + int LNBNum; }; class eDVBRegisteredFrontend; @@ -307,6 +324,7 @@ public: RESULT setLNBThreshold(int threshold); RESULT setLNBIncreasedVoltage(bool onoff); RESULT setLNBPrio(int prio); + RESULT setLNBNum(int LNBNum); /* DiSEqC Specific Parameters */ RESULT setDiSEqCMode(int diseqcmode); RESULT setToneburst(int toneburst); @@ -324,6 +342,12 @@ public: RESULT setUseInputpower(bool onoff); RESULT setInputpowerDelta(int delta); // delta between running and stopped rotor RESULT setRotorTurningSpeed(int speed); // set turning speed.. +/* Unicable Specific Parameters */ + RESULT setLNBSatCR(int SatCR_idx); + RESULT setLNBSatCRvco(int SatCRvco); +// RESULT checkGuardOffset(const eDVBFrontendParametersSatellite &sat); + RESULT getLNBSatCR(); + RESULT getLNBSatCRvco(); /* Satellite Specific Parameters */ RESULT addSatellite(int orbital_position); RESULT setVoltageMode(int mode); diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py index 168962e9..1fcbda1a 100644 --- a/lib/python/Components/NimManager.py +++ b/lib/python/Components/NimManager.py @@ -51,6 +51,8 @@ class SecConfigure: elif self.linked.has_key(slotid): for slot in self.linked[slotid]: tunermask |= (1 << slot) + sec.setLNBSatCR(-1) + sec.setLNBNum(1) sec.setLNBLOFL(9750000) sec.setLNBLOFH(10600000) sec.setLNBThreshold(11700000) @@ -255,6 +257,9 @@ class SecConfigure: currLnb = config.Nims[slotid].advanced.lnb[x] sec.addLNB() + if x < 33: + sec.setLNBNum(x) + tunermask = 1 << slotid if self.equal.has_key(slotid): for slot in self.equal[slotid]: @@ -263,10 +268,32 @@ class SecConfigure: for slot in self.linked[slotid]: tunermask |= (1 << slot) + if currLnb.lof.value != "unicable": + sec.setLNBSatCR(-1) + if currLnb.lof.value == "universal_lnb": sec.setLNBLOFL(9750000) sec.setLNBLOFH(10600000) sec.setLNBThreshold(11700000) + elif currLnb.lof.value == "unicable": + sec.setLNBLOFL(9750000) + sec.setLNBLOFH(10600000) + sec.setLNBThreshold(11700000) + if currLnb.unicable.value == "unicable_user": + sec.setLNBSatCR(currLnb.satcruser.index) + sec.setLNBSatCRvco(currLnb.satcrvcouser[currLnb.satcruser.index].value*1000) + elif currLnb.unicable.value == "unicable_matrix": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + sec.setLNBSatCR(manufacturer.scr[product_name].index) + sec.setLNBSatCRvco(manufacturer.vco[product_name][manufacturer.scr[product_name].index].value*1000) + elif currLnb.unicable.value == "unicable_lnb": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + sec.setLNBSatCR(manufacturer.scr[product_name].index) + sec.setLNBSatCRvco(manufacturer.vco[product_name][manufacturer.scr[product_name].index].value*1000) elif currLnb.lof.value == "c_band": sec.setLNBLOFL(5150000) sec.setLNBLOFH(5150000) @@ -892,6 +919,129 @@ def InitNimManager(nimmgr): for x in range(len(nimmgr.nim_slots)): config.Nims.append(ConfigSubsection()) + lnb_choices = { + "universal_lnb": _("Universal LNB"), + "unicable": _("Unicable"), + "c_band": _("C-Band"), + "user_defined": _("User defined")} + lnb_choices_default = "universal_lnb" + + unicablelnbproducts = { + "Humax": {"150 SCR":["1210","1420","1680","2040"]}, + "Inverto": {"IDLP-40UNIQD+S":["1680","1420","2040","1210"]}, + "Kathrein": {"UAS481":["1400","1516","1632","1748"]}, + "Kreiling": {"KR1440":["1680","1420","2040","1210"]}, + "Radix": {"Unicable LNB":["1680","1420","2040","1210"]}, + "Wisi": {"OC 05":["1210","1420","1680","2040"]}} + UnicableLnbManufacturers = unicablelnbproducts.keys() + UnicableLnbManufacturers.sort() + + unicablematrixproducts = { + "Ankaro": { + "UCS 51440":["1400","1632","1284","1516"], + "UCS 51820":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 51840":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 52240":["1400","1632"], + "UCS 52420":["1400","1632","1284","1516"], + "UCS 52440":["1400","1632","1284","1516"], + "UCS 91440":["1400","1632","1284","1516"], + "UCS 91820":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 91840":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 92240":["1400","1632"], + "UCS 92420":["1400","1632","1284","1516"], + "UCS 92440":["1400","1632","1284","1516"]}, + "DCT Delta": { + "SUM518":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SUM918":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SUM928":["1284","1400","1516","1632","1748","1864","1980","2096"]}, + "Inverto": { + "IDLP-UST11O-CUO1O-8PP":["1076","1178","1280","1382","1484","1586","1688","1790"]}, + "Kathrein": { + "EXR501":["1400","1516","1632","1748"], + "EXR551":["1400","1516","1632","1748"], + "EXR552":["1400","1516"]}, + "ROTEK": { + "EKL2/1":["1400","1516"], + "EKL2/1E":["0","0","1632","1748"]}, + "Smart": { + "DPA 51":["1284","1400","1516","1632","1748","1864","1980","2096"]}, + "Technisat": { + "TechniRouter 5/1x8 G":["1284","1400","1516","1632","1748","1864","1980","2096"], + "TechniRouter 5/1x8 K":["1284","1400","1516","1632","1748","1864","1980","2096"], + "TechniRouter 5/2x4 G":["1284","1400","1516","1632"], + "TechniRouter 5/2x4 K":["1284","1400","1516","1632"]}, + "Telstar": { + "SCR 5/1x8 G":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SCR 5/1x8 K":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SCR 5/2x4 G":["1284","1400","1516","1632"], + "SCR 5/2x4 K":["1284","1400","1516","1632"]}} + UnicableMatrixManufacturers = unicablematrixproducts.keys() + UnicableMatrixManufacturers.sort() + + unicable_choices = { + "unicable_lnb": _("Unicable LNB"), + "unicable_matrix": _("Unicable Martix"), + "unicable_user": "Unicable "+_("User defined")} + unicable_choices_default = "unicable_lnb" + + unicableLnb = ConfigSubDict() + for y in unicablelnbproducts: + products = unicablelnbproducts[y].keys() + products.sort() + unicableLnb[y] = ConfigSubsection() + unicableLnb[y].product = ConfigSelection(choices = products, default = products[0]) + unicableLnb[y].scr = ConfigSubDict() + unicableLnb[y].vco = ConfigSubDict() + for z in products: + scrlist = [] + vcolist = unicablelnbproducts[y][z] + unicableLnb[y].vco[z] = ConfigSubList() + for cnt in range(1,1+len(vcolist)): + scrlist.append(("%d" %cnt,"SCR %d" %cnt)) + vcofreq = int(vcolist[cnt-1]) + unicableLnb[y].vco[z].append(ConfigInteger(default=vcofreq, limits = (vcofreq, vcofreq))) + unicableLnb[y].scr[z] = ConfigSelection(choices = scrlist, default = scrlist[0][0]) + + unicableMatrix = ConfigSubDict() + + for y in unicablematrixproducts: + products = unicablematrixproducts[y].keys() + products.sort() + unicableMatrix[y] = ConfigSubsection() + unicableMatrix[y].product = ConfigSelection(choices = products, default = products[0]) + unicableMatrix[y].scr = ConfigSubDict() + unicableMatrix[y].vco = ConfigSubDict() + for z in products: + scrlist = [] + vcolist = unicablematrixproducts[y][z] + unicableMatrix[y].vco[z] = ConfigSubList() + for cnt in range(1,1+len(vcolist)): + vcofreq = int(vcolist[cnt-1]) + if vcofreq == 0: + scrlist.append(("%d" %cnt,"SCR %d " %cnt +_("not used"))) + else: + scrlist.append(("%d" %cnt,"SCR %d" %cnt)) + unicableMatrix[y].vco[z].append(ConfigInteger(default=vcofreq, limits = (vcofreq, vcofreq))) + unicableMatrix[y].scr[z] = ConfigSelection(choices = scrlist, default = scrlist[0][0]) + + satcrvcouser = ConfigSubList() + satcrvcouser.append(ConfigInteger(default=1284, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1400, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1516, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1632, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1748, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1864, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1980, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=2096, limits = (0, 9999))) + + prio_list = [ ("-1", _("Auto")) ] + for prio in range(65): + prio_list.append((str(prio), str(prio))) + for prio in range(14000,14065): + prio_list.append((str(prio), str(prio))) + for prio in range(19000,19065): + prio_list.append((str(prio), str(prio))) + for slot in nimmgr.nim_slots: x = slot.slot nim = config.Nims[x] @@ -990,12 +1140,36 @@ def InitNimManager(nimmgr): nim.advanced.lnb = ConfigSubList() nim.advanced.lnb.append(ConfigNothing()) + + for x in range(1, 37): nim.advanced.lnb.append(ConfigSubsection()) - nim.advanced.lnb[x].lof = ConfigSelection(choices={"universal_lnb": _("Universal LNB"), "c_band": _("C-Band"), "user_defined": _("User defined")}, default="universal_lnb") + nim.advanced.lnb[x].lof = ConfigSelection(choices = lnb_choices, default = lnb_choices_default) + nim.advanced.lnb[x].lofl = ConfigInteger(default=9750, limits = (0, 99999)) nim.advanced.lnb[x].lofh = ConfigInteger(default=10600, limits = (0, 99999)) nim.advanced.lnb[x].threshold = ConfigInteger(default=11700, limits = (0, 99999)) + + nim.advanced.lnb[x].unicable = ConfigSelection(choices = unicable_choices, default = unicable_choices_default) + + nim.advanced.lnb[x].unicableLnb = unicableLnb + nim.advanced.lnb[x].unicableLnbManufacturer = ConfigSelection(choices = UnicableLnbManufacturers, default = UnicableLnbManufacturers[0]) + + nim.advanced.lnb[x].unicableMatrix = unicableMatrix + nim.advanced.lnb[x].unicableMatrixManufacturer = ConfigSelection(choices = UnicableMatrixManufacturers, default = UnicableMatrixManufacturers[0]) + + nim.advanced.lnb[x].satcruser = ConfigSelection(choices=[ + ("1", "SatCR 1"), + ("2", "SatCR 2"), + ("3", "SatCR 3"), + ("4", "SatCR 4"), + ("5", "SatCR 5"), + ("6", "SatCR 6"), + ("7", "SatCR 7"), + ("8", "SatCR 8")], + default="1") + nim.advanced.lnb[x].satcrvcouser = satcrvcouser + # nim.advanced.lnb[x].output_12v = ConfigSelection(choices = [("0V", _("0 V")), ("12V", _("12 V"))], default="0V") nim.advanced.lnb[x].increased_voltage = ConfigYesNo(default=False) nim.advanced.lnb[x].toneburst = ConfigSelection(choices = [("none", _("None")), ("A", _("A")), ("B", _("B"))], default = "none") @@ -1028,13 +1202,6 @@ def InitNimManager(nimmgr): nim.advanced.lnb[x].fastTurningBegin = ConfigDateTime(default=mktime(btime.timetuple()), formatstring = _("%H:%M"), increment = 600) etime = datetime(1970, 1, 1, 19, 0); nim.advanced.lnb[x].fastTurningEnd = ConfigDateTime(default=mktime(etime.timetuple()), formatstring = _("%H:%M"), increment = 600) - prio_list = [ ("-1", _("Auto")) ] - for prio in range(65): - prio_list.append((str(prio), str(prio))) - for prio in range(14000,14065): - prio_list.append((str(prio), str(prio))) - for prio in range(19000,19065): - prio_list.append((str(prio), str(prio))) nim.advanced.lnb[x].prio = ConfigSelection(default="-1", choices=prio_list) elif slot.isCompatible("DVB-C"): nim.configMode = ConfigSelection( diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index 320bea84..da6fcc12 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -87,6 +87,10 @@ class NimSetup(Screen, ConfigListScreen): self.uncommittedDiseqcCommand = None self.cableScanType = None self.have_advanced = False + self.advancedUnicable = None + self.advancedType = None + self.advancedManufacturer = None + self.advancedSCR = None if self.nim.isCompatible("DVB-S"): self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode) @@ -190,6 +194,7 @@ class NimSetup(Screen, ConfigListScreen): checkList = (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, \ self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry, \ self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, \ + self.advancedType, self.advancedSCR, self.advancedManufacturer, self.advancedUnicable, \ self.uncommittedDiseqcCommand, self.cableScanType) for x in checkList: if self["config"].getCurrent() == x: @@ -216,19 +221,57 @@ class NimSetup(Screen, ConfigListScreen): if isinstance(currLnb, ConfigNothing): currLnb = None - self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) - self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) - if currLnb and currLnb.diseqcMode.value == "1_2": - if lnbnum < 33: - self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals) - self.list.append(self.advancedUsalsEntry) - if not Sat.usals.value: - self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) - # LNBs self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb) self.list.append(self.advancedLnbsEntry) + if currLnb: + self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) + self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof) + self.list.append(self.advancedLof) + if currLnb.lof.value == "user_defined": + self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) + self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) + self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) +# self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) + + if currLnb.lof.value == "unicable": + self.advancedUnicable = getConfigListEntry("Unicable "+_("Configuration Mode"), currLnb.unicable) + self.list.append(self.advancedUnicable) + if currLnb.unicable.value == "unicable_user": + self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.satcruser) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), currLnb.satcrvcouser[currLnb.satcruser.index])) + self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) + self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) + self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) + elif currLnb.unicable.value == "unicable_matrix": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableMatrixManufacturer) + self.advancedType = getConfigListEntry(_("Type"), manufacturer.product) + self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name]) + self.list.append(self.advancedManufacturer) + self.list.append(self.advancedType) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) + elif currLnb.unicable.value == "unicable_lnb": + manufacturer_name = currLnb.unicableLnbManufacturer.value + manufacturer = currLnb.unicableLnb[manufacturer_name] + product_name = manufacturer.product.value + self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableLnbManufacturer) + self.advancedType = getConfigListEntry(_("Type"), manufacturer.product) + self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name]) + self.list.append(self.advancedManufacturer) + self.list.append(self.advancedType) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) + else: #kein Unicable + self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) + self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) + self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) + if lnbnum < 33: self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode) self.list.append(self.advancedDiseqcMode) @@ -275,15 +318,12 @@ class NimSetup(Screen, ConfigListScreen): if currLnb.powerMeasurement.value: currLnb.powerMeasurement.value = False currLnb.powerMeasurement.save() - self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof) - self.list.append(self.advancedLof) - if currLnb.lof.value == "user_defined": - self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) - self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) - self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) -# self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) - self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) - self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) + self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals) + self.list.append(self.advancedUsalsEntry) + if not Sat.usals.value: + self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) + + def fillAdvancedList(self): self.list = [ ] -- cgit v1.2.3